@txnlab/use-wallet 1.3.1 → 2.0.0-alpha.0

package/dist/index.d.ts

@@ -1,15 +1,18 @@
 import _algosdk 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 { DaffiWalletConnect } from '@daffiwallet/connect';
+import SignClient from '@walletconnect/sign-client';
+import MyAlgoConnect from '@randlabs/myalgo-connect';
+import { WalletConnectModalConfig, WalletConnectModal } from '@walletconnect/modal';
+import { SignClientTypes } from '@walletconnect/types';
+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';
-import WalletConnect from '@walletconnect/client';
-import QRCodeModal from 'algorand-walletconnect-qrcode-modal';
 
-declare type Network = 'betanet' | 'testnet' | 'mainnet' | string;
+declare type PublicNetwork = 'betanet' | 'testnet' | 'mainnet';
+declare type Network = PublicNetwork | string;
 declare type Txn = {
     apaa: Uint8Array;
     apas: number[];
@@ -85,6 +88,7 @@ declare const DEFAULT_NODE_PORT = "";
 declare abstract class BaseClient {
     algosdk: typeof _algosdk;
     algodClient: _algosdk.Algodv2;
+    clientOptions?: ClientOptions;
     keepWCAlive: HTMLAudioElement;
     metadata: Metadata;
     static metadata: Metadata;
@@ -92,7 +96,7 @@ declare abstract class BaseClient {
     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);
+    protected constructor(metadata: Metadata, algosdk: typeof _algosdk, algodClient: _algosdk.Algodv2, clientOptions?: ClientOptions);
     healthCheck(): Promise<{}>;
     getAccountInfo(address: string): Promise<AccountInfo>;
     getAssets(address: string): Promise<Asset[]>;
@@ -174,20 +178,205 @@ declare type Metadata = {
     icon: string;
     isWalletConnect: boolean;
 };
+declare type ClientOptions = Record<string, any>;
 declare type WalletClient = BaseClient;
+declare type SupportedProviders = Partial<Record<PROVIDER_ID, WalletClient | null>>;
+
+declare type PeraWalletConnectOptions = {
+    bridge?: string;
+    shouldShowSignTxnToast?: boolean;
+    chainId?: 416001 | 416002 | 416003 | 4160;
+};
+declare type PeraWalletClientConstructor = {
+    metadata: Metadata;
+    client: PeraWalletConnect;
+    clientOptions?: PeraWalletConnectOptions;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$7 = CommonInitParams & {
+    clientOptions?: PeraWalletConnectOptions;
+    clientStatic?: typeof PeraWalletConnect;
+};
+
+declare type DeflyWalletConnectOptions = {
+    bridge?: string;
+    deep_link?: string;
+    app_meta?: {
+        logo: string;
+        name: string;
+        main_color: string;
+    };
+    shouldShowSignTxnToast?: boolean;
+};
+declare type DeflyWalletClientConstructor = {
+    metadata: Metadata;
+    client: DeflyWalletConnect;
+    clientOptions?: DeflyWalletConnectOptions;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$6 = CommonInitParams & {
+    clientOptions?: DeflyWalletConnectOptions;
+    clientStatic?: typeof DeflyWalletConnect;
+};
+
+declare type ExodusOptions = {
+    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 = {
+    metadata: Metadata;
+    client: Exodus;
+    clientOptions: ExodusOptions;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$5 = CommonInitParams & {
+    clientOptions?: ExodusOptions;
+};
+
+declare type KmdOptions = {
+    wallet: string;
+    password: string;
+    host: string;
+    token: string;
+    port: string;
+};
+declare type KMDWalletClientConstructor = {
+    metadata: Metadata;
+    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 = {
+    disableLedgerNano: boolean;
+};
+declare type MyAlgoWalletClientConstructor = {
+    metadata: Metadata;
+    client: MyAlgoConnect;
+    clientOptions?: MyAlgoConnectOptions;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+};
+declare type InitParams$3 = CommonInitParams & {
+    clientOptions?: MyAlgoConnectOptions;
+    clientStatic?: typeof MyAlgoConnect;
+};
+
+declare type WalletConnectOptions = SignClientTypes.Options;
+declare type WalletConnectModalOptions = Omit<WalletConnectModalConfig, 'projectId' | 'walletConnectVersion'>;
+declare type InitParams$2 = CommonInitParams & {
+    clientOptions?: WalletConnectOptions;
+    clientStatic?: typeof SignClient;
+    modalStatic?: typeof WalletConnectModal;
+    modalOptions?: WalletConnectModalOptions;
+};
+declare type WalletConnectClientConstructor = {
+    metadata: Metadata;
+    client: SignClient;
+    clientOptions?: WalletConnectOptions;
+    modal: WalletConnectModal;
+    algosdk: typeof _algosdk;
+    algodClient: _algosdk.Algodv2;
+    network: Network;
+    chain: string;
+};
+
+declare type DaffiWalletConnectOptions = {
+    bridge?: string;
+    shouldShowSignTxnToast?: boolean;
+    chainId?: 416001 | 416002 | 416003 | 4160;
+};
+
+declare type ProviderConfigMapping = {
+    [PROVIDER_ID.PERA]: {
+        clientOptions?: PeraWalletConnectOptions;
+        clientStatic?: typeof PeraWalletConnect;
+    };
+    [PROVIDER_ID.DAFFI]: {
+        clientOptions?: DaffiWalletConnectOptions;
+        clientStatic?: typeof DaffiWalletConnect;
+    };
+    [PROVIDER_ID.DEFLY]: {
+        clientOptions?: DeflyWalletConnectOptions;
+        clientStatic?: typeof DeflyWalletConnect;
+    };
+    [PROVIDER_ID.WALLETCONNECT]: {
+        clientOptions?: WalletConnectOptions;
+        clientStatic?: typeof SignClient;
+        modalStatic?: typeof WalletConnectModal;
+        modalOptions?: WalletConnectModalOptions;
+    };
+    [PROVIDER_ID.MYALGO]: {
+        clientOptions?: MyAlgoConnectOptions;
+        clientStatic?: typeof MyAlgoConnect;
+    };
+    [PROVIDER_ID.EXODUS]: {
+        clientOptions?: ExodusOptions;
+    };
+    [PROVIDER_ID.KMD]: {
+        clientOptions?: KmdOptions;
+    };
+    [PROVIDER_ID.ALGOSIGNER]: Record<string, never>;
+    [PROVIDER_ID.MNEMONIC]: Record<string, never>;
+};
+/**
+ * Enforces correct configuration given for each provider. For example,
+ * if `id` is `PROVIDER_ID.PERA`, then `clientOptions` must be of type
+ * `PeraWalletConnectOptions`.
+ *
+ * @todo install `tsd` to test TypeScript type definitions in CI
+ */
+declare type ProviderConfig<T extends keyof ProviderConfigMapping> = {
+    [K in T]: {
+        id: K;
+    } & ProviderConfigMapping[K];
+}[T];
+declare type CommonInitParams = {
+    network?: Network;
+    algodOptions?: AlgodClientOptions;
+    algosdkStatic?: typeof _algosdk;
+};
+declare type NodeConfig = {
+    network: Network;
+    nodeServer: string;
+    nodeToken?: string;
+    nodePort?: string;
+};
 
 declare function useWallet(): {
-    clients: Partial<{
-        kmd: Promise<BaseClient | null>;
-        pera: Promise<BaseClient | null>;
-        daffi: Promise<BaseClient | null>;
-        myalgo: Promise<BaseClient | null>;
-        algosigner: Promise<BaseClient | null>;
-        defly: Promise<BaseClient | null>;
-        exodus: Promise<BaseClient | null>;
-        walletconnect: Promise<BaseClient | null>;
-        mnemonic: Promise<BaseClient | null>;
-    }> | null;
+    clients: Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
     providers: Provider[] | null;
     connectedAccounts: Account[];
     connectedActiveAccounts: Account[];
@@ -210,25 +399,20 @@ declare function useWallet(): {
         id: string;
     }>;
     getAddress: () => string | undefined;
-    groupTransactionsBySender: (transactions: TransactionsArray) => Promise<Record<string, TxnInfo[]>>;
+    groupTransactionsBySender: (transactions: TransactionsArray) => Record<string, TxnInfo[]>;
     getAccountInfo: () => Promise<AccountInfo>;
     getAssets: () => Promise<Asset[]>;
 };
 
-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;
+interface InitializeProvidersOptions<T extends keyof ProviderConfigMapping = keyof ProviderConfigMapping> {
+    providers?: Array<T | ProviderConfig<T>>;
+    nodeConfig?: NodeConfig;
+    algosdkStatic?: typeof _algosdk;
+}
+declare function useInitializeProviders<T extends keyof ProviderConfigMapping = keyof ProviderConfigMapping>({ providers, nodeConfig, algosdkStatic }?: InitializeProvidersOptions<T>): Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
+
+declare const initializeProviders: <T extends keyof ProviderConfigMapping>(providers?: (T | ProviderConfig<T>)[] | undefined, nodeConfig?: NodeConfig, algosdkStatic?: typeof _algosdk) => Promise<SupportedProviders>;
 
-declare type SupportedProviders = {
-    [x: string]: Promise<WalletClient | null>;
-};
 declare const reconnectProviders: (providers: SupportedProviders) => Promise<void>;
 
 declare type NFDTransactionsArray = ['u' | 's', string][];
@@ -260,49 +444,20 @@ declare const useWalletStore: zustand.UseBoundStore<Omit<Omit<Omit<zustand.Store
     }>(nextStateOrUpdater: WalletStore | Partial<WalletStore> | ((state: immer_dist_internal.WritableDraft<WalletStore>) => void), shouldReplace?: boolean | undefined, action?: A | undefined): void;
 }>;
 
-declare const _default: react.Provider<Partial<{
-    kmd: Promise<BaseClient | null>;
-    pera: Promise<BaseClient | null>;
-    daffi: Promise<BaseClient | null>;
-    myalgo: Promise<BaseClient | null>;
-    algosigner: Promise<BaseClient | null>;
-    defly: Promise<BaseClient | null>;
-    exodus: Promise<BaseClient | null>;
-    walletconnect: Promise<BaseClient | null>;
-    mnemonic: Promise<BaseClient | null>;
-}> | null>;
-
-declare type ClientOptions$6 = {
-    bridge?: string;
-    shouldShowSignTxnToast?: boolean;
-    chainId?: 416001 | 416002 | 416003 | 4160;
-};
-declare type PeraWalletClientConstructor = {
-    metadata: Metadata;
-    client: PeraWalletConnect;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    network: Network;
-};
-declare type InitParams$7 = {
-    clientOptions?: ClientOptions$6;
-    algodOptions?: AlgodClientOptions;
-    clientStatic?: typeof PeraWalletConnect;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
+declare const _default: react.Provider<Partial<Record<PROVIDER_ID, BaseClient | null>> | null>;
 
 declare class PeraWalletClient extends BaseClient {
     #private;
+    clientOptions?: PeraWalletConnectOptions;
     network: Network;
-    constructor({ metadata, client, algosdk, algodClient, network }: PeraWalletClientConstructor);
+    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: PeraWalletClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$7): Promise<PeraWalletClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$7): Promise<BaseClient | null>;
     connect(onDisconnect: () => void): Promise<Wallet>;
     reconnect(onDisconnect: () => void): Promise<{
         accounts: {
@@ -319,29 +474,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 type MyAlgoWalletClientConstructor = {
-    metadata: Metadata;
-    client: _MyAlgoConnect;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    network: Network;
-};
-declare type ClientOptions$5 = {
-    disableLedgerNano: boolean;
-};
-declare type InitParams$6 = {
-    clientOptions?: ClientOptions$5;
-    algodOptions?: AlgodClientOptions;
-    clientStatic?: typeof _MyAlgoConnect;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
-
 /**
  * Helpful resources:
  * https://github.com/randlabs/myalgo-connect
@@ -349,15 +481,16 @@ declare type InitParams$6 = {
 
 declare class MyAlgoWalletClient extends BaseClient {
     #private;
+    clientOptions?: MyAlgoConnectOptions;
     network: Network;
-    constructor({ metadata, client, algosdk, algodClient, network }: MyAlgoWalletClientConstructor);
+    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: MyAlgoWalletClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$6): Promise<MyAlgoWalletClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$3): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             providerId: PROVIDER_ID;
@@ -374,42 +507,18 @@ declare class MyAlgoWalletClient extends BaseClient {
     signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type ClientOptions$4 = {
-    bridge?: string;
-    deep_link?: string;
-    app_meta?: {
-        logo: string;
-        name: string;
-        main_color: string;
-    };
-    shouldShowSignTxnToast?: boolean;
-};
-declare type DeflyWalletClientConstructor = {
-    metadata: Metadata;
-    client: DeflyWalletConnect;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    network: Network;
-};
-declare type InitParams$5 = {
-    clientOptions?: ClientOptions$4;
-    algodOptions?: AlgodClientOptions;
-    clientStatic?: typeof DeflyWalletConnect;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
-
 declare class DeflyWalletClient extends BaseClient {
     #private;
+    clientOptions?: DeflyWalletConnectOptions;
     network: Network;
-    constructor({ metadata, client, algosdk, algodClient, network }: DeflyWalletClientConstructor);
+    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: DeflyWalletClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$5): Promise<DeflyWalletClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, algosdkStatic, network }: InitParams$6): Promise<BaseClient | null>;
     connect(onDisconnect: () => void): Promise<Wallet>;
     reconnect(onDisconnect: () => void): Promise<{
         accounts: {
@@ -426,51 +535,18 @@ declare class DeflyWalletClient extends BaseClient {
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type ClientOptions$3 = {
-    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 = {
-    metadata: Metadata;
-    client: Exodus;
-    id: PROVIDER_ID;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    onlyIfTrusted: boolean;
-    network: Network;
-};
-declare type InitParams$4 = {
-    clientOptions?: ClientOptions$3;
-    algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
-
 declare class ExodusClient extends BaseClient {
     #private;
+    clientOptions: ExodusOptions;
     network: Network;
-    constructor({ metadata, client, algosdk, algodClient, onlyIfTrusted, network }: ExodusClientConstructor);
+    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: ExodusClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$4): Promise<ExodusClient | null>;
+    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$5): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             name: string;
@@ -516,16 +592,11 @@ declare type AlgoSigner = {
 declare type AlgoSignerClientConstructor = {
     metadata: Metadata;
     client: AlgoSigner;
-    id: PROVIDER_ID;
     algosdk: typeof _algosdk;
     algodClient: _algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams$3 = {
-    algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
+declare type InitParams$1 = CommonInitParams;
 
 declare class AlgoSignerClient extends BaseClient {
     #private;
@@ -538,7 +609,7 @@ declare class AlgoSignerClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams$3): Promise<AlgoSignerClient | null>;
+    static init({ algodOptions, algosdkStatic, network }: InitParams$1): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             authAddr?: string | undefined;
@@ -558,64 +629,19 @@ declare class AlgoSignerClient extends BaseClient {
     getAuthAddress(address: string): string | undefined;
 }
 
-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$2 = {
-    bridge?: string;
-    uri?: string;
-    storageId?: string;
-    signingMethods?: string[];
-    session?: IWalletConnectSession;
-    clientMeta?: IClientMeta;
-};
-declare type InitParams$2 = {
-    clientOptions?: ClientOptions$2;
-    algodOptions?: AlgodClientOptions;
-    clientStatic?: typeof WalletConnect;
-    modalStatic?: typeof QRCodeModal;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
-declare type WalletConnectClientConstructor = {
-    metadata: Metadata;
-    client: WalletConnect;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    network: Network;
-};
-
 declare class WalletConnectClient extends BaseClient {
     #private;
+    clientOptions?: WalletConnectOptions;
     network: Network;
-    constructor({ metadata, client, algosdk, algodClient, network }: WalletConnectClientConstructor);
+    chain: string;
+    constructor({ metadata, client, clientOptions, modal, algosdk, algodClient, network, chain }: WalletConnectClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, modalStatic, algosdkStatic, network }: InitParams$2): Promise<WalletConnectClient | null>;
+    static init({ clientOptions, algodOptions, clientStatic, modalStatic, modalOptions, algosdkStatic, network }: InitParams$2): Promise<BaseClient | null>;
     connect(): Promise<Wallet>;
     reconnect(): Promise<{
         accounts: {
@@ -628,48 +654,22 @@ declare class WalletConnectClient extends BaseClient {
         icon: string;
         isWalletConnect: boolean;
     } | null>;
-    check(): boolean;
     disconnect(): Promise<void>;
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type ClientOptions$1 = {
-    wallet: string;
-    password: string;
-    host: string;
-    token: string;
-    port: string;
-};
-declare type KMDWalletClientConstructor = {
-    metadata: Metadata;
-    client: _algosdk.Kmd;
-    id: PROVIDER_ID;
-    algosdk: typeof _algosdk;
-    algodClient: _algosdk.Algodv2;
-    wallet: string;
-    password: string;
-    network: Network;
-};
-declare type InitParams$1 = {
-    clientOptions?: ClientOptions$1;
-    algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
-
 declare class KMDWalletClient extends BaseClient {
     #private;
     walletId: string;
-    id: PROVIDER_ID;
     network: Network;
-    constructor({ metadata, client, id, wallet, password, algosdk, algodClient, network }: KMDWalletClientConstructor);
+    constructor({ metadata, client, wallet, password, algosdk, algodClient, network }: KMDWalletClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$1): Promise<KMDWalletClient | null>;
+    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams$4): Promise<BaseClient | null>;
     connect(): Promise<Wallet>;
     disconnect(): Promise<void>;
     reconnect(): Promise<Wallet | null>;
@@ -682,39 +682,25 @@ declare class KMDWalletClient extends BaseClient {
     signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
 }
 
-declare type ClientOptions = {
-    wallet: string;
-    password: string;
-    host: string;
-    token: string;
-    port: string;
-};
 declare type MnemonicWalletClientConstructor = {
     metadata: Metadata;
-    id: PROVIDER_ID;
     algosdk: typeof _algosdk;
     algodClient: _algosdk.Algodv2;
     network: Network;
 };
-declare type InitParams = {
-    clientOptions?: ClientOptions;
-    algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof _algosdk;
-    network?: Network;
-};
+declare type InitParams = CommonInitParams;
 
 declare class MnemonicWalletClient extends BaseClient {
     #private;
-    id: PROVIDER_ID;
     network: Network;
-    constructor({ metadata, id, algosdk, algodClient, network }: MnemonicWalletClientConstructor);
+    constructor({ metadata, algosdk, algodClient, network }: MnemonicWalletClientConstructor);
     static metadata: {
         id: PROVIDER_ID;
         name: string;
         icon: string;
         isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams): Promise<MnemonicWalletClient | null>;
+    static init({ algodOptions, algosdkStatic, network }: InitParams): Promise<BaseClient | null>;
     connect(): Promise<{
         accounts: {
             name: string;
@@ -733,4 +719,4 @@ declare class MnemonicWalletClient extends BaseClient {
     signEncodedTransactions(_transactions: TransactionsArray): Promise<Uint8Array[]>;
 }
 
-export { Account, AccountInfo, AlgodClientOptions, Asset, ConfirmedTxn, DEFAULT_NETWORK, DEFAULT_NODE_BASEURL, DEFAULT_NODE_PORT, DEFAULT_NODE_TOKEN, DecodedSignedTransaction, DecodedTransaction, Metadata, Network, PROVIDER_ID, Provider, RawTxnResponse, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, _default as WalletProvider, AlgoSignerClient as algosigner, DeflyWalletClient as defly, encodeNFDTransactionsArray, ExodusClient as exodus, initializeProviders, KMDWalletClient as kmd, MnemonicWalletClient as mnemonic, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useWallet, WalletConnectClient as walletconnect };
+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, PublicNetwork, RawTxnResponse, SupportedProviders, TransactionsArray, Txn, TxnInfo, TxnType, Wallet, WalletClient, _default as WalletProvider, AlgoSignerClient as algosigner, DeflyWalletClient as defly, encodeNFDTransactionsArray, ExodusClient as exodus, initializeProviders, KMDWalletClient as kmd, MnemonicWalletClient as mnemonic, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useInitializeProviders, useWallet, WalletConnectClient as walletconnect };