@atomiqlabs/sdk 8.7.7 → 8.9.0

package/dist/types/SwapExecutionAction.d.ts

@@ -1,88 +1,195 @@
 import { ChainType } from "@atomiqlabs/base";
 import { Transaction } from "@scure/btc-signer";
+import { TokenAmount } from "./TokenAmount";
+import { BtcToken } from "./Token";
 /**
- * Swap execution action requiring a payment of the provided bolt11 lightning network invoice
+ * Swap execution action requiring the user to send assets to a specific LIGHTNING invoice or BITCOIN
+ *  on-chain address
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionLightning = {
-    name: "Payment";
+export type SwapExecutionActionSendToAddress<Lightning extends boolean = boolean> = {
+    type: "SendToAddress";
+    /**
+     * Human-readable name of the action
+     */
+    name: Lightning extends true ? "Deposit on Lightning" : "Deposit on Bitcoin";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
-    chain: "LIGHTNING";
+    /**
+     * Chain on which the payment is expected, either `LIGHTNING` or `BITCOIN` for on-chain
+     */
+    chain: Lightning extends true ? "LIGHTNING" : "BITCOIN";
+    /**
+     * An array of payments that should be made to different addresses, usually only a single address is returned
+     */
     txs: {
-        type: "BOLT11_PAYMENT_REQUEST";
+        type: Lightning extends true ? "BOLT11_PAYMENT_REQUEST" : "BITCOIN_ADDRESS";
         address: string;
         hyperlink: string;
+        amount: TokenAmount<BtcToken<Lightning>, true>;
     }[];
+    /**
+     * Waits till the transaction is received, doesn't wait for the actual confirmation!
+     *
+     * @returns A transaction ID of the received transaction
+     */
+    waitForTransactions: (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal) => Promise<string>;
 };
 /**
- * Swap execution action on on-chain Bitcoin, has following types:
- * - `"ADDRESS"` - Destination bitcoin address and BTC amount to be sent
+ * Type guard for {@link SwapExecutionActionSendToAddress}
+ *
+ * @category Swap Actions
+ */
+export declare function isSwapExecutionActionSendToAddress<Lightning extends boolean = boolean>(obj: any, lightning?: Lightning): obj is SwapExecutionActionSendToAddress<Lightning>;
+/**
+ * Swap execution action requiring the user to sign the provided PSBT and then submit it back via the provided
+ *  `submitPsbt()` function, has two variations:
  * - `"FUNDED_PSBT"` - A ready to sign PSBT with the inputs populated from the provided bitcoin wallet address
  * - `"RAW_PSBT"` - Raw PSBT without the inputs, the implementor needs to add the input UTXOs before signing
- *  the transaction
+ *  the transaction (also make sure to set the `nSequence` field of the 2nd input, index 1, to the provided
+ *  `in1sequence` value)
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionBitcoin<T extends "ADDRESS" | "FUNDED_PSBT" | "RAW_PSBT" = "ADDRESS" | "FUNDED_PSBT" | "RAW_PSBT"> = {
-    name: "Payment";
+export type SwapExecutionActionSignPSBT<T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT"> = {
+    type: "SignPSBT";
+    /**
+     * Human-readable name of the action
+     */
+    name: "Deposit on Bitcoin";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
+    /**
+     * Chain is always bitcoin
+     */
     chain: "BITCOIN";
-    txs: (T extends "ADDRESS" ? {
-        type: "ADDRESS";
-        amount: number;
-        address: string;
-        hyperlink: string;
-    } : T extends "FUNDED_PSBT" ? {
+    /**
+     * An array of PSBTs that need to be signed, usually contains only a single PSBT
+     */
+    txs: T extends "FUNDED_PSBT" ? {
         type: "FUNDED_PSBT";
         psbt: Transaction;
         psbtHex: string;
         psbtBase64: string;
         signInputs: number[];
-    } : {
+        feeRate: number;
+    }[] : {
         type: "RAW_PSBT";
         psbt: Transaction;
         psbtHex: string;
         psbtBase64: string;
         in1sequence: number;
-    })[];
+        feeRate: number;
+    }[];
+    /**
+     * Submit a signed PSBT, accepts hexadecimal, base64 and `@scure/btc-signer` {@link Transaction} object.
+     *
+     * @returns An array of transaction IDs of the submitted Bitcoin transactions
+     */
+    submitPsbt: (signedPsbt: string | Transaction | (string | Transaction)[], idempotent?: boolean) => Promise<string[]>;
 };
 /**
- * Swap execution action for committing (initiating) the escrow on the smart chain side
+ * Type guard for {@link SwapExecutionActionSignPSBT}
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionCommit<T extends ChainType> = {
-    name: "Commit";
-    description: string;
-    chain: T["ChainId"];
-    txs: T["TX"][];
-};
+export declare function isSwapExecutionActionSignPSBT<T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT">(obj: any, psbtType?: T): obj is SwapExecutionActionSignPSBT<T>;
 /**
- * Swap execution action for claiming (settling) the swap on the smart chain side
+ * Swap execution action requiring the user to sign the provided smart chain transactions, these can then
+ *  be either broadcasted manually, or sent via the provided `submitTransactions()` function
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionClaim<T extends ChainType> = {
-    name: "Claim";
+export type SwapExecutionActionSignSmartChainTx<T extends ChainType = ChainType> = {
+    type: "SignSmartChainTransaction";
+    /**
+     * Human-readable name of the action
+     */
+    name: "Initiate swap" | "Settle manually" | "Refund";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
+    /**
+     * Chain identifier of the smart chain on which the corresponding transactions should be signed
+     */
     chain: T["ChainId"];
+    /**
+     * Smart chain transactions that should be signed and either broadcasted manually or submitted back
+     *  to the provided `submitTransactions()` function
+     */
     txs: T["TX"][];
+    /**
+     * Submits the signed transactions and waits for their confirmation
+     *
+     * @remarks This might not do any validation on the submitted transactions, so returned txids are informational
+     *  only and may not be persisted immediately. The swap may wait for an authoritative state transition before
+     *  considering the submitted transactions accepted.
+     *
+     *  Make sure to only submit valid signed transactions obtained from this action object, and pass an AbortSignal
+     *  if you need a timeout, otherwise this call can wait indefinitely when invalid transactions are submitted.
+     */
+    submitTransactions: (txs: (T["SignedTXType"] | string)[], abortSignal?: AbortSignal, idempotent?: boolean) => Promise<string[]>;
+    /**
+     * The address of the signer that has to sign the transactions
+     */
+    requiredSigner: string;
 };
 /**
- * Swap execution action for refunding the swap on the smart chain side after it fails
+ * Type guard for {@link SwapExecutionActionSignSmartChainTx}
  *
  * @category Swap Actions
  */
-export type SwapExecutionActionRefund<T extends ChainType> = {
-    name: "Refund";
+export declare function isSwapExecutionActionSignSmartChainTx<T extends ChainType = ChainType>(obj: any, chainIdentifier?: T["ChainId"] | T["ChainId"][]): obj is SwapExecutionActionSignSmartChainTx<T>;
+/**
+ * Swap action indicating that the user should wait for either LP to process the swap, automatic settlement to happen or
+ *  until the Bitcoin transaction gets enough confirmations
+ *
+ * @category Swap Actions
+ */
+export type SwapExecutionActionWait<T extends "LP" | "SETTLEMENT" | "BITCOIN_CONFS" = "LP" | "SETTLEMENT" | "BITCOIN_CONFS"> = {
+    type: "Wait";
+    /**
+     * Human-readable name of the action
+     */
+    name: T extends "LP" ? "Awaiting LP payout" : T extends "SETTLEMENT" ? "Automatic settlement" : "Bitcoin confirmations";
+    /**
+     * Human-readable description of the action
+     */
     description: string;
-    chain: T["ChainId"];
-    txs: T["TX"][];
+    /**
+     * Allows you to await till this action resolves
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for
+     * @param pollIntervalSeconds How often to poll for the state change (default 5 seconds)
+     * @param abortSignal AbortSignal to abort the wait
+     * @param btcConfirmationsCallback Optional callback when awaiting bitcoin confirmations, gets called when
+     *  number of bitcoin confirmations change
+     */
+    wait: T extends "BITCOIN_CONFS" ? (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal, btcConfirmationsCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void) => Promise<void> : (maxWaitTimeSeconds?: number, pollIntervalSeconds?: number, abortSignal?: AbortSignal) => Promise<void>;
+    /**
+     * Expected time in seconds for this action to take
+     */
+    expectedTimeSeconds: number;
+    /**
+     * Recommended time interval in seconds after which you should re-check the current action
+     */
+    pollTimeSeconds: number;
 };
+/**
+ * Type guard for {@link SwapExecutionActionWait}
+ *
+ * @category Swap Actions
+ */
+export declare function isSwapExecutionActionWait<T extends "LP" | "SETTLEMENT" | "BITCOIN_CONFS" = "LP" | "SETTLEMENT" | "BITCOIN_CONFS">(obj: any, waitType?: T): obj is SwapExecutionActionWait<T>;
 /**
  * Swap execution action, a single step in the swapping process
  *
  * @category Swap Actions
  */
-export type SwapExecutionAction<T extends ChainType> = SwapExecutionActionLightning | SwapExecutionActionBitcoin | SwapExecutionActionCommit<T> | SwapExecutionActionClaim<T> | SwapExecutionActionRefund<T>;
+export type SwapExecutionAction = SwapExecutionActionSendToAddress | SwapExecutionActionSignPSBT | SwapExecutionActionSignSmartChainTx | SwapExecutionActionWait;

package/dist/types/SwapExecutionAction.js

@@ -1,2 +1,106 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSwapExecutionActionWait = exports.isSwapExecutionActionSignSmartChainTx = exports.isSwapExecutionActionSignPSBT = exports.isSwapExecutionActionSendToAddress = void 0;
+const btc_signer_1 = require("@scure/btc-signer");
+const TokenAmount_1 = require("./TokenAmount");
+const Token_1 = require("./Token");
+const swapExecutionActionWaitNames = {
+    LP: "Awaiting LP payout",
+    SETTLEMENT: "Automatic settlement",
+    BITCOIN_CONFS: "Bitcoin confirmations"
+};
+function isSwapExecutionActionPsbtTx(obj, type) {
+    const resolvedType = type ?? obj?.type;
+    if (obj == null || typeof (obj) !== "object")
+        return false;
+    if (resolvedType !== "FUNDED_PSBT" && resolvedType !== "RAW_PSBT")
+        return false;
+    return obj.type === resolvedType &&
+        obj.psbt instanceof btc_signer_1.Transaction &&
+        typeof (obj.psbtHex) === "string" &&
+        typeof (obj.psbtBase64) === "string" &&
+        (resolvedType === "FUNDED_PSBT"
+            ? Array.isArray(obj.signInputs) && obj.signInputs.every((input) => typeof (input) === "number")
+            : typeof (obj.in1sequence) === "number");
+}
+/**
+ * Type guard for {@link SwapExecutionActionSendToAddress}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSendToAddress(obj, lightning) {
+    const resolvedLightning = lightning ?? (obj?.chain === "LIGHTNING");
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SendToAddress" &&
+        obj.name === (resolvedLightning ? "Deposit on Lightning" : "Deposit on Bitcoin") &&
+        typeof (obj.description) === "string" &&
+        obj.chain === (resolvedLightning ? "LIGHTNING" : "BITCOIN") &&
+        Array.isArray(obj.txs) &&
+        obj.txs.every((tx) => tx != null &&
+            typeof (tx) === "object" &&
+            tx.type === (resolvedLightning ? "BOLT11_PAYMENT_REQUEST" : "BITCOIN_ADDRESS") &&
+            typeof (tx.address) === "string" &&
+            typeof (tx.hyperlink) === "string" &&
+            (0, TokenAmount_1.isTokenAmount)(tx.amount, resolvedLightning ? Token_1.BitcoinTokens.BTCLN : Token_1.BitcoinTokens.BTC, true)) &&
+        typeof (obj.waitForTransactions) === "function";
+}
+exports.isSwapExecutionActionSendToAddress = isSwapExecutionActionSendToAddress;
+/**
+ * Type guard for {@link SwapExecutionActionSignPSBT}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSignPSBT(obj, psbtType) {
+    const resolvedPsbtType = psbtType ?? obj?.txs?.[0]?.type;
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SignPSBT" &&
+        obj.name === "Deposit on Bitcoin" &&
+        typeof (obj.description) === "string" &&
+        obj.chain === "BITCOIN" &&
+        Array.isArray(obj.txs) &&
+        obj.txs.every((tx) => isSwapExecutionActionPsbtTx(tx, resolvedPsbtType)) &&
+        typeof (obj.submitPsbt) === "function";
+}
+exports.isSwapExecutionActionSignPSBT = isSwapExecutionActionSignPSBT;
+/**
+ * Type guard for {@link SwapExecutionActionSignSmartChainTx}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionSignSmartChainTx(obj, chainIdentifier) {
+    const allowedChains = chainIdentifier == null ? null : Array.isArray(chainIdentifier) ? chainIdentifier : [chainIdentifier];
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "SignSmartChainTransaction" &&
+        (obj.name === "Initiate swap" ||
+            obj.name === "Settle manually" ||
+            obj.name === "Refund") &&
+        typeof (obj.description) === "string" &&
+        typeof (obj.chain) === "string" &&
+        (allowedChains == null || allowedChains.includes(obj.chain)) &&
+        Array.isArray(obj.txs) &&
+        typeof (obj.submitTransactions) === "function" &&
+        typeof (obj.requiredSigner) === "string";
+}
+exports.isSwapExecutionActionSignSmartChainTx = isSwapExecutionActionSignSmartChainTx;
+/**
+ * Type guard for {@link SwapExecutionActionWait}
+ *
+ * @category Swap Actions
+ */
+function isSwapExecutionActionWait(obj, waitType) {
+    const resolvedWaitType = waitType ??
+        Object.keys(swapExecutionActionWaitNames).find(key => swapExecutionActionWaitNames[key] === obj?.name);
+    return obj != null &&
+        typeof (obj) === "object" &&
+        obj.type === "Wait" &&
+        resolvedWaitType != null &&
+        obj.name === swapExecutionActionWaitNames[resolvedWaitType] &&
+        typeof (obj.description) === "string" &&
+        typeof (obj.wait) === "function" &&
+        typeof (obj.expectedTimeSeconds) === "number" &&
+        typeof (obj.pollTimeSeconds) === "number";
+}
+exports.isSwapExecutionActionWait = isSwapExecutionActionWait;

package/dist/types/SwapExecutionStep.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Execution step describing destination-side setup required before the swap can continue.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStepSetup<Chain extends string = string> = {
+    type: "Setup";
+    side: "destination";
+    chain: Chain;
+    title: string;
+    description: string;
+    /**
+     * Current status of the setup step.
+     *
+     * - `awaiting`: The setup transaction or action still needs to be performed.
+     * - `completed`: The setup was already completed successfully.
+     * - `soft_expired`: The setup should be treated as expired by the user, but it may still progress because of in-flight or background processing.
+     * - `expired`: The setup can no longer be performed because the swap expired.
+     */
+    status: "awaiting" | "completed" | "soft_expired" | "expired";
+    setupTxId?: string;
+};
+/**
+ * Type guard for {@link SwapExecutionStepSetup}
+ *
+ * @category Swap Steps
+ */
+export declare function isSwapExecutionStepSetup<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepSetup<Chain>;
+/**
+ * Execution step describing the user payment that initiates or funds the swap.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStepPayment<Chain extends string = string> = {
+    type: "Payment";
+    side: "source";
+    chain: Chain;
+    title: string;
+    description: string;
+    /**
+     * Current status of the payment step.
+     *
+     * - `inactive`: The payment step is not yet active because a previous step must complete first.
+     * - `awaiting`: The payment is expected, but no payment transaction is known yet.
+     * - `received`: A payment transaction is known, but it is not yet fully confirmed.
+     * - `confirmed`: The payment was confirmed and fully satisfies the swap requirements.
+     * - `soft_expired`: The payment should be treated as expired by the user, but it may still progress because of in-flight or background processing.
+     * - `expired`: The payment step can no longer be completed because the swap expired.
+     */
+    status: "inactive" | "awaiting" | "received" | "confirmed" | "soft_expired" | "expired";
+    /**
+     * Optional confirmation progress for Bitcoin on-chain payments.
+     */
+    confirmations?: {
+        /**
+         * Number of confirmations currently observed for the payment.
+         */
+        current: number;
+        /**
+         * Number of confirmations required before the payment is considered final.
+         */
+        target: number;
+        /**
+         * Estimated remaining time in seconds until the target confirmation count is reached.
+         *
+         * Can be `-1` if the estimate is not available.
+         */
+        etaSeconds: number;
+    };
+    initTxId?: string;
+    settleTxId?: string;
+};
+/**
+ * Type guard for {@link SwapExecutionStepPayment}
+ *
+ * @category Swap Steps
+ */
+export declare function isSwapExecutionStepPayment<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepPayment<Chain>;
+/**
+ * Execution step describing payout or settlement on the destination side of the swap.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStepSettlement<Chain extends string = string, AdditionalStatuses extends "awaiting_automatic" | "awaiting_manual" | "soft_settled" = "awaiting_automatic" | "awaiting_manual" | "soft_settled"> = {
+    type: "Settlement";
+    side: "destination";
+    chain: Chain;
+    title: string;
+    description: string;
+    /**
+     * Current status of the settlement step.
+     *
+     * - `inactive`: The settlement step is not yet active because a previous step must complete first.
+     * - `waiting_lp`: The swap is waiting for the intermediary (LP) to create or process the destination-side payout.
+     * - `awaiting_automatic`: The swap is waiting for automatic settlement by watchtowers.
+     * - `awaiting_manual`: The swap is ready for manual destination-side settlement by the user.
+     * - `soft_settled`: The user already received the payout, but the swap is not yet fully finalized on the source side.
+     * - `soft_expired`: The settlement should be treated as expired by the user, but it may still progress because of in-flight or background processing.
+     * - `settled`: The settlement completed successfully.
+     * - `expired`: Settlement is no longer possible because the swap expired or failed.
+     */
+    status: "inactive" | "waiting_lp" | "soft_expired" | "settled" | "expired" | AdditionalStatuses;
+    initTxId?: string;
+    settleTxId?: string;
+};
+/**
+ * Type guard for {@link SwapExecutionStepSettlement}
+ *
+ * @category Swap Steps
+ */
+export declare function isSwapExecutionStepSettlement<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepSettlement<Chain>;
+/**
+ * Execution step describing a source-side refund path after a failed swap.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStepRefund<Chain extends string = string> = {
+    type: "Refund";
+    side: "source";
+    chain: Chain;
+    title: string;
+    description: string;
+    /**
+     * Current status of the refund step.
+     *
+     * - `inactive`: The refund path is not currently available.
+     * - `awaiting`: The swap can be refunded and the user may perform the refund action.
+     * - `refunded`: The refund was completed successfully.
+     */
+    status: "inactive" | "awaiting" | "refunded";
+    refundTxId?: string;
+};
+/**
+ * Type guard for {@link SwapExecutionStepRefund}
+ *
+ * @category Swap Steps
+ */
+export declare function isSwapExecutionStepRefund<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepRefund<Chain>;
+/**
+ * Union of all supported swap execution step variants.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStep = SwapExecutionStepSetup | SwapExecutionStepPayment | SwapExecutionStepSettlement | SwapExecutionStepRefund;

package/dist/types/SwapExecutionStep.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSwapExecutionStepRefund = exports.isSwapExecutionStepSettlement = exports.isSwapExecutionStepPayment = exports.isSwapExecutionStepSetup = void 0;
+/**
+ * Type guard for {@link SwapExecutionStepSetup}
+ *
+ * @category Swap Steps
+ */
+function isSwapExecutionStepSetup(obj, chain) {
+    return typeof (obj) === "object" &&
+        obj.type === "Setup" &&
+        obj.side === "destination" &&
+        typeof (obj.chain) === "string" &&
+        (chain == null || obj.chain === chain) &&
+        typeof (obj.title) === "string" &&
+        typeof (obj.description) === "string" &&
+        (obj.status === "awaiting" ||
+            obj.status === "completed" ||
+            obj.status === "soft_expired" ||
+            obj.status === "expired");
+}
+exports.isSwapExecutionStepSetup = isSwapExecutionStepSetup;
+/**
+ * Type guard for {@link SwapExecutionStepPayment}
+ *
+ * @category Swap Steps
+ */
+function isSwapExecutionStepPayment(obj, chain) {
+    return typeof (obj) === "object" &&
+        obj.type === "Payment" &&
+        obj.side === "source" &&
+        typeof (obj.chain) === "string" &&
+        (chain == null || obj.chain === chain) &&
+        typeof (obj.title) === "string" &&
+        typeof (obj.description) === "string" &&
+        (obj.status === "inactive" ||
+            obj.status === "awaiting" ||
+            obj.status === "received" ||
+            obj.status === "confirmed" ||
+            obj.status === "soft_expired" ||
+            obj.status === "expired") &&
+        (obj.confirmations == null ||
+            (typeof (obj.confirmations) === "object" &&
+                typeof (obj.confirmations.current) === "number" &&
+                typeof (obj.confirmations.target) === "number" &&
+                typeof (obj.confirmations.etaSeconds) === "number"));
+}
+exports.isSwapExecutionStepPayment = isSwapExecutionStepPayment;
+/**
+ * Type guard for {@link SwapExecutionStepSettlement}
+ *
+ * @category Swap Steps
+ */
+function isSwapExecutionStepSettlement(obj, chain) {
+    return typeof (obj) === "object" &&
+        obj.type === "Settlement" &&
+        obj.side === "destination" &&
+        typeof (obj.chain) === "string" &&
+        (chain == null || obj.chain === chain) &&
+        typeof (obj.title) === "string" &&
+        typeof (obj.description) === "string" &&
+        (obj.status === "inactive" ||
+            obj.status === "waiting_lp" ||
+            obj.status === "awaiting_automatic" ||
+            obj.status === "awaiting_manual" ||
+            obj.status === "soft_settled" ||
+            obj.status === "soft_expired" ||
+            obj.status === "settled" ||
+            obj.status === "expired");
+}
+exports.isSwapExecutionStepSettlement = isSwapExecutionStepSettlement;
+/**
+ * Type guard for {@link SwapExecutionStepRefund}
+ *
+ * @category Swap Steps
+ */
+function isSwapExecutionStepRefund(obj, chain) {
+    return typeof (obj) === "object" &&
+        obj.type === "Refund" &&
+        obj.side === "source" &&
+        typeof (obj.chain) === "string" &&
+        (chain == null || obj.chain === chain) &&
+        typeof (obj.title) === "string" &&
+        typeof (obj.description) === "string" &&
+        (obj.status === "inactive" || obj.status === "awaiting" || obj.status === "refunded");
+}
+exports.isSwapExecutionStepRefund = isSwapExecutionStepRefund;

package/dist/types/TokenAmount.d.ts

@@ -60,6 +60,12 @@ export type TokenAmount<T extends Token = Token, Known extends boolean = boolean
      */
     isUnknown: Known extends true ? false : true;
 };
+/**
+ * Type guard for {@link TokenAmount}
+ *
+ * @category Tokens
+ */
+export declare function isTokenAmount<T extends Token = Token, Known extends boolean = boolean>(obj: any, token?: T, known?: Known): obj is TokenAmount<T, Known>;
 /**
  * Factory function to create a TokenAmount
  *

package/dist/types/TokenAmount.js

@@ -1,7 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toTokenAmount = void 0;
+exports.toTokenAmount = exports.isTokenAmount = void 0;
+const Token_1 = require("./Token");
 const Utils_1 = require("../utils/Utils");
+/**
+ * Type guard for {@link TokenAmount}
+ *
+ * @category Tokens
+ */
+function isTokenAmount(obj, token, known) {
+    const hasExpectedKnownState = known == null
+        ? ((typeof (obj?.rawAmount) === "bigint" && obj?.isUnknown === false) ||
+            (obj?.rawAmount === undefined && obj?.isUnknown === true))
+        : known
+            ? typeof (obj?.rawAmount) === "bigint" && obj?.isUnknown === false
+            : obj?.rawAmount === undefined && obj?.isUnknown === true;
+    return obj != null &&
+        typeof (obj) === "object" &&
+        typeof (obj.amount) === "string" &&
+        typeof (obj._amount) === "number" &&
+        (token == null ? (0, Token_1.isToken)(obj.token) : token.equals(obj.token)) &&
+        typeof (obj.currentUsdValue) === "function" &&
+        typeof (obj.usdValue) === "function" &&
+        (obj.pastUsdValue == null || typeof (obj.pastUsdValue) === "number") &&
+        typeof (obj.toString) === "function" &&
+        hasExpectedKnownState;
+}
+exports.isTokenAmount = isTokenAmount;
 /**
  * Factory function to create a TokenAmount
  *

package/dist/utils/BitcoinUtils.d.ts

@@ -7,8 +7,12 @@ import { CoinselectAddressTypes } from "../bitcoin/coinselect2";
 export declare function fromOutputScript(network: BTC_NETWORK, outputScriptHex: string): string;
 export declare function toOutputScript(network: BTC_NETWORK, address: string): Buffer;
 export declare function toCoinselectAddressType(outputScript: Uint8Array): CoinselectAddressTypes;
+export declare function getDummyOutputScript(type: CoinselectAddressTypes): Uint8Array;
+export declare function getDummyAddress(network: BTC_NETWORK, type: CoinselectAddressTypes): string;
 /**
  * General parsers for PSBTs, can parse hex or base64 encoded PSBTs
  * @param _psbt
  */
 export declare function parsePsbtTransaction(_psbt: Transaction | string): Transaction;
+export declare function getVoutIndex(psbt: Transaction, network: BTC_NETWORK, address: string, amount: bigint): number | undefined;
+export declare function getSenderAddress(psbt: Transaction, network: BTC_NETWORK, inputIndex?: number): string | undefined;