crypto-aio 0.0.2 → 0.1.0

package/dist/adapters/evm/driver.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evmDriverFactory = evmDriverFactory;
+const builder_1 = require("./builder");
+const client_1 = require("./client");
+const network_1 = require("./network");
+const proofs_1 = require("./proofs");
+const reader_1 = require("./reader");
+const probe = async (call, method) => (0, client_1.quantity)(await call.rpc(method), method);
+/**
+ * Identity is the decimal `eth_chainId`, the form of the network's registry identity; the
+ * height is `eth_blockNumber`. Only endpoints whose identity matches feed health heights.
+ */
+function probes(expectedIdentity) {
+    return {
+        identity: async (call) => (await probe(call, 'eth_chainId')).toString(),
+        ...(expectedIdentity !== undefined ? { expectedIdentity } : {}),
+        height: (call) => probe(call, 'eth_blockNumber'),
+    };
+}
+function evmDriverFactory(makeClient) {
+    return {
+        async create(ctx) {
+            // The handle's options too (`maxFeePerGas`); an unknown one is refused, so a
+            // misspelt key never passes silently.
+            const config = (0, network_1.evmNetworkConfig)(ctx.chain, ctx.network, ctx.options);
+            // Probes go on every transport this driver receives, before any traffic: an
+            // endpoint without them stays unverified.
+            ctx.transport.setProbes(probes(ctx.network.identity));
+            ctx.indexer?.setProbes(probes(ctx.network.identity));
+            const client = makeClient(ctx.transport, config.chainId);
+            const evm = {
+                client,
+                chain: ctx.chain,
+                network: ctx.network,
+                config,
+                log: ctx.log,
+            };
+            const replacement = (0, builder_1.createEvmReplacement)(evm);
+            const ext = (0, reader_1.createEvmExt)(client);
+            return {
+                ordering: 'nonce',
+                capabilities: config.capabilities,
+                address: (0, reader_1.createEvmAddressCodec)(client),
+                reader: (0, reader_1.createEvmReader)(evm),
+                builder: (0, builder_1.createEvmBuilder)(evm),
+                broadcaster: (0, builder_1.createEvmBroadcaster)(client, config.chainId),
+                proofs: (0, proofs_1.createEvmProofs)(evm),
+                sequence: (0, reader_1.createEvmSequence)(client),
+                ...(replacement ? { replacement } : {}),
+                blocks: (0, proofs_1.createEvmBlocks)(evm),
+                ext: { evm: { getNonce: ext.evm.getNonce } },
+                limits: () => ({ maxOutputs: 1 }),
+                // A fresh SDK client on every call, never the driver's own: a caller may mutate
+                // it (listeners, polling) without touching other handles.
+                createNativeClient: () => client.createNative(),
+            };
+        },
+    };
+}
+//# sourceMappingURL=driver.js.map

package/dist/adapters/evm/driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driver.js","sourceRoot":"","sources":["../../../src/adapters/evm/driver.ts"],"names":[],"mappings":";;AAkCA,4CAyCC;AArED,uCAAyF;AACzF,qCAAoC;AACpC,uCAA6C;AAC7C,qCAA4D;AAC5D,qCAMkB;AAGlB,MAAM,KAAK,GAAG,KAAK,EAAE,IAAkB,EAAE,MAAc,EAAmB,EAAE,CAC1E,IAAA,iBAAQ,EAAC,MAAM,IAAI,CAAC,GAAG,CAAU,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AAEpD;;;GAGG;AACH,SAAS,MAAM,CAAC,gBAAoC;IAClD,OAAO;QACL,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,QAAQ,EAAE;QACvE,GAAG,CAAC,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/D,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,iBAAiB,CAAC;KACjD,CAAC;AACJ,CAAC;AAED,SAAgB,gBAAgB,CAC9B,UAAgE;IAEhE,OAAO;QACL,KAAK,CAAC,MAAM,CAAC,GAAG;YACd,6EAA6E;YAC7E,sCAAsC;YACtC,MAAM,MAAM,GAAG,IAAA,0BAAgB,EAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACrE,4EAA4E;YAC5E,0CAA0C;YAC1C,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YACtD,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrD,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;YACzD,MAAM,GAAG,GAAe;gBACtB,MAAM;gBACN,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,MAAM;gBACN,GAAG,EAAE,GAAG,CAAC,GAAG;aACb,CAAC;YACF,MAAM,WAAW,GAAG,IAAA,8BAAoB,EAAC,GAAG,CAAC,CAAC;YAC9C,MAAM,GAAG,GAAG,IAAA,qBAAY,EAAC,MAAM,CAAC,CAAC;YACjC,OAAO;gBACL,QAAQ,EAAE,OAAO;gBACjB,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,OAAO,EAAE,IAAA,8BAAqB,EAAC,MAAM,CAAC;gBACtC,MAAM,EAAE,IAAA,wBAAe,EAAC,GAAG,CAAC;gBAC5B,OAAO,EAAE,IAAA,0BAAgB,EAAC,GAAG,CAAC;gBAC9B,WAAW,EAAE,IAAA,8BAAoB,EAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC;gBACzD,MAAM,EAAE,IAAA,wBAAe,EAAC,GAAG,CAAC;gBAC5B,QAAQ,EAAE,IAAA,0BAAiB,EAAC,MAAM,CAAC;gBACnC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBACvC,MAAM,EAAE,IAAA,wBAAe,EAAC,GAAG,CAAC;gBAC5B,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE;gBAC5C,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;gBACjC,gFAAgF;gBAChF,0DAA0D;gBAC1D,kBAAkB,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,EAAE;aAChD,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["/**\n * `EvmDriver`: all EVM logic, over the `EvmClient` strategy. One factory serves\n * every EVM chain and network; each network's registry data configures it.\n */\nimport type { ChainDriver, DriverFactory } from '../../core/driver/types';\nimport type { EndpointCall, HealthProbes, Transport } from '../../core/transport/types';\nimport { createEvmBroadcaster, createEvmBuilder, createEvmReplacement } from './builder';\nimport { quantity } from './client';\nimport { evmNetworkConfig } from './network';\nimport { createEvmBlocks, createEvmProofs } from './proofs';\nimport {\n  createEvmAddressCodec,\n  createEvmExt,\n  createEvmReader,\n  createEvmSequence,\n  type EvmContext,\n} from './reader';\nimport type { EvmClient } from './types';\n\nconst probe = async (call: EndpointCall, method: string): Promise<bigint> =>\n  quantity(await call.rpc<unknown>(method), method);\n\n/**\n * Identity is the decimal `eth_chainId`, the form of the network's registry identity; the\n * height is `eth_blockNumber`. Only endpoints whose identity matches feed health heights.\n */\nfunction probes(expectedIdentity: string | undefined): HealthProbes {\n  return {\n    identity: async (call) => (await probe(call, 'eth_chainId')).toString(),\n    ...(expectedIdentity !== undefined ? { expectedIdentity } : {}),\n    height: (call) => probe(call, 'eth_blockNumber'),\n  };\n}\n\nexport function evmDriverFactory(\n  makeClient: (transport: Transport, chainId: bigint) => EvmClient,\n): DriverFactory {\n  return {\n    async create(ctx): Promise<ChainDriver> {\n      // The handle's options too (`maxFeePerGas`); an unknown one is refused, so a\n      // misspelt key never passes silently.\n      const config = evmNetworkConfig(ctx.chain, ctx.network, ctx.options);\n      // Probes go on every transport this driver receives, before any traffic: an\n      // endpoint without them stays unverified.\n      ctx.transport.setProbes(probes(ctx.network.identity));\n      ctx.indexer?.setProbes(probes(ctx.network.identity));\n      const client = makeClient(ctx.transport, config.chainId);\n      const evm: EvmContext = {\n        client,\n        chain: ctx.chain,\n        network: ctx.network,\n        config,\n        log: ctx.log,\n      };\n      const replacement = createEvmReplacement(evm);\n      const ext = createEvmExt(client);\n      return {\n        ordering: 'nonce',\n        capabilities: config.capabilities,\n        address: createEvmAddressCodec(client),\n        reader: createEvmReader(evm),\n        builder: createEvmBuilder(evm),\n        broadcaster: createEvmBroadcaster(client, config.chainId),\n        proofs: createEvmProofs(evm),\n        sequence: createEvmSequence(client),\n        ...(replacement ? { replacement } : {}),\n        blocks: createEvmBlocks(evm),\n        ext: { evm: { getNonce: ext.evm.getNonce } },\n        limits: () => ({ maxOutputs: 1 }),\n        // A fresh SDK client on every call, never the driver's own: a caller may mutate\n        // it (listeners, polling) without touching other handles.\n        createNativeClient: () => client.createNative(),\n      };\n    },\n  };\n}\n"]}

package/dist/adapters/evm/errors.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Classifies a node's answer to `eth_sendRawTransaction`. The patterns are
+ * geth's texts (txpool and RPC), which the geth-derived clients of most built-in chains
+ * share; an Ethereum endpoint may run any client, so a text not listed here falls to the
+ * safe default, a generic refusal. The returned reasons are short, fixed texts: a
+ * node's own text can carry addresses and amounts ("insufficient funds …: address 0x… have
+ * … want …") and is never passed on. Every result is frozen, so no caller can alter a later
+ * one.
+ */
+import type { BroadcastResult } from '../../core/driver/types';
+/** The node's answer at its word (see `classifyOwnBroadcast` for the bytes we sent). */
+export declare function classifyBroadcastError(message: string): BroadcastResult;
+/**
+ * A node's rejection is a claim. The answer to `sentHex`, the
+ * bytes this driver sent on the network whose chain id is `chainId`: a `rejected` stands
+ * only when its reason holds for those bytes, read SDK-free (`readSentTx`); otherwise it is a
+ * refusal, so a lying endpoint that relays our bytes can never end the Operation and invite
+ * a second payment. Every other answer is the node's, as `classifyBroadcastError` reads it.
+ */
+export declare function classifyOwnBroadcast(message: string, sentHex: string, chainId: bigint): BroadcastResult;

package/dist/adapters/evm/errors.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyBroadcastError = classifyBroadcastError;
+exports.classifyOwnBroadcast = classifyOwnBroadcast;
+const rawtx_1 = require("./rawtx");
+const refused = (code, reason) => Object.freeze({ kind: 'refused', code, reason });
+const rejected = (reason) => Object.freeze({ kind: 'rejected', reason });
+/** Success: the node already holds these bytes, or they are already mined. */
+const ALREADY_KNOWN = /already known|known transaction|already imported|alreadyknown|already exists|already in chain/i;
+const ALREADY_KNOWN_RESULT = Object.freeze({ kind: 'already-known' });
+/**
+ * State-dependent or node policy: the same bytes may become valid later or on another node,
+ * or may already be included (observed only).
+ */
+const REFUSED = [
+    [/nonce too low/i, refused('NONCE_CONFLICT', 'nonce too low')],
+    [/nonce too high|nonce gap/i, refused('NONCE_TOO_HIGH', 'nonce too high')],
+    [/insufficient funds/i, refused('INSUFFICIENT_FUNDS', 'insufficient funds')],
+    [
+        /replacement transaction underpriced/i,
+        refused('FEE_TOO_LOW', 'replacement underpriced'),
+    ],
+    [
+        /underpriced|fee too low|less than block base fee|gas price too low|below minimum/i,
+        refused('FEE_TOO_LOW', 'fee too low'),
+    ],
+    // The block gas limit can rise.
+    [
+        /exceeds block gas limit/i,
+        refused('TX_REFUSED', 'gas limit above the block gas limit'),
+    ],
+    // A pool gates types on the forks active at its head (a syncing node) and on its config.
+    [
+        /transaction type not supported|tx type not supported/i,
+        refused('TX_REFUSED', 'unsupported transaction type'),
+    ],
+    // Arbitrum's intrinsic gas includes the L1 poster cost, which moves.
+    [/intrinsic gas too low/i, refused('TX_REFUSED', 'gas limit below intrinsic gas')],
+    // Node policy: another node may accept the same bytes.
+    [/only replay-protected/i, refused('TX_REFUSED', 'replay protection required')],
+    [/oversized data/i, refused('TX_REFUSED', 'transaction too large')],
+];
+/**
+ * Invalid by construction: these bytes can never be included on any node. Exact texts only,
+ * so a state-dependent cause that merely shares a word is never taken for one of these.
+ * `invalid chain id` comes first: geth wraps it as "invalid sender: invalid chain id …".
+ */
+const REJECTED = [
+    {
+        pattern: /invalid chain id/i,
+        result: rejected('wrong chain id'),
+        holds: (sent, chainId) => sent !== 'malformed' && sent.chainId !== undefined && sent.chainId !== chainId,
+    },
+    {
+        pattern: /invalid sender|invalid signature|invalid transaction v, r, s values/i,
+        result: rejected('invalid signature'),
+        holds: (sent) => sent !== 'malformed' && !(0, rawtx_1.signatureValuesValid)(sent),
+    },
+    {
+        pattern: /\brlp:|typed transaction too short/i,
+        result: rejected('malformed transaction'),
+        holds: (sent) => sent === 'malformed',
+    },
+    {
+        pattern: /max priority fee per gas higher than max fee per gas|tip above fee cap/i,
+        result: rejected('priority fee above the fee cap'),
+        holds: (sent) => sent !== 'malformed' &&
+            sent.type === 2 &&
+            sent.maxPriorityFeePerGas > sent.maxFeePerGas,
+    },
+];
+const REFUSED_BY_NODE = refused('TX_REFUSED', 'refused by the node');
+/**
+ * `rejected` ends an Attempt without proof, so any doubt falls toward `refused`: the
+ * refusal patterns are checked first ("invalid sender: transaction type not supported" is a
+ * refusal), and an unlisted text is a refusal.
+ */
+function classified(message) {
+    if (ALREADY_KNOWN.test(message))
+        return { result: ALREADY_KNOWN_RESULT };
+    for (const [pattern, result] of REFUSED) {
+        if (pattern.test(message))
+            return { result };
+    }
+    const rejection = REJECTED.find((entry) => entry.pattern.test(message));
+    return rejection
+        ? { result: rejection.result, rejection }
+        : { result: REFUSED_BY_NODE };
+}
+/** The node's answer at its word (see `classifyOwnBroadcast` for the bytes we sent). */
+function classifyBroadcastError(message) {
+    return classified(message).result;
+}
+/** A rejection this driver cannot confirm for the bytes it sent: observed, never terminal. */
+const UNCONFIRMED = refused('TX_REFUSED', 'the node claimed the transaction is invalid');
+/**
+ * A node's rejection is a claim. The answer to `sentHex`, the
+ * bytes this driver sent on the network whose chain id is `chainId`: a `rejected` stands
+ * only when its reason holds for those bytes, read SDK-free (`readSentTx`); otherwise it is a
+ * refusal, so a lying endpoint that relays our bytes can never end the Operation and invite
+ * a second payment. Every other answer is the node's, as `classifyBroadcastError` reads it.
+ */
+function classifyOwnBroadcast(message, sentHex, chainId) {
+    const { result, rejection } = classified(message);
+    if (!rejection)
+        return result;
+    const sent = (0, rawtx_1.readSentTx)(sentHex);
+    return sent !== undefined && rejection.holds(sent, chainId) ? result : UNCONFIRMED;
+}
+//# sourceMappingURL=errors.js.map

package/dist/adapters/evm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/adapters/evm/errors.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Classifies a node's answer to `eth_sendRawTransaction`. The patterns are\n * geth's texts (txpool and RPC), which the geth-derived clients of most built-in chains\n * share; an Ethereum endpoint may run any client, so a text not listed here falls to the\n * safe default, a generic refusal. The returned reasons are short, fixed texts: a\n * node's own text can carry addresses and amounts (\"insufficient funds …: address 0x… have\n * … want …\") and is never passed on. Every result is frozen, so no caller can alter a later\n * one.\n */\nimport type { BroadcastResult } from '../../core/driver/types';\nimport { readSentTx, signatureValuesValid, type EvmSentTx } from './rawtx';\n\ntype RefusalCode = Extract<BroadcastResult, { kind: 'refused' }>['code'];\n\nconst refused = (code: RefusalCode, reason: string): BroadcastResult =>\n  Object.freeze({ kind: 'refused', code, reason });\nconst rejected = (reason: string): BroadcastResult =>\n  Object.freeze({ kind: 'rejected', reason });\n\n/** Success: the node already holds these bytes, or they are already mined. */\nconst ALREADY_KNOWN =\n  /already known|known transaction|already imported|alreadyknown|already exists|already in chain/i;\nconst ALREADY_KNOWN_RESULT: BroadcastResult = Object.freeze({ kind: 'already-known' });\n\n/**\n * State-dependent or node policy: the same bytes may become valid later or on another node,\n * or may already be included (observed only).\n */\nconst REFUSED: readonly (readonly [RegExp, BroadcastResult])[] = [\n  [/nonce too low/i, refused('NONCE_CONFLICT', 'nonce too low')],\n  [/nonce too high|nonce gap/i, refused('NONCE_TOO_HIGH', 'nonce too high')],\n  [/insufficient funds/i, refused('INSUFFICIENT_FUNDS', 'insufficient funds')],\n  [\n    /replacement transaction underpriced/i,\n    refused('FEE_TOO_LOW', 'replacement underpriced'),\n  ],\n  [\n    /underpriced|fee too low|less than block base fee|gas price too low|below minimum/i,\n    refused('FEE_TOO_LOW', 'fee too low'),\n  ],\n  // The block gas limit can rise.\n  [\n    /exceeds block gas limit/i,\n    refused('TX_REFUSED', 'gas limit above the block gas limit'),\n  ],\n  // A pool gates types on the forks active at its head (a syncing node) and on its config.\n  [\n    /transaction type not supported|tx type not supported/i,\n    refused('TX_REFUSED', 'unsupported transaction type'),\n  ],\n  // Arbitrum's intrinsic gas includes the L1 poster cost, which moves.\n  [/intrinsic gas too low/i, refused('TX_REFUSED', 'gas limit below intrinsic gas')],\n  // Node policy: another node may accept the same bytes.\n  [/only replay-protected/i, refused('TX_REFUSED', 'replay protection required')],\n  [/oversized data/i, refused('TX_REFUSED', 'transaction too large')],\n];\n\n/** A rejection and the check that confirms it for the bytes we sent. */\ninterface Rejection {\n  readonly pattern: RegExp;\n  readonly result: BroadcastResult;\n  readonly holds: (sent: EvmSentTx | 'malformed', chainId: bigint) => boolean;\n}\n\n/**\n * Invalid by construction: these bytes can never be included on any node. Exact texts only,\n * so a state-dependent cause that merely shares a word is never taken for one of these.\n * `invalid chain id` comes first: geth wraps it as \"invalid sender: invalid chain id …\".\n */\nconst REJECTED: readonly Rejection[] = [\n  {\n    pattern: /invalid chain id/i,\n    result: rejected('wrong chain id'),\n    holds: (sent, chainId) =>\n      sent !== 'malformed' && sent.chainId !== undefined && sent.chainId !== chainId,\n  },\n  {\n    pattern: /invalid sender|invalid signature|invalid transaction v, r, s values/i,\n    result: rejected('invalid signature'),\n    holds: (sent) => sent !== 'malformed' && !signatureValuesValid(sent),\n  },\n  {\n    pattern: /\\brlp:|typed transaction too short/i,\n    result: rejected('malformed transaction'),\n    holds: (sent) => sent === 'malformed',\n  },\n  {\n    pattern: /max priority fee per gas higher than max fee per gas|tip above fee cap/i,\n    result: rejected('priority fee above the fee cap'),\n    holds: (sent) =>\n      sent !== 'malformed' &&\n      sent.type === 2 &&\n      (sent.maxPriorityFeePerGas as bigint) > (sent.maxFeePerGas as bigint),\n  },\n];\n\nconst REFUSED_BY_NODE = refused('TX_REFUSED', 'refused by the node');\n\n/**\n * `rejected` ends an Attempt without proof, so any doubt falls toward `refused`: the\n * refusal patterns are checked first (\"invalid sender: transaction type not supported\" is a\n * refusal), and an unlisted text is a refusal.\n */\nfunction classified(message: string): {\n  readonly result: BroadcastResult;\n  readonly rejection?: Rejection;\n} {\n  if (ALREADY_KNOWN.test(message)) return { result: ALREADY_KNOWN_RESULT };\n  for (const [pattern, result] of REFUSED) {\n    if (pattern.test(message)) return { result };\n  }\n  const rejection = REJECTED.find((entry) => entry.pattern.test(message));\n  return rejection\n    ? { result: rejection.result, rejection }\n    : { result: REFUSED_BY_NODE };\n}\n\n/** The node's answer at its word (see `classifyOwnBroadcast` for the bytes we sent). */\nexport function classifyBroadcastError(message: string): BroadcastResult {\n  return classified(message).result;\n}\n\n/** A rejection this driver cannot confirm for the bytes it sent: observed, never terminal. */\nconst UNCONFIRMED: BroadcastResult = refused(\n  'TX_REFUSED',\n  'the node claimed the transaction is invalid',\n);\n\n/**\n * A node's rejection is a claim. The answer to `sentHex`, the\n * bytes this driver sent on the network whose chain id is `chainId`: a `rejected` stands\n * only when its reason holds for those bytes, read SDK-free (`readSentTx`); otherwise it is a\n * refusal, so a lying endpoint that relays our bytes can never end the Operation and invite\n * a second payment. Every other answer is the node's, as `classifyBroadcastError` reads it.\n */\nexport function classifyOwnBroadcast(\n  message: string,\n  sentHex: string,\n  chainId: bigint,\n): BroadcastResult {\n  const { result, rejection } = classified(message);\n  if (!rejection) return result;\n  const sent = readSentTx(sentHex);\n  return sent !== undefined && rejection.holds(sent, chainId) ? result : UNCONFIRMED;\n}\n"]}

package/dist/adapters/evm/ethers-client.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `EthersClient`: the ethers v6 strategy (the EVM default). Driver I/O goes straight to the
+ * core transport under each call's tags, never through ethers' provider: ethers' request
+ * queue drains on a real 0 ms timer that fake-clock tests cannot step deterministically,
+ * and the driver needs none of it (one request per call). ethers does the codec work, and
+ * `TransportJsonRpcProvider` (static network, no batching, no cache, no polling, `_send` →
+ * transport) is the `crypto-aio/native` client.
+ */
+import { JsonRpcApiProvider, Network, type JsonRpcPayload, type JsonRpcResult } from 'ethers';
+import type { DisposableNativeClient } from '../../core/driver/types';
+import type { Transport } from '../../core/transport/types';
+import { EvmClientBase } from './client';
+import type { EvmAbi, EvmCallTags, EvmSignature, EvmTxFields } from './types';
+type Call = (method: string, params: unknown) => Promise<unknown>;
+/**
+ * The ethers provider bridged onto the core transport through `call`: the native client
+ * only.
+ */
+export declare class TransportJsonRpcProvider extends JsonRpcApiProvider {
+    #private;
+    constructor(network: Network, call: Call);
+    _send(payload: JsonRpcPayload | JsonRpcPayload[]): Promise<JsonRpcResult[]>;
+}
+export declare class EthersClient extends EvmClientBase {
+    #private;
+    readonly library = "ethers";
+    readonly abi: EvmAbi;
+    constructor(transport: Transport, chainId: bigint);
+    protected send(method: string, params: readonly unknown[], tags: EvmCallTags): Promise<unknown>;
+    isAddress(value: string): boolean;
+    checksum(address: string): string;
+    addressFromPublicKey(publicKey: Uint8Array): string;
+    protected encodeUnsigned(tx: EvmTxFields): string;
+    protected hashUnsigned(tx: EvmTxFields): string;
+    protected encodeSigned(tx: EvmTxFields, signature: EvmSignature): {
+        raw: string;
+        hash: string;
+    };
+    createNative(): DisposableNativeClient;
+}
+/** The `ethers` adapter's driver factory; the manifest's `load()` returns it. */
+export declare const ethersDriverFactory: import("../../core/driver/types").DriverFactory;
+export {};

package/dist/adapters/evm/ethers-client.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ethersDriverFactory = exports.EthersClient = exports.TransportJsonRpcProvider = void 0;
+/**
+ * `EthersClient`: the ethers v6 strategy (the EVM default). Driver I/O goes straight to the
+ * core transport under each call's tags, never through ethers' provider: ethers' request
+ * queue drains on a real 0 ms timer that fake-clock tests cannot step deterministically,
+ * and the driver needs none of it (one request per call). ethers does the codec work, and
+ * `TransportJsonRpcProvider` (static network, no batching, no cache, no polling, `_send` →
+ * transport) is the `crypto-aio/native` client.
+ */
+const ethers_1 = require("ethers");
+const client_1 = require("./client");
+const driver_1 = require("./driver");
+const rpc_1 = require("./rpc");
+/**
+ * The ethers provider bridged onto the core transport through `call`: the native client
+ * only.
+ */
+class TransportJsonRpcProvider extends ethers_1.JsonRpcApiProvider {
+    #call;
+    constructor(network, call) {
+        super(network, { staticNetwork: network, batchMaxCount: 1, cacheTimeout: -1 });
+        this.#call = call;
+        this._start();
+    }
+    async _send(payload) {
+        const results = [];
+        for (const item of Array.isArray(payload) ? payload : [payload]) {
+            results.push({ id: item.id, result: await this.#call(item.method, item.params) });
+        }
+        return results;
+    }
+}
+exports.TransportJsonRpcProvider = TransportJsonRpcProvider;
+const coder = ethers_1.AbiCoder.defaultAbiCoder();
+const erc20 = new ethers_1.Interface([
+    'function transfer(address to, uint256 amount)',
+    'function balanceOf(address owner) view returns (uint256)',
+    'function decimals() view returns (uint8)',
+    'function symbol() view returns (string)',
+    'event Transfer(address indexed from, address indexed to, uint256 amount)',
+]);
+const gasPriceOracle = new ethers_1.Interface([
+    'function getL1Fee(bytes data) view returns (uint256)',
+]);
+const TRANSFER_TOPIC = erc20.getEvent('Transfer')?.topicHash;
+const ethersAbi = {
+    transferTopic: TRANSFER_TOPIC,
+    encodeTransfer: (to, amount) => erc20.encodeFunctionData('transfer', [to, amount]),
+    encodeBalanceOf: (owner) => erc20.encodeFunctionData('balanceOf', [owner]),
+    encodeDecimals: () => erc20.encodeFunctionData('decimals', []),
+    encodeSymbol: () => erc20.encodeFunctionData('symbol', []),
+    encodeGetL1Fee: (unsignedTx) => gasPriceOracle.encodeFunctionData('getL1Fee', [unsignedTx]),
+    decodeUint256: (data) => {
+        if (!client_1.ABI_WORD.test(data))
+            throw new Error('not one ABI word');
+        return coder.decode(['uint256'], data)[0];
+    },
+    decodeString: (data) => coder.decode(['string'], data)[0],
+    decodeTransfer: (log) => {
+        const words = (0, client_1.transferLogWords)(log, TRANSFER_TOPIC);
+        if (!words)
+            return null;
+        return {
+            from: (0, ethers_1.getAddress)(coder.decode(['address'], words.from)[0]),
+            to: (0, ethers_1.getAddress)(coder.decode(['address'], words.to)[0]),
+            amount: coder.decode(['uint256'], words.data)[0],
+        };
+    },
+};
+function toEthers(tx, signature) {
+    const common = {
+        chainId: tx.chainId,
+        nonce: Number(tx.nonce),
+        to: tx.to,
+        value: tx.value,
+        data: tx.data,
+        gasLimit: tx.gasLimit,
+    };
+    const built = ethers_1.Transaction.from(tx.type === 'eip1559'
+        ? {
+            ...common,
+            type: 2,
+            maxFeePerGas: tx.maxFeePerGas,
+            maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+        }
+        : { ...common, type: 0, gasPrice: tx.gasPrice });
+    if (signature)
+        built.signature = ethers_1.Signature.from(signature);
+    return built;
+}
+class EthersClient extends client_1.EvmClientBase {
+    library = 'ethers';
+    abi = ethersAbi;
+    #transport;
+    #network;
+    constructor(transport, chainId) {
+        super(chainId);
+        this.#transport = transport;
+        // A plain network: ethers' known networks carry plugins (ENS, gas stations) we never use.
+        this.#network = new ethers_1.Network('crypto-aio', chainId);
+    }
+    send(method, params, tags) {
+        // No SDK queue, and so no real timer, between a driver call and the transport.
+        return (0, rpc_1.transportCall)(this.#transport, method, [...params], tags);
+    }
+    isAddress(value) {
+        return client_1.ADDRESS.test(value) && (0, ethers_1.isAddress)(value);
+    }
+    checksum(address) {
+        return this.checked(address, ethers_1.getAddress);
+    }
+    addressFromPublicKey(publicKey) {
+        return (0, ethers_1.computeAddress)((0, ethers_1.hexlify)((0, client_1.uncompressedPublicKey)(publicKey)));
+    }
+    encodeUnsigned(tx) {
+        return toEthers(tx).unsignedSerialized;
+    }
+    hashUnsigned(tx) {
+        return toEthers(tx).unsignedHash;
+    }
+    encodeSigned(tx, signature) {
+        const signed = toEthers(tx, signature);
+        return { raw: signed.serialized, hash: signed.hash };
+    }
+    createNative() {
+        const client = new TransportJsonRpcProvider(this.#network, (method, params) => (0, rpc_1.transportCall)(this.#transport, method, params, (0, rpc_1.nativeTags)(method)));
+        return { client, close: () => client.destroy() };
+    }
+}
+exports.EthersClient = EthersClient;
+/** The `ethers` adapter's driver factory; the manifest's `load()` returns it. */
+exports.ethersDriverFactory = (0, driver_1.evmDriverFactory)((transport, chainId) => new EthersClient(transport, chainId));
+//# sourceMappingURL=ethers-client.js.map

package/dist/adapters/evm/ethers-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethers-client.js","sourceRoot":"","sources":["../../../src/adapters/evm/ethers-client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `EthersClient`: the ethers v6 strategy (the EVM default). Driver I/O goes straight to the\n * core transport under each call's tags, never through ethers' provider: ethers' request\n * queue drains on a real 0 ms timer that fake-clock tests cannot step deterministically,\n * and the driver needs none of it (one request per call). ethers does the codec work, and\n * `TransportJsonRpcProvider` (static network, no batching, no cache, no polling, `_send` →\n * transport) is the `crypto-aio/native` client.\n */\nimport {\n  AbiCoder,\n  Interface,\n  JsonRpcApiProvider,\n  Network,\n  Signature,\n  Transaction,\n  computeAddress,\n  getAddress,\n  hexlify,\n  isAddress,\n  type JsonRpcPayload,\n  type JsonRpcResult,\n} from 'ethers';\nimport type { DisposableNativeClient } from '../../core/driver/types';\nimport type { Transport } from '../../core/transport/types';\nimport {\n  ABI_WORD,\n  ADDRESS,\n  EvmClientBase,\n  transferLogWords,\n  uncompressedPublicKey,\n} from './client';\nimport { evmDriverFactory } from './driver';\nimport { nativeTags, transportCall } from './rpc';\nimport type { EvmAbi, EvmCallTags, EvmSignature, EvmTxFields } from './types';\n\ntype Call = (method: string, params: unknown) => Promise<unknown>;\n\n/**\n * The ethers provider bridged onto the core transport through `call`: the native client\n * only.\n */\nexport class TransportJsonRpcProvider extends JsonRpcApiProvider {\n  readonly #call: Call;\n\n  constructor(network: Network, call: Call) {\n    super(network, { staticNetwork: network, batchMaxCount: 1, cacheTimeout: -1 });\n    this.#call = call;\n    this._start();\n  }\n\n  override async _send(\n    payload: JsonRpcPayload | JsonRpcPayload[],\n  ): Promise<JsonRpcResult[]> {\n    const results: JsonRpcResult[] = [];\n    for (const item of Array.isArray(payload) ? payload : [payload]) {\n      results.push({ id: item.id, result: await this.#call(item.method, item.params) });\n    }\n    return results;\n  }\n}\n\nconst coder = AbiCoder.defaultAbiCoder();\nconst erc20 = new Interface([\n  'function transfer(address to, uint256 amount)',\n  'function balanceOf(address owner) view returns (uint256)',\n  'function decimals() view returns (uint8)',\n  'function symbol() view returns (string)',\n  'event Transfer(address indexed from, address indexed to, uint256 amount)',\n]);\nconst gasPriceOracle = new Interface([\n  'function getL1Fee(bytes data) view returns (uint256)',\n]);\nconst TRANSFER_TOPIC = erc20.getEvent('Transfer')?.topicHash as string;\n\nconst ethersAbi: EvmAbi = {\n  transferTopic: TRANSFER_TOPIC,\n  encodeTransfer: (to, amount) => erc20.encodeFunctionData('transfer', [to, amount]),\n  encodeBalanceOf: (owner) => erc20.encodeFunctionData('balanceOf', [owner]),\n  encodeDecimals: () => erc20.encodeFunctionData('decimals', []),\n  encodeSymbol: () => erc20.encodeFunctionData('symbol', []),\n  encodeGetL1Fee: (unsignedTx) =>\n    gasPriceOracle.encodeFunctionData('getL1Fee', [unsignedTx]),\n  decodeUint256: (data) => {\n    if (!ABI_WORD.test(data)) throw new Error('not one ABI word');\n    return coder.decode(['uint256'], data)[0] as bigint;\n  },\n  decodeString: (data) => coder.decode(['string'], data)[0] as string,\n  decodeTransfer: (log) => {\n    const words = transferLogWords(log, TRANSFER_TOPIC);\n    if (!words) return null;\n    return {\n      from: getAddress(coder.decode(['address'], words.from)[0] as string),\n      to: getAddress(coder.decode(['address'], words.to)[0] as string),\n      amount: coder.decode(['uint256'], words.data)[0] as bigint,\n    };\n  },\n};\n\nfunction toEthers(tx: EvmTxFields, signature?: EvmSignature): Transaction {\n  const common = {\n    chainId: tx.chainId,\n    nonce: Number(tx.nonce),\n    to: tx.to,\n    value: tx.value,\n    data: tx.data,\n    gasLimit: tx.gasLimit,\n  };\n  const built = Transaction.from(\n    tx.type === 'eip1559'\n      ? {\n          ...common,\n          type: 2,\n          maxFeePerGas: tx.maxFeePerGas,\n          maxPriorityFeePerGas: tx.maxPriorityFeePerGas,\n        }\n      : { ...common, type: 0, gasPrice: tx.gasPrice },\n  );\n  if (signature) built.signature = Signature.from(signature);\n  return built;\n}\n\nexport class EthersClient extends EvmClientBase {\n  readonly library = 'ethers';\n  readonly abi = ethersAbi;\n  readonly #transport: Transport;\n  readonly #network: Network;\n\n  constructor(transport: Transport, chainId: bigint) {\n    super(chainId);\n    this.#transport = transport;\n    // A plain network: ethers' known networks carry plugins (ENS, gas stations) we never use.\n    this.#network = new Network('crypto-aio', chainId);\n  }\n\n  protected send(\n    method: string,\n    params: readonly unknown[],\n    tags: EvmCallTags,\n  ): Promise<unknown> {\n    // No SDK queue, and so no real timer, between a driver call and the transport.\n    return transportCall(this.#transport, method, [...params], tags);\n  }\n\n  isAddress(value: string): boolean {\n    return ADDRESS.test(value) && isAddress(value);\n  }\n\n  checksum(address: string): string {\n    return this.checked(address, getAddress);\n  }\n\n  addressFromPublicKey(publicKey: Uint8Array): string {\n    return computeAddress(hexlify(uncompressedPublicKey(publicKey)));\n  }\n\n  protected encodeUnsigned(tx: EvmTxFields): string {\n    return toEthers(tx).unsignedSerialized;\n  }\n\n  protected hashUnsigned(tx: EvmTxFields): string {\n    return toEthers(tx).unsignedHash;\n  }\n\n  protected encodeSigned(\n    tx: EvmTxFields,\n    signature: EvmSignature,\n  ): { raw: string; hash: string } {\n    const signed = toEthers(tx, signature);\n    return { raw: signed.serialized, hash: signed.hash as string };\n  }\n\n  createNative(): DisposableNativeClient {\n    const client = new TransportJsonRpcProvider(this.#network, (method, params) =>\n      transportCall(this.#transport, method, params, nativeTags(method)),\n    );\n    return { client, close: () => client.destroy() };\n  }\n}\n\n/** The `ethers` adapter's driver factory; the manifest's `load()` returns it. */\nexport const ethersDriverFactory = evmDriverFactory(\n  (transport, chainId) => new EthersClient(transport, chainId),\n);\n"]}

package/dist/adapters/evm/fees.d.ts

@@ -0,0 +1,79 @@
+import type { FeeEstimateDraft, FeeOverride, FeeSpeed } from '../../core/model/fee';
+import type { EvmFeeHistory } from './types';
+export type EvmFeeModel = 'evm-1559' | 'evm-legacy';
+/** The per-gas prices of one transaction. */
+export type EvmFeeParams = {
+    readonly type: 'eip1559';
+    readonly maxFeePerGas: bigint;
+    readonly maxPriorityFeePerGas: bigint;
+} | {
+    readonly type: 'legacy';
+    readonly gasPrice: bigint;
+};
+/**
+ * `eth_feeHistory` window and priority-fee percentiles for slow, normal and fast: the
+ * method the Polygon Gas Station documents (10th, 25th and 50th over the last 15 blocks).
+ */
+export declare const FEE_HISTORY_BLOCKS = 15;
+export declare const FEE_PERCENTILES: readonly number[];
+/** A plain transfer to an account without code costs exactly this much gas. */
+export declare const TRANSFER_GAS = 21000n;
+/** The lower median; `0n` for no values. */
+export declare function median(values: readonly bigint[]): bigint;
+/**
+ * EIP-1559 prices for `speed`: the tip is the median, over the window, of the speed's
+ * percentile (at least `minTip`); the cap allows the next base fee to double. The history
+ * must answer a request for `FEE_PERCENTILES`: one without the next base fee, without
+ * reward rows, or with a reward row shorter than `FEE_PERCENTILES` is a retryable
+ * `PROVIDER_UNAVAILABLE`, never a tip of `minTip`.
+ */
+export declare function feesFromHistory(history: EvmFeeHistory, speed: FeeSpeed, minTip: bigint): {
+    readonly params: EvmFeeParams;
+    readonly baseFeePerGas: bigint;
+};
+export declare function legacyPrice(gasPrice: bigint, speed: FeeSpeed): EvmFeeParams;
+/** The node's estimate, with headroom unless it is a plain transfer. */
+export declare function gasLimitFrom(estimate: bigint): bigint;
+/**
+ * The default `maxFeePerGas`, the highest price per gas an EVM transaction signs, 1,000
+ * gwei. It bounds a plain transfer at 0.021 and a 65,000-gas token transfer at 0.065 of
+ * the native coin, however an endpoint prices the fee. A network whose base fee rises
+ * above the ceiling stalls its transfers as `FEE_TOO_LOW` until the fee falls or the
+ * option is raised.
+ */
+export declare const DEFAULT_MAX_FEE_PER_GAS = 1000000000000n;
+/** The highest price per gas `params` may pay: the fee cap, or the legacy gas price. */
+export declare function priceCap(params: EvmFeeParams): bigint;
+/**
+ * A node's suggestion within the ceiling: the fee cap or gas price at most `ceiling`,
+ * and the tip at most the fee cap. No endpoint can raise what a transfer signs.
+ */
+export declare function capPrice(params: EvmFeeParams, ceiling: bigint): EvmFeeParams;
+/**
+ * Refuses, before anything is signed, a fee whose price per gas is above `ceiling` (the
+ * handle's `maxFeePerGas`), whatever produced it: an explicit override, a stored fee, or a
+ * cancel's least bump. The details carry the price and the bound as decimal strings.
+ */
+export declare function assertWithinCeiling(params: EvmFeeParams, ceiling: bigint): void;
+/** Validates an `EvmFeeOverride` against the network's fee model. */
+export declare function parseFeeOverride(override: FeeOverride, model: EvmFeeModel): {
+    readonly params: EvmFeeParams;
+    readonly gasLimit?: bigint;
+};
+/** The fee draft for a transaction of `gasLimit` at `params`. */
+export declare function feeDraft(speed: FeeSpeed | 'custom', gasLimit: bigint, params: EvmFeeParams, extra?: {
+    readonly baseFeePerGas?: bigint;
+    readonly l1Fee?: bigint;
+}): FeeEstimateDraft;
+/** The gas limit and prices a fee draft's details hold. */
+export declare function feeOf(details: Readonly<Record<string, unknown>>): {
+    readonly gasLimit: bigint;
+    readonly params: EvmFeeParams;
+};
+/**
+ * Whether `next` may replace `previous` under a txpool's `percent` price bump: each price
+ * strictly higher, and at least `percent` higher (geth), so a zero tip must still rise.
+ */
+export declare function meetsBump(previous: EvmFeeParams, next: EvmFeeParams, percent: number): boolean;
+/** The smallest prices that meet the bump over `previous`: each strictly higher (geth). */
+export declare function minimumBump(previous: EvmFeeParams, percent: number): EvmFeeParams;