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

package/src/chains/citrea/CitreaSwapContract.ts

@@ -0,0 +1,105 @@
+import {EVMSwapContract} from "../../evm/swaps/EVMSwapContract";
+import {EVMSwapData} from "../../evm/swaps/EVMSwapData";
+import {CitreaFees} from "./CitreaFees";
+
+export class CitreaSwapContract extends EVMSwapContract<"CITREA"> {
+
+    public static readonly 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
+    };
+
+    private calculateStateDiff(signer: string, tokenStateChanges: Set<string>): number {
+        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(swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+
+        const tokenStateChanges: Set<string> = 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());
+        }
+        //TODO: Since we don't know who is sending the transaction, we calculate with the worst case
+        if(swapData.getTotalDeposit()>0n) {
+            tokenStateChanges.add(swapData.getClaimer().toLowerCase()+":"+swapData.getDepositToken().toLowerCase());
+        }
+        diffSize += this.calculateStateDiff(null, tokenStateChanges);
+
+        const gasFee = await this.Init.getInitFee(swapData, feeRate);
+        return gasFee + CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+
+    async getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+
+        const tokenStateChanges: Set<string> = 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.getGasFee(0, feeRate, diffSize);
+    }
+
+    /**
+     * Get the estimated solana transaction fee of the refund transaction
+     */
+    async getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+
+        const tokenStateChanges: Set<string> = 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());
+        }
+        //TODO: Since we don't know if the refund is cooperative or not and also not the signer, we calculate with the worst case
+        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(null, tokenStateChanges);
+
+        const gasFee = await this.Refund.getRefundFee(swapData, feeRate);
+        return gasFee + CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+
+}

package/src/chains/citrea/CitreaTokens.ts

@@ -0,0 +1,22 @@
+import {EVMTokens} from "../../evm/chain/modules/EVMTokens";
+import {CitreaFees} from "./CitreaFees";
+
+
+export class CitreaTokens extends EVMTokens {
+
+    public static readonly StateDiffSize = {
+        APPROVE_DIFF_SIZE: 35,
+        TRANSFER_DIFF_SIZE: 55
+    };
+
+    async getApproveFee(feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return CitreaFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate, CitreaTokens.StateDiffSize.APPROVE_DIFF_SIZE);
+    }
+
+    async getTransferFee(feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return CitreaFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate, CitreaTokens.StateDiffSize.TRANSFER_DIFF_SIZE);
+    }
+
+}

package/src/evm/btcrelay/EVMBtcRelay.ts

@@ -23,25 +23,27 @@ function serializeBlockHeader(e: BtcBlock): EVMBtcHeader {
     });
 }
 
-const GAS_PER_BLOCKHEADER = 30_000;
-const GAS_BASE_MAIN = 15_000;
-const GAS_PER_BLOCKHEADER_FORK = 65_000;
-const GAS_PER_BLOCKHEADER_FORKED = 10_000;
-const GAS_BASE_FORK = 25_000;
-
 const logger = getLogger("EVMBtcRelay: ");
 
 export class EVMBtcRelay<B extends BtcBlock>
     extends EVMContractBase<BtcRelayTypechain>
     implements BtcRelay<EVMBtcStoredHeader, EVMTx, B, EVMSigner> {
 
+    public static GasCosts = {
+        GAS_PER_BLOCKHEADER: 30_000,
+        GAS_BASE_MAIN: 15_000 + 21_000,
+        GAS_PER_BLOCKHEADER_FORK: 65_000,
+        GAS_PER_BLOCKHEADER_FORKED: 10_000,
+        GAS_BASE_FORK: 25_000 + 21_000
+    }
+
     public async SaveMainHeaders(signer: string, mainHeaders: EVMBtcHeader[], storedHeader: EVMBtcStoredHeader, feeRate: string): Promise<EVMTx> {
         const tx = await this.contract.submitMainBlockheaders.populateTransaction(Buffer.concat([
             storedHeader.serialize(),
             Buffer.concat(mainHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees.applyFeeRate(tx, GAS_BASE_MAIN + (GAS_PER_BLOCKHEADER * mainHeaders.length), feeRate);
+        EVMFees.applyFeeRate(tx, EVMBtcRelay.GasCosts.GAS_BASE_MAIN + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER * mainHeaders.length), feeRate);
         return tx;
     }
 
@@ -51,7 +53,7 @@ export class EVMBtcRelay<B extends BtcBlock>
             Buffer.concat(forkHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees.applyFeeRate(tx, GAS_BASE_MAIN + (GAS_PER_BLOCKHEADER * forkHeaders.length), feeRate);
+        EVMFees.applyFeeRate(tx, EVMBtcRelay.GasCosts.GAS_BASE_MAIN + (EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER * forkHeaders.length), feeRate);
         return tx;
     }
 
@@ -61,7 +63,7 @@ export class EVMBtcRelay<B extends BtcBlock>
             Buffer.concat(forkHeaders.map(header => header.serializeCompact()))
         ]));
         tx.from = signer;
-        EVMFees.applyFeeRate(tx, GAS_BASE_FORK + (GAS_PER_BLOCKHEADER_FORK * forkHeaders.length) + (GAS_PER_BLOCKHEADER_FORKED * totalForkHeaders), feeRate);
+        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;
     }
 
@@ -398,6 +400,8 @@ export class EVMBtcRelay<B extends BtcBlock>
      * @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;
 
@@ -405,7 +409,8 @@ export class EVMBtcRelay<B extends BtcBlock>
 
         if(blockheightDelta<=0) return 0n;
 
-        const synchronizationFee = BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate);
+        const synchronizationFee = (BigInt(blockheightDelta) * await this.getFeePerBlock(feeRate))
+            + 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));
 
@@ -413,13 +418,13 @@ export class EVMBtcRelay<B extends BtcBlock>
     }
 
     /**
-     * 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
      */
     public async getFeePerBlock(feeRate?: string): Promise<bigint> {
         feeRate ??= await this.Chain.Fees.getFeeRate();
-        return EVMFees.getGasFee(GAS_PER_BLOCKHEADER, feeRate);
+        return EVMFees.getGasFee(EVMBtcRelay.GasCosts.GAS_PER_BLOCKHEADER, feeRate);
     }
 
     /**

package/src/evm/chain/EVMChainInterface.ts

@@ -33,13 +33,13 @@ export class EVMChainInterface<ChainId extends string = string, EVMChainId exten
     public readonly config: EVMConfiguration;
 
     public Fees: EVMFees;
-    public readonly Tokens: EVMTokens;
-    public readonly Transactions: EVMTransactions;
-    public readonly Signatures: EVMSignatures;
-    public readonly Events: EVMEvents;
-    public readonly Blocks: EVMBlocks;
+    public Tokens: EVMTokens;
+    public Transactions: EVMTransactions;
+    public Signatures: EVMSignatures;
+    public Events: EVMEvents;
+    public Blocks: EVMBlocks;
 
-    protected readonly logger: LoggerType;
+    protected logger: LoggerType;
 
     constructor(
         chainId: ChainId,

package/src/evm/chain/modules/EVMFees.ts

@@ -1,7 +1,5 @@
 import { getLogger } from "../../../utils/Utils";
-import {Provider, TransactionRequest} from "ethers";
-
-const MAX_FEE_AGE = 5000;
+import {JsonRpcApiProvider, TransactionRequest} from "ethers";
 
 export type EVMFeeRate = {
     maxFeePerGas: bigint;
@@ -9,14 +7,15 @@ export type EVMFeeRate = {
 };
 
 export class EVMFees {
+    protected MAX_FEE_AGE = 5000;
 
-    private readonly logger = getLogger("EVMFees: ");
+    protected readonly logger = getLogger("EVMFees: ");
 
-    private readonly provider: Provider;
-    private readonly maxFeeRatePerGas: bigint;
-    private readonly priorityFee: bigint;
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly maxFeeRatePerGas: bigint;
+    protected readonly priorityFee: bigint;
 
-    private readonly feeMultiplierPPM: bigint;
+    protected readonly feeMultiplierPPM: bigint;
 
     private blockFeeCache: {
         timestamp: number,
@@ -24,7 +23,7 @@ export class EVMFees {
     } = null;
 
     constructor(
-        provider: Provider,
+        provider: JsonRpcApiProvider,
         maxFeeRatePerGas: bigint = 500n * 1_000_000_000n,
         priorityFee: bigint = 1n * 1_000_000_000n,
         feeMultiplier: number = 1.25,
@@ -56,7 +55,7 @@ export class EVMFees {
      * @private
      */
     public async getFeeRate(): Promise<string> {
-        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > MAX_FEE_AGE) {
+        if(this.blockFeeCache==null || Date.now() - this.blockFeeCache.timestamp > this.MAX_FEE_AGE) {
             let obj = {
                 timestamp: Date.now(),
                 feeRate: null
@@ -99,7 +98,7 @@ export class EVMFees {
 
         tx.maxFeePerGas = BigInt(baseFee) + BigInt(priorityFee);
         tx.maxPriorityFeePerGas = BigInt(priorityFee);
-        tx.gasLimit = BigInt(gas) + 21_000n;
+        tx.gasLimit = BigInt(gas);
     }
 
 }

package/src/evm/chain/modules/EVMTokens.ts

@@ -3,6 +3,7 @@ import {Contract, TransactionRequest} from "ethers";
 import {ERC20Abi} from "./ERC20Abi";
 import {EVMAddresses} from "./EVMAddresses";
 import {EVMFees} from "./EVMFees";
+import {EVMSwapData} from "../../swaps/EVMSwapData";
 
 
 export class EVMTokens extends EVMModule<any> {
@@ -10,8 +11,8 @@ export class EVMTokens extends EVMModule<any> {
     public static readonly ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
 
     public static readonly GasCosts = {
-        TRANSFER: 80_000,
-        APPROVE: 80_000
+        TRANSFER: 80_000 + 21_000,
+        APPROVE: 80_000 + 21_000
     };
 
     private getContract(address: string) {
@@ -112,4 +113,14 @@ export class EVMTokens extends EVMModule<any> {
         return tx;
     }
 
+    async getApproveFee(feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
+
+    async getTransferFee(feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
+
 }

package/src/evm/spv_swap/EVMSpvVaultContract.ts

@@ -54,11 +54,11 @@ export class EVMSpvVaultContract<ChainId extends string>
         EVMSpvWithdrawalData
     >
 {
-    private static readonly GasCosts = {
-        DEPOSIT: 150_000,
-        OPEN: 100_000,
-        FRONT: 250_000,
-        CLAIM: 250_000
+    public static readonly GasCosts = {
+        DEPOSIT: 150_000 + 21_000,
+        OPEN: 100_000 + 21_000,
+        FRONT: 250_000 + 21_000,
+        CLAIM: 250_000 + 21_000
     };
 
     readonly chainId: ChainId;

package/src/evm/swaps/modules/EVMLpVault.ts

@@ -7,8 +7,8 @@ import {EVMTx} from "../../chain/modules/EVMTransactions";
 export class EVMLpVault extends EVMSwapModule {
 
     private static readonly GasCosts = {
-        WITHDRAW: 100_000,
-        DEPOSIT: 100_000
+        WITHDRAW: 100_000 + 21_000,
+        DEPOSIT: 100_000 + 21_000
     };
 
     /**

package/src/evm/swaps/modules/EVMSwapClaim.ts

@@ -13,8 +13,11 @@ import {EVMBtcStoredHeader} from "../../btcrelay/headers/EVMBtcStoredHeader";
 export class EVMSwapClaim extends EVMSwapModule {
 
     private static readonly GasCosts = {
-        CLAIM: 120_000,
-        CLAIM_WITH_SUCCESS_ACTION: 150_000
+        BASE: 30_000 + 21_000,
+        ERC20_TRANSFER: 40_000,
+        NATIVE_TRANSFER: 7500,
+        LP_VAULT_TRANSFER: 10_000,
+        REPUTATION: 25_000
     };
 
     /**
@@ -37,7 +40,7 @@ export class EVMSwapClaim extends EVMSwapModule {
         //TODO: Claim with success action not supported yet!
         const tx = await this.swapContract.claim.populateTransaction(swapData.toEscrowStruct(), witness);
         tx.from = signer;
-        EVMFees.applyFeeRate(tx, EVMSwapClaim.GasCosts.CLAIM + (claimHandlerGas ?? 0), feeRate);
+        EVMFees.applyFeeRate(tx, this.getClaimGas(swapData) + (claimHandlerGas ?? 0), feeRate);
         return tx;
     }
 
@@ -123,6 +126,35 @@ export class EVMSwapClaim extends EVMSwapModule {
         return [...initialTxns, claimTx];
     }
 
+    getClaimGas(swapData: EVMSwapData): number {
+        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
      */
@@ -130,7 +162,7 @@ export class EVMSwapClaim extends EVMSwapModule {
         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: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
         if(claimHandler!=null) gasRequired += claimHandler.getGas(swapData);

package/src/evm/swaps/modules/EVMSwapInit.ts

@@ -1,5 +1,4 @@
 import {SignatureVerificationError, SwapCommitStateType, SwapDataVerificationError} from "@atomiqlabs/base";
-import {Buffer} from "buffer";
 import { EVMSwapModule } from "../EVMSwapModule";
 import {EVMSwapData} from "../EVMSwapData";
 import {keccak256, TransactionRequest, ZeroHash} from "ethers";
@@ -36,8 +35,9 @@ const Initialize = [
 export class EVMSwapInit extends EVMSwapModule {
 
     private static readonly GasCosts = {
-        INIT: 100_000,
-        INIT_PAY_IN: 130_000,
+        BASE: 45_000 + 21_000,
+        ERC20_TRANSFER: 40_000,
+        LP_VAULT_TRANSFER: 10_000
     };
 
     /**
@@ -52,13 +52,15 @@ export class EVMSwapInit extends EVMSwapModule {
      */
     private async Init(sender: string, swapData: EVMSwapData, timeout: bigint, signature: string, feeRate: string): Promise<TransactionRequest> {
         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.applyFeeRate(tx, swapData.isPayIn() ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+        EVMFees.applyFeeRate(tx, this.getInitGas(swapData), feeRate);
         return tx;
     }
 
@@ -259,7 +261,7 @@ export class EVMSwapInit extends EVMSwapModule {
 
         const txs: EVMTx[] = [];
         const requiredApprovals: {[address: string]: bigint} = {};
-        if(swapData.payIn && swapData.isOfferer(sender)) {
+        if(swapData.isPayIn() && swapData.isOfferer(sender)) {
             if(!swapData.isToken(this.root.getNativeCurrencyAddress())) {
                 requiredApprovals[swapData.token.toLowerCase()] = swapData.amount;
             }
@@ -281,12 +283,44 @@ export class EVMSwapInit extends EVMSwapModule {
         return txs;
     }
 
+    private getInitGas(swapData: EVMSwapData): number {
+        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?: EVMSwapData, feeRate?: string): Promise<bigint> {
+    async getInitFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.root.Fees.getFeeRate();
-        return EVMFees.getGasFee(swapData.payIn ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+        let totalFee = 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;
     }
 }

package/src/evm/swaps/modules/EVMSwapRefund.ts

@@ -17,8 +17,11 @@ const Refund = [
 export class EVMSwapRefund extends EVMSwapModule {
 
     private static readonly GasCosts = {
-        REFUND: 100_000,
-        REFUND_PAY_OUT: 130_000
+        BASE: 35_000 + 21_000,
+        ERC20_TRANSFER: 40_000,
+        NATIVE_TRANSFER: 7500,
+        LP_VAULT_TRANSFER: 10_000,
+        REPUTATION: 25_000
     };
 
     /**
@@ -40,7 +43,7 @@ export class EVMSwapRefund extends EVMSwapModule {
     ): Promise<TransactionRequest> {
         const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
         tx.from = signer;
-        EVMFees.applyFeeRate(tx, (swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND) + (handlerGas ?? 0), feeRate)
+        EVMFees.applyFeeRate(tx, this.getRefundGas(swapData) + (handlerGas ?? 0), feeRate)
         return tx;
     }
 
@@ -63,7 +66,7 @@ export class EVMSwapRefund extends EVMSwapModule {
     ): Promise<TransactionRequest> {
         const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
         tx.from = sender;
-        EVMFees.applyFeeRate(tx, swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate)
+        EVMFees.applyFeeRate(tx, this.getRefundGas(swapData), feeRate)
         return tx;
     }
 
@@ -186,13 +189,41 @@ export class EVMSwapRefund extends EVMSwapModule {
         return [tx];
     }
 
+    getRefundGas(swapData: EVMSwapData): number {
+        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: EVMSwapData, feeRate?: string): Promise<bigint> {
         feeRate ??= await this.root.Fees.getFeeRate();
-        return EVMFees.getGasFee(swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate);
+        return EVMFees.getGasFee(this.getRefundGas(swapData), feeRate);
     }
 
 }

package/src/index.ts

@@ -42,3 +42,4 @@ export * from "./evm/wallet/EVMSigner";
 
 export * from "./chains/citrea/CitreaInitializer";
 export * from "./chains/citrea/CitreaChainType";
+export * from "./chains/citrea/CitreaFees";