refactor: move brother_node development artifact to dev/test-nodes subdirectory

Development Artifact Cleanup:
✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location
- dev/test-nodes/brother_node/: Moved from root directory for better organization
- Contains development configuration, test logs, and test chain data
- No impact on production systems - purely development/testing artifact

✅ DEVELOPMENT ARTIFACTS IDENTIFIED:
- Chain ID: aitbc-brother-chain (test/development chain)
- Ports: 8010 (P2P) and 8011 (RPC) - different from production
- Environment: .env file with test configuration
- Logs: rpc.log and node.log from development testing session (March 15, 2026)

✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory
- brother_node/ moved to dev/test-nodes/brother_node/
- Root directory now contains only production-ready components
- Development artifacts properly organized in dev/ subdirectory

DIRECTORY STRUCTURE IMPROVEMENT:
📁 dev/test-nodes/: Development and testing node configurations
🏗️ Root Directory: Clean production structure with only essential components
🧪 Development Isolation: Test environments separated from production

BENEFITS:
✅ Clean Production Directory: No development artifacts in root
✅ Better Organization: Development nodes grouped in dev/ subdirectory
✅ Clear Separation: Production vs development environments clearly distinguished
✅ Maintainability: Easier to identify and manage development components

RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.

dev/env/node_modules/ethers/lib.commonjs/providers/provider-fallback.d.ts

@@ -0,0 +1,115 @@
+import { AbstractProvider } from "./abstract-provider.js";
+import { Network } from "./network.js";
+import type { PerformActionRequest } from "./abstract-provider.js";
+import type { Networkish } from "./network.js";
+/**
+ *  A configuration entry for how to use a [[Provider]].
+ */
+export interface FallbackProviderConfig {
+    /**
+     *  The provider.
+     */
+    provider: AbstractProvider;
+    /**
+     *  The amount of time to wait before kicking off the next provider.
+     *
+     *  Any providers that have not responded can still respond and be
+     *  counted, but this ensures new providers start.
+     */
+    stallTimeout?: number;
+    /**
+     *  The priority. Lower priority providers are dispatched first.
+     */
+    priority?: number;
+    /**
+     *  The amount of weight a provider is given against the quorum.
+     */
+    weight?: number;
+}
+/**
+ *  The statistics and state maintained for a [[Provider]].
+ */
+export interface FallbackProviderState extends Required<FallbackProviderConfig> {
+    /**
+     *  The most recent blockNumber this provider has reported (-2 if none).
+     */
+    blockNumber: number;
+    /**
+     *  The number of total requests ever sent to this provider.
+     */
+    requests: number;
+    /**
+     *  The number of responses that errored.
+     */
+    errorResponses: number;
+    /**
+     *  The number of responses that occured after the result resolved.
+     */
+    lateResponses: number;
+    /**
+     *  How many times syncing was required to catch up the expected block.
+     */
+    outOfSync: number;
+    /**
+     *  The number of requests which reported unsupported operation.
+     */
+    unsupportedEvents: number;
+    /**
+     *  A rolling average (5% current duration) for response time.
+     */
+    rollingDuration: number;
+    /**
+     *  The ratio of quorum-agreed results to total.
+     */
+    score: number;
+}
+/**
+ *  Additional options to configure a [[FallbackProvider]].
+ */
+export type FallbackProviderOptions = {
+    quorum?: number;
+    eventQuorum?: number;
+    eventWorkers?: number;
+    cacheTimeout?: number;
+    pollingInterval?: number;
+};
+/**
+ *  A **FallbackProvider** manages several [[Providers]] providing
+ *  resilience by switching between slow or misbehaving nodes, security
+ *  by requiring multiple backends to aggree and performance by allowing
+ *  faster backends to respond earlier.
+ *
+ */
+export declare class FallbackProvider extends AbstractProvider {
+    #private;
+    /**
+     *  The number of backends that must agree on a value before it is
+     *  accpeted.
+     */
+    readonly quorum: number;
+    /**
+     *  @_ignore:
+     */
+    readonly eventQuorum: number;
+    /**
+     *  @_ignore:
+     */
+    readonly eventWorkers: number;
+    /**
+     *  Creates a new **FallbackProvider** with %%providers%% connected to
+     *  %%network%%.
+     *
+     *  If a [[Provider]] is included in %%providers%%, defaults are used
+     *  for the configuration.
+     */
+    constructor(providers: Array<AbstractProvider | FallbackProviderConfig>, network?: Networkish, options?: FallbackProviderOptions);
+    get providerConfigs(): Array<FallbackProviderState>;
+    _detectNetwork(): Promise<Network>;
+    /**
+     *  Transforms a %%req%% into the correct method call on %%provider%%.
+     */
+    _translatePerform(provider: AbstractProvider, req: PerformActionRequest): Promise<any>;
+    _perform<T = any>(req: PerformActionRequest): Promise<T>;
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=provider-fallback.d.ts.map