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/micro-eth-signer/esm/index.d.ts

@@ -0,0 +1,108 @@
+import { addr } from './address.ts';
+import { type AuthorizationItem, type AuthorizationRequest, type TxCoder, type TxType } from './tx.ts';
+import { weieth, weigwei } from './utils.ts';
+export { addr, weieth, weigwei };
+/**
+ * EIP-7702 Authorizations
+ */
+export declare const authorization: {
+    _getHash(req: AuthorizationRequest): Uint8Array;
+    sign(req: AuthorizationRequest, privateKey: string): AuthorizationItem;
+    getAuthority(item: AuthorizationItem): string;
+};
+declare const TX_DEFAULTS: {
+    readonly accessList: readonly [];
+    readonly authorizationList: readonly [];
+    readonly chainId: bigint;
+    readonly data: "";
+    readonly gasLimit: bigint;
+    readonly maxPriorityFeePerGas: bigint;
+    readonly type: "eip1559";
+};
+type DefaultField = keyof typeof TX_DEFAULTS;
+type DefaultType = (typeof TX_DEFAULTS)['type'];
+type DefaultsOptional<T> = {
+    [P in keyof T as P extends DefaultField ? P : never]?: T[P];
+} & {
+    [P in keyof T as P extends DefaultField ? never : P]: T[P];
+};
+type HumanInputInner<T extends TxType> = DefaultsOptional<{
+    type: T;
+} & TxCoder<T>>;
+type HumanInputInnerDefault = DefaultsOptional<TxCoder<DefaultType>>;
+type Required<T> = T extends undefined ? never : T;
+type HumanInput<T extends TxType | undefined> = T extends undefined ? HumanInputInnerDefault : HumanInputInner<Required<T>>;
+export declare class Transaction<T extends TxType> {
+    readonly type: T;
+    readonly raw: TxCoder<T>;
+    readonly isSigned: boolean;
+    constructor(type: T, raw: TxCoder<T>, strict?: boolean, allowSignatureFields?: boolean);
+    static prepare<T extends {
+        type: undefined;
+    }>(data: T & HumanInputInnerDefault, strict?: boolean): Transaction<(typeof TX_DEFAULTS)['type']>;
+    static prepare<TT extends TxType, T extends {
+        type: TT;
+    } & HumanInput<TT>>(data: HumanInput<TT>, strict?: boolean): Transaction<T['type']>;
+    /**
+     * Creates transaction which sends whole account balance. Does two things:
+     * 1. `amount = accountBalance - maxFeePerGas * gasLimit`
+     * 2. `maxPriorityFeePerGas = maxFeePerGas`
+     *
+     * Every eth block sets a fee for all its transactions, called base fee.
+     * maxFeePerGas indicates how much gas user is able to spend in the worst case.
+     * If the block's base fee is 5 gwei, while user is able to spend 10 gwei in maxFeePerGas,
+     * the transaction would only consume 5 gwei. That means, base fee is unknown
+     * before the transaction is included in a block.
+     *
+     * By setting priorityFee to maxFee, we make the process deterministic:
+     * `maxFee = 10, maxPriority = 10, baseFee = 5` would always spend 10 gwei.
+     * In the end, the balance would become 0.
+     *
+     * WARNING: using the method would decrease privacy of a transfer, because
+     * payments for services have specific amounts, and not *the whole amount*.
+     * @param accountBalance - account balance in wei
+     * @param burnRemaining - send unspent fee to miners. When false, some "small amount" would remain
+     * @returns new transaction with adjusted amounts
+     */
+    setWholeAmount(accountBalance: bigint, burnRemaining?: boolean): Transaction<T>;
+    static fromRawBytes(bytes: Uint8Array, strict?: boolean): Transaction<'legacy' | 'eip2930' | 'eip1559' | 'eip4844' | 'eip7702'>;
+    static fromHex(hex: string, strict?: boolean): Transaction<'eip1559' | 'legacy' | 'eip2930' | 'eip4844' | 'eip7702'>;
+    private assertIsSigned;
+    /**
+     * Converts transaction to RLP.
+     * @param includeSignature whether to include signature
+     */
+    toRawBytes(includeSignature?: boolean): Uint8Array;
+    /**
+     * Converts transaction to hex.
+     * @param includeSignature whether to include signature
+     */
+    toHex(includeSignature?: boolean): string;
+    /** Calculates keccak-256 hash of signed transaction. Used in block explorers. */
+    get hash(): string;
+    /** Returns sender's address. */
+    get sender(): string;
+    /**
+     * For legacy transactions, but can be used with libraries when yParity presented as v.
+     */
+    get v(): bigint | undefined;
+    private calcHash;
+    /** Calculates MAXIMUM fee in wei that could be spent. */
+    get fee(): bigint;
+    clone(): Transaction<T>;
+    verifySignature(): boolean;
+    removeSignature(): Transaction<T>;
+    /**
+     * Signs transaction with a private key.
+     * @param privateKey key in hex or Uint8Array format
+     * @param opts extraEntropy will increase security of sig by mixing rfc6979 randomness
+     * @returns new "same" transaction, but signed
+     */
+    signBy(privateKey: string | Uint8Array, extraEntropy?: boolean | Uint8Array): Transaction<T>;
+    /** Calculates public key and address from signed transaction's signature. */
+    recoverSender(): {
+        publicKey: string;
+        address: string;
+    };
+}
+//# sourceMappingURL=index.d.ts.map