@atomiqlabs/chain-starknet 1.0.0-beta.0

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

@@ -0,0 +1,84 @@
+import { StarknetSwapData } from "../StarknetSwapData";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetSigner } from "../../wallet/StarknetSigner";
+import { StarknetTx } from "../../base/modules/StarknetTransactions";
+export type StarknetPreFetchVerification = {
+    pendingBlockTime?: number;
+};
+export declare class StarknetSwapInit extends StarknetSwapModule {
+    private static readonly GasCosts;
+    /**
+     * bare Init action based on the data passed in swapData
+     *
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @private
+     */
+    private Init;
+    /**
+     * Returns auth prefix to be used with a specific swap, payIn=true & payIn=false use different prefixes (these
+     *  actually have no meaning for the smart contract/solana program in the Solana case)
+     *
+     * @param swapData
+     * @private
+     */
+    private getAuthPrefix;
+    preFetchForInitSignatureVerification(): Promise<StarknetPreFetchVerification>;
+    /**
+     * Signs swap initialization authorization, using data from preFetchedBlockData if provided & still valid (subject
+     *  to SIGNATURE_PREFETCH_DATA_VALIDITY)
+     *
+     * @param signer
+     * @param swapData
+     * @param authorizationTimeout
+     * @public
+     */
+    signSwapInitialization(signer: StarknetSigner, swapData: StarknetSwapData, authorizationTimeout: number): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+    }>;
+    /**
+     * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
+     *
+     * @param swapData
+     * @param timeout
+     * @param prefix
+     * @param signature
+     * @param preFetchData
+     * @public
+     */
+    isSignatureValid(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string, preFetchData?: StarknetPreFetchVerification): Promise<null>;
+    /**
+     * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
+     *
+     * @param timeout
+     * @public
+     */
+    getSignatureExpiry(timeout: string): Promise<number>;
+    /**
+     * Checks whether signature is expired for good, compares the timestamp to the current "pending" block timestamp
+     *
+     * @param timeout
+     * @param preFetchData
+     * @public
+     */
+    isSignatureExpired(timeout: string, preFetchData?: StarknetPreFetchVerification): Promise<boolean>;
+    /**
+     * Creates init transaction with a valid signature from an LP
+     *
+     * @param swapData swap to initialize
+     * @param timeout init signature timeout
+     * @param prefix init signature prefix
+     * @param signature init signature
+     * @param skipChecks whether to skip signature validity checks
+     * @param feeRate fee rate to use for the transaction
+     */
+    txsInit(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string, skipChecks?: boolean, feeRate?: string): Promise<StarknetTx[]>;
+    /**
+     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
+     *  and also deposit for ATAs
+     */
+    getInitFee(swapData?: StarknetSwapData, feeRate?: string): Promise<bigint>;
+}

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapInit = void 0;
+const base_1 = require("@atomiqlabs/base");
+const Utils_1 = require("../../../utils/Utils");
+const buffer_1 = require("buffer");
+const StarknetAction_1 = require("../../base/StarknetAction");
+const StarknetSwapModule_1 = require("../StarknetSwapModule");
+const StarknetFees_1 = require("../../base/modules/StarknetFees");
+const Initialize = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+class StarknetSwapInit extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * bare Init action based on the data passed in swapData
+     *
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @private
+     */
+    Init(swapData, timeout, signature) {
+        return new StarknetAction_1.StarknetAction(swapData.payIn ? swapData.offerer : swapData.claimer, this.root, this.contract.populateTransaction.initialize(swapData.toEscrowStruct(), signature, timeout, swapData.extraData == null || swapData.extraData === "" ? [] : (0, Utils_1.bufferToBytes31Span)(buffer_1.Buffer.from(swapData.extraData, "hex")).map(Utils_1.toHex)), swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN : StarknetSwapInit.GasCosts.INIT);
+    }
+    /**
+     * Returns auth prefix to be used with a specific swap, payIn=true & payIn=false use different prefixes (these
+     *  actually have no meaning for the smart contract/solana program in the Solana case)
+     *
+     * @param swapData
+     * @private
+     */
+    getAuthPrefix(swapData) {
+        return swapData.isPayIn() ? "claim_initialize" : "initialize";
+    }
+    async preFetchForInitSignatureVerification() {
+        return {
+            pendingBlockTime: await this.root.Blocks.getBlockTime("pending")
+        };
+    }
+    /**
+     * Signs swap initialization authorization, using data from preFetchedBlockData if provided & still valid (subject
+     *  to SIGNATURE_PREFETCH_DATA_VALIDITY)
+     *
+     * @param signer
+     * @param swapData
+     * @param authorizationTimeout
+     * @public
+     */
+    async signSwapInitialization(signer, swapData, authorizationTimeout) {
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(signer, Initialize, "Initialize", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(authTimeout)
+        });
+        return {
+            prefix: this.getAuthPrefix(swapData),
+            timeout: authTimeout.toString(10),
+            signature
+        };
+    }
+    /**
+     * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
+     *
+     * @param swapData
+     * @param timeout
+     * @param prefix
+     * @param signature
+     * @param preFetchData
+     * @public
+     */
+    async isSignatureValid(swapData, timeout, prefix, signature, preFetchData) {
+        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        const signer = swapData.isPayIn() ? swapData.claimer : swapData.offerer;
+        if (!swapData.isPayIn() && await this.root.isExpired(sender.toString(), swapData)) {
+            throw new base_1.SignatureVerificationError("Swap will expire too soon!");
+        }
+        if (prefix !== this.getAuthPrefix(swapData))
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const timeoutBN = BigInt(timeout);
+        const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        if (await this.isSignatureExpired(timeout, preFetchData))
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(signature, signer, Initialize, "Initialize", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(timeoutBN)
+        });
+        if (!valid)
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        return null;
+    }
+    /**
+     * Gets expiry of the provided signature data, this is a minimum of slot expiry & swap signature expiry
+     *
+     * @param timeout
+     * @public
+     */
+    async getSignatureExpiry(timeout) {
+        const now = Date.now();
+        const timeoutExpiryTime = (parseInt(timeout) - this.root.authGracePeriod) * 1000;
+        if (timeoutExpiryTime < now)
+            return 0;
+        return timeoutExpiryTime;
+    }
+    /**
+     * Checks whether signature is expired for good, compares the timestamp to the current "pending" block timestamp
+     *
+     * @param timeout
+     * @param preFetchData
+     * @public
+     */
+    async isSignatureExpired(timeout, preFetchData) {
+        if (preFetchData == null || preFetchData.pendingBlockTime == null) {
+            preFetchData = await this.preFetchForInitSignatureVerification();
+        }
+        return preFetchData.pendingBlockTime > parseInt(timeout);
+    }
+    /**
+     * Creates init transaction with a valid signature from an LP
+     *
+     * @param swapData swap to initialize
+     * @param timeout init signature timeout
+     * @param prefix init signature prefix
+     * @param signature init signature
+     * @param skipChecks whether to skip signature validity checks
+     * @param feeRate fee rate to use for the transaction
+     */
+    async txsInit(swapData, timeout, prefix, signature, skipChecks, feeRate) {
+        const sender = swapData.isPayIn() ? swapData.offerer : swapData.claimer;
+        if (!skipChecks) {
+            const [_, payStatus] = await Promise.all([
+                (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError),
+                (0, Utils_1.tryWithRetries)(() => this.root.getCommitStatus(sender, swapData), this.retryPolicy)
+            ]);
+            if (payStatus !== base_1.SwapCommitStatus.NOT_COMMITED)
+                throw new base_1.SwapDataVerificationError("Invoice already being paid for or paid");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const initAction = this.Init(swapData, BigInt(timeout), JSON.parse(signature));
+        if (swapData.payIn)
+            initAction.addAction(this.root.Tokens.Approve(sender, this.contract.address, swapData.token, swapData.amount), 0); //Add erc20 approve
+        if (swapData.getTotalDeposit() !== 0n)
+            initAction.addAction(this.root.Tokens.Approve(sender, this.contract.address, swapData.feeToken, swapData.getTotalDeposit()), 0); //Add deposit erc20 approve
+        this.logger.debug("txsInitPayIn(): create swap init TX, swap: " + swapData.getClaimHash() +
+            " feerate: " + feeRate);
+        return [await initAction.tx(feeRate)];
+    }
+    /**
+     * Get the estimated solana fee of the init transaction, this includes the required deposit for creating swap PDA
+     *  and also deposit for ATAs
+     */
+    async getInitFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapInit.GasCosts.INIT_PAY_IN.l1 : StarknetSwapInit.GasCosts.INIT.l1, feeRate);
+    }
+}
+exports.StarknetSwapInit = StarknetSwapInit;
+StarknetSwapInit.GasCosts = {
+    INIT: { l1: 500, l2: 0 },
+    INIT_PAY_IN: { l1: 1000, l2: 0 },
+};

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

@@ -0,0 +1,64 @@
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetSwapData } from "../StarknetSwapData";
+import { StarknetSwapContract } from "../StarknetSwapContract";
+import { StarknetTx } from "../../base/modules/StarknetTransactions";
+import { StarknetSigner } from "../../wallet/StarknetSigner";
+export declare class StarknetSwapRefund extends StarknetSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param handlerGas
+     * @constructor
+     * @private
+     */
+    private Refund;
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @constructor
+     * @private
+     */
+    private RefundWithSignature;
+    constructor(root: StarknetSwapContract);
+    signSwapRefund(signer: StarknetSigner, swapData: StarknetSwapData, authorizationTimeout: number): Promise<{
+        prefix: string;
+        timeout: string;
+        signature: string;
+    }>;
+    isSignatureValid(swapData: StarknetSwapData, timeout: string, prefix: string, signature: string): Promise<null>;
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    txsRefund<T>(signer: string, swapData: StarknetSwapData, check?: boolean, feeRate?: string, witnessData?: T): Promise<StarknetTx[]>;
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    txsRefundWithAuthorization(signer: string, swapData: StarknetSwapData, timeout: string, prefix: string, signature: string, check?: boolean, feeRate?: string): Promise<StarknetTx[]>;
+    /**
+     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
+     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     */
+    getRefundFee(swapData: StarknetSwapData, feeRate?: string): Promise<bigint>;
+}

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StarknetSwapRefund = 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");
+const Refund = [
+    { name: 'Swap hash', type: 'felt' },
+    { name: 'Timeout', type: 'timestamp' }
+];
+class StarknetSwapRefund extends StarknetSwapModule_1.StarknetSwapModule {
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param handlerGas
+     * @constructor
+     * @private
+     */
+    Refund(signer, swapData, witness, handlerGas) {
+        return new StarknetAction_1.StarknetAction(signer, this.root, this.contract.populateTransaction.refund(swapData.toEscrowStruct(), witness), (0, StarknetAction_1.sumStarknetGas)(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND, handlerGas));
+    }
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @constructor
+     * @private
+     */
+    RefundWithSignature(sender, swapData, timeout, signature) {
+        return new StarknetAction_1.StarknetAction(sender, this.root, this.contract.populateTransaction.cooperative_refund(swapData.toEscrowStruct(), signature, BigInt(timeout)), swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT : StarknetSwapRefund.GasCosts.REFUND);
+    }
+    constructor(root) {
+        super(root);
+    }
+    async signSwapRefund(signer, swapData, authorizationTimeout) {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now() / 1000) + authorizationTimeout;
+        const signature = await this.root.Signatures.signTypedMessage(signer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(authTimeout)
+        });
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+    async isSignatureValid(swapData, timeout, prefix, signature) {
+        if (prefix !== "refund")
+            throw new base_1.SignatureVerificationError("Invalid prefix");
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.root.authGracePeriod);
+        if (isExpired)
+            throw new base_1.SignatureVerificationError("Authorization expired!");
+        const valid = await this.root.Signatures.isValidSignature(signature, swapData.claimer, Refund, "Refund", {
+            "Swap hash": "0x" + swapData.getEscrowHash(),
+            "Timeout": (0, Utils_1.toHex)(expiryTimestamp)
+        });
+        if (!valid) {
+            throw new base_1.SignatureVerificationError("Invalid signature!");
+        }
+        return null;
+    }
+    /**
+     * Creates transactions required for refunding timed out swap
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param check whether to check if swap is already expired and refundable
+     * @param feeRate fee rate to be used for the transactions
+     * @param witnessData
+     */
+    async txsRefund(signer, swapData, check, feeRate, witnessData) {
+        const refundHandler = this.root.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if (refundHandler == null)
+            throw new Error("Invalid refund handler");
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.root.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not refundable yet!");
+        }
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        const { initialTxns, witness } = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+        const action = this.Refund(signer, swapData, witness, refundHandler.getGas(swapData));
+        await action.addToTxs(initialTxns, feeRate);
+        this.logger.debug("txsRefund(): creating refund transaction, swap: " + swapData.getClaimHash());
+        return initialTxns;
+    }
+    /**
+     * Creates transactions required for refunding the swap with authorization signature, also unwraps WSOL to SOL
+     *
+     * @param signer
+     * @param swapData swap data to refund
+     * @param timeout signature timeout
+     * @param prefix signature prefix of the counterparty
+     * @param signature signature of the counterparty
+     * @param check whether to check if swap is committed before attempting refund
+     * @param feeRate fee rate to be used for the transactions
+     */
+    async txsRefundWithAuthorization(signer, swapData, timeout, prefix, signature, check, feeRate) {
+        if (check && !await (0, Utils_1.tryWithRetries)(() => this.root.isCommited(swapData), this.retryPolicy)) {
+            throw new base_1.SwapDataVerificationError("Not correctly committed");
+        }
+        await (0, Utils_1.tryWithRetries)(() => this.isSignatureValid(swapData, timeout, prefix, signature), this.retryPolicy, (e) => e instanceof base_1.SignatureVerificationError);
+        const action = this.RefundWithSignature(signer, swapData, timeout, JSON.parse(signature));
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: " + swapData.getClaimHash() +
+            " auth expiry: " + timeout + " signature: " + signature);
+        return [await action.tx(feeRate)];
+    }
+    /**
+     * Get the estimated solana transaction fee of the refund transaction, in the worst case scenario in case where the
+     *  ATA needs to be initialized again (i.e. adding the ATA rent exempt lamports to the fee)
+     */
+    async getRefundFee(swapData, feeRate) {
+        feeRate ?? (feeRate = await this.root.Fees.getFeeRate());
+        return StarknetFees_1.StarknetFees.getGasFee(swapData.payIn ? StarknetSwapRefund.GasCosts.REFUND_PAY_OUT.l1 : StarknetSwapRefund.GasCosts.REFUND.l1, feeRate);
+    }
+}
+exports.StarknetSwapRefund = StarknetSwapRefund;
+StarknetSwapRefund.GasCosts = {
+    REFUND: { l1: 750, l2: 0 },
+    REFUND_PAY_OUT: { l1: 1250, l2: 0 }
+};

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

@@ -0,0 +1,54 @@
+import { RelaySynchronizer } from "@atomiqlabs/base";
+import * as BN from "bn.js";
+import { StarknetSwapModule } from "../StarknetSwapModule";
+import { StarknetSwapData } from "../StarknetSwapData";
+import { StarknetTx } from "../../base/modules/StarknetTransactions";
+import { StarknetBtcStoredHeader } from "../../btcrelay/headers/StarknetBtcStoredHeader";
+export declare class SwapClaim 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<BN>;
+}

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

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapClaim = 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 SwapClaim 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 ? SwapClaim.GasCosts.CLAIM_PAY_OUT : SwapClaim.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
+     */
+    txsClaimWithSecret(signer, swapData, secret, checkExpiry, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //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 && (yield 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 !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
+            const { initialTxns, witness } = yield claimHandler.getWitness(signer, swapData, secret, feeRate);
+            const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+            yield 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
+     */
+    txsClaimWithTxData(signer, swapData, tx, requiredConfirmations, vout, commitedHeader, synchronizer, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
+            const { initialTxns, witness } = yield claimHandler.getWitness(signer, swapData, {
+                tx,
+                vout,
+                requiredConfirmations,
+                commitedHeader,
+                btcRelay: this.root.btcRelay,
+                synchronizer,
+            }, feeRate);
+            const action = this.Claim(signer, swapData, witness, claimHandler.getGas(swapData));
+            yield action.addToTxs(initialTxns, feeRate);
+            return initialTxns;
+        });
+    }
+    /**
+     * Get the estimated starknet transaction fee of the claim transaction
+     */
+    getClaimFee(swapData, feeRate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            feeRate !== null && feeRate !== void 0 ? feeRate : (feeRate = yield this.root.Fees.getFeeRate());
+            let gasRequired = swapData.payOut ? SwapClaim.GasCosts.CLAIM_PAY_OUT : SwapClaim.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.SwapClaim = SwapClaim;
+SwapClaim.GasCosts = {
+    CLAIM: { l1: 500, l2: 0 },
+    CLAIM_PAY_OUT: { l1: 1000, l2: 0 }
+};