@bestinslot/wallet-kit 0.7.0

package/dist/types/lib/swap-reporting.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Classifies a swap as a buy or sell relative to WBTC (the quote asset): you
+ * "buy" the other token when you spend WBTC, and "sell" it when you receive WBTC.
+ *
+ * For a swap activity entry (`type` 'swap1' | 'swap2'), `token_1` is the input
+ * and `token_2` the output, so `swapSide(entry.token_1, entry.token_2, wbtc)`
+ * gives its side. (Don't apply it to liquidity entries, where token_1/token_2 are
+ * the pair's two tokens, not a direction.)
+ *
+ * @param tokenInAddress The input token address (what's spent).
+ * @param tokenOutAddress The output token address (what's received).
+ * @param wbtcAddress The WBTC token address.
+ * @returns 'buy' or 'sell', or null for a non-WBTC (token-to-token) swap.
+ */
+export declare function swapSide(tokenInAddress: string, tokenOutAddress: string, wbtcAddress: string): 'buy' | 'sell' | null;
+/**
+ * Converts a sat amount to BTC. Throws on values beyond JS safe-integer
+ * precision (~90,000 BTC) rather than silently rounding.
+ *
+ * @param sats The amount in satoshis.
+ * @returns The amount in BTC.
+ */
+export declare function satsToBtc(sats: bigint): number;
+/**
+ * Converts a sat amount to USD using a caller-supplied BTC/USD rate, keeping the
+ * library oracle-free.
+ *
+ * @param sats The amount in satoshis.
+ * @param btcUsd The BTC→USD price.
+ * @returns The amount in USD.
+ */
+export declare function satsToUsd(sats: bigint, btcUsd: number): number;
+/**
+ * The fees a swap quote costs, broken out so a UI can show the real total instead
+ * of guessing at it. Only the pool fee is baked into the quoted amounts; the rest
+ * is charged on top of them — see each field, and the swap guide for a worked
+ * example of totalling them up.
+ */
+export interface SwapFees {
+    /**
+     * The constant-product pool fee, in bps. This one is already reflected in the
+     * quote: it is taken on the way through the pool, so the quoted amount is net
+     * of it and it must not be subtracted again.
+     */
+    pool_fee_bps: bigint;
+    /** The protocol fee charged on the input leg, in bps. */
+    token_in_fee_bps: bigint;
+    /**
+     * `token_in_fee_bps` applied to the input amount, in input-token units. Debited
+     * on top of the input, so the swap really costs `amount_in + token_in_fee`.
+     */
+    token_in_fee: bigint;
+    /** The protocol fee charged on the output leg, in bps. */
+    token_out_fee_bps: bigint;
+    /**
+     * `token_out_fee_bps` applied to the output amount, in output-token units.
+     * Deducted from the output, so you really receive `amount_out - token_out_fee`.
+     */
+    token_out_fee: bigint;
+    /**
+     * The miner fee, in WBTC sats. A flat amount rather than a rate — don't fold it
+     * into a bps figure. Debited in WBTC separately from both legs.
+     */
+    miner_fee_sats: bigint;
+}
+/**
+ * Assembles the fee breakdown for a swap quote from the inputs the quote path
+ * already has. The bps → amount arithmetic mirrors `swapRequest`/`swap2Request`
+ * exactly, floor division included, so the reported amounts are the ones that
+ * will actually be debited rather than a rounded-off approximation.
+ *
+ * @param amountIn The input leg amount, whether quoted or requested.
+ * @param amountOut The output leg amount, whether quoted or requested.
+ * @param token1FeeBps The protocol fee on the input leg, in bps.
+ * @param token2FeeBps The protocol fee on the output leg, in bps.
+ * @param btcFee The miner fee in WBTC sats.
+ *
+ * @returns The fee breakdown for the quote.
+ */
+export declare function buildSwapFees(amountIn: bigint, amountOut: bigint, token1FeeBps: bigint, token2FeeBps: bigint, btcFee: bigint): SwapFees;

package/dist/types/lib/uniswap_ops.d.ts

@@ -0,0 +1,238 @@
+export interface UniswapInfoProxy {
+    balanceOf: (pubkey: string, token_address: string) => Promise<bigint | null>;
+    reservesOf: (pair_address: string) => Promise<{
+        reserveA: bigint;
+        reserveB: bigint;
+        total_supply: bigint;
+    } | null>;
+}
+/**
+ * Saves the Bis Swap information, including the WBTC address and factory address. The saveInfo function takes two string parameters, wbtcAddr and factory, which represent the WBTC token address and the Bis Swap factory address, respectively. It assigns these values to the module-level variables wbtcAddress and factoryAddr, allowing other functions in the module to access this information when needed for operations such as calculating pair addresses or fetching reserves. This function is essential for initializing the Bis Swap-related operations with the correct contract addresses.
+ *
+ * @param wbtcAddr The WBTC token address as a string. This address is used in Bis Swap operations to identify the WBTC token when calculating pair addresses, fetching reserves, or performing swaps involving WBTC.
+ * @param factory The Bis Swap factory address as a string. This address is used to calculate pair addresses and to interact with the Bis Swap protocol for operations such as fetching reserves or performing swaps. By saving this information, the module can ensure that all Bis Swap-related functions have access to the necessary contract addresses for their operations.
+ */
+export declare function saveInfo(wbtcAddr: string, factory: string): void;
+/**
+ * Calculates the pair address for two given token addresses using the Uniswap V2 formula. The calculatePairAddress function takes two token addresses as input and computes the corresponding pair address based on the Uniswap V2 deterministic address generation method. It first ensures that the token addresses are ordered correctly (the lower address is tokenA and the higher address is tokenB) to maintain consistency. Then, it uses the factory address, the keccak256 hash of the packed token addresses, and a fixed init code hash to compute the final pair address. This function is essential for interacting with the Uniswap protocol, as it allows you to determine the correct pair address for any two tokens, which is necessary for fetching reserves, performing swaps, or adding liquidity.
+ *
+ * @param tokenAAddr The address of the first token as a string. This should be a valid Ethereum address in hexadecimal format. The function will ensure that this address is ordered correctly with respect to the second token address to maintain consistency in pair address generation.
+ * @param tokenBAddr The address of the second token as a string. This should also be a valid Ethereum address in hexadecimal format. The function will compare this address with the first token address to determine the correct ordering for pair address generation, ensuring that the lower address is always tokenA and the higher address is tokenB.
+ *
+ * @returns The calculated pair address as a string in hexadecimal format. This address is derived using the Uniswap V2 formula, which involves hashing the factory address, the ordered token addresses, and a fixed init code hash. The resulting pair address can be used to interact with the Uniswap protocol for operations such as fetching reserves, performing swaps, or adding liquidity for the given token pair.
+ */
+export declare function calculatePairAddress(tokenAAddr: string, tokenBAddr: string): string;
+/**
+ * Handles the add liquidity request for a Uniswap-like decentralized exchange. The addLiquidityRequest function takes various parameters including the user's public key, token addresses, amounts, minimum amounts, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it calculates the actual amounts of tokens to be added to the liquidity pool based on the desired amounts and the current reserves. If the signature is valid and the amounts are sufficient, it updates the internal state of balances and reserves accordingly. Finally, it returns a success response with the actual amounts added and liquidity tokens minted, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the add liquidity request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully adding liquidity.
+ * @param token1Addr The address of the first token in the liquidity pair as a hexadecimal string. This address is used to identify the token being added to the liquidity pool and to fetch its current balance and reserves. The function will also use this address to calculate the pair address and to update the user's balance after adding liquidity.
+ * @param token2Addr The address of the second token in the liquidity pair as a hexadecimal string. Similar to token1Addr, this address is used to identify the second token being added to the liquidity pool, to fetch its current balance and reserves, and to calculate the pair address for updating the user's balance after adding liquidity.
+ * @param amt1 The desired amount of the first token to be added to the liquidity pool as a bigint. This amount is used in the calculation of how much of each token will actually be added based on the current reserves and the desired amounts. The function will ensure that this amount meets the minimum requirements and will update the user's balance accordingly after adding liquidity.
+ * @param amt2 The desired amount of the second token to be added to the liquidity pool as a bigint. Similar to amt1, this amount is used in the calculation of how much of each token will actually be added based on the current reserves and the desired amounts. The function will ensure that this amount meets the minimum requirements and will update the user's balance accordingly after adding liquidity.
+ * @param minamt1 The minimum acceptable amount of the first token to be added to the liquidity pool as a bigint. This parameter is used to ensure that the user receives at least this amount of the first token when adding liquidity, even if the actual amount calculated based on the desired amounts and current reserves is higher. If the calculated amount of the first token is less than this minimum, the function will throw an error and not proceed with adding liquidity.
+ * @param minamt2 The minimum acceptable amount of the second token to be added to the liquidity pool as a bigint. Similar to minamt1, this parameter is used to ensure that the user receives at least this amount of the second token when adding liquidity. If the calculated amount of the second token is less than this minimum, the function will throw an error and not proceed with adding liquidity.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the add liquidity request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with adding liquidity, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each add liquidity request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param token1FeeBps The fee for the first token in basis points (bps) as a bigint. This fee is applied to the amount of the first token being added to the liquidity pool and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after adding liquidity.
+ * @param token2FeeBps The fee for the second token in basis points (bps) as a bigint. Similar to token1FeeBps, this fee is applied to the amount of the second token being added to the liquidity pool and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after adding liquidity.
+ * @param btcFee The fee in BTC as a bigint that is applied to the add liquidity request. This fee is deducted from the user's balance in WBTC and is used to cover the costs associated with processing the request. The function will ensure that this fee is properly accounted for in the user's balance updates after adding liquidity.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the actual amounts of tokens added to the liquidity pool and the amount of liquidity tokens minted. If there is an error, the object contains an error message describing the issue that occurred during the add liquidity process.
+ */
+export declare function addLiquidityRequest(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+token1Addr: string, // hex string token1 address
+token2Addr: string, // hex string token2 address
+amt1: bigint, // bigint token1 amount
+amt2: bigint, // bigint token2 amount
+minamt1: bigint, // bigint min token1 amount
+minamt2: bigint, // bigint min token2 amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+token1FeeBps: bigint, // bigint token1 fee in bps
+token2FeeBps: bigint, // bigint token2 fee in bps
+btcFee: bigint): Promise<{
+    success: boolean;
+    data?: {
+        amountA: bigint;
+        amountB: bigint;
+        liquidity: bigint;
+    };
+    error_message?: string;
+}>;
+/**
+ * Handles the remove liquidity request for BiS Swap. The removeLiquidityRequest function takes various parameters including the user's public key, token addresses, liquidity amount, minimum amounts, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient liquidity balance to burn. If the signature is valid and the balance is sufficient, it calculates the actual amounts of tokens to be removed from the liquidity pool based on the liquidity amount and current reserves. Finally, it updates the internal state of balances and reserves accordingly and returns a success response with the actual amounts removed, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the remove liquidity request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully removing liquidity.
+ * @param token1Addr The address of the first token in the liquidity pair as a hexadecimal string. This address is used to identify the token being removed from the liquidity pool and to fetch its current balance and reserves. The function will also use this address to calculate the pair address and to update the user's balance after removing liquidity.
+ * @param token2Addr The address of the second token in the liquidity pair as a hexadecimal string. Similar to token1Addr, this address is used to identify the second token being removed from the liquidity pool, to fetch its current balance and reserves, and to calculate the pair address for updating the user's balance after removing liquidity.
+ * @param liquidity The amount of liquidity tokens to be burned as a bigint. This amount is used in the calculation of how much of each underlying token will be removed from the liquidity pool based on the current reserves and total supply. The function will ensure that this amount meets the minimum requirements and will update the user's balance accordingly after removing liquidity.
+ * @param minamt1 The minimum acceptable amount of the first token to be removed from the liquidity pool as a bigint. This parameter is used to ensure that the user receives at least this amount of the first token when removing liquidity, even if the actual amount calculated based on the liquidity burned and current reserves is higher. If the calculated amount of the first token is less than this minimum, the function will throw an error and not proceed with removing liquidity.
+ * @param minamt2 The minimum acceptable amount of the second token to be removed from the liquidity pool as a bigint. Similar to minamt1, this parameter is used to ensure that the user receives at least this amount of the second token when removing liquidity. If the calculated amount of the second token is less than this minimum, the function will throw an error and not proceed with removing liquidity.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the remove liquidity request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with removing liquidity, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each remove liquidity request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param token1FeeBps The fee for the first token in basis points (bps) as a bigint. This fee is applied to the amount of the first token being removed from the liquidity pool and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after removing liquidity.
+ * @param token2FeeBps The fee for the second token in basis points (bps) as a bigint. Similar to token1FeeBps, this fee is applied to the amount of the second token being removed from the liquidity pool and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after removing liquidity.
+ * @param btcFee The fee in BTC as a bigint that is applied to the remove liquidity request. This fee is deducted from the user's balance in WBTC and is used to cover the costs associated with processing the request. The function will ensure that this fee is properly accounted for in the user's balance updates after removing liquidity.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the actual amounts of tokens removed from the liquidity pool and the amount of liquidity tokens burned. If there is an error, the object contains an error message describing the issue that occurred during the remove liquidity process.
+ */
+export declare function removeLiquidityRequest(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+token1Addr: string, // hex string token1 address
+token2Addr: string, // hex string token2 address
+liquidity: bigint, // bigint lp token amount
+minamt1: bigint, // bigint min token1 amount
+minamt2: bigint, // bigint min token2 amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+token1FeeBps: bigint, // bigint token1 fee in bps
+token2FeeBps: bigint, // bigint token2 fee in bps
+btcFee: bigint): Promise<{
+    success: boolean;
+    data: {
+        amountA: bigint;
+        amountB: bigint;
+        liquidity: bigint;
+    };
+    error_message?: undefined;
+} | {
+    success: boolean;
+    error_message: any;
+    data?: undefined;
+}>;
+/**
+ * Handles the swap request for BiS Swap. The swapRequest function takes various parameters including the user's public key, token addresses, input amount, minimum output amount, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the input token. If the signature is valid and the balance is sufficient, it calculates the output amount based on the current reserves and the input amount. Finally, it updates the internal state of balances and reserves accordingly and returns a success response with the output amount and price impact, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the swap request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully executing the swap.
+ * @param token1Addr The address of the input token as a hexadecimal string. This address is used to identify the token being swapped from and to fetch its current balance and reserves. The function will also use this address to calculate the pair address and to update the user's balance after executing the swap.
+ * @param token2Addr The address of the output token as a hexadecimal string. Similar to token1Addr, this address is used to identify the token being swapped to, to fetch its current balance and reserves, and to calculate the pair address for updating the user's balance after executing the swap.
+ * @param inAmt The amount of the input token to be swapped as a bigint. This amount is used in the calculation of how much of the output token will be received based on the current reserves and the swap formula. The function will ensure that this amount meets the minimum requirements and will update the user's balance accordingly after executing the swap.
+ * @param minOutAmt The minimum acceptable amount of the output token to be received from the swap as a bigint. This parameter is used to ensure that the user receives at least this amount of the output token when executing the swap, even if the actual amount calculated based on the input amount and current reserves is higher. If the calculated amount of the output token is less than this minimum, the function will throw an error and not proceed with executing the swap.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the swap request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with executing the swap, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each swap request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param token1FeeBps The fee for the input token in basis points (bps) as a bigint. This fee is applied to the amount of the input token being swapped and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after executing the swap.
+ * @param token2FeeBps The fee for the output token in basis points (bps) as a bigint. This fee is applied to the amount of the output token being received and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after executing the swap.
+ * @param btcFee The miner fee as a bigint, denominated in WBTC sats. It is a flat amount, not a rate: the function debits exactly this much WBTC from the user's balance on top of the swap, so it is not reflected in the amounts returned.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the actual amount of the output token received from the swap and the price impact of the swap. If there is an error, the object contains an error message describing the issue that occurred during the swap process.
+ */
+export declare function swapRequest(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+token1Addr: string, // hex string token in address
+token2Addr: string, // hex string token out address
+inAmt: bigint, // bigint token in amount
+minOutAmt: bigint, // bigint min token out amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+token1FeeBps: bigint, // bigint token1 fee in bps
+token2FeeBps: bigint, // bigint token2 fee in bps
+btcFee: bigint): Promise<{
+    success: boolean;
+    amounts: bigint[];
+    price_impact_bps: bigint;
+    error_message?: undefined;
+} | {
+    success: boolean;
+    error_message: any;
+    amounts?: undefined;
+    price_impact_bps?: undefined;
+}>;
+/**
+ * Handles the swap request with specified output amount for BiS Swap. The swap2Request function takes various parameters including the user's public key, token addresses, maximum input amount, desired output amount, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the input token and that the maximum input amount is sufficient to receive the desired output amount based on the current reserves. If the signature is valid and the balance is sufficient, it calculates the actual input amount required to receive the desired output amount based on the current reserves and the swap formula. Finally, it updates the internal state of balances and reserves accordingly and returns a success response with the actual input amount used and price impact, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the swap request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully executing the swap.
+ * @param token1Addr The address of the input token as a hexadecimal string. This address is used to identify the token being swapped from and to fetch its current balance and reserves. The function will also use this address to calculate the pair address and to update the user's balance after executing the swap.
+ * @param token2Addr The address of the output token as a hexadecimal string. Similar to token1Addr, this address is used to identify the token being swapped to, to fetch its current balance and reserves, and to calculate the pair address for updating the user's balance after executing the swap.
+ * @param maxInAmt The maximum amount of the input token that the user is willing to swap as a bigint. This amount is used to ensure that the user does not spend more than this amount of the input token when trying to receive the desired output amount. The function will check that the actual input amount required to receive the desired output amount does not exceed this maximum, and if it does, the function will throw an error and not proceed with executing the swap.
+ * @param outAmt The desired amount of the output token to be received from the swap as a bigint. This amount is used in the calculation of how much of the input token will be required based on the current reserves and the swap formula. The function will ensure that this amount meets the minimum requirements and will update the user's balance accordingly after executing the swap.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the swap request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with executing the swap, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each swap request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param token1FeeBps The fee for the input token in basis points (bps) as a bigint. This fee is applied to the amount of the input token being swapped and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after executing the swap.
+ * @param token2FeeBps The fee for the output token in basis points (bps) as a bigint. This fee is applied to the amount of the output token being received and is deducted from the user's balance. The function will calculate the fee based on this value and ensure that it is properly accounted for in the user's balance updates after executing the swap.
+ * @param btcFee The miner fee as a bigint, denominated in WBTC sats. It is a flat amount, not a rate: the function debits exactly this much WBTC from the user's balance on top of the swap, so it is not reflected in the amounts returned.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the actual amount of the input token used for the swap and the price impact of the swap. If there is an error, the object contains an error message describing the issue that occurred during the swap process.
+ */
+export declare function swap2Request(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+token1Addr: string, // hex string token in address
+token2Addr: string, // hex string token out address
+maxInAmt: bigint, // bigint max token in amount
+outAmt: bigint, // bigint token out amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+token1FeeBps: bigint, // bigint token1 fee in bps
+token2FeeBps: bigint, // bigint token2 fee in bps
+btcFee: bigint): Promise<{
+    success: boolean;
+    amounts: bigint[];
+    price_impact_bps: bigint;
+    error_message?: undefined;
+} | {
+    success: boolean;
+    error_message: any;
+    amounts?: undefined;
+    price_impact_bps?: undefined;
+}>;
+/**
+ * Handles the withdraw request for BiS Swap. The withdrawRequest function takes various parameters including the user's public key, token address, target address, amount to withdraw, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the specified token to withdraw. If the signature is valid and the balance is sufficient, it updates the internal state of balances accordingly and returns a success response with the withdrawn amount, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the withdraw request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully executing the withdraw.
+ * @param tokenAddr The address of the token to be withdrawn as a hexadecimal string. This address is used to identify the token being withdrawn and to fetch its current balance. The function will also use this address to update the user's balance after successfully executing the withdraw.
+ * @param targetAddr The target address where the withdrawn tokens will be sent as a hexadecimal string. This address is used to specify the destination of the withdrawn tokens. The function will ensure that this address is valid and will include it in the message for BLS signature verification to ensure the authenticity of the request.
+ * @param amt The amount of the token to be withdrawn as a bigint. This amount is used to check if the user has sufficient balance of the specified token to withdraw. The function will also include this amount in the message for BLS signature verification and will update the user's balance accordingly after successfully executing the withdraw.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the withdraw request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with executing the withdraw, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each withdraw request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param btcFee The miner fee as a bigint, denominated in WBTC sats. It is a flat amount, not a rate: the function debits exactly this much WBTC from the user's balance on top of the withdraw, so it is not reflected in the amounts returned.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the amount of the token that was withdrawn. If there is an error, the object contains an error message describing the issue that occurred during the withdraw process.
+ */
+export declare function withdrawRequest(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+tokenAddr: string, // hex string token address
+targetAddr: string, // hex string target address
+amt: bigint, // bigint token amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+btcFee: bigint): Promise<{
+    success: boolean;
+    data: {
+        amt: bigint;
+    };
+    error_message?: undefined;
+} | {
+    success: boolean;
+    error_message: any;
+    data?: undefined;
+}>;
+/**
+ * Handles the unwrap request for BiS Swap. The unwrapRequest function takes various parameters including the user's public key, pkscript, amount to unwrap, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the wrapped token (WBTC) to unwrap. If the signature is valid and the balance is sufficient, it updates the internal state of balances accordingly and returns a success response with the unwrapped amount, or an error message if any step fails.
+ *
+ * @param proxy An instance of UniswapInfoProxy that provides methods to fetch balances and reserves. This proxy is used to interact with the underlying data source for token balances and liquidity pool reserves, allowing the function to perform necessary calculations and updates based on the current state of the Uniswap-like exchange.
+ * @param pubkey The user's public key as a hexadecimal string. This public key is used to identify the user making the unwrap request and to verify the BLS signature for authentication. The function will use this public key to fetch the user's current balances and to update them after successfully executing the unwrap.
+ * @param pkscript The pkscript as a hexadecimal string that specifies the script for the unwrapped Bitcoin. This pkscript is used in the construction of the message for BLS signature verification to ensure the authenticity of the request. The function will also use this pkscript to determine the destination of the unwrapped Bitcoin and to include it in the message for signature verification.
+ * @param amt The amount of the wrapped token (WBTC) to be unwrapped as a bigint. This amount is used to check if the user has sufficient balance of WBTC to unwrap. The function will also include this amount in the message for BLS signature verification and will update the user's balance accordingly after successfully executing the unwrap.
+ * @param blsSignature The BLS signature as a hexadecimal string that is used to authenticate the unwrap request. This signature is generated by the user using their private key and is verified against the public key and the message constructed from the request parameters. The function will check the validity of this signature before proceeding with executing the unwrap, ensuring that only authorized requests are processed.
+ * @param nonce A unique nonce as a bigint that is used in the construction of the message for BLS signature verification. This nonce helps to prevent replay attacks by ensuring that each unwrap request has a unique message, even if all other parameters are the same. The function will include this nonce in the message that is hashed and verified against the BLS signature to ensure the authenticity of the request.
+ * @param btcFee The miner fee as a bigint, denominated in WBTC sats. It is a flat amount, not a rate: the function debits exactly this much WBTC from the user's balance on top of the unwrap, so it is not reflected in the amounts returned.
+ *
+ * @returns A promise that resolves to an object indicating the success of the operation. If successful, the object contains the amount of the wrapped token that was unwrapped. If there is an error, the object contains an error message describing the issue that occurred during the unwrap process.
+ */
+export declare function unwrapRequest(proxy: UniswapInfoProxy, pubkey: string, // hex string bls pubkey
+pkscript: string, // hex string pkscript
+amt: bigint, // bigint token amount
+blsSignature: string, // hex string BLS signature
+nonce: bigint, // unique request nonce
+btcFee: bigint): Promise<{
+    success: boolean;
+    data: {
+        amt: bigint;
+    };
+    error_message?: undefined;
+} | {
+    success: boolean;
+    error_message: any;
+    data?: undefined;
+}>;

package/dist/types/lib/web3.d.ts

@@ -0,0 +1,7 @@
+import { default as Web3 } from 'web3';
+/**
+ * Provides a singleton instance of the Web3 library. The getWeb3 function checks if a Web3 instance already exists and returns it if available. If not, it creates a new instance of Web3 and stores it in the web3 variable for future use. This ensures that only one instance of Web3 is created throughout the application, allowing for efficient resource usage and consistent access to the Web3 functionality.
+ *
+ * @returns {Web3} A singleton instance of the Web3 library, which can be used to interact with the Ethereum blockchain. This instance is created on demand and reused for subsequent calls to getWeb3, ensuring that only one instance exists throughout the application.
+ */
+export declare function getWeb3(): Web3;

package/dist/types/node.d.ts

@@ -0,0 +1,9 @@
+export * as wallet from './api/wallet.node';
+export * as swap from './api/swap';
+export * as brc20 from './api/brc20';
+export * as mint from './api/mint';
+export * as balances from './api/balances';
+export * from './api/helpers';
+export type { PaymentOpts } from './types/common';
+export * as bitcoinjs from 'bitcoinjs-lib';
+export * as Buff from '@cmdcode/buff-utils';

package/dist/types/provider/api.d.ts

@@ -0,0 +1,97 @@
+import { BISWallet, BISWalletPurpose } from '../types/common';
+/**
+ * Defines the structure of the response returned by the sign function in the BISProvider interface. The SignResponse interface includes a transaction ID (txId) as a string and the signed PSBT (Partially Signed Bitcoin Transaction) in hexadecimal format as a string. This structure allows developers to easily access the results of the signing process, including the transaction ID for tracking purposes and the signed PSBT for further processing or broadcasting to the network.
+ *
+ * txId: A string representing the transaction ID (txid) of the signed transaction. This value is useful for tracking the transaction on the blockchain after it has been signed and potentially broadcasted.
+ * signedPsbtHex: A string containing the signed PSBT in hexadecimal format. This value can be used for further processing, such as broadcasting the transaction to the network or extracting information from the signed PSBT.
+ */
+export interface SignResponse {
+    txId: string;
+    signedTxHex: string;
+}
+/**
+ * Defines the structure of a signature response that includes both the signature and the address associated with the signature. The SignatureWithAddress interface includes a signature as a string and an address as a string. This structure allows developers to easily access both the signature and the corresponding address when signing messages or transactions using the BISProvider interface.
+ *
+ * signature: A string representing the signature generated by the provider when signing a message or transaction. This value can be used for verification or other purposes where the signature is required.
+ * address: A string representing the address associated with the signature. This value can be used to identify which wallet or address was used for signing, which can be important for verification or tracking purposes.
+ */
+export interface SignatureWithAddress {
+    signature: string;
+    address: string;
+}
+/**
+ * Defines the type for the sign function used in the BISProvider interface. The SignFunction type specifies the parameters and return type for a function that signs a PSBT (Partially Signed Bitcoin Transaction) with specific handling for inscriptions. The function takes an unsigned PSBT in hexadecimal format, payment and ordinal addresses, indexes for inputs to sign, and optional parameters for tweaking and excluding certain indexes from signing. It returns a promise that resolves to an object containing the signed PSBT as a hexadecimal string and optionally the transaction ID (txid) if the transaction was broadcasted. This type definition ensures that any implementation of the sign function adheres to the expected structure and behavior when used within the BISProvider interface.
+ *
+ * @param unsignedPsbtHex The unsigned PSBT to be signed, provided in hexadecimal format as a string. This PSBT will be processed and sent to the provider for signing.
+ * @param paymentAddr The payment address associated with the PSBT, provided as a string. This address is used in the signing process to identify the relevant inputs and outputs in the PSBT.
+ * @param ordAddr The ordinal address associated with the PSBT, provided as a string. This address is used in the signing process to identify the relevant inputs and outputs in the PSBT, particularly for inscriptions.
+ * @param ordAddrIdxes An array of indexes for the ordinal address inputs that should be signed. This array specifies which inputs in the PSBT are associated with the ordinal address and should be included in the signing process.
+ * @param useTweakSignerIdxes An array of indexes for inputs that should use a tweaked signer during the signing process. This allows for specific inputs to be signed with additional security measures, if supported by the provider.
+ * @param noSignIdxes An array of indexes for inputs that should be excluded from signing. This allows for specific inputs to be left unsigned, which can be useful in certain scenarios where not all inputs should be signed.
+ *
+ * @returns A promise that resolves to an object containing the signed PSBT as a hexadecimal string and optionally the transaction ID (txid) if the transaction was broadcasted. This allows developers to use the signed PSBT for further processing or to track the transaction on the blockchain. If there is an error in signing the PSBT, the promise will be rejected with a descriptive error message.
+ */
+export type SignFunction = (unsignedPsbtHex: string, paymentAddr: string, ordAddr: string, ordAddrIdxes: number[], useTweakSignerIdxes?: number[], noSignIdxes?: number[]) => Promise<SignResponse>;
+/**
+ * Defines the interface for a BISProvider, which includes methods for retrieving wallets, signing messages, and sending Bitcoin. The BISProvider interface specifies the structure that any wallet provider must implement to be compatible with the BIS Wallet Kit. This includes methods for getting the list of wallets, signing messages in both standard and deterministic ways, sending Bitcoin transactions, and signing PSBTs (Partially Signed Bitcoin Transactions). By adhering to this interface, different wallet providers can be integrated into the BIS Wallet Kit while ensuring a consistent API for developers using the kit.
+ */
+export interface BISProvider {
+    /**
+     * Checks the current network of the provider. The checkNetwork method is an optional function that, when implemented, allows the provider to verify and update its network status. This can be useful for providers that need to ensure they are connected to the correct Bitcoin network (e.g., mainnet, testnet) before performing operations such as signing messages or sending transactions. If the provider implements this method, it should return a promise that resolves when the network check is complete, allowing developers to handle any necessary updates or error handling related to network changes.
+     *
+     * @returns A promise that resolves when the network check is complete. This allows developers to handle any necessary updates or error handling related to network changes. If the provider does not implement this method, it can be safely ignored, and the provider will be assumed to be on the correct network by default.
+     */
+    checkNetwork?: () => Promise<void>;
+    /**
+     * Retrieves the wallets associated with the provider. The getWallets method returns a promise that resolves to an array of BISWallet objects, each representing a wallet associated with the provider. This method allows developers to access the wallets available through the provider, enabling them to perform operations such as signing messages or sending transactions using those wallets.
+     *
+     * @returns A promise that resolves to an array of BISWallet objects, each representing a wallet associated with the provider. This allows developers to access the wallets available through the provider and perform various operations with them. If there is an error in retrieving the wallets, the promise will be rejected with an appropriate error message.
+     */
+    getWallets: () => Promise<BISWallet[]>;
+    /**
+     * Signs a message using the provider. The signMessage method takes a message as a string and returns a promise that resolves to the signature of the message as a hexadecimal string. This method allows developers to sign messages using the wallets associated with the provider, enabling functionalities such as authentication or transaction signing. If there is an error in signing the message, the promise will be rejected with an appropriate error message.
+     *
+     * @param message The message to be signed as a string. This message will be sent to the provider for signing, and the resulting signature will be returned as a hexadecimal string.
+     * @returns A promise that resolves to the signature of the message as a hexadecimal string. This allows developers to use the signature for verification or other purposes. If there is an error in signing the message, the promise will be rejected with a descriptive error message.
+     */
+    signMessage: (message: string, walletType: BISWalletPurpose, walletAddress: string) => Promise<string>;
+    /**
+     * Signs a message using the provider with a deterministic signing method. The signMessageDeterministic method takes a message as a string and returns a promise that resolves to an object containing the signature of the message as a hexadecimal string and the address of the wallet used for signing. This method allows developers to sign messages in a deterministic way, which can be useful for certain applications where the same message should produce the same signature. If there is an error in signing the message, the promise will be rejected with an appropriate error message.
+     *
+     * @param message The message to be signed as a string. This message will be sent to the provider for signing using a deterministic method, and the resulting signature and signing address will be returned.
+     * @returns A promise that resolves to an object containing the signature of the message as a hexadecimal string and the address of the wallet used for signing. This allows developers to use the signature for verification or other purposes, along with the address of the signing wallet. If there is an error in signing the message, the promise will be rejected with a descriptive error message.
+     */
+    signMessageDeterministic: (message: string) => Promise<SignatureWithAddress>;
+    /**
+     * Sends Bitcoin using the provider. The sendBTC method takes the amount of Bitcoin to send in satoshis and the address to which the Bitcoin should be sent, and returns a promise that resolves to the transaction ID (txid) of the sent transaction as a string. This method allows developers to send Bitcoin transactions using the wallets associated with the provider. If there is an error in sending the Bitcoin, such as if the sending request fails, the promise will be rejected with an appropriate error message.
+     *
+     * @param amountSats The amount of Bitcoin to send in satoshis. This value will be sent to the provider to initiate the transaction.
+     * @param toAddress The address to which the Bitcoin should be sent. This value will be sent to the provider along with the amount to initiate the transaction.
+     * @param feeRate Optional fee rate in satoshis per virtual byte (sat/vB). Extension providers estimate the fee themselves and ignore this value; the local (WIF) provider builds the transaction in-process and requires it.
+     * @returns A promise that resolves to the transaction ID (txid) of the sent transaction as a string. This allows developers to track the transaction on the blockchain. If there is an error in sending the Bitcoin, the promise will be rejected with a descriptive error message.
+     */
+    sendBTC: (amountSats: number, toAddress: string, feeRate?: number) => Promise<string>;
+    /**
+     * Signs a PSBT (Partially Signed Bitcoin Transaction) with specific handling for inscriptions using the provider. The signPSBT method takes an unsigned PSBT in hexadecimal format, a boolean indicating whether to broadcast the transaction after signing, and an array of input objects that specify which inputs in the PSBT should be signed along with any specific options for signing those inputs. It returns a promise that resolves to the signed PSBT as a hexadecimal string if broadcast is false, or the transaction ID (txid) of the broadcasted transaction if broadcast is true. This method allows developers to sign PSBTs with various input configurations and optionally broadcast them to the network. If there is an error in signing the PSBT or broadcasting it, the promise will be rejected with an appropriate error message.
+     *
+     * @param psbtBase64 The unsigned PSBT to be signed, provided in Base64 format as a string. This PSBT will be processed and sent to the provider for signing.
+     * @param broadcast A boolean indicating whether the signed PSBT should be broadcasted to the network after signing. If true, the function will attempt to push the signed PSBT to the network using the provider's method for broadcasting transactions.
+     * @param inputsToSign An array of input objects that specify which inputs in the PSBT should be signed, along with any specific options for signing those inputs. Each input object can include the address associated with the input, the indexes of the inputs to sign, and whether to use a tweaked signer for those inputs. This information is used to construct the signing request sent to the provider, allowing for flexible signing of PSBTs with various input configurations.
+     *
+     * @returns A promise that resolves to the signed PSBT as a hexadecimal string if broadcast is false, or the transaction ID (txid) of the broadcasted transaction if broadcast is true. This allows developers to use the signed PSBT for further processing or to track the transaction on the blockchain. If there is an error in signing the PSBT or broadcasting it, the promise will be rejected with a descriptive error message.
+     */
+    signPSBT: (psbtBase64: string, broadcast: boolean, inputsToSign: any[], message?: string) => Promise<string>;
+    /**
+     * Signs a PSBT (Partially Signed Bitcoin Transaction) with specific handling for inscriptions using the provider. The sign function takes an unsigned PSBT in hexadecimal format, payment and ordinal addresses, indexes for inputs to sign, and optional parameters for tweaking and excluding certain indexes from signing. It constructs the necessary data for signing the PSBT with the provider and returns the signed transaction details, including the transaction ID and signed transaction hex. If the provider is not found or if the signing process fails, the function throws an error with an appropriate message.
+     *
+     * @param unsignedPsbtHex The unsigned PSBT to be signed, provided in hexadecimal format as a string. This PSBT will be processed and sent to the provider for signing.
+     * @param paymentAddr The payment address associated with the PSBT, provided as a string. This address is used in the signing process to identify the relevant inputs and outputs in the PSBT.
+     * @param ordAddr The ordinal address associated with the PSBT, provided as a string. This address is used in the signing process to identify the relevant inputs and outputs in the PSBT, particularly for inscriptions.
+     * @param ordAddrIdxes An array of indexes for the ordinal address inputs that should be signed. This array specifies which inputs in the PSBT are associated with the ordinal address and should be included in the signing process.
+     * @param useTweakSignerIdxes An array of indexes for inputs that should use a tweaked signer during the signing process. This allows for specific inputs to be signed with additional security measures, if supported by the provider.
+     * @param noSignIdxes An array of indexes for inputs that should be excluded from signing. This allows for specific inputs to be left unsigned, which can be useful in certain scenarios where not all inputs should be signed.
+     *
+     * @returns A promise that resolves to an object containing the signed PSBT as a hexadecimal string and optionally the transaction ID (txid) if the transaction was broadcasted. This allows developers to use the signed PSBT for further processing or to track the transaction on the blockchain. If there is an error in signing the PSBT, the promise will be rejected with a descriptive error message.
+     */
+    sign: SignFunction;
+}

package/dist/types/provider/leather.d.ts

@@ -0,0 +1,2 @@
+import { BISProvider } from './api';
+export declare const LEATHER: BISProvider;

package/dist/types/provider/local.d.ts

@@ -0,0 +1,39 @@
+import { BISNetwork, BISWallet } from '../types/common';
+import { BISProvider } from './api';
+export type LocalWalletSource = 'unisat' | 'okx';
+export type LocalWalletType = 'p2wpkh' | 'p2tr';
+/**
+ * Saves the wallet information to memory. The saveWallet function takes the private key, network, wallet type, and source wallet as parameters and stores this information in the local wallet storage. It also updates the wallet's network setting and saves the wallet information using the saveWalletInfo function. This function is crucial for allowing users to store their wallet information locally and retrieve it later for signing messages or sending transactions. It includes error handling to ensure that only valid wallet types and sources are accepted, and it throws an error if there is an issue with saving the wallet information.
+ *
+ * @param privKeyWIF The private key of the wallet as a string in WIF format. This is the key that will be used for signing messages and transactions, and it should be kept secure and not shared with others.
+ * @param network The network associated with the wallet, such as 'mainnet' or 'testnet'. This information is important for ensuring that the wallet is used on the correct blockchain network and for deriving the correct addresses and transaction formats.
+ * @param walletType The type of wallet being saved, which can be either 'p2wpkh' (Pay-to-Witness-Public-Key-Hash) or 'p2tr' (Pay-to-Taproot). This determines the address format and signing method used by the wallet.
+ * @param sourceWallet The source of the wallet, which can be either 'unisat' or 'okx'. This information can be used to identify where the wallet information originated from and may be useful for debugging or analytics purposes.
+ *
+ * @returns A promise that resolves when the wallet information has been successfully saved to memory. If there is an error during the saving process, such as an invalid wallet type or source, the function will throw an error with a descriptive message.
+ */
+export declare function saveWallet(privKeyWIF: string, network: BISNetwork, walletType?: LocalWalletType, sourceWallet?: LocalWalletSource): Promise<BISWallet>;
+/**
+ * Generates a brand-new single-key Bitcoin wallet and connects it, returning
+ * the private key alongside the derived address. This is the counterpart to
+ * {@link saveWallet}: instead of importing an existing WIF, it produces a fresh
+ * random key (via secp256k1) for the given network and wallet type, then loads
+ * it through the same path so the returned address is guaranteed to re-import
+ * to the same key. It is intended for headless agents that need to create a
+ * fundable address on the fly.
+ *
+ * The wallet is a single (non-HD) key — there is no mnemonic or derivation
+ * path. The returned WIF is the ONLY secret; the caller is solely responsible
+ * for storing it. This function does not persist the key anywhere beyond the
+ * in-memory session used by the current process.
+ *
+ * @param network The network the wallet is for, e.g. 'mainnet' or 'testnet'. This determines the WIF version and address format.
+ * @param walletType The address type to derive, either 'p2wpkh' (default) or 'p2tr'.
+ * @param sourceWallet The source label recorded for the session, either 'unisat' (default) or 'okx'.
+ *
+ * @returns A promise resolving to the connected wallet ({ address, pubkey, purpose }) plus the generated `wif` private key. Throws if the wallet type or source is invalid.
+ */
+export declare function createWallet(network: BISNetwork, walletType?: LocalWalletType, sourceWallet?: LocalWalletSource): Promise<BISWallet & {
+    wif: string;
+}>;
+export declare const LOCAL: BISProvider;

package/dist/types/provider/okx.d.ts

@@ -0,0 +1,2 @@
+import { BISProvider } from './api';
+export declare const OKX: BISProvider;

package/dist/types/provider/unisat.d.ts

@@ -0,0 +1,2 @@
+import { BISProvider } from './api';
+export declare const UNISAT: BISProvider;

package/dist/types/provider/xverse.d.ts

@@ -0,0 +1,2 @@
+import { BISProvider } from './api';
+export declare const XVERSE: BISProvider;

package/dist/types/react.d.ts

@@ -0,0 +1,3 @@
+export { useNetwork } from './adapters/react/use-network';
+export { useWallet } from './adapters/react/use-wallet';
+export type { BISNetwork, BISSession, BISWallet, BISWalletProvider } from './types/common';

package/dist/types/types/common.d.ts

@@ -0,0 +1,33 @@
+export type ModalState = 'connect' | 'confirm_connection' | 'error';
+export type ModalTheme = 'light' | 'dark' | 'system';
+export type BISNetwork = 'mainnet' | 'testnet' | 'signet';
+export interface ConnectCallbacks {
+    onSelect: (session: BISSession) => void;
+    onError: (error: Error) => void;
+}
+export type BISWalletProvider = 'okx' | 'unisat' | 'xverse' | 'leather' | 'local';
+export type BISWalletPurpose = 'ordinals' | 'payment' | 'all';
+export interface BISSession {
+    provider: BISWalletProvider;
+    wallets: BISWallet[];
+    signature: string | null;
+}
+export interface BISWallet {
+    address: string;
+    pubkey: string | null;
+    purpose: BISWalletPurpose;
+}
+/**
+ * An optional extra payment output attached to a transaction (e.g. a service
+ * fee). When `paymentAmount` is greater than 0, the transaction includes an
+ * output sending that many sats to `paymentAddress`, funded by the connected
+ * wallet — this is a destination the funds go *to*, not an alternate funding
+ * source. A non-positive amount adds no output.
+ *
+ * @property paymentAddress - The destination address that receives the payment output.
+ * @property paymentAmount - The amount sent to `paymentAddress`, in sats. Must be greater than 0 to add the output.
+ */
+export interface PaymentOpts {
+    paymentAddress: string;
+    paymentAmount: number;
+}

package/dist/types/types/global.d.ts

@@ -0,0 +1,26 @@
+import { ListenFn, RequestFn } from '@leather-wallet/types';
+declare global {
+  interface Window {
+    // Providers
+    unisat?: UniSat
+    LeatherProvider?: {
+      request: RequestFn
+      listen: ListenFn
+    }
+    okxwallet?: any
+    XverseProviders?: any
+  }
+}
+
+interface UniSat {
+  requestAccounts: () => Promise<string[]>
+  getNetwork: () => Promise<'livenet' | 'testnet'>
+  switchNetwork: (network: string) => Promise<void>
+  signMessage: (message: string, type?: 'ecdsa' | 'bip322-simple') => Promise<string>
+  signPsbt: (psbt: any, options?: any) => Promise<string>
+  pushPsbt: (psbt: any) => Promise<string>
+  getPublicKey: () => Promise<string>
+  sendBitcoin: (toAddress: string, amountSats: number) => Promise<string>
+}
+
+export {}