@bestinslot/wallet-kit 0.14.2 → 0.15.0-rc.0

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

@@ -0,0 +1,49 @@
+import { Brc20RpcProvider, ChainBalance, ChainProvider, MempoolAcceptResult, OrdinalUtxo, Utxo } from './chain-providers';
+/** Endpoint base URLs for a {@link BisChainProvider}. A key left out reads `setEndpoints`. */
+export interface BisChainProviderOptions {
+    /** Base URL for UTXO, balance and raw transaction reads. */
+    indexer?: string;
+    /** Base URL for mempool acceptance tests and broadcasts. */
+    tx?: string;
+}
+/** Endpoint base URL for a {@link BisBrc20RpcProvider}. Left out, it reads `setEndpoints`. */
+export interface BisBrc20RpcProviderOptions {
+    /** The BRC2.0 JSON-RPC URL. */
+    rpc?: string;
+}
+/**
+ * The default {@link ChainProvider}: reads chain data from the Best in Slot API.
+ *
+ * Without constructor options it uses the `indexer` and `tx` endpoints of the selected network,
+ * as set with `setEndpoints`. Returned outputs keep every field the API sends.
+ */
+export declare class BisChainProvider implements ChainProvider {
+    private readonly indexer?;
+    private readonly tx?;
+    /**
+     * @param options Endpoint base URLs that take the place of the `setEndpoints` values.
+     * @throws {Error} If a URL is not an absolute http(s) URL.
+     */
+    constructor(options?: BisChainProviderOptions);
+    cardinalUtxos(address: string): Promise<Utxo[]>;
+    ordinalUtxos(address: string): Promise<OrdinalUtxo[]>;
+    balance(address: string): Promise<ChainBalance>;
+    txHex(txid: string): Promise<string>;
+    testMempoolAccept(txHexes: string[]): Promise<MempoolAcceptResult[]>;
+    broadcast(txHexes: string[]): Promise<string[]>;
+}
+/**
+ * The default {@link Brc20RpcProvider}: sends JSON-RPC requests over HTTP.
+ *
+ * Without constructor options it uses the `rpc` endpoint of the selected network, as set with
+ * `setEndpoints`.
+ */
+export declare class BisBrc20RpcProvider implements Brc20RpcProvider {
+    private readonly rpc?;
+    /**
+     * @param options The JSON-RPC URL that takes the place of the `setEndpoints` value.
+     * @throws {Error} If the URL is not an absolute http(s) URL.
+     */
+    constructor(options?: BisBrc20RpcProviderOptions);
+    request(method: string, params: unknown[]): Promise<unknown>;
+}

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

@@ -1,6 +1,8 @@
 import { BISWalletPurpose } from '../types/common';
 import { SendInscriptionResult } from '../types/inscription';
 import { WalletInfo } from '../types/wallet';
+export { getProviders, setProviders } from './chain-providers';
+export type { NetworkProviders, ProvidersConfig } from './chain-providers';
 export { getAllBalanceDetails, getCardinalBalance } from './helpers';
 export { getOrdinalsWallet, getPaymentWallet, sendBTC, signMessage, signMessageLocalVerify, signMessageLocalVerifyDeterministic, subscribeToAccountChanges, WalletAccountChangedError, } from './providers';
 export type { AccountChangeEvent } from './providers';

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

@@ -1,5 +1,7 @@
 import { FeePolicy } from '../lib/fee-policy';
 import { SwapFees } from '../lib/swap-reporting';
+import { SwapRoute } from '../lib/swap-route';
+import { BatchedSendLayout } from './mint';
 import { SignProgressOptions } from './sign-progress';
 import { BISSwapWalletInfo } from './store';
 /**
@@ -106,6 +108,7 @@ export interface SwapInfo {
     wbtc_handler_address: string;
     fee_policy: FeePolicy | null;
     allow_token_token_pairs: boolean;
+    allow_multi_hop_routes: boolean;
 }
 /**
  * Fetches the swap's deployment info (the factory, WBTC and WBTC handler addresses, and the
@@ -116,7 +119,7 @@ export interface SwapInfo {
  *
  * This does not require a connected wallet or a smart wallet.
  *
- * @returns {Promise<SwapInfo>} A promise that resolves to a SwapInfo object containing the factory address, the WBTC token address, the WBTC handler address, the fee policy (`null` if the backend does not serve one), and whether the backend accepts new token/token pools.
+ * @returns {Promise<SwapInfo>} A promise that resolves to a SwapInfo object containing the factory address, the WBTC token address, the WBTC handler address, the fee policy (`null` if the backend does not serve one), whether the backend accepts new token/token pools, and whether it routes swaps through a middle token.
  */
 export declare function getSwapInfo(): Promise<SwapInfo>;
 /**
@@ -319,7 +322,7 @@ export interface GetTvlHistoryResponse {
 /**
  * Fetches a daily Total Value Locked (TVL) series for a token pair from the swap backend, for charting TVL over time.
  *
- * TVL is valued in WBTC sats: 2 x the WBTC-side reserve for a WBTC pair. A token/token pair (`wbtc_side: ''`) is valued through each token's direct BTC pool as of that day, and its point is `tvl: null` on days its BTC exposure is below the backend's threshold. Points are one per day, oldest first, each carrying the pair's reserves as of that day (carried forward across days with no on-chain change).
+ * TVL is valued in WBTC sats: 2 x the WBTC-side reserve for a WBTC pair. A token/token pair (`wbtc_side: ''`) is valued along each token's BTC price route at that day's reserves, and its point is `tvl: null` on days its BTC exposure is below the backend's threshold. Points are one per day, oldest first, each carrying the pair's reserves as of that day (carried forward across days with no on-chain change).
  *
  * @param params An object with the pair address and the number of days to look back (max 365; the backend clamps out-of-range values).
  * @returns {Promise<GetTvlHistoryResponse>} A promise that resolves to the pair address, token addresses and symbols, which side is WBTC, the period in days, and the ascending array of `{ timestamp, block_height, tvl }` points. Each `tvl` is a string of sats (or `null`, see above) and can be converted to bigint if needed.
@@ -498,6 +501,26 @@ export interface ReclaimInscription {
     amount: bigint;
 }
 export declare function sumReclaimAmounts(reclaims?: ReclaimInscription[] | null): bigint;
+export interface DepositOrderOptions extends SignProgressOptions {
+    /**
+     * Inscribes the base-layer conversion, the allowance and the deposit from one commit tx and
+     * sends all of them to the BRC20PROG OP_RETURN in one tx, so the deposit takes three wallet
+     * prompts (BIP-322, commit, send) whatever it needs. Applies when the conversion or the
+     * allowance is needed; a deposit alone takes its usual three prompts.
+     */
+    batchInscriptions?: boolean;
+    /**
+     * How the batched send moves the inscriptions into OP_RETURN outputs (see `BatchedSendLayout`).
+     * Defaults to `single`.
+     */
+    batchSendLayout?: BatchedSendLayout;
+    /**
+     * Signs a batched deposit's commit and send in one wallet prompt when the wallet can sign several
+     * PSBTs at once (UniSat, OKX, Xverse) and the payer is not a legacy P2PKH address, so the
+     * deposit takes two prompts (BIP-322, then both txs). Defaults to true; false keeps three.
+     */
+    batchSigning?: boolean;
+}
 /**
  * Creates and broadcasts a deposit order for swapping BRC-20 tokens by performing necessary checks, generating signatures, and making API calls to the swap backend. The function handles both BRC-2.0 and base BRC-20 token balances, checks allowances, and prepares the required data for the deposit order.
  *
@@ -506,11 +529,11 @@ export declare function sumReclaimAmounts(reclaims?: ReclaimInscription[] | null
  * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
  * @param createAllowanceIfNeeded A boolean flag indicating whether to create an allowance for the BRC-2.0 token transfer if the current allowance is insufficient. Defaults to true.
  * @param reclaimInscriptions Optional transfer inscriptions to reclaim toward the base-layer sufficiency check, each with `inscriptionId` and `amount` (bigint, 18 decimals).
- * @param options `onSignRequest` is called before each wallet prompt, with `total` set: 3, plus 2 when base-layer balance is converted, plus 2 when an allowance is created.
+ * @param options `onSignRequest` is called before each wallet prompt, with `total` set: 3, plus 2 when base-layer balance is converted, plus 2 when an allowance is created. With `batchInscriptions`, `total` is 3.
  *
  * @returns {Promise<string[]>} A promise that resolves to an array of transaction IDs (txids) for the transactions involved in the deposit order, including the commit transaction, reveal transaction, and send-to-opreturn transaction.
  */
-export declare function createAndBroadcastDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[], options?: SignProgressOptions): Promise<string[]>;
+export declare function createAndBroadcastDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[], options?: DepositOrderOptions): Promise<string[]>;
 /**
  * Checks the miner fees required for creating a deposit order for swapping BRC-20 tokens, including the fees for minting inscriptions for allowance and deposit, as well as the fees for sending those inscriptions to OP_RETURN. The function also checks if the user has sufficient balance and allowance for the specified token amount.
  *
@@ -518,19 +541,23 @@ export declare function createAndBroadcastDepositOrder(tokenAddress: string, tok
  * @param tokenAmount The amount of the BRC-20 token to deposit, represented as a bigint in 18 decimals format.
  * @param feeRate The fee rate to use for the transactions, represented in sats/vbyte.
  * @param createAllowanceIfNeeded A boolean flag indicating whether to include the fees for creating an allowance inscription if the current allowance is insufficient. Defaults to true.
+ * @param reclaimInscriptions Optional transfer inscriptions the deposit reclaims, as for `createAndBroadcastDepositOrder`.
+ * @param options `batchInscriptions` and `batchSendLayout` as the deposit will be made with, so the fees are those of the package it builds.
  *
  * @returns A promise that resolves to an object containing the following properties:
  * - needs_approval: A boolean indicating whether an allowance inscription needs to be created.
- * - allowance_fees_total: The total miner fees for creating and sending the allowance inscription to OP_RETURN (0 if no allowance inscription is needed).
- * - base_deposit_fees_total: The total miner fees for creating and sending the base deposit inscription to OP_RETURN (0 if no base deposit inscription is needed).
- * - deposit_fees_total: The total miner fees for creating and sending the deposit inscription to OP_RETURN.
+ * - allowance_fees_total: The total miner fees for creating and sending the allowance inscription to OP_RETURN (0 if no allowance inscription is needed, and 0 when batched).
+ * - base_deposit_fees_total: The total miner fees for creating and sending the base deposit inscription to OP_RETURN (0 if no base deposit inscription is needed, and 0 when batched).
+ * - deposit_fees_total: The total miner fees for creating and sending the deposit inscription to OP_RETURN; when batched, the fees of the whole package, burned OP_RETURN sats included.
+ * - batched: Whether the deposit is one batched package.
  * - fee_rate: The fee rate used for the calculations, in sats/vbyte.
  */
-export declare function getMinerFeesOfDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[]): Promise<{
+export declare function getMinerFeesOfDepositOrder(tokenAddress: string, tokenAmount: bigint, feeRate: number, createAllowanceIfNeeded?: boolean, reclaimInscriptions?: ReclaimInscription[], options?: Pick<DepositOrderOptions, 'batchInscriptions' | 'batchSendLayout'>): Promise<{
     needs_approval: boolean;
     allowance_fees_total: number;
     base_deposit_fees_total: number;
     deposit_fees_total: number;
+    batched: boolean;
     fee_rate: number;
 }>;
 /**
@@ -645,6 +672,26 @@ export declare function getSwapResult(tokenInAddr: string, tokenOutAddr: string,
     reserve_out: bigint;
     fees: SwapFees;
 }>;
+/**
+ * The swap backend's best route for swapping `tokenInAddr` to `tokenOutAddr` at current reserves:
+ * the most output for an exact input, or the least input for an exact output. Routes go through a
+ * middle token only while the backend allows multi-hop routes (`SwapInfo.allow_multi_hop_routes`);
+ * otherwise the route is the direct pool.
+ *
+ * This does not require a connected wallet or a smart wallet.
+ *
+ * @param tokenInAddr The address of the token being swapped from.
+ * @param tokenOutAddr The address of the token being swapped to.
+ * @param amount The exact input amount, or the exact output amount when `exactOut` is true.
+ * @param options Route options.
+ * @param options.exactOut Treat `amount` as the exact output (defaults to false).
+ * @returns The route: its path, the amount at each token, each hop's pool and LP fee, the total
+ *   LP fee and the protocol fee bps on each endpoint.
+ * @throws {BackendError} With code `PAIR_NOT_FOUND` when no route can fill the amount.
+ */
+export declare function getSwapRoute(tokenInAddr: string, tokenOutAddr: string, amount: bigint, options?: {
+    exactOut?: boolean;
+}): Promise<SwapRoute>;
 interface SwapOrderResponse {
     success: boolean;
 }
@@ -657,10 +704,11 @@ interface SwapOrderResponse {
  * @param amt2 The amount of the output token expected from the swap, represented as a bigint.
  * @param slippageBPS The slippage in basis points to be applied when calculating the minimum amounts for the liquidity order.
  * @param referrerId An optional referral ID. When provided and valid, a share of the swap fee is credited to the referrer; an invalid referral is ignored and the swap proceeds normally.
+ * @param path Optional token addresses from `token1Addr` to `token2Addr`, as `getSwapRoute` returns them. A 3-token path routes the swap through its middle token and needs `SwapInfo.allow_multi_hop_routes`; omitted, the swap uses the direct pool.
  *
  * @returns A promise that resolves to an object indicating the success of the swap order request.
  */
-export declare function prepareAndSendSwapOrder(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string): Promise<SwapOrderResponse>;
+export declare function prepareAndSendSwapOrder(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string, path?: readonly string[]): Promise<SwapOrderResponse>;
 /**
  * Calculates the expected input amount, quoted price, and price impact for a token swap operation using the swap2 algorithm. The function retrieves the necessary swap information and connected wallet details, then uses a proxy to check the current balances and reserves of the tokens in the liquidity pool. It also requests the miner fee for swapping and gets the fee basis points for the tokens involved in the swap. Finally, it calls the swap2Request function to get the expected results based on the input parameters.
  *
@@ -690,10 +738,11 @@ interface Swap2OrderResponse {
  * @param amt2 The amount of the output token expected from the swap, represented as a bigint.
  * @param slippageBPS The slippage in basis points to be applied when calculating the maximum input amount for the swap order.
  * @param referrerId An optional referral ID. When provided and valid, a share of the swap fee is credited to the referrer; an invalid referral is ignored and the swap proceeds normally.
+ * @param path Optional token addresses from `token1Addr` to `token2Addr`, as `getSwapRoute` returns them. A 3-token path routes the swap through its middle token and needs `SwapInfo.allow_multi_hop_routes`; omitted, the swap uses the direct pool.
  *
  * @returns A promise that resolves to an object indicating the success of the swap order request.
  */
-export declare function prepareAndSendSwap2Order(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string): Promise<Swap2OrderResponse>;
+export declare function prepareAndSendSwap2Order(token1Addr: string, token2Addr: string, amt1: bigint, amt2: bigint, slippageBPS: bigint, referrerId?: string, path?: readonly string[]): Promise<Swap2OrderResponse>;
 /**
  * Prepares and sends a withdraw request to transfer tokens from the smart wallet to an ordinal wallet. The function retrieves the necessary swap information and connected wallet details, converts the target ordinal Bitcoin address to an Ethereum-compatible address, and generates the required signatures for the withdraw request. It then constructs the withdraw request parameters and sends the request to the backend API.
  *

package/dist/types/core/brc20-send.d.ts

@@ -1,6 +1,7 @@
 import { SignProgressOptions } from './sign-progress';
 import { InscriptionDetails } from '../types/inscription';
 import { WalletInfo } from '../types/wallet';
+import { assertFeeRate } from './mint';
 /** The transactions of one inscribe-and-send step. */
 export interface Brc20SendPart {
     commitTxId: string;
@@ -67,7 +68,7 @@ export declare function parseBrc20Amount(value: string, label: string): bigint;
 /** Formats an 18-decimal bigint as the shortest BRC-20 decimal string, such as `"7.5"`. */
 export declare function formatBrc20Amount(value: bigint): string;
 export declare function assertRecipient(recipient: string): void;
-export declare function assertFeeRate(feeRate: number): void;
+export { assertFeeRate };
 export declare function runChain(steps: ChainStep[], feeRate: number, dryRun: boolean, options: SignProgressOptions): Promise<Brc20SendQuote | ChainResult>;
 export interface SendAsBrc20Args extends SignProgressOptions {
     tick: string;

package/dist/types/core/chain-providers.d.ts

@@ -0,0 +1,133 @@
+import { BISNetwork } from '../types/common';
+/**
+ * An unspent output that carries no inscriptions and no runes.
+ */
+export interface Utxo {
+    /** The id of the transaction that created the output. */
+    txid: string;
+    /** The output's index in that transaction. */
+    vout: number;
+    /** The output's value in sats. */
+    value: number;
+}
+/**
+ * An unspent output that carries one or more inscriptions.
+ */
+export interface OrdinalUtxo extends Utxo {
+    /** The ids of the inscriptions on the output. */
+    inscription_ids: string[];
+    /** The satpoint (`txid:vout:offset`) of each entry of `inscription_ids`, in the same order. */
+    satpoints: string[];
+    /** The height of the block that confirmed the output, or `null` while it is unconfirmed. */
+    block_height?: number | null;
+}
+/**
+ * The mempool acceptance verdict for one transaction, in the shape of Bitcoin Core's
+ * `testmempoolaccept` entries.
+ */
+export interface MempoolAcceptResult {
+    /** Whether the transaction would enter the mempool. */
+    allowed: boolean;
+    /** Why the transaction would be rejected, when `allowed` is false. */
+    'reject-reason'?: string;
+}
+/**
+ * The balance of an address in sats, over every output of the address, inscribed and runic ones
+ * included. The spendable total is `confirmed + mempool`.
+ */
+export interface ChainBalance {
+    /** The sum of the address's confirmed outputs that no mempool transaction spends. */
+    confirmed: number;
+    /** The sum of the address's unspent outputs that unconfirmed transactions create. */
+    mempool: number;
+}
+/**
+ * The Bitcoin chain data wallet-kit reads and the transaction submission it performs.
+ *
+ * wallet-kit applies its own pending transactions on top of what a provider returns: outputs a
+ * pending transaction spends are dropped, and outputs it creates for the address are added. A
+ * provider therefore only reports what the chain (and optionally the mempool) holds.
+ *
+ * Every method throws when it cannot answer.
+ */
+export interface ChainProvider {
+    /**
+     * Lists the address's unspent outputs that carry no inscriptions and no runes. A provider
+     * that cannot tell whether an output carries an inscription or a rune throws instead of
+     * returning it. A provider without mempool data returns the confirmed outputs, minus those
+     * that mempool transactions spend.
+     */
+    cardinalUtxos: (address: string) => Promise<Utxo[]>;
+    /** Lists the address's unspent outputs that carry inscriptions. */
+    ordinalUtxos: (address: string) => Promise<OrdinalUtxo[]>;
+    /** Returns the address's balance. A provider without mempool data reports `mempool: 0`. */
+    balance: (address: string) => Promise<ChainBalance>;
+    /** Returns the raw transaction with the given id, hex encoded. */
+    txHex: (txid: string) => Promise<string>;
+    /**
+     * Tests whether the transactions, in order, would enter the mempool. Later transactions may
+     * spend outputs of earlier ones. Returns one result per transaction, in the same order.
+     */
+    testMempoolAccept: (txHexes: string[]) => Promise<MempoolAcceptResult[]>;
+    /** Broadcasts the transactions, in order, and returns their txids. */
+    broadcast: (txHexes: string[]) => Promise<string[]>;
+}
+/**
+ * A BRC2.0 JSON-RPC endpoint. wallet-kit uses it for `eth_call` reads.
+ */
+export interface Brc20RpcProvider {
+    /**
+     * Sends one JSON-RPC request and returns its `result`. Throws when the request fails or the
+     * response carries an `error`.
+     */
+    request: (method: string, params: unknown[]) => Promise<unknown>;
+}
+/** The providers for one network. A key left out uses the default provider. */
+export interface NetworkProviders {
+    chain?: ChainProvider;
+    brc20Rpc?: Brc20RpcProvider;
+}
+/** Per-network provider overrides accepted by {@link setProviders}. */
+export type ProvidersConfig = {
+    [N in BISNetwork]?: NetworkProviders;
+};
+/**
+ * Sets the chain data and BRC2.0 RPC providers per network. A network or key left out uses the
+ * defaults, {@link BisChainProvider} and {@link BisBrc20RpcProvider}, which read the endpoints
+ * set with `setEndpoints`. Every call replaces the previous overrides; `setProviders({})`
+ * restores the defaults.
+ *
+ * @param config Per-network providers, e.g. `{ signet: { chain: myChainProvider } }`.
+ * @throws {Error} If a network or key is unknown, or a provider lacks one of its methods.
+ */
+export declare function setProviders(config: ProvidersConfig): void;
+/**
+ * Returns the providers in effect for a network: the overrides set with {@link setProviders},
+ * and the default providers for the keys left out.
+ *
+ * @param network The network to read. Defaults to the selected network.
+ * @returns The chain data and BRC2.0 RPC providers for that network.
+ */
+export declare function getProviders(network?: BISNetwork): Required<NetworkProviders>;
+/**
+ * Returns the chain data provider for a network.
+ *
+ * @param network The network to read. Defaults to the selected network.
+ * @returns The provider set with {@link setProviders}, or the default {@link BisChainProvider}.
+ */
+export declare function getChainProvider(network?: BISNetwork): ChainProvider;
+/**
+ * Returns the BRC2.0 RPC provider for a network.
+ *
+ * @param network The network to read. Defaults to the selected network.
+ * @returns The provider set with {@link setProviders}, or the default {@link BisBrc20RpcProvider}.
+ */
+export declare function getBrc20RpcProvider(network?: BISNetwork): Brc20RpcProvider;
+/**
+ * Whether a network has a BRC2.0 RPC: a provider set with {@link setProviders}, or an `rpc`
+ * endpoint for the default provider.
+ *
+ * @param network The network to read. Defaults to the selected network.
+ * @returns Whether BRC2.0 RPC requests on that network have somewhere to go.
+ */
+export declare function hasBrc20Rpc(network?: BISNetwork): boolean;

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

@@ -1,3 +1,4 @@
+import { MempoolAcceptResult, OrdinalUtxo, Utxo } from './chain-providers';
 import { Endpoints } from './store-network';
 import * as bitcoinjs from 'bitcoinjs-lib';
 export declare const txHexByIdCache: {
@@ -25,9 +26,10 @@ export declare function sequencerEndpointFor(path: string): 'sequencerRead' | 's
  *
  * @param key The endpoint that serves the route.
  * @param path The route path, with any query string, relative to the endpoint base.
+ * @param base A base URL to use in place of the configured `key` endpoint.
  * @returns The full URL.
  */
-export declare function getEndpointUrl(key: keyof Endpoints, path: string): Promise<string>;
+export declare function getEndpointUrl(key: keyof Endpoints, path: string, base?: string): Promise<string>;
 /**
  * Builds the full URL for a swap sequencer route, routed to `sequencerRead` or
  * `sequencer` by {@link sequencerEndpointFor}.
@@ -84,6 +86,18 @@ export declare function clearExtraUtxos(): void;
  * @returns A string representing the type of the UTXO output, such as 'pubkeyhash', 'scripthash', 'witness_v0_keyhash', 'witness_v0_scripthash', 'witness_v1_taproot', 'pubkey', 'anchor', 'witness_unknown', 'nulldata', 'multisig', or 'nonstandard'.
  */
 export declare function utxoOutputTypeFromOutputScript(output: any, network: any): 'pubkeyhash' | 'scripthash' | 'witness_v0_keyhash' | 'witness_v0_scripthash' | 'witness_v1_taproot' | 'pubkey' | 'anchor' | 'witness_unknown' | 'nulldata' | 'multisig' | 'nonstandard';
+/** The output types wallet-kit can spend, named as in Bitcoin Core's `scriptPubKey.type`. */
+export type UtxoScriptType = APIUtxoInfo['script_type'];
+/** A cardinal UTXO with the outpoint string and script type wallet-kit's transaction builders read. */
+export type CardinalUtxoInfo = Utxo & {
+    utxo: string;
+    script_type: UtxoScriptType;
+};
+/** An ordinal UTXO with the outpoint string and script type wallet-kit's transaction builders read. */
+export type OrdinalUtxoInfo = OrdinalUtxo & {
+    utxo: string;
+    script_type: UtxoScriptType;
+};
 /**
  * Returns the ordinal UTXOs that the saved extra transactions create for `addr`: the
  * output carrying the saved extra inscription, unless another extra transaction spends it.
@@ -92,13 +106,14 @@ export declare function utxoOutputTypeFromOutputScript(output: any, network: any
  * @param addr The address the inscription output must pay to.
  * @returns The extra ordinal UTXOs for `addr`, empty when no extras are saved.
  */
-export declare function getExtraOrdinalUtxos(addr: string): APIOrdinalUtxoInfo[];
+export declare function getExtraOrdinalUtxos(addr: string): OrdinalUtxoInfo[];
 /**
  * Converts a witness stack to a script witness format that can be used in Bitcoin transactions.
  * @param witness An array representing the witness stack, where each element is a buffer or a string that can be converted to a buffer.
  * @returns A buffer containing the script witness data that can be included in a Bitcoin transaction input.
  */
 export declare function witnessStackToScriptWitness(witness: any[]): any;
+/** A cardinal UTXO as the Best in Slot API's `cardinal_utxos` route serves it. */
 export interface APIUtxoInfo {
     address: string;
     amounts: number[] | null;
@@ -116,24 +131,22 @@ export interface APIUtxoInfo {
     vsize: number | null;
 }
 /**
- * Fetches the UTXOs associated with a given address from the backend API and applies fixes to include any extra UTXOs that are currently in the process of being used in transactions but not yet confirmed on the blockchain.
+ * Lists the cardinal UTXOs of an address from the chain provider (see `setProviders`), with the saved extra transactions applied: outputs they spend are dropped and outputs they create for the address are added.
  *
  * @param addr The address for which to fetch the UTXOs.
  * @param fetchedUtxos A response from `fetchCardinalUtxos(addr)` to use in place of a new fetch. Each call works on its own copy, since coin selection sorts and splices the list it is given.
  * @returns A promise that resolves to an array of UTXO information objects.
  */
-export declare function getCardinalUtxos(addr: string, fetchedUtxos?: APIUtxoInfo[]): Promise<APIUtxoInfo[]>;
+export declare function getCardinalUtxos(addr: string, fetchedUtxos?: Utxo[]): Promise<CardinalUtxoInfo[]>;
 /**
- * Fetches the backend's cardinal UTXO list for an address as served, without the saved extra UTXOs applied. A dry run that prices several transactions fetches this once and passes it to each `getCardinalUtxos` call.
+ * Fetches the chain provider's cardinal UTXO list for an address as served, without the saved extra UTXOs applied. A dry run that prices several transactions fetches this once and passes it to each `getCardinalUtxos` call.
  *
  * @param addr The address for which to fetch the UTXOs.
- * @returns A promise that resolves to the backend's array of UTXO information objects.
+ * @returns A promise that resolves to the provider's array of UTXOs.
  */
-export declare function fetchCardinalUtxos(addr: string): Promise<APIUtxoInfo[]>;
+export declare function fetchCardinalUtxos(addr: string): Promise<Utxo[]>;
 /**
- * This function gets the balance of a given address by fetching its UTXOs from the backend and summing
- * their values. It also applies fixes to include any extra UTXOs that are currently in the process of
- * being used in transactions but not yet confirmed on the blockchain.
+ * Sums the values of an address's cardinal UTXOs, with the saved extra transactions applied as in `getCardinalUtxos`.
  *
  * @param address The address for which to fetch the balance.
  * @returns The total balance of the address in satoshis.
@@ -144,15 +157,13 @@ export interface AllBalanceDetails {
     mempool_balance: number;
 }
 /**
- * Fetches the balance details of a given address from the backend API, including both confirmed and mempool balances. It also applies fixes to include any extra UTXOs that are currently in the process of being used in transactions but not yet confirmed on the blockchain.
+ * Reads the confirmed and mempool balances of an address from the chain provider (see `setProviders`).
  *
  * @param addr The address for which to fetch the balance details.
  * @returns A promise that resolves to an object containing the confirmed balance and mempool balance of the address in satoshis.
  */
 export declare function getAllBalanceDetails(addr: string): Promise<AllBalanceDetails>;
-/**
- * Represents the structure of UTXO information returned by the backend API for ordinal UTXOs. It includes details such as the address, amounts, block height, inscription IDs, rune IDs, satpoints, script, script type, transaction fee, transaction ID, UTXO identifier, value, vout index, and virtual size of the UTXO.
- */
+/** An ordinal UTXO as the Best in Slot API's `ordinal_utxos` route serves it. */
 export interface APIOrdinalUtxoInfo {
     address: string;
     amounts: number[] | null;
@@ -170,43 +181,48 @@ export interface APIOrdinalUtxoInfo {
     vsize: number | null;
 }
 /**
- * Fetches the ordinal UTXOs associated with a given address from the backend API and applies fixes to include any extra UTXOs that are currently in the process of being used in transactions but not yet confirmed on the blockchain.
+ * Lists the ordinal UTXOs of an address from the chain provider (see `setProviders`), with the saved extra transactions applied: outputs they spend are dropped and the output carrying the saved extra inscription is added.
  *
  * @param addr The address for which to fetch the ordinal UTXOs.
  *
  * @returns A promise that resolves to an array of ordinal UTXO information objects.
  */
-export declare function getOrdinalUtxos(addr: string): Promise<APIOrdinalUtxoInfo[]>;
+export declare function getOrdinalUtxos(addr: string): Promise<OrdinalUtxoInfo[]>;
 /**
- * Fetches the raw transaction hex for a given transaction ID from the backend API. It caches the result to avoid redundant network requests.
+ * Returns the raw transaction hex for a transaction ID. Transactions the kit built or fetched before come from a cache; any other is read from the chain provider (see `setProviders`).
  *
  * @param txid The transaction ID for which to fetch the raw transaction hex.
  * @returns A promise that resolves to the raw transaction hex string.
  */
 export declare function getTxhex(txid: string): Promise<string>;
 /**
- * Validates a list of transaction hexes by sending them to the backend API for testing their acceptance into the mempool. The function combines the provided transaction hexes with any currently saved extra transaction hexes and sends them to the backend for validation.
+ * Tests the mempool acceptance of a list of transactions through the chain provider (see `setProviders`). The saved extra transactions are tested first, so the given transactions may spend their outputs.
  *
  * @param txHexes An array of transaction hex strings representing the transactions to be validated.
- * @returns A promise that resolves to the validation result returned by the backend API, or null if the validation request fails.
+ * @returns A promise that resolves to one result per tested transaction, saved extras included, or null when the provider's request fails with a {@link BackendError}.
  */
-export declare function validateTxes(txHexes: string[]): Promise<any>;
+export declare function validateTxes(txHexes: string[]): Promise<MempoolAcceptResult[] | null>;
 /**
- * Broadcasts a list of transaction hexes to the network by sending them to the backend API. The function throws an error if there are any extra transaction hexes currently set, as broadcasting is not allowed in that state.
+ * Broadcasts a list of transactions through the chain provider (see `setProviders`). The function throws an error if there are any extra transaction hexes currently set, as broadcasting is not allowed in that state.
  *
  * @param txHexes An array of transaction hex strings representing the transactions to be broadcasted.
- * @returns A promise that resolves to the result of the broadcast request returned by the backend API, or null if the broadcast request fails.
+ * @returns A promise that resolves to the broadcast transactions' txids, or null when the provider's request fails with a {@link BackendError}.
  * @throws An error if there are extra transaction hexes currently set, as broadcasting is not allowed in that state.
  */
-export declare function broadcastTxes(txHexes: string[]): Promise<any>;
+export declare function broadcastTxes(txHexes: string[]): Promise<string[] | null>;
+/** The BRC2.0 precompile that verifies a BIP-322 signature; it returns 1 for a valid one. */
+export declare const BIP322_VERIFY_PRECOMPILE = "0x00000000000000000000000000000000000000fe";
 /**
- * Verifies a signature for a given message, signature, and address by sending the verification request to the backend API. The function constructs the necessary parameters for the verification request, including converting the message to hexadecimal format and generating the pkscript from the provided address, and then sends the request to the backend for verification.
+ * Verifies a BIP-322 signature with the BRC2.0 chain's own verifier: an `eth_call` to its BIP-322
+ * precompile through the network's BRC2.0 RPC provider (see `setProviders`). A signature it accepts
+ * is one the chain accepts. A call the node rejects, such as one with a malformed signature, or a
+ * request that fails, counts as invalid.
  *
- * @param message The message for which the signature needs to be verified.
- * @param signatureHex The signature in hexadecimal format that needs to be verified against the message and address.
- * @param address The Bitcoin address that is claimed to have produced the signature for the given message.
- * @returns A promise that resolves to a boolean indicating whether the signature is valid for the given message and address, or throws an error if the verification process fails.
- * @throws An error if the verification process fails, such as due to network issues or invalid input parameters.
+ * @param message The signed message.
+ * @param signatureHex The signature, hex encoded.
+ * @param address The address that signed.
+ * @returns Whether the chain's verifier accepts the signature.
+ * @throws {Error} If the address is not valid on the selected network.
  */
 export declare function verifySignature(message: string, signatureHex: string, address: string): Promise<boolean>;
 /**
@@ -232,12 +248,13 @@ export declare function fetchWithErrors<T>(url: string, options: RequestInit): P
 /**
  * Retrieves the BRC2.0 JSON-RPC URL configured as the `rpc` endpoint for the selected network.
  *
+ * @param base An RPC URL to use in place of the configured `rpc` endpoint.
  * @returns The RPC URL.
  * @throws {Error} If the selected network has no RPC endpoint configured.
  */
-export declare function getPublicRpcUrl(): Promise<string>;
+export declare function getPublicRpcUrl(base?: string): Promise<string>;
 /**
- * Executes an eth_call on the BRC2.0 RPC configured for the selected network. The function constructs the JSON-RPC request payload with the provided data and sends it to the RPC URL for execution. It returns a promise that resolves to the result of the eth_call, or throws an error if the request fails.
+ * Executes an eth_call through the BRC2.0 RPC provider of the selected network (see `setProviders`). It returns a promise that resolves to the result of the eth_call, or throws an error if the request fails.
  *
  * @param to The address of the contract to call.
  * @param abi The ABI of the contract to call.