@meshsdk/wallet 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+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>;
@@ -11,13 +15,13 @@ interface ISecretManager {
     getSigner(derivationPath: DerivationPath): Promise<ISigner>;
 }
 
-declare class InMemoryBip32 implements ISecretManager {
+declare class CardanoInMemoryBip32 implements ISecretManager {
     private bip32PrivateKey;
     private constructor();
-    static fromMnemonic(mnemonic: string[], password?: string): Promise<InMemoryBip32>;
-    static fromEntropy(entropy: string, password?: string): Promise<InMemoryBip32>;
-    static fromKeyHex(keyHex: string): InMemoryBip32;
-    static fromBech32(bech32: string): InMemoryBip32;
+    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.
@@ -30,6 +34,21 @@ declare class InMemoryBip32 implements ISecretManager {
     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.
@@ -83,17 +102,17 @@ type Credential = {
     type: CredentialType;
     hash: string;
 };
-declare enum AddressType {
+declare enum AddressType$1 {
     Enterprise = 0,
     Base = 1,
     Reward = 2
 }
 declare class CardanoAddress {
-    addressType: AddressType;
+    addressType: AddressType$1;
     networkId: number;
     paymentCredential: Credential;
     stakeCredential?: Credential;
-    constructor(addressType: AddressType, networkId: number, paymentCredential: Credential, stakeCredential?: Credential);
+    constructor(addressType: AddressType$1, networkId: number, paymentCredential: Credential, stakeCredential?: Credential);
     getAddressBech32(): string;
     getAddressHex(): string;
     private getEnterpriseAddressBech32;
@@ -104,4 +123,1137 @@ declare class CardanoAddress {
     private getRewardAddressHex;
 }
 
-export { AddressType, BaseSigner, CardanoAddress, type Credential, CredentialType, InMemoryBip32 };
+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;
+        icon: string;
+        apiVersion: string;
+        enable: (extensions?: {
+            extensions: {
+                cip: number;
+            }[];
+        }) => Promise<ICardanoWallet>;
+        supportedExtensions?: {
+            cip: number;
+        }[];
+    };
+};
+type Extension = {
+    cip: number;
+};
+declare class CardanoBrowserWallet implements ICardanoWallet {
+    walletInstance: ICardanoWallet;
+    constructor(walletInstance: 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(addressBech32: string, data: string): Promise<DataSignature>;
+    submitTx(tx: string): Promise<string>;
+    /**
+     * 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 getInstalledWallets(): Wallet[];
+    /**
+     * This is the entrypoint to start communication with the user's wallet. The wallet should request the user's permission to connect the web page to the user's wallet, and if permission has been granted, the wallet will be returned and exposing the full API for the app to use.
+     *
+     * Query BrowserWallet.getInstalledWallets() to get a list of available wallets, then provide the wallet name for which wallet the user would like to connect with.
+     *
+     * @param walletName - the name of the wallet to enable (e.g. "eternl", "begin")
+     * @param extensions - optional, a list of CIPs that the wallet should support
+     * @returns WalletInstance
+     */
+    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;
+    /**
+     * The network ID (0 for testnet, 1 for mainnet).
+     */
+    networkId: number;
+    /**
+     * The type of wallet address to use (Base or Enterprise).
+     * Base addresses include staking capabilities, while Enterprise addresses do not.
+     */
+    walletAddressType: WalletAddressType;
+    /**
+     * Optional fetcher instance for querying blockchain data (UTxOs, protocol parameters, etc.).
+     */
+    fetcher?: IFetcher;
+    /**
+     * Optional submitter instance for submitting transactions to the blockchain.
+     */
+    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>;
+    /**
+     * 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>;
+    /**
+     * 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.
+     *
+     * 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
+     */
+    getUtxos(): Promise<string[]>;
+    /**
+     * Get the collateral UTxOs for the wallet.
+     *
+     * 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
+     */
+    getCollateral(): Promise<string[]>;
+    /**
+     * Get the balance of the wallet.
+     *
+     * 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
+     */
+    getBalance(): Promise<string>;
+    /**
+     * 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 {Promise<string[]>} A promise that resolves to an array of used addresses in hex format
+     */
+    getUsedAddresses(): Promise<string[]>;
+    /**
+     * Get the unused addresses for the wallet.
+     *
+     * 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
+     */
+    getUnusedAddresses(): Promise<string[]>;
+    /**
+     * 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 {Promise<string>} A promise that resolves to the change address in hex format
+     */
+    getChangeAddress(): Promise<string>;
+    /**
+     * Get the reward address for the wallet.
+     *
+     * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in hex format
+     */
+    getRewardAddresses(): Promise<string[]>;
+    /**
+     * Sign a transaction with the wallet.
+     *
+     * 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 witness set with the signatures in CBOR hex format
+     */
+    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 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.
+     *
+     * 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
+     */
+    getUtxosMesh(): Promise<UTxO$1[]>;
+    /**
+     * Get the collateral UTxOs for the wallet.
+     *
+     * 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<UTxO[]>} A promise that resolves to an array of UTxOs in the Mesh UTxO format
+     */
+    getCollateralMesh(): Promise<UTxO$1[]>;
+    /**
+     * Get the balance of the wallet.
+     *
+     * 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
+     */
+    getBalanceMesh(): Promise<Asset[]>;
+    /**
+     * 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 {Promise<string[]>} A promise that resolves to an array of used addresses in Bech32 format
+     */
+    getUsedAddressesBech32(): Promise<string[]>;
+    /**
+     * Get the unused addresses for the wallet.
+     *
+     * 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
+     */
+    getUnusedAddressesBech32(): Promise<string[]>;
+    /**
+     * 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 {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
+     */
+    getRewardAddressesBech32(): Promise<string[]>;
+    /**
+     * Sign a transaction with the wallet.
+     *
+     * 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
+     */
+    signTxReturnFullTx(tx: string, partialSign?: boolean): Promise<string>;
+}
+
+type TransactionsStatus = {
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+};
+
+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;
+};
+
+type UTxO = {
+    status: {
+        block_hash: string;
+        block_height: number;
+        block_time: number;
+        confirmed: boolean;
+    };
+    txid: string;
+    value: number;
+    vout: number;
+};
+
+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 BitcoinAccount = {
+    walletType: "software" | "ledger" | "keystone";
+    address: string;
+    publicKey: string;
+    purpose: AddressPurpose;
+    addressType: AddressType;
+};
+type BitcoinBalance = {
+    confirmed: string;
+    unconfirmed: string;
+    total: string;
+};
+declare enum MessageSigningProtocols {
+    ECDSA = "ECDSA",
+    BIP322 = "BIP322"
+}
+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 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;
+};
+
+/**
+ * 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.
+ *
+ * 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
+ *
+ * `coinType` is 0 for mainnet, 1 for any testnet (including Testnet4).
+ */
+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;
+    /**
+     * 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).
+     */
+    root?: BIP32Interface;
+    /**
+     * Account index for hardened account derivation (defaults to 0).
+     */
+    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;
+    /**
+     * Get the address for a single purpose, deriving fresh from the root.
+     */
+    getAddress(purpose: AddressPurpose, change?: number, index?: number): DerivedBitcoinAddress;
+    /**
+     * 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`).
+     */
+    getAddresses(purposes?: AddressPurpose[]): DerivedBitcoinAddress[];
+    /**
+     * Get the BIP-32 child node for a purpose — needed for signing.
+     */
+    getChild(purpose: AddressPurpose, change?: number, index?: number): BIP32Interface;
+    /**
+     * 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.
+     */
+    getAddressesByPurpose(purpose: AddressPurpose, start?: number, count?: number, change?: number): DerivedBitcoinAddress[];
+    /**
+     * 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.
+     *
+     * 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.
+     *
+     * BIP-84:  m/84'/coin_type'/account'
+     * BIP-86:  m/86'/coin_type'/account'
+     */
+    private getAccountNode;
+    /**
+     * Export the BIP-84 (P2WPKH) account public key as a standard base58 xpub
+     * (mainnet) or tpub (testnet).
+     *
+     * Example: `xpub6CQdKacu...`
+     */
+    getAccountXpub(): string;
+    /**
+     * Export the BIP-86 (P2TR / Taproot) account public key as a standard
+     * base58 xpub (mainnet) or tpub (testnet).
+     *
+     * Example: `xpub6D5r3aJk...`
+     */
+    getTaprootXpub(): string;
+    /**
+     * 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.
+     *
+     * Conversion: decode the xpub/tpub base58check bytes, replace the first
+     * 4 version bytes, and re-encode. The 74 payload bytes are unchanged.
+     */
+    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);
+    /**
+     * Create a headless wallet from an existing BIP-32 root and configuration.
+     */
+    static create(config: BitcoinHeadlessWalletConfig & {
+        root: BIP32Interface;
+    }): Promise<BitcoinHeadlessWallet>;
+    /**
+     * Create a headless wallet from a BIP-39 mnemonic phrase.
+     */
+    static fromMnemonic(config: BitcoinHeadlessWalletConfig & {
+        mnemonic: string[];
+    }): Promise<BitcoinHeadlessWallet>;
+    /**
+     * Create a headless wallet from BIP-39 entropy (hex 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>;
+    /**
+     * Derive a contiguous range of addresses for a single purpose / change level.
+     * Delegates to `BitcoinAddressManager.getAddressesByPurpose`.
+     */
+    getAddressesByPurpose(purpose: AddressPurpose, start?: number, count?: number, change?: number): DerivedBitcoinAddress[];
+    /**
+     * 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`.
+     */
+    findManagedAddress(address: string, purpose: AddressPurpose, maxGap?: number): DerivedBitcoinAddress | undefined;
+    /**
+     * Export the BIP-84 (P2WPKH) account public key as xpub (mainnet) / tpub (testnet).
+     * Delegates to `BitcoinAddressManager.getAccountXpub`.
+     */
+    getAccountXpub(): string;
+    /**
+     * Export the BIP-86 (P2TR / Taproot) account public key as xpub (mainnet) / tpub (testnet).
+     * Delegates to `BitcoinAddressManager.getTaprootXpub`.
+     */
+    getTaprootXpub(): string;
+    /**
+     * Export the BIP-84 account public key with the zpub (mainnet) / vpub (testnet)
+     * version prefix. Delegates to `BitcoinAddressManager.getAccountZpub`.
+     */
+    getAccountZpub(): string;
+    /**
+     * 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).
+     */
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+    /**
+     * 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).
+     */
+    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;
+    })[]>;
+    /**
+     * Removes the persisted wallet selection so `restore()` returns `null` on
+     * the next page load. Call this on an explicit user-initiated disconnect.
+     */
+    disconnect(): void;
+    /**
+     * Returns a list of Bitcoin wallets the user has installed in the browser.
+     * Throws when called outside a browser (SSR).
+     */
+    static getInstalledWallets(): InstalledBitcoinWallet[];
+    /**
+     * Returns `true` when a wallet session has been persisted and `restore()`
+     * (or `enable()` with `persist: true`) can reconnect it silently.
+     */
+    static hasPersistedSession(): boolean;
+    /**
+     * Connect to a wallet, returning a wrapped `BitcoinBrowserWallet`.
+     *
+     * When `options.persist` is `true` the behaviour differs depending on
+     * whether a prior session exists:
+     *
+     *   • **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.
+     */
+    static enable(walletName: string, options?: {
+        persist?: boolean;
+    }): Promise<BitcoinBrowserWallet>;
+    /**
+     * Silently reconnects using the wallet name saved by a previous
+     * `enable({ persist: true })` call.
+     *
+     * 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.
+     */
+    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>;
+    /**
+     * Establish a dApp connection per Sats Connect: `wallet_connect` grants read
+     * permission and returns addresses. Older Xverse builds fall back to
+     * `wallet_requestPermissions` + `getAddresses`.
+     */
+    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>;
+    /**
+     * 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`.
+     */
+    verifyMessage(address: string, message: string, signature: string): Promise<VerifyMessageResult>;
+    /**
+     * 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.
+     */
+    signTransfer(recipients: {
+        address: string;
+        amount: number;
+    }[]): Promise<string>;
+    signPsbt(signConfig: {
+        psbt: string;
+        signInputs?: {
+            [x: string]: number[];
+        } | undefined;
+        broadcast?: boolean | undefined;
+    }): Promise<string>;
+    /**
+     * 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.
+     */
+    fetchUTXOs(purposes?: AddressPurpose[]): Promise<(UTxO & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+    /**
+     * Fetch transaction history for the connected wallet via Sats Connect.
+     * Xverse exposes `wallet_getTransactions` on newer builds.
+     */
+    getTransactionHistory(options?: {
+        purposes?: AddressPurpose[];
+        lastSeenTxid?: string;
+    }): Promise<(TransactionsInfo & {
+        address: string;
+        purpose: AddressPurpose;
+    })[]>;
+}
+
+interface IMultiChainWallet {
+    cardanoWallet: ICardanoWallet;
+    bitcoinWallet: IBitcoinWallet;
+}
+
+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 };