@atomiqlabs/chain-evm 1.0.0-dev.22

package/src/evm/swaps/modules/EVMSwapClaim.ts

@@ -0,0 +1,141 @@
+import {ChainSwapType, RelaySynchronizer, SwapDataVerificationError} from "@atomiqlabs/base";
+import {IClaimHandler} from "../handlers/claim/ClaimHandlers";
+import {BitcoinOutputWitnessData} from "../handlers/claim/btc/BitcoinOutputClaimHandler";
+import {BitcoinWitnessData} from "../handlers/claim/btc/IBitcoinClaimHandler";
+import {Buffer} from "buffer";
+import {EVMSwapModule} from "../EVMSwapModule";
+import { EVMSwapData } from "../EVMSwapData";
+import {TransactionRequest} from "ethers";
+import {EVMFees} from "../../chain/modules/EVMFees";
+import {EVMTx} from "../../chain/modules/EVMTransactions";
+import {EVMBtcStoredHeader} from "../../btcrelay/headers/EVMBtcStoredHeader";
+
+export class EVMSwapClaim extends EVMSwapModule {
+
+    private static readonly GasCosts = {
+        CLAIM: 120_000,
+        CLAIM_WITH_SUCCESS_ACTION: 150_000
+    };
+
+    /**
+     * Claim action which uses the provided witness for claiming the swap
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param claimHandlerGas
+     * @private
+     */
+    private async Claim(
+        signer: string,
+        swapData: EVMSwapData,
+        witness: Buffer,
+        feeRate: string,
+        claimHandlerGas?: number
+    ): Promise<TransactionRequest> {
+        //TODO: Claim with success action not supported yet!
+        const tx = await this.swapContract.claim.populateTransaction(swapData.toEscrowStruct(), witness);
+        tx.from = signer;
+        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: string,
+        swapData: EVMSwapData,
+        secret: string,
+        checkExpiry?: boolean,
+        feeRate?: string
+    ): Promise<EVMTx[]> {
+        //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 SwapDataVerificationError("Not enough time to reliably pay the invoice");
+        }
+
+        const claimHandler: IClaimHandler<Buffer, string> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
+        if(claimHandler.getType()!==ChainSwapType.HTLC) throw new SwapDataVerificationError("Invalid claim handler!");
+
+        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: 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> {
+        const claimHandler: IClaimHandler<any, BitcoinOutputWitnessData | BitcoinWitnessData> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler==null) throw new SwapDataVerificationError("Unknown claim handler!");
+        if(
+            claimHandler.getType()!==ChainSwapType.CHAIN_NONCED &&
+            claimHandler.getType()!==ChainSwapType.CHAIN_TXID &&
+            claimHandler.getType()!==ChainSwapType.CHAIN
+        ) throw new SwapDataVerificationError("Invalid claim handler!");
+
+        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
+     */
+    public async getClaimFee(swapData: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        //TODO: Claim with success action not supported yet!
+        let gasRequired = EVMSwapClaim.GasCosts.CLAIM;
+
+        const claimHandler: IClaimHandler<any, any> = this.contract.claimHandlersByAddress[swapData.claimHandler.toLowerCase()];
+        if(claimHandler!=null) gasRequired += claimHandler.getGas(swapData);
+
+        return EVMFees.getGasFee(gasRequired, feeRate);
+    }
+
+}

package/src/evm/swaps/modules/EVMSwapInit.ts

@@ -0,0 +1,292 @@
+import {SignatureVerificationError, SwapCommitStateType, SwapDataVerificationError} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import { EVMSwapModule } from "../EVMSwapModule";
+import {EVMSwapData} from "../EVMSwapData";
+import {keccak256, TransactionRequest, ZeroHash} from "ethers";
+import {EVMFees} from "../../chain/modules/EVMFees";
+import {EVMSigner} from "../../wallet/EVMSigner";
+import {EVMTx} from "../../chain/modules/EVMTransactions";
+import {tryWithRetries} from "../../../utils/Utils";
+
+export type EVMPreFetchVerification = {
+    safeBlockTime?: number
+};
+
+const Initialize = [
+    { name: "swapHash", type: "bytes32" },
+    { name: "offerer", type: "address" },
+    { name: "claimer", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "token", type: "address" },
+    { name: "payIn", type: "bool" },
+    { name: "payOut", type: "bool" },
+    { name: "trackingReputation", type: "bool" },
+    { name: "claimHandler", type: "address" },
+    { name: "claimData", type: "bytes32" },
+    { name: "refundHandler", type: "address" },
+    { name: "refundData", type: "bytes32" },
+    { name: "securityDeposit", type: "uint256" },
+    { name: "claimerBounty", type: "uint256" },
+    { name: "depositToken", type: "address" },
+    { name: "claimActionHash", type: "bytes32" },
+    { name: "deadline", type: "uint256" },
+    { name: "extraDataHash", type: "bytes32" }
+];
+
+export class EVMSwapInit extends EVMSwapModule {
+
+    private static readonly GasCosts = {
+        INIT: 100_000,
+        INIT_PAY_IN: 130_000,
+    };
+
+    /**
+     * bare Init action based on the data passed in swapData
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @param feeRate
+     * @private
+     */
+    private async Init(sender: string, swapData: EVMSwapData, timeout: bigint, signature: string, feeRate: string): Promise<TransactionRequest> {
+        let value = 0n;
+        if(swapData.isToken(this.root.getNativeCurrencyAddress())) value += swapData.getAmount();
+        if(swapData.isDepositToken(this.root.getNativeCurrencyAddress())) value += swapData.getTotalDeposit();
+        const tx = await this.swapContract.initialize.populateTransaction(swapData.toEscrowStruct(), signature, timeout, "0x"+(swapData.extraData ?? ""), {
+            value
+        });
+        tx.from = sender;
+        EVMFees.applyFeeRate(tx, swapData.isPayIn() ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+        return tx;
+    }
+
+    /**
+     * 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 in the EVM case)
+     *
+     * @param swapData
+     * @private
+     */
+    private getAuthPrefix(swapData: EVMSwapData): string {
+        return swapData.isPayIn() ? "claim_initialize" : "initialize";
+    }
+
+    public async preFetchForInitSignatureVerification(): Promise<EVMPreFetchVerification> {
+        return {
+            safeBlockTime: await this.root.Blocks.getBlockTime(this.root.config.safeBlockTag)
+        };
+    }
+
+    /**
+     * 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
+     */
+    public async signSwapInitialization(
+        signer: EVMSigner,
+        swapData: EVMSwapData,
+        authorizationTimeout: number
+    ): Promise<{prefix: string, timeout: string, signature: string}> {
+        const authExpiry = Math.floor(Date.now()/1000)+authorizationTimeout;
+
+        const signature = await this.root.Signatures.signTypedMessage(this.contract.contractAddress, signer, Initialize, "Initialize", {
+            "swapHash": "0x"+swapData.getEscrowHash(),
+            "offerer": swapData.offerer,
+            "claimer": swapData.claimer,
+            "amount": swapData.amount,
+            "token": swapData.token,
+            "payIn": swapData.isPayIn(),
+            "payOut": swapData.isPayOut(),
+            "trackingReputation": swapData.reputation,
+            "claimHandler": swapData.claimHandler,
+            "claimData": "0x"+swapData.getClaimHash(),
+            "refundHandler": swapData.refundHandler,
+            "refundData": swapData.refundData.startsWith("0x") ? swapData.refundData : "0x"+swapData.refundData,
+            "securityDeposit": swapData.securityDeposit,
+            "claimerBounty": swapData.claimerBounty,
+            "depositToken": swapData.depositToken,
+            "claimActionHash": ZeroHash,
+            "deadline": authExpiry,
+            "extraDataHash": keccak256("0x"+(swapData.extraData ?? ""))
+        });
+
+        return {
+            prefix: this.getAuthPrefix(swapData),
+            timeout: authExpiry.toString(10),
+            signature
+        };
+    }
+
+    /**
+     * Checks whether the provided signature data is valid, using preFetchedData if provided and still valid
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param prefix
+     * @param signature
+     * @param preFetchData
+     * @public
+     */
+    public async isSignatureValid(
+        sender: string,
+        swapData: EVMSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        preFetchData?: EVMPreFetchVerification
+    ): Promise<null> {
+        if(!swapData.isOfferer(sender) && !swapData.isClaimer(sender))
+            throw new SignatureVerificationError("TX sender not offerer nor claimer");
+
+        const signer = swapData.isOfferer(sender) ? swapData.claimer : swapData.offerer;
+
+        if(await this.contract.isExpired(sender, swapData)) {
+            throw new SignatureVerificationError("Swap will expire too soon!");
+        }
+
+        if(prefix!==this.getAuthPrefix(swapData)) throw new SignatureVerificationError("Invalid prefix");
+
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+        const timeoutBN = BigInt(timeout);
+        const isExpired = (timeoutBN - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if (isExpired) throw new SignatureVerificationError("Authorization expired!");
+        if(await this.isSignatureExpired(timeout, preFetchData)) throw new SignatureVerificationError("Authorization expired!");
+
+        const valid = await this.root.Signatures.isValidSignature(this.contract.contractAddress, signature, signer, Initialize, "Initialize", {
+            "swapHash": "0x"+swapData.getEscrowHash(),
+            "offerer": swapData.offerer,
+            "claimer": swapData.claimer,
+            "amount": swapData.amount,
+            "token": swapData.token,
+            "payIn": swapData.isPayIn(),
+            "payOut": swapData.isPayOut(),
+            "trackingReputation": swapData.reputation,
+            "claimHandler": swapData.claimHandler,
+            "claimData": "0x"+swapData.getClaimHash(),
+            "refundHandler": swapData.refundHandler,
+            "refundData": swapData.refundData.startsWith("0x") ? swapData.refundData : "0x"+swapData.refundData,
+            "securityDeposit": swapData.securityDeposit,
+            "claimerBounty": swapData.claimerBounty,
+            "depositToken": swapData.depositToken,
+            "claimActionHash": ZeroHash,
+            "deadline": timeoutBN,
+            "extraDataHash": keccak256("0x"+(swapData.extraData ?? ""))
+        });
+
+        if(!valid) throw new 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
+     */
+    public async getSignatureExpiry(
+        timeout: string
+    ): Promise<number> {
+        const now = Date.now();
+        const timeoutExpiryTime = (parseInt(timeout)-this.contract.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
+     */
+    public async isSignatureExpired(
+        timeout: string,
+        preFetchData?: EVMPreFetchVerification
+    ): Promise<boolean> {
+        if(preFetchData==null || preFetchData.safeBlockTime==null) {
+            preFetchData = await this.preFetchForInitSignatureVerification();
+        }
+        return preFetchData.safeBlockTime > parseInt(timeout);
+    }
+
+    /**
+     * Creates init transaction with a valid signature from an LP
+     *
+     * @param sender
+     * @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
+     */
+    public async txsInit(
+        sender: string,
+        swapData: EVMSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        skipChecks?: boolean,
+        feeRate?: string
+    ): Promise<EVMTx[]> {
+        if(
+            swapData.isClaimer(sender) && swapData.isPayIn() &&
+            swapData.isToken(this.root.getNativeCurrencyAddress())
+        ) throw new Error("Cannot initialize as claimer for payIn=true and native currency!");
+
+        if(!skipChecks) {
+            const [_, payStatus] = await Promise.all([
+                swapData.isOfferer(sender) && !swapData.reputation ? Promise.resolve() : tryWithRetries(
+                    () => this.isSignatureValid(sender, swapData, timeout, prefix, signature),
+                    this.retryPolicy, (e) => e instanceof SignatureVerificationError
+                ),
+                tryWithRetries(() => this.contract.getCommitStatus(sender, swapData), this.retryPolicy)
+            ]);
+            if(payStatus.type!==SwapCommitStateType.NOT_COMMITED) throw new SwapDataVerificationError("Invoice already being paid for or paid");
+        }
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const txs: EVMTx[] = [];
+        const requiredApprovals: {[address: string]: bigint} = {};
+        if(swapData.payIn && swapData.isOfferer(sender)) {
+            if(!swapData.isToken(this.root.getNativeCurrencyAddress())) {
+                requiredApprovals[swapData.token.toLowerCase()] = swapData.amount;
+            }
+        }
+        if(swapData.getTotalDeposit() !== 0n) {
+            if(!swapData.isDepositToken(this.root.getNativeCurrencyAddress())) {
+                requiredApprovals[swapData.depositToken.toLowerCase()] ??= 0n;
+                requiredApprovals[swapData.depositToken.toLowerCase()] += swapData.getTotalDeposit();
+            }
+        }
+        for(let tokenAddress in requiredApprovals) {
+            txs.push(await this.root.Tokens.Approve(sender, tokenAddress, requiredApprovals[tokenAddress], this.contract.contractAddress, feeRate));
+        }
+        txs.push(await this.Init(sender, swapData, BigInt(timeout), signature ?? "0x", feeRate));
+
+        this.logger.debug("txsInitPayIn(): create swap init TX, swap: "+swapData.getClaimHash()+
+            " feerate: "+feeRate);
+
+        return txs;
+    }
+
+    /**
+     * 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?: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return EVMFees.getGasFee(swapData.payIn ? EVMSwapInit.GasCosts.INIT_PAY_IN : EVMSwapInit.GasCosts.INIT, feeRate);
+    }
+}

package/src/evm/swaps/modules/EVMSwapRefund.ts

@@ -0,0 +1,198 @@
+import {SignatureVerificationError, SwapDataVerificationError} from "@atomiqlabs/base";
+import {tryWithRetries} from "../../../utils/Utils";
+import {IHandler} from "../handlers/IHandler";
+import {EVMSwapModule} from "../EVMSwapModule";
+import {Buffer} from "buffer";
+import {EVMSwapData} from "../EVMSwapData";
+import {TransactionRequest} from "ethers";
+import {EVMFees} from "../../chain/modules/EVMFees";
+import {EVMSigner} from "../../wallet/EVMSigner";
+import {EVMTx} from "../../chain/modules/EVMTransactions";
+
+const Refund = [
+    { name: "swapHash", type: "bytes32" },
+    { name: "timeout", type: "uint256" }
+];
+
+export class EVMSwapRefund extends EVMSwapModule {
+
+    private static readonly GasCosts = {
+        REFUND: 100_000,
+        REFUND_PAY_OUT: 130_000
+    };
+
+    /**
+     * Action for generic Refund instruction
+     *
+     * @param signer
+     * @param swapData
+     * @param witness
+     * @param feeRate
+     * @param handlerGas
+     * @private
+     */
+    private async Refund(
+        signer: string,
+        swapData: EVMSwapData,
+        witness: Buffer,
+        feeRate: string,
+        handlerGas?: number
+    ): Promise<TransactionRequest> {
+        const tx = await this.swapContract.refund.populateTransaction(swapData.toEscrowStruct(), witness);
+        tx.from = signer;
+        EVMFees.applyFeeRate(tx, (swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND) + (handlerGas ?? 0), feeRate)
+        return tx;
+    }
+
+    /**
+     * Action for cooperative refunding with signature
+     *
+     * @param sender
+     * @param swapData
+     * @param timeout
+     * @param signature
+     * @param feeRate
+     * @private
+     */
+    private async RefundWithSignature(
+        sender: string,
+        swapData: EVMSwapData,
+        timeout: string,
+        signature: string,
+        feeRate: string
+    ): Promise<TransactionRequest> {
+        const tx = await this.swapContract.cooperativeRefund.populateTransaction(swapData.toEscrowStruct(), signature, BigInt(timeout));
+        tx.from = sender;
+        EVMFees.applyFeeRate(tx, swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate)
+        return tx;
+    }
+
+    public async signSwapRefund(
+        signer: EVMSigner,
+        swapData: EVMSwapData,
+        authorizationTimeout: number
+    ): Promise<{ prefix: string; timeout: string; signature: string }> {
+        const authPrefix = "refund";
+        const authTimeout = Math.floor(Date.now()/1000)+authorizationTimeout;
+
+        const signature = await this.root.Signatures.signTypedMessage(this.contract.contractAddress, signer, Refund, "Refund", {
+            "swapHash": "0x"+swapData.getEscrowHash(),
+            "timeout": BigInt(authTimeout)
+        });
+
+        return {
+            prefix: authPrefix,
+            timeout: authTimeout.toString(10),
+            signature: signature
+        };
+    }
+
+    public async isSignatureValid(
+        swapData: EVMSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string
+    ): Promise<null> {
+        if(prefix!=="refund") throw new SignatureVerificationError("Invalid prefix");
+
+        const expiryTimestamp = BigInt(timeout);
+        const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+
+        const isExpired = (expiryTimestamp - currentTimestamp) < BigInt(this.contract.authGracePeriod);
+        if(isExpired) throw new SignatureVerificationError("Authorization expired!");
+
+        const valid = await this.root.Signatures.isValidSignature(this.contract.contractAddress, signature, swapData.claimer, Refund, "Refund", {
+            "swapHash": "0x"+swapData.getEscrowHash(),
+            "timeout": BigInt(expiryTimestamp)
+        });
+
+        if(!valid) {
+            throw new 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
+     */
+    public async txsRefund<T>(
+        signer: string,
+        swapData: EVMSwapData,
+        check?: boolean,
+        feeRate?: string,
+        witnessData?: T
+    ): Promise<EVMTx[]> {
+        const refundHandler: IHandler<any, T> = this.contract.refundHandlersByAddress[swapData.refundHandler.toLowerCase()];
+        if(refundHandler==null) throw new Error("Invalid refund handler");
+
+        if(check && !await tryWithRetries(() => this.contract.isRequestRefundable(swapData.offerer.toString(), swapData), this.retryPolicy)) {
+            throw new SwapDataVerificationError("Not refundable yet!");
+        }
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const {initialTxns, witness} = await refundHandler.getWitness(signer, swapData, witnessData, feeRate);
+
+        const tx = await this.Refund(signer, swapData, witness, feeRate, refundHandler.getGas(swapData));
+
+        this.logger.debug("txsRefund(): creating refund transaction, swap: "+swapData.getClaimHash());
+
+        return [...initialTxns, tx];
+    }
+
+    /**
+     * 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
+     */
+    public async txsRefundWithAuthorization(
+        signer: string,
+        swapData: EVMSwapData,
+        timeout: string,
+        prefix: string,
+        signature: string,
+        check?: boolean,
+        feeRate?: string
+    ): Promise<EVMTx[]> {
+        if(check && !await tryWithRetries(() => this.contract.isCommited(swapData), this.retryPolicy)) {
+            throw new SwapDataVerificationError("Not correctly committed");
+        }
+        await tryWithRetries(
+            () => this.isSignatureValid(swapData, timeout, prefix, signature),
+            this.retryPolicy,
+            (e) => e instanceof SignatureVerificationError
+        );
+
+        feeRate ??= await this.root.Fees.getFeeRate();
+
+        const tx = await this.RefundWithSignature(signer, swapData, timeout, signature, feeRate);
+
+        this.logger.debug("txsRefundWithAuthorization(): creating refund transaction, swap: "+swapData.getClaimHash()+
+            " auth expiry: "+timeout+" signature: "+signature);
+
+        return [tx];
+    }
+
+    /**
+     * 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: EVMSwapData, feeRate?: string): Promise<bigint> {
+        feeRate ??= await this.root.Fees.getFeeRate();
+        return EVMFees.getGasFee(swapData.payIn ? EVMSwapRefund.GasCosts.REFUND_PAY_OUT : EVMSwapRefund.GasCosts.REFUND, feeRate);
+    }
+
+}