@atomiqlabs/sdk 7.0.11 → 8.0.7

package/src/swaps/trusted/onchain/OnchainForGasWrapper.ts

@@ -0,0 +1,110 @@
+import {ISwapWrapper, ISwapWrapperOptions, SwapTypeDefinition, WrapperCtorTokens} from "../../ISwapWrapper";
+import {TrustedIntermediaryAPI} from "../../../intermediaries/apis/TrustedIntermediaryAPI";
+import {IntermediaryError} from "../../../errors/IntermediaryError";
+import {ChainType} from "@atomiqlabs/base";
+import {OnchainForGasSwap, OnchainForGasSwapInit, OnchainForGasSwapState} from "./OnchainForGasSwap";
+import {BitcoinRpcWithAddressIndex} from "../../../bitcoin/BitcoinRpcWithAddressIndex";
+import {ISwapPrice} from "../../../prices/abstract/ISwapPrice";
+import {EventEmitter} from "events";
+import {Intermediary} from "../../../intermediaries/Intermediary";
+import {SwapType} from "../../../enums/SwapType";
+import {UnifiedSwapEventListener} from "../../../events/UnifiedSwapEventListener";
+import {UnifiedSwapStorage} from "../../../storage/UnifiedSwapStorage";
+import {ISwap} from "../../ISwap";
+import {BTC_NETWORK} from "@scure/btc-signer/utils";
+
+export type OnchainForGasWrapperOptions = ISwapWrapperOptions & {
+    bitcoinNetwork: BTC_NETWORK
+};
+
+export type OnchainForGasSwapTypeDefinition<T extends ChainType> = SwapTypeDefinition<T, OnchainForGasWrapper<T>, OnchainForGasSwap<T>>;
+
+export class OnchainForGasWrapper<T extends ChainType> extends ISwapWrapper<T, OnchainForGasSwapTypeDefinition<T>, OnchainForGasWrapperOptions> {
+    public readonly TYPE = SwapType.TRUSTED_FROM_BTC;
+    public readonly swapDeserializer = OnchainForGasSwap;
+
+    readonly btcRpc: BitcoinRpcWithAddressIndex<any>;
+
+    /**
+     * @param chainIdentifier
+     * @param unifiedStorage Storage interface for the current environment
+     * @param unifiedChainEvents On-chain event listener
+     * @param chain
+     * @param prices Pricing to use
+     * @param tokens
+     * @param btcRpc Bitcoin RPC which also supports getting transactions by txoHash
+     * @param options
+     * @param events Instance to use for emitting events
+     */
+    constructor(
+        chainIdentifier: string,
+        unifiedStorage: UnifiedSwapStorage<T>,
+        unifiedChainEvents: UnifiedSwapEventListener<T>,
+        chain: T["ChainInterface"],
+        prices: ISwapPrice,
+        tokens: WrapperCtorTokens,
+        btcRpc: BitcoinRpcWithAddressIndex<any>,
+        options: OnchainForGasWrapperOptions,
+        events?: EventEmitter<{swapState: [ISwap]}>
+    ) {
+        super(chainIdentifier, unifiedStorage, unifiedChainEvents, chain, prices, tokens, options, events);
+        this.btcRpc = btcRpc;
+    }
+
+    /**
+     * Returns a newly created swap, receiving 'amount' base units of gas token
+     *
+     * @param signer
+     * @param amount            Amount you wish to receive in base units
+     * @param lpOrUrl           Intermediary/Counterparty swap service Intermediary object or raw url
+     * @param refundAddress     Bitcoin address to receive refund on in case the counterparty cannot execute the swap
+     */
+    async create(signer: string, amount: bigint, lpOrUrl: Intermediary | string, refundAddress?: string): Promise<OnchainForGasSwap<T>> {
+        if(!this.isInitialized) throw new Error("Not initialized, call init() first!");
+
+        const lpUrl = typeof(lpOrUrl)==="string" ? lpOrUrl : lpOrUrl.url;
+
+        const token = this.chain.getNativeCurrencyAddress();
+
+        const resp = await TrustedIntermediaryAPI.initTrustedFromBTC(this.chainIdentifier, lpUrl, {
+            address: signer,
+            amount,
+            refundAddress,
+            token
+        }, this.options.getRequestTimeout);
+
+        if(resp.total !== amount) throw new IntermediaryError("Invalid total returned");
+
+        const pricingInfo = await this.verifyReturnedPrice(
+            typeof(lpOrUrl)==="string" || lpOrUrl.services[SwapType.TRUSTED_FROM_BTC]==null ?
+                {swapFeePPM: 10000, swapBaseFee: 10} :
+                lpOrUrl.services[SwapType.TRUSTED_FROM_BTC],
+            false, resp.amountSats,
+            amount, this.chain.getNativeCurrencyAddress(), {}
+        );
+
+        const quote = new OnchainForGasSwap(this, {
+            paymentHash: resp.paymentHash,
+            sequence: resp.sequence,
+            address: resp.btcAddress,
+            inputAmount: resp.amountSats,
+            outputAmount: resp.total,
+            recipient: signer,
+            refundAddress,
+            pricingInfo,
+            url: lpUrl,
+            expiry: resp.expiresAt,
+            swapFee: resp.swapFee,
+            swapFeeBtc: resp.swapFeeSats,
+            exactIn: false,
+            token
+        } as OnchainForGasSwapInit);
+        await quote._save();
+        return quote;
+    }
+
+    public readonly pendingSwapStates = [OnchainForGasSwapState.PR_CREATED];
+    public readonly tickSwapState = undefined;
+    protected processEvent = undefined;
+
+}

package/src/types/AmountData.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple amount definition for swap operations
+ * @category Tokens
+ */
+export type AmountData = {
+    amount: bigint,
+    token: string,
+    exactIn: boolean
+}

package/src/types/CustomPriceFunction.ts

@@ -0,0 +1,5 @@
+/**
+ * Custom pricing callback function type
+ * @category Pricing and LPs
+ */
+export type CustomPriceFunction = (tickers: string[], abortSignal?: AbortSignal) => Promise<number[]>;

package/src/types/PriceInfoType.ts

@@ -0,0 +1,67 @@
+import {toBigInt} from "../utils/Utils";
+
+/**
+ * Pricing information for swap validation
+ * @category Pricing and LPs
+ */
+export type PriceInfoType = {
+    isValid: boolean,
+    differencePPM: bigint,
+    satsBaseFee: bigint,
+    feePPM: bigint,
+    realPriceUSatPerToken?: bigint,
+    realPriceUsdPerBitcoin?: number,
+    swapPriceUSatPerToken: bigint
+};
+
+/**
+ * Type guard for PriceInfoType
+ * @category Pricing and LPs
+ */
+export function isPriceInfoType(obj: any): obj is PriceInfoType {
+    return obj != null &&
+        typeof (obj.isValid) === "boolean" &&
+        typeof (obj.differencePPM) === "bigint" &&
+        typeof (obj.satsBaseFee) === "bigint" &&
+        typeof (obj.feePPM) === "bigint" &&
+        (obj.realPriceUSatPerToken == null || typeof (obj.realPriceUSatPerToken) === "bigint") &&
+        (obj.realPriceUsdPerBitcoin == null || typeof (obj.realPriceUsdPerBitcoin) === "number") &&
+        typeof (obj.swapPriceUSatPerToken) === "bigint";
+}
+
+/**
+ * Serializes PriceInfoType for storage
+ * @category Pricing and LPs
+ */
+export function serializePriceInfoType(obj: PriceInfoType | undefined): any {
+    if (obj == null) return null;
+    return {
+        isValid: obj.isValid,
+        differencePPM: obj.differencePPM == null ? null : obj.differencePPM.toString(10),
+        satsBaseFee: obj.satsBaseFee == null ? null : obj.satsBaseFee.toString(10),
+        feePPM: obj.feePPM == null ? null : obj.feePPM.toString(10),
+        realPriceUSatPerToken: obj.realPriceUSatPerToken == null ? null : obj.realPriceUSatPerToken.toString(10),
+        realPriceUsdPerBitcoin: obj.realPriceUsdPerBitcoin,
+        swapPriceUSatPerToken: obj.swapPriceUSatPerToken == null ? null : obj.swapPriceUSatPerToken.toString(10),
+    }
+}
+
+/**
+ * Deserializes PriceInfoType from storage
+ * @category Pricing and LPs
+ */
+export function deserializePriceInfoType(obj: any): PriceInfoType | undefined {
+    if (obj == null) return;
+    if (
+        obj.isValid != null && obj.differencePPM != null && obj.satsBaseFee != null &&
+        obj.feePPM != null && obj.swapPriceUSatPerToken != null
+    ) return {
+        isValid: obj.isValid,
+        differencePPM: toBigInt(obj.differencePPM),
+        satsBaseFee: toBigInt(obj.satsBaseFee),
+        feePPM: toBigInt(obj.feePPM),
+        realPriceUSatPerToken: toBigInt(obj.realPriceUSatPerToken),
+        realPriceUsdPerBitcoin: obj.realPriceUsdPerBitcoin,
+        swapPriceUSatPerToken: toBigInt(obj.swapPriceUSatPerToken),
+    }
+}

package/src/types/SwapExecutionAction.ts

@@ -0,0 +1,8 @@
+import {ChainType} from "@atomiqlabs/base";
+
+export type SwapExecutionAction<T extends ChainType> = {
+    name: "Payment" | "Commit" | "Claim",
+    description: string,
+    chain: "LIGHTNING" | "BITCOIN" | T["ChainId"],
+    txs: any[]
+};

package/src/types/SwapWithSigner.ts

@@ -0,0 +1,57 @@
+import {ISwap} from "../swaps/ISwap";
+import {ChainType} from "@atomiqlabs/base";
+import {IToBTCSwap} from "../swaps/escrow_swaps/tobtc/IToBTCSwap";
+import {IFromBTCSelfInitSwap} from "../swaps/escrow_swaps/frombtc/IFromBTCSelfInitSwap";
+import {FromBTCLNSwap} from "../swaps/escrow_swaps/frombtc/ln/FromBTCLNSwap";
+
+/**
+ * Proxy type that auto-injects signer into swap methods
+ * @category Swaps
+ */
+export type SwapWithSigner<T extends ISwap> = {
+    [K in keyof T]:
+        K extends "commit" ? (abortSignal?: AbortSignal, skipChecks?: boolean) => Promise<string> :
+        K extends "refund" ? (abortSignal?: AbortSignal) => Promise<string> :
+        K extends "claim" ? (abortSignal?: AbortSignal) => Promise<string> :
+        K extends "commitAndClaim" ? (abortSignal?: AbortSignal, skipChecks?: boolean) => Promise<string> :
+            T[K];
+};
+
+/**
+ * Wraps a swap with automatic signer injection for methods like commit, refund, and claim
+ * @category Swaps
+ */
+export function wrapSwapWithSigner<C extends ChainType, T extends ISwap<C>>(swap: T, signer: C["Signer"]): SwapWithSigner<T> {
+    return new Proxy(swap, {
+        get: (target, prop, receiver) => {
+            // Override the "sayGoodbye" method
+            if (prop === "commit") {
+                if(swap instanceof IToBTCSwap || swap instanceof IFromBTCSelfInitSwap) {
+                    return (abortSignal?: AbortSignal, skipChecks?: boolean) =>
+                        swap.commit(signer, abortSignal, skipChecks);
+                }
+            }
+            if (prop === "refund") {
+                if(swap instanceof IToBTCSwap) {
+                    return (abortSignal?: AbortSignal) =>
+                        swap.refund(signer, abortSignal);
+                }
+            }
+            if (prop === "claim") {
+                if(swap instanceof IFromBTCSelfInitSwap) {
+                    return (abortSignal?: AbortSignal) =>
+                        swap.claim(signer, abortSignal);
+                }
+            }
+            if (prop === "commitAndClaim") {
+                if(swap instanceof FromBTCLNSwap) {
+                    return (abortSignal?: AbortSignal, skipChecks?: boolean) =>
+                        swap.commitAndClaim(signer, abortSignal, skipChecks);
+                }
+            }
+
+            // Delegate other properties and methods to the original instance
+            return Reflect.get(target, prop, receiver);
+        }
+    }) as SwapWithSigner<T>;
+}

package/src/types/Token.ts

@@ -0,0 +1,90 @@
+/**
+ * Bitcoin token type (on-chain or lightning)
+ * @category Tokens
+ */
+export type BtcToken<L = boolean> = {
+    chain: "BTC",
+    lightning: L,
+    ticker: "BTC",
+    decimals: 8,
+    name: L extends true ? "Bitcoin (lightning L2)" : "Bitcoin (on-chain L1)",
+    displayDecimals?: number
+};
+
+/**
+ * Type guard for BtcToken
+ * @category Tokens
+ */
+export function isBtcToken(obj: any): obj is BtcToken {
+    return typeof (obj) === "object" &&
+        obj.chain === "BTC" &&
+        typeof (obj.lightning) === "boolean" &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+
+/**
+ * Predefined Bitcoin token constants
+ * @category Tokens
+ */
+export const BitcoinTokens: {
+    BTC: BtcToken<false>,
+    BTCLN: BtcToken<true>
+} = {
+    BTC: {
+        chain: "BTC",
+        lightning: false,
+        ticker: "BTC",
+        decimals: 8,
+        name: "Bitcoin (on-chain L1)"
+    },
+    BTCLN: {
+        chain: "BTC",
+        lightning: true,
+        ticker: "BTC",
+        decimals: 8,
+        name: "Bitcoin (lightning L2)"
+    }
+};
+/**
+ * Smart Chain token type
+ * @category Tokens
+ */
+export type SCToken<ChainIdentifier extends string = string> = {
+    chain: "SC",
+    chainId: ChainIdentifier,
+    address: string,
+    ticker: string,
+    decimals: number,
+    displayDecimals?: number,
+    name: string
+}
+
+/**
+ * Type guard for SCToken
+ * @category Tokens
+ */
+export function isSCToken(obj: any): obj is SCToken {
+    return typeof (obj) === "object" &&
+        obj.chain === "SC" &&
+        typeof (obj.chainId) === "string" &&
+        typeof (obj.address) === "string" &&
+        typeof (obj.ticker) === "string" &&
+        typeof (obj.decimals) === "number" &&
+        typeof (obj.name) === "string";
+}
+
+/**
+ * Union type for all token types (BTC or smart chain)
+ * @category Tokens
+ */
+export type Token<ChainIdentifier extends string = string> = BtcToken | SCToken<ChainIdentifier>;
+
+/**
+ * Type guard for Token
+ * @category Tokens
+ */
+export function isToken(obj: any): obj is Token {
+    return isBtcToken(obj) || isSCToken(obj);
+}

package/src/types/TokenAmount.ts

@@ -0,0 +1,110 @@
+import {ISwapPrice} from "../prices/abstract/ISwapPrice";
+import {Token} from "./Token";
+import {PriceInfoType} from "./PriceInfoType";
+import {toDecimal} from "../utils/Utils";
+
+/**
+ * Represents a token amount along with its formatted values and USD valuation helpers
+ * @category Tokens
+ */
+export type TokenAmount<
+    ChainIdentifier extends string = string,
+    T extends Token<ChainIdentifier> = Token<ChainIdentifier>
+> = {
+    /**
+     * Raw amount in base units represented as bigint
+     */
+    rawAmount: bigint,
+    /**
+     * Human readable amount with decimal places
+     */
+    amount: string,
+    /**
+     * Number representation of the decimal token amount (can lose precision!)
+     */
+    _amount: number,
+    /**
+     * Token associated with this amount
+     */
+    token: T,
+    /**
+     * Fetches the current USD value of the amount
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>,
+    /**
+     * Gets USD value of the amount, if this amount was returned from a swap it uses the USD value
+     *  when the swap was created, otherwise fetches the usd value on-demand
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>,
+    /**
+     * USD value of the amount when swap was created - only present for token amounts obtained
+     *  from swaps, left for convenience only, use usdValue() instead, which automatically
+     *  recognizes which pricing to use (either past value if available or fetches it on-demand)
+     */
+    pastUsdValue?: number,
+    /**
+     * Returns the string representation of the amount along with the token ticker in format: {amount} {ticker}
+     */
+    toString: () => string
+};
+
+/**
+ * Factory function to create a TokenAmount
+ * @category Tokens
+ */
+export function toTokenAmount<
+    ChainIdentifier extends string = string,
+    T extends Token<ChainIdentifier> = Token<ChainIdentifier>
+>(
+    amount: bigint,
+    token: T,
+    prices: ISwapPrice,
+    pricingInfo?: PriceInfoType
+): TokenAmount<ChainIdentifier, T> {
+    if (amount == null) return null!; //Shouldn't happen
+    const amountStr = toDecimal(amount, token.decimals, undefined, token.displayDecimals);
+    const _amount = parseFloat(amountStr);
+
+    let usdValue: number | undefined = undefined;
+    if (pricingInfo != null) {
+        if (token.chain === "BTC" && token.ticker === "BTC") {
+            if (pricingInfo.realPriceUsdPerBitcoin != null) {
+                usdValue = Number(amount) * pricingInfo.realPriceUsdPerBitcoin;
+            }
+        } else {
+            if (pricingInfo.realPriceUsdPerBitcoin != null && pricingInfo.realPriceUSatPerToken != null) {
+                usdValue = _amount
+                    * pricingInfo.realPriceUsdPerBitcoin
+                    * Number(pricingInfo.realPriceUSatPerToken)
+                    / 1_000_000;
+            }
+        }
+    }
+
+    const currentUsdValue = (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) =>
+        prices.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
+
+    return {
+        rawAmount: amount,
+        amount: amountStr,
+        _amount,
+        token,
+        currentUsdValue,
+        pastUsdValue: usdValue,
+        usdValue: async (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => {
+            if (usdValue == null) {
+                usdValue = await currentUsdValue(abortSignal, preFetchedUsdPrice);
+            }
+            return usdValue;
+        },
+        toString: () => amountStr + " " + token.ticker
+    };
+}

package/src/types/fees/Fee.ts

@@ -0,0 +1,55 @@
+import {PercentagePPM} from "./PercentagePPM";
+import {TokenAmount} from "../TokenAmount";
+import {Token} from "../Token";
+
+/**
+ * Represents a fee in both source and destination tokens, as well as providing USD valuation helpers and
+ *  fee composition
+ * @category Pricing and LPs
+ */
+export type Fee<
+    ChainIdentifier extends string = string,
+    TSrc extends Token<ChainIdentifier> = Token<ChainIdentifier>,
+    TDst extends Token<ChainIdentifier> = Token<ChainIdentifier>
+> = {
+    /**
+     * Fee value equivalent in source token
+     */
+    amountInSrcToken: TokenAmount<ChainIdentifier, TSrc>,
+    /**
+     * Fee value equivalent in destination token
+     */
+    amountInDstToken: TokenAmount<ChainIdentifier, TDst>,
+    /**
+     * Fetches the current USD value of the fee
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the token amount
+     */
+    currentUsdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>,
+    /**
+     * Gets USD value of the fee, if the USD value when the swap was created is known (newer swaps) it returns this value,
+     *  otherwise fetches the usd value on-demand
+     *
+     * @param abortSignal
+     * @param preFetchedUsdPrice You can supply a pre-fetched usd price to the pricing function
+     * @returns A promise resolving to the current USD value of the fee
+     */
+    usdValue: (abortSignal?: AbortSignal, preFetchedUsdPrice?: number) => Promise<number>,
+    /**
+     * USD value of the fee when swap was created - only present for newer swaps where the USD value at create
+     *  time is known. Left for convenience only, use usdValue() instead, which automatically
+     *  recognizes which pricing to use (either past value if available or fetches it on-demand)
+     */
+    pastUsdValue?: number,
+    /**
+     * Returns the composition of the fee (base fee + percentage fee) if known, the total fee is calculated as:
+     *  base_fee + amount * percentage_fee
+     */
+    composition?: {
+        base: TokenAmount<ChainIdentifier>,
+        percentage: PercentagePPM
+    }
+}
+

package/src/types/fees/FeeBreakdown.ts

@@ -0,0 +1,11 @@
+import {FeeType} from "../../enums/FeeType";
+import {Fee} from "./Fee";
+
+/**
+ * Breakdown of fees by type (swap fee vs network fee)
+ * @category Pricing and LPs
+ */
+export type FeeBreakdown<ChainIdentifier extends string = string> = {
+    type: FeeType,
+    fee: Fee<ChainIdentifier>
+}[];

package/src/types/fees/PercentagePPM.ts

@@ -0,0 +1,24 @@
+/**
+ * Parts-per-million fee representation with conversion helpers
+ * @category Pricing and LPs
+ */
+export type PercentagePPM = {
+    ppm: bigint,
+    decimal: number,
+    percentage: number,
+    toString: (decimal?: number) => string
+};
+
+/**
+ * Converts parts-per-million to percentage representation
+ * @category Pricing and LPs
+ */
+export function ppmToPercentage(ppm: bigint): PercentagePPM {
+    const percentage = Number(ppm) / 10_000;
+    return {
+        ppm,
+        decimal: Number(ppm) / 1_000_000,
+        percentage: percentage,
+        toString: (decimals?: number) => (decimals != null ? percentage.toFixed(decimals) : percentage) + "%"
+    }
+}

package/src/types/lnurl/LNURLPay.ts

@@ -0,0 +1,72 @@
+/**
+ * LNURL-pay request parameters
+ * @category Bitcoin
+ */
+export type LNURLPayParams = {
+    tag: "payRequest";
+    callback: string;
+    domain: string;
+    minSendable: number;
+    maxSendable: number;
+    metadata: string;
+    decodedMetadata: string[][];
+    commentAllowed: number;
+}
+
+/**
+ * LNURL-pay parameters with URL
+ * @category Bitcoin
+ */
+export type LNURLPayParamsWithUrl = LNURLPayParams & { url: string };
+
+/**
+ * LNURL-pay specification
+ * @category Bitcoin
+ */
+export type LNURLPay = {
+    type: "pay",
+    min: bigint,
+    max: bigint,
+    commentMaxLength: number,
+    shortDescription?: string,
+    longDescription?: string,
+    icon?: string,
+    params: LNURLPayParamsWithUrl
+}
+
+/**
+ * Type guard for LNURL-pay parameters
+ * @category Bitcoin
+ */
+export function isLNURLPayParams(obj: any): obj is LNURLPayParams {
+    return obj.tag === "payRequest";
+}
+
+/**
+ * Type guard for LNURL-pay
+ * @category Bitcoin
+ */
+export function isLNURLPay(value: any): value is LNURLPay {
+    return (
+        typeof value === "object" &&
+        value != null &&
+        value.type === "pay" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        typeof value.commentMaxLength === "number" &&
+        (value.shortDescription === undefined || typeof value.shortDescription === "string") &&
+        (value.longDescription === undefined || typeof value.longDescription === "string") &&
+        (value.icon === undefined || typeof value.icon === "string") &&
+        isLNURLPayParams(value.params)
+    );
+}
+
+/**
+ * Decoded LNURL-pay success action
+ * @category Bitcoin
+ */
+export type LNURLDecodedSuccessAction = {
+    description: string,
+    text?: string,
+    url?: string
+};

package/src/types/lnurl/LNURLWithdraw.ts

@@ -0,0 +1,55 @@
+/**
+ * LNURL-withdraw request parameters
+ * @category Bitcoin
+ */
+export type LNURLWithdrawParams = {
+    tag: "withdrawRequest";
+    k1: string;
+    callback: string;
+    domain: string;
+    minWithdrawable: number;
+    maxWithdrawable: number;
+    defaultDescription: string;
+    balanceCheck?: string;
+    payLink?: string;
+}
+
+/**
+ * LNURL-withdraw parameters with URL
+ * @category Bitcoin
+ */
+export type LNURLWithdrawParamsWithUrl = LNURLWithdrawParams & { url: string };
+
+/**
+ * LNURL-withdraw specification
+ * @category Bitcoin
+ */
+export type LNURLWithdraw = {
+    type: "withdraw",
+    min: bigint,
+    max: bigint,
+    params: LNURLWithdrawParamsWithUrl
+}
+
+/**
+ * Type guard for LNURL-withdraw
+ * @category Bitcoin
+ */
+export function isLNURLWithdraw(value: any): value is LNURLWithdraw {
+    return (
+        typeof value === "object" &&
+        value != null &&
+        value.type === "withdraw" &&
+        typeof (value.min) === "bigint" &&
+        typeof (value.max) === "bigint" &&
+        isLNURLWithdrawParams(value.params)
+    );
+}
+
+/**
+ * Type guard for LNURL-withdraw parameters
+ * @category Bitcoin
+ */
+export function isLNURLWithdrawParams(obj: any): obj is LNURLWithdrawParams {
+    return obj.tag === "withdrawRequest";
+}