@txnlab/use-wallet 0.1.14 → 0.1.16

package/dist/index.d.ts

@@ -1,10 +1,8 @@
-import * as algosdk from 'algosdk';
-import algosdk__default, { TransactionType, Transaction } from 'algosdk';
-import * as _walletconnect_client from '@walletconnect/client';
-import * as _blockshake_defly_connect_dist_DeflyWalletConnect from '@blockshake/defly-connect/dist/DeflyWalletConnect';
-import * as _randlabs_myalgo_connect from '@randlabs/myalgo-connect';
-import * as _perawallet_connect_dist_PeraWalletConnect from '@perawallet/connect/dist/PeraWalletConnect';
-import * as algosdk_dist_types_src_main from 'algosdk/dist/types/src/main';
+import algosdk, { TransactionType, Transaction, Kmd } from 'algosdk';
+import { PeraWalletConnect } from '@perawallet/connect';
+import MyAlgoConnect from '@randlabs/myalgo-connect';
+import { DeflyWalletConnect } from '@blockshake/defly-connect';
+import WalletConnect from '@walletconnect/client';
 
 declare type Txn = {
     apaa: Uint8Array;
@@ -82,7 +80,7 @@ interface BaseWalletInterface {
     healthCheck(): Promise<Record<string, never>>;
     disconnect(): Promise<void>;
     reconnect(onDisconnect: () => void): Promise<Wallet | null>;
-    decodeTransaction(txn: string, isSigned: boolean): algosdk__default.Transaction;
+    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[]>;
@@ -94,6 +92,46 @@ interface BaseWalletInterface {
     getAssets(address: string): Promise<Asset[]>;
     waitForConfirmation(txId: string, timeout?: number): Promise<ConfirmedTxn>;
 }
+declare abstract class BaseWallet implements BaseWalletInterface {
+    keepWCAlive: HTMLAudioElement;
+    protected abstract id: PROVIDER_ID;
+    protected abstract provider: WalletProvider;
+    abstract connect(onDisconnect: () => void): Promise<Wallet>;
+    abstract disconnect(): Promise<void>;
+    abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
+    abstract signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    abstract signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+    protected constructor();
+    healthCheck(): Promise<{}>;
+    getAccountInfo(address: string): Promise<AccountInfo>;
+    getAssets(address: string): Promise<Asset[]>;
+    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[]): 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 {
     providerId: PROVIDER_ID;
@@ -143,7 +181,7 @@ declare type WalletClient = BaseWalletInterface;
 declare function useWallet(): {
     accounts: Account[];
     activeAccount: Account | null;
-    signer: algosdk__default.TransactionSigner;
+    signer: algosdk.TransactionSigner;
     signTransactions: (transactions: Array<Uint8Array>) => Promise<Uint8Array[]>;
     sendTransactions: (transactions: Uint8Array[]) => Promise<ConfirmedTxn & {
         id: string;
@@ -188,8 +226,6 @@ declare function useConnectWallet(options?: Options): {
 };
 
 declare const getWalletClient: (id: PROVIDER_ID | undefined) => Promise<WalletClient>;
-declare const formatPrice: (price: number, isAlgos?: boolean, options?: Intl.NumberFormatOptions | undefined) => string;
-declare const convertMicroalgosToAlgos: (amount: number) => number;
 
 declare const providers: {
     "Pera Wallet": WalletProvider;
@@ -201,12 +237,7 @@ declare const providers: {
     "Wallet Connect": WalletProvider;
 };
 
-/**
- * Helpful resources:
- * https://github.com/blockshake-io/defly-connect
- */
-
-interface DeflyTransaction {
+interface PeraTransaction {
     txn: Transaction;
     /**
      * Optional list of addresses that must sign the transactions.
@@ -215,13 +246,125 @@ interface DeflyTransaction {
      */
     signers?: string[];
 }
+declare type InitWallet$6 = {
+    id: PROVIDER_ID;
+    client: PeraWalletConnect;
+    provider: WalletProvider;
+};
+declare class PeraWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$6);
+    static init(): Promise<PeraWalletClient>;
+    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>;
+    formatTransactionsArray(transactions: TransactionsArray): PeraTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
 
 /**
  * Helpful resources:
- * https://github.com/perawallet/connect
+ * https://github.com/randlabs/myalgo-connect
  */
 
-interface PeraTransaction {
+declare type InitWallet$5 = {
+    id: PROVIDER_ID;
+    client: MyAlgoConnect;
+    provider: WalletProvider;
+};
+declare class MyAlgoWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$5);
+    static init(): Promise<MyAlgoWalletClient>;
+    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(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+/**
+ * Helpful resources:
+ * https://github.com/PureStake/algosigner/blob/develop/docs/dApp-integration.md
+ */
+
+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 InitWallet$4 = {
+    client: AlgoSigner;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+};
+declare class AlgoSignerClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$4);
+    static init(): Promise<AlgoSignerClient>;
+    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>;
+    formatTransactionsArray(transactions: TransactionsArray): AlgoSignerTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+interface DeflyTransaction {
     txn: Transaction;
     /**
      * Optional list of addresses that must sign the transactions.
@@ -230,411 +373,148 @@ interface PeraTransaction {
      */
     signers?: string[];
 }
-
-declare const clients: {
-    "KMD Wallet": Promise<void | {
-        "__#23@#client": algosdk.Kmd;
-        walletId: string;
-        id: PROVIDER_ID;
-        provider: WalletProvider;
-        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<Account[]>;
-        signTransactions(activeAddress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
-    }>;
-    "Pera Wallet": Promise<void | {
-        "__#18@#client": _perawallet_connect_dist_PeraWalletConnect.default;
-        id: PROVIDER_ID;
-        provider: WalletProvider;
-        connect(onDisconnect: () => void): Promise<Wallet>;
-        reconnect(onDisconnect: () => void): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
+declare type InitWallet$3 = {
+    id: PROVIDER_ID;
+    client: DeflyWalletConnect;
+    provider: WalletProvider;
+};
+declare class DeflyWalletClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$3);
+    static init(): Promise<DeflyWalletClient>;
+    connect(onDisconnect: () => void): Promise<Wallet>;
+    reconnect(onDisconnect: () => void): Promise<{
+        accounts: {
             name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: TransactionsArray): PeraTransaction[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
-    }>;
-    "MyAlgo Wallet": Promise<void | {
-        "__#19@#client": _randlabs_myalgo_connect.default;
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
         id: PROVIDER_ID;
-        provider: WalletProvider;
-        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(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    disconnect(): Promise<void>;
+    formatTransactionsArray(transactions: TransactionsArray): DeflyTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+/**
+ * Helpful resources:
+ * https://docs.exodus.com/api-reference/algorand-provider-api/
+ */
+
+declare type Bytes = Readonly<Uint8Array>;
+declare type Exodus = {
+    isConnected: boolean;
+    address: string | null;
+    connect: () => Promise<{
+        address: string;
     }>;
-    "Algo Signer": Promise<void | {
-        "__#20@#client": {
-            connect: () => Promise<Record<string, never>>;
-            accounts: (ledger: {
-                ledger: string;
-            }) => Promise<{
-                address: string;
-            }[]>;
-            signTxn: (transactions: {
-                txn: string;
-                signers?: [] | undefined;
-                multisig?: string | undefined;
-            }[]) => Promise<{
-                txID: string;
-                blob: string;
-            }[]>;
-            encoding: {
-                msgpackToBase64(transaction: Uint8Array): string;
-                byteArrayToString(transaction: Uint8Array): string;
-            };
-        };
-        id: PROVIDER_ID;
-        provider: WalletProvider;
-        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>;
-        formatTransactionsArray(transactions: TransactionsArray): {
-            txn: string;
-            signers?: [] | undefined;
-            multisig?: string | undefined;
-        }[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
+    disconnect: () => void;
+    signAndSendTransaction(transactions: Bytes[]): Promise<{
+        txId: string;
     }>;
-    Defly: Promise<void | {
-        "__#21@#client": _blockshake_defly_connect_dist_DeflyWalletConnect.default;
-        id: PROVIDER_ID;
-        provider: WalletProvider;
-        connect(onDisconnect: () => void): Promise<Wallet>;
-        reconnect(onDisconnect: () => void): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
+    signTransaction(transactions: Bytes[]): Promise<Bytes[]>;
+};
+declare type InitWallet$2 = {
+    client: Exodus;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+};
+declare class ExodusClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$2);
+    static init(): Promise<ExodusClient>;
+    connect(): Promise<{
+        accounts: {
             name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: TransactionsArray): DeflyTransaction[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
-    }>;
-    Exodus: Promise<void | {
-        "__#22@#client": {
-            isConnected: boolean;
-            address: string | null;
-            connect: () => Promise<{
-                address: string;
-            }>;
-            disconnect: () => void;
-            signAndSendTransaction(transactions: Readonly<Uint8Array>[]): Promise<{
-                txId: string;
-            }>;
-            signTransaction(transactions: Readonly<Uint8Array>[]): Promise<Readonly<Uint8Array>[]>;
-        };
+            address: string;
+            providerId: PROVIDER_ID;
+        }[];
         id: PROVIDER_ID;
-        provider: WalletProvider;
-        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(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
     }>;
-    "Wallet Connect": Promise<void | {
-        "__#24@#client": _walletconnect_client.default;
-        id: PROVIDER_ID;
-        provider: WalletProvider;
-        connect(): Promise<Wallet>;
-        reconnect(): Promise<{
-            accounts: {
-                name: string;
-                address: string;
-                providerId: PROVIDER_ID;
-            }[];
-            id: PROVIDER_ID;
+    reconnect(onDisconnect: () => void): Promise<null>;
+    disconnect(): Promise<void>;
+    signTransactions(activeAdress: string, transactions: Array<Uint8Array>): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare type InitWallet$1 = {
+    client: Kmd;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+};
+declare class KMDWallet extends BaseWallet {
+    #private;
+    walletId: string;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet$1);
+    static init(): Promise<KMDWallet>;
+    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(activeAddress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare type WalletConnectTransaction = {
+    txn: string;
+    message?: string;
+    signers?: string[] | [];
+};
+declare type InitWallet = {
+    id: PROVIDER_ID;
+    client: WalletConnect;
+    provider: WalletProvider;
+};
+declare class WalletConnectClient extends BaseWallet {
+    #private;
+    id: PROVIDER_ID;
+    provider: WalletProvider;
+    constructor(initWallet: InitWallet);
+    static init(): Promise<WalletConnectClient>;
+    connect(): Promise<Wallet>;
+    reconnect(): Promise<{
+        accounts: {
             name: string;
-            icon: string;
-            isWalletConnect: boolean;
-        } | null>;
-        check(): boolean;
-        disconnect(): Promise<void>;
-        formatTransactionsArray(transactions: TransactionsArray): {
-            txn: string;
-            message?: string | undefined;
-            signers?: [] | string[] | undefined;
+            address: string;
+            providerId: PROVIDER_ID;
         }[];
-        signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
-        signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
-        algodClient: algosdk.Algodv2;
-        algosdk: typeof algosdk_dist_types_src_main;
-        keepWCAlive: HTMLAudioElement;
-        healthCheck(): Promise<{}>;
-        getAccountInfo(address: string): Promise<AccountInfo>;
-        getAssets(address: string): Promise<Asset[]>;
-        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[]): 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;
-    }>;
+        id: PROVIDER_ID;
+        name: string;
+        icon: string;
+        isWalletConnect: boolean;
+    } | null>;
+    check(): boolean;
+    disconnect(): Promise<void>;
+    formatTransactionsArray(transactions: TransactionsArray): WalletConnectTransaction[];
+    signTransactions(activeAdress: string, transactions: Uint8Array[]): Promise<Uint8Array[]>;
+    signEncodedTransactions(transactions: TransactionsArray): Promise<Uint8Array[]>;
+}
+
+declare const clients: {
+    "KMD Wallet": typeof KMDWallet;
+    "Pera Wallet": typeof PeraWalletClient;
+    "MyAlgo Wallet": typeof MyAlgoWalletClient;
+    "Algo Signer": typeof AlgoSignerClient;
+    Defly: typeof DeflyWalletClient;
+    Exodus: typeof ExodusClient;
+    "Wallet Connect": typeof WalletConnectClient;
 };
 
-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, clients, convertMicroalgosToAlgos, formatPrice, getWalletClient, providers, useConnectWallet, useWallet };
+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, clients, getWalletClient, providers, useConnectWallet, useWallet };