@atomiqlabs/chain-starknet 4.0.0-dev.12 → 4.0.0-dev.13

package/dist/starknet/swaps/modules/StarknetLpVault.js

@@ -1,122 +1,122 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetLpVault = void 0;
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../chain/StarknetAction");
-const starknet_1 = require("starknet");
-class StarknetLpVault extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Action for withdrawing funds from the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    Withdraw(signer, token, amount) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.withdraw(token, starknet_1.cairo.uint256(amount), signer), StarknetLpVault.GasCosts.WITHDRAW);
-    }
-    /**
-     * Action for depositing funds to the LP vault
-     *
-     * @param signer
-     * @param token
-     * @param amount
-     * @constructor
-     * @private
-     */
-    Deposit(signer, token, amount) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.deposit(token, starknet_1.cairo.uint256(amount)), StarknetLpVault.GasCosts.WITHDRAW);
-    }
-    /**
-     * 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 => starknet_1.cairo.tuple(address, token, claimHandler));
-        const rawReputation = await this.provider.callContract(this.swapContract.populateTransaction.get_reputation(filter));
-        const length = (0, Utils_1.toBigInt)(rawReputation.shift());
-        if (Number(length) !== filter.length)
-            throw new Error("getIntermediaryReputation(): Invalid response length");
-        const result = {};
-        Object.keys(this.contract.claimHandlersByAddress).forEach((address) => {
-            const handler = this.contract.claimHandlersByAddress[address];
-            result[handler.getType()] = {
-                successVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
-                successCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
-                coopCloseVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
-                coopCloseCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
-                failVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
-                failCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
-            };
-        });
-        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 = (0, Utils_1.toBigInt)((await this.swapContract.get_balance([starknet_1.cairo.tuple(address, token)]))[0]);
-        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) {
-        const action = await this.Withdraw(signer, token, amount);
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10));
-        return [await action.tx(feeRate)];
-    }
-    /**
-     * 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) {
-        //Approve first
-        const action = await this.root.Tokens.Approve(signer, this.swapContract.address, token, amount);
-        action.add(this.Deposit(signer, token, amount));
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
-            " amount: " + amount.toString(10));
-        return [await action.tx(feeRate)];
-    }
-}
-exports.StarknetLpVault = StarknetLpVault;
-StarknetLpVault.GasCosts = {
-    WITHDRAW: { l1DataGas: 500, l2Gas: 3200000, l1Gas: 0 },
-    DEPOSIT: { l1: 500, l2Gas: 4000000, l1Gas: 0 }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetLpVault = void 0;
+const Utils_1 = require("../../../utils/Utils");
+const StarknetSwapModule_1 = require("../StarknetSwapModule");
+const StarknetAction_1 = require("../../chain/StarknetAction");
+const starknet_1 = require("starknet");
+class StarknetLpVault extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Withdraw(signer, token, amount) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.withdraw(token, starknet_1.cairo.uint256(amount), signer), StarknetLpVault.GasCosts.WITHDRAW);
+    }
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    Deposit(signer, token, amount) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.deposit(token, starknet_1.cairo.uint256(amount)), StarknetLpVault.GasCosts.WITHDRAW);
+    }
+    /**
+     * 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 => starknet_1.cairo.tuple(address, token, claimHandler));
+        const rawReputation = await this.provider.callContract(this.swapContract.populateTransaction.get_reputation(filter));
+        const length = (0, Utils_1.toBigInt)(rawReputation.shift());
+        if (Number(length) !== filter.length)
+            throw new Error("getIntermediaryReputation(): Invalid response length");
+        const result = {};
+        Object.keys(this.contract.claimHandlersByAddress).forEach((address) => {
+            const handler = this.contract.claimHandlersByAddress[address];
+            result[handler.getType()] = {
+                successVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
+                successCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
+                coopCloseVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
+                coopCloseCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
+                failVolume: (0, Utils_1.toBigInt)({ low: rawReputation.shift(), high: rawReputation.shift() }),
+                failCount: (0, Utils_1.toBigInt)(rawReputation.shift()),
+            };
+        });
+        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 = (0, Utils_1.toBigInt)((await this.swapContract.get_balance([starknet_1.cairo.tuple(address, token)]))[0]);
+        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) {
+        const action = await this.Withdraw(signer, token, amount);
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        this.logger.debug("txsWithdraw(): withdraw TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10));
+        return [await action.tx(feeRate)];
+    }
+    /**
+     * 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) {
+        //Approve first
+        const action = await this.root.Tokens.Approve(signer, this.swapContract.address, token, amount);
+        action.add(this.Deposit(signer, token, amount));
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        this.logger.debug("txsDeposit(): deposit TX created, token: " + token.toString() +
+            " amount: " + amount.toString(10));
+        return [await action.tx(feeRate)];
+    }
+}
+exports.StarknetLpVault = StarknetLpVault;
+StarknetLpVault.GasCosts = {
+    WITHDRAW: { l1DataGas: 500, l2Gas: 3200000, l1Gas: 0 },
+    DEPOSIT: { l1: 500, l2Gas: 4000000, l1Gas: 0 }
+};

package/dist/starknet/swaps/modules/StarknetSwapClaim.d.ts

@@ -1,53 +1,53 @@
-import { RelaySynchronizer } from "@atomiqlabs/base";
-import { StarknetSwapModule } from "../StarknetSwapModule";
-import { StarknetSwapData } from "../StarknetSwapData";
-import { StarknetTx } from "../../chain/modules/StarknetTransactions";
-import { StarknetBtcStoredHeader } from "../../btcrelay/headers/StarknetBtcStoredHeader";
-export declare class StarknetSwapClaim extends StarknetSwapModule {
-    private static readonly GasCosts;
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param claimHandlerGas
-     * @constructor
-     * @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: StarknetSwapData, secret: string, checkExpiry?: boolean, feeRate?: string): Promise<StarknetTx[]>;
-    /**
-     * 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: StarknetSwapData, tx: {
-        blockhash: string;
-        confirmations: number;
-        txid: string;
-        hex: string;
-        height: number;
-    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<StarknetTx[] | null>;
-    /**
-     * Get the estimated starknet transaction fee of the claim transaction
-     */
-    getClaimFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint>;
-}
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetSwapData } from "../StarknetSwapData";
+import { StarknetTx } from "../../chain/modules/StarknetTransactions";
+import { StarknetBtcStoredHeader } from "../../btcrelay/headers/StarknetBtcStoredHeader";
+export declare class StarknetSwapClaim extends StarknetSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param claimHandlerGas
+     * @constructor
+     * @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: StarknetSwapData, secret: string, checkExpiry?: boolean, feeRate?: string): Promise<StarknetTx[]>;
+    /**
+     * 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: StarknetSwapData, tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    }, requiredConfirmations: number, vout: number, commitedHeader?: StarknetBtcStoredHeader, synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<StarknetTx[] | null>;
+    /**
+     * Get the estimated starknet transaction fee of the claim transaction
+     */
+    getClaimFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint>;
+}

package/dist/starknet/swaps/modules/StarknetSwapClaim.js

@@ -1,100 +1,100 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StarknetSwapClaim = void 0;
-const base_1 = require("@atomiqlabs/base");
-const Utils_1 = require("../../../utils/Utils");
-const StarknetSwapModule_1 = require("../StarknetSwapModule");
-const StarknetAction_1 = require("../../chain/StarknetAction");
-const StarknetFees_1 = require("../../chain/modules/StarknetFees");
-class StarknetSwapClaim extends StarknetSwapModule_1.StarknetSwapModule {
-    /**
-     * Claim action which uses the provided witness for claiming the swap
-     *
-     * @param signer
-     * @param swapData
-     * @param witness
-     * @param claimHandlerGas
-     * @constructor
-     * @private
-     */
-    Claim(signer, swapData, witness, claimHandlerGas) {
-        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas));
-    }
-    /**
-     * 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[(0, Utils_1.toHex)(swapData.claimHandler)];
-        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 action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
-        await action.addToTxs(initialTxns, feeRate);
-        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() + " witness: ", witness.map(Utils_1.toHex));
-        return initialTxns;
-    }
-    /**
-     * 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[(0, Utils_1.toHex)(swapData.claimHandler)];
-        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 action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
-        await action.addToTxs(initialTxns, feeRate);
-        return initialTxns;
-    }
-    /**
-     * Get the estimated starknet transaction fee of the claim transaction
-     */
-    async getClaimFee(swapData, feeRate) {
-        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
-        let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
-        const claimHandler = this.contract.claimHandlersByAddress[(0, Utils_1.toHex)(swapData.claimHandler)];
-        if (claimHandler != null)
-            gasRequired = (0, StarknetFees_1.starknetGasAdd)(gasRequired, claimHandler.getGas(swapData));
-        return StarknetFees_1.StarknetFees.getGasFee(gasRequired, feeRate);
-    }
-}
-exports.StarknetSwapClaim = StarknetSwapClaim;
-StarknetSwapClaim.GasCosts = {
-    CLAIM: { l1DataGas: 750, l2Gas: 4000000, l1Gas: 0 },
-    CLAIM_PAY_OUT: { l1DataGas: 900, l2Gas: 6000000, l1Gas: 0 }
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapClaim = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const StarknetSwapModule_1 = require("../StarknetSwapModule");
+const StarknetAction_1 = require("../../chain/StarknetAction");
+const StarknetFees_1 = require("../../chain/modules/StarknetFees");
+class StarknetSwapClaim extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param claimHandlerGas
+     * @constructor
+     * @private
+     */
+    Claim(signer, swapData, witness, claimHandlerGas) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.swapContract.populateTransaction.claim(swapData.toEscrowStruct(), witness), (0, StarknetFees_1.starknetGasAdd)(swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM, claimHandlerGas));
+    }
+    /**
+     * 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[(0, Utils_1.toHex)(swapData.claimHandler)];
+        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 action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+        this.logger.debug("txsClaimWithSecret(): creating claim transaction, swap: " + swapData.getClaimHash() + " witness: ", witness.map(Utils_1.toHex));
+        return initialTxns;
+    }
+    /**
+     * 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[(0, Utils_1.toHex)(swapData.claimHandler)];
+        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 action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+        return initialTxns;
+    }
+    /**
+     * Get the estimated starknet transaction fee of the claim transaction
+     */
+    async getClaimFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        let gasRequired = swapData.payOut ? StarknetSwapClaim.GasCosts.CLAIM_PAY_OUT : StarknetSwapClaim.GasCosts.CLAIM;
+        const claimHandler = this.contract.claimHandlersByAddress[(0, Utils_1.toHex)(swapData.claimHandler)];
+        if (claimHandler != null)
+            gasRequired = (0, StarknetFees_1.starknetGasAdd)(gasRequired, claimHandler.getGas(swapData));
+        return StarknetFees_1.StarknetFees.getGasFee(gasRequired, feeRate);
+    }
+}
+exports.StarknetSwapClaim = StarknetSwapClaim;
+StarknetSwapClaim.GasCosts = {
+    CLAIM: { l1DataGas: 750, l2Gas: 4000000, l1Gas: 0 },
+    CLAIM_PAY_OUT: { l1DataGas: 900, l2Gas: 6000000, l1Gas: 0 }
+};