@bestinslot/wallet-kit 0.7.0

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

@@ -0,0 +1,229 @@
+/**
+ * Compresses the input hex string using both Zstd and Nada compression algorithms, and returns the shortest result encoded in base64 without padding.
+ *
+ * @param inputHex - The input data in hexadecimal string format to be compressed.
+ * @returns A base64 encoded string representing the compressed data, prefixed with a byte indicating the compression method used (0x00 for uncompressed, 0x01 for Nada, 0x02 for Zstd), and without any padding characters.
+ */
+export declare function compressSmartContractData(inputHex: string): Promise<string>;
+/**
+ * Encodes a function call to a smart contract using the provided ABI and function name, along with the parameters for the function call. This function uses the Web3 library to create a contract instance and encode the function call data according to the ABI specification. It also includes error handling to ensure that the specified function exists in the ABI and that the parameters are correctly formatted.
+ *
+ * @param abi - The ABI of the smart contract, which defines the functions and their parameters.
+ * @param functionName - The name of the function to call on the smart contract.
+ * @param params - An array of parameters to be passed to the function call, which should match the types defined in the ABI for the specified function.
+ * @returns A hexadecimal string representing the encoded function call data, which can be included in a transaction to call the smart contract function. The encoding is done according to the ABI specification, and the resulting string can be used as the calldata for a transaction.
+ * @throws Will throw an error if the specified function name does not exist in the ABI or if the parameters do not match the expected types defined in the ABI for that function. It will also throw an error if there is an issue with the Web3 library during encoding.
+ */
+export declare function evmEncodeFunctionCall(abi: any, functionName: string, params: any): string;
+export declare function getEvmAddressFromBitcoinAddress(bitcoinAddress: string): string;
+export declare function getEvmAddressFromPkScript(pkscript: string): string;
+/**
+ * Deploys a smart contract by creating an inscription with the provided input data and sending it to the OP_RETURN output. The function first compresses the input data, then creates an inscription with the compressed data and mints it. After minting, it sends the inscription to an OP_RETURN output with a specific format. The function also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param inputHex - The input data for the smart contract deployment, represented as a hexadecimal string. This data will be compressed and included in the inscription.
+ * @param estimatedGas - The estimated gas required for the smart contract deployment, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the deployment process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the deployment process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function deploySmartContract(inputHex: string, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Deploys a smart contract using the provided bytecode and ABI by creating an inscription with the encoded deployment data and sending it to the OP_RETURN output. The function first encodes the deployment data using the ABI and bytecode, then creates an inscription with the encoded data and mints it. After minting, it sends the inscription to an OP_RETURN output with a specific format. The function also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param bytecode - The bytecode of the smart contract to be deployed, represented as a hexadecimal string. This bytecode will be encoded with the ABI and included in the inscription.
+ * @param abi - The ABI of the smart contract, used to encode the deployment data along with the bytecode.
+ * @param params - An array of parameters to be passed to the contract constructor, which will be encoded along with the bytecode using the ABI.
+ * @param estimatedGas - The estimated gas required for the smart contract deployment, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the deployment process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the deployment process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function deploySmartContractAbi(bytecode: string, abi: any, params: any, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Calls a smart contract function by creating an inscription with the provided input data and sending it to the OP_RETURN output. The function first compresses the input data, then creates an inscription with the compressed data and mints it. After minting, it sends the inscription to an OP_RETURN output with a specific format. The function also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param smartContractContractAddr - The address of the smart contract to call, represented as a string. This address will be included in the inscription content to indicate which contract function is being called.
+ * @param inputHex - The input data for the smart contract function call, represented as a hexadecimal string. This data will be compressed and included in the inscription.
+ * @param estimatedGas - The estimated gas required for the smart contract function call, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the function call process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the function call process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function callSmartContract(smartContractContractAddr: string, inputHex: string, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Calls a smart contract function by creating an inscription with the encoded function call data and sending it to the OP_RETURN output. The function takes the smart contract address, ABI, function name, and parameters, encodes the function call using the ABI, and then follows a similar process as `deploySmartContract` to create and send the inscription. It also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param smartContractContractAddr - The address of the smart contract to call, represented as a string. This address will be included in the inscription content to indicate which contract function is being called.
+ * @param abi - The ABI of the smart contract, used to encode the function call data along with the function name and parameters.
+ * @param funcName - The name of the function to call on the smart contract, represented as a string. This will be used along with the ABI to encode the function call data.
+ * @param params - An array of parameters to be passed to the contract function, which will be encoded using the ABI along with the function name.
+ * @param estimatedGas - The estimated gas required for the smart contract function call, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the function call process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the function call process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function callSmartContractAbi(smartContractContractAddr: string, abi: any, funcName: string, params: any, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Calls a smart contract function by creating an inscription with the provided input data and sending it to the OP_RETURN output. The function first compresses the input data, then creates an inscription with the compressed data and mints it. After minting, it sends the inscription to an OP_RETURN output with a specific format. The function also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param smartContractContractAddr - The address of the smart contract to call, represented as a string. This address will be included in the inscription content to indicate which contract function is being called.
+ * @param inputHex - The input data for the smart contract function call, represented as a hexadecimal string. This data will be compressed and included in the inscription.
+ * @param estimatedGas - The estimated gas required for the smart contract function call, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the function call process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the function call process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ * @throws Will throw an error if the wallet is not connected, if the input parameters are of incorrect types, or if there is a failure in creating or sending the inscription.
+ */
+export declare function callSmartContractFromPaymentWallet(smartContractContractAddr: string, inputHex: string, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Calls a smart contract function using the provided ABI and function name by encoding the function call data, creating an inscription with the encoded data, and sending it to the OP_RETURN output. The function takes the smart contract address, ABI, function name, and parameters, encodes the function call using the ABI, and then follows a similar process as `callSmartContract` to create and send the inscription. It also handles optional payment parameters and allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param smartContractContractAddr - The address of the smart contract to call, represented as a string. This address will be included in the inscription content to indicate which contract function is being called.
+ * @param abi - The ABI of the smart contract, used to encode the function call data along with the function name and parameters.
+ * @param funcName - The name of the function to call on the smart contract, represented as a string. This will be used along with the ABI to encode the function call data.
+ * @param params - An array of parameters to be passed to the contract function, which will be encoded using the ABI along with the function name.
+ * @param estimatedGas - The estimated gas required for the smart contract function call, used to determine if padding is needed for the inscription content.
+ * @param gasPerVbyte - The gas cost per virtual byte, used to calculate the total gas cost of the inscription content and determine if padding is needed.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the function call process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the function call process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function callSmartContractAbiFromPaymentWallet(smartContractContractAddr: string, abi: any, funcName: string, params: any, estimatedGas: number, gasPerVbyte: number, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Deposits a BRC-20 token into the BRC2.0 programmable module by creating an inscription with the transfer operation and sending it to the OP_RETURN output. The function takes the token tick, amount, fee rate, and optional payment parameters, creates an inscription with the transfer operation, mints it, and then sends it to an OP_RETURN output with a specific format. It also allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param tick - The tick of the BRC-20 token to be deposited, represented as a string. This will be included in the inscription content to indicate which token is being transferred.
+ * @param amount - The amount of the BRC-20 token to be deposited, represented as a string. This will be included in the inscription content to indicate how many tokens are being transferred.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the deposit process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the deposit process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function depositToBrc20Prog(tick: string, amount: string, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    sendToOpReturnTxId: string;
+    signedSendToOpReturnTxHex: string;
+}>;
+/**
+ * Withdraws a BRC-20 token from the BRC2.0 programmable module by creating an inscription with the transfer operation and sending it to the target address. The function takes the token tick, amount, target address, fee rate, and optional payment parameters, creates an inscription with the transfer operation, mints it, and then sends it to the target address. It also allows for a dry run mode where the transaction hexes are returned without broadcasting.
+ *
+ * @param tick - The tick of the BRC-20 token to be withdrawn, represented as a string. This will be included in the inscription content to indicate which token is being transferred.
+ * @param amount - The amount of the BRC-20 token to be withdrawn, represented as a string. This will be included in the inscription content to indicate how many tokens are being transferred.
+ * @param targetAddr - The Bitcoin address to which the withdrawn BRC-20 tokens should be sent, represented as a string. This will be used as the destination for the inscription after minting.
+ * @param feeRate - The fee rate in sats/vbyte to be used for the transactions involved in the withdrawal process.
+ * @param postage - An optional parameter representing the postage to be included in the minting transaction, specified in sats. If null, no postage will be included.
+ * @param paymentAddr - An optional parameter representing the Bitcoin address to which payment should be sent for the minting transaction. If null, no payment will be made.
+ * @param payment - An optional parameter representing the amount of payment to be sent for the minting transaction, specified in sats. If null or less than or equal to 0, no payment will be made.
+ * @param dryRun - A boolean flag indicating whether to perform a dry run. If true, the function will return the transaction hexes without broadcasting them to the network. If false, the transactions will be broadcasted after creation.
+ *
+ * @returns An object containing details of the withdrawal process, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. If dryRun is true, the transactions will not be broadcasted and the hexes will be returned for inspection.
+ */
+export declare function withdrawFromBrc20Prog(tick: string, amount: string, targetAddr: string, feeRate: number, postage: number | null, paymentAddr: string | null, payment: number | null, dryRun: boolean): Promise<{
+    commitTxId: string;
+    signedCommitTxHex: string;
+    revealTxId: string;
+    signedRevealTxHex: string;
+    inscriptionId: string;
+    postage: number;
+    secret: string;
+    transferTxId: string;
+    signedTransferTxHex: string;
+}>;

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

@@ -0,0 +1,15 @@
+import { BISSession } from '../types/common';
+/**
+ * Creates the modal instance without showing it.
+ */
+export declare function init(): void;
+/**
+ * Shows the connect modal and resolves with the selected wallet session.
+ *
+ * @returns A promise that resolves with the session when a wallet connects, or rejects on error.
+ */
+export declare function connect(): Promise<BISSession>;
+/**
+ * Disconnects the current wallet: hides the modal and clears the stored session.
+ */
+export declare function disconnect(): void;

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

@@ -0,0 +1,212 @@
+import * as bitcoinjs from 'bitcoinjs-lib';
+export declare const txHexByIdCache: {
+    [txid: string]: any;
+};
+/**
+ * Creates an unsecured JWT token with the given payload.
+ *
+ * @param payload - The payload to include in the token.
+ * @returns The unsecured JWT token as a string.
+ */
+export declare function createUnsecuredToken(payload: any): string;
+/**
+ * Converts a base64-encoded string to a hexadecimal string.
+ * @param str The base64-encoded string to convert.
+ * @returns The hexadecimal representation of the input string.
+ */
+export declare function base64ToHex(str: string): string;
+/**
+ * Converts a hexadecimal string to a base64-encoded string.
+ *
+ * @param hexstring The hexadecimal string to convert.
+ * @returns The base64-encoded representation of the input hexadecimal string.
+ */
+export declare function hexToBase64(hexstring: string): string;
+/**
+ * Finalizes every input of a signed PSBT, skipping the given indexes. Throws if
+ * an input cannot be finalized, so an incompletely-finalized (invalid) PSBT is
+ * never extracted and broadcast.
+ *
+ * @param psbt The signed PSBT to finalize in place.
+ * @param noSignIdxes Input indexes to skip (intentionally left unfinalized).
+ */
+export declare function finalizePsbtInputs(psbt: bitcoinjs.Psbt, noSignIdxes?: number[]): void;
+/**
+ * Saves extra UTXOs that are currently being used in transactions but not yet confirmed on the blockchain.
+ *
+ * @param txHexes An array of transaction hex strings representing the transactions that are currently being processed.
+ * @param inscription An optional array containing inscription details, where the first element is the inscription ID and the second element is the satpoint.
+ */
+export declare function saveExtraUtxos(txHexes: string[], inscription: string[] | null): void;
+/**
+ * Retrieves the currently saved extra UTXOs that are being used in transactions but not yet confirmed on the blockchain.
+ */
+export declare function clearExtraUtxos(): void;
+/**
+ * Determines the type of a UTXO output based on its output script and the Bitcoin network parameters.
+ *
+ * @param output The output script of the UTXO to analyze.
+ * @param network The Bitcoin network parameters to use for interpreting the output script (e.g., mainnet, testnet).
+ * @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';
+/**
+ * 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;
+export interface APIUtxoInfo {
+    address: string;
+    amounts: number[] | null;
+    block_height: number | null;
+    inscription_ids: string[] | null;
+    rune_ids: string[] | null;
+    satpoints: string[] | null;
+    script: string;
+    script_type: 'pubkeyhash' | 'scripthash' | 'witness_v0_keyhash' | 'witness_v0_scripthash' | 'witness_v1_taproot' | 'pubkey' | 'anchor' | 'witness_unknown' | 'nulldata' | 'multisig' | 'nonstandard';
+    txfee: number | null;
+    txid: string;
+    utxo: string;
+    value: number;
+    vout: number;
+    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.
+ *
+ * @param addr The address for which to fetch the UTXOs.
+ * @returns A promise that resolves to an array of UTXO information objects.
+ */
+export declare function getCardinalUtxos(addr: string): Promise<APIUtxoInfo[]>;
+/**
+ * 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.
+ *
+ * @param address The address for which to fetch the balance.
+ * @returns The total balance of the address in satoshis.
+ */
+export declare function getCardinalBalance(address: string): Promise<number>;
+export interface AllBalanceDetails {
+    confirmed_balance: number;
+    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.
+ *
+ * @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.
+ */
+export interface APIOrdinalUtxoInfo {
+    address: string;
+    amounts: number[] | null;
+    block_height: number | null;
+    inscription_ids: string[];
+    rune_ids: string[] | null;
+    satpoints: string[];
+    script: string;
+    script_type: 'pubkeyhash' | 'scripthash' | 'witness_v0_keyhash' | 'witness_v0_scripthash' | 'witness_v1_taproot' | 'pubkey' | 'anchor' | 'witness_unknown' | 'nulldata' | 'multisig' | 'nonstandard';
+    txfee: number | null;
+    txid: string;
+    utxo: string;
+    value: number;
+    vout: number;
+    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.
+ *
+ * @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[]>;
+/**
+ * Fetches the raw transaction hex for a given transaction ID from the backend API. It caches the result to avoid redundant network requests.
+ *
+ * @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.
+ *
+ * @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.
+ */
+export declare function validateTxes(txHexes: string[]): Promise<any>;
+/**
+ * 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.
+ *
+ * @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.
+ * @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>;
+/**
+ * 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.
+ *
+ * @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.
+ */
+export declare function verifySignature(message: string, signatureHex: string, address: string): Promise<boolean>;
+/**
+ * Locally verifies a signature for a given message, signature, and address using the bip322-js library. The function converts the signature from hexadecimal to base64 format and then uses the Verifier class from the bip322-js library to perform the verification against the provided message and address.
+ *
+ * @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 boolean indicating whether the signature is valid for the given message and address.
+ * @throws An error if the verification process fails, such as due to invalid input parameters.
+ */
+export declare function verifySignatureLocal(message: string, signatureHex: string, address: string): boolean;
+/**
+ * Fetches the current chain tip (the latest block height) from the backend API. The function sends a request to the backend to retrieve the current chain tip and returns it as a number. If the request fails, it throws an error indicating that the chain tip could not be retrieved.
+ *
+ * @returns A promise that resolves to the current chain tip (latest block height) as a number, or throws an error if the request fails.
+ * @throws An error if the request to fetch the chain tip fails, indicating that the chain tip could not be retrieved.
+ */
+export declare function getChainTip(): Promise<number>;
+/**
+ * A generic helper function to handle fetch requests with consistent error handling.
+ * It automatically checks for non-ok HTTP responses and for an 'error' field
+ * in the JSON response body, throwing a descriptive error in either case.
+ *
+ * @param url The URL to fetch.
+ * @param options The standard RequestInit options for the fetch call.
+ * @returns A promise that resolves with the parsed JSON data of type T.
+ * @throws {Error} Throws an error if the network request fails, the HTTP
+ * status is not ok, or the response body contains an error field.
+ */
+export declare function fetchWithErrors<T>(url: string, options: RequestInit): Promise<T>;
+/**
+ * Retrieves the appropriate BRC2.0 public RPC URL based on the current network (signet or mainnet). The function checks the current network using the getNetwork function and returns the corresponding public RPC URL for that network. If the network is not supported, it throws an error indicating that the network is unsupported for the public RPC URL.
+ *
+ * @returns The public RPC URL corresponding to the current network (signet or mainnet).
+ */
+export declare function getPublicRpcUrl(): string;
+/**
+ * Executes an eth_call on the appropriate public RPC URL based on the current network (signet or mainnet). The function constructs the JSON-RPC request payload with the provided data and sends it to the public 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.
+ *
+ * @param to The address of the contract to call.
+ * @param abi The ABI of the contract to call.
+ * @param functionName The name of the function to call on the contract.
+ * @param params The parameters to pass to the function being called on the contract.
+ * @returns A promise that resolves to the result of the eth_call as a string, or throws an error if the request fails.
+ */
+export declare function ethCallOnPublicRpc(to: string, abi: any, functionName: string, params: any): Promise<string>;
+/**
+ * Constructs the appropriate backend URL for a given API path based on the current network (signet or mainnet). The function checks the current network using the getNetwork function and returns the corresponding URL for the swap backend API. If the network is not supported, it throws an error indicating that the network is unsupported for the orderbook backend URL.
+ *
+ * @param path The specific API path to append to the base URL for the swap backend.
+ * @returns The full URL for the swap backend API corresponding to the current network and the provided path.
+ */
+export declare function getSwapBackendUrl(path: string): string;