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

package/dist/evm/chain/modules/EVMAddresses.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMAddresses = void 0;
 const EVMModule_1 = require("../EVMModule");
 const ethers_1 = require("ethers");
+const lib_esm_1 = require("ethers/lib.esm");
 class EVMAddresses extends EVMModule_1.EVMModule {
     ///////////////////
     //// Address utils
@@ -22,5 +23,9 @@ class EVMAddresses extends EVMModule_1.EVMModule {
             return false;
         }
     }
+    static randomAddress() {
+        const wallet = lib_esm_1.Wallet.createRandom();
+        return wallet.address;
+    }
 }
 exports.EVMAddresses = EVMAddresses;

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

@@ -1,16 +1,17 @@
-import { Provider, TransactionRequest } from "ethers";
+import { JsonRpcApiProvider, TransactionRequest } from "ethers";
 export type EVMFeeRate = {
     maxFeePerGas: bigint;
     maxPriorityFee: bigint;
 };
 export declare class EVMFees {
-    private readonly logger;
-    private readonly provider;
-    private readonly maxFeeRatePerGas;
-    private readonly priorityFee;
-    private readonly feeMultiplierPPM;
+    protected MAX_FEE_AGE: number;
+    protected readonly logger: import("../../../utils/Utils").LoggerType;
+    protected readonly provider: JsonRpcApiProvider;
+    protected readonly maxFeeRatePerGas: bigint;
+    protected readonly priorityFee: bigint;
+    protected readonly feeMultiplierPPM: bigint;
     private blockFeeCache;
-    constructor(provider: Provider, maxFeeRatePerGas?: bigint, priorityFee?: bigint, feeMultiplier?: number);
+    constructor(provider: JsonRpcApiProvider, maxFeeRatePerGas?: bigint, priorityFee?: bigint, feeMultiplier?: number);
     /**
      * Gets evm fee rate
      *

package/dist/evm/chain/modules/EVMFees.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EVMFees = void 0;
 const Utils_1 = require("../../../utils/Utils");
-const MAX_FEE_AGE = 5000;
 class EVMFees {
     constructor(provider, maxFeeRatePerGas = 500n * 1000000000n, priorityFee = 1n * 1000000000n, feeMultiplier = 1.25) {
+        this.MAX_FEE_AGE = 5000;
         this.logger = (0, Utils_1.getLogger)("EVMFees: ");
         this.blockFeeCache = null;
         this.provider = provider;
@@ -30,7 +30,7 @@ class EVMFees {
      * @private
      */
     async getFeeRate() {
-        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
@@ -67,7 +67,7 @@ class EVMFees {
         const [baseFee, priorityFee] = feeRate.split(",");
         tx.maxFeePerGas = BigInt(baseFee) + BigInt(priorityFee);
         tx.maxPriorityFeePerGas = BigInt(priorityFee);
-        tx.gasLimit = BigInt(gas) + 21000n;
+        tx.gasLimit = BigInt(gas);
     }
 }
 exports.EVMFees = EVMFees;

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

@@ -46,4 +46,6 @@ export declare class EVMTokens extends EVMModule<any> {
      * @private
      */
     Approve(signer: string, token: string, amount: bigint, spender: string, feeRate?: string): Promise<TransactionRequest>;
+    getApproveFee(feeRate?: string): Promise<bigint>;
+    getTransferFee(feeRate?: string): Promise<bigint>;
 }

package/dist/evm/chain/modules/EVMTokens.js

@@ -96,10 +96,18 @@ class EVMTokens extends EVMModule_1.EVMModule {
             " token: " + token.toString() + " amount: " + amount.toString(10));
         return tx;
     }
+    async getApproveFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
+    async getTransferFee(feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return EVMFees_1.EVMFees.getGasFee(EVMTokens.GasCosts.APPROVE, feeRate);
+    }
 }
 exports.EVMTokens = EVMTokens;
 EVMTokens.ETH_ADDRESS = "0x0000000000000000000000000000000000000000";
 EVMTokens.GasCosts = {
-    TRANSFER: 80000,
-    APPROVE: 80000
+    TRANSFER: 80000 + 21000,
+    APPROVE: 80000 + 21000
 };

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

@@ -15,7 +15,19 @@ 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_BASE: number;
+        DEPOSIT_ERC20: number;
+        OPEN: number;
+        CLAIM_BASE: number;
+        CLAIM_NATIVE_TRANSFER: number;
+        CLAIM_ERC20_TRANSFER: number;
+        CLAIM_EXECUTION_SCHEDULE: number;
+        FRONT_BASE: number;
+        FRONT_NATIVE_TRANSFER: number;
+        FRONT_ERC20_TRANSFER: number;
+        FRONT_EXECUTION_SCHEDULE: number;
+    };
     readonly chainId: ChainId;
     readonly btcRelay: EVMBtcRelay<any>;
     readonly bitcoinRpc: BitcoinRpc<any>;
@@ -59,6 +71,8 @@ export declare class EVMSpvVaultContract<ChainId extends string> extends EVMCont
     txsDeposit(signer: string, vault: EVMSpvVaultData, rawAmounts: bigint[], feeRate?: string): Promise<EVMTx[]>;
     txsFrontLiquidity(signer: string, vault: EVMSpvVaultData, realWithdrawalTx: EVMSpvWithdrawalData, withdrawSequence: number, feeRate?: string): Promise<EVMTx[]>;
     txsOpen(signer: string, vault: EVMSpvVaultData, feeRate?: string): Promise<EVMTx[]>;
-    getClaimFee(signer: string, withdrawalData: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
-    getFrontFee(signer: string, withdrawalData: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    getClaimGas(signer: string, vault: EVMSpvVaultData, data?: EVMSpvWithdrawalData): number;
+    getFrontGas(signer: string, vault: EVMSpvVaultData, data?: EVMSpvWithdrawalData): number;
+    getClaimFee(signer: string, vault: EVMSpvVaultData, withdrawalData: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
+    getFrontFee(signer: string, vault?: EVMSpvVaultData, withdrawalData?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint>;
 }

package/dist/evm/spv_swap/EVMSpvVaultContract.js

@@ -49,14 +49,25 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
         return tx;
     }
     async Deposit(signer, vault, rawAmounts, feeRate) {
+        let totalGas = EVMSpvVaultContract.GasCosts.DEPOSIT_BASE;
         let value = 0n;
-        if (vault.token0.token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase())
+        if (vault.token0.token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase()) {
             value += rawAmounts[0] * vault.token0.multiplier;
-        if (vault.token1.token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase())
+        }
+        else {
+            if (rawAmounts[0] > 0n)
+                totalGas += EVMSpvVaultContract.GasCosts.DEPOSIT_ERC20;
+        }
+        if (vault.token1.token.toLowerCase() === this.Chain.getNativeCurrencyAddress().toLowerCase()) {
             value += (rawAmounts[1] ?? 0n) * vault.token1.multiplier;
+        }
+        else {
+            if (rawAmounts[1] != null && rawAmounts[1] > 0n && vault.token0.token.toLowerCase() !== vault.token1.token.toLowerCase())
+                totalGas += EVMSpvVaultContract.GasCosts.DEPOSIT_ERC20;
+        }
         const tx = await this.contract.deposit.populateTransaction(vault.owner, vault.vaultId, vault.getVaultParamsStruct(), rawAmounts[0], rawAmounts[1] ?? 0n, { value });
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMSpvVaultContract.GasCosts.DEPOSIT, feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, totalGas, feeRate);
         return tx;
     }
     async Front(signer, vault, data, withdrawalSequence, feeRate) {
@@ -68,13 +79,13 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             value += (frontingAmount[1] ?? 0n) * vault.token1.multiplier;
         const tx = await this.contract.front.populateTransaction(vault.owner, vault.vaultId, vault.getVaultParamsStruct(), withdrawalSequence, data.getTxHash(), data.serializeToStruct(), { value });
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMSpvVaultContract.GasCosts.FRONT, feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getFrontGas(signer, vault, data), feeRate);
         return tx;
     }
     async Claim(signer, vault, data, blockheader, merkle, position, feeRate) {
         const tx = await this.contract.claim.populateTransaction(vault.owner, vault.vaultId, vault.getVaultParamsStruct(), "0x" + data.btcTx.hex, blockheader.serializeToStruct(), merkle, position);
         tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMSpvVaultContract.GasCosts.CLAIM, feeRate);
+        EVMFees_1.EVMFees.applyFeeRate(tx, this.getClaimGas(signer, vault, data), feeRate);
         return tx;
     }
     async checkWithdrawalTx(tx) {
@@ -392,19 +403,78 @@ class EVMSpvVaultContract extends EVMContractBase_1.EVMContractBase {
             " vaultId: " + vault.getVaultId().toString(10));
         return [tx];
     }
-    async getClaimFee(signer, withdrawalData, feeRate) {
+    getClaimGas(signer, vault, data) {
+        let totalGas = EVMSpvVaultContract.GasCosts.CLAIM_BASE;
+        if (data == null || (data.rawAmounts[0] != null && data.rawAmounts[0] > 0n)) {
+            const transferFee = vault.token0.token.toLowerCase() === this.Chain.getNativeCurrencyAddress() ?
+                EVMSpvVaultContract.GasCosts.CLAIM_NATIVE_TRANSFER : EVMSpvVaultContract.GasCosts.CLAIM_ERC20_TRANSFER;
+            totalGas += transferFee;
+            if (data == null || data.frontingFeeRate > 0n)
+                totalGas += transferFee; //Also needs to pay out to fronter
+            if (data == null || (data.callerFeeRate > 0n && !data.isRecipient(signer)))
+                totalGas += transferFee; //Also needs to pay out to caller
+        }
+        if (data == null || (data.rawAmounts[1] != null && data.rawAmounts[1] > 0n)) {
+            const transferFee = vault.token1.token.toLowerCase() === this.Chain.getNativeCurrencyAddress() ?
+                EVMSpvVaultContract.GasCosts.CLAIM_NATIVE_TRANSFER : EVMSpvVaultContract.GasCosts.CLAIM_ERC20_TRANSFER;
+            totalGas += transferFee;
+            if (data == null || data.frontingFeeRate > 0n)
+                totalGas += transferFee; //Also needs to pay out to fronter
+            if (data == null || (data.callerFeeRate > 0n && !data.isRecipient(signer)))
+                totalGas += transferFee; //Also needs to pay out to caller
+        }
+        if (data == null || (data.executionHash != null && data.executionHash !== ethers_1.ZeroHash))
+            totalGas += EVMSpvVaultContract.GasCosts.CLAIM_EXECUTION_SCHEDULE;
+        return totalGas;
+    }
+    getFrontGas(signer, vault, data) {
+        let totalGas = EVMSpvVaultContract.GasCosts.FRONT_BASE;
+        if (data == null || (data.rawAmounts[0] != null && data.rawAmounts[0] > 0n)) {
+            totalGas += vault.token0.token.toLowerCase() === this.Chain.getNativeCurrencyAddress() ?
+                EVMSpvVaultContract.GasCosts.FRONT_NATIVE_TRANSFER : EVMSpvVaultContract.GasCosts.FRONT_ERC20_TRANSFER;
+        }
+        if (data == null || (data.rawAmounts[1] != null && data.rawAmounts[1] > 0n)) {
+            totalGas += vault.token1.token.toLowerCase() === this.Chain.getNativeCurrencyAddress() ?
+                EVMSpvVaultContract.GasCosts.FRONT_NATIVE_TRANSFER : EVMSpvVaultContract.GasCosts.FRONT_ERC20_TRANSFER;
+        }
+        if (data == null || (data.executionHash != null && data.executionHash !== ethers_1.ZeroHash))
+            totalGas += EVMSpvVaultContract.GasCosts.FRONT_EXECUTION_SCHEDULE;
+        return totalGas;
+    }
+    async getClaimFee(signer, vault, withdrawalData, feeRate) {
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(EVMSpvVaultContract.GasCosts.CLAIM, feeRate);
+        return EVMFees_1.EVMFees.getGasFee(this.getClaimGas(signer, vault, withdrawalData), feeRate);
     }
-    async getFrontFee(signer, withdrawalData, feeRate) {
+    async getFrontFee(signer, vault, withdrawalData, feeRate) {
+        vault ?? (vault = EVMSpvVaultData_1.EVMSpvVaultData.randomVault());
         feeRate ?? (feeRate = await this.Chain.Fees.getFeeRate());
-        return EVMFees_1.EVMFees.getGasFee(EVMSpvVaultContract.GasCosts.FRONT, feeRate);
+        let totalFee = EVMFees_1.EVMFees.getGasFee(this.getFrontGas(signer, vault, withdrawalData), feeRate);
+        if (withdrawalData == null || (withdrawalData.rawAmounts[0] != null && withdrawalData.rawAmounts[0] > 0n)) {
+            if (vault.token0.token.toLowerCase() !== this.Chain.getNativeCurrencyAddress().toLowerCase()) {
+                totalFee += await this.Chain.Tokens.getApproveFee(feeRate);
+            }
+        }
+        if (withdrawalData == null || (withdrawalData.rawAmounts[1] != null && withdrawalData.rawAmounts[1] > 0n)) {
+            if (vault.token1.token.toLowerCase() !== this.Chain.getNativeCurrencyAddress().toLowerCase()) {
+                if (vault.token1.token.toLowerCase() !== vault.token0.token.toLowerCase() || withdrawalData == null || withdrawalData.rawAmounts[0] == null || withdrawalData.rawAmounts[0] === 0n) {
+                    totalFee += await this.Chain.Tokens.getApproveFee(feeRate);
+                }
+            }
+        }
+        return totalFee;
     }
 }
 exports.EVMSpvVaultContract = EVMSpvVaultContract;
 EVMSpvVaultContract.GasCosts = {
-    DEPOSIT: 150000,
-    OPEN: 100000,
-    FRONT: 250000,
-    CLAIM: 250000
+    DEPOSIT_BASE: 15000 + 21000,
+    DEPOSIT_ERC20: 40000,
+    OPEN: 80000 + 21000,
+    CLAIM_BASE: 85000 + 21000,
+    CLAIM_NATIVE_TRANSFER: 7500,
+    CLAIM_ERC20_TRANSFER: 40000,
+    CLAIM_EXECUTION_SCHEDULE: 30000,
+    FRONT_BASE: 75000 + 21000,
+    FRONT_NATIVE_TRANSFER: 7500,
+    FRONT_ERC20_TRANSFER: 40000,
+    FRONT_EXECUTION_SCHEDULE: 30000
 };

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

@@ -35,4 +35,5 @@ export declare class EVMSpvVaultData extends SpvVaultData<EVMSpvWithdrawalData>
     updateState(withdrawalTxOrEvent: SpvVaultClaimEvent | SpvVaultCloseEvent | SpvVaultOpenEvent | SpvVaultDepositEvent | EVMSpvWithdrawalData): void;
     getDepositCount(): number;
     getVaultParamsStruct(): SpvVaultParametersStruct;
+    static randomVault(): EVMSpvVaultData;
 }

package/dist/evm/spv_swap/EVMSpvVaultData.js

@@ -6,6 +6,7 @@ const buffer_1 = require("buffer");
 const EVMSpvWithdrawalData_1 = require("./EVMSpvWithdrawalData");
 const ethers_1 = require("ethers");
 const ethers_2 = require("ethers");
+const EVMAddresses_1 = require("../chain/modules/EVMAddresses");
 function getVaultParamsCommitment(vaultParams) {
     return (0, ethers_2.keccak256)(ethers_2.AbiCoder.defaultAbiCoder().encode(["address", "address", "address", "uint192", "uint192", "uint256"], [vaultParams.btcRelayContract, vaultParams.token0, vaultParams.token1, vaultParams.token0Multiplier, vaultParams.token1Multiplier, vaultParams.confirmations]));
 }
@@ -154,6 +155,26 @@ class EVMSpvVaultData extends base_1.SpvVaultData {
             confirmations: this.confirmations
         };
     }
+    static randomVault() {
+        const spvVaultParams = {
+            btcRelayContract: EVMAddresses_1.EVMAddresses.randomAddress(),
+            token0: EVMAddresses_1.EVMAddresses.randomAddress(),
+            token1: EVMAddresses_1.EVMAddresses.randomAddress(),
+            token0Multiplier: 1n,
+            token1Multiplier: 1n,
+            confirmations: 3n,
+        };
+        return new EVMSpvVaultData(EVMAddresses_1.EVMAddresses.randomAddress(), 0n, {
+            spvVaultParametersCommitment: getVaultParamsCommitment(spvVaultParams),
+            utxoTxHash: (0, ethers_1.randomBytes)(32),
+            utxoVout: 0n,
+            openBlockheight: 0n,
+            withdrawCount: 0n,
+            depositCount: 0n,
+            token0Amount: 0n,
+            token1Amount: 0n
+        }, spvVaultParams);
+    }
 }
 exports.EVMSpvVaultData = EVMSpvVaultData;
 base_1.SpvVaultData.deserializers["EVM"] = EVMSpvVaultData;

package/dist/evm/swaps/EVMSwapContract.d.ts

@@ -182,11 +182,11 @@ export declare class EVMSwapContract<ChainId extends string = string> extends EV
     getClaimFeeRate(signer: string, swapData: EVMSwapData): Promise<string>;
     getClaimFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
     /**
-     * Get the estimated solana fee of the commit transaction
+     * Get the estimated fee of the commit transaction
      */
-    getCommitFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    getCommitFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
     /**
-     * Get the estimated solana transaction fee of the refund transaction
+     * Get the estimated transaction fee of the refund transaction
      */
-    getRefundFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+    getRefundFee(signer: string, swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
 }

package/dist/evm/swaps/EVMSwapContract.js

@@ -358,15 +358,15 @@ class EVMSwapContract extends EVMContractBase_1.EVMContractBase {
         return this.Claim.getClaimFee(swapData, feeRate);
     }
     /**
-     * Get the estimated solana fee of the commit transaction
+     * Get the estimated fee of the commit transaction
      */
-    getCommitFee(swapData, feeRate) {
+    getCommitFee(signer, swapData, feeRate) {
         return this.Init.getInitFee(swapData, feeRate);
     }
     /**
-     * Get the estimated solana transaction fee of the refund transaction
+     * Get the estimated transaction fee of the refund transaction
      */
-    getRefundFee(swapData, feeRate) {
+    getRefundFee(signer, swapData, feeRate) {
         return this.Refund.getRefundFee(swapData, feeRate);
     }
 }

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);