@crewhaus/tool-chaincall 0.7.0 → 0.8.0

package/dist/lib/codec.d.ts

@@ -1,6 +1,10 @@
 /** Encode a call from a signature and its arguments. Throws on a bad type. */
 export declare function encodeCallData(signature: string, args: ReadonlyArray<unknown>, what: string): Promise<string>;
-/** Decode return data against a list of ABI types. */
+/**
+ * Decode return data against a list of ABI types. An empty list decodes to
+ * no values, as it always has: EvmMulticall accepts `outputs: []`, and
+ * AbiDecode's own schema (which wants at least one type) is not asked.
+ */
 export declare function decodeValues(types: ReadonlyArray<string>, hex: string, what: string): Promise<unknown[]>;
 export type CheckedAddress = {
     /** EIP-55 mixed case, which is what goes into any output. */

package/dist/lib/codec.js

@@ -20,9 +20,23 @@
  */
 import { abiDecode, abiEncodeCall, addressCheck } from "@crewhaus/tool-onchain";
 import { ChainCallError } from "./rpc";
-/** Read a tool result that is known to be a JSON string. */
+/**
+ * Run one of `tool-onchain`'s tools and read its JSON result.
+ *
+ * The input goes through the tool's own schema first, as it would from a
+ * model. Calling `execute` directly skips the executor that normally parses
+ * it, and with it the limits the schema carries — `AbiDecode`'s cap on the
+ * size of the data it decodes among them — while the data here comes from
+ * a node answering for a contract somebody else deployed.
+ */
 async function toolJson(tool, input, what) {
-    const result = await tool.execute(input);
+    const parsed = tool.inputSchema.safeParse(input);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const path = issue === undefined || issue.path.length === 0 ? "" : ` (${issue.path.join(".")})`;
+        throw new ChainCallError(`${what}: ${tool.name} refused the input${path}: ${issue?.message ?? "invalid"}`);
+    }
+    const result = await tool.execute(parsed.data);
     if (typeof result !== "string") {
         throw new ChainCallError(`${what}: ${tool.name} returned non-text content`);
     }
@@ -36,8 +50,14 @@ export async function encodeCallData(signature, args, what) {
         throw new ChainCallError(`${what}: could not encode the call`);
     return encoded;
 }
-/** Decode return data against a list of ABI types. */
+/**
+ * Decode return data against a list of ABI types. An empty list decodes to
+ * no values, as it always has: EvmMulticall accepts `outputs: []`, and
+ * AbiDecode's own schema (which wants at least one type) is not asked.
+ */
 export async function decodeValues(types, hex, what) {
+    if (types.length === 0)
+        return [];
     const out = await toolJson(abiDecode, { data: hex, types }, what);
     const values = out["values"];
     if (!Array.isArray(values))

package/dist/lib/rpc.d.ts

@@ -16,7 +16,7 @@
  * does — this package holds no endpoint list of its own and there is no
  * caller-supplied URL anywhere in it.
  */
-import type { ChainAdapter } from "@crewhaus/chain-adapter-base";
+import type { ChainAdapter, ChainAdapterConfig } from "@crewhaus/chain-adapter-base";
 import { CrewhausError } from "@crewhaus/errors";
 /** A refusal raised by this package: a bad input, a broken promise, a limit. */
 export declare class ChainCallError extends CrewhausError {
@@ -30,6 +30,12 @@ export declare class ChainCallError extends CrewhausError {
  */
 export type ChainRpc = (method: string, params: ReadonlyArray<unknown>, opts?: {
     readonly signal?: AbortSignal;
+    /**
+     * What is left of the tool's own deadline, in ms. A transport with a
+     * deadline of its own (the chain adapter's defaults to 30 s) uses this
+     * instead, so a `timeoutMs` above that default is not silently cut to it.
+     */
+    readonly timeoutMs?: number;
 }) => Promise<unknown>;
 /** Boot-time binding: chain id in, transport out. */
 export type ChainRpcResolver = (chainId: string) => ChainRpc | undefined;
@@ -41,9 +47,19 @@ export declare function setChainRpcResolver(fn: ChainRpcResolver | undefined): v
 /**
  * Adapt a `ChainAdapter` into the seam, so the runtime can hand these tools
  * the same adapters `tool-evm` already gets. `rpcRead` keeps its own
- * allowlist and boundary classification; this does not replace either.
+ * allowlist and boundary classification; this does not replace either. The
+ * call's signal goes through, so a cancelled read closes its request instead
+ * of leaving it in flight.
  */
 export declare function chainRpcFromAdapter(adapter: ChainAdapter): ChainRpc;
+/**
+ * Bind the transports from the spec's `chains` block — what every generated
+ * bundle, `crewhaus run` and `crewhaus eval` call at boot when a spec lists
+ * one of these tools. Each chain gets the adapter `tool-evm` gets.
+ */
+export declare function bindChainCallChains(config: {
+    readonly chains: ReadonlyArray<ChainAdapterConfig>;
+}): void;
 /**
  * Test-only injection point, the convention every networked package here
  * follows: one transport for every chain id. `undefined` unbinds, and a
@@ -62,12 +78,12 @@ export declare function resolveRpc(chainId: string, toolName: string): ChainRpc;
  * write-class method reaching this line is a defect in this package and
  * should arrive at the log looking like one.
  *
- * The signal is both passed down AND raced against. `ChainAdapter.rpcRead`
- * takes no signal, so a transport built on one cannot be cancelled — and a
- * `timeoutMs` that bounds nothing is a promise this package should not be
- * making. Racing means the TOOL returns on time; the request underneath it
- * may still be in flight, which is the honest limit of a seam whose other
- * side does not accept a signal.
+ * The signal is both passed down AND raced against. The chain adapter
+ * honours it (see `chainRpcFromAdapter`), but a transport bound some other
+ * way may not — and a `timeoutMs` that bounds nothing is a promise this
+ * package should not be making. Racing means the TOOL returns on time even
+ * then; the request underneath may still be in flight, which is the honest
+ * limit of a seam whose other side does not accept a signal.
  */
 export declare function rpcRead(rpc: ChainRpc, chainId: string, method: string, params: ReadonlyArray<unknown>, signal?: AbortSignal): Promise<unknown>;
 /** The JSON-RPC error object, as much of it as a thrown value tends to carry. */
@@ -82,19 +98,50 @@ export type RpcErrorShape = {
  * `.data` attached, some an `Error` wrapping one under `.cause` or `.error`.
  */
 export declare function rpcError(err: unknown): RpcErrorShape;
-/** True when the failure is the caller's or the runtime's cancellation. */
+/**
+ * True when the failure is a cancellation or a deadline — the caller's, the
+ * runtime's, or the transport's own (a chain adapter's timeout carries
+ * `timedOut`) — rather than anything the node said.
+ */
 export declare function isAbort(err: unknown, signal?: AbortSignal): boolean;
 /**
- * -32601 and the strings providers use instead of it.
+ * What each node the read was sent to said, one entry per node.
+ *
+ * The chain adapter reports a read that failed on every node as one error
+ * whose words end with the last node's reason; which node failed last is a
+ * matter of timing, so nothing here decides on those words. It also carries
+ * `attempts`, each node's own failure, and each one that the node answered
+ * with a JSON-RPC error carries that error as `rpc`. `answer` is that error,
+ * or undefined for a node that answered nothing a JSON-RPC client can read:
+ * it could not be reached, answered an HTTP error or a redirect, or the
+ * adapter refused what it sent. An adapter error without `attempts` (a quorum
+ * lost before every voter was heard, or no node at all) is one entry with no
+ * answer. Anything else, a transport bound some other way, is read as the
+ * node's own answer, as it always was.
+ */
+export declare function nodeAnswers(err: unknown): ReadonlyArray<{
+    readonly answer: RpcErrorShape | undefined;
+    readonly text: string;
+}>;
+/**
+ * -32601 and the strings providers use instead of it, from EVERY node.
  *
  * This is the one predicate `EvmSimulateBundle` degrades on, so it has to be
  * narrow in both directions. A node that has never heard of `eth_simulateV1`
  * is a reason to answer a lesser question; a node that timed out, or that
  * rejected the parameters, or whose simulation reverted, is NOT — degrading
  * on those would turn a transient fault into a quietly weaker answer that
- * still looks like an answer.
+ * still looks like an answer. So with several nodes every one must have said
+ * so: one that rejected the parameters, could not be reached, or was not
+ * heard may implement the method.
  */
 export declare function isMethodUnsupported(err: unknown, signal?: AbortSignal): boolean;
+/**
+ * The first node, in the order the chain names them, that answered with an
+ * error other than "no such method": a node that implements the method and
+ * refused this request. Undefined when no node did.
+ */
+export declare function firstRefusal(err: unknown): string | undefined;
 /** A one-line description of a node failure, for a refusal message. */
 export declare function rpcErrorText(err: unknown): string;
 export type Deadline = {
@@ -102,9 +149,4 @@ export type Deadline = {
     /** Clear the timer. Always call it, or the process keeps a handle alive. */
     cancel(): void;
 };
-/**
- * A deadline that also honours the runtime's own cancellation. Every tool
- * here opens one before its first byte and cancels it in a `finally`: a tool
- * that fans out over several round trips can hang in several places.
- */
 export declare function startDeadline(ms: number, outer?: AbortSignal): Deadline;

package/dist/lib/rpc.js

@@ -1,4 +1,5 @@
-import { assertReadOnlyMethod } from "@crewhaus/chain-adapter-base";
+import { CHAINS_BLOCK_EXAMPLE, assertReadOnlyMethod } from "@crewhaus/chain-adapter-base";
+import { createEvmAdapters } from "@crewhaus/chain-adapter-evm";
 import { CrewhausError } from "@crewhaus/errors";
 /** A refusal raised by this package: a bad input, a broken promise, a limit. */
 export class ChainCallError extends CrewhausError {
@@ -18,10 +19,27 @@ export function setChainRpcResolver(fn) {
 /**
  * Adapt a `ChainAdapter` into the seam, so the runtime can hand these tools
  * the same adapters `tool-evm` already gets. `rpcRead` keeps its own
- * allowlist and boundary classification; this does not replace either.
+ * allowlist and boundary classification; this does not replace either. The
+ * call's signal goes through, so a cancelled read closes its request instead
+ * of leaving it in flight.
  */
 export function chainRpcFromAdapter(adapter) {
-    return (method, params) => adapter.rpcRead(method, params);
+    return (method, params, opts) => adapter.rpcRead(method, params, {
+        ...(opts?.signal === undefined ? {} : { signal: opts.signal }),
+        ...(opts?.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }),
+    });
+}
+/**
+ * Bind the transports from the spec's `chains` block — what every generated
+ * bundle, `crewhaus run` and `crewhaus eval` call at boot when a spec lists
+ * one of these tools. Each chain gets the adapter `tool-evm` gets.
+ */
+export function bindChainCallChains(config) {
+    const adapters = createEvmAdapters(config.chains);
+    setChainRpcResolver((chainId) => {
+        const adapter = adapters.get(chainId);
+        return adapter === undefined ? undefined : chainRpcFromAdapter(adapter);
+    });
 }
 /**
  * Test-only injection point, the convention every networked package here
@@ -35,7 +53,7 @@ export function _setRpc(fn) {
 /** Find the transport for a chain, or say what the operator has to wire. */
 export function resolveRpc(chainId, toolName) {
     if (resolver === undefined) {
-        throw new ChainCallError(`${toolName}: no chain transport is bound — the runtime must call setChainRpcResolver() at boot with the chains from spec.chains[]`);
+        throw new ChainCallError(`${toolName}: no chain is configured. Declare one in the spec — ${CHAINS_BLOCK_EXAMPLE}.`);
     }
     const rpc = resolver(chainId);
     if (rpc === undefined) {
@@ -58,12 +76,12 @@ function abortError(signal) {
  * write-class method reaching this line is a defect in this package and
  * should arrive at the log looking like one.
  *
- * The signal is both passed down AND raced against. `ChainAdapter.rpcRead`
- * takes no signal, so a transport built on one cannot be cancelled — and a
- * `timeoutMs` that bounds nothing is a promise this package should not be
- * making. Racing means the TOOL returns on time; the request underneath it
- * may still be in flight, which is the honest limit of a seam whose other
- * side does not accept a signal.
+ * The signal is both passed down AND raced against. The chain adapter
+ * honours it (see `chainRpcFromAdapter`), but a transport bound some other
+ * way may not — and a `timeoutMs` that bounds nothing is a promise this
+ * package should not be making. Racing means the TOOL returns on time even
+ * then; the request underneath may still be in flight, which is the honest
+ * limit of a seam whose other side does not accept a signal.
  */
 export async function rpcRead(rpc, chainId, method, params, signal) {
     assertReadOnlyMethod(chainId, method);
@@ -71,7 +89,13 @@ export async function rpcRead(rpc, chainId, method, params, signal) {
     // reason a node sees one more request.
     if (signal?.aborted === true)
         throw abortError(signal);
-    const call = rpc(method, params, signal === undefined ? {} : { signal });
+    const deadlineAt = signal === undefined ? undefined : DEADLINES.get(signal);
+    const call = rpc(method, params, {
+        ...(signal === undefined ? {} : { signal }),
+        // The rest of the tool's budget, so the transport's own deadline is not
+        // shorter than the one the caller asked for.
+        ...(deadlineAt === undefined ? {} : { timeoutMs: Math.max(1, deadlineAt - Date.now()) }),
+    });
     if (signal === undefined)
         return call;
     let onAbort;
@@ -124,27 +148,55 @@ export function rpcError(err) {
     const message = record?.["message"];
     return typeof message === "string" ? { message } : { message: String(err) };
 }
-/** True when the failure is the caller's or the runtime's cancellation. */
+/**
+ * True when the failure is a cancellation or a deadline — the caller's, the
+ * runtime's, or the transport's own (a chain adapter's timeout carries
+ * `timedOut`) — rather than anything the node said.
+ */
 export function isAbort(err, signal) {
     if (signal?.aborted === true)
         return true;
     const record = asRecord(err);
-    return record?.["name"] === "AbortError" || record?.["name"] === "TimeoutError";
+    return (record?.["name"] === "AbortError" ||
+        record?.["name"] === "TimeoutError" ||
+        record?.["timedOut"] === true);
 }
 /**
- * -32601 and the strings providers use instead of it.
+ * What each node the read was sent to said, one entry per node.
  *
- * This is the one predicate `EvmSimulateBundle` degrades on, so it has to be
- * narrow in both directions. A node that has never heard of `eth_simulateV1`
- * is a reason to answer a lesser question; a node that timed out, or that
- * rejected the parameters, or whose simulation reverted, is NOT — degrading
- * on those would turn a transient fault into a quietly weaker answer that
- * still looks like an answer.
+ * The chain adapter reports a read that failed on every node as one error
+ * whose words end with the last node's reason; which node failed last is a
+ * matter of timing, so nothing here decides on those words. It also carries
+ * `attempts`, each node's own failure, and each one that the node answered
+ * with a JSON-RPC error carries that error as `rpc`. `answer` is that error,
+ * or undefined for a node that answered nothing a JSON-RPC client can read:
+ * it could not be reached, answered an HTTP error or a redirect, or the
+ * adapter refused what it sent. An adapter error without `attempts` (a quorum
+ * lost before every voter was heard, or no node at all) is one entry with no
+ * answer. Anything else, a transport bound some other way, is read as the
+ * node's own answer, as it always was.
  */
-export function isMethodUnsupported(err, signal) {
-    if (isAbort(err, signal))
-        return false;
-    const { code, message } = rpcError(err);
+export function nodeAnswers(err) {
+    const record = asRecord(err);
+    if (record?.["name"] !== "ChainAdapterError") {
+        return [{ answer: rpcError(err), text: rpcErrorText(err) }];
+    }
+    const attempts = record["attempts"];
+    const nodes = Array.isArray(attempts) && attempts.length > 0 ? attempts : [err];
+    return nodes.map((node) => {
+        const rpc = asRecord(asRecord(node)?.["rpc"]);
+        const code = rpc?.["code"];
+        const message = rpc?.["message"];
+        if (typeof code !== "number") {
+            const said = asRecord(node)?.["message"];
+            return { answer: undefined, text: typeof said === "string" ? said : String(node) };
+        }
+        const words = typeof message === "string" ? message : "";
+        return { answer: { code, message: words }, text: `${words} (code ${code})` };
+    });
+}
+/** -32601 and the strings providers use instead of it, in one node's answer. */
+function saysUnsupported({ code, message }) {
     // -32601 is "method not found". -32004 is the "method not supported" code
     // several providers return instead; Geth and Erigon both use -32601.
     if (code === -32601 || code === -32004)
@@ -159,6 +211,32 @@ export function isMethodUnsupported(err, signal) {
         /\bunknown method\b/.test(text) ||
         /\bdoes not exist\/is not available\b/.test(text));
 }
+/**
+ * -32601 and the strings providers use instead of it, from EVERY node.
+ *
+ * This is the one predicate `EvmSimulateBundle` degrades on, so it has to be
+ * narrow in both directions. A node that has never heard of `eth_simulateV1`
+ * is a reason to answer a lesser question; a node that timed out, or that
+ * rejected the parameters, or whose simulation reverted, is NOT — degrading
+ * on those would turn a transient fault into a quietly weaker answer that
+ * still looks like an answer. So with several nodes every one must have said
+ * so: one that rejected the parameters, could not be reached, or was not
+ * heard may implement the method.
+ */
+export function isMethodUnsupported(err, signal) {
+    if (isAbort(err, signal))
+        return false;
+    return nodeAnswers(err).every(({ answer }) => answer !== undefined && saysUnsupported(answer));
+}
+/**
+ * The first node, in the order the chain names them, that answered with an
+ * error other than "no such method": a node that implements the method and
+ * refused this request. Undefined when no node did.
+ */
+export function firstRefusal(err) {
+    return nodeAnswers(err).find(({ answer }) => answer !== undefined && !saysUnsupported(answer))
+        ?.text;
+}
 /** A one-line description of a node failure, for a refusal message. */
 export function rpcErrorText(err) {
     const { code, message } = rpcError(err);
@@ -170,8 +248,11 @@ export function rpcErrorText(err) {
  * here opens one before its first byte and cancels it in a `finally`: a tool
  * that fans out over several round trips can hang in several places.
  */
+/** When each deadline's signal runs out (epoch ms), for `rpcRead` to pass down. */
+const DEADLINES = new WeakMap();
 export function startDeadline(ms, outer) {
     const ctrl = new AbortController();
+    DEADLINES.set(ctrl.signal, Date.now() + ms);
     const timer = setTimeout(() => ctrl.abort(new Error(`deadline of ${ms}ms elapsed`)), ms);
     const onOuter = () => ctrl.abort(outer?.reason);
     if (outer !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/tool-chaincall",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "Deterministic EVM contract reads: batched calls, contract introspection, gas market and simulation",
   "main": "dist/index.js",
@@ -8,18 +8,20 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/chain-adapter-base": "0.7.0",
-    "@crewhaus/errors": "0.7.0",
-    "@crewhaus/tool-builder": "0.7.0",
-    "@crewhaus/tool-catalog": "0.7.0",
-    "@crewhaus/tool-onchain": "0.7.0",
+    "@crewhaus/chain-adapter-base": "0.8.0",
+    "@crewhaus/chain-adapter-evm": "0.8.0",
+    "@crewhaus/errors": "0.8.0",
+    "@crewhaus/tool-builder": "0.8.0",
+    "@crewhaus/tool-catalog": "0.8.0",
+    "@crewhaus/tool-onchain": "0.8.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -43,5 +45,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"],
+  "engines": {
+    "bun": ">=1.3.14"
+  }
 }

package/dist/fixtures.d.ts

@@ -1,120 +0,0 @@
-import type { ChainRpc } from "./lib/rpc";
-/** A 32-byte word holding an unsigned integer. */
-export declare function word(value: bigint | number): string;
-/** A 32-byte word holding an address in its low 20 bytes. */
-export declare function addressWord(address: string): string;
-/** A 32-byte word that is not an address: the top bytes are dirty. */
-export declare const NON_ADDRESS_WORD = "0xc5f16f0fcc639fa48a6947836d9850f504798523bf8c9a3a87d5876cf622bec8";
-export declare const ZERO_WORD: string;
-/**
- * ABI-encode what `aggregate3` returns, through the real encoder.
- *
- * The trick is to encode a call taking exactly that argument and drop the
- * four-byte selector: the remaining bytes are the argument's encoding, which
- * is what a node hands back.
- */
-export declare function aggregate3Return(rows: ReadonlyArray<readonly [boolean, string]>): Promise<string>;
-/** `Error(string)` revert bytes for a given message, through the real encoder. */
-export declare function errorStringRevert(message: string): Promise<string>;
-/** The canonical EIP-1167 runtime bytecode delegating to `target`. */
-export declare function minimalProxyCode(target: string): string;
-/** A JSON-RPC error as a provider throws it: an Error carrying `code`. */
-export declare function jsonRpcError(code: number, message: string, data?: unknown): Error;
-/** What a node says about a method it has never heard of. */
-export declare function methodNotFound(method: string): Error;
-export type RpcHandler = (params: ReadonlyArray<unknown>, call: number) => unknown | Promise<unknown>;
-export type RpcStub = {
-    readonly rpc: ChainRpc;
-    /** Every dispatch, in order. The "nothing sends" test reads this. */
-    readonly calls: Array<{
-        method: string;
-        params: ReadonlyArray<unknown>;
-    }>;
-    /** How many times one method was dispatched. */
-    count(method: string): number;
-};
-/**
- * A transport built from a table of handlers.
- *
- * An unhandled method answers -32601, which is what a real node does and is
- * also the one failure this package degrades on — so a test that forgets a
- * handler exercises the degradation path loudly rather than hanging.
- */
-export declare function rpcStub(handlers: Readonly<Record<string, RpcHandler>>): RpcStub;
-/** Serve a different blob to each successive `eth_call`, in order. */
-export declare function sequentialCalls(blobs: ReadonlyArray<string>): RpcHandler;
-export type InspectViews = {
-    /** What supportsInterface(0xffffffff) answers. A compliant contract: false. */
-    readonly sentinel?: boolean | "revert";
-    /** Interface ids the contract claims. */
-    readonly supports?: ReadonlyArray<string>;
-    /** What implementation() answers, when it answers. */
-    readonly implementationView?: string;
-    /** Whether proxiableUUID() answers at all. */
-    readonly proxiable?: boolean;
-    /** Present only when the beacon slot is set: the beacon's implementation(). */
-    readonly beaconImplementation?: string | "revert";
-};
-/**
- * The view rows `ContractInspect` expects, in the order it builds them:
- * the 0xffffffff sentinel, one row per probed interface id, implementation(),
- * proxiableUUID(), and the beacon's implementation() when there is a beacon.
- */
-export declare function inspectViewRows(spec: InspectViews): Array<readonly [boolean, string]>;
-export type SimulatedCall = {
-    readonly returnData?: string;
-    readonly gasUsed?: number;
-    readonly status?: 0 | 1;
-    readonly logs?: ReadonlyArray<{
-        address: string;
-        topics: string[];
-        data: string;
-    }>;
-    readonly error?: {
-        code: number;
-        message: string;
-    };
-};
-/** One block of `eth_simulateV1` output. */
-export declare function simulateV1Result(blockNumber: number, calls: ReadonlyArray<SimulatedCall>): unknown;
-/**
- * One block of `eth_simulateV1` output with the call objects passed through
- * VERBATIM.
- *
- * `simulateV1Result` fills in `status`, `gasUsed` and `logs` for every call,
- * which makes the case worth testing — a node that leaves one of them out —
- * inexpressible. A fixture that cannot express a shape hides every bug that
- * shape causes.
- */
-export declare function simulateV1Raw(blockNumber: number, calls: ReadonlyArray<Record<string, unknown>>): unknown;
-/** An ERC-20 Transfer log, the shape a simulation returns them in. */
-export declare const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-export declare function transferLog(token: string, from: string, to: string, amount: bigint): {
-    address: string;
-    topics: string[];
-    data: string;
-};
-export type BlockFixture = {
-    readonly number: number;
-    readonly gasUsed: bigint;
-    readonly gasLimit: bigint;
-    readonly baseFeePerGas?: bigint;
-};
-export declare function blockResult(block: BlockFixture): unknown;
-export type FeeHistoryFixture = {
-    readonly oldestBlock: number;
-    /** blockCount + 1 entries: the last is the NEXT block's base fee. */
-    readonly baseFeePerGas: ReadonlyArray<bigint>;
-    readonly reward?: ReadonlyArray<ReadonlyArray<bigint>>;
-    readonly baseFeePerBlobGas?: ReadonlyArray<bigint>;
-};
-export declare function feeHistoryResult(history: FeeHistoryFixture): unknown;
-export declare const ADDR: Readonly<{
-    proxy: "0x1111111111111111111111111111111111111111";
-    implementation: "0x2222222222222222222222222222222222222222";
-    admin: "0x3333333333333333333333333333333333333333";
-    beacon: "0x4444444444444444444444444444444444444444";
-    other: "0x5555555555555555555555555555555555555555";
-    token: "0x6666666666666666666666666666666666666666";
-    wallet: "0x7777777777777777777777777777777777777777";
-}>;