@bestinslot/wallet-kit 0.7.0

package/dist/types/core/bis_swap.d.ts

@@ -0,0 +1,622 @@
+import { SwapFees } from '../lib/swap-reporting';
+import { BISSwapWalletInfo } from './store';
+/**
+ * Checks IndexedDB for an existing swap wallet associated with the current ordinals wallet address.
+ *
+ * @returns {Promise<BISSwapWalletInfo | null>} Resolves with the SwapWalletInfo if found, or null if no wallet is stored for the current ordinals address.
+ */
+export declare function getSwapWalletFromDB(): Promise<BISSwapWalletInfo | null>;
+/**
+ * Generates a new swap wallet by creating a BLS key pair derived from a deterministic signature of the user's ordinals wallet.
+ *
+ * The process involves:
+ * 1. Validating that the ordinals wallet address is available.
+ * 2. Generating a deterministic signature using the ordinals wallet's signing function, and deriving a BLS private key from it using HKDF.
+ * 3. Computing the corresponding BLS public key.
+ * 4. Storing the swap wallet information (Bitcoin address, BLS public key, and BLS private key) in IndexedDB for future use.
+ *
+ * @returns {Promise<BISSwapWalletInfo>} Resolves with the generated SwapWalletInfo containing the Bitcoin address, BLS public key, and BLS private key.
+ */
+export declare function generateAndStoreSwapWallet(): Promise<BISSwapWalletInfo>;
+export interface ImportSwapWalletOptions {
+    /**
+     * Replace a stored wallet whose key differs from the imported one. Required for that case, because an import
+     * is destructive: it is only ever needed when derivation is no longer reproducing the right key, so replacing
+     * the stored wallet is the point — but it should be asked for rather than happen as a side effect.
+     */
+    overwrite?: boolean;
+}
+/**
+ * Restores a swap wallet from a saved security code, binding it to the connected ordinals wallet.
+ *
+ * Swap wallets are normally derived from a BIP-322 signature, and that derivation is guarded at creation by
+ * signing twice and comparing. If a wallet later starts signing non-deterministically — a wallet update, or the
+ * same address moved to a different implementation whose BIP-322 output differs byte-for-byte — the derivation
+ * no longer reproduces the key, and the funds become unreachable even though the address is still controlled.
+ * This is the way back: the saved code is exactly what the derivation was supposed to produce.
+ *
+ * Importing does not weaken the security of the code. It restores only the BLS half of a swap wallet's
+ * authority; the backend requires a BIP-322 signature from the ordinals address on every withdraw and unwrap,
+ * and resolves that address from the BLS public key. So a code imported under an address that does not own the
+ * funds is inert, and a stolen code still cannot move anything on its own.
+ *
+ * The code is validated before anything is stored, and re-importing the code already in storage is a no-op.
+ * Replacing a *different* stored wallet requires `overwrite`.
+ *
+ * @param securityCode The security code to import, as hex with or without a `0x` prefix.
+ * @param options Import options. Set `overwrite` to replace a stored wallet whose key differs from this one.
+ * @returns {Promise<BISSwapWalletInfo>} Resolves with the imported swap wallet, now stored against the connected ordinals address.
+ */
+export declare function importSwapWallet(securityCode: string, options?: ImportSwapWalletOptions): Promise<BISSwapWalletInfo>;
+export interface EnsureSwapWalletResult {
+    /** The swap wallet now in storage, whether it was just created or already there. */
+    wallet: BISSwapWalletInfo;
+    /** True only when this call derived and stored the wallet. False when one already existed. */
+    created: boolean;
+}
+/**
+ * Returns the swap wallet for the connected ordinals wallet, deriving and storing one only if none exists yet.
+ *
+ * This is the idempotent counterpart to `generateAndStoreSwapWallet`, which re-derives (and so re-prompts for two
+ * signatures) on every call. Callers that just want the wallet to exist — e.g. on every connect — should use this
+ * instead, so a user with a wallet already on disk is never asked to sign again.
+ *
+ * `created` distinguishes the two paths, so a caller can show a first-run disclosure exactly once.
+ *
+ * @returns {Promise<EnsureSwapWalletResult>} Resolves with the swap wallet and whether this call created it.
+ */
+export declare function ensureSwapWallet(): Promise<EnsureSwapWalletResult>;
+/**
+ * Reads the security code (the BLS private key) of the stored swap wallet for the connected ordinals wallet.
+ *
+ * The code is a second factor, not a recovery seed: on its own it cannot move funds, because the swap backend
+ * requires a BIP-322 signature from the ordinals address alongside every BLS-signed order. It is exposed so that
+ * an interface can show it again after creation without re-deriving the wallet.
+ *
+ * @returns {Promise<string | null>} Resolves with the security code, or null if no swap wallet is stored for the connected address.
+ */
+export declare function getSwapWalletSecurityCode(): Promise<string | null>;
+export interface GetSwapStatusResponse {
+    reorg_handler_running: boolean;
+    emergency_stop: boolean;
+}
+/**
+ * Checks the status of the swap backend, including whether the reorg handler is running and if emergency stop is active.
+ *
+ * This function is useful for the frontend to determine if the swap functionalities are currently operational or if there are any issues with the backend that users should be aware of.
+ *
+ * @returns {Promise<GetSwapStatusResponse>} An object containing the status of the reorg handler and emergency stop.
+ */
+export declare function getSwapStatus(): Promise<GetSwapStatusResponse>;
+/**
+ * Checks the swap allowance for a given token address by making an API call to the swap backend.
+ *
+ * @param tokenAddress The address of the token to check the allowance for.
+ *
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the swap allowance for the specified token address. The allowance is returned as a string from the API and converted to bigint in this function.
+ */
+export declare function getSwapAllowance(tokenAddress: string): Promise<bigint>;
+export interface SwapInfo {
+    factory_address: string;
+    wbtc_address: string;
+    wbtc_handler_address: string;
+}
+/**
+ * Fetches the swap's deployment info — the factory, WBTC and WBTC handler addresses — for the current network, by making an API call to the swap backend. The result is fetched once per network and cached.
+ *
+ * This does not require a connected wallet or a smart wallet.
+ *
+ * @returns {Promise<SwapInfo>} A promise that resolves to a SwapInfo object containing the factory address, the WBTC token address, and the WBTC handler address.
+ */
+export declare function getSwapInfo(): Promise<SwapInfo>;
+/**
+ * Checks the BRC-20 token balance for the current ordinals wallet address by making an API call to the swap backend.
+ *
+ * @param tokenAddress The address of the BRC-20 token to check the balance for.
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the BRC-20 token balance for the current ordinals wallet address. The balance is returned as a string from the API and converted to bigint in this function.
+ */
+export declare function getBRC20ProgBalance(tokenAddress: string): Promise<bigint>;
+export interface SwapBalance {
+    token_address: string;
+    balance: string;
+    ticker: string;
+    decimals: number;
+    is_lp: boolean;
+    price_sats: number;
+    reserve_token_amt?: string;
+    token_decimals?: number;
+    reserve_btc_amt?: string;
+    btc_decimals?: number;
+    lp_total_supply?: string;
+}
+/**
+ * Checks the swap balances for all tokens associated with the current ordinals wallet address by making an API call to the swap backend.
+ *
+ * @param ordinalsAddress The ordinals wallet address to check the swap balances for.
+ * @returns {Promise<SwapBalance[]>} A promise that resolves to an array of SwapBalance objects, each containing details about the token address, balance, ticker, decimals, whether it's an LP token, price in sats, and optionally reserve amounts and decimals for LP tokens. The balances are returned as strings from the API and can be converted to bigint if needed.
+ */
+export declare function getSwapBalances(ordinalsAddress: string): Promise<SwapBalance[]>;
+/**
+ * Checks the swap balance for a specific token address associated with the current ordinals wallet address by making an API call to the swap backend.
+ *
+ * @param tokenAddress The address of the token to check the swap balance for.
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the swap balance for the specified token address and current ordinals wallet address. The balance is returned as a string from the API and converted to bigint in this function.
+ */
+export declare function getSwapBalance(tokenAddress: string): Promise<bigint>;
+export interface PairReserves {
+    reserveA: bigint;
+    reserveB: bigint;
+    total_supply: bigint;
+}
+/**
+ * Checks the reserves of a specific token pair by making an API call to the swap backend.
+ *
+ * @param pairAddress The address of the token pair to check the reserves for.
+ * @returns {Promise<PairReserves>} A promise that resolves to an object containing the reserves of token A, token B, and the total supply of liquidity tokens for the specified pair address. The reserves and total supply are returned as strings from the API and converted to bigint in this function.
+ */
+export declare function getPairReserves(pairAddress: string): Promise<PairReserves>;
+/**
+ * Resolves a referral ID to the referrer's swap pubkey and their return-rate
+ * (rebate) in basis points. Returns undefined fields if the referral cannot be
+ * resolved, so a bad or expired referral degrades to a normal swap rather than
+ * failing the order.
+ *
+ * @param currentPubkey The swap pubkey of the user performing the swap. Used to reject self-referrals.
+ * @param refId The referral identifier to resolve.
+ * @returns The referrer's swap pubkey and return-rate bps, or undefined fields when the referral is invalid.
+ */
+export declare function tryGetSwapReferrerInfo(currentPubkey: string, refId: string): Promise<{
+    referrerPubkey: string | undefined;
+    refReturnBps: bigint | undefined;
+}>;
+/**
+ * Requests the estimated miner fee for a specific swap operation type by making an API call to the swap backend.
+ *
+ * @param type The type of swap operation to estimate the miner fee for. Valid values are 'add_liquidity', 'remove_liquidity', 'swap', 'withdraw', or 'unwrap'.
+ * @returns {Promise<bigint>} A promise that resolves to a bigint representing the estimated miner fee for the specified swap operation type. The fee is returned as a string from the API and converted to bigint in this function.
+ */
+export declare function requestMinerFee(type: 'add_liquidity' | 'remove_liquidity' | 'swap' | 'withdraw' | 'unwrap'): Promise<bigint>;
+export interface TokenInfo {
+    token_address: string;
+    symbol: string;
+    decimals: number;
+}
+/**
+ * Fetches every token tradable on the swap, ordered by symbol, by making an API call to the swap backend. LP tokens are excluded by the backend.
+ *
+ * This does not require a connected wallet or a smart wallet, so it can be used to populate a token picker before the user connects.
+ *
+ * @returns {Promise<TokenInfo[]>} A promise that resolves to an array of TokenInfo objects, each containing the token address, symbol, and decimals.
+ */
+export declare function listTokens(): Promise<TokenInfo[]>;
+export type ListPairsOrderBy = 'price_asc' | 'price_desc' | 'price_change_24h_asc' | 'price_change_24h_desc' | 'price_change_7d_asc' | 'price_change_7d_desc' | 'volume_24h_asc' | 'volume_24h_desc' | 'volume_7d_asc' | 'volume_7d_desc' | 'tvl_asc' | 'tvl_desc' | 'apr_asc' | 'apr_desc';
+export interface ListPairsRequest {
+    order_by?: ListPairsOrderBy;
+    page?: number;
+    count?: number;
+}
+export interface PairInfo {
+    pair_address: string;
+    pair_name: string;
+    token_a_addr: string;
+    token_a_symbol: string;
+    token_b_addr: string;
+    token_b_symbol: string;
+    price: number;
+    price_change_24h: number;
+    price_change_7d: number;
+    volume_24h: bigint;
+    volume_7d: bigint;
+    lp_fee_tier: number;
+    tvl: bigint;
+    apr: number;
+}
+export interface ListPairsResponse {
+    page: number;
+    count: number;
+    total: number;
+    data: PairInfo[];
+}
+/**
+ * Fetches a paginated, sortable listing of every swap pair and its market data by making an API call to the swap backend.
+ *
+ * This does not require a connected wallet or a smart wallet, so it can be used to populate a market table or pair selector before the user connects.
+ *
+ * @param params (Optional) An object containing the sort order (defaults to 'tvl_desc'), the page to fetch (defaults to 1), and the number of pairs per page (defaults to 20, max 100).
+ * @returns {Promise<ListPairsResponse>} A promise that resolves to an object containing the current page, page size, total number of pairs, and an array of PairInfo objects. Each pair includes both token addresses and symbols, price, 24h/7d price change, 24h/7d volume, LP fee tier, TVL, and APR. The volumes and TVL are returned as strings from the API and converted to bigint in this function.
+ */
+export declare function listPairs(params?: ListPairsRequest): Promise<ListPairsResponse>;
+export interface GetPairVolumeRequest {
+    pair_address: string;
+    days: number;
+}
+export interface GetPairVolumeResponse {
+    pair_address: string;
+    token_a_address: string;
+    token_a_symbol: string;
+    token_b_address: string;
+    token_b_symbol: string;
+    period_days: number;
+    total_volume_wbtc: string;
+    total_trades: number;
+    start_time: string;
+    end_time: string;
+}
+/**
+ * Fetches the trading volume and number of trades for a specific token pair over a given number of days by making an API call to the swap backend.
+ *
+ * @param params An object containing the pair address and the number of days to look back for volume data.
+ * @returns {Promise<GetPairVolumeResponse>} A promise that resolves to an object containing the pair address, token addresses and symbols, period in days, total volume in WBTC, total number of trades, and the start and end time of the period. The total volume is returned as a string from the API and can be converted to bigint if needed.
+ */
+export declare function getPairVolumeOverDays(params: GetPairVolumeRequest): Promise<GetPairVolumeResponse>;
+export interface GetKlinesRequest {
+    pair_address: string;
+    interval: '1m' | '5m' | '15m' | '1h' | '4h' | '1d';
+    limit: number;
+    startTime: number | null;
+    endTime: number | null;
+}
+export interface Kline {
+    open_time: number;
+    close_time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume_wbtc: string;
+    trades: number;
+}
+export interface GetKlinesResponse {
+    pair_address: string;
+    token_a_address: string;
+    token_a_symbol: string;
+    token_b_address: string;
+    token_b_symbol: string;
+    interval: string;
+    klines: Kline[];
+}
+/**
+ * Fetches the historical price and volume data (klines) for a specific token pair and time interval by making an API call to the swap backend.
+ *
+ * @param params An object containing the pair address, desired time interval for the klines, limit on the number of klines to fetch (max 1000), and optional start and end timestamps to filter the klines.
+ * @returns {Promise<GetKlinesResponse>} A promise that resolves to an object containing the pair address, token addresses and symbols, interval, and an array of kline data. Each kline includes open time, close time, open price, high price, low price, close price, volume in WBTC, and number of trades. The volume is returned as a string from the API and can be converted to bigint if needed.
+ */
+export declare function getKlines(params: GetKlinesRequest): Promise<GetKlinesResponse>;
+export interface GetActivityOfPairRequest {
+    pair_address: string;
+    limit: number;
+    offset: number;
+}
+export interface PairActivityEntry {
+    id: string;
+    type: 'add_liq' | 'remove_liq' | 'swap1' | 'swap2';
+    timestamp: number;
+    block_height: number;
+    success: boolean;
+    user_address: string;
+    user_pubkey: string;
+    amount1: string;
+    amount2: string;
+    liquidity: string | null;
+    token_1: string;
+    token_2: string;
+}
+export interface GetActivityOfPairResponse {
+    pair_address: string;
+    token_a: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    token_b: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    activities: PairActivityEntry[];
+}
+/**
+ * Fetches the recent swap activities for a specific token pair by making an API call to the swap backend.
+ *
+ * @param params An object containing the pair address, limit on the number of activities to fetch (max 200), and offset for pagination.
+ * @returns {Promise<GetActivityOfPairResponse>} A promise that resolves to an object containing the pair address, token details, and an array of recent activities for that pair. Each activity includes details such as the type of activity (add/remove liquidity or swap), timestamp, block height, success status, user address and pubkey, amounts involved, and token addresses.
+ */
+export declare function getActivityOfPair(params: GetActivityOfPairRequest): Promise<GetActivityOfPairResponse>;
+interface GetWalletActivitiesRequest {
+    pubkey: string;
+    pairAddress: string;
+}
+export interface WalletActivityEntry {
+    id: string;
+    type: 'add_liq' | 'remove_liq' | 'swap1' | 'swap2' | 'deposit' | 'unwrap' | 'withdraw' | 'withdraw (lp)';
+    timestamp: number | null;
+    block_height: number | null;
+    success: boolean;
+    token_1: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    token_2?: {
+        address: string;
+        symbol: string;
+        decimals: number;
+    };
+    amount1: string;
+    amount2?: string;
+    txid: string | null;
+    liquidity?: string | null;
+    target_address?: string | null;
+    target_pkscript?: string | null;
+}
+export interface GetWalletActivitiesResponse {
+    pubkey: string;
+    btc_address: string;
+    pair_address: string;
+    activities: WalletActivityEntry[];
+}
+/**
+ * Fetches the swap activities associated with a specific wallet public key and pair address by making an API call to the swap backend.
+ *
+ * @param params An object containing the wallet public key and pair address to query activities for.
+ * @returns {Promise<GetWalletActivitiesResponse>} A promise that resolves to an object containing the wallet public key, associated Bitcoin address, pair address, and a list of swap activities (deposits, swaps, liquidity changes, withdrawals) related to that wallet and pair.
+ */
+export declare function getWalletActivities(params: GetWalletActivitiesRequest): Promise<GetWalletActivitiesResponse>;
+/**
+ * Fetches the number of decimals for a given token address by making an API call to the swap backend.
+ *
+ * @param tokenAddress The address of the token to fetch the decimals for.
+ * @returns {Promise<number>} A promise that resolves to a number representing the decimals for the specified token address.
+ */
+export declare function getTokenDecimals(tokenAddress: string): Promise<number>;
+export interface ReclaimInscription {
+    inscriptionId: string;
+    amount: bigint;
+}
+export declare function sumReclaimAmounts(reclaims?: ReclaimInscription[] | null): bigint;
+/**
+ * Creates and broadcasts a deposit order for swapping BRC-20 tokens by performing necessary checks, generating signatures, and making API calls to the swap backend. The function handles both BRC-2.0 and base BRC-20 token balances, checks allowances, and prepares the required data for the deposit order.
+ *
+ * @param tokenAddress The address of the BRC-20 token to deposit.
+ * @param tokenAmount The amount of the BRC-20 token to deposit, represented as a bigint in 18 decimals format.
+ * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
+ * @param createAllowanceIfNeeded A boolean flag indicating whether to create an allowance for the BRC-2.0 token transfer if the current allowance is insufficient. Defaults to true.
+ * @param reclaimInscriptions Optional transfer inscriptions to reclaim toward the base-layer sufficiency check, each with `inscriptionId` and `amount` (bigint, 18 decimals).
+ *
+ * @returns {Promise<string[]>} A promise that resolves to an array of transaction IDs (txids) for the transactions involved in the deposit order, including the commit transaction, reveal transaction, and send-to-opreturn transaction.
+ */
+export declare function createAndBroadcastDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[]): Promise<string[]>;
+/**
+ * Checks the miner fees required for creating a deposit order for swapping BRC-20 tokens, including the fees for minting inscriptions for allowance and deposit, as well as the fees for sending those inscriptions to OP_RETURN. The function also checks if the user has sufficient balance and allowance for the specified token amount.
+ *
+ * @param tokenAddress The address of the BRC-20 token to deposit.
+ * @param tokenAmount The amount of the BRC-20 token to deposit, represented as a bigint in 18 decimals format.
+ * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
+ * @param createAllowanceIfNeeded A boolean flag indicating whether to include the fees for creating an allowance inscription if the current allowance is insufficient. Defaults to true.
+ *
+ * @returns A promise that resolves to an object containing the following properties:
+ * - needs_approval: A boolean indicating whether an allowance inscription needs to be created.
+ * - allowance_fees_total: The total miner fees for creating and sending the allowance inscription to OP_RETURN (0 if no allowance inscription is needed).
+ * - base_deposit_fees_total: The total miner fees for creating and sending the base deposit inscription to OP_RETURN (0 if no base deposit inscription is needed).
+ * - deposit_fees_total: The total miner fees for creating and sending the deposit inscription to OP_RETURN.
+ * - fee_rate: The fee rate used for the calculations, in sats/vbyte.
+ */
+export declare function getMinerFeesOfDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[]): Promise<{
+    needs_approval: boolean;
+    allowance_fees_total: number;
+    base_deposit_fees_total: number;
+    deposit_fees_total: number;
+    fee_rate: number;
+}>;
+/**
+ * Creates and broadcasts a wrap order for swapping BRC-20 tokens. The function first retrieves the necessary swap information and connected wallet details, then generates the required signatures for the deposit. It constructs the call data for the wrap order and mints an inscription with the call data as its content. Finally, it sends the inscription to OP_RETURN and broadcasts the transaction to the network.
+ *
+ * @param btcAmount The amount of BTC to wrap, represented as a bigint in satoshis.
+ * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
+ *
+ * @returns A promise that resolves to an array of transaction IDs related to the wrap order, including the commit transaction, reveal transaction, and the transaction for sending the inscription to OP_RETURN.
+ */
+export declare function createAndBroadcastWrapOrder(btcAmount: bigint, feeRate: number): Promise<string[]>;
+/**
+ * Checks the miner fees required for creating a wrap order for swapping BRC-20 tokens. The function retrieves the necessary swap information and connected wallet details, then generates the required signatures for the deposit. It constructs the call data for the wrap order and estimates the gas fees for minting an inscription with the call data as its content and sending it to OP_RETURN.
+ *
+ * @param btcAmount The amount of BTC to wrap, represented as a bigint in satoshis.
+ * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
+ *
+ * @returns A promise that resolves to an object containing the total miner fees for creating and sending the inscriptions related to the wrap order, as well as the fee rate used for the calculations.
+ */
+export declare function getMinerFeesOfWrapOrder(btcAmount: bigint, feeRate: number): Promise<{
+    total_fee: number;
+    fee_rate: number;
+}>;
+/**
+ * Calculates the expected amounts of tokens A and B to be added to the liquidity pool, as well as the amount of liquidity tokens that will be minted, based on the input parameters for adding liquidity. The function retrieves the necessary swap information and uses a proxy to check the current balances and reserves of the tokens in the liquidity pool. It also requests the miner fee for adding liquidity and then calls the addLiquidityRequest function to get the expected results.
+ *
+ * @param token1Addr The address of the first token to be added to the liquidity pool.
+ * @param token2Addr The address of the second token to be added to the liquidity pool.
+ * @param amt1 The amount of the first token to be added to the liquidity pool, represented as a bigint.
+ * @param amt2 The amount of the second token to be added to the liquidity pool, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the expected amounts of tokens A and B to be added to the liquidity pool, as well as the amount of liquidity tokens that will be minted, represented as bigints.
+ */
+export declare function getAddLiquidityResult(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint): Promise<{
+    amountA: bigint;
+    amountB: bigint;
+    liquidity: bigint;
+}>;
+interface AddLiquidityOrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends an add liquidity order for a decentralized exchange. The function retrieves the necessary swap information and connected wallet details, calculates the minimum amounts based on the provided slippage, and generates the required signatures for the order. It then constructs the order parameters and sends the add liquidity order to the backend API.
+ *
+ * @param token1Addr The address of the first token to be added to the liquidity pool.
+ * @param token2Addr The address of the second token to be added to the liquidity pool.
+ * @param amt1 The amount of the first token to be added to the liquidity pool, represented as a bigint.
+ * @param amt2 The amount of the second token to be added to the liquidity pool, represented as a bigint.
+ * @param slippageBPS The slippage in basis points to be applied when calculating the minimum amounts for the liquidity order.
+ *
+ * @returns A promise that resolves to an object indicating the success of the add liquidity order request.
+ */
+export declare function prepareAndSendAddLiquidityOrder(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint): Promise<AddLiquidityOrderResponse>;
+/**
+ * Calculates the expected amounts of tokens A and B to be removed from the liquidity pool, as well as the amount of liquidity tokens that will be burned, based on the input parameters for removing liquidity. The function retrieves the necessary swap information and uses a proxy to check the current balances and reserves of the tokens in the liquidity pool. It also requests the miner fee for removing liquidity and then calls the removeLiquidityRequest function to get the expected results.
+ *
+ * @param token1Addr The address of the first token to be removed from the liquidity pool.
+ * @param token2Addr The address of the second token to be removed from the liquidity pool.
+ * @param lpAmt The amount of liquidity tokens to be burned, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the expected amounts of tokens A and B to be removed from the liquidity pool, as well as the amount of liquidity tokens that will be burned, represented as bigints.
+ */
+export declare function getRemoveLiquidityResult(token1Addr: string, token2Addr: string, lpAmt: bigint): Promise<{
+    amountA: bigint;
+    amountB: bigint;
+    liquidity: bigint;
+}>;
+interface RemoveLiquidityOrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends a remove liquidity order for a decentralized exchange. The function retrieves the necessary swap information and connected wallet details, calculates the minimum amounts based on the provided slippage, and generates the required signatures for the order. It then constructs the order parameters and sends the remove liquidity order to the backend API.
+ *
+ * @param token1Addr The address of the first token to be removed from the liquidity pool.
+ * @param token2Addr The address of the second token to be removed from the liquidity pool.
+ * @param lpAmt The amount of liquidity tokens to be burned, represented as a bigint.
+ * @param amt1 The expected amount of the first token to be removed from the liquidity pool, represented as a bigint.
+ * @param amt2 The expected amount of the second token to be removed from the liquidity pool, represented as a bigint.
+ * @param slippageBPS The slippage in basis points to be applied when calculating the minimum amounts for the liquidity order.
+ *
+ * @returns A promise that resolves to an object indicating the success of the remove liquidity order request.
+ */
+export declare function prepareAndSendRemoveLiquidityOrder(token1Addr: string, token2Addr: string, lpAmt: bigint, amt1: bigint, amt2: bigint, slippageBPS: bigint): Promise<RemoveLiquidityOrderResponse>;
+/**
+ * Calculates the expected output amount, quoted price, and price impact for a token swap operation. The function retrieves the necessary swap information and connected wallet details, then uses a proxy to check the current balances and reserves of the tokens in the liquidity pool. It also requests the miner fee for swapping and gets the fee basis points for the tokens involved in the swap. Finally, it calls the swapRequest function to get the expected results based on the input parameters.
+ *
+ * @param tokenInAddr The address of the token being swapped from.
+ * @param tokenOutAddr The address of the token being swapped to.
+ * @param amtIn The amount of the input token to be swapped, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the expected output amount of the token being swapped to, the quoted price for the swap, the price impact in basis points, and the fee breakdown (see `SwapFees` — `amount_out` is net of the pool fee only, with the rest charged on top).
+ */
+export declare function getSwapResult(tokenInAddr: string, tokenOutAddr: string, amtIn: bigint): Promise<{
+    amount_out: bigint;
+    quoted_price: number;
+    price_impact_bps: bigint;
+    fees: SwapFees;
+}>;
+interface SwapOrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends a swap order for BiS Swap. The function retrieves the necessary swap information and connected wallet details, calculates the minimum output amount based on the provided slippage, and generates the required signatures for the order. It then constructs the order parameters and sends the swap order to the backend API.
+ *
+ * @param token1Addr The address of the token being swapped from.
+ * @param token2Addr The address of the token being swapped to.
+ * @param amt1 The amount of the input token to be swapped, represented as a bigint.
+ * @param amt2 The amount of the output token expected from the swap, represented as a bigint.
+ * @param slippageBPS The slippage in basis points to be applied when calculating the minimum amounts for the liquidity order.
+ * @param referrerId An optional referral ID. When provided and valid, a share of the swap fee is credited to the referrer; an invalid referral is ignored and the swap proceeds normally.
+ *
+ * @returns A promise that resolves to an object indicating the success of the swap order request.
+ */
+export declare function prepareAndSendSwapOrder(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string): Promise<SwapOrderResponse>;
+/**
+ * Calculates the expected input amount, quoted price, and price impact for a token swap operation using the swap2 algorithm. The function retrieves the necessary swap information and connected wallet details, then uses a proxy to check the current balances and reserves of the tokens in the liquidity pool. It also requests the miner fee for swapping and gets the fee basis points for the tokens involved in the swap. Finally, it calls the swap2Request function to get the expected results based on the input parameters.
+ *
+ * @param tokenInAddr The address of the token being swapped from.
+ * @param tokenOutAddr The address of the token being swapped to.
+ * @param amtOut The amount of the output token expected from the swap, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the expected input amount of the token being swapped from, the quoted price for the swap, the price impact in basis points, and the fee breakdown (see `SwapFees` — `amount_in` covers the pool fee only, with the rest charged on top).
+ */
+export declare function getSwap2Result(tokenInAddr: string, tokenOutAddr: string, amtOut: bigint): Promise<{
+    amount_in: bigint;
+    quoted_price: number;
+    price_impact_bps: bigint;
+    fees: SwapFees;
+}>;
+interface Swap2OrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends a swap order using the swap2 algorithm for BiS Swap. The function retrieves the necessary swap information and connected wallet details, calculates the maximum input amount based on the provided slippage, and generates the required signatures for the order. It then constructs the order parameters and sends the swap order to the backend API.
+ *
+ * @param token1Addr The address of the token being swapped from.
+ * @param token2Addr The address of the token being swapped to.
+ * @param amt1 The amount of the input token to be swapped, represented as a bigint.
+ * @param amt2 The amount of the output token expected from the swap, represented as a bigint.
+ * @param slippageBPS The slippage in basis points to be applied when calculating the maximum input amount for the swap order.
+ * @param referrerId An optional referral ID. When provided and valid, a share of the swap fee is credited to the referrer; an invalid referral is ignored and the swap proceeds normally.
+ *
+ * @returns A promise that resolves to an object indicating the success of the swap order request.
+ */
+export declare function prepareAndSendSwap2Order(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string): Promise<Swap2OrderResponse>;
+/**
+ * Prepares and sends a withdraw request to transfer tokens from the smart wallet to an ordinal wallet. The function retrieves the necessary swap information and connected wallet details, converts the target ordinal Bitcoin address to an Ethereum-compatible address, and generates the required signatures for the withdraw request. It then constructs the withdraw request parameters and sends the request to the backend API.
+ *
+ * @param tokenAddress The address of the token to be withdrawn.
+ * @param ordinalAddress The Bitcoin address of the target ordinal wallet.
+ * @param amt The amount of the token to be withdrawn, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the amount withdrawn, represented as a bigint.
+ */
+export declare function getWithdrawToOrdinalWalletResult(tokenAddress: string, ordinalAddress: string, amt: bigint): Promise<{
+    amt: bigint;
+}>;
+/**
+ * Prepares and sends a withdraw request to transfer tokens from the smart wallet to the user's own ordinal wallet. The function retrieves the necessary swap information and connected wallet details, obtains the user's ordinal wallet address, converts it to an Ethereum-compatible address, and generates the required signatures for the withdraw request. It then constructs the withdraw request parameters and sends the request to the backend API.
+ *
+ * @param tokenAddress The address of the token to be withdrawn.
+ * @param amt The amount of the token to be withdrawn, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the amount withdrawn, represented as a bigint.
+ */
+export declare function getWithdrawToSelfOrdinalWalletResult(tokenAddress: string, amt: bigint): Promise<{
+    amt: bigint;
+}>;
+export interface WithdrawOrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends a withdraw order to transfer tokens from the smart wallet to an ordinal wallet. The function retrieves the necessary swap information and connected wallet details, converts the target ordinal Bitcoin address to an Ethereum-compatible address, and generates the required signatures for the withdraw order. It then constructs the withdraw order parameters and sends the order to the backend API.
+ *
+ * @param tokenAddr The address of the token to be withdrawn.
+ * @param ordinalAddr The Bitcoin address of the target ordinal wallet.
+ * @param amt The amount of the token to be withdrawn, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object indicating the success of the withdraw order request.
+ */
+export declare function prepareAndSendWithdrawOrderToOrdinalWallet(tokenAddr: string, ordinalAddr: string, amt: bigint): Promise<WithdrawOrderResponse>;
+/**
+ * Prepares and sends a withdraw order to transfer tokens from the smart wallet to the user's own ordinal wallet. The function retrieves the necessary swap information and connected wallet details, obtains the user's ordinal wallet address, converts it to an Ethereum-compatible address, and generates the required signatures for the withdraw order. It then constructs the withdraw order parameters and sends the order to the backend API.
+ *
+ * @param tokenAddr The address of the token to be withdrawn.
+ * @param amt The amount of the token to be withdrawn, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object indicating the success of the withdraw order request.
+ */
+export declare function prepareAndSendWithdrawOrderToSelfOrdinalWallet(tokenAddr: string, amt: bigint): Promise<WithdrawOrderResponse>;
+/**
+ * Prepares and sends an unwrap order to transfer WBTC from the smart wallet back to Bitcoin. The function retrieves the necessary swap information and connected wallet details, generates the required signatures for the unwrap order, and constructs the unwrap order parameters before sending the order to the backend API.
+ *
+ * @param pkscript The pkscript of the target Bitcoin address where the unwrapped WBTC will be sent.
+ * @param amt The amount of WBTC to be unwrapped, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object containing the amount unwrapped, represented as a bigint.
+ */
+export declare function getUnwrapResult(pkscript: string, amt: bigint): Promise<{
+    amt: bigint;
+}>;
+interface UnwrapOrderResponse {
+    success: boolean;
+}
+/**
+ * Prepares and sends an unwrap order to transfer WBTC from the smart wallet back to Bitcoin. The function retrieves the necessary swap information and connected wallet details, generates the required signatures for the unwrap order, and constructs the unwrap order parameters before sending the order to the backend API.
+ *
+ * @param pkscript The pkscript of the target Bitcoin address where the unwrapped WBTC will be sent.
+ * @param amt The amount of WBTC to be unwrapped, represented as a bigint.
+ *
+ * @returns A promise that resolves to an object indicating the success of the unwrap order request.
+ */
+export declare function prepareAndSendUnwrapOrder(pkscript: string, amt: bigint): Promise<UnwrapOrderResponse>;
+export {};