@atomiqlabs/sdk 7.0.12 → 8.0.7

package/dist/swaps/trusted/onchain/OnchainForGasSwap.d.ts

@@ -0,0 +1,164 @@
+import { SwapType } from "../../../enums/SwapType";
+import { ChainType } from "@atomiqlabs/base";
+import { ISwap, ISwapInit } from "../../ISwap";
+import { OnchainForGasSwapTypeDefinition, OnchainForGasWrapper } from "./OnchainForGasWrapper";
+import { Fee } from "../../../types/fees/Fee";
+import { IBitcoinWallet } from "../../../bitcoin/wallet/IBitcoinWallet";
+import { IAddressSwap } from "../../IAddressSwap";
+import { IBTCWalletSwap } from "../../IBTCWalletSwap";
+import { Transaction } from "@scure/btc-signer";
+import { MinimalBitcoinWalletInterface, MinimalBitcoinWalletInterfaceWithSigner } from "../../../bitcoin/wallet/MinimalBitcoinWalletInterface";
+import { FeeType } from "../../../enums/FeeType";
+import { TokenAmount } from "../../../types/TokenAmount";
+import { BtcToken, SCToken } from "../../../types/Token";
+import { LoggerType } from "../../../utils/Logger";
+/**
+ * State enum for trusted on-chain gas swaps
+ * @category Swaps
+ */
+export declare enum OnchainForGasSwapState {
+    EXPIRED = -3,
+    FAILED = -2,
+    REFUNDED = -1,
+    PR_CREATED = 0,
+    FINISHED = 1,
+    REFUNDABLE = 2
+}
+export type OnchainForGasSwapInit = ISwapInit & {
+    paymentHash: string;
+    sequence: bigint;
+    address: string;
+    inputAmount: bigint;
+    outputAmount: bigint;
+    recipient: string;
+    token: string;
+    refundAddress?: string;
+};
+export declare function isOnchainForGasSwapInit(obj: any): obj is OnchainForGasSwapInit;
+/**
+ * Trusted on-chain BTC to gas token swap
+ * @category Swaps
+ */
+export declare class OnchainForGasSwap<T extends ChainType = ChainType> extends ISwap<T, OnchainForGasSwapTypeDefinition<T>> implements IAddressSwap, IBTCWalletSwap {
+    getSmartChainNetworkFee: null;
+    protected readonly TYPE: SwapType;
+    protected readonly logger: LoggerType;
+    private readonly paymentHash;
+    private readonly sequence;
+    private readonly address;
+    private readonly recipient;
+    private readonly token;
+    private inputAmount;
+    private outputAmount;
+    private refundAddress?;
+    scTxId?: string;
+    txId?: string;
+    refundTxId?: string;
+    wrapper: OnchainForGasWrapper<T>;
+    constructor(wrapper: OnchainForGasWrapper<T>, init: OnchainForGasSwapInit);
+    constructor(wrapper: OnchainForGasWrapper<T>, obj: any);
+    protected upgradeVersion(): void;
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    protected tryRecomputeSwapPrice(): void;
+    _getEscrowHash(): string;
+    getOutputAddress(): string | null;
+    getInputAddress(): string | null;
+    getInputTxId(): string | null;
+    getOutputTxId(): string | null;
+    getId(): string;
+    getAddress(): string;
+    getHyperlink(): string;
+    requiresAction(): boolean;
+    isFinished(): boolean;
+    isQuoteExpired(): boolean;
+    isQuoteSoftExpired(): boolean;
+    isFailed(): boolean;
+    isSuccessful(): boolean;
+    verifyQuoteValid(): Promise<boolean>;
+    protected getOutAmountWithoutFee(): bigint;
+    getOutputToken(): SCToken<T["ChainId"]>;
+    getOutput(): TokenAmount<T["ChainId"], SCToken<T["ChainId"]>>;
+    getInputToken(): BtcToken<false>;
+    getInput(): TokenAmount<T["ChainId"], BtcToken<false>>;
+    getInputWithoutFee(): TokenAmount<T["ChainId"], BtcToken<false>>;
+    protected getSwapFee(): Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>>;
+    getFee(): Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>>;
+    getFeeBreakdown(): [{
+        type: FeeType.SWAP;
+        fee: Fee<T["ChainId"], BtcToken<false>, SCToken<T["ChainId"]>>;
+    }];
+    getRequiredConfirmationsCount(): number;
+    /**
+     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
+     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
+     *  `swap.submitPsbt()`
+     *
+     * @param _bitcoinWallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
+     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     */
+    getFundedPsbt(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number, additionalOutputs?: ({
+        amount: bigint;
+        outputScript: Uint8Array;
+    } | {
+        amount: bigint;
+        address: string;
+    })[]): Promise<{
+        psbt: Transaction;
+        psbtHex: string;
+        psbtBase64: string;
+        signInputs: number[];
+    }>;
+    /**
+     * Submits a PSBT signed by the wallet back to the SDK
+     *
+     * @param _psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     */
+    submitPsbt(_psbt: Transaction | string): Promise<string>;
+    estimateBitcoinFee(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>> | null>;
+    sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string>;
+    txsExecute(options?: {
+        bitcoinWallet?: MinimalBitcoinWalletInterface;
+    }): Promise<{
+        name: "Payment";
+        description: string;
+        chain: string;
+        txs: ({
+            address: string;
+            amount: number;
+            hyperlink: string;
+            type: string;
+        } | {
+            type: string;
+            psbt: Transaction;
+            psbtHex: string;
+            psbtBase64: string;
+            signInputs: number[];
+            address?: undefined;
+            amount?: undefined;
+            hyperlink?: undefined;
+        })[];
+    }[]>;
+    protected checkAddress(save?: boolean): Promise<boolean | null>;
+    protected setRefundAddress(refundAddress: string): Promise<void>;
+    /**
+     * A blocking promise resolving when payment was received by the intermediary and client can continue
+     * rejecting in case of failure
+     *
+     * @param abortSignal Abort signal
+     * @param checkIntervalSeconds How often to poll the intermediary for answer
+     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
+     * @throws {PaymentAuthError} If swap expired or failed
+     * @throws {Error} When in invalid state (not PR_CREATED)
+     */
+    waitForBitcoinTransaction(updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<string>;
+    waitTillRefunded(checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<void>;
+    requestRefund(refundAddress?: string, abortSignal?: AbortSignal): Promise<void>;
+    serialize(): any;
+    _getInitiator(): string;
+    _sync(save?: boolean): Promise<boolean>;
+    _tick(save?: boolean): Promise<boolean>;
+}

package/dist/swaps/trusted/onchain/OnchainForGasSwap.js

@@ -0,0 +1,520 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainForGasSwap = exports.isOnchainForGasSwapInit = exports.OnchainForGasSwapState = void 0;
+const SwapType_1 = require("../../../enums/SwapType");
+const PaymentAuthError_1 = require("../../../errors/PaymentAuthError");
+const Utils_1 = require("../../../utils/Utils");
+const BitcoinUtils_1 = require("../../../utils/BitcoinUtils");
+const ISwap_1 = require("../../ISwap");
+const TrustedIntermediaryAPI_1 = require("../../../intermediaries/apis/TrustedIntermediaryAPI");
+const IBitcoinWallet_1 = require("../../../bitcoin/wallet/IBitcoinWallet");
+const btc_signer_1 = require("@scure/btc-signer");
+const SingleAddressBitcoinWallet_1 = require("../../../bitcoin/wallet/SingleAddressBitcoinWallet");
+const buffer_1 = require("buffer");
+const FeeType_1 = require("../../../enums/FeeType");
+const PercentagePPM_1 = require("../../../types/fees/PercentagePPM");
+const TokenAmount_1 = require("../../../types/TokenAmount");
+const Token_1 = require("../../../types/Token");
+const Logger_1 = require("../../../utils/Logger");
+const TimeoutUtils_1 = require("../../../utils/TimeoutUtils");
+const BitcoinWalletUtils_1 = require("../../../utils/BitcoinWalletUtils");
+/**
+ * State enum for trusted on-chain gas swaps
+ * @category Swaps
+ */
+var OnchainForGasSwapState;
+(function (OnchainForGasSwapState) {
+    OnchainForGasSwapState[OnchainForGasSwapState["EXPIRED"] = -3] = "EXPIRED";
+    OnchainForGasSwapState[OnchainForGasSwapState["FAILED"] = -2] = "FAILED";
+    OnchainForGasSwapState[OnchainForGasSwapState["REFUNDED"] = -1] = "REFUNDED";
+    OnchainForGasSwapState[OnchainForGasSwapState["PR_CREATED"] = 0] = "PR_CREATED";
+    OnchainForGasSwapState[OnchainForGasSwapState["FINISHED"] = 1] = "FINISHED";
+    OnchainForGasSwapState[OnchainForGasSwapState["REFUNDABLE"] = 2] = "REFUNDABLE";
+})(OnchainForGasSwapState = exports.OnchainForGasSwapState || (exports.OnchainForGasSwapState = {}));
+function isOnchainForGasSwapInit(obj) {
+    return typeof (obj.paymentHash) === "string" &&
+        typeof (obj.sequence) === "bigint" &&
+        typeof (obj.address) === "string" &&
+        typeof (obj.inputAmount) === "bigint" &&
+        typeof (obj.outputAmount) === "bigint" &&
+        typeof (obj.recipient) === "string" &&
+        typeof (obj.token) === "string" &&
+        (obj.refundAddress == null || typeof (obj.refundAddress) === "string") &&
+        (0, ISwap_1.isISwapInit)(obj);
+}
+exports.isOnchainForGasSwapInit = isOnchainForGasSwapInit;
+/**
+ * Trusted on-chain BTC to gas token swap
+ * @category Swaps
+ */
+class OnchainForGasSwap extends ISwap_1.ISwap {
+    constructor(wrapper, initOrObj) {
+        if (isOnchainForGasSwapInit(initOrObj) && initOrObj.url != null)
+            initOrObj.url += "/frombtc_trusted";
+        super(wrapper, initOrObj);
+        this.getSmartChainNetworkFee = null;
+        this.TYPE = SwapType_1.SwapType.TRUSTED_FROM_BTC;
+        this.wrapper = wrapper;
+        if (isOnchainForGasSwapInit(initOrObj)) {
+            this.paymentHash = initOrObj.paymentHash;
+            this.sequence = initOrObj.sequence;
+            this.address = initOrObj.address;
+            this.inputAmount = initOrObj.inputAmount;
+            this.outputAmount = initOrObj.outputAmount;
+            this.recipient = initOrObj.recipient;
+            this.token = initOrObj.token;
+            this.refundAddress = initOrObj.refundAddress;
+            this.state = OnchainForGasSwapState.PR_CREATED;
+        }
+        else {
+            this.paymentHash = initOrObj.paymentHash;
+            this.sequence = (0, Utils_1.toBigInt)(initOrObj.sequence);
+            this.address = initOrObj.address;
+            this.inputAmount = (0, Utils_1.toBigInt)(initOrObj.inputAmount);
+            this.outputAmount = (0, Utils_1.toBigInt)(initOrObj.outputAmount);
+            this.recipient = initOrObj.recipient;
+            this.token = initOrObj.token;
+            this.refundAddress = initOrObj.refundAddress;
+            this.scTxId = initOrObj.scTxId;
+            this.txId = initOrObj.txId;
+            this.refundTxId = initOrObj.refundTxId;
+        }
+        this.logger = (0, Logger_1.getLogger)("OnchainForGas(" + this.getId() + "): ");
+        this.tryRecomputeSwapPrice();
+    }
+    upgradeVersion() {
+        if (this.version == null) {
+            //Noop
+            this.version = 1;
+        }
+    }
+    /**
+     * In case swapFee in BTC is not supplied it recalculates it based on swap price
+     * @protected
+     */
+    tryRecomputeSwapPrice() {
+        if (this.swapFeeBtc == null && this.swapFee != null) {
+            this.swapFeeBtc = this.swapFee * this.getInput().rawAmount / this.getOutAmountWithoutFee();
+        }
+        super.tryRecomputeSwapPrice();
+    }
+    //////////////////////////////
+    //// Getters & utils
+    _getEscrowHash() {
+        return this.paymentHash;
+    }
+    getOutputAddress() {
+        return this.recipient;
+    }
+    getInputAddress() {
+        //TODO: Fuck this, it's not used anyway
+        return null;
+    }
+    getInputTxId() {
+        return this.txId ?? null;
+    }
+    getOutputTxId() {
+        return this.scTxId ?? null;
+    }
+    getId() {
+        return this.paymentHash;
+    }
+    getAddress() {
+        return this.address;
+    }
+    getHyperlink() {
+        return "bitcoin:" + this.address + "?amount=" + encodeURIComponent((Number(this.inputAmount) / 100000000).toString(10));
+    }
+    requiresAction() {
+        return this.state === OnchainForGasSwapState.REFUNDABLE;
+    }
+    isFinished() {
+        return this.state === OnchainForGasSwapState.FINISHED || this.state === OnchainForGasSwapState.FAILED || this.state === OnchainForGasSwapState.EXPIRED || this.state === OnchainForGasSwapState.REFUNDED;
+    }
+    isQuoteExpired() {
+        return this.state === OnchainForGasSwapState.EXPIRED;
+    }
+    isQuoteSoftExpired() {
+        return this.expiry < Date.now();
+    }
+    isFailed() {
+        return this.state === OnchainForGasSwapState.FAILED;
+    }
+    isSuccessful() {
+        return this.state === OnchainForGasSwapState.FINISHED;
+    }
+    verifyQuoteValid() {
+        return Promise.resolve(this.expiry > Date.now());
+    }
+    //////////////////////////////
+    //// Amounts & fees
+    getOutAmountWithoutFee() {
+        return this.outputAmount + (this.swapFee ?? 0n);
+    }
+    getOutputToken() {
+        return this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()];
+    }
+    getOutput() {
+        return (0, TokenAmount_1.toTokenAmount)(this.outputAmount, this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()], this.wrapper.prices, this.pricingInfo);
+    }
+    getInputToken() {
+        return Token_1.BitcoinTokens.BTC;
+    }
+    getInput() {
+        return (0, TokenAmount_1.toTokenAmount)(this.inputAmount, Token_1.BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+    }
+    getInputWithoutFee() {
+        return (0, TokenAmount_1.toTokenAmount)(this.inputAmount - (this.swapFeeBtc ?? 0n), Token_1.BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+    }
+    getSwapFee() {
+        if (this.pricingInfo == null)
+            throw new Error("No pricing info known!");
+        const feeWithoutBaseFee = this.swapFeeBtc == null ? 0n : this.swapFeeBtc - this.pricingInfo.satsBaseFee;
+        const swapFeePPM = feeWithoutBaseFee * 1000000n / this.getInputWithoutFee().rawAmount;
+        const amountInSrcToken = (0, TokenAmount_1.toTokenAmount)(this.swapFeeBtc ?? 0n, Token_1.BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+        return {
+            amountInSrcToken,
+            amountInDstToken: (0, TokenAmount_1.toTokenAmount)(this.swapFee ?? 0n, this.wrapper.tokens[this.wrapper.chain.getNativeCurrencyAddress()], this.wrapper.prices, this.pricingInfo),
+            currentUsdValue: amountInSrcToken.currentUsdValue,
+            usdValue: amountInSrcToken.usdValue,
+            pastUsdValue: amountInSrcToken.pastUsdValue,
+            composition: {
+                base: (0, TokenAmount_1.toTokenAmount)(this.pricingInfo.satsBaseFee, Token_1.BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo),
+                percentage: (0, PercentagePPM_1.ppmToPercentage)(swapFeePPM)
+            }
+        };
+    }
+    getFee() {
+        return this.getSwapFee();
+    }
+    getFeeBreakdown() {
+        return [{
+                type: FeeType_1.FeeType.SWAP,
+                fee: this.getSwapFee()
+            }];
+    }
+    getRequiredConfirmationsCount() {
+        return 1;
+    }
+    /**
+     * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
+     *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
+     *  `swap.submitPsbt()`
+     *
+     * @param _bitcoinWallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
+     * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
+     */
+    async getFundedPsbt(_bitcoinWallet, feeRate, additionalOutputs) {
+        if (this.state !== OnchainForGasSwapState.PR_CREATED)
+            throw new Error("Swap already paid for!");
+        let bitcoinWallet;
+        if ((0, IBitcoinWallet_1.isIBitcoinWallet)(_bitcoinWallet)) {
+            bitcoinWallet = _bitcoinWallet;
+        }
+        else {
+            bitcoinWallet = new SingleAddressBitcoinWallet_1.SingleAddressBitcoinWallet(this.wrapper.btcRpc, this.wrapper.options.bitcoinNetwork, _bitcoinWallet);
+        }
+        //TODO: Maybe re-introduce fee rate check here if passed from the user
+        if (feeRate == null) {
+            feeRate = await bitcoinWallet.getFeeRate();
+        }
+        const basePsbt = new btc_signer_1.Transaction({
+            allowUnknownOutputs: true,
+            allowLegacyWitnessUtxo: true
+        });
+        basePsbt.addOutput({
+            amount: this.outputAmount,
+            script: (0, BitcoinUtils_1.toOutputScript)(this.wrapper.options.bitcoinNetwork, this.address)
+        });
+        if (additionalOutputs != null)
+            additionalOutputs.forEach(output => {
+                basePsbt.addOutput({
+                    amount: output.amount,
+                    script: output.outputScript ?? (0, BitcoinUtils_1.toOutputScript)(this.wrapper.options.bitcoinNetwork, output.address)
+                });
+            });
+        const psbt = await bitcoinWallet.fundPsbt(basePsbt, feeRate);
+        //Sign every input
+        const signInputs = [];
+        for (let i = 0; i < psbt.inputsLength; i++) {
+            signInputs.push(i);
+        }
+        const serializedPsbt = buffer_1.Buffer.from(psbt.toPSBT());
+        return {
+            psbt,
+            psbtHex: serializedPsbt.toString("hex"),
+            psbtBase64: serializedPsbt.toString("base64"),
+            signInputs
+        };
+    }
+    /**
+     * Submits a PSBT signed by the wallet back to the SDK
+     *
+     * @param _psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     */
+    async submitPsbt(_psbt) {
+        const psbt = (0, BitcoinUtils_1.parsePsbtTransaction)(_psbt);
+        if (this.state !== OnchainForGasSwapState.PR_CREATED)
+            throw new Error("Swap already paid for!");
+        //Ensure not expired
+        if (this.expiry < Date.now()) {
+            throw new Error("Swap expired!");
+        }
+        const output0 = psbt.getOutput(0);
+        if (output0.amount !== this.outputAmount)
+            throw new Error("PSBT output amount invalid, expected: " + this.outputAmount + " got: " + output0.amount);
+        const expectedOutputScript = (0, BitcoinUtils_1.toOutputScript)(this.wrapper.options.bitcoinNetwork, this.address);
+        if (output0.script == null || !expectedOutputScript.equals(output0.script))
+            throw new Error("PSBT output script invalid!");
+        if (!psbt.isFinal)
+            psbt.finalize();
+        return await this.wrapper.btcRpc.sendRawTransaction(buffer_1.Buffer.from(psbt.toBytes(true, true)).toString("hex"));
+    }
+    async estimateBitcoinFee(_bitcoinWallet, feeRate) {
+        const bitcoinWallet = (0, BitcoinWalletUtils_1.toBitcoinWallet)(_bitcoinWallet, this.wrapper.btcRpc, this.wrapper.options.bitcoinNetwork);
+        const txFee = await bitcoinWallet.getTransactionFee(this.address, this.inputAmount, feeRate);
+        if (txFee == null)
+            return null;
+        return (0, TokenAmount_1.toTokenAmount)(BigInt(txFee), Token_1.BitcoinTokens.BTC, this.wrapper.prices, this.pricingInfo);
+    }
+    async sendBitcoinTransaction(wallet, feeRate) {
+        if (this.state !== OnchainForGasSwapState.PR_CREATED)
+            throw new Error("Swap already paid for!");
+        //Ensure not expired
+        if (this.expiry < Date.now()) {
+            throw new Error("Swap expired!");
+        }
+        if ((0, IBitcoinWallet_1.isIBitcoinWallet)(wallet)) {
+            return await wallet.sendTransaction(this.address, this.inputAmount, feeRate);
+        }
+        else {
+            const { psbt, psbtHex, psbtBase64, signInputs } = await this.getFundedPsbt(wallet, feeRate);
+            const signedPsbt = await wallet.signPsbt({
+                psbt, psbtHex, psbtBase64
+            }, signInputs);
+            return await this.submitPsbt(signedPsbt);
+        }
+    }
+    async txsExecute(options) {
+        if (this.state === OnchainForGasSwapState.PR_CREATED) {
+            if (!await this.verifyQuoteValid())
+                throw new Error("Quote already expired or close to expiry!");
+            return [
+                {
+                    name: "Payment",
+                    description: "Send funds to the bitcoin swap address",
+                    chain: "BITCOIN",
+                    txs: [
+                        options?.bitcoinWallet == null ? {
+                            address: this.address,
+                            amount: Number(this.inputAmount),
+                            hyperlink: this.getHyperlink(),
+                            type: "ADDRESS"
+                        } : {
+                            ...await this.getFundedPsbt(options.bitcoinWallet),
+                            type: "FUNDED_PSBT"
+                        }
+                    ]
+                }
+            ];
+        }
+        throw new Error("Invalid swap state to obtain execution txns, required PR_CREATED or CLAIM_COMMITED");
+    }
+    //////////////////////////////
+    //// Payment
+    async checkAddress(save = true) {
+        if (this.state === OnchainForGasSwapState.FAILED ||
+            this.state === OnchainForGasSwapState.EXPIRED ||
+            this.state === OnchainForGasSwapState.REFUNDED)
+            return false;
+        if (this.state === OnchainForGasSwapState.FINISHED)
+            return false;
+        if (this.url == null)
+            return false;
+        const response = await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.getAddressStatus(this.url, this.paymentHash, this.sequence, this.wrapper.options.getRequestTimeout);
+        switch (response.code) {
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.AWAIT_PAYMENT:
+                if (this.txId != null) {
+                    this.txId = undefined;
+                    if (save)
+                        await this._save();
+                    return true;
+                }
+                return false;
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.AWAIT_CONFIRMATION:
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.PENDING:
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.TX_SENT:
+                const inputAmount = BigInt(response.data.adjustedAmount);
+                const outputAmount = BigInt(response.data.adjustedTotal);
+                const adjustedFee = response.data.adjustedFee == null ? null : BigInt(response.data.adjustedFee);
+                const adjustedFeeSats = response.data.adjustedFeeSats == null ? null : BigInt(response.data.adjustedFeeSats);
+                const txId = response.data.txId;
+                if (this.txId != txId ||
+                    this.inputAmount !== inputAmount ||
+                    this.outputAmount !== outputAmount) {
+                    this.txId = txId;
+                    this.inputAmount = inputAmount;
+                    this.outputAmount = outputAmount;
+                    if (adjustedFee != null)
+                        this.swapFee = adjustedFee;
+                    if (adjustedFeeSats != null)
+                        this.swapFeeBtc = adjustedFeeSats;
+                    if (save)
+                        await this._save();
+                    return true;
+                }
+                return false;
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.PAID:
+                const txStatus = await this.wrapper.chain.getTxIdStatus(response.data.txId);
+                if (txStatus === "success") {
+                    this.state = OnchainForGasSwapState.FINISHED;
+                    this.scTxId = response.data.txId;
+                    if (save)
+                        await this._saveAndEmit();
+                    return true;
+                }
+                return false;
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.EXPIRED:
+                this.state = OnchainForGasSwapState.EXPIRED;
+                if (save)
+                    await this._saveAndEmit();
+                return true;
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.REFUNDABLE:
+                if (this.state === OnchainForGasSwapState.REFUNDABLE)
+                    return null;
+                this.state = OnchainForGasSwapState.REFUNDABLE;
+                if (save)
+                    await this._saveAndEmit();
+                return true;
+            case TrustedIntermediaryAPI_1.AddressStatusResponseCodes.REFUNDED:
+                this.state = OnchainForGasSwapState.REFUNDED;
+                this.refundTxId = response.data.txId;
+                if (save)
+                    await this._saveAndEmit();
+                return true;
+            default:
+                this.state = OnchainForGasSwapState.FAILED;
+                if (save)
+                    await this._saveAndEmit();
+                return true;
+        }
+    }
+    async setRefundAddress(refundAddress) {
+        if (this.refundAddress != null) {
+            if (this.refundAddress !== refundAddress)
+                throw new Error("Different refund address already set!");
+            return;
+        }
+        if (this.url == null)
+            throw new Error("LP URL not known, cannot set refund address!");
+        await TrustedIntermediaryAPI_1.TrustedIntermediaryAPI.setRefundAddress(this.url, this.paymentHash, this.sequence, refundAddress, this.wrapper.options.getRequestTimeout);
+        this.refundAddress = refundAddress;
+    }
+    /**
+     * A blocking promise resolving when payment was received by the intermediary and client can continue
+     * rejecting in case of failure
+     *
+     * @param abortSignal Abort signal
+     * @param checkIntervalSeconds How often to poll the intermediary for answer
+     * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
+     * @throws {PaymentAuthError} If swap expired or failed
+     * @throws {Error} When in invalid state (not PR_CREATED)
+     */
+    async waitForBitcoinTransaction(updateCallback, checkIntervalSeconds = 5, abortSignal) {
+        if (this.state !== OnchainForGasSwapState.PR_CREATED)
+            throw new Error("Must be in PR_CREATED state!");
+        if (!this.initiated) {
+            this.initiated = true;
+            await this._saveAndEmit();
+        }
+        while (!abortSignal?.aborted &&
+            this.state === OnchainForGasSwapState.PR_CREATED) {
+            await this.checkAddress(true);
+            if (this.txId != null && updateCallback != null) {
+                const res = await this.wrapper.btcRpc.getTransaction(this.txId);
+                if (res == null) {
+                    updateCallback();
+                }
+                else if (res.confirmations != null && res.confirmations > 0) {
+                    updateCallback(res.txid, res.confirmations, 1, 0);
+                }
+                else {
+                    const delay = await this.wrapper.btcRpc.getConfirmationDelay(res, 1);
+                    updateCallback(res.txid, 0, 1, delay ?? undefined);
+                }
+            }
+            if (this.state === OnchainForGasSwapState.PR_CREATED)
+                await (0, TimeoutUtils_1.timeoutPromise)(checkIntervalSeconds * 1000, abortSignal);
+        }
+        if (this.state === OnchainForGasSwapState.REFUNDABLE ||
+            this.state === OnchainForGasSwapState.REFUNDED)
+            return this.txId;
+        if (this.isQuoteExpired())
+            throw new PaymentAuthError_1.PaymentAuthError("Swap expired");
+        if (this.isFailed())
+            throw new PaymentAuthError_1.PaymentAuthError("Swap failed");
+        return this.txId;
+    }
+    async waitTillRefunded(checkIntervalSeconds, abortSignal) {
+        checkIntervalSeconds ??= 5;
+        if (this.state === OnchainForGasSwapState.REFUNDED)
+            return;
+        if (this.state !== OnchainForGasSwapState.REFUNDABLE)
+            throw new Error("Must be in REFUNDABLE state!");
+        while (!abortSignal?.aborted &&
+            this.state === OnchainForGasSwapState.REFUNDABLE) {
+            await this.checkAddress(true);
+            if (this.state === OnchainForGasSwapState.REFUNDABLE)
+                await (0, TimeoutUtils_1.timeoutPromise)(checkIntervalSeconds * 1000, abortSignal);
+        }
+        if (this.isQuoteExpired())
+            throw new PaymentAuthError_1.PaymentAuthError("Swap expired");
+        if (this.isFailed())
+            throw new PaymentAuthError_1.PaymentAuthError("Swap failed");
+    }
+    async requestRefund(refundAddress, abortSignal) {
+        if (refundAddress != null)
+            await this.setRefundAddress(refundAddress);
+        await this.waitTillRefunded(undefined, abortSignal);
+    }
+    //////////////////////////////
+    //// Storage
+    serialize() {
+        return {
+            ...super.serialize(),
+            paymentHash: this.paymentHash,
+            sequence: this.sequence == null ? null : this.sequence.toString(10),
+            address: this.address,
+            inputAmount: this.inputAmount == null ? null : this.inputAmount.toString(10),
+            outputAmount: this.outputAmount == null ? null : this.outputAmount.toString(10),
+            recipient: this.recipient,
+            token: this.token,
+            refundAddress: this.refundAddress,
+            scTxId: this.scTxId,
+            txId: this.txId,
+            refundTxId: this.refundTxId,
+        };
+    }
+    _getInitiator() {
+        return this.recipient;
+    }
+    //////////////////////////////
+    //// Swap ticks & sync
+    async _sync(save) {
+        if (this.state === OnchainForGasSwapState.PR_CREATED) {
+            //Check if it's maybe already paid
+            const result = await this.checkAddress(false);
+            if (result) {
+                if (save)
+                    await this._saveAndEmit();
+                return true;
+            }
+        }
+        return false;
+    }
+    _tick(save) {
+        return Promise.resolve(false);
+    }
+}
+exports.OnchainForGasSwap = OnchainForGasSwap;