@atomiqlabs/chain-evm 1.0.0-dev.62 → 1.0.0-dev.64

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

@@ -1,134 +1,134 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMLpVault = void 0;
-const EVMSwapModule_1 = require("../EVMSwapModule");
-const EVMFees_1 = require("../../chain/modules/EVMFees");
-class EVMLpVault extends EVMSwapModule_1.EVMSwapModule {
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     * @private
-     */
-    async Withdraw(signer, token, amount, feeRate) {
-        const tx = await this.swapContract.withdraw.populateTransaction(token, amount, signer);
-        tx.from = signer;
-        tx.gasLimit = BigInt(EVMLpVault.GasCosts.WITHDRAW);
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.WITHDRAW, feeRate);
-        return tx;
-    }
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     * @private
-     */
-    async Deposit(signer, token, amount, feeRate) {
-        const tx = await this.swapContract.deposit.populateTransaction(token, amount, {
-            value: token.toLowerCase() === this.root.getNativeCurrencyAddress().toLowerCase() ? amount : 0n
-        });
-        tx.from = signer;
-        EVMFees_1.EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.DEPOSIT, feeRate);
-        return tx;
-    }
-    /**
-     * Returns intermediary's reputation & vault balance for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryData(address, token) {
-        const [balance, reputation] = await Promise.all([
-            this.getIntermediaryBalance(address, token),
-            this.getIntermediaryReputation(address, token)
-        ]);
-        return { balance, reputation };
-    }
-    /**
-     * Returns intermediary's reputation for a specific token
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryReputation(address, token) {
-        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => ({ owner: address, token, claimHandler }));
-        const resp = await this.swapContract.getReputation(filter);
-        if (resp.length !== filter.length)
-            throw new Error("getIntermediaryReputation(): Invalid response length");
-        const result = {};
-        Object.keys(this.contract.claimHandlersByAddress).forEach((address, index) => {
-            const handler = this.contract.claimHandlersByAddress[address.toLowerCase()];
-            const handlerResp = resp[index];
-            result[handler.getType()] = {
-                successVolume: handlerResp[0].amount,
-                successCount: handlerResp[0].count,
-                coopCloseVolume: handlerResp[1].amount,
-                coopCloseCount: handlerResp[1].count,
-                failVolume: handlerResp[2].amount,
-                failCount: handlerResp[2].count,
-            };
-        });
-        return result;
-    }
-    /**
-     * Returns the balance of the token an intermediary has in his LP vault
-     *
-     * @param address
-     * @param token
-     */
-    async getIntermediaryBalance(address, token) {
-        const [balance] = await this.swapContract.getBalance([{ owner: address, token }]);
-        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: " + token.toString() +
-            " address: " + address + " amount: " + (balance == null ? "null" : balance.toString()));
-        return balance;
-    }
-    /**
-     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
-     *  WSOL to SOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    async txsWithdraw(signer, token, amount, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const withdrawTx = await this.Withdraw(signer, token, amount, feeRate);
-        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10));
-        return [withdrawTx];
-    }
-    /**
-     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @param feeRate
-     */
-    async txsDeposit(signer, token, amount, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const txs = [];
-        //Approve first
-        if (token.toLowerCase() !== this.root.getNativeCurrencyAddress().toLowerCase()) {
-            const approveTx = await this.root.Tokens.checkAndGetApproveTx(signer, token, amount, this.contract.contractAddress, feeRate);
-            if (approveTx != null)
-                txs.push(approveTx);
-        }
-        txs.push(await this.Deposit(signer, token, amount, feeRate));
-        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10));
-        return txs;
-    }
-}
-exports.EVMLpVault = EVMLpVault;
-EVMLpVault.GasCosts = {
-    WITHDRAW: 100000 + 21000,
-    DEPOSIT: 100000 + 21000
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMLpVault = void 0;
+const EVMSwapModule_1 = require("../EVMSwapModule");
+const EVMFees_1 = require("../../chain/modules/EVMFees");
+class EVMLpVault extends EVMSwapModule_1.EVMSwapModule {
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @private
+     */
+    async Withdraw(signer, token, amount, feeRate) {
+        const tx = await this.swapContract.withdraw.populateTransaction(token, amount, signer);
+        tx.from = signer;
+        tx.gasLimit = BigInt(EVMLpVault.GasCosts.WITHDRAW);
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.WITHDRAW, feeRate);
+        return tx;
+    }
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @private
+     */
+    async Deposit(signer, token, amount, feeRate) {
+        const tx = await this.swapContract.deposit.populateTransaction(token, amount, {
+            value: token.toLowerCase() === this.root.getNativeCurrencyAddress().toLowerCase() ? amount : 0n
+        });
+        tx.from = signer;
+        EVMFees_1.EVMFees.applyFeeRate(tx, EVMLpVault.GasCosts.DEPOSIT, feeRate);
+        return tx;
+    }
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryData(address, token) {
+        const [balance, reputation] = await Promise.all([
+            this.getIntermediaryBalance(address, token),
+            this.getIntermediaryReputation(address, token)
+        ]);
+        return { balance, reputation };
+    }
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryReputation(address, token) {
+        const filter = Object.keys(this.contract.claimHandlersByAddress).map(claimHandler => ({ owner: address, token, claimHandler }));
+        const resp = await this.swapContract.getReputation(filter);
+        if (resp.length !== filter.length)
+            throw new Error("getIntermediaryReputation(): Invalid response length");
+        const result = {};
+        Object.keys(this.contract.claimHandlersByAddress).forEach((address, index) => {
+            const handler = this.contract.claimHandlersByAddress[address.toLowerCase()];
+            const handlerResp = resp[index];
+            result[handler.getType()] = {
+                successVolume: handlerResp[0].amount,
+                successCount: handlerResp[0].count,
+                coopCloseVolume: handlerResp[1].amount,
+                coopCloseCount: handlerResp[1].count,
+                failVolume: handlerResp[2].amount,
+                failCount: handlerResp[2].count,
+            };
+        });
+        return result;
+    }
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    async getIntermediaryBalance(address, token) {
+        const [balance] = await this.swapContract.getBalance([{ owner: address, token }]);
+        this.logger.debug("getIntermediaryBalance(): token LP balance fetched, token: " + token.toString() +
+            " address: " + address + " amount: " + (balance == null ? "null" : balance.toString()));
+        return balance;
+    }
+    /**
+     * Creates transactions for withdrawing funds from the LP vault, creates ATA if it doesn't exist and unwraps
+     *  WSOL to SOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    async txsWithdraw(signer, token, amount, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const withdrawTx = await this.Withdraw(signer, token, amount, feeRate);
+        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10));
+        return [withdrawTx];
+    }
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    async txsDeposit(signer, token, amount, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const txs = [];
+        //Approve first
+        if (token.toLowerCase() !== this.root.getNativeCurrencyAddress().toLowerCase()) {
+            const approveTx = await this.root.Tokens.checkAndGetApproveTx(signer, token, amount, this.contract.contractAddress, feeRate);
+            if (approveTx != null)
+                txs.push(approveTx);
+        }
+        txs.push(await this.Deposit(signer, token, amount, feeRate));
+        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10));
+        return txs;
+    }
+}
+exports.EVMLpVault = EVMLpVault;
+EVMLpVault.GasCosts = {
+    WITHDRAW: 100000 + 21000,
+    DEPOSIT: 100000 + 21000
+};

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

@@ -1,54 +1,54 @@
-import { RelaySynchronizer } from "@atomiqlabs/base";
-import { EVMSwapModule } from "../EVMSwapModule";
-import { EVMSwapData } from "../EVMSwapData";
-import { EVMTx } from "../../chain/modules/EVMTransactions";
-import { EVMBtcStoredHeader } from "../../btcrelay/headers/EVMBtcStoredHeader";
-export declare class EVMSwapClaim extends EVMSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param feeRate
-     * @param claimHandlerGas
-     * @private
-     */
-    private Claim;
-    /**
-     * Creates transactions claiming the swap using a secret (for HTLC swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param secret hex encoded secret pre-image to the HTLC hash
-     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
-     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
-     * @param feeRate fee rate to use for the transaction
-     */
-    txsClaimWithSecret(signer: string, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, feeRate?: string): Promise<EVMTx[]>;
-    /**
-     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param tx bitcoin transaction that satisfies the swap condition
-     * @param requiredConfirmations
-     * @param vout vout of the bitcoin transaction that satisfies the swap condition
-     * @param commitedHeader commited header data from btc relay (fetched internally if null)
-     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
-     * @param feeRate fee rate to be used for the transactions
-     */
-    txsClaimWithTxData(signer: string, swapData: EVMSwapData, tx: {
-        blockhash: string;
-        confirmations: number;
-        txid: string;
-        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
-     */
-    getClaimFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
-}
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import { EVMSwapModule } from "../EVMSwapModule";
+import { EVMSwapData } from "../EVMSwapData";
+import { EVMTx } from "../../chain/modules/EVMTransactions";
+import { EVMBtcStoredHeader } from "../../btcrelay/headers/EVMBtcStoredHeader";
+export declare class EVMSwapClaim extends EVMSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param claimHandlerGas
+     * @private
+     */
+    private Claim;
+    /**
+     * Creates transactions claiming the swap using a secret (for HTLC swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param secret hex encoded secret pre-image to the HTLC hash
+     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
+     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
+     * @param feeRate fee rate to use for the transaction
+     */
+    txsClaimWithSecret(signer: string, swapData: EVMSwapData, secret: string, checkExpiry?: boolean, feeRate?: string): Promise<EVMTx[]>;
+    /**
+     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param tx bitcoin transaction that satisfies the swap condition
+     * @param requiredConfirmations
+     * @param vout vout of the bitcoin transaction that satisfies the swap condition
+     * @param commitedHeader commited header data from btc relay (fetched internally if null)
+     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
+     * @param feeRate fee rate to be used for the transactions
+     */
+    txsClaimWithTxData(signer: string, swapData: EVMSwapData, tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        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
+     */
+    getClaimFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+}

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

@@ -1,137 +1,137 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMSwapClaim = void 0;
-const base_1 = require("@atomiqlabs/base");
-const EVMSwapModule_1 = require("../EVMSwapModule");
-const EVMFees_1 = require("../../chain/modules/EVMFees");
-class EVMSwapClaim extends EVMSwapModule_1.EVMSwapModule {
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param feeRate
-     * @param claimHandlerGas
-     * @private
-     */
-    async Claim(signer, swapData, witness, feeRate, claimHandlerGas) {
-        //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, this.getClaimGas(swapData) + (claimHandlerGas ?? 0), feeRate);
-        return tx;
-    }
-    /**
-     * Creates transactions claiming the swap using a secret (for HTLC swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param secret hex encoded secret pre-image to the HTLC hash
-     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
-     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
-     * @param feeRate fee rate to use for the transaction
-     */
-    async txsClaimWithSecret(signer, swapData, secret, checkExpiry, feeRate) {
-        //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
-        // and won't claim the funds
-        if (checkExpiry && await this.contract.isExpired(swapData.claimer.toString(), swapData)) {
-            throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
-        }
-        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-        if (claimHandler == null)
-            throw new base_1.SwapDataVerificationError("Unknown claim handler!");
-        if (claimHandler.getType() !== base_1.ChainSwapType.HTLC)
-            throw new base_1.SwapDataVerificationError("Invalid claim handler!");
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const { initialTxns, witness } = await claimHandler.getWitness(signer, swapData, secret, feeRate);
-        const tx = await this.Claim(signer, swapData, witness, feeRate, claimHandler.getGas(swapData));
-        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() + " witness: ", witness.toString("hex"));
-        return [...initialTxns, tx];
-    }
-    /**
-     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
-     *
-     * @param signer
-     * @param swapData swap to claim
-     * @param tx bitcoin transaction that satisfies the swap condition
-     * @param requiredConfirmations
-     * @param vout vout of the bitcoin transaction that satisfies the swap condition
-     * @param commitedHeader commited header data from btc relay (fetched internally if null)
-     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
-     * @param feeRate fee rate to be used for the transactions
-     */
-    async txsClaimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, feeRate) {
-        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-        if (claimHandler == null)
-            throw new base_1.SwapDataVerificationError("Unknown claim handler!");
-        if (claimHandler.getType() !== base_1.ChainSwapType.CHAIN_NONCED &&
-            claimHandler.getType() !== base_1.ChainSwapType.CHAIN_TXID &&
-            claimHandler.getType() !== base_1.ChainSwapType.CHAIN)
-            throw new base_1.SwapDataVerificationError("Invalid claim handler!");
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        const { initialTxns, witness } = await claimHandler.getWitness(signer, swapData, {
-            tx,
-            vout,
-            requiredConfirmations,
-            commitedHeader,
-            btcRelay: this.contract.btcRelay,
-            synchronizer,
-        }, feeRate);
-        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 = this.getClaimGas(swapData);
-        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
-        if (claimHandler != null)
-            gasRequired += claimHandler.getGas(swapData);
-        return EVMFees_1.EVMFees.getGasFee(gasRequired, feeRate);
-    }
-}
-exports.EVMSwapClaim = EVMSwapClaim;
-EVMSwapClaim.GasCosts = {
-    BASE: 30000 + 21000,
-    ERC20_TRANSFER: 40000,
-    NATIVE_TRANSFER: 35500,
-    LP_VAULT_TRANSFER: 10000,
-    REPUTATION: 25000
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMSwapClaim = void 0;
+const base_1 = require("@atomiqlabs/base");
+const EVMSwapModule_1 = require("../EVMSwapModule");
+const EVMFees_1 = require("../../chain/modules/EVMFees");
+class EVMSwapClaim extends EVMSwapModule_1.EVMSwapModule {
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param claimHandlerGas
+     * @private
+     */
+    async Claim(signer, swapData, witness, feeRate, claimHandlerGas) {
+        //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, this.getClaimGas(swapData) + (claimHandlerGas ?? 0), feeRate);
+        return tx;
+    }
+    /**
+     * Creates transactions claiming the swap using a secret (for HTLC swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param secret hex encoded secret pre-image to the HTLC hash
+     * @param checkExpiry whether to check if the swap is already expired (trying to claim an expired swap with a secret
+     *  is dangerous because we might end up revealing the secret to the counterparty without being able to claim the swap)
+     * @param feeRate fee rate to use for the transaction
+     */
+    async txsClaimWithSecret(signer, swapData, secret, checkExpiry, feeRate) {
+        //We need to be sure that this transaction confirms in time, otherwise we reveal the secret to the counterparty
+        // and won't claim the funds
+        if (checkExpiry && await this.contract.isExpired(swapData.claimer.toString(), swapData)) {
+            throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
+        }
+        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if (claimHandler == null)
+            throw new base_1.SwapDataVerificationError("Unknown claim handler!");
+        if (claimHandler.getType() !== base_1.ChainSwapType.HTLC)
+            throw new base_1.SwapDataVerificationError("Invalid claim handler!");
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await claimHandler.getWitness(signer, swapData, secret, feeRate);
+        const tx = await this.Claim(signer, swapData, witness, feeRate, claimHandler.getGas(swapData));
+        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() + " witness: ", witness.toString("hex"));
+        return [...initialTxns, tx];
+    }
+    /**
+     * Creates transaction claiming the swap using a confirmed transaction data (for BTC on-chain swaps)
+     *
+     * @param signer
+     * @param swapData swap to claim
+     * @param tx bitcoin transaction that satisfies the swap condition
+     * @param requiredConfirmations
+     * @param vout vout of the bitcoin transaction that satisfies the swap condition
+     * @param commitedHeader commited header data from btc relay (fetched internally if null)
+     * @param synchronizer optional synchronizer to use in case we need to sync up the btc relay ourselves
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsClaimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, feeRate) {
+        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if (claimHandler == null)
+            throw new base_1.SwapDataVerificationError("Unknown claim handler!");
+        if (claimHandler.getType() !== base_1.ChainSwapType.CHAIN_NONCED &&
+            claimHandler.getType() !== base_1.ChainSwapType.CHAIN_TXID &&
+            claimHandler.getType() !== base_1.ChainSwapType.CHAIN)
+            throw new base_1.SwapDataVerificationError("Invalid claim handler!");
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await claimHandler.getWitness(signer, swapData, {
+            tx,
+            vout,
+            requiredConfirmations,
+            commitedHeader,
+            btcRelay: this.contract.btcRelay,
+            synchronizer,
+        }, feeRate);
+        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 = this.getClaimGas(swapData);
+        const claimHandler = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if (claimHandler != null)
+            gasRequired += claimHandler.getGas(swapData);
+        return EVMFees_1.EVMFees.getGasFee(gasRequired, feeRate);
+    }
+}
+exports.EVMSwapClaim = EVMSwapClaim;
+EVMSwapClaim.GasCosts = {
+    BASE: 30000 + 21000,
+    ERC20_TRANSFER: 40000,
+    NATIVE_TRANSFER: 35500,
+    LP_VAULT_TRANSFER: 10000,
+    REPUTATION: 25000
+};