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

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`,

package/dist/types/core.d.ts

@@ -6,6 +6,8 @@ export * as balances from './api/balances';
 export * from './api/helpers';
 export { getEndpoints, getNetwork, setEndpoints, setNetwork, subscribeToNetwork, } from './core/store-network';
 export type { Endpoints, EndpointsConfig } from './core/store-network';
+export { getProviders, setProviders } from './core/chain-providers';
+export type { NetworkProviders, ProvidersConfig } from './core/chain-providers';
 export type { PaymentOpts } from './types/common';
 export * as bitcoinjs from 'bitcoinjs-lib';
 export * as Buff from '@cmdcode/buff-utils';

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

@@ -0,0 +1,118 @@
+/** The most tokens a swap path can list (two hops). */
+export declare const MAX_SWAP_PATH_LENGTH = 3;
+/** One pool step of a swap route. Amounts are in base units. */
+export interface SwapRouteHop {
+    pair_address: string;
+    token_in: string;
+    token_out: string;
+    amount_in: bigint;
+    amount_out: bigint;
+    /** The pool's LP fee, in bps. Already reflected in `amount_out`. */
+    lp_fee_bps: bigint;
+}
+/**
+ * The best route the swap backend found for a swap at current reserves.
+ *
+ * `amounts[0]` is the input and `amounts[amounts.length - 1]` the output; with an exact input the
+ * first is the amount asked for, with an exact output the last is. Pass `path` to
+ * `swapExactInput` / `swapExactOutput` to execute this route.
+ */
+export interface SwapRoute {
+    /** Token addresses from input to output, lowercased: 2 for a direct swap, 3 for a routed one. */
+    path: string[];
+    /** The amount at each token of `path`, net of LP fees. */
+    amounts: bigint[];
+    hops: SwapRouteHop[];
+    /** The LP fee of every hop added up, in bps. */
+    lp_fee_bps_total: bigint;
+    /** The protocol fee on the input token, in bps (the swap's `token1FeeBps`). */
+    token1FeeBps: bigint;
+    /** The protocol fee on the output token, in bps (the swap's `token2FeeBps`). */
+    token2FeeBps: bigint;
+}
+/** The `result` of the swap backend's `/get_swap_route`, as served. */
+export interface RawSwapRoute {
+    path: string[];
+    amounts: string[];
+    hops: {
+        pair_address: string;
+        token_in: string;
+        token_out: string;
+        amount_in: string;
+        amount_out: string;
+        lp_fee_bps: number | string;
+    }[];
+    lp_fee_bps_total: number | string;
+    token1FeeBps: string;
+    token2FeeBps: string;
+}
+/**
+ * Converts a `/get_swap_route` result into a `SwapRoute`, checking that its path is one the swap
+ * flow can sign.
+ *
+ * @param raw The backend's route.
+ * @param tokenIn The input token asked for.
+ * @param tokenOut The output token asked for.
+ * @returns The route with bigint amounts and lowercased addresses.
+ * @throws {Error} If the path does not run from `tokenIn` to `tokenOut` or is malformed.
+ */
+export declare function parseSwapRoute(raw: RawSwapRoute, tokenIn: string, tokenOut: string): SwapRoute;
+/**
+ * Checks a swap path against the swap's input and output tokens, as the swap backend does.
+ *
+ * @param path Token addresses from `token1` to `token2`, or `undefined` for the direct path.
+ * @param token1 The input token.
+ * @param token2 The output token.
+ * @returns The path lowercased; `[token1, token2]` when `path` is undefined.
+ * @throws {Error} If the path lists fewer than 2 or more than 3 tokens, holds an invalid or
+ *   repeated address, or does not start at `token1` and end at `token2`.
+ */
+export declare function resolveSwapPath(path: readonly string[] | undefined, token1: string, token2: string): string[];
+/** The fields shared by the exact-input and exact-output BIP322 swap texts. */
+interface SwapOrderTextFields {
+    /** Token addresses from input to output; the direct path is `[token1, token2]`. */
+    path: readonly string[];
+    token1FeeBps: string;
+    token2FeeBps: string;
+    btc_fee: string;
+    referrer_pubkey?: string;
+    ref_return_bps?: string;
+}
+/**
+ * The BIP322 text signed for an exact-input swap (`/swap`). A routed path adds a
+ * `Route: a -> x -> b` line after the token addresses.
+ */
+export declare function swapOrderSignatureText(fields: SwapOrderTextFields & {
+    in_amt: string;
+    min_out_amt: string;
+}): string;
+/**
+ * The BIP322 text signed for an exact-output swap (`/swap2`). A routed path adds a
+ * `Route: a -> x -> b` line after the token addresses.
+ */
+export declare function swap2OrderSignatureText(fields: SwapOrderTextFields & {
+    max_in_amt: string;
+    out_amt: string;
+}): string;
+/** The fields of the BLS swap message; `amount1`/`amount2` are the op's two amount words. */
+export interface SwapBLSMessageFields {
+    pubkey: string;
+    nonce: bigint;
+    /** Token addresses from input to output; the direct path is `[token1, token2]`. */
+    path: readonly string[];
+    amount1: bigint;
+    amount2: bigint;
+    token1FeeBps: bigint;
+    token2FeeBps: bigint;
+    btc_fee: bigint;
+    referrer_pubkey?: string;
+    ref_return_bps?: bigint;
+}
+/**
+ * The hex message hashed to the BLS curve and signed for a swap op: `03` for exact input (swap1)
+ * with amounts (in_amt, min_out_amt), `04` for exact output (swap2) with (max_in_amt, out_amt).
+ * Every path address is left-padded to 64 hex chars (the contract's address[] encoding), in path
+ * order.
+ */
+export declare function swapBLSMessage(opType: '03' | '04', fields: SwapBLSMessageFields): string;
+export {};

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

@@ -32,6 +32,20 @@ export interface SignatureWithAddress {
  * @returns A promise that resolves to an object containing the signed PSBT as a hexadecimal string and optionally the transaction ID (txid) if the transaction was broadcasted. This allows developers to use the signed PSBT for further processing or to track the transaction on the blockchain. If there is an error in signing the PSBT, the promise will be rejected with a descriptive error message.
  */
 export type SignFunction = (unsignedPsbtHex: string, paymentAddr: string, ordAddr: string, ordAddrIdxes: number[], useTweakSignerIdxes?: number[], noSignIdxes?: number[]) => Promise<SignResponse>;
+/** One PSBT of a `SignManyFunction` call, with the arguments a `SignFunction` takes for it. */
+export interface SignPsbtRequest {
+    unsignedPsbtHex: string;
+    paymentAddr: string;
+    ordAddr: string;
+    ordAddrIdxes: number[];
+    useTweakSignerIdxes?: number[];
+    noSignIdxes?: number[];
+}
+/**
+ * Signs several PSBTs in one wallet prompt and returns one `SignResponse` per request, in order.
+ * The PSBTs may depend on each other (one spending another's outputs), so none is broadcast.
+ */
+export type SignManyFunction = (requests: SignPsbtRequest[]) => Promise<SignResponse[]>;
 /**
  * Defines the interface for a BISProvider, which includes methods for retrieving wallets, signing messages, and sending Bitcoin. The BISProvider interface specifies the structure that any wallet provider must implement to be compatible with the BIS Wallet Kit. This includes methods for getting the list of wallets, signing messages in both standard and deterministic ways, sending Bitcoin transactions, and signing PSBTs (Partially Signed Bitcoin Transactions). By adhering to this interface, different wallet providers can be integrated into the BIS Wallet Kit while ensuring a consistent API for developers using the kit.
  */
@@ -110,4 +124,10 @@ export interface BISProvider {
      * @returns A promise that resolves to an object containing the signed PSBT as a hexadecimal string and optionally the transaction ID (txid) if the transaction was broadcasted. This allows developers to use the signed PSBT for further processing or to track the transaction on the blockchain. If there is an error in signing the PSBT, the promise will be rejected with a descriptive error message.
      */
     sign: SignFunction;
+    /**
+     * Returns a function that signs several PSBTs in one wallet prompt, or null when the wallet
+     * (or its installed version) has no such method. Implemented only by providers whose wallet
+     * offers batch signing.
+     */
+    getSignMany?: () => SignManyFunction | null;
 }

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

@@ -21,6 +21,8 @@ interface UniSat {
   switchNetwork: (network: string) => Promise<void>
   signMessage: (message: string, type?: 'ecdsa' | 'bip322-simple') => Promise<string>
   signPsbt: (psbt: any, options?: any) => Promise<string>
+  /** Signs several PSBT hexes in one prompt; absent before UniSat added batch signing. */
+  signPsbts?: (psbts: string[], options?: any[]) => Promise<string[]>
   pushPsbt: (psbt: any) => Promise<string>
   getPublicKey: () => Promise<string>
   sendBitcoin: (toAddress: string, amountSats: number) => Promise<string>

package/dist/vue.js

@@ -1,6 +1,6 @@
 import { ref as s, onScopeDispose as u, watch as i } from "vue";
-import { e as r, U as c, k as a } from "./mint-CSk_3TfL.js";
-function n() {
+import { e as r, Z as c, l as a } from "./mint-FmqHYTrX.js";
+function w() {
   const o = s(r()), t = c((e) => {
     o.value !== e && (o.value = e);
   });
@@ -9,5 +9,5 @@ function n() {
   }), o;
 }
 export {
-  n as useNetwork
+  w as useNetwork
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bestinslot/wallet-kit",
   "type": "module",
-  "version": "0.14.2",
+  "version": "0.15.0-rc.0",
   "private": false,
   "description": "A lightweight JavaScript library for connecting Bitcoin wallets with a unified API.",
   "license": "MIT",