@txnlab/use-wallet 0.1.22 → 1.0.0

package/dist/index.d.ts

@@ -1,24 +1,12 @@
-import _algosdk from 'algosdk';
-
-declare enum PROVIDER_ID {
-    KMD_WALLET = "KMD Wallet",
-    PERA_WALLET = "Pera Wallet",
-    MYALGO_WALLET = "MyAlgo Wallet",
-    ALGO_SIGNER = "Algo Signer",
-    DEFLY = "Defly",
-    EXODUS = "Exodus",
-    WALLET_CONNECT = "Wallet Connect"
-}
-declare const NODE_SERVER: string;
-declare const NODE_TOKEN: string;
-declare const NODE_PORT: string;
-declare const NODE_NETWORK: string;
-declare const KMD_HOST: string;
-declare const KMD_TOKEN: string;
-declare const KMD_PORT: string;
-declare const KMD_WALLET: string;
-declare const KMD_PASSWORD: string;
+import _algosdk, { Transaction } from 'algosdk';
+import * as react from 'react';
+import { PeraWalletConnect } from '@perawallet/connect';
+import _MyAlgoConnect from '@randlabs/myalgo-connect';
+import { DeflyWalletConnect } from '@blockshake/defly-connect';
+import WalletConnect from '@walletconnect/client';
+import QRCodeModal from 'algorand-walletconnect-qrcode-modal';
 
+declare type Network = "betanet" | "testnet" | "mainnet" | string;
 declare type Txn = {
     apaa: Uint8Array;
     apas: number[];
@@ -59,6 +47,7 @@ declare type DecodedSignedTransaction = {
     sig: Uint8Array;
     txn: DecodedTransaction;
 };
+declare type AlgodClientOptions = ConstructorParameters<typeof _algosdk.Algodv2>;
 
 declare type TransactionsArray = ["u" | "s", string][];
 declare type TxnInfo = {
@@ -71,22 +60,65 @@ declare type TxnInfo = {
     signedTxn?: Uint8Array;
 };
 
-interface BaseWalletInterface {
-    connect(onDisconnect: () => void): Promise<Wallet>;
-    healthCheck(): Promise<Record<string, never>>;
-    disconnect(): Promise<void>;
-    reconnect(onDisconnect: () => void): Promise<Wallet | null>;
-    decodeTransaction(txn: string, isSigned: boolean): _algosdk.Transaction;
-    logEncodedTransaction(txn: string, isSigned: boolean): void;
-    groupTransactionsBySender(transactions: TransactionsArray): Record<string, TxnInfo[]>;
-    signTransactions(activeAddress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
-    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-    sendRawTransactions(transactions: Uint8Array[]): Promise<ConfirmedTxn & {
-        id: string;
-    }>;
+declare enum PROVIDER_ID {
+    KMD = "kmd",
+    PERA = "pera",
+    MYALGO = "myalgo",
+    ALGOSIGNER = "algosigner",
+    DEFLY = "defly",
+    EXODUS = "exodus",
+    WALLETCONNECT = "walletconnect"
+}
+declare const DEFAULT_NETWORK: Network;
+declare const DEFAULT_NODE_BASEURL = "https://mainnet-api.algonode.cloud";
+declare const DEFAULT_NODE_TOKEN = "";
+declare const DEFAULT_NODE_PORT = "";
+
+declare abstract class BaseClient {
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    keepWCAlive: HTMLAudioElement;
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    abstract connect(onDisconnect: () => void): Promise<Wallet>;
+    abstract disconnect(): Promise<void>;
+    abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
+    abstract signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    abstract signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+    protected constructor(algosdk: typeof _algosdk, algodClient: _algosdk.Algodv2);
+    healthCheck(): Promise<{}>;
     getAccountInfo(address: string): Promise<AccountInfo>;
     getAssets(address: string): Promise<Asset[]>;
-    waitForConfirmation(txId: string, timeout?: number): Promise<ConfirmedTxn>;
+    waitForConfirmation(txId: string, timeout?: number): Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: Txn;
+        };
+        txId: string;
+    }>;
+    decodeTransaction: (txn: string, isSigned: boolean) => _algosdk.Transaction;
+    logEncodedTransaction(txn: string, isSigned: boolean): void;
+    groupTransactionsBySender(transactions: TransactionsArray): Record<string, any>;
+    sendRawTransactions(transactions: Uint8Array[], waitRoundsToConfirm?: number): Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: Txn;
+        };
+        txId: string;
+        id: any;
+    }>;
+    keepWCAliveStart(): void;
+    keepWCAliveStop(): void;
 }
 
 interface Account {
@@ -132,55 +164,626 @@ declare type ExtendValues<Type> = {
 declare type Wallet = ExtendValues<WalletProvider> & {
     accounts: Account[];
 };
-declare type WalletClient = BaseWalletInterface;
+declare type WalletClient = BaseClient;
 
 declare function useWallet(): {
-    accounts: Account[];
+    clients: Partial<{
+        kmd: Promise<BaseClient | null>;
+        pera: Promise<BaseClient | null>;
+        myalgo: Promise<BaseClient | null>;
+        algosigner: Promise<BaseClient | null>;
+        defly: Promise<BaseClient | null>;
+        exodus: Promise<BaseClient | null>;
+        walletconnect: Promise<BaseClient | null>;
+    }> | null;
+    providers: ({
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    } | {
+        accounts: Account[];
+        isActive: boolean;
+        isConnected: boolean;
+        connect: () => Promise<void>;
+        disconnect: () => Promise<void>;
+        reconnect: () => Promise<void>;
+        setActiveProvider: () => Promise<void>;
+        setActiveAccount: (account: string) => Promise<void>;
+        metadata: {
+            id: PROVIDER_ID;
+            name: string;
+            icon: string;
+            isWalletConnect: boolean;
+        };
+    })[] | null;
+    connectedAccounts: Account[];
+    connectedActiveAccounts: Account[];
     activeAccount: Account | null;
+    activeAddress: string | undefined;
     signer: _algosdk.TransactionSigner;
     signTransactions: (transactions: Array<Uint8Array>) => Promise<Uint8Array[]>;
-    sendTransactions: (transactions: Uint8Array[]) => Promise<ConfirmedTxn & {
-        id: string;
+    sendTransactions: (transactions: Uint8Array[], waitRoundsToConfirm?: number) => Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: Txn;
+        };
+        txId: string;
+        id: any;
     }>;
     getAddress: () => string | undefined;
-    groupTransactionsBySender: (transactions: TransactionsArray) => Promise<Record<string, TxnInfo[]>>;
+    groupTransactionsBySender: (transactions: TransactionsArray) => Promise<Record<string, any>>;
     getAccountInfo: () => Promise<AccountInfo>;
     getAssets: () => Promise<Asset[]>;
     signEncodedTransactions: (transactions: TransactionsArray) => Promise<Uint8Array[]>;
-    sendRawTransactions: (transactions: Uint8Array[]) => Promise<ConfirmedTxn & {
-        id: string;
+    sendRawTransactions: (transactions: Uint8Array[], waitRoundsToConfirm?: number) => Promise<{
+        "confirmed-round": number;
+        "global-state-delta": Record<string, unknown>[];
+        "pool-error": string;
+        txn: {
+            sig: Uint8Array;
+            txn: Txn;
+        };
+        txId: string;
+        id: any;
     }>;
 };
 
-declare type Options = Partial<{
-    providers: PROVIDER_ID[];
-}>;
-declare function useConnectWallet(options?: Options): {
-    providers: {
+declare type SupportedProviders$1 = {
+    [x: string]: Promise<WalletClient | null>;
+};
+declare type NodeConfig = {
+    network: Network;
+    nodeServer: string;
+    nodeToken?: string;
+    nodePort?: string;
+};
+declare const initializeProviders: (providers?: PROVIDER_ID[], nodeConfig?: NodeConfig, algosdkStatic?: typeof _algosdk) => SupportedProviders$1;
+
+declare type SupportedProviders = {
+    [x: string]: Promise<WalletClient | null>;
+};
+declare const reconnectProviders: (providers: SupportedProviders) => Promise<void>;
+
+declare const _default: react.Provider<Partial<{
+    kmd: Promise<BaseClient | null>;
+    pera: Promise<BaseClient | null>;
+    myalgo: Promise<BaseClient | null>;
+    algosigner: Promise<BaseClient | null>;
+    defly: Promise<BaseClient | null>;
+    exodus: Promise<BaseClient | null>;
+    walletconnect: Promise<BaseClient | null>;
+}> | null>;
+
+declare type ClientOptions$5 = {
+    bridge?: string;
+    deep_link?: string;
+    app_meta?: {
+        logo: string;
+        name: string;
+        main_color: string;
+    };
+    shouldShowSignTxnToast?: boolean;
+};
+interface PeraTransaction {
+    txn: Transaction;
+    /**
+     * Optional list of addresses that must sign the transactions.
+     * Wallet skips to sign this txn if signers is empty array.
+     * If undefined, wallet tries to sign it.
+     */
+    signers?: string[];
+}
+declare type PeraWalletClientConstructor = {
+    client: PeraWalletConnect;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$6 = {
+    clientOptions?: ClientOptions$5;
+    algodOptions?: AlgodClientOptions;
+    clientStatic?: typeof PeraWalletConnect;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+
+declare class PeraWalletClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, network, }: PeraWalletClientConstructor);
+    static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
-        accounts: Account[];
-        activeAccount: Account | null;
-        isActive: boolean;
-        isConnected: boolean;
         isWalletConnect: boolean;
-        connect: () => Promise<void>;
-        disconnect: () => Promise<void>;
-        reconnect: () => Promise<void>;
-        setActive: () => Promise<void>;
-        selectAccount: (account: string) => Promise<void>;
-    }[];
-    activeAccount: Account | null;
-    accounts: Account[];
-    connect: (id: PROVIDER_ID) => Promise<void>;
-    reconnect: (id: PROVIDER_ID) => Promise<void>;
-    disconnect: (id: PROVIDER_ID) => Promise<void>;
-    selectActiveAccount: (providerId: PROVIDER_ID, address: string) => Promise<void>;
-    setActive: (id: PROVIDER_ID) => Promise<void>;
-    reconnectProviders: () => Promise<void>;
+    };
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network, }: InitParams$6): Promise<PeraWalletClient | null>;
+    connect(onDisconnect: () => void): Promise<Wallet>;
+    reconnect(onDisconnect: () => void): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    /** @deprecated */
+    formatTransactionsArray(transactions: TransactionsArray): PeraTransaction[];
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+/**
+ * Helpful resources:
+ * https://github.com/randlabs/myalgo-connect
+ */
+
+declare type MyAlgoWalletClientConstructor = {
+    client: _MyAlgoConnect;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type ClientOptions$4 = {
+    disableLedgerNano: boolean;
+};
+declare type InitParams$5 = {
+    clientOptions?: ClientOptions$4;
+    algodOptions?: AlgodClientOptions;
+    clientStatic?: typeof _MyAlgoConnect;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+
+/**
+ * Helpful resources:
+ * https://github.com/randlabs/myalgo-connect
+ */
+
+declare class MyAlgoWalletClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, network, }: MyAlgoWalletClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network, }: InitParams$5): Promise<MyAlgoWalletClient | null>;
+    connect(): Promise<{
+        accounts: {
+            providerId: PROVIDER_ID;
+            address: string;
+            name: string;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    }>;
+    reconnect(): Promise<null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare type ClientOptions$3 = {
+    bridge?: string;
+    deep_link?: string;
+    app_meta?: {
+        logo: string;
+        name: string;
+        main_color: string;
+    };
+    shouldShowSignTxnToast?: boolean;
+};
+declare type DeflyTransaction = {
+    txn: Transaction;
+    /**
+     * Optional list of addresses that must sign the transactions.
+     * Wallet skips to sign this txn if signers is empty array.
+     * If undefined, wallet tries to sign it.
+     */
+    signers?: string[];
+};
+declare type DeflyWalletClientConstructor = {
+    client: DeflyWalletConnect;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$4 = {
+    clientOptions?: ClientOptions$3;
+    algodOptions?: AlgodClientOptions;
+    clientStatic?: typeof DeflyWalletConnect;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+
+declare class DeflyWalletClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, network, }: DeflyWalletClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network, }: InitParams$4): Promise<DeflyWalletClient | null>;
+    connect(onDisconnect: () => void): Promise<Wallet>;
+    reconnect(onDisconnect: () => void): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+    /** @deprecated */
+    formatTransactionsArray(transactions: TransactionsArray): DeflyTransaction[];
+}
+
+declare type ClientOptions$2 = {
+    onlyIfTrusted: boolean;
+};
+declare type Bytes = Readonly<Uint8Array>;
+declare type Exodus = {
+    isConnected: boolean;
+    address: string | null;
+    connect: ({ onlyIfTrusted }: {
+        onlyIfTrusted: boolean;
+    }) => Promise<{
+        address: string;
+    }>;
+    disconnect: () => void;
+    signAndSendTransaction(transactions: Bytes[]): Promise<{
+        txId: string;
+    }>;
+    signTransaction(transactions: Bytes[]): Promise<Bytes[]>;
+};
+declare type ExodusClientConstructor = {
+    client: Exodus;
+    id: PROVIDER_ID;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    onlyIfTrusted: boolean;
+    network: Network;
+};
+declare type InitParams$3 = {
+    clientOptions?: ClientOptions$2;
+    algodOptions?: AlgodClientOptions;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
 };
 
-declare const getWalletClient: (id: PROVIDER_ID | undefined) => Promise<WalletClient>;
+declare class ExodusClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, onlyIfTrusted, network, }: ExodusClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, algosdkStatic, network, }: InitParams$3): Promise<ExodusClient | null>;
+    connect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    }>;
+    reconnect(onDisconnect: () => void): Promise<null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare type AlgoSignerTransaction = {
+    txn: string;
+    signers?: [];
+    multisig?: string;
+};
+declare type SupportedLedgers = "MainNet" | "TestNet" | "BetaNet" | string;
+declare type AlgoSigner = {
+    connect: () => Promise<Record<string, never>>;
+    accounts: (ledger: {
+        ledger: SupportedLedgers;
+    }) => Promise<{
+        address: string;
+    }[]>;
+    signTxn: (transactions: AlgoSignerTransaction[]) => Promise<{
+        txID: string;
+        blob: string;
+    }[]>;
+    encoding: {
+        msgpackToBase64(transaction: Uint8Array): string;
+        byteArrayToString(transaction: Uint8Array): string;
+    };
+};
+declare type AlgoSignerClientConstructor = {
+    client: AlgoSigner;
+    id: PROVIDER_ID;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: SupportedLedgers;
+};
+declare type InitParams$2 = {
+    algodOptions?: AlgodClientOptions;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+
+declare class AlgoSignerClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, network, }: AlgoSignerClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ algodOptions, algosdkStatic, network, }: InitParams$2): Promise<AlgoSignerClient | null>;
+    connect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    }>;
+    reconnect(onDisconnect: () => void): Promise<null>;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    /** @deprecated */
+    formatTransactionsArray(transactions: TransactionsArray): AlgoSignerTransaction[];
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+interface IClientMeta {
+    description: string;
+    url: string;
+    icons: string[];
+    name: string;
+}
+interface IWalletConnectSession {
+    connected: boolean;
+    accounts: string[];
+    chainId: number;
+    bridge: string;
+    key: string;
+    clientId: string;
+    clientMeta: IClientMeta | null;
+    peerId: string;
+    peerMeta: IClientMeta | null;
+    handshakeId: number;
+    handshakeTopic: string;
+    qrcodeModal: {
+        open: (uri: string, cb: any, qrcodeModalOptions?: any) => void;
+        close: () => void;
+    };
+}
+declare type ClientOptions$1 = {
+    bridge?: string;
+    uri?: string;
+    storageId?: string;
+    signingMethods?: string[];
+    session?: IWalletConnectSession;
+    clientMeta?: IClientMeta;
+};
+declare type WalletConnectTransaction = {
+    txn: string;
+    message?: string;
+    signers?: string[] | [];
+};
+declare type InitParams$1 = {
+    clientOptions?: ClientOptions$1;
+    algodOptions?: AlgodClientOptions;
+    clientStatic?: typeof WalletConnect;
+    modalStatic?: typeof QRCodeModal;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+declare type WalletConnectClientConstructor = {
+    client: WalletConnect;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+
+declare class WalletConnectClient extends BaseClient {
+    #private;
+    network: Network;
+    constructor({ client, algosdk, algodClient, network, }: WalletConnectClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, clientStatic, modalStatic, algosdkStatic, network, }: InitParams$1): Promise<WalletConnectClient | null>;
+    connect(): Promise<Wallet>;
+    reconnect(): Promise<{
+        accounts: {
+            name: string;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    check(): boolean;
+    disconnect(): Promise<void>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    /** @deprecarted */
+    formatTransactionsArray(transactions: TransactionsArray): WalletConnectTransaction[];
+    /** @deprecated */
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare type ClientOptions = {
+    wallet: string;
+    password: string;
+    host: string;
+    token: string;
+    port: string;
+};
+declare type KMDWalletClientConstructor = {
+    client: _algosdk.Kmd;
+    id: PROVIDER_ID;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    wallet: string;
+    password: string;
+    network: Network;
+};
+declare type InitParams = {
+    clientOptions?: ClientOptions;
+    algodOptions?: AlgodClientOptions;
+    algosdkStatic?: typeof _algosdk;
+    network?: Network;
+};
+
+declare class KMDWalletClient extends BaseClient {
+    #private;
+    walletId: string;
+    id: PROVIDER_ID;
+    network: Network;
+    constructor({ client, id, wallet, password, algosdk, algodClient, network, }: KMDWalletClientConstructor);
+    static metadata: {
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    };
+    static init({ clientOptions, algodOptions, algosdkStatic, network, }: InitParams): Promise<KMDWalletClient | null>;
+    connect(): Promise<Wallet>;
+    disconnect(): Promise<void>;
+    reconnect(): Promise<Wallet | null>;
+    requestPassword(): Promise<string>;
+    getWalletToken(walletId: string, password: string): Promise<string>;
+    releaseToken(token: string): Promise<void>;
+    listWallets(): Promise<Record<string, string>>;
+    listAccounts(wallet: string, password: string): Promise<Array<Account>>;
+    signTransactions(connectedAccounts: string[], transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
 
-export { Account, AccountInfo, Asset, ConfirmedTxn, DecodedSignedTransaction, DecodedTransaction, KMD_HOST, KMD_PASSWORD, KMD_PORT, KMD_TOKEN, KMD_WALLET, NODE_NETWORK, NODE_PORT, NODE_SERVER, NODE_TOKEN, PROVIDER_ID, Provider, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, WalletProvider, getWalletClient, useConnectWallet, useWallet };
+export { Account, AccountInfo, AlgodClientOptions, Asset, ConfirmedTxn, DEFAULT_NETWORK, DEFAULT_NODE_BASEURL, DEFAULT_NODE_PORT, DEFAULT_NODE_TOKEN, DecodedSignedTransaction, DecodedTransaction, Network, PROVIDER_ID, Provider, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, _default as WalletProvider, AlgoSignerClient as algosigner, DeflyWalletClient as defly, ExodusClient as exodus, initializeProviders, KMDWalletClient as kmd, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useWallet, WalletConnectClient as walletconnect };