@atomiqlabs/chain-evm 1.0.0-dev.22 → 1.0.0-dev.28

package/dist/chains/citrea/CitreaBtcRelay.d.ts

@@ -0,0 +1,21 @@
+import { EVMBtcRelay } from "../../evm/btcrelay/EVMBtcRelay";
+import { BtcBlock } from "@atomiqlabs/base";
+export declare class CitreaBtcRelay<B extends BtcBlock> extends EVMBtcRelay<B> {
+    static StateDiffSize: {
+        STATE_DIFF_PER_BLOCKHEADER: number;
+        STATE_DIFF_BASE: number;
+    };
+    /**
+     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
+     *
+     * @param requiredBlockheight
+     * @param feeRate
+     */
+    estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
+    /**
+     * Returns fee required (in native token) to synchronize a single block to btc relay
+     *
+     * @param feeRate
+     */
+    getFeePerBlock(feeRate?: string): Promise<bigint>;
+}

package/dist/chains/citrea/CitreaBtcRelay.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitreaBtcRelay = void 0;
+const EVMBtcRelay_1 = require("../../evm/btcrelay/EVMBtcRelay");
+const Utils_1 = require("../../utils/Utils");
+const CitreaFees_1 = require("./CitreaFees");
+const logger = (0, Utils_1.getLogger)("CitreaBtcRelay: ");
+class CitreaBtcRelay extends EVMBtcRelay_1.EVMBtcRelay {
+    /**
+     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
+     *
+     * @param requiredBlockheight
+     * @param feeRate
+     */
+    async estimateSynchronizeFee(requiredBlockheight, feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tipData = await this.getTipData();
+        const currBlockheight = tipData.blockheight;
+        const blockheightDelta = requiredBlockheight - currBlockheight;
+        if (blockheightDelta <= 0)
+            return 0n;
+        const numTxs = Math.ceil(blockheightDelta / this.maxHeadersPerTx);
+        const synchronizationFee = (BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate))
+            + CitreaFees_1.CitreaFees.getGasFee(EVMBtcRelay_1.EVMBtcRelay.GasCosts.GAS_BASE_MAIN * numTxs, feeRate, CitreaBtcRelay.StateDiffSize.STATE_DIFF_BASE * numTxs);
+        logger.debug("estimateSynchronizeFee(): required blockheight: " + requiredBlockheight +
+            " blockheight delta: " + blockheightDelta + " fee: " + synchronizationFee.toString(10));
+        return synchronizationFee;
+    }
+    /**
+     * Returns fee required (in native token) to synchronize a single block to btc relay
+     *
+     * @param feeRate
+     */
+    async getFeePerBlock(feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        return CitreaFees_1.CitreaFees.getGasFee(EVMBtcRelay_1.EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER, feeRate, CitreaBtcRelay.StateDiffSize.STATE_DIFF_PER_BLOCKHEADER);
+    }
+}
+exports.CitreaBtcRelay = CitreaBtcRelay;
+CitreaBtcRelay.StateDiffSize = {
+    STATE_DIFF_PER_BLOCKHEADER: 22,
+    STATE_DIFF_BASE: 30
+};

package/dist/chains/citrea/CitreaChainType.d.ts

@@ -3,11 +3,11 @@ 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">>;
+import { CitreaSwapContract } from "./CitreaSwapContract";
+import { CitreaBtcRelay } from "./CitreaBtcRelay";
+import { CitreaSpvVaultContract } from "./CitreaSpvVaultContract";
+export type CitreaChainType = ChainType<"CITREA", never, EVMPreFetchVerification, EVMTx, EVMSigner, EVMSwapData, CitreaSwapContract, EVMChainInterface<"CITREA", 5115>, EVMChainEventsBrowser, CitreaBtcRelay<any>, EVMSpvVaultData, EVMSpvWithdrawalData, CitreaSpvVaultContract>;

package/dist/chains/citrea/CitreaFees.d.ts

@@ -0,0 +1,29 @@
+import { EVMFees } from "../../evm/chain/modules/EVMFees";
+export declare class CitreaFees extends EVMFees {
+    static readonly StateDiffSize: {
+        APPROVE_DIFF_SIZE: number;
+    };
+    protected readonly logger: import("../../utils/Utils").LoggerType;
+    private _blockFeeCache;
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    private __getFeeRate;
+    /**
+     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @private
+     */
+    getFeeRate(): Promise<string>;
+    /**
+     * Calculates the total gas fee paid for a given gas limit and state diff size at a given fee rate
+     *
+     * @param gas
+     * @param stateDiffSize
+     * @param feeRate
+     */
+    static getGasFee(gas: number, feeRate: string, stateDiffSize?: number): bigint;
+}

package/dist/chains/citrea/CitreaFees.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitreaFees = void 0;
+const EVMFees_1 = require("../../evm/chain/modules/EVMFees");
+const Utils_1 = require("../../utils/Utils");
+class CitreaFees extends EVMFees_1.EVMFees {
+    constructor() {
+        super(...arguments);
+        this.logger = (0, Utils_1.getLogger)("CitreaFees: ");
+        this._blockFeeCache = null;
+    }
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    async __getFeeRate() {
+        const res = await this.provider.send("eth_getBlockByNumber", ["latest", false]);
+        const l1Fee = BigInt(res.l1FeeRate);
+        const baseFee = BigInt(res.baseFeePerGas) * this.feeMultiplierPPM / 1000000n;
+        this.logger.debug("__getFeeRate(): Base fee rate: " + baseFee.toString(10) + ", l1 fee rate: " + l1Fee.toString(10));
+        return { baseFee, l1Fee };
+    }
+    /**
+     * Gets the gas price with caching, format: <gas price in Wei>;<transaction version: v1/v3>
+     *
+     * @private
+     */
+    async getFeeRate() {
+        if (this._blockFeeCache == null || Date.now() - this._blockFeeCache.timestamp > this.MAX_FEE_AGE) {
+            let obj = {
+                timestamp: Date.now(),
+                feeRate: null
+            };
+            obj.feeRate = this.__getFeeRate().catch(e => {
+                if (this._blockFeeCache === obj)
+                    this._blockFeeCache = null;
+                throw e;
+            });
+            this._blockFeeCache = obj;
+        }
+        let { baseFee, l1Fee } = await this._blockFeeCache.feeRate;
+        if (baseFee > this.maxFeeRatePerGas)
+            baseFee = this.maxFeeRatePerGas;
+        const fee = baseFee.toString(10) + "," + this.priorityFee.toString(10) + "," + l1Fee.toString(10);
+        this.logger.debug("getFeeRate(): calculated fee: " + fee);
+        return fee;
+    }
+    /**
+     * Calculates the total gas fee paid for a given gas limit and state diff size at a given fee rate
+     *
+     * @param gas
+     * @param stateDiffSize
+     * @param feeRate
+     */
+    static getGasFee(gas, feeRate, stateDiffSize = 0) {
+        if (feeRate == null)
+            return 0n;
+        const [maxFee, priorityFee, l1StateDiffFee] = feeRate.split(",");
+        return (BigInt(gas) * BigInt(maxFee)) + (BigInt(stateDiffSize) * BigInt(l1StateDiffFee ?? 0n));
+    }
+}
+exports.CitreaFees = CitreaFees;
+CitreaFees.StateDiffSize = {
+    APPROVE_DIFF_SIZE: 40,
+};

package/dist/chains/citrea/CitreaInitializer.d.ts

@@ -1,9 +1,9 @@
 import { BaseTokenType, BitcoinNetwork, BitcoinRpc, ChainData, ChainInitializer, ChainSwapType } from "@atomiqlabs/base";
 import { JsonRpcApiProvider } from "ethers";
 import { EVMRetryPolicy } from "../../evm/chain/EVMChainInterface";
-import { EVMFees } from "../../evm/chain/modules/EVMFees";
 import { CitreaChainType } from "./CitreaChainType";
-export type CitreaAssetsType = BaseTokenType<"CBTC">;
+import { CitreaFees } from "./CitreaFees";
+export type CitreaAssetsType = BaseTokenType<"CBTC" | "USDC">;
 export declare const CitreaAssets: CitreaAssetsType;
 export type CitreaOptions = {
     rpcUrl: string | JsonRpcApiProvider;
@@ -23,7 +23,7 @@ export type CitreaOptions = {
             [type in ChainSwapType]?: string;
         };
     };
-    fees?: EVMFees;
+    fees?: CitreaFees;
 };
 export declare function initializeCitrea(options: CitreaOptions, bitcoinRpc: BitcoinRpc<any>, network: BitcoinNetwork): ChainData<CitreaChainType>;
 export type CitreaInitializerType = ChainInitializer<CitreaOptions, CitreaChainType, CitreaAssetsType>;

package/dist/chains/citrea/CitreaInitializer.js

@@ -4,14 +4,15 @@ exports.CitreaInitializer = exports.initializeCitrea = exports.CitreaAssets = vo
 const base_1 = require("@atomiqlabs/base");
 const ethers_1 = require("ethers");
 const EVMChainInterface_1 = require("../../evm/chain/EVMChainInterface");
-const EVMFees_1 = require("../../evm/chain/modules/EVMFees");
-const EVMBtcRelay_1 = require("../../evm/btcrelay/EVMBtcRelay");
-const EVMSwapContract_1 = require("../../evm/swaps/EVMSwapContract");
-const EVMSpvVaultContract_1 = require("../../evm/spv_swap/EVMSpvVaultContract");
 const EVMChainEventsBrowser_1 = require("../../evm/events/EVMChainEventsBrowser");
 const EVMSwapData_1 = require("../../evm/swaps/EVMSwapData");
 const EVMSpvVaultData_1 = require("../../evm/spv_swap/EVMSpvVaultData");
 const EVMSpvWithdrawalData_1 = require("../../evm/spv_swap/EVMSpvWithdrawalData");
+const CitreaFees_1 = require("./CitreaFees");
+const CitreaBtcRelay_1 = require("./CitreaBtcRelay");
+const CitreaSwapContract_1 = require("./CitreaSwapContract");
+const CitreaTokens_1 = require("./CitreaTokens");
+const CitreaSpvVaultContract_1 = require("./CitreaSpvVaultContract");
 const CitreaChainIds = {
     MAINNET: null,
     TESTNET4: 5115
@@ -61,6 +62,11 @@ exports.CitreaAssets = {
         address: "0x0000000000000000000000000000000000000000",
         decimals: 18,
         displayDecimals: 8
+    },
+    USDC: {
+        address: "0x2C8abD2A528D19AFc33d2ebA507c0F405c131335",
+        decimals: 6,
+        displayDecimals: 6
     }
 };
 function initializeCitrea(options, bitcoinRpc, network) {
@@ -79,13 +85,14 @@ function initializeCitrea(options, bitcoinRpc, network) {
     const provider = typeof (options.rpcUrl) === "string" ?
         new ethers_1.JsonRpcProvider(options.rpcUrl, { name: "Citrea", chainId }) :
         options.rpcUrl;
-    const Fees = options.fees ?? new EVMFees_1.EVMFees(provider, 2n * 1000000000n, 1000000n);
+    const Fees = options.fees ?? new CitreaFees_1.CitreaFees(provider, 2n * 1000000000n, 1000000n);
     const chainInterface = new EVMChainInterface_1.EVMChainInterface("CITREA", chainId, provider, {
         safeBlockTag: "latest",
         maxLogsBlockRange: options.maxLogsBlockRange ?? 500
     }, options.retryPolicy, Fees);
-    const btcRelay = new EVMBtcRelay_1.EVMBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract, options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight);
-    const swapContract = new EVMSwapContract_1.EVMSwapContract(chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {
+    chainInterface.Tokens = new CitreaTokens_1.CitreaTokens(chainInterface); //Override with custom token module allowing l1 state diff based fee calculation
+    const btcRelay = new CitreaBtcRelay_1.CitreaBtcRelay(chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract, options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight);
+    const swapContract = new CitreaSwapContract_1.CitreaSwapContract(chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {
         refund: {
             ...defaultContractAddresses.handlerContracts.refund,
             ...options?.handlerContracts?.refund
@@ -95,7 +102,7 @@ function initializeCitrea(options, bitcoinRpc, network) {
             ...options?.handlerContracts?.claim
         }
     });
-    const spvVaultContract = new EVMSpvVaultContract_1.EVMSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
+    const spvVaultContract = new CitreaSpvVaultContract_1.CitreaSpvVaultContract(chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract, options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight);
     const chainEvents = new EVMChainEventsBrowser_1.EVMChainEventsBrowser(chainInterface, swapContract, spvVaultContract);
     return {
         chainId: "CITREA",

package/dist/chains/citrea/CitreaSpvVaultContract.d.ts

@@ -0,0 +1,15 @@
+import { EVMSpvVaultContract } from "../../evm/spv_swap/EVMSpvVaultContract";
+import { EVMSpvWithdrawalData } from "../../evm/spv_swap/EVMSpvWithdrawalData";
+import { EVMSpvVaultData } from "../../evm/spv_swap/EVMSpvVaultData";
+export declare class CitreaSpvVaultContract extends EVMSpvVaultContract<"CITREA"> {
+    static readonly StateDiffSize: {
+        BASE_DIFF_SIZE: number;
+        ERC_20_TRANSFER_DIFF_SIZE: number;
+        NATIVE_SELF_TRANSFER_DIFF_SIZE: number;
+        NATIVE_TRANSFER_DIFF_SIZE: number;
+        EXECUTION_SCHEDULE_DIFF_SIZE: number;
+    };
+    private calculateStateDiff;
+    getClaimFee(signer: string, vault?: EVMSpvVaultData, data?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    getFrontFee(signer: string, vault?: EVMSpvVaultData, data?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+}

package/dist/chains/citrea/CitreaSpvVaultContract.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitreaSpvVaultContract = void 0;
+const EVMSpvVaultContract_1 = require("../../evm/spv_swap/EVMSpvVaultContract");
+const EVMSpvVaultData_1 = require("../../evm/spv_swap/EVMSpvVaultData");
+const lib_esm_1 = require("ethers/lib.esm");
+const ethers_1 = require("ethers");
+const CitreaFees_1 = require("./CitreaFees");
+const EVMAddresses_1 = require("../../evm/chain/modules/EVMAddresses");
+class CitreaSpvVaultContract extends EVMSpvVaultContract_1.EVMSpvVaultContract {
+    calculateStateDiff(signer, tokenStateChanges) {
+        let stateDiffSize = 0;
+        tokenStateChanges.forEach(val => {
+            const [address, token] = val.split(":");
+            if (token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase()) {
+                stateDiffSize += address.toLowerCase() === signer?.toLowerCase() ? CitreaSpvVaultContract.StateDiffSize.NATIVE_SELF_TRANSFER_DIFF_SIZE : CitreaSpvVaultContract.StateDiffSize.NATIVE_TRANSFER_DIFF_SIZE;
+            }
+            else {
+                stateDiffSize += CitreaSpvVaultContract.StateDiffSize.ERC_20_TRANSFER_DIFF_SIZE;
+            }
+        });
+        return stateDiffSize;
+    }
+    async getClaimFee(signer, vault, data, feeRate) {
+        vault ?? (vault = EVMSpvVaultData_1.EVMSpvVaultData.randomVault());
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tokenStateChanges = new Set();
+        let diffSize = CitreaSpvVaultContract.StateDiffSize.BASE_DIFF_SIZE;
+        const recipient = data != null ? data.recipient : EVMAddresses_1.EVMAddresses.randomAddress();
+        if (data == null || (data.rawAmounts[0] != null && data.rawAmounts[0] > 0n)) {
+            tokenStateChanges.add(recipient.toLowerCase() + ":" + vault.token0.token.toLowerCase());
+            if (data == null || data.frontingFeeRate > 0n)
+                tokenStateChanges.add(ethers_1.ZeroAddress + ":" + vault.token0.token.toLowerCase()); //Also needs to pay out to fronter
+            if (data == null || data.callerFeeRate > 0n)
+                tokenStateChanges.add(signer + ":" + vault.token0.token.toLowerCase()); //Also needs to pay out to caller
+        }
+        if (data == null || (data.rawAmounts[1] != null && data.rawAmounts[1] > 0n)) {
+            tokenStateChanges.add(recipient.toLowerCase() + ":" + vault.token1.token.toLowerCase());
+            if (data == null || data.frontingFeeRate > 0n)
+                tokenStateChanges.add(ethers_1.ZeroAddress + ":" + vault.token1.token.toLowerCase()); //Also needs to pay out to fronter
+            if (data == null || data.callerFeeRate > 0n)
+                tokenStateChanges.add(signer + ":" + vault.token1.token.toLowerCase()); //Also needs to pay out to caller
+        }
+        diffSize += this.calculateStateDiff(signer, tokenStateChanges);
+        if (data == null || (data.executionHash != null && data.executionHash !== lib_esm_1.ZeroHash))
+            diffSize += CitreaSpvVaultContract.StateDiffSize.EXECUTION_SCHEDULE_DIFF_SIZE;
+        const gasFee = await super.getClaimFee(signer, vault, data, feeRate);
+        return gasFee + CitreaFees_1.CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+    async getFrontFee(signer, vault, data, feeRate) {
+        vault ?? (vault = EVMSpvVaultData_1.EVMSpvVaultData.randomVault());
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tokenStateChanges = new Set();
+        let diffSize = CitreaSpvVaultContract.StateDiffSize.BASE_DIFF_SIZE;
+        if (data == null || (data.rawAmounts[0] != null && data.rawAmounts[0] > 0n)) {
+            tokenStateChanges.add(signer + ":" + vault.token0.token.toLowerCase());
+        }
+        if (data == null || (data.rawAmounts[1] != null && data.rawAmounts[1] > 0n)) {
+            tokenStateChanges.add(signer + ":" + vault.token1.token.toLowerCase());
+        }
+        diffSize += this.calculateStateDiff(signer, tokenStateChanges);
+        if (data == null || (data.executionHash != null && data.executionHash !== lib_esm_1.ZeroHash))
+            diffSize += CitreaSpvVaultContract.StateDiffSize.EXECUTION_SCHEDULE_DIFF_SIZE;
+        const gasFee = await super.getFrontFee(signer, vault, data, feeRate);
+        return gasFee + CitreaFees_1.CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+}
+exports.CitreaSpvVaultContract = CitreaSpvVaultContract;
+CitreaSpvVaultContract.StateDiffSize = {
+    BASE_DIFF_SIZE: 50,
+    ERC_20_TRANSFER_DIFF_SIZE: 50,
+    NATIVE_SELF_TRANSFER_DIFF_SIZE: 20,
+    NATIVE_TRANSFER_DIFF_SIZE: 30,
+    EXECUTION_SCHEDULE_DIFF_SIZE: 40
+};

package/dist/chains/citrea/CitreaSwapContract.d.ts

@@ -0,0 +1,22 @@
+import { EVMSwapContract } from "../../evm/swaps/EVMSwapContract";
+import { EVMSwapData } from "../../evm/swaps/EVMSwapData";
+export declare class CitreaSwapContract extends EVMSwapContract<"CITREA"> {
+    static readonly StateDiffSize: {
+        BASE_DIFF_SIZE: number;
+        REPUTATION_UPDATE_DIFF_SIZE: number;
+        LP_VAULT_UPDATE_DIFF_SIZE: number;
+        ERC_20_TRANSFER_DIFF_SIZE: number;
+        NATIVE_SELF_TRANSFER_DIFF_SIZE: number;
+        NATIVE_TRANSFER_DIFF_SIZE: number;
+    };
+    private calculateStateDiff;
+    /**
+     * Get the estimated solana fee of the commit transaction
+     */
+    getCommitFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    /**
+     * Get the estimated solana transaction fee of the refund transaction
+     */
+    getRefundFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+}

package/dist/chains/citrea/CitreaSwapContract.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitreaSwapContract = void 0;
+const EVMSwapContract_1 = require("../../evm/swaps/EVMSwapContract");
+const CitreaFees_1 = require("./CitreaFees");
+class CitreaSwapContract extends EVMSwapContract_1.EVMSwapContract {
+    calculateStateDiff(signer, tokenStateChanges) {
+        let stateDiffSize = 0;
+        tokenStateChanges.forEach(val => {
+            const [address, token] = val.split(":");
+            if (token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase()) {
+                stateDiffSize += address.toLowerCase() === signer?.toLowerCase() ? CitreaSwapContract.StateDiffSize.NATIVE_SELF_TRANSFER_DIFF_SIZE : CitreaSwapContract.StateDiffSize.NATIVE_TRANSFER_DIFF_SIZE;
+            }
+            else {
+                stateDiffSize += CitreaSwapContract.StateDiffSize.ERC_20_TRANSFER_DIFF_SIZE;
+            }
+        });
+        return stateDiffSize;
+    }
+    /**
+     * Get the estimated solana fee of the commit transaction
+     */
+    async getCommitFee(signer, swapData, feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tokenStateChanges = new Set();
+        let diffSize = CitreaSwapContract.StateDiffSize.BASE_DIFF_SIZE;
+        if (!swapData.isPayIn()) {
+            diffSize += CitreaSwapContract.StateDiffSize.LP_VAULT_UPDATE_DIFF_SIZE;
+        }
+        else {
+            tokenStateChanges.add(swapData.getOfferer().toLowerCase() + ":" + swapData.getToken().toLowerCase());
+        }
+        if (swapData.getTotalDeposit() > 0n) {
+            tokenStateChanges.add(signer.toLowerCase() + ":" + swapData.getDepositToken().toLowerCase());
+        }
+        diffSize += this.calculateStateDiff(signer, tokenStateChanges);
+        const gasFee = await this.Init.getInitFee(swapData, feeRate);
+        return gasFee + CitreaFees_1.CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+    async getClaimFee(signer, swapData, feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tokenStateChanges = new Set();
+        let diffSize = CitreaSwapContract.StateDiffSize.BASE_DIFF_SIZE;
+        if (swapData.reputation)
+            diffSize += CitreaSwapContract.StateDiffSize.REPUTATION_UPDATE_DIFF_SIZE;
+        if (!swapData.isPayOut()) {
+            diffSize += CitreaSwapContract.StateDiffSize.LP_VAULT_UPDATE_DIFF_SIZE;
+        }
+        else {
+            tokenStateChanges.add(swapData.getClaimer().toLowerCase() + ":" + swapData.getToken().toLowerCase());
+        }
+        if (swapData.getClaimerBounty() > 0) {
+            tokenStateChanges.add(signer.toLowerCase() + ":" + swapData.getDepositToken().toLowerCase());
+        }
+        if (swapData.getSecurityDeposit() > swapData.getClaimerBounty()) {
+            tokenStateChanges.add(swapData.getClaimer().toLowerCase() + ":" + swapData.getDepositToken().toLowerCase());
+        }
+        diffSize += this.calculateStateDiff(signer, tokenStateChanges);
+        const gasFee = await this.Claim.getClaimFee(swapData, feeRate);
+        return gasFee + CitreaFees_1.CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+    /**
+     * Get the estimated solana transaction fee of the refund transaction
+     */
+    async getRefundFee(signer, swapData, feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
+        const tokenStateChanges = new Set();
+        let diffSize = CitreaSwapContract.StateDiffSize.BASE_DIFF_SIZE;
+        if (swapData.reputation)
+            diffSize += CitreaSwapContract.StateDiffSize.REPUTATION_UPDATE_DIFF_SIZE;
+        if (!swapData.isPayIn()) {
+            diffSize += CitreaSwapContract.StateDiffSize.LP_VAULT_UPDATE_DIFF_SIZE;
+        }
+        else {
+            tokenStateChanges.add(swapData.getOfferer().toLowerCase() + ":" + swapData.getToken().toLowerCase());
+        }
+        if (swapData.getSecurityDeposit() > 0) {
+            tokenStateChanges.add(swapData.getOfferer().toLowerCase() + ":" + swapData.getDepositToken().toLowerCase());
+        }
+        if (swapData.getClaimerBounty() > swapData.getSecurityDeposit()) {
+            tokenStateChanges.add(swapData.getClaimer().toLowerCase() + ":" + swapData.getDepositToken().toLowerCase());
+        }
+        diffSize += this.calculateStateDiff(signer, tokenStateChanges);
+        const gasFee = await this.Refund.getRefundFee(swapData, feeRate);
+        return gasFee + CitreaFees_1.CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+}
+exports.CitreaSwapContract = CitreaSwapContract;
+CitreaSwapContract.StateDiffSize = {
+    BASE_DIFF_SIZE: 35,
+    REPUTATION_UPDATE_DIFF_SIZE: 25,
+    LP_VAULT_UPDATE_DIFF_SIZE: 25,
+    ERC_20_TRANSFER_DIFF_SIZE: 50,
+    NATIVE_SELF_TRANSFER_DIFF_SIZE: 20,
+    NATIVE_TRANSFER_DIFF_SIZE: 30
+};

package/dist/chains/citrea/CitreaTokens.d.ts

@@ -0,0 +1,9 @@
+import { EVMTokens } from "../../evm/chain/modules/EVMTokens";
+export declare class CitreaTokens extends EVMTokens {
+    static readonly StateDiffSize: {
+        APPROVE_DIFF_SIZE: number;
+        TRANSFER_DIFF_SIZE: number;
+    };
+    getApproveFee(feeRate?: string): Promise<bigint>;
+    getTransferFee(feeRate?: string): Promise<bigint>;
+}

package/dist/chains/citrea/CitreaTokens.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CitreaTokens = void 0;
+const EVMTokens_1 = require("../../evm/chain/modules/EVMTokens");
+const CitreaFees_1 = require("./CitreaFees");
+class CitreaTokens extends EVMTokens_1.EVMTokens {
+    async getApproveFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return CitreaFees_1.CitreaFees.getGasFee(EVMTokens_1.EVMTokens.GasCosts.APPROVE, feeRate, CitreaTokens.StateDiffSize.APPROVE_DIFF_SIZE);
+    }
+    async getTransferFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return CitreaFees_1.CitreaFees.getGasFee(EVMTokens_1.EVMTokens.GasCosts.APPROVE, feeRate, CitreaTokens.StateDiffSize.TRANSFER_DIFF_SIZE);
+    }
+}
+exports.CitreaTokens = CitreaTokens;
+CitreaTokens.StateDiffSize = {
+    APPROVE_DIFF_SIZE: 35,
+    TRANSFER_DIFF_SIZE: 55
+};

package/dist/evm/btcrelay/EVMBtcRelay.d.ts

@@ -9,6 +9,13 @@ import { EVMSigner } from "../wallet/EVMSigner";
 import { EVMTx } from "../chain/modules/EVMTransactions";
 import { EVMChainInterface } from "../chain/EVMChainInterface";
 export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<BtcRelayTypechain> implements BtcRelay<EVMBtcStoredHeader, EVMTx, B, EVMSigner> {
+    static GasCosts: {
+        GAS_PER_BLOCKHEADER: number;
+        GAS_BASE_MAIN: number;
+        GAS_PER_BLOCKHEADER_FORK: number;
+        GAS_PER_BLOCKHEADER_FORKED: number;
+        GAS_BASE_FORK: number;
+    };
     SaveMainHeaders(signer: string, mainHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string): Promise<EVMTx>;
     SaveShortForkHeaders(signer: string, forkHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string): Promise<EVMTx>;
     SaveLongForkHeaders(signer: string, forkId: number, forkHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string, totalForkHeaders?: number): Promise<EVMTx>;
@@ -148,7 +155,7 @@ export declare class EVMBtcRelay<B extends BtcBlock> extends EVMContractBase<Btc
      */
     estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint>;
     /**
-     * Returns fee required (in SOL) to synchronize a single block to btc relay
+     * Returns fee required (in native token) to synchronize a single block to btc relay
      *
      * @param feeRate
      */

package/dist/evm/btcrelay/EVMBtcRelay.js

@@ -20,11 +20,6 @@ function serializeBlockHeader(e) {
         hash: Buffer.from(e.getHash(), "hex").reverse()
     });
 }
-const GAS_PER_BLOCKHEADER = 30000;
-const GAS_BASE_MAIN = 15000;
-const GAS_PER_BLOCKHEADER_FORK = 65000;
-const GAS_PER_BLOCKHEADER_FORKED = 10000;
-const GAS_BASE_FORK = 25000;
 const logger = (0, Utils_1.getLogger)("EVMBtcRelay: ");
 class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
     async SaveMainHeaders(signer, mainHeaders, storedHeader, feeRate) {
@@ -33,7 +28,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
             Buffer.concat(mainHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, GAS_BASE_MAIN + (GAS_PER_BLOCKHEADER * mainHeaders.length), feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMBtcRelay.GasCosts.GAS_BASE_MAIN + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER * mainHeaders.length), feeRate);
         return tx;
     }
     async SaveShortForkHeaders(signer, forkHeaders, storedHeader, feeRate) {
@@ -42,7 +37,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
             Buffer.concat(forkHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, GAS_BASE_MAIN + (GAS_PER_BLOCKHEADER * forkHeaders.length), feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMBtcRelay.GasCosts.GAS_BASE_MAIN + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER * forkHeaders.length), feeRate);
         return tx;
     }
     async SaveLongForkHeaders(signer, forkId, forkHeaders, storedHeader, feeRate, totalForkHeaders = 100) {
@@ -51,7 +46,7 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
             Buffer.concat(forkHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, GAS_BASE_FORK + (GAS_PER_BLOCKHEADER_FORK * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORKED * totalForkHeaders), feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMBtcRelay.GasCosts.GAS_BASE_FORK + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER_FORK * forkHeaders.length) + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER_FORKED * totalForkHeaders), feeRate);
         return tx;
     }
     constructor(chainInterface, bitcoinRpc, bitcoinNetwork, contractAddress, contractDeploymentHeight) {
@@ -327,24 +322,26 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
      * @param feeRate
      */
     async estimateSynchronizeFee(requiredBlockheight, feeRate) {
+        feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
         const tipData = await this.getTipData();
         const currBlockheight = tipData.blockheight;
         const blockheightDelta = requiredBlockheight - currBlockheight;
         if (blockheightDelta <= 0)
             return 0n;
-        const synchronizationFee = BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate);
+        const synchronizationFee = (BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate))
+            + EVMFees_1.EVMFees.getGasFee(EVMBtcRelay.GasCosts.GAS_BASE_MAIN * Math.ceil(blockheightDelta / this.maxHeadersPerTx), feeRate);
         logger.debug("estimateSynchronizeFee(): required blockheight: " + requiredBlockheight +
             " blockheight delta: " + blockheightDelta + " fee: " + synchronizationFee.toString(10));
         return synchronizationFee;
     }
     /**
-     * Returns fee required (in SOL) to synchronize a single block to btc relay
+     * Returns fee required (in native token) to synchronize a single block to btc relay
      *
      * @param feeRate
      */
     async getFeePerBlock(feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(GAS_PER_BLOCKHEADER, feeRate);
+        return EVMFees_1.EVMFees.getGasFee(EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER, feeRate);
     }
     /**
      * Gets fee rate required for submitting blockheaders to the main chain
@@ -417,3 +414,10 @@ class EVMBtcRelay extends EVMContractBase_1.EVMContractBase {
     }
 }
 exports.EVMBtcRelay = EVMBtcRelay;
+EVMBtcRelay.GasCosts = {
+    GAS_PER_BLOCKHEADER: 30000,
+    GAS_BASE_MAIN: 15000 + 21000,
+    GAS_PER_BLOCKHEADER_FORK: 65000,
+    GAS_PER_BLOCKHEADER_FORKED: 10000,
+    GAS_BASE_FORK: 25000 + 21000
+};

package/dist/evm/chain/EVMChainInterface.d.ts

@@ -24,12 +24,12 @@ export declare class EVMChainInterface<ChainId extends string = string, EVMChain
     readonly evmChainId: EVMChainId;
     readonly config: EVMConfiguration;
     Fees: EVMFees;
-    readonly Tokens: EVMTokens;
-    readonly Transactions: EVMTransactions;
-    readonly Signatures: EVMSignatures;
-    readonly Events: EVMEvents;
-    readonly Blocks: EVMBlocks;
-    protected readonly logger: LoggerType;
+    Tokens: EVMTokens;
+    Transactions: EVMTransactions;
+    Signatures: EVMSignatures;
+    Events: EVMEvents;
+    Blocks: EVMBlocks;
+    protected logger: LoggerType;
     constructor(chainId: ChainId, evmChainId: EVMChainId, provider: JsonRpcApiProvider, config: EVMConfiguration, retryPolicy?: EVMRetryPolicy, evmFeeEstimator?: EVMFees);
     getBalance(signer: string, tokenAddress: string): Promise<bigint>;
     getNativeCurrencyAddress(): string;

package/dist/evm/chain/EVMChainInterface.js

@@ -54,8 +54,7 @@ class EVMChainInterface {
         return this.Transactions.offBeforeTxSigned(callback);
     }
     randomAddress() {
-        const wallet = ethers_1.Wallet.createRandom();
-        return wallet.address;
+        return EVMAddresses_1.EVMAddresses.randomAddress();
     }
     randomSigner() {
         const wallet = ethers_1.Wallet.createRandom();

package/dist/evm/chain/modules/EVMAddresses.d.ts

@@ -6,4 +6,5 @@ export declare class EVMAddresses extends EVMModule<any> {
      * @param value
      */
     static isValidAddress(value: string): boolean;
+    static randomAddress(): string;
 }