@atomiqlabs/sdk 8.8.3 → 8.9.1

package/src/types/SwapExecutionAction.ts

@@ -1,91 +1,315 @@
 import {ChainType} from "@atomiqlabs/base";
 import {Transaction} from "@scure/btc-signer";
+import {isTokenAmount, TokenAmount} from "./TokenAmount";
+import {BitcoinTokens, BtcToken, isBtcToken} from "./Token";
+
+const swapExecutionActionWaitNames = {
+    LP: "Awaiting LP payout",
+    SETTLEMENT: "Automatic settlement",
+    BITCOIN_CONFS: "Bitcoin confirmations"
+} as const;
+
+function isSwapExecutionActionPsbtTx(
+    obj: any,
+    type?: "FUNDED_PSBT" | "RAW_PSBT"
+): obj is SwapExecutionActionSignPSBT["txs"][number] {
+    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 Transaction &&
+        typeof(obj.psbtHex) === "string" &&
+        typeof(obj.psbtBase64) === "string" &&
+        (
+            resolvedType === "FUNDED_PSBT"
+                ? Array.isArray(obj.signInputs) && obj.signInputs.every((input: any) => typeof(input) === "number")
+                : typeof(obj.in1sequence) === "number"
+        );
+}
 
 /**
- * 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
-    }[]
+        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 function isSwapExecutionActionSendToAddress<Lightning extends boolean = boolean>(
+    obj: any,
+    lightning?: Lightning
+): obj is SwapExecutionActionSendToAddress<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: any) =>
+            tx != null &&
+            typeof(tx) === "object" &&
+            tx.type === (resolvedLightning ? "BOLT11_PAYMENT_REQUEST" : "BITCOIN_ADDRESS") &&
+            typeof(tx.address) === "string" &&
+            typeof(tx.hyperlink) === "string" &&
+            isTokenAmount(
+                tx.amount,
+                resolvedLightning ? BitcoinTokens.BTCLN : BitcoinTokens.BTC,
+                true
+            )
+        ) &&
+        typeof(obj.waitForTransactions) === "function";
+}
+
+/**
+ * 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"
+export type SwapExecutionActionSignPSBT<
+  T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT"
 > = {
-    name: "Payment",
+    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[]
-    } : {
+        signInputs: number[],
+        feeRate: number
+    }[] : {
         type: "RAW_PSBT",
         psbt: Transaction,
         psbtHex: string,
         psbtBase64: string,
-        in1sequence: number
-    })[]
+        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 function isSwapExecutionActionSignPSBT<
+    T extends "FUNDED_PSBT" | "RAW_PSBT" = "FUNDED_PSBT" | "RAW_PSBT"
+>(
+    obj: any,
+    psbtType?: T
+): obj is SwapExecutionActionSignPSBT<T> {
+    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: any) => isSwapExecutionActionPsbtTx(tx, resolvedPsbtType)) &&
+        typeof(obj.submitPsbt) === "function";
 }
 
 /**
- * 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"],
-    txs: T["TX"][]
+    /**
+     * 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
+}
+
+/**
+ * Type guard for {@link SwapExecutionActionSignSmartChainTx}
+ *
+ * @category Swap Actions
+ */
+export function isSwapExecutionActionSignSmartChainTx<T extends ChainType = ChainType>(
+    obj: any,
+    chainIdentifier?: T["ChainId"] | T["ChainId"][]
+): obj is SwapExecutionActionSignSmartChainTx<T> {
+    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";
 }
 
 /**
- * Swap execution action for refunding the swap on the smart chain side after it fails
+ * 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 SwapExecutionActionRefund<T extends ChainType> = {
-    name: "Refund",
+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 function isSwapExecutionActionWait<
+    T extends "LP" | "SETTLEMENT" | "BITCOIN_CONFS" = "LP" | "SETTLEMENT" | "BITCOIN_CONFS"
+>(
+    obj: any,
+    waitType?: T
+): obj is SwapExecutionActionWait<T> {
+    const resolvedWaitType = waitType ??
+        (Object.keys(swapExecutionActionWaitNames).find(key =>
+            swapExecutionActionWaitNames[key as keyof typeof swapExecutionActionWaitNames] === obj?.name
+        ) as keyof typeof swapExecutionActionWaitNames | undefined);
+    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";
 }
 
 /**
@@ -93,8 +317,7 @@ export type SwapExecutionActionRefund<T extends ChainType> = {
  *
  * @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/src/types/SwapExecutionStep.ts

@@ -0,0 +1,224 @@
+/**
+ * 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 function isSwapExecutionStepSetup<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepSetup<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"
+        );
+}
+
+/**
+ * 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 function isSwapExecutionStepPayment<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepPayment<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"
+            )
+        );
+}
+
+/**
+ * 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 function isSwapExecutionStepSettlement<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepSettlement<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"
+        );
+}
+
+/**
+ * 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 function isSwapExecutionStepRefund<Chain extends string = string>(obj: any, chain?: Chain): obj is SwapExecutionStepRefund<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");
+}
+
+/**
+ * Union of all supported swap execution step variants.
+ *
+ * @category Swap Steps
+ */
+export type SwapExecutionStep = SwapExecutionStepSetup |
+    SwapExecutionStepPayment |
+    SwapExecutionStepSettlement |
+    SwapExecutionStepRefund;

package/src/types/TokenAmount.ts

@@ -1,5 +1,5 @@
 import {ISwapPrice} from "../prices/abstract/ISwapPrice";
-import {Token} from "./Token";
+import {isToken, Token} from "./Token";
 import {PriceInfoType} from "./PriceInfoType";
 import {toDecimal} from "../utils/Utils";
 
@@ -66,6 +66,40 @@ export type TokenAmount<
     isUnknown: Known extends true ? false : true
 };
 
+/**
+ * Type guard for {@link TokenAmount}
+ *
+ * @category Tokens
+ */
+export function isTokenAmount<
+    T extends Token = Token,
+    Known extends boolean = boolean
+>(
+    obj: any,
+    token?: T,
+    known?: Known
+): obj is TokenAmount<T, 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 ? 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;
+}
+
 /**
  * Factory function to create a TokenAmount
  *
@@ -130,4 +164,4 @@ export function toTokenAmount<
         toString: () => amountStr + " " + token.ticker,
         isUnknown: false
     } as TokenAmount<T>;
-}
+}

package/src/utils/BitcoinUtils.ts

@@ -130,3 +130,35 @@ export function parsePsbtTransaction(_psbt: Transaction | string): Transaction {
     }
 }
 
+export function getVoutIndex(psbt: Transaction, network: BTC_NETWORK, address: string, amount: bigint): number | undefined {
+    const script = toOutputScript(network, address);
+    for(let i=0;i<psbt.outputsLength;i++) {
+        const output = psbt.getOutput(i);
+        if(
+            output.amount===amount &&
+            output.script!=null &&
+            script.equals(Buffer.from(output.script))
+        ) {
+            return i;
+        }
+    }
+}
+
+export function getSenderAddress(psbt: Transaction, network: BTC_NETWORK, inputIndex: number = 0): string | undefined {
+    if(psbt.inputsLength<=inputIndex) return undefined;
+
+    const input = psbt.getInput(inputIndex);
+    let script: Uint8Array | undefined;
+    if(input.witnessUtxo?.script!=null) {
+        script = input.witnessUtxo.script as Uint8Array;
+    } else if(input.nonWitnessUtxo!=null && input.index!=null) {
+        script = input.nonWitnessUtxo.outputs[input.index]?.script;
+    }
+    if(script==null) return undefined;
+
+    try {
+        return Address(network).encode(OutScript.decode(script));
+    } catch (e) {
+        return Buffer.from(script).toString("hex");
+    }
+}