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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomiqlabs/chain-evm",
-  "version": "1.0.0-dev.22",
+  "version": "1.0.0-dev.28",
   "description": "EVM specific base implementation",
   "main": "./dist/index.js",
   "types:": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
   "author": "adambor",
   "license": "Apache-2.0",
   "dependencies": {
-    "@atomiqlabs/base": "^10.0.0-dev.1",
+    "@atomiqlabs/base": "^10.0.0-dev.2",
     "@noble/hashes": "^1.8.0",
     "@scure/btc-signer": "1.6.0",
     "buffer": "6.0.3"

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,11 @@ 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";
+import {CitreaSpvVaultContract} from "./CitreaSpvVaultContract";
 
 const CitreaChainIds = {
     MAINNET: null,
@@ -57,12 +62,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 +96,7 @@ export type CitreaOptions = {
         }
     }
 
-    fees?: EVMFees
+    fees?: CitreaFees
 }
 
 export function initializeCitrea(
@@ -112,19 +122,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,
@@ -137,7 +148,7 @@ export function initializeCitrea(
         }
     );
 
-    const spvVaultContract = new EVMSpvVaultContract(
+    const spvVaultContract = new CitreaSpvVaultContract(
         chainInterface, btcRelay, bitcoinRpc, options.spvVaultContract ?? defaultContractAddresses.spvVaultContract,
         options.spvVaultDeploymentHeight ?? defaultContractAddresses.spvVaultDeploymentHeight
     )

package/src/chains/citrea/CitreaSpvVaultContract.ts

@@ -0,0 +1,76 @@
+import {EVMSpvVaultContract} from "../../evm/spv_swap/EVMSpvVaultContract";
+import {EVMSpvWithdrawalData} from "../../evm/spv_swap/EVMSpvWithdrawalData";
+import {EVMSpvVaultData} from "../../evm/spv_swap/EVMSpvVaultData";
+import {ZeroHash} from "ethers/lib.esm";
+import {ZeroAddress} from "ethers";
+import {CitreaFees} from "./CitreaFees";
+import {EVMAddresses} from "../../evm/chain/modules/EVMAddresses";
+
+
+export class CitreaSpvVaultContract extends EVMSpvVaultContract<"CITREA"> {
+
+    public static readonly 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
+    };
+
+    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() ? 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: string, vault?: EVMSpvVaultData, data?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+        vault ??= EVMSpvVaultData.randomVault();
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+        const tokenStateChanges: Set<string> = new Set();
+
+        let diffSize = CitreaSpvVaultContract.StateDiffSize.BASE_DIFF_SIZE;
+        const recipient = data!=null ? data.recipient : 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(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(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 !== ZeroHash)) diffSize += CitreaSpvVaultContract.StateDiffSize.EXECUTION_SCHEDULE_DIFF_SIZE;
+
+        const gasFee = await super.getClaimFee(signer, vault, data, feeRate);
+        return gasFee + CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+
+    async getFrontFee(signer: string, vault?: EVMSpvVaultData, data?: EVMSpvWithdrawalData, feeRate?: string): Promise<bigint> {
+        vault ??= EVMSpvVaultData.randomVault();
+        feeRate ??= await this.Chain.Fees.getFeeRate();
+        const tokenStateChanges: Set<string> = 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 !== ZeroHash)) diffSize += CitreaSpvVaultContract.StateDiffSize.EXECUTION_SCHEDULE_DIFF_SIZE;
+
+        const gasFee = await super.getFrontFee(signer, vault, data, feeRate);
+        return gasFee + CitreaFees.getGasFee(0, feeRate, diffSize);
+    }
+
+}

package/src/chains/citrea/CitreaSwapContract.ts

@@ -0,0 +1,103 @@
+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(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.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.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(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.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.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,
@@ -100,8 +100,7 @@ export class EVMChainInterface<ChainId extends string = string, EVMChainId exten
     }
 
     randomAddress(): string {
-        const wallet = Wallet.createRandom();
-        return wallet.address;
+        return EVMAddresses.randomAddress();
     }
 
     randomSigner(): EVMSigner {

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

@@ -1,5 +1,6 @@
 import {EVMModule} from "../EVMModule";
 import {isAddress} from "ethers";
+import {Wallet} from "ethers/lib.esm";
 
 
 export class EVMAddresses extends EVMModule<any> {
@@ -21,4 +22,9 @@ export class EVMAddresses extends EVMModule<any> {
         }
     }
 
+    static randomAddress(): string {
+        const wallet = Wallet.createRandom();
+        return wallet.address;
+    }
+
 }

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