crypto-aio 0.0.2 → 0.1.0

package/dist/adapters/avalanche/sdk.d.ts

@@ -0,0 +1,182 @@
+/**
+ * The one place that loads `@avalabs/avalanchejs`, at run time with `require()` (its 5.x
+ * package is an ES module with a CommonJS build). Its type declarations re-export their own
+ * modules without file extensions, which TypeScript cannot follow under `node16`
+ * resolution, so the part of the SDK this library uses is declared here instead: the codec
+ * managers, the transaction builders, the P-Chain fee calculator and the serializable
+ * classes the driver reads. The tests run every declared member against the real package.
+ * Loaded only through the manifest's `load()`.
+ */
+/** A serializable avalanchejs object; `_type` names its class (e.g. `avm.BaseTx`). */
+export interface SdkSerializable {
+    readonly _type: string;
+}
+export interface SdkId {
+    toString(): string;
+    toBytes(): Uint8Array;
+}
+export interface SdkInt {
+    value(): number;
+}
+export interface SdkBigInt {
+    value(): bigint;
+}
+export interface SdkAddress {
+    toBytes(): Uint8Array;
+}
+export interface SdkOutputOwners {
+    readonly locktime: SdkBigInt;
+    readonly threshold: SdkInt;
+    readonly addrs: readonly SdkAddress[];
+}
+/** A `secp256k1fx.TransferOutput`. */
+export interface SdkTransferOutput extends SdkSerializable {
+    readonly outputOwners: SdkOutputOwners;
+    amount(): bigint;
+}
+export interface SdkTransferableOutput extends SdkSerializable {
+    readonly assetId: SdkId;
+    readonly output: SdkSerializable;
+    amount(): bigint;
+}
+export interface SdkUtxoId {
+    readonly txID: SdkId;
+    readonly outputIdx: SdkInt;
+}
+export interface SdkTransferableInput extends SdkSerializable {
+    readonly utxoID: SdkUtxoId;
+    readonly assetId: SdkId;
+    amount(): bigint;
+    sigIndicies(): number[];
+}
+export interface SdkUtxo extends SdkSerializable {
+    readonly utxoId: SdkUtxoId;
+    readonly assetId: SdkId;
+    readonly output: SdkSerializable;
+    /** Its bytes without the codec version, in `codec`. */
+    toBytes(codec: unknown): Uint8Array;
+}
+/** The `avax.BaseTx` every X-Chain and most P-Chain transactions carry. */
+export interface SdkBaseTx {
+    readonly NetworkId: SdkInt;
+    readonly BlockchainId: SdkId;
+    readonly outputs: readonly SdkTransferableOutput[];
+    readonly inputs: readonly SdkTransferableInput[];
+    readonly memo: {
+        readonly bytes: Uint8Array;
+    };
+}
+/** An unsigned transaction of any type (`avm.*`, `pvm.*`). */
+export interface SdkTransaction extends SdkSerializable {
+    readonly vm: string;
+    readonly baseTx?: SdkBaseTx;
+    getSigIndices(): number[][];
+}
+export interface SdkCredential extends SdkSerializable {
+    /** Each signature as hex (65 bytes: r, s, recovery id). */
+    getSignatures(): string[];
+}
+export interface SdkSignedTx {
+    readonly unsignedTx: SdkTransaction;
+    getCredentials(): SdkCredential[];
+    toBytes(): Uint8Array;
+}
+/** A builder's result. */
+export interface SdkUnsignedTx {
+    getTx(): SdkTransaction;
+    toBytes(): Uint8Array;
+}
+export interface SdkManager {
+    getDefaultCodec(): unknown;
+    unpack<T>(bytes: Uint8Array, unpacker: SdkUnpacker<T>): T;
+    unpackTransaction(bytes: Uint8Array): SdkTransaction;
+    packCodec(serializable: SdkSerializable): Uint8Array;
+}
+/** A class `Manager.unpack` reads (`Utxo`, `avaxSerial.SignedTx`). */
+export interface SdkUnpacker<T> {
+    fromBytes(bytes: Uint8Array, codec: unknown): [T, Uint8Array];
+}
+export interface SdkDimensions {
+    readonly 0: number;
+    readonly 1: number;
+    readonly 2: number;
+    readonly 3: number;
+}
+/** avalanchejs's `Context`: what its builders need to know about the network. */
+export interface SdkContext {
+    readonly networkID: number;
+    readonly hrp: string;
+    readonly xBlockchainID: string;
+    readonly pBlockchainID: string;
+    readonly cBlockchainID: string;
+    readonly avaxAssetID: string;
+    readonly baseTxFee: bigint;
+    readonly createAssetTxFee: bigint;
+    readonly platformFeeConfig: {
+        readonly weights: SdkDimensions;
+        readonly maxCapacity: bigint;
+        readonly maxPerSecond: bigint;
+        readonly targetPerSecond: bigint;
+        readonly minPrice: bigint;
+        readonly excessConversionConstant: bigint;
+    };
+}
+export interface SdkFeeState {
+    readonly capacity: bigint;
+    readonly excess: bigint;
+    readonly price: bigint;
+    readonly timestamp: string;
+}
+export interface SdkSignature extends SdkSerializable {
+    toString(): string;
+}
+/** The members of `@avalabs/avalanchejs` this library calls. */
+export interface AvalancheSdk {
+    readonly Utxo: SdkUnpacker<SdkUtxo>;
+    readonly avaxSerial: {
+        readonly SignedTx: SdkUnpacker<SdkSignedTx> & (new (tx: SdkTransaction, credentials: SdkSerializable[]) => SdkSignedTx);
+    };
+    readonly Credential: new (signatures: SdkSignature[]) => SdkCredential;
+    readonly Signature: new (bytes: Uint8Array) => SdkSignature;
+    readonly TransferableOutput: {
+        fromNative(assetId: string, amount: bigint, addresses: readonly Uint8Array[], locktime?: bigint, threshold?: number): SdkTransferableOutput;
+    };
+    readonly Common: {
+        createDimensions(dimensions: {
+            bandwidth: number;
+            dbRead: number;
+            dbWrite: number;
+            compute: number;
+        }): SdkDimensions;
+    };
+    readonly utils: {
+        getManagerForVM(vm: 'AVM' | 'PVM'): SdkManager;
+        getBurnedAmountByTx(tx: SdkTransaction, context: SdkContext): Map<string, bigint>;
+    };
+    readonly avm: {
+        newBaseTx(context: SdkContext, fromAddressesBytes: readonly Uint8Array[], utxos: readonly SdkUtxo[], outputs: readonly SdkTransferableOutput[], options: {
+            readonly changeAddresses: readonly Uint8Array[];
+            readonly memo: Uint8Array;
+            readonly minIssuanceTime: bigint;
+        }): SdkUnsignedTx;
+    };
+    readonly pvm: {
+        newBaseTx(props: {
+            readonly feeState: SdkFeeState;
+            readonly fromAddressesBytes: readonly Uint8Array[];
+            readonly changeAddressesBytes: readonly Uint8Array[];
+            readonly outputs: readonly SdkTransferableOutput[];
+            readonly utxos: readonly SdkUtxo[];
+            readonly memo: Uint8Array;
+            readonly minIssuanceTime: bigint;
+        }, context: SdkContext): SdkUnsignedTx;
+        calculateFee(tx: SdkTransaction, weights: SdkDimensions, price: bigint): bigint;
+    };
+}
+export declare const avalanche: AvalancheSdk;
+/** The serializable class names the driver tells apart. */
+export declare const TYPES: Readonly<{
+    transferOutput: "secp256k1fx.TransferOutput";
+    stakeableLockOut: "pvm.StakeableLockOut";
+    credential: "secp256k1fx.Credential";
+}>;

package/dist/adapters/avalanche/sdk.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * The one place that loads `@avalabs/avalanchejs`, at run time with `require()` (its 5.x
+ * package is an ES module with a CommonJS build). Its type declarations re-export their own
+ * modules without file extensions, which TypeScript cannot follow under `node16`
+ * resolution, so the part of the SDK this library uses is declared here instead: the codec
+ * managers, the transaction builders, the P-Chain fee calculator and the serializable
+ * classes the driver reads. The tests run every declared member against the real package.
+ * Loaded only through the manifest's `load()`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPES = exports.avalanche = void 0;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+exports.avalanche = require('@avalabs/avalanchejs');
+/** The serializable class names the driver tells apart. */
+exports.TYPES = Object.freeze({
+    transferOutput: 'secp256k1fx.TransferOutput',
+    stakeableLockOut: 'pvm.StakeableLockOut',
+    credential: 'secp256k1fx.Credential',
+});
+//# sourceMappingURL=sdk.js.map

package/dist/adapters/avalanche/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.js","sourceRoot":"","sources":["../../../src/adapters/avalanche/sdk.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA6MH,iEAAiE;AACpD,QAAA,SAAS,GAAG,OAAO,CAAC,sBAAsB,CAAiB,CAAC;AAEzE,2DAA2D;AAC9C,QAAA,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IACjC,cAAc,EAAE,4BAA4B;IAC5C,gBAAgB,EAAE,sBAAsB;IACxC,UAAU,EAAE,wBAAwB;CACrC,CAAC,CAAC","sourcesContent":["/**\n * The one place that loads `@avalabs/avalanchejs`, at run time with `require()` (its 5.x\n * package is an ES module with a CommonJS build). Its type declarations re-export their own\n * modules without file extensions, which TypeScript cannot follow under `node16`\n * resolution, so the part of the SDK this library uses is declared here instead: the codec\n * managers, the transaction builders, the P-Chain fee calculator and the serializable\n * classes the driver reads. The tests run every declared member against the real package.\n * Loaded only through the manifest's `load()`.\n */\n\n/** A serializable avalanchejs object; `_type` names its class (e.g. `avm.BaseTx`). */\nexport interface SdkSerializable {\n  readonly _type: string;\n}\n\nexport interface SdkId {\n  toString(): string;\n  toBytes(): Uint8Array;\n}\n\nexport interface SdkInt {\n  value(): number;\n}\n\nexport interface SdkBigInt {\n  value(): bigint;\n}\n\nexport interface SdkAddress {\n  toBytes(): Uint8Array;\n}\n\nexport interface SdkOutputOwners {\n  readonly locktime: SdkBigInt;\n  readonly threshold: SdkInt;\n  readonly addrs: readonly SdkAddress[];\n}\n\n/** A `secp256k1fx.TransferOutput`. */\nexport interface SdkTransferOutput extends SdkSerializable {\n  readonly outputOwners: SdkOutputOwners;\n  amount(): bigint;\n}\n\nexport interface SdkTransferableOutput extends SdkSerializable {\n  readonly assetId: SdkId;\n  readonly output: SdkSerializable;\n  amount(): bigint;\n}\n\nexport interface SdkUtxoId {\n  readonly txID: SdkId;\n  readonly outputIdx: SdkInt;\n}\n\nexport interface SdkTransferableInput extends SdkSerializable {\n  readonly utxoID: SdkUtxoId;\n  readonly assetId: SdkId;\n  amount(): bigint;\n  sigIndicies(): number[];\n}\n\nexport interface SdkUtxo extends SdkSerializable {\n  readonly utxoId: SdkUtxoId;\n  readonly assetId: SdkId;\n  readonly output: SdkSerializable;\n  /** Its bytes without the codec version, in `codec`. */\n  toBytes(codec: unknown): Uint8Array;\n}\n\n/** The `avax.BaseTx` every X-Chain and most P-Chain transactions carry. */\nexport interface SdkBaseTx {\n  readonly NetworkId: SdkInt;\n  readonly BlockchainId: SdkId;\n  readonly outputs: readonly SdkTransferableOutput[];\n  readonly inputs: readonly SdkTransferableInput[];\n  readonly memo: { readonly bytes: Uint8Array };\n}\n\n/** An unsigned transaction of any type (`avm.*`, `pvm.*`). */\nexport interface SdkTransaction extends SdkSerializable {\n  readonly vm: string;\n  readonly baseTx?: SdkBaseTx;\n  getSigIndices(): number[][];\n}\n\nexport interface SdkCredential extends SdkSerializable {\n  /** Each signature as hex (65 bytes: r, s, recovery id). */\n  getSignatures(): string[];\n}\n\nexport interface SdkSignedTx {\n  readonly unsignedTx: SdkTransaction;\n  getCredentials(): SdkCredential[];\n  toBytes(): Uint8Array;\n}\n\n/** A builder's result. */\nexport interface SdkUnsignedTx {\n  getTx(): SdkTransaction;\n  toBytes(): Uint8Array;\n}\n\nexport interface SdkManager {\n  getDefaultCodec(): unknown;\n  unpack<T>(bytes: Uint8Array, unpacker: SdkUnpacker<T>): T;\n  unpackTransaction(bytes: Uint8Array): SdkTransaction;\n  packCodec(serializable: SdkSerializable): Uint8Array;\n}\n\n/** A class `Manager.unpack` reads (`Utxo`, `avaxSerial.SignedTx`). */\nexport interface SdkUnpacker<T> {\n  fromBytes(bytes: Uint8Array, codec: unknown): [T, Uint8Array];\n}\n\nexport interface SdkDimensions {\n  readonly 0: number;\n  readonly 1: number;\n  readonly 2: number;\n  readonly 3: number;\n}\n\n/** avalanchejs's `Context`: what its builders need to know about the network. */\nexport interface SdkContext {\n  readonly networkID: number;\n  readonly hrp: string;\n  readonly xBlockchainID: string;\n  readonly pBlockchainID: string;\n  readonly cBlockchainID: string;\n  readonly avaxAssetID: string;\n  readonly baseTxFee: bigint;\n  readonly createAssetTxFee: bigint;\n  readonly platformFeeConfig: {\n    readonly weights: SdkDimensions;\n    readonly maxCapacity: bigint;\n    readonly maxPerSecond: bigint;\n    readonly targetPerSecond: bigint;\n    readonly minPrice: bigint;\n    readonly excessConversionConstant: bigint;\n  };\n}\n\nexport interface SdkFeeState {\n  readonly capacity: bigint;\n  readonly excess: bigint;\n  readonly price: bigint;\n  readonly timestamp: string;\n}\n\nexport interface SdkSignature extends SdkSerializable {\n  toString(): string;\n}\n\n/** The members of `@avalabs/avalanchejs` this library calls. */\nexport interface AvalancheSdk {\n  readonly Utxo: SdkUnpacker<SdkUtxo>;\n  readonly avaxSerial: {\n    readonly SignedTx: SdkUnpacker<SdkSignedTx> &\n      (new (tx: SdkTransaction, credentials: SdkSerializable[]) => SdkSignedTx);\n  };\n  readonly Credential: new (signatures: SdkSignature[]) => SdkCredential;\n  readonly Signature: new (bytes: Uint8Array) => SdkSignature;\n  readonly TransferableOutput: {\n    fromNative(\n      assetId: string,\n      amount: bigint,\n      addresses: readonly Uint8Array[],\n      locktime?: bigint,\n      threshold?: number,\n    ): SdkTransferableOutput;\n  };\n  readonly Common: {\n    createDimensions(dimensions: {\n      bandwidth: number;\n      dbRead: number;\n      dbWrite: number;\n      compute: number;\n    }): SdkDimensions;\n  };\n  readonly utils: {\n    getManagerForVM(vm: 'AVM' | 'PVM'): SdkManager;\n    getBurnedAmountByTx(tx: SdkTransaction, context: SdkContext): Map<string, bigint>;\n  };\n  readonly avm: {\n    newBaseTx(\n      context: SdkContext,\n      fromAddressesBytes: readonly Uint8Array[],\n      utxos: readonly SdkUtxo[],\n      outputs: readonly SdkTransferableOutput[],\n      options: {\n        readonly changeAddresses: readonly Uint8Array[];\n        readonly memo: Uint8Array;\n        readonly minIssuanceTime: bigint;\n      },\n    ): SdkUnsignedTx;\n  };\n  readonly pvm: {\n    newBaseTx(\n      props: {\n        readonly feeState: SdkFeeState;\n        readonly fromAddressesBytes: readonly Uint8Array[];\n        readonly changeAddressesBytes: readonly Uint8Array[];\n        readonly outputs: readonly SdkTransferableOutput[];\n        readonly utxos: readonly SdkUtxo[];\n        readonly memo: Uint8Array;\n        readonly minIssuanceTime: bigint;\n      },\n      context: SdkContext,\n    ): SdkUnsignedTx;\n    calculateFee(tx: SdkTransaction, weights: SdkDimensions, price: bigint): bigint;\n  };\n}\n\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nexport const avalanche = require('@avalabs/avalanchejs') as AvalancheSdk;\n\n/** The serializable class names the driver tells apart. */\nexport const TYPES = Object.freeze({\n  transferOutput: 'secp256k1fx.TransferOutput',\n  stakeableLockOut: 'pvm.StakeableLockOut',\n  credential: 'secp256k1fx.Credential',\n});\n"]}

package/dist/adapters/avalanche/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SDK-free types of the Avalanche family (the X-Chain and the P-Chain): the `ext.avalanche`
+ * API, fee details and overrides. Nothing here imports an SDK, so the composition root can
+ * export these types. The C-Chain is an EVM chain (`avalanche`, family `evm`), not part of
+ * this family.
+ */
+import type { CallOptions } from '../../core/transport/types';
+declare module '../../index' {
+    interface ChainRegistry {
+        'avalanche-x': {
+            family: 'avalanche';
+            network: 'mainnet' | 'fuji';
+        };
+        'avalanche-p': {
+            family: 'avalanche';
+            network: 'mainnet' | 'fuji';
+        };
+    }
+    interface FamilyRegistry {
+        avalanche: {
+            library: '@avalabs/avalanchejs';
+            ext: AvalancheExt;
+            fee: AvalancheFeeDetails;
+        };
+    }
+}
+/** Which virtual machine a chain runs: the X-Chain's AVM or the P-Chain's PlatformVM. */
+export type AvalancheVm = 'avm' | 'pvm';
+/**
+ * `FeeEstimate.details` of the `avalanche` fee kind. The X-Chain burns a fixed fee per
+ * transaction (`static`); the P-Chain prices gas since the Etna upgrade (`dynamic`). Amounts
+ * are in nAVAX (9 decimals).
+ */
+export interface AvalancheFeeDetails {
+    readonly model: 'static' | 'dynamic';
+    /** X-Chain: the network's fixed fee per transaction. */
+    readonly txFee?: bigint;
+    /** P-Chain: the gas price paid, in nAVAX per unit of gas. */
+    readonly gasPrice?: bigint;
+    /** P-Chain: the gas the transaction uses (its complexity weighed by the network). */
+    readonly gas?: bigint;
+    readonly inputs: number;
+    /** Outputs including change. */
+    readonly outputs: number;
+    /** The change paid back to the sender; `0n` when there is none. */
+    readonly change: bigint;
+}
+/**
+ * An explicit P-Chain fee (`TransferIntent.fee`): the gas price in nAVAX per unit of gas,
+ * as a bigint or a decimal integer string. The X-Chain's fee is fixed, so it takes the
+ * speeds only.
+ */
+export type AvalancheFeeOverride = {
+    readonly gasPrice: bigint | string;
+};
+/** An output an address owns, as `ext.avalanche.listUnspent` reports it. */
+export interface AvalancheUnspent {
+    /** `txID:outputIndex`, the reservation key of this output. */
+    readonly utxoId: string;
+    readonly txId: string;
+    readonly outputIndex: number;
+    /** The asset's id (cb58); AVAX is the network's `avaxAssetId`. */
+    readonly assetId: string;
+    readonly amount: bigint;
+    /** Unix seconds before which the output cannot be spent; `0n` for none. */
+    readonly locktime: bigint;
+    /** How many of the output's owners must sign. */
+    readonly threshold: number;
+    /**
+     * Whether a transfer from this address may spend it: AVAX in a plain transfer output,
+     * not locked, that this address can sign alone (threshold 1).
+     */
+    readonly spendable: boolean;
+}
+/** `bc.ext.avalanche`: the Avalanche family extension. */
+export interface AvalancheExt {
+    readonly avalanche: {
+        /** The outputs an address owns on this chain (the node's UTXO set), largest first. */
+        listUnspent(address: string): Promise<readonly AvalancheUnspent[]>;
+    };
+}
+/**
+ * The transport tags every Avalanche I/O call carries: the purpose and retry class the
+ * `ChainDriver` contract table gives each method.
+ */
+export type AvalancheCallTags = Pick<CallOptions, 'purpose' | 'retry' | 'quorum' | 'quorumKey' | 'fanout' | 'signal' | 'exactIntegers'>;

package/dist/{type/common.js → adapters/avalanche/types.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=common.js.map
+//# sourceMappingURL=types.js.map

package/dist/adapters/avalanche/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/adapters/avalanche/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * SDK-free types of the Avalanche family (the X-Chain and the P-Chain): the `ext.avalanche`\n * API, fee details and overrides. Nothing here imports an SDK, so the composition root can\n * export these types. The C-Chain is an EVM chain (`avalanche`, family `evm`), not part of\n * this family.\n */\nimport type { CallOptions } from '../../core/transport/types';\n\n// Augment the registries through the package entry, as users do with 'crypto-aio', so a\n// user's own augmentation and this one merge in any file order.\ndeclare module '../../index' {\n  interface ChainRegistry {\n    'avalanche-x': { family: 'avalanche'; network: 'mainnet' | 'fuji' };\n    'avalanche-p': { family: 'avalanche'; network: 'mainnet' | 'fuji' };\n  }\n  interface FamilyRegistry {\n    avalanche: {\n      library: '@avalabs/avalanchejs';\n      ext: AvalancheExt;\n      fee: AvalancheFeeDetails;\n    };\n  }\n}\n\n/** Which virtual machine a chain runs: the X-Chain's AVM or the P-Chain's PlatformVM. */\nexport type AvalancheVm = 'avm' | 'pvm';\n\n/**\n * `FeeEstimate.details` of the `avalanche` fee kind. The X-Chain burns a fixed fee per\n * transaction (`static`); the P-Chain prices gas since the Etna upgrade (`dynamic`). Amounts\n * are in nAVAX (9 decimals).\n */\nexport interface AvalancheFeeDetails {\n  readonly model: 'static' | 'dynamic';\n  /** X-Chain: the network's fixed fee per transaction. */\n  readonly txFee?: bigint;\n  /** P-Chain: the gas price paid, in nAVAX per unit of gas. */\n  readonly gasPrice?: bigint;\n  /** P-Chain: the gas the transaction uses (its complexity weighed by the network). */\n  readonly gas?: bigint;\n  readonly inputs: number;\n  /** Outputs including change. */\n  readonly outputs: number;\n  /** The change paid back to the sender; `0n` when there is none. */\n  readonly change: bigint;\n}\n\n/**\n * An explicit P-Chain fee (`TransferIntent.fee`): the gas price in nAVAX per unit of gas,\n * as a bigint or a decimal integer string. The X-Chain's fee is fixed, so it takes the\n * speeds only.\n */\nexport type AvalancheFeeOverride = { readonly gasPrice: bigint | string };\n\n/** An output an address owns, as `ext.avalanche.listUnspent` reports it. */\nexport interface AvalancheUnspent {\n  /** `txID:outputIndex`, the reservation key of this output. */\n  readonly utxoId: string;\n  readonly txId: string;\n  readonly outputIndex: number;\n  /** The asset's id (cb58); AVAX is the network's `avaxAssetId`. */\n  readonly assetId: string;\n  readonly amount: bigint;\n  /** Unix seconds before which the output cannot be spent; `0n` for none. */\n  readonly locktime: bigint;\n  /** How many of the output's owners must sign. */\n  readonly threshold: number;\n  /**\n   * Whether a transfer from this address may spend it: AVAX in a plain transfer output,\n   * not locked, that this address can sign alone (threshold 1).\n   */\n  readonly spendable: boolean;\n}\n\n/** `bc.ext.avalanche`: the Avalanche family extension. */\nexport interface AvalancheExt {\n  readonly avalanche: {\n    /** The outputs an address owns on this chain (the node's UTXO set), largest first. */\n    listUnspent(address: string): Promise<readonly AvalancheUnspent[]>;\n  };\n}\n\n/**\n * The transport tags every Avalanche I/O call carries: the purpose and retry class the\n * `ChainDriver` contract table gives each method.\n */\nexport type AvalancheCallTags = Pick<\n  CallOptions,\n  'purpose' | 'retry' | 'quorum' | 'quorumKey' | 'fanout' | 'signal' | 'exactIntegers'\n>;\n"]}

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

@@ -0,0 +1,11 @@
+/**
+ * Fees, funds, building, assembling, broadcasting, and same-nonce replace and cancel.
+ * One output per transfer, native or ERC-20 `transfer`.
+ */
+import type { Broadcaster, ReplacementPolicy, TxBuilder } from '../../core/driver/types';
+import { type EvmContext } from './reader';
+import type { EvmClient } from './types';
+export declare function createEvmBuilder(ctx: EvmContext): TxBuilder;
+export declare function createEvmBroadcaster(client: EvmClient, chainId: bigint): Broadcaster;
+/** Same-nonce replace and cancel under the network's bump; absent without a mempool. */
+export declare function createEvmReplacement(ctx: EvmContext): ReplacementPolicy | undefined;

package/dist/adapters/evm/builder.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvmBuilder = createEvmBuilder;
+exports.createEvmBroadcaster = createEvmBroadcaster;
+exports.createEvmReplacement = createEvmReplacement;
+const error_1 = require("../../core/errors/error");
+const asset_1 = require("../../core/model/asset");
+const bytes_1 = require("../../core/util/bytes");
+const errors_1 = require("./errors");
+const fees_1 = require("./fees");
+const network_1 = require("./network");
+const reader_1 = require("./reader");
+function transferOf(intent) {
+    if (intent.memo !== undefined) {
+        throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', 'EVM transfers carry no memo');
+    }
+    const [output] = intent.outputs;
+    if (!output || intent.outputs.length !== 1) {
+        throw new error_1.ValidationError('INVALID_INTENT', 'an EVM transfer has exactly one output');
+    }
+    if (intent.asset === 'native')
+        return { to: output.to, amount: output.amount };
+    if (intent.asset.standard !== 'erc20') {
+        throw new error_1.ValidationError('ASSET_RESOLUTION', `EVM tokens use the 'erc20' standard`);
+    }
+    return { to: output.to, amount: output.amount, token: intent.asset.contract };
+}
+/** The call a transfer makes: a value transfer, or `transfer(to, amount)` on the token. */
+function callOf(client, transfer) {
+    return transfer.token === undefined
+        ? { to: transfer.to, value: transfer.amount, data: '0x' }
+        : {
+            to: transfer.token,
+            value: 0n,
+            data: client.abi.encodeTransfer(transfer.to, transfer.amount),
+        };
+}
+function fieldsOf(ctx, call, nonce, gasLimit, params) {
+    const base = { chainId: ctx.config.chainId, nonce, gasLimit, ...call };
+    return params.type === 'eip1559'
+        ? {
+            ...base,
+            type: 'eip1559',
+            maxFeePerGas: params.maxFeePerGas,
+            maxPriorityFeePerGas: params.maxPriorityFeePerGas,
+        }
+        : { ...base, type: 'legacy', gasPrice: params.gasPrice };
+}
+function nonceOf(ordering) {
+    if (ordering?.kind !== 'nonce') {
+        throw new error_1.StateError('INVALID_TRANSITION', 'an EVM transaction needs an allocated nonce');
+    }
+    return ordering.nonce;
+}
+/**
+ * Rebuilds an unsigned transaction's fields from its ordering, summary and fee: a stored
+ * record holds plain data only, never an SDK object.
+ */
+function unsignedFields(ctx, unsigned) {
+    const { ref } = (0, asset_1.parseAssetId)(unsigned.summary.asset);
+    const [output] = unsigned.summary.outputs;
+    if (!output)
+        throw new error_1.ValidationError('INVALID_INTENT', 'the unsigned transaction has no output');
+    const transfer = {
+        to: output.to,
+        amount: BigInt(output.amount),
+        ...(ref === 'native' ? {} : { token: ref.contract }),
+    };
+    const { gasLimit, params } = (0, fees_1.feeOf)(unsigned.fee.details);
+    return fieldsOf(ctx, callOf(ctx.client, transfer), nonceOf(unsigned.ordering), gasLimit, params);
+}
+function keyOf(keys) {
+    const key = keys.find((k) => k.scheme === 'secp256k1-ecdsa');
+    if (!key)
+        throw new error_1.SigningError('SIGNER_UNAVAILABLE', 'no secp256k1 key for the sending wallet');
+    return key;
+}
+function unsignedTx(ctx, fields, fee, key, summary) {
+    const { client } = ctx;
+    return {
+        payload: { encoding: 'hex', data: client.serializeUnsigned(fields) },
+        signingRequests: [
+            {
+                id: 'r0',
+                scheme: 'secp256k1-ecdsa',
+                payload: (0, bytes_1.fromHex)(client.unsignedHash(fields)),
+                payloadKind: 'digest',
+                publicKey: key.publicKey,
+                ...(key.keyRef ? { keyRef: key.keyRef } : {}),
+            },
+        ],
+        ordering: { kind: 'nonce', nonce: fields.nonce },
+        fee,
+        summary,
+    };
+}
+async function priceFor(ctx, fee, signal) {
+    const { client, config } = ctx;
+    if (typeof fee === 'object') {
+        const { params, gasLimit } = (0, fees_1.parseFeeOverride)(fee, config.feeModel);
+        // An explicit fee above the ceiling is refused before any request.
+        (0, fees_1.assertWithinCeiling)(params, config.maxFeePerGas);
+        return { speed: 'custom', params, ...(gasLimit !== undefined ? { gasLimit } : {}) };
+    }
+    // A node's suggestion is clamped to the ceiling, so no endpoint can raise it.
+    if (config.feeModel === 'evm-legacy') {
+        const gasPrice = await client.gasPrice((0, reader_1.withSignal)(reader_1.READ, signal));
+        return {
+            speed: fee,
+            params: (0, fees_1.capPrice)((0, fees_1.legacyPrice)(gasPrice, fee), config.maxFeePerGas),
+        };
+    }
+    const history = await client.feeHistory(fees_1.FEE_HISTORY_BLOCKS, 'latest', fees_1.FEE_PERCENTILES, (0, reader_1.withSignal)(reader_1.READ, signal));
+    const { params, baseFeePerGas } = (0, fees_1.feesFromHistory)(history, fee, config.minPriorityFeePerGas);
+    return { speed: fee, params: (0, fees_1.capPrice)(params, config.maxFeePerGas), baseFeePerGas };
+}
+/** OP Stack: the oracle's L1 data fee for these exact unsigned bytes. */
+async function l1FeeFor(ctx, fields, signal) {
+    if (!ctx.config.l1DataFee)
+        return undefined;
+    const { client } = ctx;
+    const data = client.abi.encodeGetL1Fee(client.serializeUnsigned(fields));
+    const result = await client.call({ to: network_1.GAS_PRICE_ORACLE, data }, 'latest', (0, reader_1.withSignal)(reader_1.READ, signal));
+    try {
+        return client.abi.decodeUint256(result);
+    }
+    catch {
+        throw new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'the L1 fee oracle gave no fee');
+    }
+}
+async function draftFor(ctx, fields, price, signal) {
+    const l1Fee = await l1FeeFor(ctx, fields, signal);
+    return (0, fees_1.feeDraft)(price.speed, fields.gasLimit, price.params, {
+        ...(price.baseFeePerGas !== undefined ? { baseFeePerGas: price.baseFeePerGas } : {}),
+        ...(l1Fee !== undefined ? { l1Fee } : {}),
+    });
+}
+/** geth's estimate reached its gas cap: the call fails at any gas limit. */
+const GAS_ALLOWANCE = /^gas required exceeds allowance/i;
+/**
+ * The node's gas estimate; a failing call or a shortfall becomes a clear pre-signing failure.
+ * A revert, a VM execution failure or an exhausted gas allowance is the call's own
+ * failure, tested first so that a token's revert text naming "insufficient funds" still gets
+ * the balance check. Any other error is the provider's and is rethrown unchanged.
+ */
+async function estimateGas(ctx, from, transfer, signal) {
+    try {
+        return await ctx.client.estimateGas({ from, ...callOf(ctx.client, transfer) }, (0, reader_1.withSignal)(reader_1.READ, signal));
+    }
+    catch (error) {
+        const definitive = (0, error_1.isCryptoAioError)(error, 'RPC_ERROR') && !error.ambiguous;
+        const message = definitive ? String(error.details?.rpcMessage ?? error.message) : '';
+        const fails = (0, reader_1.isRevert)(error) || (0, reader_1.isExecutionFailure)(error) || GAS_ALLOWANCE.test(message);
+        if (!fails) {
+            if (/insufficient funds/i.test(message)) {
+                throw new error_1.ChainError('INSUFFICIENT_FUNDS', 'insufficient funds for this transfer');
+            }
+            throw error;
+        }
+        if (transfer.token !== undefined) {
+            const available = await (0, reader_1.erc20Balance)(ctx.client, transfer.token, from, (0, reader_1.withSignal)(reader_1.READ, signal));
+            if (available < transfer.amount) {
+                throw new error_1.ChainError('INSUFFICIENT_FUNDS', 'insufficient token balance for this transfer', {
+                    details: {
+                        required: transfer.amount.toString(),
+                        available: available.toString(),
+                    },
+                });
+            }
+        }
+        throw new error_1.ValidationError('INVALID_INTENT', 'the transfer would fail');
+    }
+}
+function createEvmBuilder(ctx) {
+    const { client } = ctx;
+    return {
+        async estimateFee(intent, build) {
+            const transfer = transferOf(intent);
+            const price = await priceFor(ctx, intent.fee, build.signal);
+            const gasLimit = price.gasLimit ??
+                (0, fees_1.gasLimitFrom)(await estimateGas(ctx, intent.from, transfer, build.signal));
+            const nonce = build.ordering?.kind === 'nonce' ? build.ordering.nonce : 0n;
+            const fields = fieldsOf(ctx, callOf(client, transfer), nonce, gasLimit, price.params);
+            return draftFor(ctx, fields, price, build.signal);
+        },
+        async checkFunds(intent, fee, build) {
+            const transfer = transferOf(intent);
+            if (transfer.token !== undefined) {
+                const available = await (0, reader_1.erc20Balance)(client, transfer.token, intent.from, (0, reader_1.withSignal)(reader_1.READ, build.signal));
+                if (available < transfer.amount) {
+                    return {
+                        ok: false,
+                        asset: { standard: 'erc20', contract: transfer.token },
+                        required: transfer.amount,
+                        available,
+                    };
+                }
+            }
+            const cost = fee.charges.reduce((sum, c) => (c.asset === 'native' ? sum + c.amount : sum), 0n);
+            const required = cost + (transfer.token === undefined ? transfer.amount : 0n);
+            const available = await client.getBalance(intent.from, 'latest', (0, reader_1.withSignal)(reader_1.READ, build.signal));
+            return available >= required
+                ? { ok: true }
+                : { ok: false, asset: 'native', required, available };
+        },
+        async build(intent, fee, build) {
+            const transfer = transferOf(intent);
+            const { gasLimit, params } = (0, fees_1.feeOf)(fee.details);
+            const model = params.type === 'eip1559' ? 'evm-1559' : 'evm-legacy';
+            if (model !== ctx.config.feeModel) {
+                throw new error_1.ValidationError('INVALID_INTENT', `this network takes ${ctx.config.feeModel} fees`);
+            }
+            // The ceiling is checked again, whatever produced the fee object.
+            (0, fees_1.assertWithinCeiling)(params, ctx.config.maxFeePerGas);
+            const fields = fieldsOf(ctx, callOf(client, transfer), nonceOf(build.ordering), gasLimit, params);
+            return unsignedTx(ctx, fields, fee, keyOf(build.keys), {
+                asset: (0, asset_1.assetId)(ctx.chain.id, ctx.network.id, intent.asset),
+                outputs: [{ to: transfer.to, amount: transfer.amount.toString() }],
+            });
+        },
+        async assemble(unsigned, signatures) {
+            const request = unsigned.signingRequests[0];
+            const signature = signatures.find((s) => s.requestId === request?.id);
+            if (!request ||
+                !signature ||
+                signature.bytes.length !== 64 ||
+                (signature.recovery !== 0 && signature.recovery !== 1)) {
+                throw new error_1.SigningError('SIGNING_FAILED', 'missing signature for request r0');
+            }
+            const mismatch = () => new error_1.SigningError('SIGNING_FAILED', 'the unsigned payload or its digest does not match its fee and summary');
+            let fields;
+            try {
+                fields = unsignedFields(ctx, unsigned);
+            }
+            catch {
+                throw mismatch();
+            }
+            // The signature must be over these fields' digest, or it signs other bytes.
+            if (client.serializeUnsigned(fields) !== unsigned.payload.data ||
+                !(0, bytes_1.equalBytes)(request.payload, (0, bytes_1.fromHex)(client.unsignedHash(fields)))) {
+                throw mismatch();
+            }
+            const { raw, hash } = client.serializeSigned(fields, {
+                r: (0, bytes_1.toHex)(signature.bytes.slice(0, 32), true),
+                s: (0, bytes_1.toHex)(signature.bytes.slice(32), true),
+                yParity: signature.recovery,
+            });
+            return {
+                raw: { encoding: 'hex', data: raw },
+                ref: { id: hash, idKind: 'tx-hash', canonical: true },
+            };
+        },
+    };
+}
+function createEvmBroadcaster(client, chainId) {
+    return {
+        async broadcast(signed, options = {}) {
+            try {
+                await client.sendRawTransaction(signed.raw.data, {
+                    purpose: 'broadcast',
+                    retry: 'ambiguous-on-failure',
+                    ...(options.fanout !== undefined ? { fanout: options.fanout } : {}),
+                    ...(options.signal ? { signal: options.signal } : {}),
+                });
+                return { kind: 'accepted' };
+            }
+            catch (error) {
+                // An ambiguous error may hide a delivered transaction; it is never classified.
+                // A rejection stands only when its reason holds for the bytes we sent.
+                if ((0, error_1.isCryptoAioError)(error, 'RPC_ERROR') && !error.ambiguous) {
+                    return (0, errors_1.classifyOwnBroadcast)(String(error.details?.rpcMessage ?? error.message), signed.raw.data, chainId);
+                }
+                throw error;
+            }
+        },
+    };
+}
+/** Same-nonce replace and cancel under the network's bump; absent without a mempool. */
+function createEvmReplacement(ctx) {
+    const { config } = ctx;
+    const bump = config.minBumpPercent;
+    if (bump === undefined)
+        return undefined;
+    const prices = config.feeModel === 'evm-legacy' ? 'the gas price' : 'the fee cap and the tip';
+    const tooLow = (what) => new error_1.ChainError('FEE_TOO_LOW', `${what} must raise ${prices} by at least ${bump}%`);
+    const keyFrom = (previous) => {
+        const request = previous.signingRequests[0];
+        if (!request)
+            throw new error_1.SigningError('SIGNER_UNAVAILABLE', 'the previous attempt has no key');
+        return {
+            scheme: request.scheme,
+            publicKey: request.publicKey,
+            ...(request.keyRef ? { keyRef: request.keyRef } : {}),
+        };
+    };
+    return {
+        replace: config.capabilities.has('replace-fee'),
+        cancel: config.capabilities.has('cancel'),
+        async buildReplacement(previous, fee, build) {
+            const before = (0, fees_1.feeOf)(previous.fee.details);
+            const price = await priceFor(ctx, fee, build.signal);
+            if (!(0, fees_1.meetsBump)(before.params, price.params, bump))
+                throw tooLow('a replacement');
+            const old = unsignedFields(ctx, previous);
+            const fields = fieldsOf(ctx, { to: old.to, value: old.value, data: old.data }, old.nonce, price.gasLimit ?? before.gasLimit, price.params);
+            return unsignedTx(ctx, fields, await draftFor(ctx, fields, price, build.signal), keyFrom(previous), previous.summary);
+        },
+        async buildCancel(previous, build, fee) {
+            const before = (0, fees_1.feeOf)(previous.fee.details);
+            const price = fee === undefined
+                ? { speed: 'custom', params: (0, fees_1.minimumBump)(before.params, bump) }
+                : await priceFor(ctx, fee, build.signal);
+            if (!(0, fees_1.meetsBump)(before.params, price.params, bump))
+                throw tooLow('a cancel');
+            // A cancel whose least bump would pay above the ceiling is refused.
+            (0, fees_1.assertWithinCeiling)(price.params, config.maxFeePerGas);
+            const nonce = nonceOf(previous.ordering);
+            const fields = fieldsOf(ctx, { to: build.from, value: 0n, data: '0x' }, nonce, price.gasLimit ?? fees_1.TRANSFER_GAS, price.params);
+            return unsignedTx(ctx, fields, await draftFor(ctx, fields, price, build.signal), keyFrom(previous), {
+                asset: (0, asset_1.assetId)(ctx.chain.id, ctx.network.id, 'native'),
+                outputs: [{ to: build.from, amount: '0' }],
+            });
+        },
+    };
+}
+//# sourceMappingURL=builder.js.map