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

package/dist/evm/spv_swap/EVMSpvVaultContract.d.ts

@@ -15,7 +15,12 @@ import { EVMBtcStoredHeader } from "../btcrelay/headers/EVMBtcStoredHeader";
 export declare function packOwnerAndVaultId(owner: string, vaultId: bigint): string;
 export declare function unpackOwnerAndVaultId(data: string): [string, bigint];
 export declare class EVMSpvVaultContract<ChainId extends string> extends EVMContractBase<SpvVaultManager> implements SpvVaultContract<EVMTx, EVMSigner, ChainId, EVMSpvVaultData, EVMSpvWithdrawalData> {
-    private static readonly GasCosts;
+    static readonly GasCosts: {
+        DEPOSIT: number;
+        OPEN: number;
+        FRONT: number;
+        CLAIM: number;
+    };
     readonly chainId: ChainId;
     readonly btcRelay: EVMBtcRelay<any>;
     readonly bitcoinRpc: BitcoinRpc<any>;

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -403,8 +403,8 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
 }
 exports.EVMSpvVaultContract = EVMSpvVaultContract;
 EVMSpvVaultContract.GasCosts = {
-    DEPOSIT: 150000,
-    OPEN: 100000,
-    FRONT: 250000,
-    CLAIM: 250000
+    DEPOSIT: 150000 + 21000,
+    OPEN: 100000 + 21000,
+    FRONT: 250000 + 21000,
+    CLAIM: 250000 + 21000
 };

package/dist/evm/swaps/modules/EVMLpVault.js

@@ -126,6 +126,6 @@ class EVMLpVault extends EVMSwapModule_1.EVMSwapModule {
 }
 exports.EVMLpVault = EVMLpVault;
 EVMLpVault.GasCosts = {
-    WITHDRAW: 100000,
-    DEPOSIT: 100000
+    WITHDRAW: 100000 + 21000,
+    DEPOSIT: 100000 + 21000
 };

package/dist/evm/swaps/modules/EVMSwapClaim.d.ts

@@ -46,6 +46,7 @@ export declare class EVMSwapClaim extends EVMSwapModule {
         hex: string;
         height: number;
     }, requiredConfirmations: number, vout: number, commitedHeader?: EVMBtcStoredHeader, synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>, feeRate?: string): Promise<EVMTx[] | null>;
+    getClaimGas(swapData: EVMSwapData): number;
     /**
      * Get the estimated starknet transaction fee of the claim transaction
      */

package/dist/evm/swaps/modules/EVMSwapClaim.js

@@ -19,7 +19,7 @@ class EVMSwapClaim extends EVMSwapModule_1.EVMSwapModule {
         //TODO: Claim with success action not supported yet!
         const tx = await this.swapContract.claim.populateTransaction(swapData.toEscrowStruct(), witness);
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMSwapClaim.GasCosts.CLAIM + (claimHandlerGas ?? 0), feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getClaimGas(swapData) + (claimHandlerGas ?? 0), feeRate);
         return tx;
     }
     /**
@@ -81,13 +81,46 @@ class EVMSwapClaim extends EVMSwapModule_1.EVMSwapModule {
         const claimTx = await this.Claim(signer, swapData, witness, feeRate, claimHandler.getGas(swapData));
         return [...initialTxns, claimTx];
     }
+    getClaimGas(swapData) {
+        let totalGas = EVMSwapClaim.GasCosts.BASE;
+        if (swapData.reputation)
+            totalGas += EVMSwapClaim.GasCosts.REPUTATION;
+        if (swapData.isPayOut()) {
+            if (swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapClaim.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapClaim.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        else {
+            totalGas += EVMSwapClaim.GasCosts.LP_VAULT_TRANSFER;
+        }
+        if (swapData.getClaimerBounty() > 0n) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapClaim.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapClaim.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        if (swapData.getSecurityDeposit() > swapData.getClaimerBounty()) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapClaim.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapClaim.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        return totalGas;
+    }
     /**
      * Get the estimated starknet transaction fee of the claim transaction
      */
     async getClaimFee(swapData, feeRate) {
         feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
         //TODO: Claim with success action not supported yet!
-        let gasRequired = EVMSwapClaim.GasCosts.CLAIM;
+        let gasRequired = this.getClaimGas(swapData);
         const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         if (claimHandler != null)
             gasRequired += claimHandler.getGas(swapData);
@@ -96,6 +129,9 @@ class EVMSwapClaim extends EVMSwapModule_1.EVMSwapModule {
 }
 exports.EVMSwapClaim = EVMSwapClaim;
 EVMSwapClaim.GasCosts = {
-    CLAIM: 120000,
-    CLAIM_WITH_SUCCESS_ACTION: 150000
+    BASE: 30000 + 21000,
+    ERC20_TRANSFER: 40000,
+    NATIVE_TRANSFER: 7500,
+    LP_VAULT_TRANSFER: 10000,
+    REPUTATION: 25000
 };

package/dist/evm/swaps/modules/EVMSwapInit.d.ts

@@ -80,9 +80,9 @@ export declare class EVMSwapInit extends EVMSwapModule {
      * @param feeRate fee rate to use for the transaction
      */
     txsInit(sender: string, swapData: EVMSwapData, timeout: string, prefix: string, signature: string, skipChecks?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    private getInitGas;
     /**
-     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
-     *  and also deposit for ATAs
+     * Get the estimated fee of the init transaction
      */
-    getInitFee(swapData?: EVMSwapData, feeRate?: string): Promise<bigint>;
+    getInitFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
 }

package/dist/evm/swaps/modules/EVMSwapInit.js

@@ -39,15 +39,17 @@ class EVMSwapInit extends EVMSwapModule_1.EVMSwapModule {
      */
     async Init(sender, swapData, timeout, signature, feeRate) {
         let value = 0n;
-        if (swapData.isToken(this.root.getNativeCurrencyAddress()))
-            value += swapData.getAmount();
+        if (swapData.isPayIn()) {
+            if (swapData.isOfferer(sender) && swapData.isToken(this.root.getNativeCurrencyAddress()))
+                value += swapData.getAmount();
+        }
         if (swapData.isDepositToken(this.root.getNativeCurrencyAddress()))
             value += swapData.getTotalDeposit();
         const tx = await this.swapContract.initialize.populateTransaction(swapData.toEscrowStruct(), signature, timeout, "0x" + (swapData.extraData ?? ""), {
             value
         });
         tx.from = sender;
-        EVMFees_1.EVMFees.applyFeeRate(tx, swapData.isPayIn() ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getInitGas(swapData), feeRate);
         return tx;
     }
     /**
@@ -206,7 +208,7 @@ class EVMSwapInit extends EVMSwapModule_1.EVMSwapModule {
         feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
         const txs = [];
         const requiredApprovals = {};
-        if (swapData.payIn && swapData.isOfferer(sender)) {
+        if (swapData.isPayIn() && swapData.isOfferer(sender)) {
             if (!swapData.isToken(this.root.getNativeCurrencyAddress())) {
                 requiredApprovals[swapData.token.toLowerCase()] = swapData.amount;
             }
@@ -225,17 +227,49 @@ class EVMSwapInit extends EVMSwapModule_1.EVMSwapModule {
             " feerate: " + feeRate);
         return txs;
     }
+    getInitGas(swapData) {
+        let totalGas = EVMSwapInit.GasCosts.BASE;
+        if (swapData.isPayIn()) {
+            if (!swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapInit.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        else {
+            totalGas += EVMSwapInit.GasCosts.LP_VAULT_TRANSFER;
+        }
+        if (swapData.getTotalDeposit() > 0) {
+            if (!swapData.isPayIn() || !swapData.isDepositToken(swapData.token)) {
+                if (!swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                    totalGas += EVMSwapInit.GasCosts.ERC20_TRANSFER;
+                }
+            }
+        }
+        return totalGas;
+    }
     /**
-     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
-     *  and also deposit for ATAs
+     * Get the estimated fee of the init transaction
      */
     async getInitFee(swapData, feeRate) {
         feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(swapData.payIn ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+        let totalFee = EVMFees_1.EVMFees.getGasFee(this.getInitGas(swapData), feeRate);
+        if (swapData.isPayIn()) {
+            if (!swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalFee += await this.root.Tokens.getApproveFee(feeRate);
+            }
+        }
+        if (swapData.getTotalDeposit() > 0) {
+            if (!swapData.isPayIn() || !swapData.isDepositToken(swapData.token)) {
+                if (!swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                    totalFee += await this.root.Tokens.getApproveFee(feeRate);
+                }
+            }
+        }
+        return totalFee;
     }
 }
 exports.EVMSwapInit = EVMSwapInit;
 EVMSwapInit.GasCosts = {
-    INIT: 100000,
-    INIT_PAY_IN: 130000,
+    BASE: 45000 + 21000,
+    ERC20_TRANSFER: 40000,
+    LP_VAULT_TRANSFER: 10000
 };

package/dist/evm/swaps/modules/EVMSwapRefund.d.ts

@@ -54,9 +54,9 @@ export declare class EVMSwapRefund extends EVMSwapModule {
      * @param feeRate fee rate to be used for the transactions
      */
     txsRefundWithAuthorization(signer: string, swapData: EVMSwapData, timeout: string, prefix: string, signature: string, check?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    getRefundGas(swapData: EVMSwapData): number;
     /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     * Get the estimated transaction fee of the refund transaction
      */
     getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
 }

package/dist/evm/swaps/modules/EVMSwapRefund.js

@@ -23,7 +23,7 @@ class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
     async Refund(signer, swapData, witness, feeRate, handlerGas) {
         const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, (swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND) + (handlerGas ?? 0), feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData) + (handlerGas ?? 0), feeRate);
         return tx;
     }
     /**
@@ -39,7 +39,7 @@ class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
     async RefundWithSignature(sender, swapData, timeout, signature, feeRate) {
         const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
         tx.from = sender;
-        EVMFees_1.EVMFees.applyFeeRate(tx, swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getRefundGas(swapData), feeRate);
         return tx;
     }
     async signSwapRefund(signer, swapData, authorizationTimeout) {
@@ -116,17 +116,52 @@ class EVMSwapRefund extends EVMSwapModule_1.EVMSwapModule {
             " auth expiry: " + timeout + " signature: " + signature);
         return [tx];
     }
+    getRefundGas(swapData) {
+        let totalGas = EVMSwapRefund.GasCosts.BASE;
+        if (swapData.reputation)
+            totalGas += EVMSwapRefund.GasCosts.REPUTATION;
+        if (swapData.isPayIn()) {
+            if (swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        else {
+            totalGas += EVMSwapRefund.GasCosts.LP_VAULT_TRANSFER;
+        }
+        if (swapData.getSecurityDeposit() > 0n) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        if (swapData.getClaimerBounty() > swapData.getSecurityDeposit()) {
+            if (swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                totalGas += EVMSwapRefund.GasCosts.NATIVE_TRANSFER;
+            }
+            else {
+                totalGas += EVMSwapRefund.GasCosts.ERC20_TRANSFER;
+            }
+        }
+        return totalGas;
+    }
     /**
-     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
-     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     * Get the estimated transaction fee of the refund transaction
      */
     async getRefundFee(swapData, feeRate) {
         feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate);
+        return EVMFees_1.EVMFees.getGasFee(this.getRefundGas(swapData), feeRate);
     }
 }
 exports.EVMSwapRefund = EVMSwapRefund;
 EVMSwapRefund.GasCosts = {
-    REFUND: 100000,
-    REFUND_PAY_OUT: 130000
+    BASE: 35000 + 21000,
+    ERC20_TRANSFER: 40000,
+    NATIVE_TRANSFER: 7500,
+    LP_VAULT_TRANSFER: 10000,
+    REPUTATION: 25000
 };

package/dist/index.d.ts

@@ -35,3 +35,4 @@ export * from "./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHandler";
 export * from "./evm/wallet/EVMSigner";
 export * from "./chains/citrea/CitreaInitializer";
 export * from "./chains/citrea/CitreaChainType";
+export * from "./chains/citrea/CitreaFees";

package/dist/index.js

@@ -51,3 +51,4 @@ __exportStar(require("./evm/swaps/handlers/claim/btc/BitcoinNoncedOutputClaimHan
 __exportStar(require("./evm/wallet/EVMSigner"), exports);
 __exportStar(require("./chains/citrea/CitreaInitializer"), exports);
 __exportStar(require("./chains/citrea/CitreaChainType"), exports);
+__exportStar(require("./chains/citrea/CitreaFees"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.22",
+  "version": "1.0.0-dev.27",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",

package/src/chains/citrea/CitreaBtcRelay.ts

@@ -0,0 +1,58 @@
+import {EVMBtcRelay} from "../../evm/btcrelay/EVMBtcRelay";
+import {BtcBlock} from "@atomiqlabs/base";
+import {getLogger} from "../../utils/Utils";
+import {CitreaFees} from "./CitreaFees";
+
+const logger = getLogger("CitreaBtcRelay: ");
+
+export class CitreaBtcRelay<B extends BtcBlock> extends EVMBtcRelay<B> {
+
+    public static StateDiffSize = {
+        STATE_DIFF_PER_BLOCKHEADER: 22,
+        STATE_DIFF_BASE: 30
+    }
+
+    /**
+     * Estimate required synchronization fee (worst case) to synchronize btc relay to the required blockheight
+     *
+     * @param requiredBlockheight
+     * @param feeRate
+     */
+    public async estimateSynchronizeFee(requiredBlockheight: number, feeRate?: string): Promise<bigint> {
+        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.getGasFee(
+                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
+     */
+    public async getFeePerBlock(feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+        return CitreaFees.getGasFee(
+            EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER,
+            feeRate,
+            CitreaBtcRelay.StateDiffSize.STATE_DIFF_PER_BLOCKHEADER
+        );
+    }
+
+}

package/src/chains/citrea/CitreaChainType.ts

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

package/src/chains/citrea/CitreaFees.ts

@@ -0,0 +1,77 @@
+import {EVMFees} from "../../evm/chain/modules/EVMFees";
+import {getLogger} from "../../utils/Utils";
+
+export class CitreaFees extends EVMFees {
+
+    public static readonly StateDiffSize = {
+        APPROVE_DIFF_SIZE: 40,
+    };
+
+    protected readonly logger = getLogger("CitreaFees: ");
+
+    private _blockFeeCache: {
+        timestamp: number,
+        feeRate: Promise<{baseFee: bigint, l1Fee: bigint}>
+    } = null;
+
+    /**
+     * Gets evm fee rate
+     *
+     * @private
+     * @returns {Promise<bigint>} L1 gas price denominated in Wei
+     */
+    private async __getFeeRate(): Promise<{baseFee: bigint, l1Fee: bigint}> {
+        const res = await this.provider.send("eth_getBlockByNumber", ["latest", false]);
+        const l1Fee = BigInt(res.l1FeeRate);
+        const baseFee = BigInt(res.baseFeePerGas) * this.feeMultiplierPPM / 1_000_000n;
+
+        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
+     */
+    public async getFeeRate(): Promise<string> {
+        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
+     */
+    public static getGasFee(gas: number, feeRate: string, stateDiffSize: number = 0): bigint {
+        if(feeRate==null) return 0n;
+
+        const [maxFee, priorityFee, l1StateDiffFee] = feeRate.split(",");
+
+        return (BigInt(gas) * BigInt(maxFee)) + (BigInt(stateDiffSize) * BigInt(l1StateDiffFee ?? 0n));
+    }
+
+}

package/src/chains/citrea/CitreaInitializer.ts

@@ -10,6 +10,10 @@ 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";
+import {CitreaFees} from "./CitreaFees";
+import {CitreaBtcRelay} from "./CitreaBtcRelay";
+import {CitreaSwapContract} from "./CitreaSwapContract";
+import {CitreaTokens} from "./CitreaTokens";
 
 const CitreaChainIds = {
     MAINNET: null,
@@ -57,12 +61,17 @@ const CitreaContractAddresses = {
     }
 };
 
-export type CitreaAssetsType = BaseTokenType<"CBTC">;
+export type CitreaAssetsType = BaseTokenType<"CBTC" | "USDC">;
 export const CitreaAssets: CitreaAssetsType = {
     CBTC: {
         address: "0x0000000000000000000000000000000000000000",
         decimals: 18,
         displayDecimals: 8
+    },
+    USDC: {
+        address: "0x2C8abD2A528D19AFc33d2ebA507c0F405c131335",
+        decimals: 6,
+        displayDecimals: 6
     }
 } as const;
 
@@ -86,7 +95,7 @@ export type CitreaOptions = {
         }
     }
 
-    fees?: EVMFees
+    fees?: CitreaFees
 }
 
 export function initializeCitrea(
@@ -112,19 +121,20 @@ export function initializeCitrea(
         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 Fees = options.fees ?? new CitreaFees(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);
+    chainInterface.Tokens = new CitreaTokens(chainInterface); //Override with custom token module allowing l1 state diff based fee calculation
 
-    const btcRelay = new EVMBtcRelay(
+    const btcRelay = new CitreaBtcRelay(
         chainInterface, bitcoinRpc, network, options.btcRelayContract ?? defaultContractAddresses.btcRelayContract,
         options.btcRelayDeploymentHeight ?? defaultContractAddresses.btcRelayDeploymentHeight
     );
 
-    const swapContract = new EVMSwapContract(
+    const swapContract = new CitreaSwapContract(
         chainInterface, btcRelay, options.swapContract ?? defaultContractAddresses.swapContract, {
             refund: {
                 ...defaultContractAddresses.handlerContracts.refund,

package/src/chains/citrea/CitreaSpvVaultContract.ts

@@ -0,0 +1,18 @@
+import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
+import {EVMSpvWithdrawalData} from "../../evm/spv_swap/EVMSpvWithdrawalData";
+import {EVMFees} from "../../evm/chain/modules/EVMFees";
+
+
+export class CitreaSpvVaultContract extends EVMSpvVaultContract<"CITREA"> {
+
+    async getClaimFee(signer: string, withdrawalData: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+        return EVMFees.getGasFee(EVMSpvVaultContract.GasCosts.CLAIM, feeRate);
+    }
+
+    async getFrontFee(signer: string, withdrawalData: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+        return EVMFees.getGasFee(EVMSpvVaultContract.GasCosts.FRONT, feeRate);
+    }
+
+}