@temporalabs/treasury 0.1.1 → 0.1.3

package/dist/client.d.ts

@@ -78,240 +78,17 @@ export declare const chains: {
         formatters: {
             readonly block: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => {
-                    baseFeePerGas: bigint | null;
-                    blobGasUsed: bigint;
-                    difficulty: bigint;
-                    excessBlobGas: bigint;
-                    extraData: import("viem").Hex;
-                    gasLimit: bigint;
-                    gasUsed: bigint;
-                    hash: `0x${string}` | null;
-                    logsBloom: `0x${string}` | null;
-                    miner: import("viem").Address;
-                    mixHash: import("viem").Hash;
-                    nonce: `0x${string}` | null;
-                    number: bigint | null;
-                    parentBeaconBlockRoot?: `0x${string}` | undefined;
-                    parentHash: import("viem").Hash;
-                    receiptsRoot: import("viem").Hex;
-                    sealFields: import("viem").Hex[];
-                    sha3Uncles: import("viem").Hash;
-                    size: bigint;
-                    stateRoot: import("viem").Hash;
-                    timestamp: bigint;
-                    totalDifficulty: bigint | null;
-                    transactions: `0x${string}`[] | import("viem/chains").OpStackTransaction<boolean>[];
-                    transactionsRoot: import("viem").Hash;
-                    uncles: import("viem").Hash[];
-                    withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
-                    withdrawalsRoot?: `0x${string}` | undefined;
-                } & {};
+                format: (args: import("viem/chains").OpStackRpcBlock, action?: string | undefined) => import("viem/chains").OpStackBlock;
                 type: "block";
             };
             readonly transaction: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => ({
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    nonce: number;
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    to: import("viem").Address | null;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    v: bigint;
-                    value: bigint;
-                    yParity: number;
-                    gasPrice?: undefined | undefined;
-                    maxFeePerBlobGas?: undefined | undefined;
-                    maxFeePerGas: bigint;
-                    maxPriorityFeePerGas: bigint;
-                    isSystemTx?: boolean;
-                    mint?: bigint | undefined | undefined;
-                    sourceHash: import("viem").Hex;
-                    type: "deposit";
-                } | {
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    v: bigint;
-                    to: import("viem").Address | null;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    nonce: number;
-                    value: bigint;
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    accessList?: undefined | undefined;
-                    authorizationList?: undefined | undefined;
-                    blobVersionedHashes?: undefined | undefined;
-                    chainId?: number | undefined;
-                    yParity?: undefined | undefined;
-                    type: "legacy";
-                    gasPrice: bigint;
-                    maxFeePerBlobGas?: undefined | undefined;
-                    maxFeePerGas?: undefined | undefined;
-                    maxPriorityFeePerGas?: undefined | undefined;
-                    isSystemTx?: undefined | undefined;
-                    mint?: undefined | undefined;
-                    sourceHash?: undefined | undefined;
-                } | {
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    nonce: number;
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    to: import("viem").Address | null;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    v: bigint;
-                    value: bigint;
-                    yParity: number;
-                    accessList: import("viem").AccessList;
-                    authorizationList?: undefined | undefined;
-                    blobVersionedHashes?: undefined | undefined;
-                    chainId: number;
-                    type: "eip2930";
-                    gasPrice: bigint;
-                    maxFeePerBlobGas?: undefined | undefined;
-                    maxFeePerGas?: undefined | undefined;
-                    maxPriorityFeePerGas?: undefined | undefined;
-                    isSystemTx?: undefined | undefined;
-                    mint?: undefined | undefined;
-                    sourceHash?: undefined | undefined;
-                } | {
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    nonce: number;
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    to: import("viem").Address | null;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    v: bigint;
-                    value: bigint;
-                    yParity: number;
-                    accessList: import("viem").AccessList;
-                    authorizationList?: undefined | undefined;
-                    blobVersionedHashes?: undefined | undefined;
-                    chainId: number;
-                    type: "eip1559";
-                    gasPrice?: undefined | undefined;
-                    maxFeePerBlobGas?: undefined | undefined;
-                    maxFeePerGas: bigint;
-                    maxPriorityFeePerGas: bigint;
-                    isSystemTx?: undefined | undefined;
-                    mint?: undefined | undefined;
-                    sourceHash?: undefined | undefined;
-                } | {
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    nonce: number;
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    to: import("viem").Address | null;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    v: bigint;
-                    value: bigint;
-                    yParity: number;
-                    accessList: import("viem").AccessList;
-                    authorizationList?: undefined | undefined;
-                    blobVersionedHashes: readonly import("viem").Hex[];
-                    chainId: number;
-                    type: "eip4844";
-                    gasPrice?: undefined | undefined;
-                    maxFeePerBlobGas: bigint;
-                    maxFeePerGas: bigint;
-                    maxPriorityFeePerGas: bigint;
-                    isSystemTx?: undefined | undefined;
-                    mint?: undefined | undefined;
-                    sourceHash?: undefined | undefined;
-                } | {
-                    blockHash: `0x${string}` | null;
-                    blockNumber: bigint | null;
-                    blockTimestamp?: bigint | undefined;
-                    from: import("viem").Address;
-                    gas: bigint;
-                    hash: import("viem").Hash;
-                    input: import("viem").Hex;
-                    nonce: number;
-                    r: import("viem").Hex;
-                    s: import("viem").Hex;
-                    to: import("viem").Address | null;
-                    transactionIndex: number | null;
-                    typeHex: import("viem").Hex | null;
-                    v: bigint;
-                    value: bigint;
-                    yParity: number;
-                    accessList: import("viem").AccessList;
-                    authorizationList: import("viem").SignedAuthorizationList;
-                    blobVersionedHashes?: undefined | undefined;
-                    chainId: number;
-                    type: "eip7702";
-                    gasPrice?: undefined | undefined;
-                    maxFeePerBlobGas?: undefined | undefined;
-                    maxFeePerGas: bigint;
-                    maxPriorityFeePerGas: bigint;
-                    isSystemTx?: undefined | undefined;
-                    mint?: undefined | undefined;
-                    sourceHash?: undefined | undefined;
-                }) & {};
+                format: (args: import("viem/chains").OpStackRpcTransaction, action?: string | undefined) => import("viem/chains").OpStackTransaction;
                 type: "transaction";
             };
             readonly transactionReceipt: {
                 exclude: [] | undefined;
-                format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => {
-                    blobGasPrice?: bigint | undefined;
-                    blobGasUsed?: bigint | undefined;
-                    blockHash: import("viem").Hash;
-                    blockNumber: bigint;
-                    blockTimestamp?: bigint | undefined;
-                    contractAddress: import("viem").Address | null | undefined;
-                    cumulativeGasUsed: bigint;
-                    effectiveGasPrice: bigint;
-                    from: import("viem").Address;
-                    gasUsed: bigint;
-                    logs: import("viem").Log<bigint, number, false>[];
-                    logsBloom: import("viem").Hex;
-                    root?: `0x${string}` | undefined;
-                    status: "success" | "reverted";
-                    to: import("viem").Address | null;
-                    transactionHash: import("viem").Hash;
-                    transactionIndex: number;
-                    type: import("viem").TransactionType;
-                    depositNonce?: bigint | undefined | undefined;
-                    depositReceiptVersion?: number | undefined | undefined;
-                    l1GasPrice: bigint | null;
-                    l1GasUsed: bigint | null;
-                    l1Fee: bigint | null;
-                    l1FeeScalar: number | null;
-                } & {};
+                format: (args: import("viem/chains").OpStackRpcTransactionReceipt, action?: string | undefined) => import("viem/chains").OpStackTransactionReceipt;
                 type: "transactionReceipt";
             };
         };
@@ -329,9 +106,300 @@ export declare const chains: {
         };
         verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
     };
+    readonly 42161: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Arbiscan";
+                readonly url: "https://arbiscan.io";
+                readonly apiUrl: "https://api.arbiscan.io/api";
+            };
+        };
+        blockTime: 250;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 7654707;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 42161;
+        name: "Arbitrum One";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    };
+    readonly 4663: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Blockscout";
+                readonly url: "https://robinhoodchain.blockscout.com";
+                readonly apiUrl: "https://robinhoodchain.blockscout.com/api";
+            };
+        };
+        blockTime: 100;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 4663;
+        name: "Robinhood Chain";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.mainnet.chain.robinhood.com", "https://rpc.ordofi.network"];
+                readonly webSocket: readonly ["wss://rpc.ordofi.network"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    };
+    readonly 1: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://etherscan.io";
+                readonly apiUrl: "https://api.etherscan.io/api";
+            };
+        };
+        blockTime: 12000;
+        contracts: {
+            readonly ensUniversalResolver: {
+                readonly address: "0xeeeeeeee14d718c2b47d9923deab1335e144eeee";
+                readonly blockCreated: 23085558;
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 14353601;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 1;
+        name: "Ethereum";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://ethereum.reth.rs/rpc"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    };
+    readonly 143: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Monadscan";
+                readonly url: "https://monadscan.com";
+                readonly apiUrl: "https://api.etherscan.io/v2/api?chainid=143";
+            };
+            readonly monadvision: {
+                readonly name: "MonadVision";
+                readonly url: "https://monadvision.com";
+            };
+        };
+        blockTime: 400;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+                readonly blockCreated: 9248132;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 143;
+        name: "Monad";
+        nativeCurrency: {
+            readonly name: "Monad";
+            readonly symbol: "MON";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://rpc.monad.xyz", "https://rpc1.monad.xyz"];
+                readonly webSocket: readonly ["wss://rpc.monad.xyz", "wss://rpc1.monad.xyz"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        supportsTransactionReplacementDetection?: boolean | undefined | undefined;
+        testnet: false;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: import("viem").ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+            client: import("viem").Client;
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+        verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+    };
 };
 export type SupportedChainId = keyof typeof chains;
 export declare function isSupportedChainId(id: number): id is SupportedChainId;
+/**
+ * Everything this client knows about a chain besides viem's own definition: the name a tool caller
+ * uses for it (`chain: "arbitrum"`), the name shown to an operator, the environment variables that
+ * configure its RPC, and the public endpoint used when none is set.
+ *
+ * ONE TABLE, so a chain cannot be half-added: `rpcUrlFromEnv`, `logsRpcUrlFromEnv`,
+ * `rpcSourceForEnv`, `resolvedRpcSecrets` and `publicRpcHint` all read it, and `Record<
+ * SupportedChainId, …>` makes a chain present in `chains` and absent here a compile error.
+ * `links.ts` holds the explorer map and is the one place this table does not reach; it fails loudly
+ * on a chain it does not know.
+ *
+ * `rpcEnv` is tried in order. The second name of each pair is the conventional one an operator may
+ * already have set. The CLI reads the whole environment it was started in, so both names reach it.
+ */
+export interface ChainInfo {
+    key: string;
+    name: string;
+    rpcEnv: readonly string[];
+    logsRpcEnv: string;
+    publicRpc: string;
+}
+export declare const CHAIN_INFO: {
+    readonly 8453: {
+        readonly key: "base";
+        readonly name: "Base";
+        readonly rpcEnv: readonly ["TREASURY_RPC_BASE", "BASE_RPC_URL"];
+        readonly logsRpcEnv: "TREASURY_LOGS_RPC_BASE";
+        readonly publicRpc: "https://mainnet.base.org";
+    };
+    readonly 42161: {
+        readonly key: "arbitrum";
+        readonly name: "Arbitrum One";
+        readonly rpcEnv: readonly ["TREASURY_RPC_ARBITRUM", "ARBITRUM_RPC_URL"];
+        readonly logsRpcEnv: "TREASURY_LOGS_RPC_ARBITRUM";
+        readonly publicRpc: "https://arb1.arbitrum.io/rpc";
+    };
+    readonly 4663: {
+        readonly key: "robinhood";
+        readonly name: "Robinhood Chain";
+        readonly rpcEnv: readonly ["TREASURY_RPC_ROBINHOOD", "ROBINHOOD_RPC_URL"];
+        readonly logsRpcEnv: "TREASURY_LOGS_RPC_ROBINHOOD";
+        readonly publicRpc: "https://rpc.mainnet.chain.robinhood.com";
+    };
+    readonly 1: {
+        readonly key: "ethereum";
+        readonly name: "Ethereum";
+        readonly rpcEnv: readonly ["TREASURY_RPC_ETHEREUM", "ETHEREUM_RPC_URL"];
+        readonly logsRpcEnv: "TREASURY_LOGS_RPC_ETHEREUM";
+        readonly publicRpc: "https://ethereum.reth.rs/rpc";
+    };
+    readonly 143: {
+        readonly key: "monad";
+        readonly name: "Monad";
+        readonly rpcEnv: readonly ["TREASURY_RPC_MONAD", "MONAD_RPC_URL"];
+        readonly logsRpcEnv: "TREASURY_LOGS_RPC_MONAD";
+        readonly publicRpc: "https://rpc.monad.xyz";
+    };
+};
+/**
+ * Solana — the one chain here that is not an EVM chain. It has no chain id, no `viem` chain and no
+ * `eth_getLogs`, so it is not a row of `CHAIN_INFO`; everything else about it follows the same rules:
+ * its own variables only, then its public endpoint. An endpoint is checked for the right cluster by its
+ * genesis hash (`src/solana/rpc.ts`), the counterpart of an EVM endpoint's chain id.
+ */
+export declare const SOLANA_INFO: {
+    readonly key: "solana";
+    readonly name: "Solana";
+    readonly rpcEnv: readonly ["TREASURY_RPC_SOLANA", "SOLANA_RPC_URL"];
+    readonly publicRpc: "https://api.mainnet-beta.solana.com";
+};
+/** The Solana RPC URL: `TREASURY_RPC_SOLANA`, then `SOLANA_RPC_URL`, then the public mainnet endpoint. */
+export declare function solanaRpcUrlFromEnv(): string;
+/** Which variable supplied the Solana RPC URL — the NAME only, never the value. */
+export declare function solanaRpcSourceForEnv(): {
+    source: string;
+    configured: boolean;
+};
+/** `publicRpcHint` for Solana: the sentence for a failure on the unconfigured public endpoint. */
+export declare function solanaPublicRpcHint(): string | undefined;
+/** The name a tool caller uses for a chain: `"base"`, `"arbitrum"`, `"robinhood"`, `"ethereum"`, `"monad"`. */
+export type ChainKey = (typeof CHAIN_INFO)[SupportedChainId]["key"];
+/**
+ * Every supported chain, in the order chains were added: Base first, then Arbitrum One, Robinhood
+ * Chain, Ethereum and Monad. Listed rather than read from `Object.keys(chains)`, whose integer keys
+ * enumerate in numeric order and would put Ethereum (1) ahead of Base everywhere a list of chains is shown.
+ * `client.unit.test.ts` holds this list equal to the keys of `chains`.
+ */
+export declare const supportedChainIds: SupportedChainId[];
+/** `"arbitrum"` → 42161. `undefined` for a name this client does not know — the caller says so. */
+export declare function chainIdForKey(key: string): SupportedChainId | undefined;
 /**
  * Read-only client. This module constructs exactly one kind of thing — a public (unsigned)
  * client from an RPC URL. It never constructs a wallet client: the signer is the consumer's,
@@ -372,29 +440,45 @@ export declare function makePublicClient(chainId: SupportedChainId, rpcUrl: stri
 /**
  * An env value counts as an RPC URL only if it parses as one with an http(s) scheme. Anything else —
  * empty, whitespace, a non-URL, and in particular an UNEXPANDED placeholder like `${TREASURY_RPC_BASE}` —
- * is treated as unset. Measured 2026-09-12: Claude Code forwards the plugin's `.mcp.json` value
- * `${TREASURY_RPC_BASE}` verbatim when the host variable is unset, and with the old `if (v)` test every
- * RPC-touching tool died on "Failed to parse URL from ${TREASURY_RPC_BASE}". `.mcp.json` now also uses
- * `${VAR:-}`, but this guard is what makes the server independent of any host's expansion rules.
+ * is treated as unset. Measured 2026-09-12, when the plugin still declared an MCP server: Claude Code
+ * forwarded the server declaration's value `${TREASURY_RPC_BASE}` verbatim when the host variable was
+ * unset, and with the old `if (v)` test every RPC-touching tool died on "Failed to parse URL from
+ * ${TREASURY_RPC_BASE}". The plugin now runs the CLI through the shell and declares nothing, but any
+ * host or wrapper can still pass a placeholder through, and this guard is what makes the client
+ * independent of anyone's expansion rules.
  */
 export declare function rpcUrlFromEnvValue(v: string | undefined): string | undefined;
 /**
  * Resolves the RPC URL for a chain from the environment. ⚠️ A keyed provider URL IS a secret: it must
- * never appear in tool output — every error crossing the tool boundary goes through `describeError`
- * (`src/redact.ts`), which strips endpoints. Fallback names after `TREASURY_RPC_BASE`:
- * `BASE_RPC_URL`; the plugin's `.mcp.json` passes only the `TREASURY_*` pair through, so under the
- * packaged path the fallback is unreachable.
- * `TREASURY_LOGS_RPC_BASE`, if set, is preferred for log scans (providers cap eth_getLogs ranges very
- * differently: Alchemy free 10 blocks, Base public 2,000) — see `position.ts`.
+ * never appear in tool output — every error crossing the tool boundary goes through `redactEndpoints`
+ * (`src/redact.ts`), which strips endpoints. The names come from `CHAIN_INFO`: on Base,
+ * `TREASURY_RPC_BASE` then `BASE_RPC_URL`; on Arbitrum One, `TREASURY_RPC_ARBITRUM` then
+ * `ARBITRUM_RPC_URL`; on Robinhood Chain, `TREASURY_RPC_ROBINHOOD` then `ROBINHOOD_RPC_URL`; on Ethereum,
+ * `TREASURY_RPC_ETHEREUM` then `ETHEREUM_RPC_URL`; on Monad, `TREASURY_RPC_MONAD` then `MONAD_RPC_URL`.
+ * The CLI inherits its shell's whole environment, so on every path, the plugin's
+ * included, the second name of each pair is used when the first is unset.
+ * The chain's logs variable (`TREASURY_LOGS_RPC_<CHAIN>`: BASE, ARBITRUM, ROBINHOOD, ETHEREUM, MONAD), if set, is
+ * preferred for log scans (providers cap eth_getLogs ranges very differently: Alchemy free 10 blocks,
+ * Base public 2,000, Infura 10,000 on Arbitrum) — see `position.ts`.
+ *
+ * 🔴 A chain reads ONLY its own variables. An Arbitrum call never falls back to a Base endpoint: a
+ * vault's address has no contract on the other chain, so reads fail with "returned no data" — which
+ * reads as a broken vault rather than as a misconfiguration.
  */
 export declare function rpcUrlFromEnv(chainId: SupportedChainId): string;
 /**
  * The endpoint an event scan falls back to when the configured logs RPC cannot cover the range — and
- * the operator's opt-out from it. `TREASURY_LOGS_FALLBACK` unset ⇒ Base's public endpoint; an http(s)
- * URL ⇒ that endpoint; ANY other value — `off`, `none`, `disabled`, a typo — ⇒ no fallback at all, and
- * the scan degrades to a cut-short window as it did before the fallback existed. It exists because the fallback
+ * the operator's opt-out from it. `TREASURY_LOGS_FALLBACK` unset ⇒ the chain's public endpoint; an
+ * http(s) URL ⇒ that endpoint, ON BASE ONLY; ANY other value — `off`, `none`, `disabled`, a typo — ⇒ no
+ * fallback at all, and the scan degrades to a cut-short window as it did before the fallback existed. It exists because the fallback
  * otherwise sends a query to a third party the operator never named, which some
  * deployments cannot accept — and it fails CLOSED for the same reason.
+ *
+ * 🔴 The variable names ONE endpoint, and that endpoint is on Base. On any other chain a URL there
+ * cannot serve the scan — it would answer for the wrong chain — so a SET variable means no fallback
+ * on that chain, whatever it holds: either the operator opted out, or they named a Base endpoint and
+ * so constrained where this process talks. An operator who wants history on another chain points that
+ * chain's logs variable (`TREASURY_LOGS_RPC_ARBITRUM`, `TREASURY_LOGS_RPC_MONAD`, …) at a provider with a wide eth_getLogs range.
  */
 export declare function logsFallbackUrlFromEnv(chainId: SupportedChainId, logsUrl: string): string | undefined;
 /** RPC to use for eth_getLogs scans: a dedicated one if configured, else the general one. */
@@ -427,3 +511,46 @@ export declare function resolvedRpcSecrets(): string[];
  * undefined when a keyed RPC resolved, so a real chain fault is never mislabelled as a setup problem.
  */
 export declare function publicRpcHint(chainId: SupportedChainId): string | undefined;
+/** How long a chain-identity probe may take before the endpoint counts as "did not say". */
+export declare const CHAIN_PROBE_MS = 3000;
+/**
+ * Which chain does this endpoint say it is? `undefined` when it did not say within
+ * `CHAIN_PROBE_MS` — an error, a rate limit, a hang — which is NOT a statement about the chain: the
+ * caller reports that as "not verified", never as a match and never as a mismatch.
+ *
+ * It exists because two chains mean two RPC variables, and the likeliest mistake is one pointed at
+ * the other chain. Nothing then errors usefully: a vault's address has no code there, so reads fail
+ * with "returned no data" and the failure reads as a broken vault.
+ *
+ * Bounded on purpose. The transport's own deadline is 10 s and a rate-limited `eth_chainId` is waited
+ * out for all of it, which would make a health check that already has its answer wait ten seconds
+ * for a second one (measured in review). An answer is remembered per endpoint URL, so a process asks
+ * each endpoint once.
+ */
+export declare function endpointChainId(client: ReadClient, rpcUrl: string, timeoutMs?: number): Promise<number | undefined>;
+/** An endpoint a tool is about to read through, and the NAME of the variable that supplied it. */
+export interface Endpoint {
+    client: ReadClient;
+    url: string;
+    source: string;
+}
+/**
+ * The first of these endpoints that answers for a chain other than `chainId`, or `undefined`.
+ * A chain's public endpoint is never asked: it is this client's own constant, so the question
+ * would be a request to a third party with a known answer. An endpoint that does not say is not a
+ * mismatch.
+ */
+export declare function firstEndpointOnWrongChain(chainId: SupportedChainId, endpoints: Endpoint[]): Promise<{
+    source: string;
+    answersFor: number;
+} | undefined>;
+/** TEST SEAM — forgets what every endpoint said, so one test's mock port cannot answer for the next. NOT re-exported from index.ts. */
+export declare function __forgetEndpointChainsForTests(): void;
+/**
+ * Which variable supplied the endpoint `earn_balance` scans events through — the chain's logs
+ * variable when it resolves, otherwise whatever supplied the general RPC. The NAME only.
+ */
+export declare function logsRpcSourceForEnv(chainId: SupportedChainId): {
+    source: string;
+    configured: boolean;
+};