@meshsdk/wallet 1.9.0 → 2.0.0-beta.10

package/dist/index.d.ts

@@ -1,7 +1,151 @@
-import { DataSignature, ISigner, ISubmitter, IFetcher, IWallet, Wallet, Extension, Asset, UTxO, AssetExtended } from '@meshsdk/common';
-import { Ed25519PublicKeyHex, TransactionUnspentOutput, Address, Ed25519PrivateKey, DRepID, Ed25519KeyHashHex, VkeyWitness } from '@meshsdk/core-cst';
-import * as _simplewebauthn_browser from '@simplewebauthn/browser';
+import { DataSignature, Extension as Extension$1, UTxO as UTxO$1, Asset, IFetcher, ISubmitter } from '@meshsdk/common';
+import { Network, Signer, Psbt } from 'bitcoinjs-lib';
+import { BIP32Interface } from 'bip32';
 
+interface ISigner {
+    getPublicKey(): Promise<string>;
+    getPublicKeyHash(): Promise<string>;
+    sign(data: string): Promise<string>;
+    verify(data: string, signature: string): Promise<boolean>;
+}
+
+type DerivationPath = number[] | string;
+interface ISecretManager {
+    getPublicKey(derivationPath: DerivationPath): Promise<string>;
+    getSigner(derivationPath: DerivationPath): Promise<ISigner>;
+}
+
+declare class CardanoInMemoryBip32 implements ISecretManager {
+    private bip32PrivateKey;
+    private constructor();
+    static fromMnemonic(mnemonic: string[], password?: string): Promise<CardanoInMemoryBip32>;
+    static fromEntropy(entropy: string, password?: string): Promise<CardanoInMemoryBip32>;
+    static fromKeyHex(keyHex: string): CardanoInMemoryBip32;
+    static fromBech32(bech32: string): CardanoInMemoryBip32;
+    /**
+     * Get the Bip32 public key in hex format.
+     * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+     */
+    getPublicKey(): Promise<string>;
+    /**
+     * Get an ISigner instance initialized with the current Bip32 private key.
+     * @returns {Promise<ISigner>} A promise that resolves to an ISigner instance initialized with the current Bip32 private key.
+     */
+    getSigner(derivationPath: DerivationPath): Promise<ISigner>;
+}
+
+declare class BitcoinInMemoryBip32 {
+    private root;
+    private constructor();
+    static fromMnemonic(mnemonic: string[], password?: string): Promise<BitcoinInMemoryBip32>;
+    static fromEntropy(entropy: string, password?: string): Promise<BitcoinInMemoryBip32>;
+    /**
+     * Get the private key (hex) for the provided derivation path.
+     */
+    getPrivateKey(derivationPath: DerivationPath): string;
+    /**
+     * Get the public key (hex) for the provided derivation path.
+     */
+    getPublicKey(derivationPath: DerivationPath): string;
+}
+
+/**
+ * BaseSigner provides functionalities to sign and verify data using Ed25519 keys.
+ * It supports construction from both extended and normal private key hex formats.
+ */
+declare class BaseSigner implements ISigner {
+    private ed25519PrivateKey;
+    private constructor();
+    /**
+     * Create a BaseSigner instance from an Ed25519 private key in extended hex format.
+     * @param keyHex Ed25519 private key in extended hex format
+     * @returns {BaseSigner} A BaseSigner instance
+     */
+    static fromExtendedKeyHex(keyHex: string): BaseSigner;
+    /**
+     * Create a BaseSigner instance from an Ed25519 private key in normal hex format.
+     * @param keyHex Ed25519 private key in normal hex format
+     * @returns {BaseSigner} A BaseSigner instance
+     */
+    static fromNormalKeyHex(keyHex: string): BaseSigner;
+    static fromKeyHex(keyHex: string): BaseSigner;
+    /**
+     * Get the Ed25519 public key in hex format.
+     * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+     */
+    getPublicKey(): Promise<string>;
+    /**
+     * Get the Ed25519 public key hash in hex format.
+     * @returns {Promise<string>} A promise that resolves to the public key hash in hex format.
+     */
+    getPublicKeyHash(): Promise<string>;
+    /**
+     * Sign data using the Ed25519 private key.
+     * @param data data to be signed in hex format
+     * @returns {Promise<string>} A promise that resolves to the signature in hex format.
+     */
+    sign(data: string): Promise<string>;
+    /**
+     * Verify a signature using the Ed25519 public key.
+     * @param data The original data in hex format.
+     * @param signature The signature to verify in hex format.
+     * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
+     */
+    verify(data: string, signature: string): Promise<boolean>;
+}
+
+declare enum CredentialType {
+    KeyHash = 0,
+    ScriptHash = 1
+}
+type Credential = {
+    type: CredentialType;
+    hash: string;
+};
+declare enum AddressType$1 {
+    Enterprise = 0,
+    Base = 1,
+    Reward = 2
+}
+declare class CardanoAddress {
+    addressType: AddressType$1;
+    networkId: number;
+    paymentCredential: Credential;
+    stakeCredential?: Credential;
+    constructor(addressType: AddressType$1, networkId: number, paymentCredential: Credential, stakeCredential?: Credential);
+    getAddressBech32(): string;
+    getAddressHex(): string;
+    private getEnterpriseAddressBech32;
+    private getEnterpriseAddressHex;
+    private getBaseAddressBech32;
+    private getBaseAddressHex;
+    private getRewardAddressBech32;
+    private getRewardAddressHex;
+}
+
+interface ICardanoWallet {
+    getExtensions(): Promise<{
+        cip: number;
+    }[]>;
+    getNetworkId(): Promise<number>;
+    getUtxos(): Promise<string[]>;
+    getCollateral(): Promise<string[]>;
+    getBalance(): Promise<string>;
+    getUsedAddresses(): Promise<string[]>;
+    getUnusedAddresses(): Promise<string[]>;
+    getRewardAddresses(): Promise<string[]>;
+    getChangeAddress(): Promise<string>;
+    signTx(data: string, partialSign: boolean): Promise<string>;
+    signData(addressHex: string, data: string): Promise<DataSignature>;
+    submitTx(tx: string): Promise<string>;
+}
+
+type Wallet = {
+    id: string;
+    name: string;
+    icon: string;
+    version: string;
+};
 type Cardano = {
     [key: string]: {
         name: string;
@@ -11,130 +155,32 @@ type Cardano = {
             extensions: {
                 cip: number;
             }[];
-        }) => Promise<WalletInstance>;
+        }) => Promise<ICardanoWallet>;
         supportedExtensions?: {
             cip: number;
         }[];
     };
 };
-type TransactionSignatureRequest = {
-    cbor: string;
-    partialSign: boolean;
+type Extension = {
+    cip: number;
 };
-interface Cip30WalletApi {
-    experimental: ExperimentalFeatures;
-    getBalance(): Promise<string>;
-    getChangeAddress(): Promise<string>;
+declare class CardanoBrowserWallet implements ICardanoWallet {
+    walletInstance: ICardanoWallet;
+    constructor(walletInstance: ICardanoWallet);
     getExtensions(): Promise<{
         cip: number;
     }[]>;
-    getCollateral(): Promise<string[] | undefined>;
     getNetworkId(): Promise<number>;
-    getRewardAddresses(): Promise<string[]>;
-    getUnusedAddresses(): Promise<string[]>;
+    getUtxos(): Promise<string[]>;
+    getCollateral(): Promise<string[]>;
+    getBalance(): Promise<string>;
     getUsedAddresses(): Promise<string[]>;
-    getUtxos(): Promise<string[] | undefined>;
-    signData(address: string, payload: string): Promise<DataSignature>;
-    signTx(tx: string, partialSign: boolean): Promise<string>;
-    signTxs?(txs: TransactionSignatureRequest[]): Promise<string[]>;
-    signTxs?(txs: string[], partialSign: boolean): Promise<string[]>;
-    submitTx(tx: string): Promise<string>;
-    cip95?: Cip95WalletApi;
-}
-interface Cip95WalletApi {
-    getRegisteredPubStakeKeys: () => Promise<Ed25519PublicKeyHex[]>;
-    getUnregisteredPubStakeKeys: () => Promise<Ed25519PublicKeyHex[]>;
-    getPubDRepKey: () => Promise<Ed25519PublicKeyHex>;
-    signData(address: string, payload: string): Promise<DataSignature>;
-}
-type WalletInstance = Cip30WalletApi & Cip95WalletApi;
-type ExperimentalFeatures = {
-    getCollateral(): Promise<string[] | undefined>;
-    signTxs?(txs: TransactionSignatureRequest[]): Promise<string[]>;
-    signTxs?(txs: string[], partialSign: boolean): Promise<string[]>;
-};
-type GetAddressType = "enterprise" | "payment";
-
-type AppWalletKeyType = {
-    type: "root";
-    bech32: string;
-} | {
-    type: "cli";
-    payment: string;
-    stake?: string;
-} | {
-    type: "mnemonic";
-    words: string[];
-};
-type CreateAppWalletOptions = {
-    networkId: number;
-    fetcher?: IFetcher;
-    submitter?: ISubmitter;
-    key: AppWalletKeyType;
-};
-declare class AppWallet implements ISigner, ISubmitter {
-    private readonly _fetcher?;
-    private readonly _submitter?;
-    private readonly _wallet;
-    constructor(options: CreateAppWalletOptions);
-    /**
-     * Initializes the wallet. This is a required call as fetching addresses from the wallet is an async operation.
-     * @returns void
-     */
-    init(): Promise<void>;
-    /**
-     * Get a list of UTXOs to be used as collateral inputs for transactions with plutus script inputs.
-     *
-     * This is used in transaction building.
-     *
-     * @returns a list of UTXOs
-     */
-    getCollateralUnspentOutput(accountIndex?: number, addressType?: GetAddressType): Promise<TransactionUnspentOutput[]>;
-    getEnterpriseAddress(accountIndex?: number, keyIndex?: number): string;
-    getPaymentAddress(accountIndex?: number, keyIndex?: number): string;
-    getRewardAddress(accountIndex?: number, keyIndex?: number): string;
-    getNetworkId(): number;
-    getUsedAddress(accountIndex?: number, keyIndex?: number, addressType?: GetAddressType): Address;
-    getUnspentOutputs(accountIndex?: number, addressType?: GetAddressType): Promise<TransactionUnspentOutput[]>;
-    signData(address: string, payload: string, accountIndex?: number, keyIndex?: number): Promise<DataSignature>;
-    signTx(unsignedTx: string, partialSign?: boolean, returnFullTx?: boolean, accountIndex?: number, keyIndex?: number): Promise<string>;
-    signTxSync(unsignedTx: string, partialSign?: boolean, accountIndex?: number, keyIndex?: number): string;
-    signTxs(unsignedTxs: string[], partialSign: boolean): Promise<string[]>;
+    getUnusedAddresses(): Promise<string[]>;
+    getRewardAddresses(): Promise<string[]>;
+    getChangeAddress(): Promise<string>;
+    signTx(data: string, partialSign: boolean): Promise<string>;
+    signData(addressBech32: string, data: string): Promise<DataSignature>;
     submitTx(tx: string): Promise<string>;
-    static brew(strength?: number): string[];
-}
-
-declare global {
-    interface Window {
-        cardano: Cardano;
-    }
-}
-/**
- * Browser Wallet provides a set of APIs to interact with the blockchain. This wallet is compatible with Mesh transaction builders.
- *
- * These wallets APIs are in accordance to CIP-30, which defines the API for apps to communicate with the user's wallet. Additional utility functions provided for developers that are useful for building applications.
- * ```javascript
- * import { BrowserWallet } from '@meshsdk/core';
- *
- * const wallet = await BrowserWallet.enable('eternl');
- * ```
- */
-declare class BrowserWallet implements IWallet {
-    readonly _walletInstance: WalletInstance;
-    readonly _walletName: string;
-    walletInstance: WalletInstance;
-    private constructor();
-    /**
-     * Returns a list of wallets installed on user's device. Each wallet is an object with the following properties:
-     * - A name is provided to display wallet's name on the user interface.
-     * - A version is provided to display wallet's version on the user interface.
-     * - An icon is provided to display wallet's icon on the user interface.
-     *
-     * @returns a list of wallet names
-     */
-    static getAvailableWallets({ injectFn, }?: {
-        injectFn?: () => Promise<void>;
-    }): Promise<Wallet[]>;
     /**
      * Returns a list of wallets installed on user's device. Each wallet is an object with the following properties:
      * - A name is provided to display wallet's name on the user interface.
@@ -153,650 +199,1061 @@ declare class BrowserWallet implements IWallet {
      * @param extensions - optional, a list of CIPs that the wallet should support
      * @returns WalletInstance
      */
-    static enable(walletName: string, extensions?: Extension[]): Promise<BrowserWallet>;
+    static enable(walletName: string, extensions?: Extension[]): Promise<ICardanoWallet>;
+}
+
+declare class MeshCardanoBrowserWallet extends CardanoBrowserWallet {
+    constructor(walletInstance: ICardanoWallet);
+    static enable(walletName: string, extensions?: Extension$1[]): Promise<MeshCardanoBrowserWallet>;
+    getUtxosMesh(): Promise<UTxO$1[]>;
+    getCollateralMesh(): Promise<UTxO$1[]>;
+    getBalanceMesh(): Promise<Asset[]>;
+    getUsedAddressesBech32(): Promise<string[]>;
+    getUnusedAddressesBech32(): Promise<string[]>;
+    getChangeAddressBech32(): Promise<string>;
+    getRewardAddressesBech32(): Promise<string[]>;
+    signTxReturnFullTx(tx: string, partialSign?: boolean): Promise<string>;
+}
+
+type CredentialSource = {
+    type: "signer";
+    signer: ISigner;
+} | {
+    type: "scriptHash";
+    scriptHash: string;
+};
+interface AddressManagerConfig {
+    addressSource: AddressSource;
+    networkId: number;
+}
+type AddressSource = {
+    type: "secretManager";
+    secretManager: ISecretManager;
+} | {
+    type: "credentials";
+    paymentCredential: CredentialSource;
+    stakeCredential?: CredentialSource;
+    drepCredential?: CredentialSource;
+};
+declare class AddressManager {
+    private readonly paymentCredential;
+    private readonly stakeCredential;
+    private readonly drepCredential;
+    private readonly paymentSigner;
+    private readonly stakeSigner?;
+    private readonly drepSigner?;
+    private readonly networkId;
+    static create(config: AddressManagerConfig): Promise<AddressManager>;
+    private constructor();
+    getNextAddress(addressType: AddressType$1): Promise<CardanoAddress>;
+    getChangeAddress(addressType: AddressType$1): Promise<CardanoAddress>;
+    getRewardAccount(): Promise<CardanoAddress>;
+    asyncGetAllUsedAddresses(): Promise<CardanoAddress[]>;
+    getCredentialsSigners(pubkeyHashes: Set<string>): Promise<Map<string, ISigner>>;
+}
+
+type WalletAddressType = AddressType$1.Base | AddressType$1.Enterprise;
+/**
+ * Configuration for creating a CardanoHeadlessWallet instance.
+ */
+interface CardanoHeadlessWalletConfig {
+    /**
+     * The source for wallet's signing keys and addresses. Could either be a secret manager or explicit credentials.
+     */
+    addressSource: AddressSource;
     /**
-     * Returns a list of assets in the wallet. This API will return every assets in the wallet. Each asset is an object with the following properties:
-     * - A unit is provided to display asset's name on the user interface.
-     * - A quantity is provided to display asset's quantity on the user interface.
-     *
-     * @returns a list of assets and their quantities
+     * The network ID (0 for testnet, 1 for mainnet).
      */
-    getBalance(): Promise<Asset[]>;
+    networkId: number;
     /**
-     * Returns an address owned by the wallet that should be used as a change address to return leftover assets during transaction creation back to the connected wallet.
-     *
-     * @returns an address
+     * The type of wallet address to use (Base or Enterprise).
+     * Base addresses include staking capabilities, while Enterprise addresses do not.
      */
-    getChangeAddress(): Promise<string>;
+    walletAddressType: WalletAddressType;
     /**
-     * This function shall return a list of one or more UTXOs (unspent transaction outputs) controlled by the wallet that are required to reach AT LEAST the combined ADA value target specified in amount AND the best suitable to be used as collateral inputs for transactions with plutus script inputs (pure ADA-only UTXOs).
-     *
-     * If this cannot be attained, an error message with an explanation of the blocking problem shall be returned. NOTE: wallets are free to return UTXOs that add up to a greater total ADA value than requested in the amount parameter, but wallets must never return any result where UTXOs would sum up to a smaller total ADA value, instead in a case like that an error message must be returned.
-     *
-     * @param limit
-     * @returns a list of UTXOs
+     * Optional fetcher instance for querying blockchain data (UTxOs, protocol parameters, etc.).
      */
-    getCollateral(): Promise<UTxO[]>;
+    fetcher?: IFetcher;
     /**
-     * Return a list of supported CIPs of the wallet.
-     *
-     * @returns a list of CIPs
+     * Optional submitter instance for submitting transactions to the blockchain.
      */
-    getExtensions(): Promise<number[]>;
+    submitter?: ISubmitter;
+}
+declare class CardanoHeadlessWallet implements ICardanoWallet {
+    protected networkId: number;
+    protected addressManager: AddressManager;
+    protected fetcher?: IFetcher;
+    protected submitter?: ISubmitter;
+    protected walletAddressType: WalletAddressType;
+    protected constructor(networkId: number, addressManager: AddressManager, walletAddressType: WalletAddressType, fetcher?: IFetcher, submitter?: ISubmitter);
+    static create(config: CardanoHeadlessWalletConfig): Promise<CardanoHeadlessWallet>;
     /**
-     * Returns the network ID of the currently connected account. 0 is testnet and 1 is mainnet but other networks can possibly be returned by wallets. Those other network ID values are not governed by CIP-30. This result will stay the same unless the connected account has changed.
-     *
-     * @returns network ID
+     * Create a CardanoHeadlessWallet instance from a Bip32 root in Bech32 format.
+     * @param config The configuration object
+     * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
+     */
+    static fromBip32Root(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        bech32: string;
+    }): Promise<CardanoHeadlessWallet>;
+    /**
+     * Create a CardanoHeadlessWallet instance from a Bip32 root in hex format.
+     * @param config The configuration object
+     * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
+     */
+    static fromBip32RootHex(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        hex: string;
+    }): Promise<CardanoHeadlessWallet>;
+    /**
+     * Create a CardanoHeadlessWallet instance from a mnemonic phrase.
+     * @param config The configuration object
+     * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
+     */
+    static fromMnemonic(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        mnemonic: string[];
+        password?: string;
+    }): Promise<CardanoHeadlessWallet>;
+    static fromCredentialSources(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        paymentCredentialSource: CredentialSource;
+        stakeCredentialSource?: CredentialSource;
+        drepCredentialSource?: CredentialSource;
+    }): Promise<CardanoHeadlessWallet>;
+    /**
+     * Submit a transaction to the network, using the submitter instance.
+     * @param tx The transaction in CBOR hex format
+     * @returns {Promise<string>} A promise that resolves to the transaction ID
+     */
+    submitTx(tx: string): Promise<string>;
+    /**
+     * Get the list of extensions enabled for this wallet.
+     * @returns {Promise<{ cip: number }[]>} A promise that resolves to an array of enabled extensions
+     */
+    getExtensions(): Promise<{
+        cip: number;
+    }[]>;
+    /**
+     * Get the network ID.
+     * @returns {number} The network ID
      */
     getNetworkId(): Promise<number>;
     /**
-     * Returns a list of reward addresses owned by the wallet. A reward address is a stake address that is used to receive rewards from staking, generally starts from `stake` prefix.
+     * Get the UTxOs for the wallet.
+     *
+     * NOTE: This method is only an approximation to CIP-30 getUtxos, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+     * will be overlap between getUtxos() and getCollateral() results. This can result in the collateral being
+     * spent between transactions.
      *
-     * @returns a list of reward addresses
+     * The method also does not perform pagination, nor is there a coin selection mechanism.
+     * @returns {Promise<string[]>} A promise that resolves to an array of UTxOs in CBOR hex format
      */
-    getRewardAddresses(): Promise<string[]>;
+    getUtxos(): Promise<string[]>;
     /**
-     * Returns a list of unused addresses controlled by the wallet.
+     * Get the collateral UTxOs for the wallet.
      *
-     * @returns a list of unused addresses
+     * NOTE: This method is only an approximation to CIP-30 getCollateral, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+     * will be overlap between getUtxos() and getCollateral() results.
+     *
+     * The basic strategy is to return the smallest pure ADA UTxO that is at least 5 ADA belonging to the wallet.
+     * @returns {Promise<string[]>} A promise that resolves to an array of UTxOs in CBOR hex format
      */
-    getUnusedAddresses(): Promise<string[]>;
+    getCollateral(): Promise<string[]>;
     /**
-     * Returns a list of used addresses controlled by the wallet.
+     * Get the balance of the wallet.
      *
-     * @returns a list of used addresses
+     * NOTE: This method is only an approximation to CIP-30 getBalance, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means the balance
+     * returned includes all UTxOs, including those that may be used as collateral.
+     * @returns {Promise<string>} A promise that resolves to the balance in CBOR hex format
      */
-    getUsedAddresses(): Promise<string[]>;
+    getBalance(): Promise<string>;
     /**
-     * Return a list of all UTXOs (unspent transaction outputs) controlled by the wallet.
+     * Get the used addresses for the wallet.
+     *
+     * NOTE: This method completely deviates from CIP-30 getUsedAddresses, as this wallet is stateless
+     * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
      *
-     * @returns a list of UTXOs
+     * It will be effective to be used as a single address wallet.
+     *
+     * @returns {Promise<string[]>} A promise that resolves to an array of used addresses in hex format
      */
-    getUtxos(): Promise<UTxO[]>;
+    getUsedAddresses(): Promise<string[]>;
     /**
-     * This endpoint utilizes the [CIP-8 - Message Signing](https://cips.cardano.org/cips/cip8/) to sign arbitrary data, to verify the data was signed by the owner of the private key.
+     * Get the unused addresses for the wallet.
      *
-     * @param payload - the data to be signed
-     * @param address - optional, if not provided, the first staking address will be used
-     * @returns a signature
+     * NOTE: This method completely deviates from CIP-30 getUnusedAddresses, as this wallet is stateless
+     * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+     *
+     * It will be effective to be used as a single address wallet.
+     *
+     * @returns {Promise<string[]>} A promise that resolves to an array of unused addresses in hex format
      */
-    signData(payload: string, address?: string | undefined, convertFromUTF8?: boolean): Promise<DataSignature>;
+    getUnusedAddresses(): Promise<string[]>;
     /**
-     * Requests user to sign the provided transaction (tx). The wallet should ask the user for permission, and if given, try to sign the supplied body and return a signed transaction. partialSign should be true if the transaction provided requires multiple signatures.
+     * Get the change address for the wallet.
+     * NOTE: This method deviates from CIP-30 getChangeAddress, as this wallet is stateless
+     * it does not track which addresses has been previously used as change address. This method simply
+     * returns the wallet's main address.
      *
-     * @param unsignedTx - a transaction in CBOR
-     * @param partialSign - if the transaction is signed partially
-     * @param returnFullTx - if the full tx should be returned or only the witness set (default: true)
-     * @returns a signed transaction in CBOR
+     * It will be effective to be used as a single address wallet.
+     *
+     * @returns {Promise<string>} A promise that resolves to the change address in hex format
      */
-    signTx(unsignedTx: string, partialSign?: boolean, returnFullTx?: boolean): Promise<string>;
+    getChangeAddress(): Promise<string>;
     /**
-     * Experimental feature - sign multiple transactions at once (Supported wallet(s): Typhon)
+     * Get the reward address for the wallet.
      *
-     * @param unsignedTxs - array of unsigned transactions in CborHex string
-     * @param partialSign - if the transactions are signed partially
-     * @returns array of signed transactions CborHex string
+     * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in hex format
      */
-    signTxs(unsignedTxs: string[], partialSign?: boolean): Promise<string[]>;
+    getRewardAddresses(): Promise<string[]>;
     /**
-     * Submits the signed transaction to the blockchain network.
+     * Sign a transaction with the wallet.
      *
-     * As wallets should already have this ability to submit transaction, we allow apps to request that a transaction be sent through it. If the wallet accepts the transaction and tries to send it, it shall return the transaction ID for the app to track. The wallet can return error messages or failure if there was an error in sending it.
+     * NOTE: This method requires a fetcher to resolve input UTxOs for determining required signers.
      *
-     * @param tx
-     * @returns a transaction hash
-     */
-    submitTx(tx: string): Promise<string>;
-    /**
-     * Get a used address of type Address from the wallet.
+     * It is also only an approximation to CIP-30 signTx, as this wallet is stateless and does not repeatedly
+     * derive keys, it is unable to sign for multiple derived key indexes.
      *
-     * This is used in transaction building.
+     * It will be effective to be used as a single address wallet.
      *
-     * @returns an Address object
+     * @param tx The transaction in CBOR hex format
+     * @returns A promise that resolves to a witness set with the signatures in CBOR hex format
      */
-    getUsedAddress(): Promise<Address>;
+    signTx(tx: string, partialSign?: boolean): Promise<string>;
+    signData(addressBech32: string, data: string): Promise<DataSignature>;
+    fetchAccountUtxos(): Promise<UTxO$1[]>;
+}
+
+/**
+ * MeshCardanoHeadlessWallet provides additional convenience methods on top of CardanoHeadlessWallet,
+ * such as returning results in Mesh-compatible formats and Bech32 addresses.
+ */
+declare class MeshCardanoHeadlessWallet extends CardanoHeadlessWallet {
+    static create(config: CardanoHeadlessWalletConfig): Promise<MeshCardanoHeadlessWallet>;
+    static fromMnemonic(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        mnemonic: string[];
+        password?: string;
+    }): Promise<MeshCardanoHeadlessWallet>;
+    static fromBip32Root(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        bech32: string;
+    }): Promise<MeshCardanoHeadlessWallet>;
+    static fromBip32RootHex(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        hex: string;
+    }): Promise<MeshCardanoHeadlessWallet>;
+    static fromCredentialSources(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
+        paymentCredentialSource: CredentialSource;
+        stakeCredentialSource?: CredentialSource;
+        drepCredentialSource?: CredentialSource;
+    }): Promise<MeshCardanoHeadlessWallet>;
     /**
-     * Get a list of UTXOs to be used as collateral inputs for transactions with plutus script inputs.
+     * Get the UTxOs for the wallet.
      *
-     * This is used in transaction building.
+     * NOTE: This method is only an approximation to CIP-30 getUtxos, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+     * will be overlap between getUtxos() and getCollateral() results. This can result in the collateral being
+     * spent between transactions.
      *
-     * @returns a list of UTXOs
+     * The method also does not perform pagination, nor is there a coin selection mechanism.
+     * @returns {Promise<UTxO[]>} A promise that resolves to an array of UTxOs in the Mesh UTxO format
      */
-    getCollateralUnspentOutput(limit?: number): Promise<TransactionUnspentOutput[]>;
+    getUtxosMesh(): Promise<UTxO$1[]>;
     /**
-     * Get a list of UTXOs to be used for transaction building.
+     * Get the collateral UTxOs for the wallet.
      *
-     * This is used in transaction building.
+     * NOTE: This method is only an approximation to CIP-30 getCollateral, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+     * will be overlap between getUtxos() and getCollateral() results.
      *
-     * @returns a list of UTXOs
+     * The basic strategy is to return the smallest pure ADA UTxO that is at least 5 ADA belonging to the wallet.
+     * @returns {Promise<UTxO[]>} A promise that resolves to an array of UTxOs in the Mesh UTxO format
      */
-    getUsedUTxOs(): Promise<TransactionUnspentOutput[]>;
+    getCollateralMesh(): Promise<UTxO$1[]>;
     /**
-     * A helper function to get the assets in the wallet.
+     * Get the balance of the wallet.
      *
-     * @returns a list of assets
+     * NOTE: This method is only an approximation to CIP-30 getBalance, as this wallet is completely
+     * stateless and does not track which UTxOs are specifically set as collateral. Which means the balance
+     * returned includes all UTxOs, including those that may be used as collateral.
+     * @returns {Promise<Asset[]>} A promise that resolves to the balance in the Mesh Asset format
      */
-    getAssets(): Promise<AssetExtended[]>;
+    getBalanceMesh(): Promise<Asset[]>;
     /**
-     * A helper function to get the lovelace balance in the wallet.
+     * Get the used addresses for the wallet.
+     *
+     * NOTE: This method completely deviates from CIP-30 getUsedAddresses, as this wallet is stateless
+     * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+     *
+     * It will be effective to be used as a single address wallet.
      *
-     * @returns lovelace balance
+     * @returns {Promise<string[]>} A promise that resolves to an array of used addresses in Bech32 format
      */
-    getLovelace(): Promise<string>;
+    getUsedAddressesBech32(): Promise<string[]>;
     /**
-     * A helper function to get the assets of a specific policy ID in the wallet.
+     * Get the unused addresses for the wallet.
      *
-     * @param policyId
-     * @returns a list of assets
+     * NOTE: This method completely deviates from CIP-30 getUnusedAddresses, as this wallet is stateless
+     * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+     *
+     * It will be effective to be used as a single address wallet.
+     *
+     * @returns {Promise<string[]>} A promise that resolves to an array of unused addresses in Bech32 format
      */
-    getPolicyIdAssets(policyId: string): Promise<AssetExtended[]>;
+    getUnusedAddressesBech32(): Promise<string[]>;
     /**
-     * A helper function to get the policy IDs of all the assets in the wallet.
+     * Get the change address for the wallet.
+     * NOTE: This method deviates from CIP-30 getChangeAddress, as this wallet is stateless
+     * it does not track which addresses has been previously used as change address. This method simply
+     * returns the wallet's main address.
+     *
+     * It will be effective to be used as a single address wallet.
      *
-     * @returns a list of policy IDs
+     * @returns {Promise<string>} A promise that resolves to the change address in Bech32 format
+     */
+    getChangeAddressBech32(): Promise<string>;
+    /**
+     * Get the reward address for the wallet.
+     * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in Bech32 format
      */
-    getPolicyIds(): Promise<string[]>;
+    getRewardAddressesBech32(): Promise<string[]>;
     /**
-     * The connected wallet account provides the account's public DRep Key, derivation as described in CIP-0105.
-     * These are used by the client to identify the user's on-chain CIP-1694 interactions, i.e. if a user has registered to be a DRep.
+     * Sign a transaction with the wallet.
      *
-     * @returns DRep object
+     * NOTE: This method requires a fetcher to resolve input UTxOs for determining required signers.
+     *
+     * It is also only an approximation to CIP-30 signTx, as this wallet is stateless and does not repeatedly
+     * derive keys, it is unable to sign for multiple derived key indexes.
+     *
+     * It will be effective to be used as a single address wallet.
+     *
+     * @param tx The transaction in CBOR hex format
+     * @returns A promise that resolves to a full transaction with extra vkey witnesses added from the wallet
+     * to the witness set in CBOR hex format
      */
-    getDRep(): Promise<{
-        publicKey: string;
-        publicKeyHash: string;
-        dRepIDCip105: string;
-    } | undefined>;
-    /**
-     * The connected wallet account provides the account's public DRep Key, derivation as described in CIP-0105.
-     * These are used by the client to identify the user's on-chain CIP-1694 interactions, i.e. if a user has registered to be a DRep.
-     *
-     * @returns wallet account's public DRep Key
-     */
-    getPubDRepKey(): Promise<string | undefined>;
-    getRegisteredPubStakeKeys(): Promise<{
-        pubStakeKeys: string[];
-        pubStakeKeyHashes: string[];
-    } | undefined>;
-    getUnregisteredPubStakeKeys(): Promise<{
-        pubStakeKeys: string[];
-        pubStakeKeyHashes: string[];
-    } | undefined>;
-    private static dRepKeyToDRepID;
-    private static resolveInstance;
-    static addBrowserWitnesses(unsignedTx: string, witnesses: string): any;
-    static getSupportedExtensions(wallet: string): {
-        cip: number;
-    }[];
+    signTxReturnFullTx(tx: string, partialSign?: boolean): Promise<string>;
 }
 
-declare function connect({ username, password, serverUrl, }: {
-    username: string;
-    password: string;
-    serverUrl: string;
-}): Promise<{
-    success: boolean;
-    wallet: {
-        bech32PrivateKey: string;
-    };
-    error?: undefined;
-} | {
-    success: boolean;
-    error: any;
-    wallet?: undefined;
-}>;
+type TransactionsStatus = {
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+};
 
-declare function login({ serverUrl, username, }: {
-    serverUrl: string;
-    username: string;
-}): Promise<{
-    success: boolean;
-    error: any;
-    errorCode: any;
-    authJSON?: undefined;
-} | {
-    success: boolean;
-    error: any;
-    errorCode?: undefined;
-    authJSON?: undefined;
-} | {
-    success: boolean;
-    authJSON: _simplewebauthn_browser.AuthenticationResponseJSON;
-    error?: undefined;
-    errorCode?: undefined;
-}>;
+type TransactionsInfo = {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: {
+        txid: string;
+        vout: number;
+        prevout: {
+            scriptpubkey: string;
+            scriptpubkey_asm: string;
+            scriptpubkey_type: string;
+            scriptpubkey_address: string;
+            value: number;
+        };
+        scriptsig: string;
+        scriptsig_asm: string;
+        witness: string[];
+        is_coinbase: boolean;
+        sequence: number;
+    }[];
+    vout: {
+        scriptpubkey: string;
+        scriptpubkey_asm: string;
+        scriptpubkey_type: string;
+        scriptpubkey_address: string;
+        value: number;
+    }[];
+    size: number;
+    weight: number;
+    fee: number;
+    status: TransactionsStatus;
+};
 
-declare function register({ serverUrl, username, }: {
-    serverUrl: string;
-    username: string;
-}): Promise<{
-    success: boolean;
-    error: any;
-    errorCode: any;
-} | {
-    success: boolean;
-    error?: undefined;
-    errorCode?: undefined;
-}>;
+type UTxO = {
+    status: {
+        block_hash: string;
+        block_height: number;
+        block_time: number;
+        confirmed: boolean;
+    };
+    txid: string;
+    value: number;
+    vout: number;
+};
 
-type AccountType = "payment" | "stake" | "drep";
-type Account = {
-    baseAddress: Address;
-    enterpriseAddress: Address;
-    rewardAddress: Address;
-    baseAddressBech32: string;
-    enterpriseAddressBech32: string;
-    rewardAddressBech32: string;
-    paymentKey: Ed25519PrivateKey;
-    stakeKey: Ed25519PrivateKey;
-    paymentKeyHex: string;
-    stakeKeyHex: string;
-    drepKey?: Ed25519PrivateKey;
-    pubDRepKey?: string;
-    dRepIDBech32?: DRepID;
-    dRepIDHash?: Ed25519KeyHashHex;
-    dRepIDCip105?: string;
+declare enum AddressPurpose {
+    Ordinals = "ordinals",
+    Payment = "payment",
+    Stacks = "stacks",
+    Starknet = "starknet",
+    Spark = "spark"
+}
+declare enum AddressType {
+    p2pkh = "p2pkh",
+    p2sh = "p2sh",
+    p2wpkh = "p2wpkh",
+    p2wsh = "p2wsh",
+    p2tr = "p2tr",
+    stacks = "stacks",
+    starknet = "starknet",
+    spark = "spark"
+}
+type BitcoinAddress = {
+    address: string;
+    publicKey: string;
+    purpose: AddressPurpose;
+    addressType: AddressType;
+    walletType: "software" | "ledger" | "keystone";
 };
-type EmbeddedWalletKeyType = {
-    type: "root";
-    bech32: string;
-} | {
-    type: "cli";
-    payment: string;
-    stake?: string;
-} | {
-    type: "mnemonic";
-    words: string[];
-} | {
-    type: "bip32Bytes";
-    bip32Bytes: Uint8Array;
+type BitcoinAccount = {
+    walletType: "software" | "ledger" | "keystone";
+    address: string;
+    publicKey: string;
+    purpose: AddressPurpose;
+    addressType: AddressType;
 };
-type CreateEmbeddedWalletOptions = {
-    networkId: number;
-    key: EmbeddedWalletKeyType;
+type BitcoinBalance = {
+    confirmed: string;
+    unconfirmed: string;
+    total: string;
 };
-declare class WalletStaticMethods {
-    static privateKeyBech32ToPrivateKeyHex(_bech32: string): string;
-    static mnemonicToPrivateKeyHex(words: string[]): string;
-    static signingKeyToHexes(paymentKey: string, stakeKey: string): [string, string];
-    static bip32BytesToPrivateKeyHex(bip32Bytes: Uint8Array): string;
-    static getAddresses(paymentKey: Ed25519PrivateKey, stakingKey: Ed25519PrivateKey, networkId?: number): {
-        baseAddress: Address;
-        enterpriseAddress: Address;
-        rewardAddress: Address;
-    };
-    static getDRepKey(dRepKey: Ed25519PrivateKey, networkId?: number): {
-        pubDRepKey: string;
-        dRepIDBech32: DRepID;
-        dRepIDHash: Ed25519KeyHashHex;
-        dRepIDCip105: string;
-    };
-    static generateMnemonic(strength?: number): string[];
-    static addWitnessSets(txHex: string, witnesses: VkeyWitness[]): string;
+declare enum MessageSigningProtocols {
+    ECDSA = "ECDSA",
+    BIP322 = "BIP322"
 }
-declare class EmbeddedWallet extends WalletStaticMethods {
-    private readonly _walletSecret?;
-    private readonly _networkId;
-    cryptoIsReady: boolean;
-    constructor(options: CreateEmbeddedWalletOptions);
-    init(): Promise<void>;
-    getAccount(accountIndex?: number, keyIndex?: number): Account;
-    /**
-     * Get wallet network ID.
-     *
-     * @returns network ID
-     */
-    getNetworkId(): number;
-    /**
-     * This endpoint utilizes the [CIP-8 - Message Signing](https://cips.cardano.org/cips/cip8/) to sign arbitrary data, to verify the data was signed by the owner of the private key.
-     *
-     * @param address - bech32 address to sign the data with
-     * @param payload - the data to be signed
-     * @param accountIndex account index (default: 0)
-     * @returns a signature
-     */
-    signData(address: string, payload: string, accountIndex?: number, keyIndex?: number): DataSignature;
-    /**
-     * This endpoints sign the provided transaction (unsignedTx) with the private key of the owner.
-     *
-     * @param unsignedTx - a transaction in CBOR
-     * @param accountIndex account index (default: 0)
-     * @param keyIndex key index (default: 0)
-     * @param accountType - type of the account (default: payment)
-     * @returns VkeyWitness
-     */
-    signTx(unsignedTx: string, accountIndex?: number, keyIndex?: number, accountType?: AccountType): VkeyWitness;
+type BitcoinSignature = {
+    signature: string;
+    messageHash: string;
+    address: string;
+    protocol: MessageSigningProtocols;
+};
+type VerifyMessageResult = {
+    valid: boolean;
+    recoveredPublicKey?: string;
+    reason?: string;
+};
+interface IBitcoinWallet {
+    getNetwork(): Promise<"Mainnet" | "Testnet4">;
+    getAddresses(addressPurposes: AddressPurpose[]): Promise<BitcoinAddress[]>;
+    getAccounts(addressPurposes: AddressPurpose[]): Promise<BitcoinAccount[]>;
+    getBalance(): Promise<BitcoinBalance>;
+    signMessage(address: string, message: string, protocol?: MessageSigningProtocols): Promise<BitcoinSignature>;
+    verifyMessage(address: string, message: string, signature: string): Promise<VerifyMessageResult>;
+    signTransfer(recipients: {
+        address: string;
+        amount: number;
+    }[]): Promise<string>;
+    signPsbt(signConfig: {
+        psbt: string;
+        signInputs?: {
+            [x: string]: number[];
+        } | undefined;
+        broadcast?: boolean | undefined;
+    }): Promise<string>;
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+    getTransactionHistory(options?: {
+        purposes?: AddressPurpose[];
+        lastSeenTxid?: string;
+    }): Promise<(TransactionsInfo & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
 }
 
-type CreateMeshWalletOptions = {
-    networkId: 0 | 1;
-    fetcher?: IFetcher;
-    submitter?: ISubmitter;
-    key: {
-        type: "root";
-        bech32: string;
-    } | {
-        type: "cli";
-        payment: string;
-        stake?: string;
-    } | {
-        type: "mnemonic";
-        words: string[];
-    } | {
-        type: "bip32Bytes";
-        bip32Bytes: Uint8Array;
-    } | {
-        type: "address";
-        address: string;
-    };
-    accountIndex?: number;
-    keyIndex?: number;
-    accountType?: AccountType;
+type ChainStats = {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+};
+
+type MempoolStats = {
+    funded_txo_count: number;
+    funded_txo_sum: number;
+    spent_txo_count: number;
+    spent_txo_sum: number;
+    tx_count: number;
+};
+
+type AddressInfo = {
+    address: string;
+    chain_stats: ChainStats;
+    mempool_stats: MempoolStats;
+};
+
+type ScriptInfo = {
+    scripthash: string;
+    chain_stats: ChainStats;
+    mempool_stats: MempoolStats;
 };
+
 /**
- * Mesh Wallet provides a set of APIs to interact with the blockchain. This wallet is compatible with Mesh transaction builders.
- *
- * There are 4 types of keys that can be used to create a wallet:
- * - root: A private key in bech32 format, generally starts with `xprv1`
- * - cli: CLI generated keys starts with `5820`. Payment key is required, and the stake key is optional.
- * - mnemonic: A list of 24 words
- * - address: A bech32 address that can be used to create a read-only wallet, generally starts with `addr` or `addr_test1`
- *
- * ```javascript
- * import { MeshWallet, BlockfrostProvider } from '@meshsdk/core';
- *
- * const provider = new BlockfrostProvider('<BLOCKFROST_API_KEY>');
+ * Read-only chain data queries for Bitcoin addresses and scripts.
+ * Mirrors the Mesh `IFetcher` interface shape for Cardano, adapted to Bitcoin.
+ * Only the methods relevant to Bitcoin are included; script variants are optional
+ * because P2SH/P2WSH usage is uncommon in most dApp workflows.
+ */
+interface IBitcoinFetcher {
+    fetchAddressInfo(address: string): Promise<AddressInfo>;
+    fetchAddressUTxOs(address: string): Promise<UTxO[]>;
+    fetchUTxO(txid: string, vout?: number): Promise<UTxO[]>;
+    fetchAddressTxs(address: string, lastSeenTxid?: string): Promise<TransactionsInfo[]>;
+    fetchTxInfo(txid: string): Promise<TransactionsStatus>;
+    fetchFeeEstimates(blocks: number): Promise<number>;
+    fetchScriptInfo?(hash: string): Promise<ScriptInfo>;
+    fetchScriptUTxOs?(hash: string): Promise<UTxO[]>;
+    fetchScriptTxs?(hash: string, lastSeenTxid?: string): Promise<TransactionsInfo[]>;
+}
+interface IBitcoinSubmitter {
+    submitTx(tx: string): Promise<string>;
+}
+interface IBitcoinProvider extends IBitcoinFetcher, IBitcoinSubmitter {
+}
+
+type RecoveryId = 0 | 1 | 2 | 3;
+
+type BitcoinNetworkName = "Mainnet" | "Testnet4";
+/**
+ * Map a friendly network name to a bitcoinjs `Network` object.
  *
- * const wallet = new MeshWallet({
- *   networkId: 0,
- *   fetcher: provider,
- *   submitter: provider,
- *   key: {
- *     type: 'mnemonic',
- *     words: ["solution","solution","solution","solution","solution",","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution","solution"],
- *   },
- * });
- * ```
+ * NOTE: bitcoinjs-lib does not currently ship a dedicated Testnet4 network object.
+ * Testnet4 and Testnet3 use identical address encoding (`tb` bech32/bech32m, same
+ * version/HRP/script-hash formats), so reusing `bitcoin.networks.testnet` is safe
+ * for address derivation and PSBT construction. Chain state differs, but that is
+ * the provider's responsibility, not the encoder's.
+ */
+declare function networkFromName(name: BitcoinNetworkName): Network;
+/**
+ * Drop the parity prefix byte of a compressed secp256k1 pubkey (33 bytes -> 32 bytes).
+ * Required for Taproot (BIP-340) which uses x-only public keys. Returns a copy so
+ * callers cannot accidentally mutate the source buffer.
+ */
+declare function toXOnly(pubkey: Buffer): Buffer;
+/**
+ * Derive the P2WPKH (native SegWit) payment address from a compressed public key.
+ */
+declare function deriveP2wpkhAddress(publicKey: Buffer | Uint8Array, network: Network): {
+    address: string;
+    publicKey: string;
+};
+/**
+ * Derive the P2TR (Taproot, ordinals) address from a compressed public key.
+ * Uses the BIP-86 single-key spend path (no script tree).
+ */
+declare function deriveP2trAddress(publicKey: Buffer | Uint8Array, network: Network): {
+    address: string;
+    publicKey: string;
+};
+/**
+ * Internal derived-address record. Holds the public-facing fields plus the
+ * derivation path so the manager can request signing from the right child node.
+ * Public wallet methods convert this to plain `BitcoinAddress` / `BitcoinAccount`
+ * shapes defined on `IBitcoinWallet`.
+ */
+declare class DerivedBitcoinAddress {
+    readonly address: string;
+    readonly publicKey: string;
+    readonly purpose: AddressPurpose;
+    readonly addressType: AddressType;
+    readonly walletType: "software" | "ledger" | "keystone";
+    readonly derivationPath: string;
+    readonly change: number;
+    readonly index: number;
+    constructor(args: {
+        address: string;
+        publicKey: string;
+        purpose: AddressPurpose;
+        addressType: AddressType;
+        walletType?: "software" | "ledger" | "keystone";
+        derivationPath: string;
+        change: number;
+        index: number;
+    });
+    toBitcoinAddress(): BitcoinAddress;
+    toBitcoinAccount(): BitcoinAccount;
+}
+
+/**
+ * Standard BIP derivation paths used by the Mesh Bitcoin wallet:
+ *   - BIP-84 native SegWit (P2WPKH) for the `payment` purpose
+ *   - BIP-86 single-key Taproot (P2TR) for the `ordinals` purpose
  *
- * Please call `await wallet.init()` after creating the wallet to fetch the addresses from the wallet.
+ * `coinType` is 0 for mainnet, 1 for any testnet (including Testnet4).
  */
-declare class MeshWallet implements IWallet {
-    private readonly _keyType;
-    private readonly _accountType;
-    private readonly _wallet;
-    private readonly _accountIndex;
-    private readonly _keyIndex;
-    private readonly _fetcher?;
-    private readonly _submitter?;
-    private readonly _networkId;
-    addresses: {
-        baseAddress?: Address;
-        enterpriseAddress?: Address;
-        rewardAddress?: Address;
-        baseAddressBech32?: string;
-        enterpriseAddressBech32?: string;
-        rewardAddressBech32?: string;
-        pubDRepKey?: string;
-        dRepIDBech32?: DRepID;
-        dRepIDHash?: Ed25519KeyHashHex;
-        dRepIDCip105?: string;
-    };
-    constructor(options: CreateMeshWalletOptions);
-    /**
-     * Initializes the wallet. This is a required call as fetching addresses from the wallet is an async operation.
-     * @returns void
-     */
-    init(): Promise<void>;
-    /**
-     * Returns all derived addresses from the wallet.
-     * @returns a list of addresses
-     */
-    getAddresses(): {
-        baseAddress?: Address;
-        enterpriseAddress?: Address;
-        rewardAddress?: Address;
-        baseAddressBech32?: string;
-        enterpriseAddressBech32?: string;
-        rewardAddressBech32?: string;
-        pubDRepKey?: string;
-        dRepIDBech32?: any;
-        dRepIDHash?: Ed25519KeyHashHex;
-        dRepIDCip105?: string;
-    };
+declare function getCoinType(network: Network): 0 | 1;
+declare function paymentPath(network: Network, account?: number, change?: number, index?: number): string;
+declare function ordinalsPath(network: Network, account?: number, change?: number, index?: number): string;
+interface BitcoinAddressManagerConfig {
+    network: Network;
     /**
-     * Returns a list of assets in the wallet. This API will return every assets in the wallet. Each asset is an object with the following properties:
-     * - A unit is provided to display asset's name on the user interface.
-     * - A quantity is provided to display asset's quantity on the user interface.
-     *
-     * @returns a list of assets and their quantities
+     * BIP-32 root node (seed-derived). The manager owns derivation from this root.
+     * Optional when the manager is used in read-only mode (no key material available).
      */
-    getBalance(): Promise<Asset[]>;
+    root?: BIP32Interface;
     /**
-     * Returns an address owned by the wallet that should be used as a change address to return leftover assets during transaction creation back to the connected wallet.
-     *
-     * @returns an address
+     * Account index for hardened account derivation (defaults to 0).
      */
-    getChangeAddress(addressType?: GetAddressType): Promise<string>;
+    account?: number;
+}
+/**
+ * Centralises address derivation for the Bitcoin wallet across purposes.
+ * Mirrors the role of Cardano's `AddressManager` — single source of truth for
+ * which addresses correspond to which purposes.
+ */
+declare class BitcoinAddressManager {
+    private readonly network;
+    private readonly root?;
+    private readonly account;
+    constructor(config: BitcoinAddressManagerConfig);
+    static fromSeed(seed: Buffer, network: Network, account?: number): BitcoinAddressManager;
+    getNetwork(): Network;
+    private requireRoot;
     /**
-     * Returns an address owned by the wallet that should be used as a change address to return leftover assets during transaction creation back to the connected wallet in hex format.
-     *
-     * @returns an address in hex format
+     * Get the address for a single purpose, deriving fresh from the root.
      */
-    getChangeAddressHex(addressType?: GetAddressType): Promise<string>;
+    getAddress(purpose: AddressPurpose, change?: number, index?: number): DerivedBitcoinAddress;
     /**
-     * This function shall return a list of one or more UTXOs (unspent transaction outputs) controlled by the wallet that are required to reach AT LEAST the combined ADA value target specified in amount AND the best suitable to be used as collateral inputs for transactions with plutus script inputs (pure ADA-only UTXOs).
-     *
-     * If this cannot be attained, an error message with an explanation of the blocking problem shall be returned. NOTE: wallets are free to return UTXOs that add up to a greater total ADA value than requested in the amount parameter, but wallets must never return any result where UTXOs would sum up to a smaller total ADA value, instead in a case like that an error message must be returned.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs
+     * Get addresses for an array of purposes (default: payment + ordinals).
+     * Skips unsupported purposes silently to remain forward-compatible with
+     * non-Bitcoin Sats Connect purposes (`stacks`, `starknet`, `spark`).
      */
-    getCollateral(addressType?: GetAddressType): Promise<UTxO[]>;
+    getAddresses(purposes?: AddressPurpose[]): DerivedBitcoinAddress[];
     /**
-     * This function shall return a list of one or more UTXOs (unspent transaction outputs) controlled by the wallet that are required to reach AT LEAST the combined ADA value target specified in amount AND the best suitable to be used as collateral inputs for transactions with plutus script inputs (pure ADA-only UTXOs).
-     *
-     * If this cannot be attained, an error message with an explanation of the blocking problem shall be returned. NOTE: wallets are free to return UTXOs that add up to a greater total ADA value than requested in the amount parameter, but wallets must never return any result where UTXOs would sum up to a smaller total ADA value, instead in a case like that an error message must be returned.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs in hex format
+     * Get the BIP-32 child node for a purpose — needed for signing.
      */
-    getCollateralHex(addressType?: GetAddressType): Promise<string[]>;
+    getChild(purpose: AddressPurpose, change?: number, index?: number): BIP32Interface;
     /**
-     * Return a list of supported CIPs of the wallet.
-     *
-     * @returns a list of CIPs
+     * Derive a contiguous range of addresses for a single purpose/change level.
+     * Useful for gap-limit scanning: call with `start=0, count=20` to get the
+     * first gap-limit window (BIP-84 / BIP-86), then advance `start` if any are used.
+     *
+     * @param purpose  Payment (BIP-84 P2WPKH) or Ordinals (BIP-86 P2TR).
+     * @param start    First index in the range (default 0).
+     * @param count    How many addresses to derive (default 20).
+     * @param change   Change chain: 0 = external/receive, 1 = internal/change.
      */
-    getExtensions(): Promise<number[]>;
+    getAddressesByPurpose(purpose: AddressPurpose, start?: number, count?: number, change?: number): DerivedBitcoinAddress[];
     /**
-     * Get a list of UTXOs to be used as collateral inputs for transactions with plutus script inputs.
+     * Scan the derivation path for `address` up to `maxGap` indices, returning
+     * the matching `DerivedBitcoinAddress` (with correct `change` and `index`)
+     * or `undefined` if not found. Checks both the external (0) and internal (1)
+     * change chains.
      *
-     * This is used in transaction building.
+     * BIP-32 recommends a gap limit of 20; use a higher value if you know the
+     * wallet has been used extensively.
+     */
+    findAddress(address: string, purpose: AddressPurpose, maxGap?: number): DerivedBitcoinAddress | undefined;
+    /**
+     * Return the BIP-32 account node (hardened, public-key-only) for the given
+     * purpose. This is the xpub you would share with a watch-only wallet.
      *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs
+     * BIP-84:  m/84'/coin_type'/account'
+     * BIP-86:  m/86'/coin_type'/account'
      */
-    getCollateralUnspentOutput(addressType?: GetAddressType): Promise<TransactionUnspentOutput[]>;
+    private getAccountNode;
     /**
-     * The connected wallet account provides the account's public DRep Key, derivation as described in CIP-0105.
-     * These are used by the client to identify the user's on-chain CIP-1694 interactions, i.e. if a user has registered to be a DRep.
+     * Export the BIP-84 (P2WPKH) account public key as a standard base58 xpub
+     * (mainnet) or tpub (testnet).
      *
-     * @returns DRep object
+     * Example: `xpub6CQdKacu...`
      */
-    getDRep(): Promise<{
-        publicKey: string;
-        publicKeyHash: string;
-        dRepIDCip105: string;
-    } | undefined>;
+    getAccountXpub(): string;
     /**
-     * Returns the network ID of the currently connected account. 0 is testnet and 1 is mainnet but other networks can possibly be returned by wallets. Those other network ID values are not governed by CIP-30. This result will stay the same unless the connected account has changed.
+     * Export the BIP-86 (P2TR / Taproot) account public key as a standard
+     * base58 xpub (mainnet) or tpub (testnet).
      *
-     * @returns network ID
+     * Example: `xpub6D5r3aJk...`
      */
-    getNetworkId(): Promise<number>;
+    getTaprootXpub(): string;
     /**
-     * Returns a list of reward addresses owned by the wallet. A reward address is a stake address that is used to receive rewards from staking, generally starts from `stake` prefix.
+     * Export the BIP-84 account public key with the **zpub** (mainnet) or
+     * **vpub** (testnet) version prefix, as expected by wallet software that
+     * distinguishes BIP-84 SegWit accounts from BIP-44/49 accounts by the
+     * key prefix rather than the derivation path.
      *
-     * @returns a list of reward addresses
+     * Conversion: decode the xpub/tpub base58check bytes, replace the first
+     * 4 version bytes, and re-encode. The 74 payload bytes are unchanged.
      */
-    getRewardAddresses(): Promise<string[]>;
+    getAccountZpub(): string;
+}
+
+interface BitcoinHeadlessWalletConfig {
+    network: BitcoinNetworkName;
+    provider?: IBitcoinProvider;
+    password?: string;
+    account?: number;
+}
+interface InternalConfig {
+    network: BitcoinNetworkName;
+    bitcoinNetwork: Network;
+    root: BIP32Interface;
+    manager: BitcoinAddressManager;
+    provider?: IBitcoinProvider;
+    account: number;
+}
+/**
+ * Internal signer extension. Carries the optional BIP-341 internal x-only
+ * pubkey alongside the standard `Signer` surface so `signSingleInput` can
+ * populate `input.tapInternalKey` when signing Taproot inputs. ECDSA signers
+ * (P2WPKH) simply omit `internalPubkey`.
+ */
+type TaprootCapableSigner = Signer & {
+    internalPubkey?: Buffer;
+};
+declare class BitcoinHeadlessWallet implements IBitcoinWallet {
+    protected readonly networkName: BitcoinNetworkName;
+    protected readonly bitcoinNetwork: Network;
+    protected readonly root: BIP32Interface;
+    protected readonly manager: BitcoinAddressManager;
+    protected readonly provider?: IBitcoinProvider;
+    protected readonly account: number;
+    protected constructor(cfg: InternalConfig);
     /**
-     * Returns a list of reward addresses owned by the wallet. A reward address is a stake address that is used to receive rewards from staking.
-     * @returns a list of reward addresses in hex format
+     * Create a headless wallet from an existing BIP-32 root and configuration.
      */
-    getRewardAddressesHex(): Promise<string[]>;
+    static create(config: BitcoinHeadlessWalletConfig & {
+        root: BIP32Interface;
+    }): Promise<BitcoinHeadlessWallet>;
     /**
-     * Returns a list of unused addresses controlled by the wallet.
-     *
-     * @returns a list of unused addresses
+     * Create a headless wallet from a BIP-39 mnemonic phrase.
      */
-    getUnusedAddresses(): Promise<string[]>;
+    static fromMnemonic(config: BitcoinHeadlessWalletConfig & {
+        mnemonic: string[];
+    }): Promise<BitcoinHeadlessWallet>;
     /**
-     * Returns a list of unused addresses controlled by the wallet.
-     *
-     * @returns a list of unused addresses in hex format
+     * Create a headless wallet from BIP-39 entropy (hex string).
      */
-    getUnusedAddressesHex(): Promise<string[]>;
+    static fromEntropy(config: BitcoinHeadlessWalletConfig & {
+        entropy: string;
+    }): Promise<BitcoinHeadlessWallet>;
+    static fromPrivateKey(config: BitcoinHeadlessWalletConfig & {
+        privateKey: string;
+    }): Promise<BitcoinHeadlessWallet>;
+    getNetwork(): Promise<BitcoinNetworkName>;
+    getAddresses(addressPurposes: AddressPurpose[]): Promise<BitcoinAddress[]>;
+    getAccounts(addressPurposes: AddressPurpose[]): Promise<BitcoinAccount[]>;
+    getBalance(): Promise<BitcoinBalance>;
     /**
-     * Returns a list of used addresses controlled by the wallet.
-     *
-     * @returns a list of used addresses
+     * Derive a contiguous range of addresses for a single purpose / change level.
+     * Delegates to `BitcoinAddressManager.getAddressesByPurpose`.
      */
-    getUsedAddresses(): Promise<string[]>;
+    getAddressesByPurpose(purpose: AddressPurpose, start?: number, count?: number, change?: number): DerivedBitcoinAddress[];
     /**
-     * Returns a list of used addresses controlled by the wallet.
-     *
-     * @returns a list of used addresses in hex format
+     * Scan the derivation path for `address` up to `maxGap` indices across both
+     * external and internal (change) chains. Returns the matching
+     * `DerivedBitcoinAddress` (with correct `change` and `index`) or `undefined`.
+     * Delegates to `BitcoinAddressManager.findAddress`.
      */
-    getUsedAddressesHex(): Promise<string[]>;
+    findManagedAddress(address: string, purpose: AddressPurpose, maxGap?: number): DerivedBitcoinAddress | undefined;
     /**
-     * Get a list of UTXOs to be used for transaction building.
-     *
-     * This is used in transaction building.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs
+     * Export the BIP-84 (P2WPKH) account public key as xpub (mainnet) / tpub (testnet).
+     * Delegates to `BitcoinAddressManager.getAccountXpub`.
      */
-    getUsedUTxOs(addressType?: GetAddressType): Promise<TransactionUnspentOutput[]>;
+    getAccountXpub(): string;
     /**
-     * Return a list of all UTXOs (unspent transaction outputs) controlled by the wallet.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs
+     * Export the BIP-86 (P2TR / Taproot) account public key as xpub (mainnet) / tpub (testnet).
+     * Delegates to `BitcoinAddressManager.getTaprootXpub`.
      */
-    getUtxos(addressType?: GetAddressType): Promise<UTxO[]>;
+    getTaprootXpub(): string;
     /**
-     * Return a list of all UTXOs (unspent transaction outputs) controlled by the wallet.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs in hex format
+     * Export the BIP-84 account public key with the zpub (mainnet) / vpub (testnet)
+     * version prefix. Delegates to `BitcoinAddressManager.getAccountZpub`.
      */
-    getUtxosHex(addressType?: GetAddressType): Promise<string[]>;
+    getAccountZpub(): string;
     /**
-     * This endpoint utilizes the [CIP-8 - Message Signing](https://cips.cardano.org/cips/cip8/) to sign arbitrary data, to verify the data was signed by the owner of the private key.
-     *
-     * @param payload - the payload to sign
-     * @param address - the address to use for signing (optional)
-     * @returns a signature
+     * Fetch unspent transaction outputs (UTXOs) for one or both managed addresses.
+     *
+     * @param purposes - Which address(es) to query. Defaults to both Payment and
+     *   Ordinals so callers get a unified view. Pass `[AddressPurpose.Payment]`
+     *   to restrict to the P2WPKH address only (e.g. when building a send tx).
+     * @returns Flat array of UTXOs across all requested addresses, each annotated
+     *   with the `address` and `purpose` it belongs to so callers can route
+     *   inputs correctly (P2WPKH vs P2TR signing).
      */
-    signData(payload: string, address?: string): Promise<DataSignature>;
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
     /**
-     * Requests user to sign the provided transaction (tx). The wallet should ask the user for permission, and if given, try to sign the supplied body and return a signed transaction. partialSign should be true if the transaction provided requires multiple signatures.
-     *
-     * @param unsignedTx - a transaction in CBOR
-     * @param partialSign - if the transaction is partially signed (default: false)
-     * @param returnFullTx - if the full tx should be returned or only the witness set (default: true)
-     * @returns a signed transaction in CBOR
+     * Fetch confirmed and mempool transaction history for one or both managed
+     * addresses, with optional pagination via `lastSeenTxid`.
+     *
+     * @param options.purposes - Which address(es) to query (default: both).
+     * @param options.lastSeenTxid - Cursor for page-based pagination: pass the
+     *   last `txid` from a previous page to fetch the next batch (Esplora API
+     *   returns at most 25 txs per page).
+     * @returns Transactions in reverse-chronological order (newest first),
+     *   each annotated with `address` and `purpose` for easy filtering.
+     *   If both addresses are queried the two lists are merged and re-sorted by
+     *   block height descending (unconfirmed txs sort to the top).
      */
-    signTx(unsignedTx: string, partialSign?: boolean, returnFullTx?: boolean): Promise<string>;
+    getTransactionHistory(options?: {
+        purposes?: AddressPurpose[];
+        lastSeenTxid?: string;
+    }): Promise<(TransactionsInfo & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+    signMessage(address: string, message: string, protocol?: MessageSigningProtocols): Promise<BitcoinSignature>;
+    verifyMessage(address: string, message: string, signature: string): Promise<VerifyMessageResult>;
+    signTransfer(recipients: {
+        address: string;
+        amount: number;
+    }[]): Promise<string>;
+    signPsbt(signConfig: {
+        psbt: string;
+        signInputs?: {
+            [x: string]: number[];
+        } | undefined;
+        broadcast?: boolean | undefined;
+    }): Promise<string>;
+    protected findDerivedByAddress(address: string): DerivedBitcoinAddress;
+    protected signerForPurpose(purpose: AddressPurpose, change?: number, index?: number): TaprootCapableSigner;
+    protected signSingleInput(psbt: Psbt, index: number, entry: {
+        signer: TaprootCapableSigner;
+        purpose: AddressPurpose;
+    }): void;
+}
+/**
+ * Verify a Bitcoin signed-message (BIP-137 style, 65-byte compact recoverable ECDSA, base64).
+ *
+ * Cross-type acceptance: recovers the pubkey from the signature and matches against
+ * P2PKH / P2SH-P2WPKH / P2WPKH / P2TR (BIP-86) addresses derived from that pubkey.
+ * The header byte selects compression + recoveryId per BIP-137 but does not constrain
+ * which address type the caller may verify against — matches how Sparrow/Leather behave.
+ */
+declare function verifyBitcoinMessage(address: string, message: string, signature: string, network: Network): VerifyMessageResult;
+
+type InstalledBitcoinWallet = {
+    id: string;
+    name: string;
+    icon?: string;
+};
+/**
+ * BitcoinBrowserWallet wraps an `IBitcoinWallet`-compatible browser provider
+ * (e.g., Xverse). Mirrors `CardanoBrowserWallet` for the Bitcoin chain.
+ *
+ * Typical usage:
+ *   const wallets = BitcoinBrowserWallet.getInstalledWallets();
+ *   const wallet  = await BitcoinBrowserWallet.enable("xverse", { persist: true });
+ *   const balance = await wallet.getBalance();
+ *
+ * To reconnect after a page reload without prompting the user again:
+ *   const wallet = await BitcoinBrowserWallet.restore();
+ */
+declare class BitcoinBrowserWallet implements IBitcoinWallet {
+    walletInstance: IBitcoinWallet;
+    /** Lowercase registry key of the connected wallet (e.g. `"xverse"`). */
+    readonly walletName: string;
+    constructor(walletInstance: IBitcoinWallet, walletName?: string);
+    getNetwork(): Promise<"Mainnet" | "Testnet4">;
+    getAddresses(addressPurposes: AddressPurpose[]): Promise<BitcoinAddress[]>;
+    getAccounts(addressPurposes: AddressPurpose[]): Promise<BitcoinAccount[]>;
+    getBalance(): Promise<BitcoinBalance>;
+    signMessage(address: string, message: string, protocol?: MessageSigningProtocols): Promise<BitcoinSignature>;
+    verifyMessage(address: string, message: string, signature: string): Promise<VerifyMessageResult>;
+    signTransfer(recipients: {
+        address: string;
+        amount: number;
+    }[]): Promise<string>;
+    signPsbt(signConfig: {
+        psbt: string;
+        signInputs?: {
+            [x: string]: number[];
+        } | undefined;
+        broadcast?: boolean | undefined;
+    }): Promise<string>;
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+    getTransactionHistory(options?: {
+        purposes?: AddressPurpose[];
+        lastSeenTxid?: string;
+    }): Promise<(TransactionsInfo & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
     /**
-     * Experimental feature - sign multiple transactions at once.
-     *
-     * @param unsignedTxs - array of unsigned transactions in CborHex string
-     * @param partialSign - if the transactions are signed partially
-     * @returns array of signed transactions CborHex string
+     * Removes the persisted wallet selection so `restore()` returns `null` on
+     * the next page load. Call this on an explicit user-initiated disconnect.
      */
-    signTxs(unsignedTxs: string[], partialSign?: boolean, returnFullTx?: boolean): Promise<string[]>;
+    disconnect(): void;
     /**
-     * Submits the signed transaction to the blockchain network.
-     *
-     * As wallets should already have this ability to submit transaction, we allow apps to request that a transaction be sent through it. If the wallet accepts the transaction and tries to send it, it shall return the transaction ID for the app to track. The wallet can return error messages or failure if there was an error in sending it.
-     *
-     * @param tx - a signed transaction in CBOR
-     * @returns a transaction hash
+     * Returns a list of Bitcoin wallets the user has installed in the browser.
+     * Throws when called outside a browser (SSR).
      */
-    submitTx(tx: string): Promise<string>;
+    static getInstalledWallets(): InstalledBitcoinWallet[];
     /**
-     * Get a used address of type Address from the wallet.
-     *
-     * This is used in transaction building.
-     *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns an Address object
+     * Returns `true` when a wallet session has been persisted and `restore()`
+     * (or `enable()` with `persist: true`) can reconnect it silently.
      */
-    getUsedAddress(addressType?: GetAddressType): Address;
+    static hasPersistedSession(): boolean;
     /**
-     * Get a list of UTXOs to be used for transaction building.
+     * Connect to a wallet, returning a wrapped `BitcoinBrowserWallet`.
      *
-     * This is used in transaction building.
+     * When `options.persist` is `true` the behaviour differs depending on
+     * whether a prior session exists:
      *
-     * @param addressType - the type of address to fetch UTXOs from (default: payment)
-     * @returns a list of UTXOs
+     *   • **No existing session** — runs the normal connect flow (may show the
+     *     wallet's approval popup)
+     *   • **Existing session for the same wallet** — silently reconnects without showing any popup.
+     *
+     * @param walletName  Registry key of the wallet (e.g. `"xverse"`).
+     * @param options.persist  Opt-in to silent restore on subsequent page loads.
      */
-    getUnspentOutputs(addressType?: GetAddressType): Promise<TransactionUnspentOutput[]>;
+    static enable(walletName: string, options?: {
+        persist?: boolean;
+    }): Promise<BitcoinBrowserWallet>;
     /**
-     * A helper function to get the assets in the wallet.
+     * Silently reconnects using the wallet name saved by a previous
+     * `enable({ persist: true })` call.
      *
-     * @returns a list of assets
+     * Returns `null` if nothing was persisted or the saved wallet is no longer
+     * available (extension uninstalled / access revoked). The stale entry is
+     * cleared automatically in the latter case.
      */
-    getAssets(): Promise<AssetExtended[]>;
+    static restore(): Promise<BitcoinBrowserWallet | null>;
+}
+
+/**
+ * Shape of the Xverse `BitcoinProvider` reachable via `window.XverseProviders.BitcoinProvider`.
+ * We only depend on the `request(method, params)` JSON-RPC-style surface, which is the public
+ * Sats Connect protocol — no SDK dependency required.
+ *
+ * See: https://docs.xverse.app/sats-connect (`getAddresses`, `getAccounts`, `getBalance`,
+ *      `signMessage`, `sendTransfer`, `signPsbt`, `getNetwork`).
+ */
+interface XverseBitcoinProvider {
+    request<T = unknown>(method: string, params?: Record<string, unknown> | null): Promise<XverseResponse<T>>;
+}
+/**
+ * The Xverse provider's `request()` returns one of two envelopes, depending on
+ * whether the dApp went through the sats-connect-core library (which normalises
+ * the wire format) or hit `window.XverseProviders.BitcoinProvider` directly
+ * (raw JSON-RPC 2.0). We accept both so the adapter works either way.
+ */
+type XverseResponse<T> = {
+    status: "success";
+    result: T;
+} | {
+    status: "error";
+    error: {
+        code: number;
+        message: string;
+    };
+} | {
+    jsonrpc: "2.0";
+    result: T;
+    id?: string | number | null;
+} | {
+    jsonrpc: "2.0";
+    error: {
+        code: number;
+        message: string;
+    };
+    id?: string | number | null;
+};
+/**
+ * Typed error preserving the RPC error code so callers can distinguish
+ * `USER_REJECTION` (-32000) from `ACCESS_DENIED` (-32002), etc.
+ */
+/** Sats Connect `RpcErrorCode.ACCESS_DENIED` — app has not connected yet. */
+declare const XVERSE_ACCESS_DENIED = -32002;
+declare class XverseRpcError extends Error {
+    readonly code: number;
+    readonly method: string;
+    constructor(method: string, code: number, message: string);
+}
+declare global {
+    interface Window {
+        XverseProviders?: {
+            BitcoinProvider?: XverseBitcoinProvider;
+        };
+        BitcoinProvider?: XverseBitcoinProvider;
+    }
+}
+declare function isXverseInstalled(): boolean;
+/**
+ * Adapter that implements `IBitcoinWallet` against the Xverse / Sats Connect surface.
+ * Created on `enable()` after the user authorizes the dApp.
+ */
+declare class XverseAdapter implements IBitcoinWallet {
+    private connected;
+    private cachedAddresses;
+    private constructor();
+    static enable(): Promise<XverseAdapter>;
     /**
-     * A helper function to get the lovelace balance in the wallet.
-     *
-     * @returns lovelace balance
+     * Establish a dApp connection per Sats Connect: `wallet_connect` grants read
+     * permission and returns addresses. Older Xverse builds fall back to
+     * `wallet_requestPermissions` + `getAddresses`.
      */
-    getLovelace(): Promise<string>;
+    private connect;
+    private connectViaWalletConnect;
+    private connectViaPermissions;
+    private requestPermissions;
+    private requestAddresses;
+    private fetchAddresses;
+    getNetwork(): Promise<"Mainnet" | "Testnet4">;
+    getAddresses(addressPurposes: AddressPurpose[]): Promise<BitcoinAddress[]>;
+    getAccounts(addressPurposes: AddressPurpose[]): Promise<BitcoinAccount[]>;
+    getBalance(): Promise<BitcoinBalance>;
+    signMessage(address: string, message: string, protocol?: MessageSigningProtocols): Promise<BitcoinSignature>;
     /**
-     * A helper function to get the assets of a specific policy ID in the wallet.
-     *
-     * @param policyId
-     * @returns a list of assets
+     * Verify a Bitcoin signed-message locally. Trustless — does not call the extension.
+     * Supports the ECDSA 65-byte BIP-137 compact format. Non-ECDSA signatures (e.g. the
+     * BIP-322 format Xverse produces for Taproot addresses) return `{ valid: false }` rather
+     * than throwing, so callers can safely check `result.valid`.
      */
-    getPolicyIdAssets(policyId: string): Promise<AssetExtended[]>;
+    verifyMessage(address: string, message: string, signature: string): Promise<VerifyMessageResult>;
     /**
-     * A helper function to get the policy IDs of all the assets in the wallet.
-     *
-     * @returns a list of policy IDs
+     * Xverse's Sats Connect exposes `sendTransfer` which prompts the user to sign
+     * AND broadcast in one step — there is no "sign-only" variant.
+     * Returns the broadcast txid, satisfying the `IBitcoinWallet.signTransfer` contract.
      */
-    getPolicyIds(): Promise<string[]>;
-    getRegisteredPubStakeKeys(): Promise<{
-        pubStakeKeys: string[];
-        pubStakeKeyHashes: string[];
-    } | undefined>;
-    getUnregisteredPubStakeKeys(): Promise<{
-        pubStakeKeys: string[];
-        pubStakeKeyHashes: string[];
-    } | undefined>;
+    signTransfer(recipients: {
+        address: string;
+        amount: number;
+    }[]): Promise<string>;
+    signPsbt(signConfig: {
+        psbt: string;
+        signInputs?: {
+            [x: string]: number[];
+        } | undefined;
+        broadcast?: boolean | undefined;
+    }): Promise<string>;
     /**
-     * A helper function to create a collateral input for a transaction.
-     *
-     * @returns a transaction hash
+     * Fetch UTXOs for the connected wallet via Sats Connect.
+     * Xverse exposes `wallet_getUtxos` on newer builds; for older builds that
+     * don't support it this will throw a clear METHOD_NOT_FOUND error.
      */
-    createCollateral(): Promise<string>;
-    getPubDRepKey(): {
-        pubDRepKey: string | undefined;
-        dRepIDBech32: string | undefined;
-        dRepIDHash: string | undefined;
-        dRepIDCip105: string | undefined;
-    };
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
     /**
-     * Generate mnemonic or private key
-     *
-     * @param privateKey return private key if true
-     * @returns a transaction hash
+     * Fetch transaction history for the connected wallet via Sats Connect.
+     * Xverse exposes `wallet_getTransactions` on newer builds.
      */
-    static brew(privateKey?: boolean, strength?: number): string[] | string;
-    private getAddressesFromWallet;
-    private buildAddressFromBech32Address;
+    getTransactionHistory(options?: {
+        purposes?: AddressPurpose[];
+        lastSeenTxid?: string;
+    }): Promise<(TransactionsInfo & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+}
+
+interface IMultiChainWallet {
+    cardanoWallet: ICardanoWallet;
+    bitcoinWallet: IBitcoinWallet;
 }
 
-export { type Account, type AccountType, AppWallet, type AppWalletKeyType, BrowserWallet, type CreateAppWalletOptions, type CreateEmbeddedWalletOptions, type CreateMeshWalletOptions, EmbeddedWallet, type EmbeddedWalletKeyType, MeshWallet, WalletStaticMethods, connect, login, register };
+export { type AddressInfo, AddressPurpose, AddressType$1 as AddressType, BaseSigner, type BitcoinAccount, type BitcoinAddress, BitcoinAddressManager, type BitcoinAddressManagerConfig, AddressType as BitcoinAddressType, type BitcoinBalance, BitcoinBrowserWallet, BitcoinHeadlessWallet, type BitcoinHeadlessWalletConfig, BitcoinInMemoryBip32, type BitcoinNetworkName, type BitcoinSignature, type Cardano, CardanoAddress, CardanoBrowserWallet, CardanoHeadlessWallet, type CardanoHeadlessWalletConfig, CardanoInMemoryBip32, type ChainStats, type Credential, type CredentialSource, CredentialType, DerivedBitcoinAddress, type IBitcoinFetcher, type IBitcoinProvider, type IBitcoinSubmitter, type IBitcoinWallet, type ICardanoWallet, type IMultiChainWallet, type InstalledBitcoinWallet, type MempoolStats, MeshCardanoBrowserWallet, MeshCardanoHeadlessWallet, MessageSigningProtocols, type RecoveryId, type ScriptInfo, type TransactionsInfo, type TransactionsStatus, type UTxO, type VerifyMessageResult, type WalletAddressType, XVERSE_ACCESS_DENIED, XverseAdapter, type XverseBitcoinProvider, type XverseResponse, XverseRpcError, deriveP2trAddress, deriveP2wpkhAddress, getCoinType, isXverseInstalled, networkFromName, ordinalsPath, paymentPath, toXOnly, verifyBitcoinMessage };