@txnlab/use-wallet 2.0.0-alpha.5 → 2.0.0

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-import _algosdk from 'algosdk';
+import algosdk from 'algosdk';
 import { PeraWalletConnect } from '@perawallet/connect';
 import { DeflyWalletConnect } from '@blockshake/defly-connect';
 import { DaffiWalletConnect } from '@daffiwallet/connect';
 import MyAlgoConnect from '@randlabs/myalgo-connect';
-import { Web3ModalSignOptions, Web3ModalSign } from '@web3modal/sign-html';
+import { WalletConnectModalSignOptions, WalletConnectModalSign } from '@walletconnect/modal-sign-html';
 import * as react from 'react';
 import * as zustand_middleware from 'zustand/middleware';
 import * as immer_dist_internal from 'immer/dist/internal';
 import * as zustand from 'zustand';
 
-declare type PublicNetwork = 'betanet' | 'testnet' | 'mainnet';
-declare type Network = PublicNetwork | string;
-declare type Txn = {
+type PublicNetwork = 'betanet' | 'testnet' | 'mainnet';
+type Network = PublicNetwork | string;
+type Txn = {
     apaa: Uint8Array;
     apas: number[];
     apid: number;
@@ -24,7 +24,7 @@ declare type Txn = {
     snd: Uint8Array;
     type: string;
 };
-declare type ConfirmedTxn = {
+type ConfirmedTxn = {
     'confirmed-round': number;
     'global-state-delta': Record<string, unknown>[];
     'pool-error': string;
@@ -33,8 +33,8 @@ declare type ConfirmedTxn = {
         txn: Txn;
     };
 };
-declare type TxnType = 'pay' | 'keyreg' | 'acfg' | 'axfer' | 'afrz' | 'appl' | 'stpf';
-declare type DecodedTransaction = {
+type TxnType = 'pay' | 'keyreg' | 'acfg' | 'axfer' | 'afrz' | 'appl' | 'stpf';
+type DecodedTransaction = {
     amt: number;
     fee: number;
     fv: number;
@@ -47,14 +47,14 @@ declare type DecodedTransaction = {
     snd: Uint8Array;
     type: TxnType;
 };
-declare type DecodedSignedTransaction = {
+type DecodedSignedTransaction = {
     sig: Uint8Array;
     txn: DecodedTransaction;
 };
-declare type AlgodClientOptions = ConstructorParameters<typeof _algosdk.Algodv2>;
+type AlgodClientOptions = ConstructorParameters<typeof algosdk.Algodv2>;
 
-declare type TransactionsArray = ['u' | 's', string][];
-declare type TxnInfo = {
+type TransactionsArray = ['u' | 's', string][];
+type TxnInfo = {
     groupIndex: number;
     amount: number;
     from: string;
@@ -63,7 +63,7 @@ declare type TxnInfo = {
     txn: string;
     signedTxn?: Uint8Array;
 };
-declare type RawTxnResponse = {
+type RawTxnResponse = {
     txId: string;
 };
 
@@ -83,56 +83,13 @@ 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;
-    clientOptions?: ClientOptions;
-    keepWCAlive: HTMLAudioElement;
-    metadata: Metadata;
-    static metadata: Metadata;
-    abstract connect(onDisconnect: () => void): Promise<Wallet>;
-    abstract disconnect(): Promise<void>;
-    abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
-    abstract signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
-    protected constructor(metadata: Metadata, algosdk: typeof _algosdk, algodClient: _algosdk.Algodv2, clientOptions?: ClientOptions);
-    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, TxnInfo[]>;
-    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: string;
-    }>;
-    keepWCAliveStart(): Promise<void>;
-    keepWCAliveStop(): void;
-}
-
 interface Account {
     providerId: PROVIDER_ID;
     name: string;
     address: string;
     authAddr?: string;
 }
-declare type Provider = {
+type Provider = {
     accounts: Account[];
     isActive: boolean;
     isConnected: boolean;
@@ -143,7 +100,7 @@ declare type Provider = {
     setActiveAccount: (account: string) => void;
     metadata: Metadata;
 };
-declare type Asset = {
+type Asset = {
     amount: number;
     'asset-id': number;
     creator: string;
@@ -151,54 +108,48 @@ declare type Asset = {
     'unit-name': string;
     name: string;
 };
-declare type AccountInfo = {
+type AccountInfo = {
     address: string;
     amount: number;
     'min-balance': number;
     'auth-addr'?: string;
     assets?: Asset[];
 };
-declare type WalletProvider = {
+type WalletProvider = {
     id: PROVIDER_ID;
     name: string;
     icon: string;
     isWalletConnect: boolean;
 };
-declare type ExtendValues<Type> = {
+type ExtendValues<Type> = {
     [Property in keyof Type]: Type[Property] | null;
 };
-declare type Wallet = ExtendValues<WalletProvider> & {
+type Wallet = ExtendValues<WalletProvider> & {
     accounts: Account[];
 };
-declare type Metadata = {
+type Metadata = {
     id: PROVIDER_ID;
     name: string;
     icon: string;
     isWalletConnect: boolean;
 };
-declare type ClientOptions = Record<string, any>;
-declare type WalletClient = BaseClient;
-declare type SupportedProviders = Partial<Record<PROVIDER_ID, WalletClient | null>>;
+type ClientOptions = Record<string, any>;
 
-declare type PeraWalletConnectOptions = {
+type PeraWalletConnectOptions = {
     bridge?: string;
     shouldShowSignTxnToast?: boolean;
     chainId?: 416001 | 416002 | 416003 | 4160;
 };
-declare type PeraWalletClientConstructor = {
+type PeraWalletClientConstructor = {
     metadata: Metadata;
     client: PeraWalletConnect;
     clientOptions?: PeraWalletConnectOptions;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$7 = CommonInitParams & {
-    clientOptions?: PeraWalletConnectOptions;
-    clientStatic?: typeof PeraWalletConnect;
-};
 
-declare type DeflyWalletConnectOptions = {
+type DeflyWalletConnectOptions = {
     bridge?: string;
     deep_link?: string;
     app_meta?: {
@@ -208,24 +159,20 @@ declare type DeflyWalletConnectOptions = {
     };
     shouldShowSignTxnToast?: boolean;
 };
-declare type DeflyWalletClientConstructor = {
+type DeflyWalletClientConstructor = {
     metadata: Metadata;
     client: DeflyWalletConnect;
     clientOptions?: DeflyWalletConnectOptions;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$6 = CommonInitParams & {
-    clientOptions?: DeflyWalletConnectOptions;
-    clientStatic?: typeof DeflyWalletConnect;
-};
 
-declare type ExodusOptions = {
+type ExodusOptions = {
     onlyIfTrusted: boolean;
 };
-declare type Bytes = Readonly<Uint8Array>;
-declare type Exodus = {
+type Bytes = Readonly<Uint8Array>;
+type Exodus = {
     isConnected: boolean;
     address: string | null;
     connect: ({ onlyIfTrusted }: {
@@ -239,68 +186,101 @@ declare type Exodus = {
     }>;
     signTransaction(transactions: Bytes[]): Promise<Bytes[]>;
 };
-declare type ExodusClientConstructor = {
+type ExodusClientConstructor = {
     metadata: Metadata;
     client: Exodus;
     clientOptions: ExodusOptions;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$5 = CommonInitParams & {
-    clientOptions?: ExodusOptions;
-};
 
-declare type KmdOptions = {
+type KmdOptions = {
     wallet: string;
     password: string;
     host: string;
     token: string;
     port: string;
 };
-declare type KMDWalletClientConstructor = {
+type KMDWalletClientConstructor = {
     metadata: Metadata;
-    client: _algosdk.Kmd;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    client: algosdk.Kmd;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     wallet: string;
     password: string;
     network: Network;
 };
-declare type InitParams$4 = CommonInitParams & {
-    clientOptions?: KmdOptions;
-};
 
 /**
  * Helpful resources:
  * https://github.com/randlabs/myalgo-connect
  */
 
-declare type MyAlgoConnectOptions = {
+type MyAlgoConnectOptions = {
     disableLedgerNano: boolean;
 };
-declare type MyAlgoWalletClientConstructor = {
+type MyAlgoWalletClientConstructor = {
     metadata: Metadata;
     client: MyAlgoConnect;
     clientOptions?: MyAlgoConnectOptions;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$3 = CommonInitParams & {
-    clientOptions?: MyAlgoConnectOptions;
-    clientStatic?: typeof MyAlgoConnect;
-};
 
-declare type DaffiWalletConnectOptions = {
+type DaffiWalletConnectOptions = {
     bridge?: string;
     shouldShowSignTxnToast?: boolean;
     chainId?: 416001 | 416002 | 416003 | 4160;
 };
 
-declare type NonEmptyArray<T> = [T, ...T[]];
+type NonEmptyArray<T> = [T, ...T[]];
+
+declare abstract class BaseClient {
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
+    clientOptions?: ClientOptions;
+    keepWCAlive: HTMLAudioElement;
+    metadata: Metadata;
+    static metadata: Metadata;
+    abstract connect(onDisconnect: () => void): Promise<Wallet>;
+    abstract disconnect(): Promise<void>;
+    abstract reconnect(onDisconnect: () => void): Promise<Wallet | null>;
+    abstract signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    protected constructor(metadata: Metadata, algosdk: typeof algosdk, algodClient: algosdk.Algodv2, clientOptions?: ClientOptions);
+    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, TxnInfo[]>;
+    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: string;
+    }>;
+    keepWCAliveStart(): Promise<void>;
+    keepWCAliveStop(): void;
+}
 
-declare type ProviderConfigMapping = {
+type ProviderConfigMapping = {
     [PROVIDER_ID.PERA]: {
         clientOptions?: PeraWalletConnectOptions;
         clientStatic?: typeof PeraWalletConnect;
@@ -314,8 +294,8 @@ declare type ProviderConfigMapping = {
         clientStatic?: typeof DeflyWalletConnect;
     };
     [PROVIDER_ID.WALLETCONNECT]: {
-        clientOptions?: Web3ModalSignOptions;
-        clientStatic?: typeof Web3ModalSign;
+        clientOptions?: WalletConnectModalSignOptions;
+        clientStatic?: typeof WalletConnectModalSign;
     };
     [PROVIDER_ID.MYALGO]: {
         clientOptions?: MyAlgoConnectOptions;
@@ -323,12 +303,20 @@ declare type ProviderConfigMapping = {
     };
     [PROVIDER_ID.EXODUS]: {
         clientOptions?: ExodusOptions;
+        clientStatic?: undefined;
     };
     [PROVIDER_ID.KMD]: {
         clientOptions?: KmdOptions;
+        clientStatic?: undefined;
+    };
+    [PROVIDER_ID.ALGOSIGNER]: {
+        clientOptions?: undefined;
+        clientStatic?: undefined;
+    };
+    [PROVIDER_ID.MNEMONIC]: {
+        clientOptions?: undefined;
+        clientStatic?: undefined;
     };
-    [PROVIDER_ID.ALGOSIGNER]: Record<string, never>;
-    [PROVIDER_ID.MNEMONIC]: Record<string, never>;
 };
 /**
  * Enforces correct configuration given for each provider. For example,
@@ -337,80 +325,46 @@ declare type ProviderConfigMapping = {
  *
  * @todo install `tsd` to test TypeScript type definitions in CI
  */
-declare type ProviderConfig<T extends keyof ProviderConfigMapping> = {
+type ProviderConfig<T extends keyof ProviderConfigMapping> = {
     [K in T]: {
         id: K;
     } & ProviderConfigMapping[K];
 }[T];
-declare type CommonInitParams = {
+type CommonInitParams = {
     network?: Network;
     algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof _algosdk;
+    algosdkStatic?: typeof algosdk;
 };
-declare type NodeConfig = {
+type InitParams<T extends keyof ProviderConfigMapping> = CommonInitParams & ProviderConfigMapping[T];
+type NodeConfig = {
     network: Network;
     nodeServer: string;
-    nodeToken?: string;
+    nodeToken?: string | algosdk.AlgodTokenHeader | algosdk.CustomTokenHeader | algosdk.BaseHTTPClient;
     nodePort?: string | number;
     nodeHeaders?: Record<string, string>;
 };
-declare type ProviderDef = (ProviderConfig<PROVIDER_ID.PERA> & {
+type ProviderDef = (ProviderConfig<PROVIDER_ID.PERA> & {
     clientStatic: typeof PeraWalletConnect;
 }) | (ProviderConfig<PROVIDER_ID.DEFLY> & {
     clientStatic: typeof DeflyWalletConnect;
 }) | (ProviderConfig<PROVIDER_ID.DAFFI> & {
     clientStatic: typeof DaffiWalletConnect;
 }) | (ProviderConfig<PROVIDER_ID.WALLETCONNECT> & {
-    clientStatic: typeof Web3ModalSign;
-    clientOptions: Web3ModalSignOptions;
+    clientStatic: typeof WalletConnectModalSign;
+    clientOptions: WalletConnectModalSignOptions;
 }) | (ProviderConfig<PROVIDER_ID.MYALGO> & {
     clientStatic: typeof MyAlgoConnect;
 }) | ProviderConfig<PROVIDER_ID.EXODUS> | ProviderConfig<PROVIDER_ID.KMD> | PROVIDER_ID.EXODUS | PROVIDER_ID.KMD | PROVIDER_ID.ALGOSIGNER | PROVIDER_ID.MNEMONIC;
-declare type ProvidersArray = NonEmptyArray<ProviderDef>;
-
-declare function useWallet(): {
-    clients: Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
-    providers: Provider[] | null;
-    connectedAccounts: Account[];
-    connectedActiveAccounts: Account[];
-    activeAccount: Account | null | undefined;
-    activeAddress: string | undefined;
-    status: string;
-    isActive: boolean;
-    isReady: boolean;
-    signer: _algosdk.TransactionSigner;
-    signTransactions: (transactions: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
-    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: string;
-    }>;
-    getAddress: () => string | undefined;
-    groupTransactionsBySender: (transactions: TransactionsArray) => Record<string, TxnInfo[]>;
-    getAccountInfo: () => Promise<AccountInfo>;
-    getAssets: () => Promise<Asset[]>;
-};
-
-interface InitializeProvidersOptions {
-    providers: ProvidersArray;
-    nodeConfig?: NodeConfig;
-    algosdkStatic?: typeof _algosdk;
-    debug?: boolean;
-}
-declare function useInitializeProviders({ providers, nodeConfig, algosdkStatic, debug }: InitializeProvidersOptions): Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
+type ProvidersArray = NonEmptyArray<ProviderDef>;
+type WalletClient = BaseClient;
+type SupportedProviders = Partial<Record<PROVIDER_ID, WalletClient | null>>;
 
 declare const reconnectProviders: (providers: SupportedProviders) => Promise<void>;
 
-declare type NFDTransactionsArray = ['u' | 's', string][];
+type NFDTransactionsArray = ['u' | 's', string][];
 declare function encodeNFDTransactionsArray(transactionsArray: NFDTransactionsArray): Uint8Array[];
 
-declare type WalletStore = {
+type WalletStore = {
     accounts: Account[];
     activeAccount: Account | null | undefined;
     setActiveAccount: (account: Account) => void;
@@ -424,7 +378,7 @@ declare const useWalletStore: zustand.UseBoundStore<Omit<Omit<Omit<zustand.Store
     persist: {
         setOptions: (options: Partial<zustand_middleware.PersistOptions<WalletStore, WalletStore>>) => void;
         clearStorage: () => void;
-        rehydrate: () => Promise<void>;
+        rehydrate: () => void | Promise<void>;
         hasHydrated: () => boolean;
         onHydrate: (fn: (state: WalletStore) => void) => () => void;
         onFinishHydration: (fn: (state: WalletStore) => void) => () => void;
@@ -449,7 +403,7 @@ declare class PeraWalletClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$7): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams<PROVIDER_ID.PERA>): Promise<BaseClient | null>;
     connect(onDisconnect: () => void): Promise<Wallet>;
     reconnect(onDisconnect: () => void): Promise<{
         accounts: {
@@ -466,11 +420,6 @@ declare class PeraWalletClient extends BaseClient {
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-/**
- * Helpful resources:
- * https://github.com/randlabs/myalgo-connect
- */
-
 declare class MyAlgoWalletClient extends BaseClient {
     #private;
     clientOptions?: MyAlgoConnectOptions;
@@ -482,7 +431,7 @@ declare class MyAlgoWalletClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$3): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams<PROVIDER_ID.MYALGO>): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             providerId: PROVIDER_ID;
@@ -510,7 +459,7 @@ declare class DeflyWalletClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$6): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams<PROVIDER_ID.DEFLY>): Promise<BaseClient | null>;
     connect(onDisconnect: () => void): Promise<Wallet>;
     reconnect(onDisconnect: () => void): Promise<{
         accounts: {
@@ -538,7 +487,7 @@ declare class ExodusClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$5): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.EXODUS>): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             name: string;
@@ -555,25 +504,25 @@ declare class ExodusClient extends BaseClient {
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type GenesisId = 'betanet-v1.0' | 'testnet-v1.0' | 'mainnet-v1.0' | string;
-declare type EnableParams = {
+type GenesisId = 'betanet-v1.0' | 'testnet-v1.0' | 'mainnet-v1.0' | string;
+type EnableParams = {
     genesisID?: GenesisId;
     genesisHash?: string;
     accounts?: string[];
 };
-declare type EnableResponse = {
+type EnableResponse = {
     genesisID: GenesisId;
     genesisHash: string;
     accounts: string[];
 };
-declare type AlgoSignerTransaction = {
+type AlgoSignerTransaction = {
     txn: string;
     signers?: string[];
     stxn?: string;
     multisig?: string;
     authAddr?: string;
 };
-declare type AlgoSigner = {
+type AlgoSigner = {
     enable: (params?: EnableParams) => Promise<EnableResponse>;
     signTxns: (transactions: AlgoSignerTransaction[]) => Promise<string[]>;
     encoding: {
@@ -581,14 +530,13 @@ declare type AlgoSigner = {
         byteArrayToString(transaction: Uint8Array): string;
     };
 };
-declare type AlgoSignerClientConstructor = {
+type AlgoSignerClientConstructor = {
     metadata: Metadata;
     client: AlgoSigner;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$2 = CommonInitParams;
 
 declare class AlgoSignerClient extends BaseClient {
     #private;
@@ -601,7 +549,7 @@ declare class AlgoSignerClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams$2): Promise<BaseClient | null>;
+    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.ALGOSIGNER>): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             authAddr?: string | undefined;
@@ -621,23 +569,19 @@ declare class AlgoSignerClient extends BaseClient {
     getAuthAddress(address: string): string | undefined;
 }
 
-declare type WalletConnectClientConstructor = {
+type WalletConnectClientConstructor = {
     metadata: Metadata;
-    client: Web3ModalSign;
-    clientOptions: Web3ModalSignOptions;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    client: WalletConnectModalSign;
+    clientOptions: WalletConnectModalSignOptions;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
     chain: string;
 };
-declare type InitParams$1 = CommonInitParams & {
-    clientOptions?: Web3ModalSignOptions;
-    clientStatic?: typeof Web3ModalSign;
-};
 
 declare class WalletConnectClient extends BaseClient {
     #private;
-    clientOptions?: Web3ModalSignOptions;
+    clientOptions?: WalletConnectModalSignOptions;
     network: Network;
     chain: string;
     constructor({ metadata, client, clientOptions, algosdk, algodClient, network, chain }: WalletConnectClientConstructor);
@@ -647,7 +591,7 @@ declare class WalletConnectClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$1): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams<PROVIDER_ID.WALLETCONNECT>): Promise<BaseClient | null>;
     connect(): Promise<Wallet>;
     reconnect(): Promise<{
         accounts: {
@@ -675,7 +619,7 @@ declare class KMDWalletClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$4): Promise<BaseClient | null>;
+    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.KMD>): Promise<BaseClient | null>;
     connect(): Promise<Wallet>;
     disconnect(): Promise<void>;
     reconnect(): Promise<Wallet | null>;
@@ -688,13 +632,12 @@ declare class KMDWalletClient extends BaseClient {
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type MnemonicWalletClientConstructor = {
+type MnemonicWalletClientConstructor = {
     metadata: Metadata;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
+    algosdk: typeof algosdk;
+    algodClient: algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams = CommonInitParams;
 
 declare class MnemonicWalletClient extends BaseClient {
     #private;
@@ -706,7 +649,7 @@ declare class MnemonicWalletClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams): Promise<BaseClient | null>;
+    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.MNEMONIC>): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             name: string;
@@ -725,4 +668,41 @@ declare class MnemonicWalletClient extends BaseClient {
     signEncodedTransactions(_transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
 
-export { Account, AccountInfo, AlgodClientOptions, Asset, ClientOptions, CommonInitParams, ConfirmedTxn, DEFAULT_NETWORK, DEFAULT_NODE_BASEURL, DEFAULT_NODE_PORT, DEFAULT_NODE_TOKEN, DecodedSignedTransaction, DecodedTransaction, Metadata, Network, NodeConfig, PROVIDER_ID, Provider, ProviderConfig, ProviderConfigMapping, ProvidersArray, PublicNetwork, RawTxnResponse, SupportedProviders, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, _default as WalletProvider, AlgoSignerClient as algosigner, DeflyWalletClient as defly, encodeNFDTransactionsArray, ExodusClient as exodus, KMDWalletClient as kmd, MnemonicWalletClient as mnemonic, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useInitializeProviders, useWallet, WalletConnectClient as walletconnect };
+declare function useWallet(): {
+    clients: Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
+    providers: Provider[] | null;
+    connectedAccounts: Account[];
+    connectedActiveAccounts: Account[];
+    activeAccount: Account | null | undefined;
+    activeAddress: string | undefined;
+    status: string;
+    isActive: boolean;
+    isReady: boolean;
+    signer: algosdk.TransactionSigner;
+    signTransactions: (transactions: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    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: string;
+    }>;
+    getAddress: () => string | undefined;
+    groupTransactionsBySender: (transactions: TransactionsArray) => Record<string, TxnInfo[]>;
+    getAccountInfo: () => Promise<AccountInfo>;
+    getAssets: () => Promise<Asset[]>;
+};
+
+interface InitializeProvidersOptions {
+    providers: ProvidersArray;
+    nodeConfig?: NodeConfig;
+    algosdkStatic?: typeof algosdk;
+    debug?: boolean;
+}
+declare function useInitializeProviders({ providers, nodeConfig, algosdkStatic, debug }: InitializeProvidersOptions): Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
+
+export { Account, AccountInfo, AlgodClientOptions, Asset, ClientOptions, CommonInitParams, ConfirmedTxn, DEFAULT_NETWORK, DEFAULT_NODE_BASEURL, DEFAULT_NODE_PORT, DEFAULT_NODE_TOKEN, DecodedSignedTransaction, DecodedTransaction, InitParams, Metadata, Network, NodeConfig, PROVIDER_ID, Provider, ProviderConfig, ProviderConfigMapping, ProvidersArray, PublicNetwork, RawTxnResponse, SupportedProviders, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, _default as WalletProvider, AlgoSignerClient as algosigner, DeflyWalletClient as defly, encodeNFDTransactionsArray, ExodusClient as exodus, KMDWalletClient as kmd, MnemonicWalletClient as mnemonic, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useInitializeProviders, useWallet, WalletConnectClient as walletconnect };