@bestinslot/wallet-kit 0.7.0

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

@@ -0,0 +1,110 @@
+import { BISWalletPurpose, PaymentOpts } from '../types/common';
+/**
+ * Interface representing the result of an inscription and send to OP_RETURN operation, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. This interface is used to encapsulate the details of the deploy, call and deposit operations in the BRC2.0 programmable module.
+ *
+ * @property {string} commitTxId - The transaction ID of the commit transaction created during the inscription process.
+ * @property {string} revealTxId - The transaction ID of the reveal transaction created during the inscription process.
+ * @property {string} signedCommitTxHex - The hexadecimal representation of the signed commit transaction, which can be broadcasted to the network to initiate the inscription process.
+ * @property {string} signedRevealTxHex - The hexadecimal representation of the signed reveal transaction, which can be broadcasted to the network to complete the inscription process and transfer the BRC-20 tokens.
+ * @property {string} inscriptionId - The unique identifier of the inscription created during the minting process, which can be used to track and reference the specific inscription associated with the deposit or withdrawal operation.
+ * @property {number | null} postage - The amount of postage included in the minting transaction, specified in sats. This value may be null if no postage was included.
+ * @property {string} secret - A secret value used in the minting process, which may be required for certain operations or for tracking the transaction. This value is typically generated during the minting process and can be used for verification or reference purposes.
+ * @property {string} sendToOpReturnTxId - The transaction ID of the transaction created to send the BRC-20 tokens to the OP_RETURN output after the reveal transaction.
+ * @property {string} signedSendToOpReturnTxHex - The hexadecimal representation of the signed transaction created to send the BRC-20 tokens to the OP_RETURN output, which can be broadcasted to the network after the reveal transaction.
+ */
+export interface InscribeAndSendToOpReturn {
+    commitTxId: string;
+    revealTxId: string;
+    sendToOpReturnTxId: string;
+    signedCommitTxHex: string;
+    signedRevealTxHex: string;
+    signedSendToOpReturnTxHex: string;
+    inscriptionId: string;
+    postage: number | null;
+    secret: string;
+}
+/**
+ * Interface representing the result of an inscription and send to OP_RETURN operation, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. This interface is used to encapsulate the details of the withdrawal operations for BRC-20 tokens in the BRC2.0 programmable module.
+ *
+ * @property {string} commitTxId - The transaction ID of the commit transaction created during the inscription process.
+ * @property {string} revealTxId - The transaction ID of the reveal transaction created during the inscription process.
+ * @property {string} signedCommitTxHex - The hexadecimal representation of the signed commit transaction, which can be broadcasted to the network to initiate the inscription process.
+ * @property {string} signedRevealTxHex - The hexadecimal representation of the signed reveal transaction, which can be broadcasted to the network to complete the inscription process and transfer the BRC-20 tokens.
+ * @property {string} inscriptionId - The unique identifier of the inscription created during the minting process, which can be used to track and reference the specific inscription associated with the deposit or withdrawal operation.
+ * @property {number | null} postage - The amount of postage included in the minting transaction, specified in sats. This value may be null if no postage was included.
+ * @property {string} secret - A secret value used in the minting process, which may be required for certain operations or for tracking the transaction. This value is typically generated during the minting process and can be used for verification or reference purposes.
+ * @property {string} transferTxId - The transaction ID of the transfer transaction created to send the BRC-20 tokens to the target address after the reveal transaction.
+ * @property {string} signedTransferTxHex - The hexadecimal representation of the signed transfer transaction, which can be broadcasted to the network to transfer the BRC-20 tokens to the target address after the reveal transaction.
+ */
+export interface InscribeAndSendToAddress {
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number | null;
+    secret: string;
+    transferTxId: string;
+    signedTransferTxHex: string;
+}
+/**
+ * Calls a smart contract on BRC2.0 using either an Ordinals wallet or a Payment wallet, depending on the specified wallet type. This function abstracts the logic for calling a smart contract and allows for flexibility in choosing the wallet type for the transaction.
+ *
+ * @param contractAddress The address of the smart contract to call.
+ * @param calldataHex The calldata to send to the smart contract, encoded as a hexadecimal string.
+ * @param estimatedGas The estimated amount of gas required for the transaction.
+ * @param gasPerVbyte The gas cost per vbyte for the transaction.
+ * @param feeRate The fee rate to use for the transaction, in satoshis per vbyte.
+ * @param postage The amount of postage to include with the transaction, or null if no postage is needed.
+ * @param dryRun A boolean indicating whether to perform a dry run of the transaction (i.e., simulate the transaction without actually sending it).
+ * @param paymentOpts Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @param walletType The type of wallet to use for the transaction, either 'payment' or 'ordinals'. If not specified, defaults to 'payment'.
+ * @returns The result of the smart contract call, which may vary depending on the wallet type and the specifics of the transaction. The exact structure of the result will depend on the implementation of the callSmartContractFromOrdinalsWallet and callSmartContractFromPaymentWallet functions.
+ * @throws An error if an unsupported wallet type is specified or if there is an issue with the smart contract call.
+ */
+export declare function callSmartContract(contractAddress: string, calldataHex: string, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts, walletType?: BISWalletPurpose): Promise<InscribeAndSendToOpReturn>;
+/**
+ * Calls a smart contract function by encoding the function call with the provided ABI, function name, and parameters, and then invoking the callSmartContract function to execute the transaction. This function serves as a higher-level abstraction for calling smart contract functions, allowing developers to specify the function and parameters in a more intuitive way without needing to manually encode the calldata.
+ *
+ * @param contractAddress The address of the smart contract to call.
+ * @param abi The ABI (Application Binary Interface) of the smart contract, which defines the functions and their parameters for encoding the function call.
+ * @param funcName The name of the function to call on the smart contract, which should be defined in the provided ABI.
+ * @param params The parameters to pass to the smart contract function, which should be provided as an array and will be encoded according to the ABI specifications.
+ * @param estimatedGas The estimated amount of gas required for the transaction, which is used to calculate the transaction fee and ensure that sufficient funds are available for the transaction to be processed.
+ * @param gasPerVbyte The gas cost per vbyte for the transaction, which is used in conjunction with the estimated gas to calculate the total transaction fee.
+ * @param feeRate The fee rate to use for the transaction, in satoshis per vbyte, which is used to calculate the total transaction fee based on the estimated gas and gas cost per vbyte.
+ * @param postage The amount of postage to include with the transaction, or null if no postage is needed. Postage may be required for certain transactions to ensure that they are processed in a timely manner, especially during periods of high network congestion.
+ * @param dryRun A boolean indicating whether to perform a dry run of the transaction (i.e., simulate the transaction without actually sending it). This can be useful for testing and debugging purposes to ensure that the function call is correctly encoded and that the transaction would succeed before actually sending it to the network.
+ * @param paymentOpts Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @param walletType The type of wallet to use for the transaction, either 'payment' or 'ordinals'. This parameter allows the caller to specify which wallet implementation to use when executing the smart contract call, providing flexibility in how the transaction is processed based on the capabilities and requirements of the chosen wallet type.
+ * @returns The result of the smart contract call, which may vary depending on the wallet type and the specifics of the transaction. The exact structure of the result will depend on the implementation of the callSmartContractFromOrdinalsWallet and callSmartContractFromPaymentWallet functions, as well as the nature of the smart contract being called and the function being invoked.
+ * @throws An error if the ABI is not an object, if the function name is not a string, if the parameters are not an array, if an unsupported wallet type is specified, or if there is an issue with the smart contract call.
+ */
+export declare function callSmartContractAbi(contractAddress: string, abi: any, funcName: string, params: any, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts, walletType?: BISWalletPurpose): Promise<InscribeAndSendToOpReturn>;
+/**
+ * Deposits a BRC-20 token into the BRC2.0 programmable module by creating an inscription with the transfer operation and sending it to the OP_RETURN output. The function takes the token tick, amount, fee rate, and optional payment parameters, creates an inscription with the transfer operation, mints it, and then sends it to an OP_RETURN output with a specific format. It also allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param tick - The tick of the BRC-20 token to be deposited, represented as a string. This will be included in the inscription content to indicate which token is being transferred.
+ * @param amount - The amount of the BRC-20 token to be deposited, represented as a string. This will be included in the inscription content to indicate how many tokens are being transferred.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the deposit process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ *
+ * @returns An object containing details of the deposit process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function depositToBrc20Prog(tick: string, amount: string, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeAndSendToOpReturn>;
+/**
+ * Withdraws a BRC-20 token from the BRC2.0 programmable module by creating an inscription with the transfer operation and sending it to the OP_RETURN output. The function takes the token tick, amount, target address, fee rate, and optional payment parameters, creates an inscription with the transfer operation, mints it, and then sends it to an OP_RETURN output with a specific format. It also allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param tick - The tick of the BRC-20 token to be withdrawn, represented as a string. This will be included in the inscription content to indicate which token is being transferred.
+ * @param amount - The amount of the BRC-20 token to be withdrawn, represented as a string. This will be included in the inscription content to indicate how many tokens are being transferred.
+ * @param targetAddress - The Bitcoin address to which the withdrawn tokens should be sent. This will be included in the inscription content to indicate the recipient of the tokens.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the withdrawal process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ *
+ * @returns An object containing details of the withdrawal process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function withdrawFromBrc20Prog(tick: string, amount: string, targetAddress: string, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeAndSendToAddress>;

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

@@ -0,0 +1,3 @@
+export { getEvmAddressFromBitcoinAddress, getEvmAddressFromPkScript } from '../core/brc20';
+export { delegateInscription, jsonInscription, textInscription } from '../types/inscription';
+export { addressWalletInfo, opReturnWalletInfo } from '../types/wallet';

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

@@ -0,0 +1,57 @@
+import { PaymentOpts } from '../types/common';
+import { InscribeFees, InscribeMultipleResult, InscribeResult, InscriptionDetails } from '../types/inscription';
+export type { InscribeFees, InscribeMultipleResult, InscribeResult, InscriptionDetails };
+/**
+ * Inscribe an inscription with the given details, fee rate, postage, and payment options. This function performs the inscription process for a single inscription. The function returns the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription ID, postage, and secret used for the inscription.
+ *
+ * @param inscriptionDetails - An InscriptionDetails instance containing the details of the inscription to be minted.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the inscription transactions.
+ * @param postage - The postage amount in satoshis to be included in the inscription transactions, or null to use the default dust value.
+ * @param dryRun - A boolean indicating whether to perform a dry run of the inscription, which will return the transaction details without broadcasting them to the network.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @returns A promise that resolves to an object containing the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription IDs, postage, and secret used for the inscriptions.
+ */
+export declare function inscribe(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeResult>;
+/**
+ * Inscribe multiple inscriptions with the given details, fee rate, postage, and payment options. This function performs the inscription process for multiple inscriptions in a single batch, which can be more efficient than inscribing them individually. The function returns the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription IDs, postage, and secret used for the inscriptions.
+ *
+ * @param inscriptionDetailsArray - An array of InscriptionDetails instances containing the details of each inscription to be minted.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the inscription transactions.
+ * @param postage - The postage amount in satoshis to be included in the inscription transactions, or null to use the default dust value.
+ * @param dryRun - A boolean indicating whether to perform a dry run of the inscription, which will return the transaction details without broadcasting them to the network.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @returns A promise that resolves to an object containing the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription IDs, postage, and secret used for the inscriptions.
+ */
+export declare function inscribeMultiple(inscriptionDetailsArray: InscriptionDetails[], feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeMultipleResult>;
+/**
+ * Inscribe an inscription with a parent inscription by providing the details of the inscription, the parent inscription ID, fee rate, postage, and payment options. This function allows for creating a new inscription that is linked to an existing parent inscription, which can be useful for creating a series of related inscriptions or for building more complex inscription structures. The function returns the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription ID, postage, and secret used for the inscription.
+ *
+ * @param inscriptionDetails - An InscriptionDetails instance containing the details of the inscription to be minted.
+ * @param parentInscriptionId - The ID of the parent inscription to which the new inscription will be linked.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the inscription transactions.
+ * @param postage - The postage amount in satoshis to be included in the inscription transactions, or null to use the default dust value.
+ * @param dryRun - A boolean indicating whether to perform a dry run of the inscription, which will return the transaction details without broadcasting them to the network.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @returns A promise that resolves to an object containing the transaction IDs and signed transaction hex for both the commit and reveal transactions, as well as the inscription ID, postage, and secret used for the inscription.
+ * @throws Will throw an error if the inscription process fails for any reason, such as invalid input parameters, insufficient funds for fees, or issues with the parent inscription. The error message will provide details about the reason for the failure.
+ */
+export declare function inscribeWithParent(inscriptionDetails: InscriptionDetails, parentInscriptionId: string, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeResult>;
+/**
+ * Get the fee estimates for inscribing an inscription with the given details, fee rate, postage, and payment options. This function returns the estimated fees for both the commit and reveal transactions, as well as the total fee for the inscription process.
+ * @param inscriptionDetails - An InscriptionDetails instance containing the details of the inscription to be minted.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the inscription transactions.
+ * @param postage - The postage amount in satoshis to be included in the inscription transactions, or null to use the default dust value.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @returns A promise that resolves to an object containing the estimated fees for both the commit and reveal transactions, as well as the total fee for the inscription process.
+ */
+export declare function getInscribeFee(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, paymentOpts?: PaymentOpts): Promise<InscribeFees>;
+/**
+ * Get the fee estimates for inscribing multiple inscriptions with the given details, fee rate, postage, and payment options. This function returns the estimated fees for both the commit and reveal transactions, as well as the total fee for the inscription process for multiple inscriptions in a single batch.
+ *
+ * @param inscriptionDetailsArray - An array of InscriptionDetails instances containing the details of each inscription to be minted.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the inscription transactions.
+ * @param postage - The postage amount in satoshis to be included in the inscription transactions, or null to use the default dust value.
+ * @param paymentOpts - Optional extra payment output: when `paymentOpts.paymentAmount` is greater than 0, the transaction sends that many sats to `paymentOpts.paymentAddress` (funded by the connected wallet — e.g. a service fee). Omit, or pass a non-positive amount, for no extra payment.
+ * @returns A promise that resolves to an object containing the estimated fees for both the commit and reveal transactions, as well as the total fee for the inscription process for multiple inscriptions in a single batch.
+ */
+export declare function getInscribeMultipleFee(inscriptionDetailsArray: InscriptionDetails[], feeRate: number, postage: number | null, paymentOpts?: PaymentOpts): Promise<InscribeFees>;

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

@@ -0,0 +1,3 @@
+export { connect, disconnect, init } from '../core/connect-modal';
+export * from '../core/modal';
+export type { ConnectCallbacks, ModalTheme } from '../types/common';

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

@@ -0,0 +1,122 @@
+export { generateAndStoreSwapWallet as createSwapWallet, ensureSwapWallet, getAddLiquidityResult, getKlines, requestMinerFee as getMinerFee, getMinerFeesOfDepositOrder, getMinerFeesOfWrapOrder, getPairReserves, getPairVolumeOverDays, getRemoveLiquidityResult, getSwapBalance, getSwapBalances, getSwapResult as getSwapExactInputResult, getSwap2Result as getSwapExactOutputResult, getSwapInfo, getSwapStatus, getSwapWalletSecurityCode, getTokenDecimals, getUnwrapResult as getUnwrapBtcResult, importSwapWallet, listPairs, listTokens, tryGetSwapReferrerInfo, } from '../core/bis_swap';
+export type { EnsureSwapWalletResult, GetActivityOfPairResponse, GetKlinesRequest, GetKlinesResponse, GetPairVolumeRequest, GetPairVolumeResponse, GetSwapStatusResponse, GetWalletActivitiesResponse, ImportSwapWalletOptions, Kline, ListPairsOrderBy, ListPairsRequest, ListPairsResponse, PairActivityEntry, PairInfo, PairReserves, SwapBalance, SwapInfo, TokenInfo, WalletActivityEntry, } from '../core/bis_swap';
+export type { AllBalanceDetails } from '../core/helpers';
+export type { BISSwapWalletInfo } from '../core/store';
+export type { SwapFees } from '../lib/swap-reporting';
+export { satsToBtc, satsToUsd, swapSide } from '../lib/swap-reporting';
+export { calculatePairAddress as getPairAddress } from '../lib/uniswap_ops';
+/**
+ * Retrieves the wallet activities for a given public key and pair address.
+ *
+ * @param pubkey - The public key of the wallet for which to retrieve activities.
+ * @param pairAddress - The address of the pair for which to retrieve activities.
+ * @returns A promise that resolves to an array of wallet activities.
+ */
+export declare function getWalletActivities(pubkey: string, pairAddress: string): Promise<import('./swap').GetWalletActivitiesResponse>;
+/**
+ * Retrieves activities for a pair.
+ *
+ * @param pairAddress - The address of the pair for which to retrieve activities.
+ * @param limit - (Optional) The maximum number of activities to retrieve. Defaults to 20.
+ * @param offset - (Optional) The number of activities to skip before starting to collect the result set. Defaults to 0.
+ */
+export declare function getActivityOfPair(pairAddress: string, limit?: number, offset?: number): Promise<import('./swap').GetActivityOfPairResponse>;
+/**
+ * Adds liquidity to a specified token pair with the desired amounts and slippage tolerance.
+ *
+ * One of the two tokens must be WBTC; the order is rejected otherwise.
+ *
+ * @param token1Address - The address of the first token in the pair.
+ * @param token2Address - The address of the second token in the pair.
+ * @param amount1Desired - The desired amount of the first token to add. The enforced minimum is derived from this by applying `slippageBPS`.
+ * @param amount2Desired - The desired amount of the second token to add. The enforced minimum is derived from this by applying `slippageBPS`.
+ * @param slippageBPS - The slippage tolerance in basis points.
+ * @returns A promise that resolves to a boolean indicating the success of the operation.
+ */
+export declare function addLiquidity(token1Address: string, token2Address: string, amount1Desired: bigint, amount2Desired: bigint, slippageBPS: bigint): Promise<boolean>;
+/**
+ * Removes liquidity from a specified token pair, burning `liquidity` LP tokens and
+ * returning both underlying tokens.
+ *
+ * One of the two tokens must be WBTC; the order is rejected otherwise.
+ *
+ * @param token1Address - The address of the first token in the pair.
+ * @param token2Address - The address of the second token in the pair.
+ * @param liquidity - The amount of liquidity to remove.
+ * @param amount1 - The expected (quoted) amount of the first token to receive, as returned by `getRemoveLiquidityResult`. The enforced minimum is derived from this by applying `slippageBPS` — pass the quote, not an already slippage-adjusted value, to avoid double-applying slippage.
+ * @param amount2 - The expected (quoted) amount of the second token to receive, as returned by `getRemoveLiquidityResult`. The enforced minimum is derived from this by applying `slippageBPS` — pass the quote, not an already slippage-adjusted value, to avoid double-applying slippage.
+ * @param slippageBPS - The slippage tolerance in basis points.
+ * @returns A promise that resolves to a boolean indicating the success of the operation.
+ */
+export declare function removeLiquidity(token1Address: string, token2Address: string, liquidity: bigint, amount1: bigint, amount2: bigint, slippageBPS: bigint): Promise<boolean>;
+/**
+ * Executes an exact-input token swap: spends an exact `amountIn` of the input
+ * token and receives at least `amountOutMin` of the output token (Uniswap-style
+ * `swapExactTokensForTokens`).
+ *
+ * @param tokenInAddress - The address of the token to swap from.
+ * @param tokenOutAddress - The address of the token to swap to.
+ * @param amountIn - The exact amount of the input token to spend.
+ * @param amountOutMin - The expected (quoted) output amount. The enforced minimum is derived from this by applying `slippageBPS` — pass the quote, not an already slippage-adjusted value, to avoid double-applying slippage.
+ * @param slippageBPS - The slippage tolerance in basis points.
+ * @param referrerId - An optional referral ID. When 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 a boolean indicating the success of the swap operation.
+ */
+export declare function swapExactInput(tokenInAddress: string, tokenOutAddress: string, amountIn: bigint, amountOutMin: bigint, slippageBPS: bigint, referrerId?: string): Promise<boolean>;
+/**
+ * Executes an exact-output token swap: receives an exact `amountOut` of the
+ * output token and spends at most the input amount (the `amountIn` reference
+ * expanded by `slippageBPS`) — Uniswap-style `swapTokensForExactTokens`.
+ *
+ * @param tokenInAddress - The address of the token to swap from.
+ * @param tokenOutAddress - The address of the token to swap to.
+ * @param amountIn - The expected (quoted) input amount; slippage is applied to this to derive the maximum input spent.
+ * @param amountOut - The exact amount of the output token to receive.
+ * @param slippageBPS - The slippage tolerance in basis points.
+ * @param referrerId - An optional referral ID. When 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 a boolean indicating the success of the swap operation.
+ */
+export declare function swapExactOutput(tokenInAddress: string, tokenOutAddress: string, amountIn: bigint, amountOut: bigint, slippageBPS: bigint, referrerId?: string): Promise<boolean>;
+/**
+ * Redeems WBTC from the smart wallet back into BTC on Bitcoin L1, the reverse of
+ * `wrapBtc`. The BTC is paid out on L1 to `pkscript`, so that value must be an
+ * output script rather than a token or wallet address. Quote first with
+ * `getUnwrapBtcResult`, which takes the same destination.
+ *
+ * @param pkscript - The output script (hex) of the destination Bitcoin address the unwrapped BTC is paid to.
+ * @param amount - The amount of WBTC to unwrap, in sats.
+ * @returns A promise that resolves to a boolean indicating the success of the unwrap operation.
+ */
+export declare function unwrapBtc(pkscript: string, amount: bigint): Promise<boolean>;
+/**
+ * Deposits a specified amount of a token into the swap contract for a given pair.
+ *
+ * @param tokenAddress - The address of the token to deposit.
+ * @param amount - The amount of the token to deposit, specified as a bigint.
+ * @param feeRate - The fee rate for the deposit operation.
+ * @param createAllowanceIfNeeded - Whether to create an allowance if needed.
+ * @param reclaimInscriptions - Optional transfer inscriptions to reclaim toward the deposit, each with `inscriptionId` and `amount` (bigint, 18 decimals).
+ * @returns A promise that resolves to an array of transaction IDs related to the deposit operation.
+ */
+export declare function deposit(tokenAddress: string, amount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: {
+    inscriptionId: string;
+    amount: bigint;
+}[]): Promise<string[]>;
+/**
+ * Wraps BTC into the smart wallet as WBTC (the swap layer's BTC representation),
+ * the BTC equivalent of `deposit`.
+ *
+ * @param btcAmount - The amount of BTC to wrap, in sats, specified as a bigint.
+ * @param feeRate - The fee rate (sats/vByte) for the wrap transaction.
+ * @returns A promise that resolves to an array of transaction IDs related to the wrap operation.
+ */
+export declare function wrapBtc(btcAmount: bigint, feeRate: number): Promise<string[]>;
+/**
+ * Withdraws a specified amount of a token to a target address.
+ *
+ * @param tokenAddress - The address of the token to withdraw.
+ * @param amount - The amount of the token to withdraw, specified as a bigint.
+ * @param targetAddress - (Optional) The target address to which the tokens should be withdrawn. If not provided, the tokens will be withdrawn to the user's own Ordinals wallet.
+ * @returns A promise that resolves when the withdrawal process is complete.
+ */
+export declare function withdraw(tokenAddress: string, amount: bigint, targetAddress?: string): Promise<boolean>;

package/dist/types/api/wallet.browser.d.ts

@@ -0,0 +1,2 @@
+export { connect, disconnect } from '../core/connect-modal';
+export * from './wallet';

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

@@ -0,0 +1,6 @@
+import { WalletInfo } from '../types/wallet';
+export { getAllBalanceDetails, getCardinalBalance, getOrdinalsWallet, getPaymentWallet, getSession, sendBTC, sendInscription, setNetwork, signMessage, signMessageLocalVerify, signMessageLocalVerifyDeterministic, } from '../core/bis';
+export { getNetwork } from '../core/store-network';
+export type { WalletInfo };
+export type { BISNetwork, BISSession, BISWallet, BISWalletProvider, BISWalletPurpose, } from '../types/common';
+export type { SendInscriptionResult } from '../types/inscription';

package/dist/types/api/wallet.node.d.ts

@@ -0,0 +1,4 @@
+import { LocalWalletSource, LocalWalletType } from '../provider/local';
+export { createWallet, saveWallet as connectLocalWallet } from '../provider/local';
+export * from './wallet';
+export type { LocalWalletSource, LocalWalletType };

package/dist/types/browser.d.ts

@@ -0,0 +1,10 @@
+export * as wallet from './api/wallet.browser';
+export * as modal from './api/modal';
+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/components/Dev.vue.d.ts

@@ -0,0 +1,11 @@
+import { BISSession, BISWallet } from '../types/common';
+export interface DevUserSession {
+    data: BISSession;
+    wallet: {
+        ordinals: BISWallet;
+        payment: BISWallet;
+    };
+    balance: number;
+}
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/types/components/connect-modal-view.d.ts

@@ -0,0 +1,28 @@
+import { BISWalletProvider, ConnectCallbacks, ModalTheme } from '../types/common';
+/**
+ * Framework-free connect modal. Renders into the shadow-DOM root created by
+ * `core/modal.ts`. Replaces the former Vue `Modal.vue` so the published browser
+ * bundle no longer depends on Vue. The public method surface mirrors the old
+ * component's `defineExpose`, so `core/modal.ts` is a drop-in caller.
+ */
+export declare class BisModalView {
+    private root;
+    private theme;
+    private visible;
+    private state;
+    private errorMessage;
+    private provider;
+    private callbacks;
+    constructor(root: HTMLElement);
+    showConnect(callbacks: ConnectCallbacks): void;
+    showConnectConfirmation(provider: BISWalletProvider): void;
+    showError(message: string): void;
+    hide(): void;
+    setTheme(theme: ModalTheme): void;
+    private onClose;
+    private onRetry;
+    private onProviderSelect;
+    private themeClass;
+    private screenMarkup;
+    private render;
+}

package/dist/types/components/dev/BRC20.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/types/components/dev/Button.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLButtonElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLButtonElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/dev/Input.vue.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    defaultValue?: string | number;
+    modelValue?: string | number;
+    class?: HTMLAttributes['class'];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (payload: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLInputElement>;
+export default _default;

package/dist/types/components/dev/Label.vue.d.ts

@@ -0,0 +1,17 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLLabelElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLLabelElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/dev/Select.vue.d.ts

@@ -0,0 +1,17 @@
+type __VLS_Props = {
+    options: Option[];
+    class?: string;
+};
+interface Option {
+    value: string;
+    label: string;
+}
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLSelectElement>;
+export default _default;

package/dist/types/components/dev/SessionInfo.vue.d.ts

@@ -0,0 +1,6 @@
+import { DevUserSession } from '../Dev.vue';
+type __VLS_Props = {
+    session: DevUserSession | undefined;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { BISWalletPurpose } from '../types/common';
+import { SendInscriptionResult } from '../types/inscription';
+import { WalletInfo } from '../types/wallet';
+export { getAllBalanceDetails, getCardinalBalance } from './helpers';
+export { getOrdinalsWallet, getPaymentWallet, sendBTC, signMessage, signMessageLocalVerify, signMessageLocalVerifyDeterministic, } from './providers';
+export { getWalletInfo as getSession } from './store';
+export { getNetwork, setNetwork } from './store-network';
+/**
+ * Sends an inscription to a target wallet with the specified postage, fee rate, and dry run option. The function determines the appropriate method for sending the inscription based on the target wallet's properties and the specified wallet type. It uses the provided signing function to sign the necessary transactions for sending the inscription.
+ *
+ * @param inscriptionId - The ID of the inscription to be sent.
+ * @param targetWallet - An object containing information about the target wallet, including its address and whether it is an OP_RETURN wallet.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the transaction.
+ * @param postage - The amount of postage in satoshis to be included in the transaction for sending the inscription.
+ * @param dryRun - A boolean indicating whether to perform a dry run of the transaction, which will return the transaction details without broadcasting it to the network.
+ * @param walletType - An optional parameter specifying the type of wallet to use for sending the inscription, which can affect the method used for sending. If not provided, the function will determine the method based on the target wallet's properties.
+ * @returns A promise that resolves with the result of the send operation, which may include transaction details or an error if the operation fails.
+ * @throws Will throw an error if there is no wallet currently connected, if the target wallet type is unsupported, or if there is an issue with the signing function.
+ * @remarks The function uses different methods for sending the inscription based on whether the target wallet is an OP_RETURN wallet and the specified wallet type. It also ensures that a wallet is currently connected before attempting to send the inscription.
+ */
+export declare function sendInscription(inscriptionId: string, targetWallet: WalletInfo, feeRate: number, postage: number | null, dryRun: boolean, walletType?: BISWalletPurpose): Promise<SendInscriptionResult>;