@atomiqlabs/chain-evm 1.0.0-dev.22

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./evm/btcrelay/headers/EVMBtcHeader"), exports);
+__exportStar(require("./evm/btcrelay/headers/EVMBtcStoredHeader"), exports);
+__exportStar(require("./evm/btcrelay/EVMBtcRelay"), exports);
+__exportStar(require("./evm/chain/EVMChainInterface"), exports);
+__exportStar(require("./evm/chain/EVMModule"), exports);
+__exportStar(require("./evm/chain/modules/EVMAddresses"), exports);
+__exportStar(require("./evm/chain/modules/EVMBlocks"), exports);
+__exportStar(require("./evm/chain/modules/EVMEvents"), exports);
+__exportStar(require("./evm/chain/modules/EVMFees"), exports);
+__exportStar(require("./evm/chain/modules/EVMSignatures"), exports);
+__exportStar(require("./evm/chain/modules/EVMTokens"), exports);
+__exportStar(require("./evm/chain/modules/EVMTransactions"), exports);
+__exportStar(require("./evm/contract/modules/EVMContractEvents"), exports);
+__exportStar(require("./evm/contract/EVMContractBase"), exports);
+__exportStar(require("./evm/contract/EVMContractModule"), exports);
+__exportStar(require("./evm/events/EVMChainEventsBrowser"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvVaultContract"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvWithdrawalData"), exports);
+__exportStar(require("./evm/spv_swap/EVMSpvVaultData"), exports);
+__exportStar(require("./evm/swaps/EVMSwapContract"), exports);
+__exportStar(require("./evm/swaps/EVMSwapData"), exports);
+__exportStar(require("./evm/swaps/EVMSwapModule"), exports);
+__exportStar(require("./evm/swaps/modules/EVMLpVault"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapInit"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapClaim"), exports);
+__exportStar(require("./evm/swaps/modules/EVMSwapRefund"), exports);
+__exportStar(require("./evm/swaps/handlers/IHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/refund/TimelockRefundHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/ClaimHandlers"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/HashlockClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/IBitcoinClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler"), exports);
+__exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler"), exports);
+__exportStar(require("./evm/wallet/EVMSigner"), exports);
+__exportStar(require("./chains/citrea/CitreaInitializer"), exports);
+__exportStar(require("./chains/citrea/CitreaChainType"), exports);

package/dist/utils/Utils.d.ts

@@ -0,0 +1,15 @@
+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;
+};
+export declare function timeoutPromise(timeoutMillis: number, abortSignal?: AbortSignal): Promise<void>;
+export declare function onceAsync<T>(executor: () => Promise<T>): () => Promise<T>;
+export declare function getLogger(prefix: string): LoggerType;
+export declare function tryWithRetries<T>(func: () => Promise<T>, retryPolicy?: {
+    maxRetries?: number;
+    delay?: number;
+    exponential?: boolean;
+}, errorAllowed?: (e: any) => boolean, abortSignal?: AbortSignal): Promise<T>;
+export declare function uint32ReverseEndianness(value: number): number;

package/dist/utils/Utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint32ReverseEndianness = exports.tryWithRetries = exports.getLogger = exports.onceAsync = exports.timeoutPromise = void 0;
+function timeoutPromise(timeoutMillis, abortSignal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, timeoutMillis);
+        if (abortSignal != null)
+            abortSignal.addEventListener("abort", () => {
+                clearTimeout(timeout);
+                reject(new Error("Aborted"));
+            });
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+function onceAsync(executor) {
+    let promise;
+    return () => {
+        if (promise == null) {
+            promise = executor();
+            return promise;
+        }
+        else {
+            return promise.catch(() => promise = executor());
+        }
+    };
+}
+exports.onceAsync = onceAsync;
+function getLogger(prefix) {
+    return {
+        debug: (msg, ...args) => global.atomiqLogLevel >= 3 && console.debug(prefix + msg, ...args),
+        info: (msg, ...args) => global.atomiqLogLevel >= 2 && console.info(prefix + msg, ...args),
+        warn: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 1) && console.warn(prefix + msg, ...args),
+        error: (msg, ...args) => (global.atomiqLogLevel == null || global.atomiqLogLevel >= 0) && console.error(prefix + msg, ...args)
+    };
+}
+exports.getLogger = getLogger;
+const logger = getLogger("Utils: ");
+async function tryWithRetries(func, retryPolicy, errorAllowed, abortSignal) {
+    retryPolicy = retryPolicy || {};
+    retryPolicy.maxRetries = retryPolicy.maxRetries || 5;
+    retryPolicy.delay = retryPolicy.delay || 500;
+    retryPolicy.exponential = retryPolicy.exponential == null ? true : retryPolicy.exponential;
+    let err = null;
+    for (let i = 0; i < retryPolicy.maxRetries; i++) {
+        try {
+            const resp = await func();
+            return resp;
+        }
+        catch (e) {
+            if (errorAllowed != null && errorAllowed(e))
+                throw e;
+            err = e;
+            logger.error("tryWithRetries(): error on try number: " + i, e);
+        }
+        if (abortSignal != null && abortSignal.aborted)
+            throw new Error("Aborted");
+        if (i !== retryPolicy.maxRetries - 1) {
+            await timeoutPromise(retryPolicy.exponential ? retryPolicy.delay * Math.pow(2, i) : retryPolicy.delay, abortSignal);
+        }
+    }
+    throw err;
+}
+exports.tryWithRetries = tryWithRetries;
+function uint32ReverseEndianness(value) {
+    const valueBN = BigInt(value);
+    return Number(((valueBN & 0xffn) << 24n) |
+        ((valueBN & 0xff00n) << 8n) |
+        ((valueBN >> 8n) & 0xff00n) |
+        ((valueBN >> 24n) & 0xffn));
+}
+exports.uint32ReverseEndianness = uint32ReverseEndianness;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@atomiqlabs/chain-evm",
+  "version": "1.0.0-dev.22",
+  "description": "EVM specific base implementation",
+  "main": "./dist/index.js",
+  "types:": "./dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "/dist",
+    "/src"
+  ],
+  "keywords": [
+    "EVM",
+    "Ethereum",
+    "Bitcoin",
+    "Cross-chain",
+    "Cryptocurrency",
+    "Bridge",
+    "Trustless"
+  ],
+  "author": "adambor",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@atomiqlabs/base": "^10.0.0-dev.1",
+    "@noble/hashes": "^1.8.0",
+    "@scure/btc-signer": "1.6.0",
+    "buffer": "6.0.3"
+  },
+  "peerDependencies": {
+    "ethers": "^6.15.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  }
+}

package/src/chains/citrea/CitreaChainType.ts

@@ -0,0 +1,28 @@
+import {ChainType} from "@atomiqlabs/base";
+import {EVMPreFetchVerification} from "../../evm/swaps/modules/EVMSwapInit";
+import {EVMTx} from "../../evm/chain/modules/EVMTransactions";
+import {EVMSigner} from "../../evm/wallet/EVMSigner";
+import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
+import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
+import {EVMChainInterface} from "../../evm/chain/EVMChainInterface";
+import {EVMChainEventsBrowser} from "../../evm/events/EVMChainEventsBrowser";
+import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
+import { EVMSpvVaultData } from "../../evm/spv_swap/EVMSpvVaultData";
+import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
+import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
+
+export type CitreaChainType = ChainType<
+    "CITREA",
+    never,
+    EVMPreFetchVerification,
+    EVMTx,
+    EVMSigner,
+    EVMSwapData,
+    EVMSwapContract<"CITREA">,
+    EVMChainInterface<"CITREA", 5115>,
+    EVMChainEventsBrowser,
+    EVMBtcRelay<any>,
+    EVMSpvVaultData,
+    EVMSpvWithdrawalData,
+    EVMSpvVaultContract<"CITREA">
+>;

package/src/chains/citrea/CitreaInitializer.ts

@@ -0,0 +1,167 @@
+import {BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType} from "@atomiqlabs/base";
+import {JsonRpcApiProvider, JsonRpcProvider} from "ethers";
+import {EVMChainInterface, EVMRetryPolicy} from "../../evm/chain/EVMChainInterface";
+import {EVMFees} from "../../evm/chain/modules/EVMFees";
+import {CitreaChainType} from "./CitreaChainType";
+import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
+import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
+import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
+import {EVMChainEventsBrowser} from "../../evm/events/EVMChainEventsBrowser";
+import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
+import {EVMSpvVaultData} from "../../evm/spv_swap/EVMSpvVaultData";
+import {EVMSpvWithdrawalData} from "../../evm/spv_swap/EVMSpvWithdrawalData";
+
+const CitreaChainIds = {
+    MAINNET: null,
+    TESTNET4: 5115
+};
+
+const CitreaContractAddresses = {
+    MAINNET: {
+        executionContract: "",
+        swapContract: "",
+        btcRelayContract: "",
+        btcRelayDeploymentHeight: 0,
+        spvVaultContract: "",
+        spvVaultDeploymentHeight: 0,
+        handlerContracts: {
+            refund: {
+                timelock: ""
+            },
+            claim: {
+                [ChainSwapType.HTLC]: "",
+                [ChainSwapType.CHAIN_TXID]: "",
+                [ChainSwapType.CHAIN]: "",
+                [ChainSwapType.CHAIN_NONCED]: ""
+            }
+        }
+    },
+    TESTNET4: {
+        executionContract: "0x9e289512965A0842b342A6BB3F3c41F22a555Cfe",
+        swapContract: "0xBbf7755b674dD107d59F0650D1A3fA9C60bf6Fe6",
+        btcRelayContract: "0xfd0FbA128244f502678251b07dEa0fb4EcE959F3",
+        btcRelayDeploymentHeight: 12346223,
+        spvVaultContract: "0x9Bf990C6088F716279797a602b05941c40591533",
+        spvVaultDeploymentHeight: 12346223,
+        handlerContracts: {
+            refund: {
+                timelock: "0x4699450973c21d6Fe09e36A8A475EaE4D78a3137"
+            },
+            claim: {
+                [ChainSwapType.HTLC]: "0x1120e1Eb3049148AeBEe497331774BfE1f6c174D",
+                [ChainSwapType.CHAIN_TXID]: "0xf61D1da542111216337FeEA5586022130D468842",
+                [ChainSwapType.CHAIN]: "0xBe8C784b03F0c6d54aC35a4D41bd6CF2EDb6e012",
+                [ChainSwapType.CHAIN_NONCED]: "0x65faec5DC334bf2005eC2DFcf012da87a832f1F0"
+            }
+        }
+    }
+};
+
+export type CitreaAssetsType = BaseTokenType<"CBTC">;
+export const CitreaAssets: CitreaAssetsType = {
+    CBTC: {
+        address: "0x0000000000000000000000000000000000000000",
+        decimals: 18,
+        displayDecimals: 8
+    }
+} as const;
+
+export type CitreaOptions = {
+    rpcUrl: string | JsonRpcApiProvider,
+    retryPolicy?: EVMRetryPolicy,
+    chainType?: "MAINNET" | "TESTNET4",
+    maxLogsBlockRange?: number,
+
+    swapContract?: string,
+    btcRelayContract?: string,
+    btcRelayDeploymentHeight?: number,
+    spvVaultContract?: string,
+    spvVaultDeploymentHeight?: number,
+    handlerContracts?: {
+        refund?: {
+            timelock?: string
+        },
+        claim?: {
+            [type in ChainSwapType]?: string
+        }
+    }
+
+    fees?: EVMFees
+}
+
+export function initializeCitrea(
+    options: CitreaOptions,
+    bitcoinRpc: BitcoinRpc<any>,
+    network: BitcoinNetwork
+): ChainData<CitreaChainType> {
+    if(options.chainType==null) {
+        switch (network) {
+            case BitcoinNetwork.TESTNET4:
+                options.chainType = "TESTNET4";
+                break;
+            case BitcoinNetwork.MAINNET:
+                options.chainType = "MAINNET";
+                break;
+        }
+    }
+
+    const defaultContractAddresses = CitreaContractAddresses[options.chainType];
+    const chainId = CitreaChainIds[options.chainType];
+
+    const provider = typeof(options.rpcUrl)==="string" ?
+        new JsonRpcProvider(options.rpcUrl, {name: "Citrea", chainId}) :
+        options.rpcUrl;
+
+    const Fees = options.fees ?? new EVMFees(provider, 2n * 1_000_000_000n, 1_000_000n);
+
+    const chainInterface = new EVMChainInterface("CITREA", chainId, provider, {
+        safeBlockTag: "latest",
+        maxLogsBlockRange: options.maxLogsBlockRange ?? 500
+    }, options.retryPolicy, Fees);
+
+    const btcRelay = new EVMBtcRelay(
+        chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract,
+        options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight
+    );
+
+    const swapContract = new EVMSwapContract(
+        chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {
+            refund: {
+                ...defaultContractAddresses.handlerContracts.refund,
+                ...options?.handlerContracts?.refund
+            },
+            claim: {
+                ...defaultContractAddresses.handlerContracts.claim,
+                ...options?.handlerContracts?.claim
+            }
+        }
+    );
+
+    const spvVaultContract = new EVMSpvVaultContract(
+        chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract,
+        options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
+    )
+
+    const chainEvents = new EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
+
+    return {
+        chainId: "CITREA",
+        btcRelay,
+        chainInterface,
+        swapContract,
+        chainEvents,
+        swapDataConstructor: EVMSwapData,
+        spvVaultContract,
+        spvVaultDataConstructor: EVMSpvVaultData,
+        spvVaultWithdrawalDataConstructor: EVMSpvWithdrawalData
+    }
+};
+
+export type CitreaInitializerType = ChainInitializer<CitreaOptions, CitreaChainType, CitreaAssetsType>;
+export const CitreaInitializer: CitreaInitializerType = {
+    chainId: "CITREA",
+    chainType: null as CitreaChainType,
+    initializer: initializeCitrea,
+    tokens: CitreaAssets,
+    options: null as CitreaOptions
+} as const;

package/src/evm/btcrelay/BtcRelayAbi.ts

@@ -0,0 +1,258 @@
+export const BtcRelayAbi = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "bytes32[5]",
+                        "name": "data",
+                        "type": "bytes32[5]"
+                    }
+                ],
+                "internalType": "struct StoredBlockHeader",
+                "name": "storedHeader",
+                "type": "tuple"
+            },
+            {
+                "internalType": "bool",
+                "name": "clampBlockTarget",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            },
+            {
+                "indexed": false,
+                "internalType": "address",
+                "name": "submitter",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "uint256",
+                "name": "startHeight",
+                "type": "uint256"
+            }
+        ],
+        "name": "ChainReorg",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            }
+        ],
+        "name": "StoreForkHeader",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "commitHash",
+                "type": "bytes32"
+            },
+            {
+                "indexed": true,
+                "internalType": "bytes32",
+                "name": "blockHash",
+                "type": "bytes32"
+            }
+        ],
+        "name": "StoreHeader",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "getBlockheight",
+        "outputs": [
+            {
+                "internalType": "uint32",
+                "name": "blockheight",
+                "type": "uint32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getChainwork",
+        "outputs": [
+            {
+                "internalType": "uint224",
+                "name": "chainWork",
+                "type": "uint224"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "height",
+                "type": "uint256"
+            }
+        ],
+        "name": "getCommitHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getTipCommitHash",
+        "outputs": [
+            {
+                "internalType": "bytes32",
+                "name": "",
+                "type": "bytes32"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "forkId",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitForkBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitMainBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "data",
+                "type": "bytes"
+            }
+        ],
+        "name": "submitShortForkBlockheaders",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {
+                        "internalType": "bytes32[5]",
+                        "name": "data",
+                        "type": "bytes32[5]"
+                    }
+                ],
+                "internalType": "struct StoredBlockHeader",
+                "name": "storedHeader",
+                "type": "tuple"
+            }
+        ],
+        "name": "verifyBlockheader",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "confirmations",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "height",
+                "type": "uint256"
+            },
+            {
+                "internalType": "bytes32",
+                "name": "commitmentHash",
+                "type": "bytes32"
+            }
+        ],
+        "name": "verifyBlockheaderHash",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "confirmations",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+] as const;