@atomiqlabs/chain-evm 1.0.0-dev.22

package/dist/evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainSwapType } from "@atomiqlabs/base";
+import { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
+import { Buffer } from "buffer";
+import { EVMTx } from "../../../../chain/modules/EVMTransactions";
+import { EVMSwapData } from "../../../EVMSwapData";
+export type BitcoinOutputCommitmentData = {
+    output: Buffer;
+    amount: bigint;
+};
+export type BitcoinOutputWitnessData = BitcoinWitnessData & {
+    vout: number;
+};
+export declare class BitcoinOutputClaimHandler extends IBitcoinClaimHandler<BitcoinOutputCommitmentData, BitcoinOutputWitnessData> {
+    static readonly type: ChainSwapType;
+    static readonly gas: number;
+    protected serializeCommitment(data: BitcoinOutputCommitmentData & BitcoinCommitmentData): Buffer;
+    getWitness(signer: string, swapData: EVMSwapData, witnessData: BitcoinOutputWitnessData, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    getGas(data: EVMSwapData): number;
+    getType(): ChainSwapType;
+}

package/dist/evm/swaps/handlers/claim/btc/BitcoinOutputClaimHandler.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinOutputClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const buffer_1 = require("buffer");
+const ethers_1 = require("ethers");
+const btc_signer_1 = require("@scure/btc-signer");
+class BitcoinOutputClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        const txoHash = (0, ethers_1.solidityPackedKeccak256)(["uint64", "bytes32"], [data.amount, (0, ethers_1.keccak256)(data.output)]);
+        return buffer_1.Buffer.concat([
+            buffer_1.Buffer.from(txoHash.substring(2), "hex"),
+            super.serializeCommitment(data)
+        ]);
+    }
+    async getWitness(signer, swapData, witnessData, feeRate) {
+        if (!swapData.isClaimHandler(this.address))
+            throw new Error("Invalid claim handler");
+        const txBuffer = buffer_1.Buffer.from(witnessData.tx.hex, "hex");
+        const parsedBtcTx = btc_signer_1.Transaction.fromRaw(txBuffer);
+        const out = parsedBtcTx.getOutput(witnessData.vout);
+        const { initialTxns, commitment, blockheader, merkleProof } = await this._getWitness(signer, swapData, witnessData, {
+            output: buffer_1.Buffer.from(out.script),
+            amount: out.amount
+        });
+        const voutAndTxData = buffer_1.Buffer.concat([
+            base_1.BigIntBufferUtils.toBuffer(BigInt(witnessData.vout), "be", 4),
+            base_1.BigIntBufferUtils.toBuffer(BigInt(txBuffer.length), "be", 32),
+            txBuffer
+        ]);
+        return {
+            initialTxns,
+            witness: buffer_1.Buffer.concat([
+                commitment,
+                blockheader,
+                voutAndTxData,
+                merkleProof
+            ])
+        };
+    }
+    getGas(data) {
+        return BitcoinOutputClaimHandler.gas;
+    }
+    getType() {
+        return BitcoinOutputClaimHandler.type;
+    }
+}
+exports.BitcoinOutputClaimHandler = BitcoinOutputClaimHandler;
+BitcoinOutputClaimHandler.type = base_1.ChainSwapType.CHAIN;
+BitcoinOutputClaimHandler.gas = 40000;

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

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChainSwapType } from "@atomiqlabs/base";
+import { BitcoinCommitmentData, BitcoinWitnessData, IBitcoinClaimHandler } from "./IBitcoinClaimHandler";
+import { Buffer } from "buffer";
+import { EVMSwapData } from "../../../EVMSwapData";
+import { EVMTx } from "../../../../chain/modules/EVMTransactions";
+export type BitcoinTxIdCommitmentData = {
+    txId: string;
+};
+export declare class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler<BitcoinTxIdCommitmentData, BitcoinWitnessData> {
+    static readonly type: ChainSwapType;
+    static readonly gas: number;
+    protected serializeCommitment(data: BitcoinTxIdCommitmentData & BitcoinCommitmentData): Buffer;
+    getWitness(signer: string, swapData: EVMSwapData, witnessData: BitcoinWitnessData, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    getGas(data: EVMSwapData): number;
+    getType(): ChainSwapType;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitcoinTxIdClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const IBitcoinClaimHandler_1 = require("./IBitcoinClaimHandler");
+const buffer_1 = require("buffer");
+class BitcoinTxIdClaimHandler extends IBitcoinClaimHandler_1.IBitcoinClaimHandler {
+    serializeCommitment(data) {
+        return buffer_1.Buffer.concat([
+            buffer_1.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 = 10000;

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

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IClaimHandler } from "../ClaimHandlers";
+import { ChainSwapType, RelaySynchronizer } from "@atomiqlabs/base";
+import { EVMBtcRelay } from "../../../../btcrelay/EVMBtcRelay";
+import { EVMBtcStoredHeader } from "../../../../btcrelay/headers/EVMBtcStoredHeader";
+import { EVMTx } from "../../../../chain/modules/EVMTransactions";
+import { Buffer } from "buffer";
+import { EVMSwapData } from "../../../EVMSwapData";
+export type BitcoinCommitmentData = {
+    btcRelay: EVMBtcRelay<any>;
+    confirmations: number;
+};
+export type BitcoinWitnessData = {
+    tx: {
+        blockhash: string;
+        confirmations: number;
+        txid: string;
+        hex: string;
+        height: number;
+    };
+    requiredConfirmations: number;
+    commitedHeader?: EVMBtcStoredHeader;
+    btcRelay?: EVMBtcRelay<any>;
+    synchronizer?: RelaySynchronizer<EVMBtcStoredHeader, EVMTx, any>;
+};
+export declare abstract class IBitcoinClaimHandler<C, W extends BitcoinWitnessData> implements IClaimHandler<C & BitcoinCommitmentData, W> {
+    readonly address: string;
+    constructor(address: string);
+    static readonly address = "";
+    static readonly type: ChainSwapType;
+    static readonly gas: number;
+    protected serializeCommitment(data: BitcoinCommitmentData): Buffer;
+    getCommitment(data: C & BitcoinCommitmentData): string;
+    protected _getWitness(signer: string, swapData: EVMSwapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }: BitcoinWitnessData, commitment: C, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+        commitment: Buffer;
+        blockheader: Buffer;
+        merkleProof: Buffer;
+    }>;
+    abstract getWitness(signer: string, data: EVMSwapData, witnessData: W, feeRate?: string): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    abstract getGas(data: EVMSwapData): number;
+    abstract getType(): ChainSwapType;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IBitcoinClaimHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+const EVMBtcRelay_1 = require("../../../../btcrelay/EVMBtcRelay");
+const Utils_1 = require("../../../../../utils/Utils");
+const ethers_1 = require("ethers");
+const buffer_1 = require("buffer");
+const logger = (0, Utils_1.getLogger)("IBitcoinClaimHandler: ");
+class IBitcoinClaimHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    serializeCommitment(data) {
+        const buffer = buffer_1.Buffer.alloc(24);
+        buffer.writeUint32BE(data.confirmations, 0);
+        buffer_1.Buffer.from(data.btcRelay.contractAddress.substring(2), "hex").copy(buffer, 4, 0, 20);
+        return buffer;
+    }
+    getCommitment(data) {
+        return (0, ethers_1.keccak256)(this.serializeCommitment(data));
+    }
+    async _getWitness(signer, swapData, { tx, btcRelay, commitedHeader, synchronizer, requiredConfirmations }, commitment, feeRate) {
+        const serializedCommitment = this.serializeCommitment({
+            ...commitment,
+            btcRelay,
+            confirmations: requiredConfirmations
+        });
+        const commitmentHash = (0, ethers_1.keccak256)(serializedCommitment);
+        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) {
+            const headers = await EVMBtcRelay_1.EVMBtcRelay.getCommitedHeadersAndSynchronize(signer, btcRelay, [{ blockheight: tx.height, requiredConfirmations, blockhash: tx.blockhash }], txs, synchronizer, feeRate);
+            if (headers == null)
+                throw new Error("Cannot fetch committed header!");
+            commitedHeader = headers[tx.blockhash];
+        }
+        const serializedHeader = commitedHeader.serialize();
+        const serializedMerkleProof = buffer_1.Buffer.concat([
+            base_1.BigIntBufferUtils.toBuffer(BigInt(merkleProof.pos), "be", 4),
+            base_1.BigIntBufferUtils.toBuffer(BigInt(merkleProof.merkle.length), "be", 32),
+            ...merkleProof.merkle
+        ]);
+        return {
+            initialTxns: txs,
+            witness: buffer_1.Buffer.concat([
+                serializedCommitment,
+                serializedHeader,
+                serializedMerkleProof
+            ]),
+            commitment: serializedCommitment,
+            blockheader: serializedHeader,
+            merkleProof: serializedMerkleProof
+        };
+    }
+}
+exports.IBitcoinClaimHandler = IBitcoinClaimHandler;
+IBitcoinClaimHandler.address = "";
+IBitcoinClaimHandler.type = base_1.ChainSwapType.CHAIN_TXID;
+IBitcoinClaimHandler.gas = 10000;

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IHandler } from "../IHandler";
+import { EVMSwapData } from "../../EVMSwapData";
+import { EVMTx } from "../../../chain/modules/EVMTransactions";
+export declare class TimelockRefundHandler implements IHandler<bigint, never> {
+    readonly address: string;
+    static readonly gas: number;
+    constructor(address: string);
+    getCommitment(data: bigint): string;
+    getWitness(signer: string, data: EVMSwapData): Promise<{
+        initialTxns: EVMTx[];
+        witness: Buffer;
+    }>;
+    getGas(): number;
+    static getExpiry(data: EVMSwapData): bigint;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelockRefundHandler = void 0;
+const base_1 = require("@atomiqlabs/base");
+class TimelockRefundHandler {
+    constructor(address) {
+        this.address = address;
+    }
+    getCommitment(data) {
+        return "0x" + base_1.BigIntBufferUtils.toBuffer(data, "be", 32).toString("hex");
+    }
+    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: Buffer.alloc(0) });
+    }
+    getGas() {
+        return TimelockRefundHandler.gas;
+    }
+    static getExpiry(data) {
+        const expiryDataBuffer = Buffer.from(data.refundData.startsWith("0x") ? data.refundData.substring(2) : data.refundData, "hex");
+        return base_1.BigIntBufferUtils.fromBuffer(expiryDataBuffer, "be");
+    }
+}
+exports.TimelockRefundHandler = TimelockRefundHandler;
+TimelockRefundHandler.gas = 5000;

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

@@ -0,0 +1,69 @@
+import { IntermediaryReputationType } from "@atomiqlabs/base";
+import { EVMSwapModule } from "../EVMSwapModule";
+import { EVMTx } from "../../chain/modules/EVMTransactions";
+export declare class EVMLpVault extends EVMSwapModule {
+    private static readonly GasCosts;
+    /**
+     * Action for withdrawing funds from the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @private
+     */
+    private Withdraw;
+    /**
+     * Action for depositing funds to the LP vault
+     *
+     * @param signer
+     * @param token
+     * @param amount
+     * @param feeRate
+     * @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<EVMTx[]>;
+    /**
+     * 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<EVMTx[]>;
+}

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

@@ -0,0 +1,131 @@
+"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())
+            txs.push(await this.root.Tokens.Approve(signer, token, amount, this.contract.contractAddress, feeRate));
+        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,
+    DEPOSIT: 100000
+};

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

@@ -0,0 +1,53 @@
+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>;
+    /**
+     * Get the estimated starknet transaction fee of the claim transaction
+     */
+    getClaimFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint>;
+}

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

@@ -0,0 +1,101 @@
+"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, EVMSwapClaim.GasCosts.CLAIM + (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];
+    }
+    /**
+     * 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 = EVMSwapClaim.GasCosts.CLAIM;
+        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 = {
+    CLAIM: 120000,
+    CLAIM_WITH_SUCCESS_ACTION: 150000
+};