@atomiqlabs/chain-starknet 1.0.0-beta.0

package/dist/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.d.ts

@@ -0,0 +1,20 @@
+import { StarknetSwapData } from "../../../StarknetSwapData";
+import { StarknetGas } from "../../../../base/StarknetAction";
+import { ChainSwapType } from "@atomiqlabs/base";
+import { BigNumberish } from "starknet";
+import { StarknetTx } from "../../../../base/modules/StarknetTransactions";
+import { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
+export type BitcoinTxIdCommitmentData = {
+    txId: string;
+};
+export declare class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
+    static readonly type: ChainSwapType;
+    static readonly gas: StarknetGas;
+    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): BigNumberish[];
+    getWitness(signer: string, swapData: StarknetSwapData, witnessData: BitcoinWitnessData, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    getGas(data: StarknetSwapData): StarknetGas;
+    getType(): ChainSwapType;
+}

package/dist/starknet/swaps/handlers/claim/btc/BitcoinTxIdClaimHandler.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinTxIdClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../../../utils/Utils");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const logger = (0, Utils_1.getLogger)("BitcoinTxIdClaimHandler: ");
+class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        return [
+            ...(0, Utils_1.bufferToU32Array)(Buffer.from(data.txId, "hex").reverse()),
+            ...super.serializeCommitment(data)
+        ];
+    }
+    getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        return this._getWitness(signer, swapData, witnessData, { txId: witnessData.tx.txid });
+    }
+    getGas(data) {
+        return BitcoinTxIdClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinTxIdClaimHandler.type;
+    }
+}
+exports.BitcoinTxIdClaimHandler = BitcoinTxIdClaimHandler;
+BitcoinTxIdClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
+BitcoinTxIdClaimHandler.gas = { l1: 20000 };

package/dist/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.d.ts

@@ -0,0 +1,64 @@
+import { IClaimHandler } from "../ClaimHandlers";
+import { StarknetSwapData } from "../../../StarknetSwapData";
+import { StarknetGas } from "../../../../base/StarknetAction";
+import { ChainSwapType, RelaySynchronizer } from "@atomiqlabs/base";
+import { BigNumberish } from "starknet";
+import { StarknetBtcStoredHeader } from "../../../../btcrelay/headers/StarknetBtcStoredHeader";
+import { StarknetTx } from "../../../../base/modules/StarknetTransactions";
+import { StarknetBtcRelay } from "../../../../btcrelay/StarknetBtcRelay";
+export type BitcoinCommitmentData = {
+    btcRelay: StarknetBtcRelay<any>;
+    confirmations: number;
+};
+export type BitcoinWitnessData = {
+    tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    };
+    requiredConfirmations: number;
+    commitedHeader?: StarknetBtcStoredHeader;
+    btcRelay?: StarknetBtcRelay<any>;
+    synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>;
+};
+export declare abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
+    readonly address: string;
+    constructor(address: string);
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param txBlockheight transaction blockheight
+     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
+     * @param blockhash blockhash of the block which includes the transaction
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    protected getCommitedHeaderAndSynchronize(signer: string, btcRelay: StarknetBtcRelay<any>, txBlockheight: number, requiredConfirmations: number, blockhash: string, txs: StarknetTx[], synchronizer?: RelaySynchronizer<StarknetBtcStoredHeader, StarknetTx, any>, feeRate?: string): Promise<StarknetBtcStoredHeader>;
+    static readonly address = "";
+    static readonly type: ChainSwapType;
+    static readonly gas: StarknetGas;
+    protected serializeCommitment(data: BitcoinCommitmentData): BigNumberish[];
+    getCommitment(data: C & BitcoinCommitmentData): BigNumberish;
+    protected _getWitness(signer: string, swapData: StarknetSwapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }: BitcoinWitnessData, commitment: C, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    abstract getWitness(signer: string, data: StarknetSwapData, witnessData: W, feeRate?: string): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    abstract getGas(data: StarknetSwapData): StarknetGas;
+    abstract getType(): ChainSwapType;
+    parseWitnessResult(result: BigNumberish[]): string;
+}

package/dist/starknet/swaps/handlers/claim/btc/IBitcoinClaimHandler.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBitcoinClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const starknet_1 = require("starknet");
+const Utils_1 = require("../../../../../utils/Utils");
+const logger = (0, Utils_1.getLogger)("IBitcoinClaimHandler: ");
+class IBitcoinClaimHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    /**
+     * Gets committed header, identified by blockhash & blockheight, determines required BTC relay blockheight based on
+     *  requiredConfirmations
+     * If synchronizer is passed & blockhash is not found, it produces transactions to sync up the btc relay to the
+     *  current chain tip & adds them to the txs array
+     *
+     * @param signer
+     * @param btcRelay
+     * @param txBlockheight transaction blockheight
+     * @param requiredConfirmations required confirmation for the swap to be claimable with that TX
+     * @param blockhash blockhash of the block which includes the transaction
+     * @param txs solana transaction array, in case we need to synchronize the btc relay ourselves the synchronization
+     *  txns are added here
+     * @param synchronizer optional synchronizer to use to synchronize the btc relay in case it is not yet synchronized
+     *  to the required blockheight
+     * @param feeRate Fee rate to use for synchronization transactions
+     * @private
+     */
+    async getCommitedHeaderAndSynchronize(signer, btcRelay, txBlockheight, requiredConfirmations, blockhash, txs, synchronizer, feeRate) {
+        const requiredBlockheight = txBlockheight + requiredConfirmations - 1;
+        const result = await (0, Utils_1.tryWithRetries)(() => btcRelay.retrieveLogAndBlockheight({
+            blockhash: blockhash
+        }, requiredBlockheight));
+        if (result != null)
+            return result.header;
+        //Need to synchronize
+        if (synchronizer == null)
+            return null;
+        //TODO: We don't have to synchronize to tip, only to our required blockheight
+        const resp = await synchronizer.syncToLatestTxs(signer.toString(), feeRate);
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay not synchronized to required blockheight, " +
+            "synchronizing ourselves in " + resp.txs.length + " txs");
+        logger.debug("getCommitedHeaderAndSynchronize(): BTC Relay computed header map: ", resp.computedHeaderMap);
+        resp.txs.forEach(tx => txs.push(tx));
+        //Retrieve computed header
+        return resp.computedHeaderMap[txBlockheight];
+    }
+    serializeCommitment(data) {
+        return [
+            data.confirmations,
+            data.btcRelay.contract.address
+        ];
+    }
+    getCommitment(data) {
+        return starknet_1.hash.computePoseidonHashOnElements(this.serializeCommitment(data));
+    }
+    async _getWitness(signer, swapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }, commitment, feeRate) {
+        const serializedData = this.serializeCommitment({
+            ...commitment,
+            btcRelay,
+            confirmations: requiredConfirmations
+        });
+        const commitmentHash = starknet_1.hash.computePoseidonHashOnElements(serializedData);
+        if (!swapData.isClaimData(commitmentHash))
+            throw new Error("Invalid commit data");
+        const merkleProof = await btcRelay.bitcoinRpc.getMerkleProof(tx.txid, tx.blockhash);
+        logger.debug("getWitness(): merkle proof computed: ", merkleProof);
+        const txs = [];
+        if (commitedHeader == null)
+            commitedHeader = await this.getCommitedHeaderAndSynchronize(signer, btcRelay, tx.height, requiredConfirmations, tx.blockhash, txs, synchronizer, feeRate);
+        if (commitedHeader == null)
+            throw new Error("Cannot fetch committed header!");
+        serializedData.push(...commitedHeader.serialize());
+        serializedData.push(merkleProof.merkle.length, ...merkleProof.merkle.map(Utils_1.bufferToU32Array).flat());
+        serializedData.push(merkleProof.pos);
+        return { initialTxns: txs, witness: serializedData };
+    }
+    parseWitnessResult(result) {
+        return (0, Utils_1.u32ArrayToBuffer)(result).toString("hex");
+    }
+}
+exports.IBitcoinClaimHandler = IBitcoinClaimHandler;
+IBitcoinClaimHandler.address = "";
+IBitcoinClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
+IBitcoinClaimHandler.gas = { l1: 20000 };

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.d.ts

@@ -0,0 +1,17 @@
+import { StarknetTx } from "../../../base/modules/StarknetTransactions";
+import { StarknetSwapData } from "../../StarknetSwapData";
+import { BigNumberish } from "starknet";
+import { IHandler } from "../IHandler";
+import { StarknetGas } from "../../../base/StarknetAction";
+export declare class TimelockRefundHandler implements IHandler<bigint, never> {
+    readonly address: string;
+    static readonly gas: StarknetGas;
+    constructor(address: string);
+    getCommitment(data: bigint): BigNumberish;
+    getWitness(signer: string, data: StarknetSwapData): Promise<{
+        initialTxns: StarknetTx[];
+        witness: BigNumberish[];
+    }>;
+    getGas(): StarknetGas;
+    static getExpiry(data: StarknetSwapData): bigint;
+}

package/dist/starknet/swaps/handlers/refund/TimelockRefundHandler.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelockRefundHandler = void 0;
+const Utils_1 = require("../../../../utils/Utils");
+class TimelockRefundHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    getCommitment(data) {
+        return data;
+    }
+    getWitness(signer, data) {
+        const expiry = TimelockRefundHandler.getExpiry(data);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        if (expiry > currentTimestamp)
+            throw new Error("Not expired yet!");
+        return Promise.resolve({ initialTxns: [], witness: [] });
+    }
+    getGas() {
+        return TimelockRefundHandler.gas;
+    }
+    static getExpiry(data) {
+        return (0, Utils_1.bigNumberishToBuffer)(data.refundData, 32).readBigUInt64BE(24);
+    }
+}
+exports.TimelockRefundHandler = TimelockRefundHandler;
+TimelockRefundHandler.gas = { l1: 500 };

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

@@ -0,0 +1,69 @@
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetTx } from "../../base/modules/StarknetTransactions";
+export declare class StarknetLpVault extends StarknetSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Withdraw;
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @constructor
+     * @private
+     */
+    private Deposit;
+    /**
+     * Returns intermediary's reputation & vault balance for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryData(address: string, token: string): Promise<{
+        balance: bigint;
+        reputation: IntermediaryReputationType;
+    }>;
+    /**
+     * Returns intermediary's reputation for a specific token
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryReputation(address: string, token: string): Promise<IntermediaryReputationType>;
+    /**
+     * Returns the balance of the token an intermediary has in his LP vault
+     *
+     * @param address
+     * @param token
+     */
+    getIntermediaryBalance(address: string, token: string): Promise<bigint>;
+    /**
+     * 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
+     */
+    txsWithdraw(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
+    /**
+     * Creates transaction for depositing funds into the LP vault, wraps SOL to WSOL if required
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     */
+    txsDeposit(signer: string, token: string, amount: bigint, feeRate?: string): Promise<StarknetTx[]>;
+}

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

@@ -0,0 +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("../../base/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.contract.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.contract.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.root.claimHandlersByAddress).map(claimHandler => starknet_1.cairo.tuple(address, token, claimHandler));
+        const rawReputation = await this.provider.callContract(this.contract.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.root.claimHandlersByAddress).forEach((address) => {
+            const handler = this.root.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.contract.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.contract.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: { l1: 750, l2: 0 },
+    DEPOSIT: { l1: 750, l2: 0 }
+};

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

@@ -0,0 +1,53 @@
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetSwapData } from "../StarknetSwapData";
+import { StarknetTx } from "../../base/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

@@ -0,0 +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("../../base/StarknetAction");
+const StarknetFees_1 = require("../../base/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.contract.populateTransaction.claim(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(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.root.isExpired(swapData.claimer.toString(), swapData)) {
+            throw new base_1.SwapDataVerificationError("Not enough time to reliably pay the invoice");
+        }
+        const claimHandler = this.root.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 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.root.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.root.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.root.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if (claimHandler != null)
+            gasRequired = (0, StarknetAction_1.sumStarknetGas)(gasRequired, claimHandler.getGas(swapData));
+        return StarknetFees_1.StarknetFees.getGasFee(gasRequired.l1, feeRate);
+    }
+}
+exports.StarknetSwapClaim = StarknetSwapClaim;
+StarknetSwapClaim.GasCosts = {
+    CLAIM: { l1: 500, l2: 0 },
+    CLAIM_PAY_OUT: { l1: 1000, l2: 0 }
+};