@babylonlabs-io/wallet-connector 0.4.0

package/dist/context/State.context.d.ts

@@ -0,0 +1,42 @@
+import { PropsWithChildren } from 'react';
+import { IChain, IWallet } from '../core/types';
+export type Screen<T extends string = string> = {
+    type: T;
+    params?: Record<string, any>;
+};
+export type Screens = Screen<"LOADER"> | Screen<"TERMS_OF_SERVICE"> | Screen<"CHAINS"> | Screen<"WALLETS"> | Screen<"INSCRIPTIONS"> | Screen<"ERROR">;
+export interface State {
+    confirmed: boolean;
+    visible: boolean;
+    screen: Screens;
+    selectedWallets: Record<string, IWallet | undefined>;
+    chains: Record<string, IChain>;
+}
+export interface Actions {
+    open?: () => void;
+    close?: () => void;
+    displayLoader?: (message?: string) => void;
+    displayChains?: () => void;
+    displayWallets?: (chain: string) => void;
+    displayInscriptions?: () => void;
+    displayTermsOfService?: () => void;
+    displayError?: (params: {
+        icon?: JSX.Element;
+        title: string;
+        description: string;
+        cancelButton?: string;
+        submitButton?: string;
+        onCancel?: () => void;
+        onSubmit?: () => void;
+    }) => void;
+    selectWallet?: (chain: string, wallet: IWallet) => void;
+    removeWallet?: (chain: string) => void;
+    confirm?: () => void;
+    reset?: () => void;
+}
+export declare const StateContext: import('react').Context<State & Actions>;
+interface StateProviderProps {
+    chains: IChain[];
+}
+export declare function StateProvider({ children, chains }: PropsWithChildren<StateProviderProps>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/core/Wallet.d.ts

@@ -0,0 +1,27 @@
+import { Account, IProvider, IWallet, Network } from './types';
+export interface WalletOptions<P extends IProvider> {
+    id: string;
+    name: string;
+    icon: string;
+    docs: string;
+    networks: Network[];
+    origin: any;
+    provider: P | null;
+    label?: string;
+}
+export declare class Wallet<P extends IProvider> implements IWallet {
+    readonly id: string;
+    readonly origin: any;
+    readonly name: string;
+    readonly icon: string;
+    readonly docs: string;
+    readonly networks: Network[];
+    readonly provider: P | null;
+    private readonly _label?;
+    account: Account | null;
+    constructor({ id, origin, name, icon, docs, networks, provider, label }: WalletOptions<P>);
+    get installed(): boolean;
+    get label(): string;
+    connect(): Promise<this>;
+    clone(): Wallet<P>;
+}

package/dist/core/WalletConnector.d.ts

@@ -0,0 +1,23 @@
+import { Wallet } from './Wallet';
+import { IConnector, IProvider } from './types';
+export interface ConnectorEvents<P extends IProvider> {
+    connecting: (message?: string) => void;
+    connect: (wallet: Wallet<P>) => void;
+    disconnect: (wallet: Wallet<P>) => void;
+    error: (error: Error) => void;
+}
+export declare class WalletConnector<N extends string, P extends IProvider, C> implements IConnector<N, P, C> {
+    readonly id: N;
+    readonly name: string;
+    readonly icon: string;
+    readonly wallets: Wallet<P>[];
+    readonly config: C;
+    private _connectedWallet;
+    private _ee;
+    constructor(id: N, name: string, icon: string, wallets: Wallet<P>[], config: C);
+    get connectedWallet(): Wallet<P> | null;
+    connect(wallet: string | Wallet<P>): Promise<Wallet<P> | null>;
+    disconnect(): Promise<void>;
+    clone(): WalletConnector<N, P, C>;
+    on<K extends keyof ConnectorEvents<P>>(name: K, handler: ConnectorEvents<P>[K]): import('nanoevents').Unsubscribe;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+import { Wallet } from './Wallet';
+import { WalletConnector } from './WalletConnector';
+import { ChainMetadata, ExternalWalletProps, IProvider, WalletMetadata } from './types';
+export declare const createWallet: <P extends IProvider, C>(metadata: WalletMetadata<P, C>, context: any, config: C) => Promise<Wallet<P>>;
+export declare const createExternalWallet: <P extends IProvider>({ id, name, icon, provider }: ExternalWalletProps<P>) => Wallet<P>;
+export declare const createWalletConnector: <N extends string, P extends IProvider, C>(metadata: ChainMetadata<N, P, C>, context: any, config: C) => Promise<WalletConnector<N, P, C>>;

package/dist/core/types.d.ts

@@ -0,0 +1,214 @@
+import { ChainInfo, OfflineAminoSigner, OfflineDirectSigner } from '@keplr-wallet/types';
+import { ComponentType } from 'react';
+export type Fees = {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    economyFee: number;
+    minimumFee: number;
+};
+export interface UTXO {
+    txid: string;
+    vout: number;
+    value: number;
+    scriptPubKey: string;
+}
+export interface InscriptionIdentifier {
+    txid: string;
+    vout: number;
+}
+export declare enum Network {
+    MAINNET = "mainnet",
+    CANARY = "canary",
+    TESTNET = "testnet",
+    SIGNET = "signet"
+}
+export type WalletInfo = {
+    publicKeyHex: string;
+    address: string;
+};
+export interface BTCConfig {
+    coinName: string;
+    coinSymbol: string;
+    networkName: string;
+    mempoolApiUrl: string;
+    network: Network;
+}
+export type BBNConfig = {
+    chainId: string;
+    rpc: string;
+    chainData: ChainInfo;
+    networkName: string;
+    networkFullName: string;
+    coinSymbol: string;
+};
+export interface IProvider {
+    connectWallet: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    getPublicKeyHex: () => Promise<string>;
+}
+export interface IWallet<P extends IProvider = IProvider> {
+    id: string;
+    name: string;
+    icon: string;
+    docs: string;
+    installed: boolean;
+    provider: P | null;
+    account: Account | null;
+    label: string;
+}
+export interface IChain<K extends string = string, P extends IProvider = IProvider, C = any> {
+    id: K;
+    name: string;
+    icon: string;
+    wallets: IWallet<P>[];
+    config: C;
+}
+export interface IConnector<K extends string = string, P extends IProvider = IProvider, C = any> extends IChain<K, P, C> {
+    connect(wallet: string | IWallet<P>): Promise<IWallet<P> | null>;
+    disconnect(): Promise<void>;
+    on(event: string, cb: (wallet: IWallet<P>) => void): () => void;
+}
+export interface Account {
+    address: string;
+    publicKeyHex: string;
+}
+export interface WalletMetadata<P extends IProvider, C> {
+    id: string;
+    wallet?: string | ((context: any, config: C) => any);
+    label?: string;
+    name: string | ((wallet: any, config: C) => Promise<string>);
+    icon: string | ((wallet: any, config: C) => Promise<string>);
+    docs: string;
+    networks: Network[];
+    createProvider: (wallet: any, config: C) => P;
+}
+export interface ChainMetadata<N extends string, P extends IProvider, C> {
+    chain: N;
+    name: string;
+    icon: string;
+    wallets: WalletMetadata<P, C>[];
+}
+export interface ExternalWalletProps<P extends IProvider> {
+    id: string;
+    name: string;
+    icon: string;
+    provider: P;
+}
+export interface WidgetProps<P extends IProvider = IProvider> {
+    id: string;
+    connector: IConnector;
+    createWallet: (props: ExternalWalletProps<P>) => IWallet<P>;
+}
+export type WidgetComponent<P extends IProvider = IProvider> = ComponentType<WidgetProps<P>>;
+export interface ExternalConnector<P extends IProvider = IProvider> {
+    id: string;
+    widget: WidgetComponent<P>;
+}
+export interface IBTCProvider extends IProvider {
+    /**
+     * Connects to the wallet and returns the instance of the wallet provider.
+     * Currently only supports "native segwit" and "taproot" address types.
+     * @returns A promise that resolves to an instance of the wrapper wallet provider in babylon friendly format.
+     * @throws An error if the wallet is not installed or if connection fails.
+     */
+    connectWallet(): Promise<void>;
+    /**
+     * Gets the address of the connected wallet.
+     * @returns A promise that resolves to the address of the connected wallet.
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Gets the public key of the connected wallet.
+     * @returns A promise that resolves to the public key of the connected wallet.
+     */
+    getPublicKeyHex(): Promise<string>;
+    /**
+     * Signs the given PSBT in hex format.
+     * @param psbtHex - The hex string of the unsigned PSBT to sign.
+     * @returns A promise that resolves to the hex string of the signed PSBT.
+     */
+    signPsbt(psbtHex: string): Promise<string>;
+    /**
+     * Signs multiple PSBTs in hex format.
+     * @param psbtsHexes - The hex strings of the unsigned PSBTs to sign.
+     * @returns A promise that resolves to an array of hex strings, each representing a signed PSBT.
+     */
+    signPsbts(psbtsHexes: string[]): Promise<string[]>;
+    /**
+     * Gets the network of the current account.
+     * @returns A promise that resolves to the network of the current account.
+     */
+    getNetwork(): Promise<Network>;
+    /**
+     * Signs a message using the specified signing method.
+     * @param message - The message to sign.
+     * @param type - The signing method to use.
+     * @returns A promise that resolves to the signed message.
+     */
+    signMessage(message: string, type: "ecdsa"): Promise<string>;
+    /**
+     * Retrieves the inscriptions for the connected wallet.
+     * @returns A promise that resolves to an array of inscriptions.
+     */
+    getInscriptions(): Promise<InscriptionIdentifier[]>;
+    /**
+     * Registers an event listener for the specified event.
+     * At the moment, only the "accountChanged" event is supported.
+     * @param eventName - The name of the event to listen for.
+     * @param callBack - The callback function to be executed when the event occurs.
+     */
+    on(eventName: string, callBack: () => void): void;
+    /**
+     * Unregisters an event listener for the specified event.
+     * @param eventName - The name of the event to listen for.
+     * @param callBack - The callback function to be executed when the event occurs.
+     */
+    off(eventName: string, callBack: () => void): void;
+    /**
+     * Gets the name of the wallet provider.
+     * @returns A promise that resolves to the name of the wallet provider.
+     */
+    getWalletProviderName(): Promise<string>;
+    /**
+     * Gets the icon of the wallet provider.
+     * @returns A promise that resolves to the icon of the wallet provider.
+     */
+    getWalletProviderIcon(): Promise<string>;
+}
+export interface IBBNProvider extends IProvider {
+    /**
+     * Connects to the wallet and returns the instance of the wallet provider.
+     * @returns A promise that resolves to an instance of the wrapper wallet provider.
+     * @throws An error if the wallet is not installed or if connection fails.
+     */
+    connectWallet(): Promise<void>;
+    /**
+     * Gets the address of the connected wallet.
+     * @returns A promise that resolves to the address of the connected wallet.
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Gets the public key of the connected wallet.
+     * @returns A promise that resolves to the public key of the connected wallet.
+     */
+    getPublicKeyHex(): Promise<string>;
+    /**
+     * Gets the name of the wallet provider.
+     * @returns A promise that resolves to the name of the wallet provider.
+     */
+    getWalletProviderName(): Promise<string>;
+    /**
+     * Gets the icon of the wallet provider.
+     * @returns A promise that resolves to the icon of the wallet provider.
+     */
+    getWalletProviderIcon(): Promise<string>;
+    /**
+     * Retrieves an offline signer that supports both Amino and Direct signing methods.
+     * This signer is used for signing transactions offline before broadcasting them to the network.
+     *
+     * @returns {Promise<OfflineAminoSigner & OfflineDirectSigner>} A promise that resolves to a signer supporting both Amino and Direct signing
+     * @throws {Error} If wallet connection is not established or signer cannot be retrieved
+     */
+    getOfflineSigner(): Promise<OfflineAminoSigner & OfflineDirectSigner>;
+}

package/dist/core/utils/bip322.d.ts

@@ -0,0 +1,41 @@
+import * as bitcoin from "bitcoinjs-lib";
+/**
+ * https://github.com/ACken2/bip322-js/blob/main/src/BIP322.ts
+ * use the existing the bip322-js file with some modification, use the file directly instead of install the whole package,
+ * because the package will introduce too many dependencies.
+ * Class that handles BIP-322 related operations.
+ */
+declare class BIP322 {
+    static TAG: Buffer;
+    /**
+     * Compute the message hash as specified in the BIP-322.
+     * The standard is specified in BIP-340 as:
+     *      The function hashtag(x) where tag is a UTF-8 encoded tag name and x is a byte array returns the 32-byte hash SHA256(SHA256(tag) || SHA256(tag) || x).
+     * @param message Message to be hashed
+     * @returns Hashed message
+     */
+    static hashMessage(message: string): Buffer;
+    /**
+     * Build a to_spend transaction using simple signature in accordance to the BIP-322.
+     * @param message Message to be signed using BIP-322
+     * @param scriptPublicKey The script public key for the signing wallet
+     * @returns Bitcoin transaction that correspond to the to_spend transaction
+     */
+    static buildToSpendTx(message: string, scriptPublicKey: Buffer): bitcoin.Transaction;
+    /**
+     * Build a to_sign transaction using simple signature in accordance to the BIP-322.
+     * @param toSpendTxId Transaction ID of the to_spend transaction as constructed by buildToSpendTx
+     * @param witnessScript The script public key for the signing wallet, or the redeemScript for P2SH-P2WPKH address
+     * @param isRedeemScript Set to true if the provided witnessScript is a redeemScript for P2SH-P2WPKH address, default to false
+     * @param tapInternalKey Used to set the taproot internal public key of a taproot signing address when provided, default to undefined
+     * @returns Ready-to-be-signed bitcoinjs.Psbt transaction
+     */
+    static buildToSignTx(toSpendTxId: string, witnessScript: Buffer, isRedeemScript?: boolean, tapInternalKey?: Buffer): bitcoin.Psbt;
+    /**
+     * Encode witness stack in a signed BIP-322 PSBT into its base-64 encoded format.
+     * @param signedPsbt Signed PSBT
+     * @returns Base-64 encoded witness data
+     */
+    static encodeWitness(signedPsbt: bitcoin.Psbt): string;
+}
+export default BIP322;

package/dist/core/utils/mempool.d.ts

@@ -0,0 +1,10 @@
+import { Fees, UTXO } from '../types';
+export interface MempoolApi {
+    pushTx(txHex: string): Promise<string>;
+    getAddressBalance(address: string): Promise<number>;
+    getNetworkFees(): Promise<Fees>;
+    getTipHeight(): Promise<number>;
+    getFundingUTXOs(address: string, amount?: number): Promise<UTXO[]>;
+    getTxInfo(txId: string): Promise<any>;
+}
+export declare function createMempoolAPI(mempoolApiUrl: string): MempoolApi;

package/dist/core/utils/wallet.d.ts

@@ -0,0 +1,8 @@
+import { networks } from 'bitcoinjs-lib';
+import { Network } from '../types';
+export declare const COMPRESSED_PUBLIC_KEY_HEX_LENGTH = 66;
+export declare const getTaprootAddress: (publicKey: string, network: Network) => string;
+export declare const getNativeSegwitAddress: (publicKey: string, network: Network) => string;
+export declare function validateAddressWithPK(address: string, publicKey: string, network: Network): boolean;
+export declare function validateAddress(network: Network, address: string): void;
+export declare const toNetwork: (network: Network) => networks.Network;

package/dist/core/wallets/bbn/index.d.ts

@@ -0,0 +1,3 @@
+import { BBNConfig, ChainMetadata, IBBNProvider } from '../../types';
+declare const metadata: ChainMetadata<"BBN", IBBNProvider, BBNConfig>;
+export default metadata;

package/dist/core/wallets/bbn/injectable/index.d.ts

@@ -0,0 +1,3 @@
+import { IBBNProvider, BBNConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBBNProvider, BBNConfig>;
+export default metadata;

package/dist/core/wallets/bbn/keplr/index.d.ts

@@ -0,0 +1,3 @@
+import { IBBNProvider, BBNConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBBNProvider, BBNConfig>;
+export default metadata;

package/dist/core/wallets/bbn/keplr/provider.d.ts

@@ -0,0 +1,22 @@
+import { Window as KeplrWindow } from '@keplr-wallet/types';
+import { OfflineAminoSigner, OfflineDirectSigner } from '@keplr-wallet/types/src/cosmjs';
+import { BBNConfig, IBBNProvider } from '../../../types';
+declare global {
+    interface Window extends KeplrWindow {
+    }
+}
+export declare const WALLET_PROVIDER_NAME = "Keplr";
+export declare class KeplrProvider implements IBBNProvider {
+    private keplr;
+    private walletInfo;
+    private chainId;
+    private rpc;
+    private chainData;
+    constructor(keplr: Window["keplr"], config: BBNConfig);
+    connectWallet(): Promise<void>;
+    getAddress(): Promise<string>;
+    getPublicKeyHex(): Promise<string>;
+    getWalletProviderName(): Promise<string>;
+    getWalletProviderIcon(): Promise<string>;
+    getOfflineSigner(): Promise<OfflineAminoSigner & OfflineDirectSigner>;
+}

package/dist/core/wallets/bbn/leap/index.d.ts

@@ -0,0 +1,3 @@
+import { IBBNProvider, BBNConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBBNProvider, BBNConfig>;
+export default metadata;

package/dist/core/wallets/bbn/leap/provider.d.ts

@@ -0,0 +1,17 @@
+import { OfflineAminoSigner, OfflineDirectSigner } from '@keplr-wallet/types/src/cosmjs';
+import { BBNConfig, IBBNProvider } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "Leap";
+export declare class LeapProvider implements IBBNProvider {
+    private wallet;
+    private walletInfo;
+    private chainId;
+    private rpc;
+    private chainData;
+    constructor(wallet: any, config: BBNConfig);
+    connectWallet(): Promise<void>;
+    getAddress(): Promise<string>;
+    getPublicKeyHex(): Promise<string>;
+    getWalletProviderName(): Promise<string>;
+    getWalletProviderIcon(): Promise<string>;
+    getOfflineSigner(): Promise<OfflineAminoSigner & OfflineDirectSigner>;
+}

package/dist/core/wallets/bbn/okx/index.d.ts

@@ -0,0 +1,3 @@
+import { IBBNProvider, BBNConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBBNProvider, BBNConfig>;
+export default metadata;

package/dist/core/wallets/bbn/okx/provider.d.ts

@@ -0,0 +1,17 @@
+import { OfflineAminoSigner, OfflineDirectSigner } from '@keplr-wallet/types/src/cosmjs';
+import { BBNConfig, IBBNProvider } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "OKX";
+export declare class OKXBabylonProvider implements IBBNProvider {
+    private wallet;
+    private walletInfo;
+    private chainId;
+    private rpc;
+    private chainData;
+    constructor(wallet: any, config: BBNConfig);
+    connectWallet(): Promise<void>;
+    getAddress(): Promise<string>;
+    getPublicKeyHex(): Promise<string>;
+    getWalletProviderName(): Promise<string>;
+    getWalletProviderIcon(): Promise<string>;
+    getOfflineSigner(): Promise<OfflineAminoSigner & OfflineDirectSigner>;
+}

package/dist/core/wallets/btc/index.d.ts

@@ -0,0 +1,3 @@
+import { BTCConfig, ChainMetadata, IBTCProvider } from '../../types';
+declare const metadata: ChainMetadata<"BTC", IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/injectable/index.d.ts

@@ -0,0 +1,3 @@
+import { IBTCProvider, BTCConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/keystone/index.d.ts

@@ -0,0 +1,3 @@
+import { IBTCProvider, BTCConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/keystone/provider.d.ts

@@ -0,0 +1,42 @@
+import { BTCConfig, InscriptionIdentifier, IBTCProvider, Network } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "Keystone";
+export declare class KeystoneProvider implements IBTCProvider {
+    private keystoneWaleltInfo;
+    private viewSDK;
+    private dataSdk;
+    private config;
+    constructor(_wallet: any, config: BTCConfig);
+    /**
+     * Connects the staking app to the Keystone device and retrieves the necessary information.
+     * @returns A Promise that resolves to the current instance of the class.
+     * @throws An error if there is an issue reading the QR code or retrieving the extended public key.
+     */
+    connectWallet: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    getPublicKeyHex: () => Promise<string>;
+    signPsbt: (psbtHex: string) => Promise<string>;
+    signPsbts: (psbtsHexes: string[]) => Promise<string[]>;
+    getNetwork: () => Promise<Network>;
+    signMessage: (message: string, type: "ecdsa") => Promise<string>;
+    getInscriptions: () => Promise<InscriptionIdentifier[]>;
+    on: () => void;
+    off: () => void;
+    getWalletProviderName: () => Promise<string>;
+    getWalletProviderIcon: () => Promise<string>;
+    /**
+     * Sign the PSBT with the Keystone device.
+     *
+     * @param psbtHex - The PSBT in hex format.
+     * @returns The signed PSBT in hex format.
+     * */
+    private sign;
+    /**
+     * Add the BIP32 derivation information for each input.
+     * The Keystone device is stateless, so it needs to know which key to use to sign the PSBT.
+     * Therefore, add the Taproot BIP32 derivation information to the PSBT.
+     * https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki#Specification
+     * @param psbt - The PSBT object.
+     * @returns The PSBT object with the BIP32 derivation information added.
+     */
+    private enhancePsbt;
+}

package/dist/core/wallets/btc/okx/index.d.ts

@@ -0,0 +1,3 @@
+import { IBTCProvider, BTCConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/okx/provider.d.ts

@@ -0,0 +1,21 @@
+import { BTCConfig, InscriptionIdentifier, IBTCProvider, Network } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "OKX";
+export declare class OKXProvider implements IBTCProvider {
+    private wallet;
+    private provider;
+    private walletInfo;
+    private config;
+    constructor(wallet: any, config: BTCConfig);
+    connectWallet: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    getPublicKeyHex: () => Promise<string>;
+    signPsbt: (psbtHex: string) => Promise<string>;
+    signPsbts: (psbtsHexes: string[]) => Promise<string[]>;
+    getNetwork: () => Promise<Network>;
+    signMessage: (message: string, type: "ecdsa") => Promise<string>;
+    getInscriptions: () => Promise<InscriptionIdentifier[]>;
+    on: (eventName: string, callBack: () => void) => any;
+    off: (eventName: string, callBack: () => void) => any;
+    getWalletProviderName: () => Promise<string>;
+    getWalletProviderIcon: () => Promise<string>;
+}

package/dist/core/wallets/btc/onekey/index.d.ts

@@ -0,0 +1,3 @@
+import { IBTCProvider, BTCConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/onekey/provider.d.ts

@@ -0,0 +1,20 @@
+import { BTCConfig, IBTCProvider, InscriptionIdentifier, Network } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "OneKey";
+export declare class OneKeyProvider implements IBTCProvider {
+    private provider;
+    private walletInfo;
+    private config;
+    constructor(wallet: any, config: BTCConfig);
+    connectWallet: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    getPublicKeyHex: () => Promise<string>;
+    signPsbt: (psbtHex: string) => Promise<string>;
+    signPsbts: (psbtsHexes: string[]) => Promise<string[]>;
+    getNetwork: () => Promise<Network>;
+    signMessage: (message: string, type: "ecdsa") => Promise<string>;
+    getInscriptions: () => Promise<InscriptionIdentifier[]>;
+    on: (eventName: string, callBack: () => void) => any;
+    off: (eventName: string, callBack: () => void) => any;
+    getWalletProviderName: () => Promise<string>;
+    getWalletProviderIcon: () => Promise<string>;
+}

package/dist/core/wallets/btc/unisat/index.d.ts

@@ -0,0 +1,3 @@
+import { IBTCProvider, BTCConfig, WalletMetadata } from '../../../types';
+declare const metadata: WalletMetadata<IBTCProvider, BTCConfig>;
+export default metadata;

package/dist/core/wallets/btc/unisat/provider.d.ts

@@ -0,0 +1,21 @@
+import { BTCConfig, IBTCProvider, InscriptionIdentifier, Network } from '../../../types';
+export declare const WALLET_PROVIDER_NAME = "Unisat";
+export declare class UnisatProvider implements IBTCProvider {
+    private provider;
+    private walletInfo;
+    private config;
+    constructor(wallet: any, config: BTCConfig);
+    connectWallet: () => Promise<void>;
+    getAddress: () => Promise<string>;
+    getPublicKeyHex: () => Promise<string>;
+    signPsbt: (psbtHex: string) => Promise<string>;
+    signPsbts: (psbtsHexes: string[]) => Promise<string[]>;
+    private getSignPsbtDefaultOptions;
+    getNetwork: () => Promise<Network>;
+    signMessage: (message: string, type: "ecdsa") => Promise<string>;
+    getInscriptions: () => Promise<InscriptionIdentifier[]>;
+    on: (eventName: string, callBack: () => void) => any;
+    off: (eventName: string, callBack: () => void) => any;
+    getWalletProviderName: () => Promise<string>;
+    getWalletProviderIcon: () => Promise<string>;
+}

package/dist/core/wallets/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    readonly BTC: import('../types').ChainMetadata<"BTC", import('../types').IBTCProvider, import('../types').BTCConfig>;
+    readonly BBN: import('../types').ChainMetadata<"BBN", import('../types').IBBNProvider, import('../types').BBNConfig>;
+};
+export default _default;