@atomiqlabs/chain-evm 2.1.12 → 2.2.0

package/dist/evm/wallet/EVMPersistentSigner.d.ts

@@ -1,9 +1,14 @@
 import { Signer, TransactionRequest, TransactionResponse } from "ethers";
-import { EVMBlockTag } from "../chain/modules/EVMBlocks";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 import { EVMSigner } from "./EVMSigner";
+/**
+ * A robust EVM signer implementation with internal nonce management, automatic rebroadcasting and fee bumping.
+ * Uses Node.js `fs` to persist transaction data across restarts, so it is intended for backend runtimes.
+ *
+ * @category Wallets
+ */
 export declare class EVMPersistentSigner extends EVMSigner {
-    readonly safeBlockTag: EVMBlockTag;
+    private readonly safeBlockTag;
     private pendingTxs;
     private confirmedNonce;
     private pendingNonce;
@@ -23,7 +28,13 @@ export declare class EVMPersistentSigner extends EVMSigner {
     private checkPastTransactions;
     private startFeeBumper;
     private syncNonceFromChain;
+    /**
+     * @inheritDoc
+     */
     init(): Promise<void>;
+    /**
+     * @inheritDoc
+     */
     stop(): Promise<void>;
     private readonly sendTransactionQueue;
     sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;

package/dist/evm/wallet/EVMPersistentSigner.js

@@ -10,6 +10,12 @@ const fs = require("fs/promises");
 const WAIT_BEFORE_BUMP = 15 * 1000;
 const MIN_FEE_INCREASE_ABSOLUTE = 1n * 1000000000n; //1GWei
 const MIN_FEE_INCREASE_PPM = 100000n; // +10%
+/**
+ * A robust EVM signer implementation with internal nonce management, automatic rebroadcasting and fee bumping.
+ * Uses Node.js `fs` to persist transaction data across restarts, so it is intended for backend runtimes.
+ *
+ * @category Wallets
+ */
 class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
     constructor(account, address, chainInterface, directory, minFeeIncreaseAbsolute, minFeeIncreasePpm, waitBeforeBumpMillis) {
         super(account, address, true);
@@ -25,7 +31,7 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         this.minFeeIncreaseAbsolute = minFeeIncreaseAbsolute ?? MIN_FEE_INCREASE_ABSOLUTE;
         this.minFeeIncreasePpm = minFeeIncreasePpm ?? MIN_FEE_INCREASE_PPM;
         this.waitBeforeBump = waitBeforeBumpMillis ?? WAIT_BEFORE_BUMP;
-        this.safeBlockTag = chainInterface.config.safeBlockTag;
+        this.safeBlockTag = chainInterface._config.safeBlockTag;
         this.logger = (0, Utils_1.getLogger)("EVMPersistentSigner(" + address + "): ");
     }
     async load() {
@@ -179,6 +185,9 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
             this.save();
         }
     }
+    /**
+     * @inheritDoc
+     */
     async init() {
         try {
             await fs.mkdir(this.directory);
@@ -190,6 +199,9 @@ class EVMPersistentSigner extends EVMSigner_1.EVMSigner {
         await this.load();
         this.startFeeBumper();
     }
+    /**
+     * @inheritDoc
+     */
     stop() {
         this.stopped = true;
         if (this.feeBumper != null) {

package/dist/evm/wallet/EVMSigner.d.ts

@@ -1,19 +1,48 @@
 import { AbstractSigner } from "@atomiqlabs/base";
 import { Signer, TransactionRequest, TransactionResponse } from "ethers";
 /**
- * EVM signer implementation wrapping an ethers Signer
+ * EVM signer implementation wrapping an ethers {@link Signer}, for browser-based wallet use
+ *  {@link EVMBrowserSigner}.
+ *
  * @category Wallets
  */
 export declare class EVMSigner implements AbstractSigner {
+    /**
+     * A static message, which should be signed by the EVM wallets to generate reproducible entropy. Works when
+     *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+     *  same signature (same entropy).
+     */
+    private static readonly EVM_REPRODUCIBLE_ENTROPY_MESSAGE;
+    /**
+     * Returns a static message, which should be signed by the EVM wallets to generate reproducible entropy. Works when
+     *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+     *  same signature (same entropy).
+     *
+     * @param appName Application name to differentiate reproducible entropy generated across different apps
+     */
+    static getReproducibleEntropyMessage(appName: string): string;
     type: "AtomiqAbstractSigner";
     account: Signer;
     readonly address: string;
     readonly isManagingNoncesInternally: boolean;
+    /**
+     * Constructs a signer wrapping an ethers {@link Signer}.
+     *
+     * @param account
+     * @param address
+     * @param isManagingNoncesInternally
+     */
     constructor(account: Signer, address: string, isManagingNoncesInternally?: boolean);
     /**
      * @inheritDoc
      */
     getAddress(): string;
+    /**
+     * @inheritDoc
+     */
     signTransaction?(transaction: TransactionRequest): Promise<string>;
+    /**
+     * @inheritDoc
+     */
     sendTransaction(transaction: TransactionRequest, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<TransactionResponse>;
 }

package/dist/evm/wallet/EVMSigner.js

@@ -3,10 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMSigner = void 0;
 const ethers_1 = require("ethers");
 /**
- * EVM signer implementation wrapping an ethers Signer
+ * EVM signer implementation wrapping an ethers {@link Signer}, for browser-based wallet use
+ *  {@link EVMBrowserSigner}.
+ *
  * @category Wallets
  */
 class EVMSigner {
+    /**
+     * Returns a static message, which should be signed by the EVM wallets to generate reproducible entropy. Works when
+     *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+     *  same signature (same entropy).
+     *
+     * @param appName Application name to differentiate reproducible entropy generated across different apps
+     */
+    static getReproducibleEntropyMessage(appName) {
+        return EVMSigner.EVM_REPRODUCIBLE_ENTROPY_MESSAGE.replace(new RegExp("%APPNAME%", 'g'), appName);
+    }
+    /**
+     * Constructs a signer wrapping an ethers {@link Signer}.
+     *
+     * @param account
+     * @param address
+     * @param isManagingNoncesInternally
+     */
     constructor(account, address, isManagingNoncesInternally = false) {
         this.type = "AtomiqAbstractSigner";
         this.account = account;
@@ -19,9 +38,15 @@ class EVMSigner {
     getAddress() {
         return (0, ethers_1.getAddress)(this.address);
     }
+    /**
+     * @inheritDoc
+     */
     async signTransaction(transaction) {
         return this.account.signTransaction(transaction);
     }
+    /**
+     * @inheritDoc
+     */
     async sendTransaction(transaction, onBeforePublish) {
         const txResponse = await this.account.sendTransaction(transaction);
         if (onBeforePublish != null)
@@ -33,3 +58,11 @@ class EVMSigner {
     }
 }
 exports.EVMSigner = EVMSigner;
+/**
+ * A static message, which should be signed by the EVM wallets to generate reproducible entropy. Works when
+ *  wallets use signing with deterministic nonce, such that signature over the same message always yields the
+ *  same signature (same entropy).
+ */
+EVMSigner.EVM_REPRODUCIBLE_ENTROPY_MESSAGE = "Signing this messages generates a reproducible secret to be used on %APPNAME%.\n\nPLEASE DOUBLE CHECK THAT YOU" +
+    " ARE ON THE %APPNAME% WEBSITE BEFORE SIGNING THE MESSAGE, SIGNING THIS MESSAGE ON ANY OTHER WEBSITE MIGHT LEAD TO" +
+    " LOSS OF FUNDS!";

package/dist/index.d.ts

@@ -1,3 +1,73 @@
+/**
+ * # @atomiqlabs/chain-evm
+ *
+ * `@atomiqlabs/chain-evm` is the EVM integration package for the Atomiq protocol.
+ *
+ * Within the Atomiq stack, this library provides the EVM-side building blocks used for Bitcoin-aware swaps and SPV-backed vault flows on supported EVM-compatible chains. It includes:
+ *
+ * - chain initializers for Atomiq-supported EVM networks
+ * - the `EVMChainInterface` used to talk to chain RPCs
+ * - BTC relay, escrow swap, and SPV vault contract wrappers
+ * - browser and server-side EVM signer helpers
+ * - event utilities for tracking swap and vault activity
+ *
+ * This package is intended for direct protocol integrations and for higher-level Atomiq SDK layers that need EVM chain support.
+ *
+ * ## Installation
+ *
+ * Install the package with its `ethers` peer dependency:
+ *
+ * ```bash
+ * npm install @atomiqlabs/chain-evm ethers
+ * ```
+ *
+ * ## Supported Chains
+ *
+ * The package currently exports chain initializers for:
+ *
+ * - Botanix via `BotanixInitializer`
+ * - Citrea via `CitreaInitializer`
+ * - Alpen via `AlpenInitializer`
+ * - GOAT Network via `GoatInitializer`
+ *
+ * Canonical deployments currently defined in this package:
+ *
+ * | Chain | Canonical deployments included |
+ * | --- | --- |
+ * | Botanix | `MAINNET`, `TESTNET` |
+ * | Citrea | `MAINNET`, `TESTNET4` |
+ * | Alpen | `TESTNET`, `TESTNET4` |
+ * | GOAT Network | `TESTNET`, `TESTNET4` |
+ *
+ * For Alpen and GOAT Network, `MAINNET` chain types exist in the API, but default mainnet contract addresses are not populated in this package yet. In those cases, pass explicit contract addresses if you want to use non-canonical deployments.
+ *
+ * ## SDK Example
+ *
+ * Initialize the atomiq SDK with Citrea network support:
+ *
+ * ```ts
+ * import {CitreaInitializer, CitreaInitializerType} from "@atomiqlabs/chain-evm";
+ * import {BitcoinNetwork, SwapperFactory, TypedSwapper} from "@atomiqlabs/sdk";
+ *
+ * //Define chains that you want to support here
+ * const chains = [CitreaInitializer] as const;
+ * type SupportedChains = typeof chains; //It's helpful that we also get the type of the chains array
+ *
+ * const Factory = new SwapperFactory<SupportedChains>(chains); //Create swapper factory
+ *
+ * const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
+ *   chains: {
+ *     CITREA: {
+ *       rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
+ *     }
+ *   },
+ *   bitcoinNetwork: BitcoinNetwork.MAINNET //or BitcoinNetwork.TESTNET3, BitcoinNetwork.TESTNET4 - this also sets the deployment to use for EVM chains
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from "./chains/EVMOptions";
 export * from "./chains/citrea/CitreaInitializer";
 export * from "./chains/citrea/CitreaChainType";
 export * from "./chains/citrea/CitreaFees";
@@ -12,6 +82,7 @@ export { EVMBtcStoredHeader } from "./evm/btcrelay/headers/EVMBtcStoredHeader";
 export { EVMBtcRelay } from "./evm/btcrelay/EVMBtcRelay";
 export * from "./evm/chain/EVMChainInterface";
 export * from "./evm/chain/modules/EVMFees";
+export { EVMTx, SignedEVMTx } from "./evm/chain/modules/EVMTransactions";
 export * from "./evm/events/EVMChainEventsBrowser";
 export * from "./evm/providers/JsonRpcProviderWithRetries";
 export * from "./evm/providers/WebSocketProviderWithRetries";

package/dist/index.js

@@ -15,6 +15,76 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMSpvVaultData = exports.EVMSpvWithdrawalData = exports.EVMSpvVaultContract = exports.EVMBtcRelay = exports.EVMBtcStoredHeader = exports.EVMBtcHeader = void 0;
+/**
+ * # @atomiqlabs/chain-evm
+ *
+ * `@atomiqlabs/chain-evm` is the EVM integration package for the Atomiq protocol.
+ *
+ * Within the Atomiq stack, this library provides the EVM-side building blocks used for Bitcoin-aware swaps and SPV-backed vault flows on supported EVM-compatible chains. It includes:
+ *
+ * - chain initializers for Atomiq-supported EVM networks
+ * - the `EVMChainInterface` used to talk to chain RPCs
+ * - BTC relay, escrow swap, and SPV vault contract wrappers
+ * - browser and server-side EVM signer helpers
+ * - event utilities for tracking swap and vault activity
+ *
+ * This package is intended for direct protocol integrations and for higher-level Atomiq SDK layers that need EVM chain support.
+ *
+ * ## Installation
+ *
+ * Install the package with its `ethers` peer dependency:
+ *
+ * ```bash
+ * npm install @atomiqlabs/chain-evm ethers
+ * ```
+ *
+ * ## Supported Chains
+ *
+ * The package currently exports chain initializers for:
+ *
+ * - Botanix via `BotanixInitializer`
+ * - Citrea via `CitreaInitializer`
+ * - Alpen via `AlpenInitializer`
+ * - GOAT Network via `GoatInitializer`
+ *
+ * Canonical deployments currently defined in this package:
+ *
+ * | Chain | Canonical deployments included |
+ * | --- | --- |
+ * | Botanix | `MAINNET`, `TESTNET` |
+ * | Citrea | `MAINNET`, `TESTNET4` |
+ * | Alpen | `TESTNET`, `TESTNET4` |
+ * | GOAT Network | `TESTNET`, `TESTNET4` |
+ *
+ * For Alpen and GOAT Network, `MAINNET` chain types exist in the API, but default mainnet contract addresses are not populated in this package yet. In those cases, pass explicit contract addresses if you want to use non-canonical deployments.
+ *
+ * ## SDK Example
+ *
+ * Initialize the atomiq SDK with Citrea network support:
+ *
+ * ```ts
+ * import {CitreaInitializer, CitreaInitializerType} from "@atomiqlabs/chain-evm";
+ * import {BitcoinNetwork, SwapperFactory, TypedSwapper} from "@atomiqlabs/sdk";
+ *
+ * //Define chains that you want to support here
+ * const chains = [CitreaInitializer] as const;
+ * type SupportedChains = typeof chains; //It's helpful that we also get the type of the chains array
+ *
+ * const Factory = new SwapperFactory<SupportedChains>(chains); //Create swapper factory
+ *
+ * const swapper: TypedSwapper<SupportedChains> = Factory.newSwapper({
+ *   chains: {
+ *     CITREA: {
+ *       rpcUrl: citreaRpc, //You can also pass JsonApiProvider object here
+ *     }
+ *   },
+ *   bitcoinNetwork: BitcoinNetwork.MAINNET //or BitcoinNetwork.TESTNET3, BitcoinNetwork.TESTNET4 - this also sets the deployment to use for EVM chains
+ * });
+ * ```
+ *
+ * @packageDocumentation
+ */
+__exportStar(require("./chains/EVMOptions"), exports);
 __exportStar(require("./chains/citrea/CitreaInitializer"), exports);
 __exportStar(require("./chains/citrea/CitreaChainType"), exports);
 __exportStar(require("./chains/citrea/CitreaFees"), exports);

package/dist/node/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Node.js-only entrypoint for filesystem-backed EVM helpers.
+ *
+ * Import from `@atomiqlabs/chain-evm/node` when you need runtime features
+ * that depend on Node's `fs` module.
+ *
+ * @packageDocumentation
+ */
+export { EVMChainEvents } from "../evm/events/EVMChainEvents";
+export { EVMPersistentSigner } from "../evm/wallet/EVMPersistentSigner";

package/dist/node/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMPersistentSigner = exports.EVMChainEvents = void 0;
+/**
+ * Node.js-only entrypoint for filesystem-backed EVM helpers.
+ *
+ * Import from `@atomiqlabs/chain-evm/node` when you need runtime features
+ * that depend on Node's `fs` module.
+ *
+ * @packageDocumentation
+ */
+var EVMChainEvents_1 = require("../evm/events/EVMChainEvents");
+Object.defineProperty(exports, "EVMChainEvents", { enumerable: true, get: function () { return EVMChainEvents_1.EVMChainEvents; } });
+var EVMPersistentSigner_1 = require("../evm/wallet/EVMPersistentSigner");
+Object.defineProperty(exports, "EVMPersistentSigner", { enumerable: true, get: function () { return EVMPersistentSigner_1.EVMPersistentSigner; } });

package/dist/utils/Utils.d.ts

@@ -1,19 +1,69 @@
+/**
+ * Logger interface used across EVM modules.
+ *
+ * @category Internal/Utils
+ */
 export type LoggerType = {
     debug: (msg: string, ...args: any[]) => void;
     info: (msg: string, ...args: any[]) => void;
     warn: (msg: string, ...args: any[]) => void;
     error: (msg: string, ...args: any[]) => void;
 };
+/**
+ * Returns a promise that resolves after `timeoutMillis` unless aborted first.
+ *
+ * @category Internal/Utils
+ */
 export declare function timeoutPromise(timeoutMillis: number, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * Wraps an async executor so it runs once at a time and reuses the same promise.
+ *
+ * @category Internal/Utils
+ */
 export declare function onceAsync<T>(executor: () => Promise<T>): () => Promise<T>;
+/**
+ * Creates a prefixed logger that honors the global `atomiqLogLevel`.
+ *
+ * @category Internal/Utils
+ */
 export declare function getLogger(prefix: string): LoggerType;
+/**
+ * Retries an async function using the provided retry policy.
+ *
+ * @category Internal/Utils
+ */
 export declare function tryWithRetries<T>(func: () => Promise<T>, retryPolicy?: {
     maxRetries?: number;
     delay?: number;
     exponential?: boolean;
 }, errorAllowed?: (e: any) => boolean, abortSignal?: AbortSignal): Promise<T>;
+/**
+ * Reverses byte order of a 32-bit unsigned integer.
+ *
+ * @category Internal/Utils
+ */
 export declare function uint32ReverseEndianness(value: number): number;
+/**
+ * Returns the greater of two bigint values.
+ *
+ * @category Internal/Utils
+ */
 export declare function bigIntMax(a: bigint, b: bigint): bigint;
+/**
+ * Ethers.js error codes considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 export declare const allowedEthersErrorCodes: Set<string>;
+/**
+ * JSON-RPC error numbers considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 export declare const allowedEthersErrorNumbers: Set<number>;
+/**
+ * RPC error messages considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 export declare const allowedEthersErrorMessages: Set<string>;

package/dist/utils/Utils.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.allowedEthersErrorMessages = exports.allowedEthersErrorNumbers = exports.allowedEthersErrorCodes = exports.bigIntMax = exports.uint32ReverseEndianness = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
+/**
+ * Returns a promise that resolves after `timeoutMillis` unless aborted first.
+ *
+ * @category Internal/Utils
+ */
 function timeoutPromise(timeoutMillis, abortSignal) {
     return new Promise((resolve, reject) => {
         const timeout = setTimeout(resolve, timeoutMillis);
@@ -12,6 +17,11 @@ function timeoutPromise(timeoutMillis, abortSignal) {
     });
 }
 exports.timeoutPromise = timeoutPromise;
+/**
+ * Wraps an async executor so it runs once at a time and reuses the same promise.
+ *
+ * @category Internal/Utils
+ */
 function onceAsync(executor) {
     let promise;
     return () => {
@@ -25,6 +35,11 @@ function onceAsync(executor) {
     };
 }
 exports.onceAsync = onceAsync;
+/**
+ * Creates a prefixed logger that honors the global `atomiqLogLevel`.
+ *
+ * @category Internal/Utils
+ */
 function getLogger(prefix) {
     return {
         debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
@@ -35,6 +50,11 @@ function getLogger(prefix) {
 }
 exports.getLogger = getLogger;
 const logger = getLogger("Utils: ");
+/**
+ * Retries an async function using the provided retry policy.
+ *
+ * @category Internal/Utils
+ */
 async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
     retryPolicy = retryPolicy || {};
     retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
@@ -61,6 +81,11 @@ async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
     throw err;
 }
 exports.tryWithRetries = tryWithRetries;
+/**
+ * Reverses byte order of a 32-bit unsigned integer.
+ *
+ * @category Internal/Utils
+ */
 function uint32ReverseEndianness(value) {
     const valueBN = BigInt(value);
     return Number(((valueBN & 0xffn) << 24n) |
@@ -69,16 +94,31 @@ function uint32ReverseEndianness(value) {
         ((valueBN >> 24n) & 0xffn));
 }
 exports.uint32ReverseEndianness = uint32ReverseEndianness;
+/**
+ * Returns the greater of two bigint values.
+ *
+ * @category Internal/Utils
+ */
 function bigIntMax(a, b) {
     return a > b ? a : b;
 }
 exports.bigIntMax = bigIntMax;
+/**
+ * Ethers.js error codes considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 exports.allowedEthersErrorCodes = new Set([
     "NOT_IMPLEMENTED", "UNSUPPORTED_OPERATION", "BAD_DATA",
     "NUMERIC_FAULT",
     "INVALID_ARGUMENT", "MISSING_ARGUMENT", "UNEXPECTED_ARGUMENT", "VALUE_MISMATCH",
     "CALL_EXCEPTION", "NONCE_EXPIRED", "REPLACEMENT_UNDERPRICED", "TRANSACTION_REPLACED", "UNCONFIGURED_NAME", "OFFCHAIN_FAULT", "ACTION_REJECTED"
 ]);
+/**
+ * JSON-RPC error numbers considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 exports.allowedEthersErrorNumbers = new Set([
     3,
     -32700,
@@ -94,6 +134,11 @@ exports.allowedEthersErrorNumbers = new Set([
     // -32005, //Limit exceeded
     -32006 //JSON-RPC version not supported
 ]);
+/**
+ * RPC error messages considered recoverable for retry logic.
+ *
+ * @category Internal/Utils
+ */
 exports.allowedEthersErrorMessages = new Set([
     "already known"
 ]);

package/node/index.d.ts

@@ -0,0 +1 @@
+export * from "../dist/node";

package/node/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("../dist/node");

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "2.1.12",
+  "version": "2.2.0",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
   "scripts": {
+    "build": "npx -y -p typescript@4.9 tsc",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build:ts4": "npx -p typescript@4.9 tsc --noEmit",
     "build:ts5": "npx -p typescript@5.3 tsc --noEmit"
   },
   "files": [
     "/dist",
-    "/src"
+    "/src",
+    "/node"
   ],
   "keywords": [
     "EVM",
@@ -25,7 +27,7 @@
   "author": "adambor",
   "license": "Apache-2.0",
   "dependencies": {
-    "@atomiqlabs/base": "^13.1.9",
+    "@atomiqlabs/base": "^13.2.0",
     "@noble/hashes": "^1.8.0",
     "@scure/btc-signer": "^1.6.0",
     "buffer": "6.0.3",

package/src/chains/EVMOptions.ts

@@ -0,0 +1,70 @@
+import {JsonRpcApiProvider} from "ethers";
+import {EVMConfiguration, EVMRetryPolicy} from "../evm/chain/EVMChainInterface";
+import {ChainSwapType} from "@atomiqlabs/base";
+import {EVMFees} from "../evm/chain/modules/EVMFees";
+
+/**
+ * Generic options for an EVM chain
+ *
+ * @category Chain Interface
+ */
+export type EVMOptions<C extends string, F extends EVMFees = EVMFees> = {
+  /**
+   * EVM RPC URL or {@link JsonRpcApiProvider} object to use for EVM network access
+   */
+  rpcUrl: string | JsonRpcApiProvider,
+  /**
+   * Retry policy for the RPC calls
+   */
+  retryPolicy?: EVMRetryPolicy,
+  /**
+   * Network type for the EVM chain
+   */
+  chainType?: C,
+
+  /**
+   * Contract address of the Escrow Manager contract, uses canonical deployment by default
+   */
+  swapContract?: string,
+  /**
+   * Optional Escrow Manager contract deployment height, which acts as genesis when querying events
+   */
+  swapContractDeploymentHeight?: number,
+  /**
+   * Contract address of the BTC Relay contract, uses canonical deployment by default
+   */
+  btcRelayContract?: string,
+  /**
+   * Optional BTC Relay contract deployment height, which acts as genesis when querying events
+   */
+  btcRelayDeploymentHeight?: number,
+  /**
+   * Contract address of the UTXO-controlled vault (SPV Vault manager) contract, uses canonical deployment by default
+   */
+  spvVaultContract?: string,
+  /**
+   * Optional UTXO-controlled vault (SPV Vault manager) contract deployment height, which acts as genesis when querying events
+   */
+  spvVaultDeploymentHeight?: number,
+  /**
+   * Contract addresses of the refund and claim handlers, uses canonical deployment by default
+   */
+  handlerContracts?: {
+    refund?: {
+      timelock?: string
+    },
+    claim?: {
+      [type in ChainSwapType]?: string
+    }
+  }
+
+  /**
+   * EVM network fee API
+   */
+  fees?: F,
+
+  /**
+   * EVM configuration
+   */
+  evmConfig?: Partial<Omit<EVMConfiguration, "safeBlockTag" | "finalizedBlockTag" | "finalityCheckStrategy">>
+}