@bestinslot/wallet-kit 0.7.0

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

@@ -0,0 +1,364 @@
+import { SignFunction, SignResponse } from '../provider/api';
+import { PaymentOpts } from '../types/common';
+import { InscribeFees, InscribeMultipleResult, InscribeResult, SendInscriptionResult, InscriptionDetails } from '../types/inscription';
+import { Buffer } from 'node:buffer';
+import { WalletInfo } from '../types/wallet';
+import * as bitcoinjs from 'bitcoinjs-lib';
+interface TapLeafScriptInfo {
+    script: Buffer;
+    controlBlock: Buffer;
+    leafVersion: number;
+}
+interface UtxoInfo {
+    utxo: string;
+    script_type: 'pubkeyhash' | 'scripthash' | 'witness_v0_keyhash' | 'witness_v0_scripthash' | 'witness_v1_taproot' | 'pubkey' | 'anchor' | 'witness_unknown' | 'nulldata' | 'multisig' | 'nonstandard';
+    value: number;
+    tapLeafScript?: Array<TapLeafScriptInfo>;
+    wallet?: WalletInfo;
+    witnessUtxoScript?: Buffer;
+    sequence?: number;
+    finalScriptWitness?: Buffer;
+}
+interface UtxoInfoWithWallet {
+    utxo: string;
+    script_type: 'pubkeyhash' | 'scripthash' | 'witness_v0_keyhash' | 'witness_v0_scripthash' | 'witness_v1_taproot' | 'pubkey' | 'anchor' | 'witness_unknown' | 'nulldata' | 'multisig' | 'nonstandard';
+    value: number;
+    tapLeafScript?: Array<TapLeafScriptInfo>;
+    wallet: WalletInfo;
+    witnessUtxoScript?: Buffer;
+    sequence?: number;
+    finalScriptWitness?: Buffer;
+}
+/**
+ * Calculate the fees for inscribing multiple inscriptions with the given details, fee rate, postage, payment address, and payment amount.
+ *
+ * @param inscriptionDetailsArray - An array of InscriptionDetails instances containing the details of each inscription to be minted.
+ * @param feeRate - The fee rate in satoshis per virtual byte to be used for the fee calculation.
+ * @param postage - The postage amount in satoshis to be included in the fee calculation, or null to use the default dust value.
+ * @param paymentOpts - An object containing the payment address and payment amount, or null if no payment is required.
+ * @returns A promise that resolves to an object containing the total fee, commit fee, reveal fee, postage, and secret for the inscriptions.
+ */
+export declare function getInscribeMultipleFee(inscriptionDetailsArray: InscriptionDetails[], feeRate: number, postage: number | null, paymentOpts?: PaymentOpts): Promise<InscribeFees>;
+export declare function inscribeWithParent(inscriptionDetails: InscriptionDetails, parentInscriptionId: string, feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeResult>;
+export declare function inscribeMultiple(inscriptionDetailsArray: InscriptionDetails[], feeRate: number, postage: number | null, dryRun: boolean, paymentOpts?: PaymentOpts): Promise<InscribeMultipleResult>;
+interface BuildTransactionResult {
+    tx: bitcoinjs.Transaction;
+    tx_fee: number;
+}
+export declare function buildTransaction(utxoInfos: UtxoInfo[], forceInUtxos: UtxoInfoWithWallet[], payerWallet: WalletInfo, opReturnWallets: WalletInfo[], outputWallet: WalletInfo | null, changeWallet: WalletInfo, feeRate: number, amount: number, paymentWallet: WalletInfo | null, payment: number | null): BuildTransactionResult;
+interface TransactionInOuts {
+    ins: {
+        hash: Buffer;
+        index: number;
+    }[];
+    outs: {
+        value: number;
+        script: Buffer;
+    }[];
+}
+export declare function buildPsbtFromTx(tx: TransactionInOuts, cardinalUtxos: UtxoInfo[], payerWallet: WalletInfo, forceInUtxos: UtxoInfoWithWallet[]): Promise<bitcoinjs.Psbt>;
+export interface ReclaimInput {
+    utxo: string;
+    value: number;
+    script_type: UtxoInfo['script_type'];
+}
+/**
+ * Builds an unsigned combined commit tx that reclaims transfer inscriptions
+ * back to the inscription wallet while paying for a new taproot commit
+ * output in the same transaction.
+ *
+ * Output layout:
+ *  - outputs `0..n-1`: one self-send per reclaim input, 1:1 with the
+ *    reclaim inputs (same index, same value), so the ordinal sat carried
+ *    by each reclaim input flows onto its own output.
+ *  - output `n`: the taproot commit output, funded purely by the cardinal
+ *    utxos (never by reclaimed sats).
+ *  - any trailing output: payer change.
+ *
+ * The candidate utxo set is passed in by the caller; the only network access
+ * is the PSBT-building step, which looks up each spent input's prevout tx
+ * (mirrors buildCommitTx).
+ */
+export declare function buildReclaimCommitTx(cardinalUtxos: UtxoInfo[], reclaimInputs: ReclaimInput[], payerWallet: WalletInfo, inscriptionWallet: WalletInfo, secret: string, inscriptionDetails: InscriptionDetails, feeRate: number, postage: number): Promise<{
+    unsignedCommitTx: bitcoinjs.Transaction;
+    unsignedPsbtHex: string;
+    commitVout: number;
+    commitOutputValue: number;
+    commitFee: number;
+    revealFee: number;
+}>;
+/**
+ * Builds, signs, and validates a full reclaim commit+reveal pair offline: creates
+ * a fresh secret, builds the reclaim commit tx (Task 1), signs its PSBT with the
+ * caller-supplied signFunc, builds the reveal tx spending the relocated commit
+ * output, and checks both signed txes with the mempool-accept validator before
+ * returning them for the caller to broadcast.
+ *
+ * Pure w.r.t. network selection: all utxos are passed in by the caller. Network
+ * access (prevout lookups, mempool-accept validation) is delegated to the same
+ * helpers buildCommitTx-based flows already use.
+ */
+export declare function assembleReclaimCommitAndReveal(cardinalUtxos: UtxoInfo[], reclaimInputs: ReclaimInput[], payerWallet: WalletInfo, inscriptionWallet: WalletInfo, inscriptionDetails: InscriptionDetails, feeRate: number, postage: number, signFunc: SignFunction): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    commitVout: number;
+    postage: number;
+    secret: string;
+}>;
+/**
+ * Fetches the connected wallets' cardinal utxos and delegates to
+ * assembleReclaimCommitAndReveal to build, sign, and validate the reclaim
+ * commit+reveal pair, then broadcasts both txes unless dryRun is set.
+ */
+export declare function mintWithReclaimsAll(inscriptionDetails: InscriptionDetails, reclaimInputs: ReclaimInput[], feeRate: number, postage: number | null, dryRun: boolean, signFunc: SignFunction): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    commitVout: number;
+    postage: number;
+    secret: string;
+}>;
+/**
+ * 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.
+ */
+export declare function mintWithReclaimsCheckFees(inscriptionDetails: InscriptionDetails, reclaimInputs: ReclaimInput[], feeRate: number, postage: number | null): Promise<{
+    unsigned_commit_tx_hex: string;
+    signed_reveal_tx_hex: string;
+    inscription_id: string;
+    total_fee: number;
+    commit_vout: number;
+}>;
+/**
+ * Resolves reclaim inscriptions (transfer inscriptions to reclaim toward the
+ * base-deposit sufficiency check) into `ReclaimInput`s for
+ * `buildReclaimCommitTx`/`mintWithReclaimsAll`/`mintWithReclaimsCheckFees`.
+ *
+ * Looks up each inscription's current UTXO via `getInscriptionDetails` and
+ * enforces that it sits at sat offset 0 of its satpoint, which the reclaim
+ * commit tx assumes when self-sending the reclaim input.
+ */
+export declare function resolveReclaimInputs(reclaimInscriptions: {
+    inscriptionId: string;
+    amount: bigint;
+}[], ordinalsAddress: string): Promise<ReclaimInput[]>;
+/**
+ * Builds a transaction with multiple outputs. This is used for batch minting or batch sending.
+ *
+ * @param utxoArray - array of UTXOs to select from
+ * @param forceInUtxos - array of UTXOs that must be included in the transaction (e.g. for minting, the UTXO with the inscription must be included)
+ * @param payerWallet - the wallet that will pay for the transaction (must be the same for all inputs)
+ * @param outputWallets - array of wallets to send the outputs to (must be the same length as amounts)
+ * @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
+ *
+ * @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;
+interface SendMultiInscriptionWithBufferResult {
+    txid: string;
+    signed_tx_hex: string;
+    output_utxos: string[];
+    output_values: number[];
+    buffer_utxo: string;
+    buffer_output_value: number;
+}
+export declare function sendMultiInscriptionWithBuffer(inscriptionIds: string[], targetPostages: number[], targetAddr: string, bufferValue: number, feeRate: number, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<SendMultiInscriptionWithBufferResult>;
+/**
+ * Sends an inscription to a target address with specified postage and fee rate. This function is used for sending a single inscription, but it can also be used for batch sending by calling it multiple times with different inscription IDs and the same target address.
+ *
+ * @param inscriptionId - the ID of the inscription to send
+ * @param targetWallet - the wallet to send the inscription to (only the address field is used)
+ * @param targetPostage - the amount of satoshis to send with the inscription (must be greater than or equal to the dust value for the target wallet)
+ * @param feeRate - the fee rate in sat/vbyte to use for the transaction
+ * @param dryRun - if true, the transaction will not be broadcasted and the signed transaction hex will be returned for inspection
+ * @param signFunc - the function to use for signing the transaction, which takes the unsigned PSBT hex, payer address, inscription address, and an array of input indexes that belong to the inscription wallet, and returns an object containing the signed transaction hex and transaction ID
+ *
+ * @returns an object containing the transaction ID, signed transaction hex, vout index of the output containing the inscription, and the value of the output containing the inscription
+ */
+export declare function sendInscriptionAll(inscriptionId: string, targetWallet: WalletInfo, targetPostage: number | null, feeRate: number, dryRun: boolean, signFunc: SignFunction): Promise<SendInscriptionResult>;
+/**
+ * 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.
+ *
+ * @param inscriptionIds - array of inscription IDs to send
+ * @param targetPostages - array of target postages for each inscription
+ * @param targetAddr - address to send the inscriptions to
+ * @param bufferValue - value of the buffer output
+ * @param feeRate - fee rate in sat/vbyte
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ *
+ * @returns the fee paid for the transaction in satoshis
+ */
+export declare function getMultiInscriptionWithBufferFeeRate(inscriptionIds: string[], targetPostages: number[], targetAddr: string, bufferValue: number, feeRate: number, paymentAddr: string | null, payment: number | null): Promise<number>;
+/**
+ * Mints an inscription by building and signing the commit and reveal transactions. The commit transaction is built using the buildCommitTx function, and the reveal transaction is built using the buildRevealTx function. The function also validates the transactions before broadcasting them to the network. If dryRun is true, the transactions will not be broadcasted and the signed transaction hex will be returned for inspection.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ * @param dryRun - if true, the transactions will not be broadcasted and the signed transaction hex will be returned for inspection
+ * @param signFunc - function to sign the transactions
+ *
+ * @returns an object containing the commit transaction ID, signed commit transaction hex, reveal transaction ID, signed reveal transaction hex, inscription ID, postage used, and the secret token used for minting
+ */
+export declare function mintAll(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean, signFunc: SignFunction): Promise<{
+    commit_txid: string;
+    signed_commit_tx_hex: string;
+    reveal_txid: string;
+    signed_reveal_tx_hex: string;
+    inscription_id: string;
+    postage: number;
+    secret: string;
+}>;
+/**
+ * Mints an inscription using the connected payment wallet for both the commit and reveal transactions. This function is a wrapper around the mintAll function that simplifies the minting process when the user wants to use the same wallet for both transactions. It 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.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ * @param dryRun - if true, the transactions will not be broadcasted and the signed transaction hex will be returned for inspection
+ * @param signFunc - function to sign the transactions
+ *
+ * @returns an object containing the commit transaction ID, signed commit transaction hex, reveal transaction ID, signed reveal transaction hex, inscription ID, postage used, and the secret token used for minting
+ */
+export declare function mintAllPaymentWallet(inscriptionDetails: InscriptionDetails, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean, signFunc: SignFunction): Promise<InscribeResult>;
+interface InscribeCheckFeesResult {
+    commit_fee: number;
+    reveal_fee: number;
+    total_fee: number;
+    unsigned_commit_tx_hex: string;
+    signed_reveal_tx_hex: string;
+    inscription_id: string;
+    postage: number;
+}
+/**
+ * Checks the fees for minting an inscription by building the commit and reveal transactions without signing or broadcasting them. This function is useful for users who want to estimate the fees before actually minting the inscription. It returns the estimated commit fee, reveal fee, total fee, unsigned commit transaction hex, signed reveal transaction hex, inscription ID, and postage used.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ *
+ * @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): 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.
+ *
+ * @param inscriptionId - ID of the inscription to send, in the format of "txid:output_index"
+ * @param targetWallet - wallet information of the target address to send the inscription to
+ * @param targetPostage - postage amount in satoshis to include in the target output
+ * @param feeRate - fee rate in sat/vbyte to use for the transaction
+ * @param dryRun - if true, the transaction will not be broadcasted
+ * @param signFunc - function to sign the transaction
+ *
+ * @returns an object containing the transaction ID and signed transaction hex of the sent transaction
+ */
+export declare function sendInscriptionToOpReturnAll(inscriptionId: string, targetWallet: WalletInfo, targetPostage: number | null, feeRate: number, dryRun: boolean, signFunc: SignFunction): Promise<SendInscriptionResult>;
+/**
+ * Sends an inscription to a target address using an OP_RETURN output, with the payment wallet as the source of funds for the transaction. This function is similar to sendInscriptionToOpReturnAll, but it specifically uses the payment wallet for funding the transaction, which can be useful in cases where the inscription wallet does not have enough funds to cover the transaction fees. It 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.
+ *
+ * @param inscriptionId - ID of the inscription to send, in the format of "txid:output_index"
+ * @param targetWallet - wallet information of the target address to send the inscription to
+ * @param targetPostage - postage amount in satoshis to include in the target output
+ * @param feeRate - fee rate in sat/vbyte to use for the transaction
+ * @param dryRun - if true, the transaction will not be broadcasted
+ * @param signFunc - function to sign the transaction
+ *
+ * @returns an object containing the transaction ID and signed transaction hex of the sent transaction
+ */
+export declare function sendInscriptionInPaymentWalletToOpReturnAll(inscriptionId: string, targetWallet: WalletInfo, targetPostage: number | null, feeRate: number, dryRun: boolean, signFunc: SignFunction): Promise<SendInscriptionResult>;
+/**
+ * Mints an inscription with a parent inscription by building and signing the commit and reveal transactions that reference the parent inscription. This function is used when the user wants to create a new inscription that is linked to an existing parent inscription, allowing for hierarchical relationships between inscriptions. It 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.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param parentInscriptionId - ID of the parent inscription to link to, in the format of "txid:output_index"
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ * @param dryRun - if true, the transactions will not be broadcasted and the signed transaction hex will be returned for inspection
+ * @param signFunc - function to sign the transactions
+ *
+ * @returns an object containing the commit transaction ID, signed commit transaction hex, reveal transaction ID, signed reveal transaction hex, inscription ID, postage used, and the secret token used for minting
+ */
+export declare function mintWithParentAll(inscriptionDetails: InscriptionDetails, parentInscriptionId: string, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean, signFunc: SignFunction): Promise<InscribeResult>;
+interface OutputUtxoInfo {
+    wallet: WalletInfo;
+    value: number;
+}
+/**
+ * Sends an inscription to a target address using an OP_RETURN output, with extra input UTXOs and extra output UTXOs included in the transaction. This function allows for more complex transactions where the user wants to include additional inputs and outputs beyond just the inscription UTXO and the target output. It builds a transaction that spends the inscription UTXO along with the extra input UTXOs, creates an OP_RETURN output with the inscription data, includes a target output with the specified postage, and adds any extra output UTXOs. It then signs and broadcasts the transaction. If dryRun is true, it returns the signed transaction hex without broadcasting.
+ *
+ * @param inscriptionId - ID of the inscription to send, in the format of "txid:output_index"
+ * @param extraInputUtxos - array of extra input UTXOs to include in the transaction, each with its associated wallet information
+ * @param targetWallet - wallet information of the target address to send the inscription to
+ * @param targetPostage - postage amount in satoshis to include in the target output
+ * @param extraOutputUtxos - array of extra output UTXOs to include in the transaction, each with its associated wallet information and value
+ * @param feeRate - fee rate in sat/vbyte to use for the transaction
+ * @param dryRun - if true, the transaction will not be broadcasted
+ * @param signFunc - function to sign the transaction
+ *
+ * @returns an object containing the transaction ID and signed transaction hex of the sent transaction
+ */
+export declare function sendInscriptionToOpReturnWithExtraInputsAndExtraOutputAll(inscriptionId: string, extraInputUtxos: UtxoInfoWithWallet[], targetWallet: WalletInfo, targetPostage: number, extraOutputUtxos: OutputUtxoInfo[], feeRate: number, dryRun: boolean, signFunc: SignFunction): Promise<SignResponse>;
+interface SendInscriptionFeeRateResult {
+    txid: string;
+    unsigned_tx_hex: string;
+    tx_fee: number;
+}
+/**
+ * Calculates the fee for sending an inscription to a target address using an OP_RETURN output, with extra input UTXOs and extra output UTXOs included in the transaction, based on a specified fee rate. This function builds the transaction without signing or broadcasting it, allowing the user to estimate the fees before actually sending the inscription. It returns the transaction ID, unsigned transaction hex, and the calculated transaction fee.
+ *
+ * @param inscriptionId - ID of the inscription to send, in the format of "txid:output_index"
+ * @param extraInputUtxos - array of extra input UTXOs to include in the transaction, each with its associated wallet information
+ * @param targetWallet - wallet information of the target address to send the inscription to
+ * @param targetPostage - postage amount in satoshis to include in the target output
+ * @param extraOutputUtxos - array of extra output UTXOs to include in the transaction, each with its associated wallet information and value
+ * @param feeRate - fee rate in sat/vbyte to use for the transaction
+ *
+ * @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): 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.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param extraInputUtxos - array of extra input UTXOs to include in the commit transaction, each with its associated wallet information
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ * @param dryRun - if true, the transactions will not be broadcasted and the signed transaction hex will be returned for inspection
+ * @param signFunc - function to sign the transactions
+ *
+ * @returns an object containing the commit transaction ID, signed commit transaction hex, reveal transaction ID, signed reveal transaction hex, inscription ID, postage used, and the secret token used for minting
+ */
+export declare function mintWithExtraInputInCommitAll(inscriptionDetails: InscriptionDetails, extraInputUtxos: UtxoInfoWithWallet[], feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean, signFunc: SignFunction): Promise<InscribeResult>;
+/**
+ * Checks the fees for minting an inscription with extra input UTXOs included in the commit transaction by building the commit and reveal transactions without signing or broadcasting them. This function is useful for users who want to estimate the fees before actually minting the inscription with extra inputs. It returns the estimated commit fee, reveal fee, total fee, unsigned commit transaction hex, signed reveal transaction hex, inscription ID, and postage used.
+ *
+ * @param inscriptionDetails - details of the inscription to mint, including content type, content length, and the actual content in hex format
+ * @param extraInputUtxos - array of extra input UTXOs to include in the commit transaction, each with its associated wallet information
+ * @param feeRate - fee rate in sat/vbyte to use for the transactions
+ * @param postage - postage amount in satoshis to use for the transactions
+ * @param paymentAddr - address to send the payment to (if payment is not null)
+ * @param payment - amount to pay (if payment is not null)
+ *
+ * @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): Promise<InscribeCheckFeesResult>;
+export {};

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

@@ -0,0 +1,21 @@
+import { BISWalletProvider, ConnectCallbacks, ModalTheme } from '../types/common';
+/**
+ * NOTE: The modal instance is created once and reused for subsequent calls to showConnect or showError. This ensures that only one modal is present in the DOM at any given time, and it can be easily shown or hidden as needed without creating multiple instances.
+ *
+ * The create function checks if the modal instance already exists before creating a new one. If it does exist, it simply returns without doing anything. This prevents multiple modals from being created if create is called multiple times.
+ *
+ * The showConnect, showConnectConfirmation, and showError functions all check if the modal instance exists before attempting to call methods on it. If the modal instance does not exist (e.g., if create has not been called), these functions will simply do nothing, which is a safe fallback behavior.
+ *
+ * This design allows for a single modal instance to be created and reused throughout the application, ensuring efficient resource usage and consistent user experience.
+ */
+export declare function create(): void;
+export declare function showConnect(callbacks: ConnectCallbacks): void;
+export declare function showConnectConfirmation(_provider: BISWalletProvider): void;
+export declare function showError(msg?: string | null | undefined): void;
+export declare function hide(): void;
+/**
+ * Sets the theme for the modal.
+ *
+ * @param theme The theme to set for the modal, which can be 'light', 'dark', or 'auto'.
+ */
+export declare function setTheme(theme: ModalTheme): void;

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

@@ -0,0 +1,90 @@
+import { BISProvider, SignFunction } from '../provider/api';
+import { BISSession, BISWallet, BISWalletProvider, BISWalletPurpose } from '../types/common';
+/**
+ * Registry of wallet providers, populated per build via `registerProvider`. The
+ * browser build registers the extension wallets; the server build registers only
+ * the local wallet. Keeping this empty by default means the core no longer
+ * statically imports every provider (so each flavour only bundles what it needs).
+ */
+export declare const PROVIDERS: Partial<Record<BISWalletProvider, BISProvider>>;
+/**
+ * Registers a wallet provider implementation under its key. Build entries call
+ * this at startup to populate the registry for their environment.
+ *
+ * @param name The provider key (e.g. 'unisat', 'local').
+ * @param provider The provider implementation.
+ */
+export declare function registerProvider(name: BISWalletProvider, provider: BISProvider): void;
+/**
+ * Gets the list of wallets from the specified provider. The function checks if the provider is supported and then calls the corresponding getWallets function from the provider module to retrieve the list of wallets. If the provider is not supported or if there is an error while fetching the wallets, it throws an error with an appropriate message.
+ *
+ * @param provider The wallet provider for which to fetch the wallets. This should be one of the registered providers.
+ *
+ * @returns A promise that resolves to a BISSession object containing the provider, the list of wallets, and a null signature. The function also saves the wallet information to local storage for later use.
+ * @throws An error if the provider is not supported or if there is an error while fetching the wallets, with a message indicating the reason for the failure.
+ */
+export declare function getWallets(provider: BISWalletProvider): Promise<BISSession>;
+/**
+ * Returns the currently connected ordinals wallet, or undefined if no ordinals wallet is connected. The function retrieves the wallet information from local storage and checks for a wallet with the purpose of 'ordinals'. If such a wallet is found, it is returned; otherwise, the function returns undefined.
+ *
+ * @returns The currently connected ordinals wallet, or undefined if no ordinals wallet is connected.
+ */
+export declare function getOrdinalsWallet(): BISWallet | undefined;
+/**
+ * Returns the currently connected payment wallet, or undefined if no payment wallet is connected. The function retrieves the wallet information from local storage and checks for a wallet with the purpose of 'payment'. If such a wallet is found, it is returned; otherwise, the function returns undefined.
+ *
+ * @returns The currently connected payment wallet, or undefined if no payment wallet is connected.
+ */
+export declare function getPaymentWallet(): BISWallet | undefined;
+/**
+ * Returns the sign function for the specified wallet provider from the registry.
+ *
+ * @param provider The wallet provider for which to get the sign function.
+ * @returns The provider's sign function.
+ * @throws An error if the provider is not registered.
+ */
+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.
+ *
+ * @param message The message to sign.
+ * @param walletType The wallet purpose to sign with ('payment' | 'ordinals' | 'all').
+ * @returns The signature as a hex string.
+ */
+export declare function signMessage(message: string, walletType: BISWalletPurpose): Promise<string>;
+/**
+ * Signs a message using the currently connected wallet provider, then verifies it
+ * locally (offline). 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').
+ * @returns The signature as a hex string.
+ */
+export declare function signMessageLocalVerify(message: string, walletType: BISWalletPurpose): Promise<string>;
+/**
+ * Signs a message deterministically using the currently connected wallet provider,
+ * then verifies it locally. Returns the signature, or throws on failure.
+ *
+ * @param message The message to sign.
+ * @returns The signature as a hex string.
+ */
+export declare function signMessageLocalVerifyDeterministic(message: string): Promise<string>;
+/**
+ * Sends Bitcoin using the currently connected wallet provider.
+ *
+ * @param amountSats The amount to send, in satoshis.
+ * @param toAddress The destination address.
+ * @param feeRate Optional fee rate in sat/vB. Extension providers estimate the fee themselves and ignore this; the local (WIF) provider requires it.
+ * @returns The transaction ID of the sent transaction.
+ */
+export declare function sendBTC(amountSats: number, toAddress: string, feeRate?: number): Promise<string>;
+/**
+ * Signs a PSBT using the currently connected wallet provider.
+ *
+ * @param psbtBase64 The PSBT to sign, base64-encoded.
+ * @param broadcast Whether to broadcast the signed transaction.
+ * @param inputsToSign The inputs to sign.
+ * @param message Optional message passed to providers that support it (ignored by others).
+ */
+export declare function signPSBT(psbtBase64: string, broadcast: boolean, inputsToSign: any[], message?: string): Promise<void>;

package/dist/types/core/register-browser-providers.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/core/register-local-provider.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,19 @@
+export interface KeyValueStore {
+    get: (key: string) => string | null;
+    set: (key: string, value: string) => void;
+    remove: (key: string) => void;
+}
+/**
+ * Creates an in-memory key-value store that can be used for storing data during the session. The memoryStorage function returns an object that implements the KeyValueStore interface, allowing you to get, set, and remove key-value pairs using a Map object internally. This is useful for scenarios where you want to store data temporarily without persisting it across sessions, such as during testing or when localStorage is not available.
+ *
+ * The returned KeyValueStore object provides three methods:
+ * - get(key: string): Retrieves the value associated with the specified key. If the key does not exist, it returns null.
+ * - set(key: string, value: string): Stores a key-value pair in the memory storage. If the key already exists, it will overwrite the existing value.
+ * - remove(key: string): Removes the key-value pair associated with the specified key from the memory storage. If the key does not exist, it does nothing.
+ *
+ * This in-memory storage is useful for scenarios where you want to store data temporarily during the runtime of an application without needing to persist it across sessions or reloads. It can be particularly helpful for testing purposes or when working in environments where localStorage is not available (e.g., server-side rendering).
+ *
+ * @returns An object that implements the KeyValueStore interface, providing methods to get, set, and remove key-value pairs in memory.
+ */
+export declare function memoryStorage(): KeyValueStore;
+export declare const browserStorage: KeyValueStore;

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

@@ -0,0 +1,20 @@
+import { BISNetwork } from '../types/common';
+/**
+ * Returns the currently selected network (e.g. 'mainnet', 'testnet', 'signet').
+ *
+ * @returns The currently selected network.
+ */
+export declare function getNetwork(): BISNetwork;
+/**
+ * Sets the current network and notifies subscribers. No-op if unchanged.
+ *
+ * @param newNetwork The network to switch to.
+ */
+export declare function setNetwork(newNetwork: BISNetwork): void;
+/**
+ * Subscribes to network changes.
+ *
+ * @param listener Called with the new network whenever it changes.
+ * @returns An unsubscribe function that removes the listener.
+ */
+export declare function subscribeToNetwork(listener: (network: BISNetwork) => void): () => void;

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

@@ -0,0 +1,39 @@
+import { BISSession } from '../types/common';
+/**
+ * Saves the wallet information to local storage. The saveWalletInfo function takes a BISSession object as an argument and stores it in local storage under a specific key (LS_KEY). The data is serialized to a JSON string before being stored. This allows the application to persist wallet information across sessions, enabling users to retain their wallet data even after closing and reopening the application.
+ * @param data The BISSession object containing the wallet information to be saved. This object typically includes details about the connected wallet, such as the provider, accounts, and other relevant session data. The function serializes this object to a JSON string and stores it in local storage under the key defined by LS_KEY, allowing for easy retrieval and management of wallet information in the application.
+ */
+export declare function saveWalletInfo(data: BISSession): void;
+/**
+ * Retrieves the wallet information from local storage. The getWalletInfo function reads the data stored under the LS_KEY in local storage, parses it from a JSON string back into a BISSession object, and returns it. If no data is found, it returns null. This function allows the application to access the persisted wallet information, enabling features like session restoration and wallet management.
+ * @returns The BISSession object containing the wallet information, or null if no data is found. This object typically includes details about the connected wallet, such as the provider, accounts, and other relevant session data.
+ */
+export declare function getWalletInfo(): BISSession | null;
+/**
+ * Clears the wallet information from local storage. The clearWalletInfo function removes the data stored under the LS_KEY in local storage, effectively clearing any persisted wallet information. This can be used when a user wants to disconnect their wallet or reset their session, ensuring that no wallet data remains stored in the browser after the operation is performed.
+ */
+export declare function clearWalletInfo(): void;
+export interface BISSwapWalletInfo {
+    swapPubkey: string;
+    swapPrivkey: string;
+    bitcoinAddress: string;
+}
+/**
+ * Saves the swap wallet information securely in IndexedDB. The saveSwapWalletInfo function takes a SwapWalletInfo object containing the swap public key, private key, and associated Bitcoin address. It generates a random encryption key and initialization vector (IV) to encrypt the private key using AES-GCM encryption. The encrypted private key, along with the IV, encryption key, swap public key, and Bitcoin address, are then stored in IndexedDB for secure retrieval later. This approach ensures that sensitive wallet information is protected while still allowing for necessary access when needed.
+ *
+ * @param data The SwapWalletInfo object containing the swap public key, private key, and associated Bitcoin address. The function encrypts the private key using AES-GCM encryption with a randomly generated key and IV, and then stores the encrypted data along with the necessary information for decryption in IndexedDB. This allows for secure storage of sensitive wallet information while still enabling retrieval when needed.
+ */
+export declare function saveSwapWalletInfo(data: BISSwapWalletInfo): Promise<void>;
+/**
+ * Reads the swap wallet information from IndexedDB. The readSwapWalletInfo function takes a Bitcoin address as an argument and retrieves the corresponding encrypted wallet information from IndexedDB. It then decrypts the private key using the stored encryption key and IV, returning the swap public key, decrypted private key, and associated Bitcoin address as a SwapWalletInfo object. If no matching record is found or if decryption fails, it returns null. This function allows for secure retrieval of wallet information while ensuring that sensitive data remains protected.
+ *
+ * @param bitcoinAddressToRead The Bitcoin address for which to read the swap wallet information. The function looks up the encrypted wallet information associated with this Bitcoin address in IndexedDB, decrypts the private key using the stored encryption key and IV, and returns the swap public key, decrypted private key, and Bitcoin address as a SwapWalletInfo object. If no matching record is found or if decryption fails, it returns null, ensuring that sensitive wallet information is handled securely.
+ * @returns A promise that resolves to a SwapWalletInfo object containing the swap public key, decrypted private key, and associated Bitcoin address if the information is successfully retrieved and decrypted, or null if no matching record is found or if decryption fails. This allows for secure access to wallet information while maintaining the confidentiality of sensitive data.
+ */
+export declare function readSwapWalletInfo(bitcoinAddressToRead: string): Promise<BISSwapWalletInfo | null>;
+/**
+ * Deletes the swap wallet information associated with the given Bitcoin address from IndexedDB. The deleteSwapWalletInfo function takes a Bitcoin address as an argument and removes the corresponding record from IndexedDB, effectively deleting the stored swap wallet information. This can be used when a user wants to remove their wallet data or when it is no longer needed, ensuring that sensitive information is properly cleaned up from storage.
+ *
+ * @param bitcoinAddress The Bitcoin address for which to delete the swap wallet information. The function looks up the record associated with this Bitcoin address in IndexedDB and deletes it, effectively removing the stored swap wallet information. This allows for proper cleanup of sensitive data when it is no longer needed or when a user wants to remove their wallet information from storage.
+ */
+export declare function deleteSwapWalletInfo(bitcoinAddress: string): Promise<void>;

package/dist/types/core.d.ts

@@ -0,0 +1,10 @@
+export * as wallet from './api/wallet';
+export * as swap from './api/swap';
+export * as brc20 from './api/brc20';
+export * as mint from './api/mint';
+export * as balances from './api/balances';
+export * from './api/helpers';
+export { getNetwork, setNetwork, subscribeToNetwork } from './core/store-network';
+export type { PaymentOpts } from './types/common';
+export * as bitcoinjs from 'bitcoinjs-lib';
+export * as Buff from '@cmdcode/buff-utils';

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

@@ -0,0 +1,8 @@
+import * as bitcoinjs from 'bitcoinjs-lib';
+/**
+ * Get the Bitcoin network parameters based on the current network.
+ * This is used for address generation and transaction creation.
+ *
+ * @returns {bitcoinjs.Network} The Bitcoin network parameters for the current network.
+ */
+export declare function getBitcoinNetwork(): bitcoinjs.Network;

package/dist/types/lib/dev-worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import { ClassValue } from 'clsx';
+/**
+ * Utility function to combine class names conditionally. The cn function takes any number of class name inputs
+ * and merges them into a single string, resolving conflicts according to Tailwind CSS rules.
+ *
+ * @param inputs A variable number of class name inputs, which can be strings, arrays, or objects. The clsx function processes these inputs to determine which class names should be included based on their truthiness and structure. The twMerge function then takes the resulting class string and merges any conflicting Tailwind CSS classes according to its rules, ensuring that the final output is a clean and optimized string of class names.
+ * @returns {string} A single string of combined class names, with duplicates merged according to Tailwind CSS rules. This function is useful for conditionally applying class names in a clean and efficient way, especially when working with Tailwind CSS, as it ensures that conflicting classes are resolved correctly.
+ */
+export declare function cn(...inputs: ClassValue[]): string;

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

@@ -0,0 +1,7 @@
+/**
+ * The constant-product pool fee, in basis points. Charged by the pool on the way
+ * in and already baked into the amounts `getAmountOut`/`getAmountIn` return, via
+ * their 997/1000 factor — keep the two in step if either ever changes. The
+ * `POOL_FEE_BPS` unit test pins this to that factor, so drift fails the build.
+ */
+export declare const POOL_FEE_BPS = 30n;