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

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

@@ -1,6 +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';
 /**
@@ -321,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.
@@ -500,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.
  *
@@ -508,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.
  *
@@ -520,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;
 }>;
 /**

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.

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

@@ -1,10 +1,13 @@
-import { APIOrdinalUtxoInfo, APIUtxoInfo } from '../core/helpers';
-import { SignFunction, SignResponse } from '../provider/api';
+import { SignFunction, SignManyFunction, SignResponse } from '../provider/api';
 import { PaymentOpts } from '../types/common';
 import { InscribeFees, InscribeMultipleResult, InscribeResult, SendInscriptionResult, InscriptionDetails } from '../types/inscription';
+import { Utxo } from './chain-providers';
+import { OrdinalUtxoInfo } from './helpers';
 import { Buffer } from 'node:buffer';
 import { WalletInfo } from '../types/wallet';
 import * as bitcoinjs from 'bitcoinjs-lib';
+/** Fee rates are sat/vB and may be fractional; every fee built from one is rounded up to whole sats. */
+export declare function assertFeeRate(feeRate: number): void;
 export declare function getDustValue(wallet: WalletInfo): number;
 interface TapLeafScriptInfo {
     script: Buffer;
@@ -125,13 +128,82 @@ export declare function mintWithReclaimsAll(inscriptionDetails: InscriptionDetai
     postage: number;
     secret: string;
 }>;
+/** One inscription of an `inscribeAllToOpReturn` package. */
+export interface BatchedReveal {
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    secret: string;
+}
+/**
+ * How the send tx of `inscribeAllToOpReturn` moves its inscriptions into OP_RETURN outputs.
+ *
+ * - `single`: one OP_RETURN output worth `postage * (n - 1) + 1` sats, which covers the first sat
+ *   of every inscription input. The postage of all but the last inscription is burned.
+ * - `interleaved`: a 1-sat OP_RETURN output per inscription, each followed by a payer output that
+ *   takes back the rest of that inscription's postage (the last one merges into change). Only `n`
+ *   sats are burned. Multiple OP_RETURN outputs relay from Bitcoin Core 30.
+ * - `auto`: whichever of the two costs the payer less at the fee rate.
+ *
+ * Either layout leaves one postage minus a sat after its last OP_RETURN. The send pays the fee
+ * from it, or adds a payer input and returns it as change when that costs less (low fee rates).
+ */
+export type BatchedSendLayout = 'single' | 'interleaved' | 'auto';
+export interface InscribeAllToOpReturnResult {
+    commitTxId: string;
+    signedCommitTxHex: string;
+    /** One reveal per inscription, in the order the inscriptions were given. */
+    reveals: BatchedReveal[];
+    sendTxId: string;
+    signedSendTxHex: string;
+    /** The send layout used; `auto` resolves to one of the other two. */
+    sendLayout: Exclude<BatchedSendLayout, 'auto'>;
+    /** Miner fees of the commit, the reveals and the send, plus the sats burned in OP_RETURN outputs. */
+    totalFee: number;
+}
+/**
+ * The fees an `inscribeAllToOpReturn` package with the same arguments would pay, built offline
+ * without signing: the commit, the reveals, and the send's miner fee plus the sats it burns in
+ * OP_RETURN outputs. The send is priced against `cardinals` (or a fresh fetch) as they stand
+ * before the commit, the way `inscribeAllToOpReturn` picks its send plan.
+ */
+export declare function getInscribeAllToOpReturnFee(inscriptions: InscriptionDetails[], reclaimInputs: ReclaimInput[], opReturnWallet: WalletInfo, feeRate: number, sendLayout?: BatchedSendLayout, cardinals?: UtxoInfo[]): Promise<{
+    totalFee: number;
+    sendLayout: Exclude<BatchedSendLayout, 'auto'>;
+}>;
+/**
+ * `psbt`'s unsigned transaction with each input's scriptSig as signing will leave it, so its txid
+ * is the signed tx's; or null when a signature lands in a scriptSig. SegWit and taproot inputs
+ * sign in the witness and keep an empty scriptSig, and a P2SH-P2WPKH input's scriptSig is the push
+ * of its redeem script. Any other input, such as legacy P2PKH, makes it null.
+ */
+export declare function unsignedTxOnceSigned(psbt: bitcoinjs.Psbt): bitcoinjs.Transaction | null;
+/**
+ * Inscribes several inscriptions from one commit tx and sends them all to OP_RETURN outputs in
+ * one tx, so the wallet signs two transactions however many inscriptions there are. The signed
+ * package is validated with testmempoolaccept and returned for the caller to broadcast.
+ *
+ * Commit outputs: one self-send per reclaim input (same index and value as the input), then one
+ * taproot commit output per inscription, then payer change. Each inscription keeps its own reveal
+ * tx, because BRC-20 indexers only accept an inscription made in the first input of its reveal.
+ *
+ * The send tx spends the reveal outputs as inputs `0..n-1` in the given order, and its outputs
+ * follow `sendLayout`. Either way the first sat of every inscription input lands in an OP_RETURN
+ * output, in input order, so ord moves each inscription there and indexers process them in that
+ * order.
+ *
+ * With `signManyFunc`, the commit and the send are signed in one wallet prompt whenever the commit's
+ * txid is known before signing (see `unsignedTxOnceSigned`); the package is refused if the signed
+ * commit's txid differs. Otherwise `signFunc` signs the commit, then the send.
+ */
+export declare function inscribeAllToOpReturn(inscriptions: InscriptionDetails[], reclaimInputs: ReclaimInput[], opReturnWallet: WalletInfo, feeRate: number, signFunc: SignFunction, sendLayout?: BatchedSendLayout, signManyFunc?: SignManyFunction | null): Promise<InscribeAllToOpReturnResult>;
 /**
  * Estimates the fees for a reclaim mint by building the unsigned reclaim
  * commit tx (Task 1) and a fee-sizing reveal tx offline, without signing or
  * broadcasting. Mirrors mintWithExtraInputInCommitFeeRate. `fetchedCardinalUtxos`, the
  * payer's `fetchCardinalUtxos` response, funds the commit in place of a new fetch.
  */
-export declare function mintWithReclaimsCheckFees(inscriptionDetails: InscriptionDetails, reclaimInputs: ReclaimInput[], feeRate: number, postage: number | null, fetchedCardinalUtxos?: APIUtxoInfo[]): Promise<{
+export declare function mintWithReclaimsCheckFees(inscriptionDetails: InscriptionDetails, reclaimInputs: ReclaimInput[], feeRate: number, postage: number | null, fetchedCardinalUtxos?: Utxo[]): Promise<{
     unsigned_commit_tx_hex: string;
     signed_reveal_tx_hex: string;
     inscription_id: string;
@@ -161,10 +233,12 @@ export declare function resolveReclaimInputs(reclaimInscriptions: {
  * @param amounts - array of amounts to send to each output wallet (must be the same length as outputWallets)
  * @param changeWallet - the wallet to send the change to
  * @param feeRate - the fee rate in sat/vbyte
+ * @param fundingInput - add a payer UTXO even when `forceInUtxos` cover the outputs and the fee, so
+ *   their surplus returns as change instead of going to the miner
  *
  * @returns an object containing the built transaction and the fee paid for the transaction
  */
-export declare function buildTransactionMultiOutput(utxoArray: UtxoInfo[], forceInUtxos: UtxoInfoWithWallet[], payerWallet: WalletInfo, outputWallets: WalletInfo[], amounts: number[], changeWallet: WalletInfo, feeRate: number): BuildTransactionResult;
+export declare function buildTransactionMultiOutput(utxoArray: UtxoInfo[], forceInUtxos: UtxoInfoWithWallet[], payerWallet: WalletInfo, outputWallets: WalletInfo[], amounts: number[], changeWallet: WalletInfo, feeRate: number, fundingInput?: boolean): BuildTransactionResult;
 interface SendMultiInscriptionWithBufferResult {
     txid: string;
     signed_tx_hex: string;
@@ -199,7 +273,7 @@ export interface InscriptionUTXODetails {
  * Otherwise an inscription created by the saved extra transactions resolves from them
  * directly, and any other inscription is looked up in the backend's `ordinal_utxos` list.
  */
-export declare function getInscriptionDetails(inscriptionId: string, inscriptionAddr: string, ordinalUtxos?: APIOrdinalUtxoInfo[]): Promise<InscriptionUTXODetails | null>;
+export declare function getInscriptionDetails(inscriptionId: string, inscriptionAddr: string, ordinalUtxos?: OrdinalUtxoInfo[]): Promise<InscriptionUTXODetails | null>;
 /**
  * Sends multiple inscriptions in one transaction with a buffer output and returns the fee paid for the transaction. This is used for batch minting or batch sending when the user wants to know the fee before actually sending the transaction.
  *
@@ -271,7 +345,7 @@ interface InscribeCheckFeesResult {
  *
  * @returns an object containing the estimated commit fee, reveal fee, total fee, unsigned commit transaction hex, signed reveal transaction hex, inscription ID, and postage used
  */
-export declare function mintAllCheckFees(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, fetchedCardinalUtxos?: APIUtxoInfo[]): Promise<InscribeCheckFeesResult>;
+export declare function mintAllCheckFees(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, fetchedCardinalUtxos?: Utxo[]): Promise<InscribeCheckFeesResult>;
 /**
  * Sends an inscription to a target address using an OP_RETURN output. This function builds a transaction that spends the inscription UTXO and creates an OP_RETURN output with the inscription data, along with a target output with the specified postage. It then signs and broadcasts the transaction. If dryRun is true, it returns the signed transaction hex without broadcasting.
  *
@@ -350,7 +424,7 @@ interface SendInscriptionFeeRateResult {
  *
  * @returns an object containing the transaction ID, unsigned transaction hex, and calculated transaction fee
  */
-export declare function sendInscriptionToOpReturnWithExtraInputsAndExtraOutputFeeRate(inscriptionId: string, extraInputUtxos: UtxoInfoWithWallet[], targetWallet: WalletInfo, targetPostage: number, extraOutputUtxos: OutputUtxoInfo[], feeRate: number, fetchedCardinalUtxos?: APIUtxoInfo[]): Promise<SendInscriptionFeeRateResult>;
+export declare function sendInscriptionToOpReturnWithExtraInputsAndExtraOutputFeeRate(inscriptionId: string, extraInputUtxos: UtxoInfoWithWallet[], targetWallet: WalletInfo, targetPostage: number, extraOutputUtxos: OutputUtxoInfo[], feeRate: number, fetchedCardinalUtxos?: Utxo[]): Promise<SendInscriptionFeeRateResult>;
 /**
  * Mints an inscription with extra input UTXOs included in the commit transaction. This function builds and signs the commit and reveal transactions for minting an inscription, while allowing the user to include additional input UTXOs in the commit transaction. This can be useful in cases where the user wants to fund the commit transaction with specific UTXOs or needs to include additional inputs for other reasons. The function retrieves the connected wallets, builds and signs the transactions, validates them, and broadcasts them to the network. If dryRun is true, it returns the signed transaction hex without broadcasting.
  *
@@ -379,5 +453,5 @@ export declare function mintWithExtraInputInCommitAll(inscriptionDetails: Inscri
  *
  * @returns an object containing the estimated commit fee, reveal fee, total fee, unsigned commit transaction hex, signed reveal transaction hex, inscription ID, and postage used
  */
-export declare function mintWithExtraInputInCommitFeeRate(inscriptionDetails: InscriptionDetails, extraInputUtxos: UtxoInfoWithWallet[], feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, fetchedCardinalUtxos?: APIUtxoInfo[]): Promise<InscribeCheckFeesResult>;
+export declare function mintWithExtraInputInCommitFeeRate(inscriptionDetails: InscriptionDetails, extraInputUtxos: UtxoInfoWithWallet[], feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, fetchedCardinalUtxos?: Utxo[]): Promise<InscribeCheckFeesResult>;
 export {};

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

@@ -1,4 +1,4 @@
-import { BISProvider, SignFunction } from '../provider/api';
+import { BISProvider, SignFunction, SignManyFunction } from '../provider/api';
 import { BISSession, BISWallet, BISWalletProvider, BISWalletPurpose } from '../types/common';
 /**
  * Thrown before signing when the account active in the wallet extension differs from the
@@ -78,8 +78,16 @@ export declare function getPaymentWallet(): BISWallet | undefined;
  */
 export declare function getSignFn(provider: BISWalletProvider): SignFunction;
 /**
- * Signs a message using the currently connected wallet provider, then verifies it
- * against the backend. Returns the signature, or throws if signing or verification fails.
+ * Returns the specified provider's function for signing several PSBTs in one wallet prompt, or
+ * null when the provider or its installed wallet has none.
+ *
+ * @param provider The wallet provider.
+ * @returns The provider's batch sign function, or null.
+ */
+export declare function getSignManyFn(provider: BISWalletProvider): SignManyFunction | null;
+/**
+ * Signs a message using the currently connected wallet provider, then verifies its BIP-322
+ * signature. Returns the signature, or throws if signing or verification fails.
  *
  * @param message The message to sign.
  * @param walletType The wallet purpose to sign with ('payment' | 'ordinals' | 'all').

package/dist/types/core/sign-progress.d.ts

@@ -1,4 +1,4 @@
-import { SignFunction } from '../provider/api';
+import { SignFunction, SignManyFunction } from '../provider/api';
 /** A wallet prompt a multi-signature flow is about to raise. */
 export interface SignRequest {
     /** 1-based index of this prompt within the flow. */
@@ -27,4 +27,6 @@ export declare class SignProgress {
     constructor(options?: SignProgressOptions, total?: number);
     next(): void;
     wrap(signFn: SignFunction): SignFunction;
+    /** As `wrap`, for a function that signs several PSBTs in one prompt: each call counts once. */
+    wrapMany(signMany: SignManyFunction): SignManyFunction;
 }

package/dist/types/core/store-network.d.ts

@@ -51,6 +51,14 @@ export type EndpointsConfig = {
  * @throws {Error} If a key is unknown or a value is not an absolute http(s) URL.
  */
 export declare function setEndpoints(config: EndpointsConfig): void;
+/**
+ * Checks that a value is an absolute http(s) URL.
+ *
+ * @param label The setting the value belongs to, used as the error prefix.
+ * @param value The URL to check.
+ * @throws {Error} If the value is not a valid URL or uses another protocol.
+ */
+export declare function assertHttpUrl(label: string, value: string): void;
 /**
  * Returns the effective base URLs for a network: the defaults with any
  * {@link setEndpoints} overrides applied. Testnet has no `sequencerRead`,