@txnlab/use-wallet 2.8.0 → 3.0.0-beta.1

package/dist/index.d.ts

@@ -1,977 +1,511 @@
+import { Store } from '@tanstack/store';
 import algosdk from 'algosdk';
-import { PeraWalletConnect } from '@perawallet/connect';
-import { DeflyWalletConnect } from '@blockshake/defly-connect';
-import { DaffiWalletConnect } from '@daffiwallet/connect';
-import LuteConnect from 'lute-connect';
-import { Magic } from 'magic-sdk';
-import { AlgorandExtension } from '@magic-ext/algorand';
-import MyAlgoConnect from '@randlabs/myalgo-connect';
-import { WalletConnectModalSignOptions, WalletConnectModalSign } from '@walletconnect/modal-sign-html';
-import 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 { InstanceWithExtensions, SDKBase } from '@magic-sdk/provider';
-
-type PublicNetwork = 'betanet' | 'testnet' | 'mainnet';
-type Network = PublicNetwork | string;
-type Txn = {
-    apaa: Uint8Array;
-    apas: number[];
-    apid: number;
-    fee: number;
-    fv: number;
-    gen: string;
-    gh: Uint8Array;
-    grp: Uint8Array;
-    lv: number;
-    snd: Uint8Array;
-    type: string;
-};
-type ConfirmedTxn = {
-    'confirmed-round': number;
-    'global-state-delta': Record<string, unknown>[];
-    'pool-error': string;
-    txn: {
-        sig: Uint8Array;
-        txn: Txn;
-    };
-};
-type TxnType = 'pay' | 'keyreg' | 'acfg' | 'axfer' | 'afrz' | 'appl' | 'stpf';
-type DecodedTransaction = {
-    amt: number;
-    fee: number;
-    fv: number;
-    gen: string;
-    gh: Uint8Array;
-    grp: Uint8Array;
-    lv: number;
-    note: Uint8Array;
-    rcv: Uint8Array;
-    snd: Uint8Array;
-    type: TxnType;
-};
-type DecodedSignedTransaction = {
-    sig: Uint8Array;
-    txn: DecodedTransaction;
-};
-type AlgodClientOptions = ConstructorParameters<typeof algosdk.Algodv2>;
-
-type TransactionsArray = ['u' | 's', string][];
-type TxnInfo = {
-    groupIndex: number;
-    amount: number;
-    from: string;
-    to: string;
-    type: TxnType;
-    txn: string;
-    signedTxn?: Uint8Array;
-};
-type RawTxnResponse = {
-    txId: string;
-};
-
-declare enum PROVIDER_ID {
-    KMD = "kmd",
-    CUSTOM = "custom",
-    PERA = "pera",
-    DAFFI = "daffi",
-    LUTE = "lute",
-    MYALGO = "myalgo",
-    ALGOSIGNER = "algosigner",
-    DEFLY = "defly",
-    EXODUS = "exodus",
-    KIBISIS = "kibisis",
-    WALLETCONNECT = "walletconnect",
-    MNEMONIC = "mnemonic",
-    MAGIC = "magic"
+import { WalletConnectModalConfig } from '@walletconnect/modal';
+import { SignClientTypes } from '@walletconnect/types';
+
+declare enum NetworkId {
+    MAINNET = "mainnet",
+    TESTNET = "testnet",
+    BETANET = "betanet",
+    LOCALNET = "localnet"
 }
-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 = "";
-
-interface Account {
-    providerId: PROVIDER_ID;
-    name: string;
-    address: string;
-    authAddr?: string;
-    email?: string;
+interface AlgodConfig {
+    token: string | algosdk.AlgodTokenHeader | algosdk.CustomTokenHeader | algosdk.BaseHTTPClient;
+    baseServer: string;
+    port?: string | number;
+    headers?: Record<string, string>;
 }
-type Provider = {
-    accounts: Account[];
-    isActive: boolean;
-    isConnected: boolean;
-    connect: (arg?: any, throws?: boolean) => Promise<void>;
-    disconnect: () => Promise<void>;
-    reconnect: () => Promise<void>;
-    setActiveProvider: () => void;
-    setActiveAccount: (account: string) => void;
-    metadata: Metadata;
-};
-type Asset = {
-    amount: number;
-    'asset-id': number;
-    creator: string;
-    'is-frozen': boolean;
-    'unit-name': string;
-    name: string;
-};
-type AccountInfo = {
-    address: string;
-    amount: number;
-    'min-balance': number;
-    'auth-addr'?: string;
-    assets?: Asset[];
-};
-type WalletProvider$1 = {
-    id: PROVIDER_ID;
-    name: string;
-    icon: string;
-    isWalletConnect: boolean;
-};
-type ExtendValues<Type> = {
-    [Property in keyof Type]: Type[Property] | null;
-};
-type Wallet = ExtendValues<WalletProvider$1> & {
-    accounts: Account[];
-};
-type Metadata = {
-    id: PROVIDER_ID;
-    name: string;
-    icon: string;
-    isWalletConnect: boolean;
-};
-type ClientOptions = Record<string, any>;
+type NetworkConfigMap = Record<NetworkId, AlgodConfig>;
+type NetworkConfig = Partial<AlgodConfig> | Partial<Record<NetworkId, Partial<AlgodConfig>>>;
 
-type PeraWalletConnectOptions = {
+interface DeflyWalletConnectOptions {
     bridge?: string;
     shouldShowSignTxnToast?: boolean;
     chainId?: 416001 | 416002 | 416003 | 4160;
-};
-type PeraWalletClientConstructor = {
-    metadata: Metadata;
-    client: PeraWalletConnect;
-    clientOptions?: PeraWalletConnectOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-type DeflyWalletConnectOptions = {
-    bridge?: string;
-    deep_link?: string;
-    app_meta?: {
-        logo: string;
-        name: string;
-        main_color: string;
-    };
-    shouldShowSignTxnToast?: boolean;
-};
-type DeflyWalletClientConstructor = {
-    metadata: Metadata;
-    client: DeflyWalletConnect;
-    clientOptions?: DeflyWalletConnectOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-type ExodusOptions = {
-    onlyIfTrusted: boolean;
-};
-type Bytes = Readonly<Uint8Array>;
-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[]>;
-};
-type ExodusClientConstructor = {
-    metadata: Metadata;
-    client: Exodus;
-    clientOptions: ExodusOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-type KmdOptions = {
-    wallet: string;
-    password: string;
-    host: string;
-    token: string;
-    port: string;
-};
-type KMDWalletClientConstructor = {
-    metadata: Metadata;
-    client: algosdk.Kmd;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    wallet: string;
-    password: string;
-    network: Network;
-};
-
-type LuteConnectOptions = {
-    siteName: string;
-};
-type LuteClientConstructor = {
-    metadata: Metadata;
-    client: LuteConnect;
-    clientOptions?: LuteConnectOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-/**
- * Helpful resources:
- * https://github.com/randlabs/myalgo-connect
- */
-
-type MyAlgoConnectOptions = {
-    disableLedgerNano: boolean;
-};
-type MyAlgoWalletClientConstructor = {
-    metadata: Metadata;
-    client: MyAlgoConnect;
-    clientOptions?: MyAlgoConnectOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-type DaffiWalletConnectOptions = {
-    bridge?: string;
-    shouldShowSignTxnToast?: boolean;
-    chainId?: 416001 | 416002 | 416003 | 4160;
-};
-
-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, arg?: any): 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;
-}
-
-type CustomOptions = {
-    name: string;
-    icon?: string;
-    getProvider: (params: {
-        network?: Network;
-        algod?: algosdk.Algodv2;
-        algosdkStatic?: typeof algosdk;
-    }) => CustomProvider;
-};
-type CustomProvider = {
-    connect(metadata: Metadata): Promise<Wallet>;
-    disconnect(): Promise<void>;
-    reconnect(metadata: Metadata): Promise<Wallet | null>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
-};
-type CustomWalletClientConstructor = {
-    providerProxy: CustomProvider;
-    metadata: Metadata;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-type ProviderConfigMapping = {
-    [PROVIDER_ID.PERA]: {
-        clientOptions?: PeraWalletConnectOptions;
-        clientStatic?: typeof PeraWalletConnect;
-        getDynamicClient?: () => Promise<typeof PeraWalletConnect>;
-    };
-    [PROVIDER_ID.DAFFI]: {
-        clientOptions?: DaffiWalletConnectOptions;
-        clientStatic?: typeof DaffiWalletConnect;
-        getDynamicClient?: () => Promise<typeof DaffiWalletConnect>;
-    };
-    [PROVIDER_ID.DEFLY]: {
-        clientOptions?: DeflyWalletConnectOptions;
-        clientStatic?: typeof DeflyWalletConnect;
-        getDynamicClient?: () => Promise<typeof DeflyWalletConnect>;
-    };
-    [PROVIDER_ID.WALLETCONNECT]: {
-        clientOptions?: WalletConnectModalSignOptions;
-        clientStatic?: typeof WalletConnectModalSign;
-        getDynamicClient?: () => Promise<typeof WalletConnectModalSign>;
-    };
-    [PROVIDER_ID.LUTE]: {
-        clientOptions?: LuteConnectOptions;
-        clientStatic?: typeof LuteConnect;
-        getDynamicClient?: () => Promise<typeof LuteConnect>;
-    };
-    [PROVIDER_ID.MYALGO]: {
-        clientOptions?: MyAlgoConnectOptions;
-        clientStatic?: typeof MyAlgoConnect;
-        getDynamicClient?: () => Promise<typeof MyAlgoConnect>;
-    };
-    [PROVIDER_ID.EXODUS]: {
-        clientOptions?: ExodusOptions;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.KMD]: {
-        clientOptions?: KmdOptions;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.CUSTOM]: {
-        clientOptions?: CustomOptions;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.ALGOSIGNER]: {
-        clientOptions?: undefined;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.MNEMONIC]: {
-        clientOptions?: undefined;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.KIBISIS]: {
-        clientOptions?: undefined;
-        clientStatic?: undefined;
-        getDynamicClient?: undefined;
-    };
-    [PROVIDER_ID.MAGIC]: {
-        clientOptions?: {
-            apiKey: string;
-        };
-        clientStatic?: undefined;
-        getDynamicClient?: () => Promise<typeof Magic>;
-        extensionStatic?: typeof AlgorandExtension;
-        getDynamicExtension?: () => Promise<typeof AlgorandExtension>;
-    };
-};
-/**
- * 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
- */
-type ProviderConfig<T extends keyof ProviderConfigMapping> = {
-    [K in T]: {
-        id: K;
-    } & ProviderConfigMapping[K];
-}[T];
-type CommonInitParams = {
-    network?: Network;
-    algodOptions?: AlgodClientOptions;
-    algosdkStatic?: typeof algosdk;
-};
-type InitParams<T extends keyof ProviderConfigMapping> = CommonInitParams & ProviderConfigMapping[T];
-type NodeConfig = {
-    network: Network;
-    nodeServer: string;
-    nodeToken?: string | algosdk.AlgodTokenHeader | algosdk.CustomTokenHeader | algosdk.BaseHTTPClient;
-    nodePort?: string | number;
-    nodeHeaders?: Record<string, string>;
-};
-type StaticClient<T> = {
-    clientStatic: T;
-    getDynamicClient?: undefined;
-};
-type DynamicClient<T> = {
-    clientStatic?: undefined;
-    getDynamicClient: () => Promise<T>;
-};
-type OneOfStaticOrDynamicClient<T> = StaticClient<T> | DynamicClient<T>;
-type StaticAlgoExtension<T> = {
-    extensionStatic: T;
-    getDynamicExtension?: undefined;
-};
-type DynamicAlgoExtension<T> = {
-    extensionStatic?: undefined;
-    getDynamicExtension: () => Promise<T>;
-};
-type OneOfStaticOrDynamicAlgoExtension<T> = StaticAlgoExtension<T> | DynamicAlgoExtension<T>;
-type ProviderDef = (ProviderConfig<PROVIDER_ID.PERA> & OneOfStaticOrDynamicClient<typeof PeraWalletConnect>) | (ProviderConfig<PROVIDER_ID.MAGIC> & OneOfStaticOrDynamicClient<typeof Magic> & OneOfStaticOrDynamicAlgoExtension<typeof AlgorandExtension> & {
-    clientOptions: {
-        apiKey: string;
-    };
-}) | (ProviderConfig<PROVIDER_ID.DEFLY> & OneOfStaticOrDynamicClient<typeof DeflyWalletConnect>) | (ProviderConfig<PROVIDER_ID.DAFFI> & OneOfStaticOrDynamicClient<typeof DaffiWalletConnect>) | (ProviderConfig<PROVIDER_ID.LUTE> & OneOfStaticOrDynamicClient<typeof LuteConnect> & {
-    clientOptions: LuteConnectOptions;
-}) | (ProviderConfig<PROVIDER_ID.WALLETCONNECT> & OneOfStaticOrDynamicClient<typeof WalletConnectModalSign> & {
-    clientOptions: WalletConnectModalSignOptions;
-}) | (ProviderConfig<PROVIDER_ID.MYALGO> & OneOfStaticOrDynamicClient<typeof MyAlgoConnect>) | ProviderConfig<PROVIDER_ID.EXODUS> | ProviderConfig<PROVIDER_ID.KMD> | ProviderConfig<PROVIDER_ID.CUSTOM> | ProviderConfig<PROVIDER_ID.KIBISIS> | PROVIDER_ID.EXODUS | PROVIDER_ID.KMD | PROVIDER_ID.ALGOSIGNER | PROVIDER_ID.MNEMONIC | PROVIDER_ID.CUSTOM | PROVIDER_ID.KIBISIS;
-type ProvidersArray = NonEmptyArray<ProviderDef>;
-type WalletClient = BaseClient;
-type SupportedProviders = Partial<Record<PROVIDER_ID, WalletClient | null>>;
-
-declare const reconnectProviders: (providers: SupportedProviders) => Promise<void>;
-
-type NFDTransactionsArray = ['u' | 's', string][];
-declare function encodeNFDTransactionsArray(transactionsArray: NFDTransactionsArray): Uint8Array[];
-
-interface WalletProviderProps {
-    children: React.ReactNode;
-    value: SupportedProviders | null;
 }
-declare const WalletProvider: ({ children, value }: WalletProviderProps) => React.JSX.Element;
-
-declare class PeraWalletClient extends BaseClient {
-    #private;
-    clientOptions?: PeraWalletConnectOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: PeraWalletClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+declare class DeflyWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.DEFLY>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.PERA>): Promise<BaseClient | 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>;
+    private initializeClient;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-declare class MyAlgoWalletClient extends BaseClient {
-    #private;
-    clientOptions?: MyAlgoConnectOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: MyAlgoWalletClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.MYALGO>): Promise<BaseClient | 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[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+/** @see https://docs.exodus.com/api-reference/algorand-provider-arc-api/ */
+interface EnableNetworkOpts {
+    genesisID?: string;
+    genesisHash?: string;
 }
-
-declare class DeflyWalletClient extends BaseClient {
-    #private;
-    clientOptions?: DeflyWalletConnectOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: DeflyWalletClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.DEFLY>): Promise<BaseClient | 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[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+interface EnableAccountsOpts {
+    accounts?: string[];
 }
-
-declare class ExodusClient extends BaseClient {
-    #private;
-    clientOptions: ExodusOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: ExodusClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+type ExodusOptions = EnableNetworkOpts & EnableAccountsOpts;
+interface EnableNetworkResult {
+    genesisID: string;
+    genesisHash: string;
+}
+interface EnableAccountsResult {
+    accounts: string[];
+}
+type EnableResult = EnableNetworkResult & EnableAccountsResult;
+type SignTxnsResult = (string | null)[];
+interface Exodus {
+    isConnected: boolean;
+    address: string | null;
+    enable: (options?: ExodusOptions) => Promise<EnableResult>;
+    signTxns: (transactions: WalletTransaction[]) => Promise<SignTxnsResult>;
+}
+type WindowExtended = {
+    algorand: Exodus;
+} & Window & typeof globalThis;
+declare class ExodusWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.EXODUS>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.EXODUS>): Promise<BaseClient | 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>;
+    private initializeClient;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-type WalletStore = {
-    accounts: Account[];
-    activeAccount: Account | null | undefined;
-    setActiveAccount: (account: Account) => void;
-    clearActiveAccount: (id: PROVIDER_ID) => void;
-    addAccounts: (accounts: Account[]) => void;
-    removeAccounts: (providerId: PROVIDER_ID) => void;
-};
-declare const useWalletStore: zustand.UseBoundStore<Omit<Omit<Omit<zustand.StoreApi<WalletStore>, "setState"> & {
-    setState(nextStateOrUpdater: WalletStore | Partial<WalletStore> | ((state: immer_dist_internal.WritableDraft<WalletStore>) => void), shouldReplace?: boolean | undefined): void;
-}, "persist"> & {
-    persist: {
-        setOptions: (options: Partial<zustand_middleware.PersistOptions<WalletStore, WalletStore>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => void | Promise<void>;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: WalletStore) => void) => () => void;
-        onFinishHydration: (fn: (state: WalletStore) => void) => () => void;
-        getOptions: () => Partial<zustand_middleware.PersistOptions<WalletStore, WalletStore>>;
-    };
-}, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(nextStateOrUpdater: WalletStore | Partial<WalletStore> | ((state: immer_dist_internal.WritableDraft<WalletStore>) => void), shouldReplace?: boolean | undefined, action?: A | undefined): void;
-}>;
-
-type GenesisId = 'betanet-v1.0' | 'testnet-v1.0' | 'mainnet-v1.0' | string;
-type EnableParams = {
-    genesisID?: GenesisId;
-    genesisHash?: string;
-    accounts?: string[];
-};
-type EnableResponse = {
-    genesisID: GenesisId;
-    genesisHash: string;
-    accounts: string[];
-};
-type AlgoSignerTransaction = {
-    txn: string;
-    signers?: string[];
-    stxn?: string;
-    multisig?: string;
-    authAddr?: string;
-};
-type AlgoSigner = {
-    enable: (params?: EnableParams) => Promise<EnableResponse>;
-    signTxns: (transactions: AlgoSignerTransaction[]) => Promise<string[]>;
-    encoding: {
-        msgpackToBase64(transaction: Uint8Array): string;
-        byteArrayToString(transaction: Uint8Array): string;
-    };
-};
-type AlgoSignerClientConstructor = {
-    metadata: Metadata;
-    client: AlgoSigner;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-declare class AlgoSignerClient extends BaseClient {
-    #private;
-    network: Network;
-    walletStore: typeof useWalletStore;
-    constructor({ metadata, client, algosdk, algodClient, network }: AlgoSignerClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+type ProviderMethod = 'enable' | 'getProviders' | 'postTxns' | 'signAndPostTxns' | 'signBytes' | 'signTxns';
+interface SendRequestWithTimeoutOptions<Params> {
+    method: ProviderMethod;
+    params: Params;
+    reference: string;
+    timeout?: number;
+}
+declare class KibisisWallet extends BaseWallet {
+    methods: ProviderMethod[];
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, metadata }: WalletConstructor<WalletId.KIBISIS>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.ALGOSIGNER>): Promise<BaseClient | null>;
-    connect(): Promise<{
-        accounts: {
-            authAddr?: string | undefined;
-            name: string;
-            address: string;
-            providerId: PROVIDER_ID;
-        }[];
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    }>;
-    reconnect(onDisconnect: () => void): Promise<null>;
+    static sendRequestWithTimeout<Params, Result>({ method, params, timeout, reference }: SendRequestWithTimeoutOptions<Params>): Promise<Result | undefined>;
+    /**
+     * Calls the enable method on the provider that returns the authorized accounts.
+     * @returns {Arc0027Account[]} the authorized accounts.
+     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private enable;
+    /**
+     * Gets the genesis hash of the algod client's configured network.
+     * @returns {string} the genesis hash
+     */
+    private getGenesisHash;
+    /**
+     * Gets the provider information and updates the supported methods. This should be called
+     * before interacting with the provider to ensure methods are supported.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private getSupportedMethods;
+    /**
+     * Calls the signTxns methods to sign the supplied transactions.
+     * @param {Arc0001SignTxns[]} txns -  the unsigned or signed transactions as defined in ARC-0001.
+     * @returns {(string | null)[]} the authorized accounts.
+     * @throws {INVALID_INPUT_ERROR} if computed group ID for the txns does not match the assigned group ID.
+     * @throws {INVALID_GROUP_ID_ERROR} if the unsigned txns is malformed or not conforming to ARC-0001.
+     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
+     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
+     * @throws {UNAUTHORIZED_SIGNER_ERROR} if a signer in the request is not authorized by the provider.
+     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     */
+    private signTxns;
+    /**
+     * Validates whether a method is supported with the provider.
+     * @param {ProviderMethod} method -  the method to validate.
+     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     */
+    private validateMethod;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
-    getGenesisID(): string;
-    getAuthAddress(address: string): string | undefined;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-declare class LuteClient extends BaseClient {
-    #private;
-    clientOptions?: LuteConnectOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: LuteClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+interface KmdConstructor {
+    token: string | algosdk.KMDTokenHeader | algosdk.CustomTokenHeader;
+    baseServer?: string;
+    port?: string | number;
+    headers?: Record<string, string>;
+}
+type KmdOptions = Partial<Pick<KmdConstructor, 'token'>> & Omit<KmdConstructor, 'token'> & {
+    wallet?: string;
+};
+declare class KmdWallet extends BaseWallet {
+    private client;
+    private options;
+    private walletName;
+    private walletId;
+    private password;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.KMD>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.LUTE>): Promise<BaseClient | null>;
-    connect(): Promise<{
-        accounts: {
-            name: string;
-            address: string;
-            providerId: PROVIDER_ID;
-        }[];
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    }>;
-    reconnect(): Promise<null>;
+    private initializeClient;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    shouldSignTxnObject(txn: DecodedTransaction | DecodedSignedTransaction, addresses: string[], indexesToSign: number[] | undefined, idx: number): boolean;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession: () => Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
+    private fetchWalletId;
+    private fetchToken;
+    private fetchAccounts;
+    private releaseToken;
+    private getPassword;
 }
 
-type WalletConnectClientConstructor = {
-    metadata: Metadata;
-    client: WalletConnectModalSign;
-    clientOptions: WalletConnectModalSignOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-    chain: string;
-};
-
-declare class WalletConnectClient extends BaseClient {
-    #private;
-    clientOptions?: WalletConnectModalSignOptions;
-    network: Network;
-    chain: string;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network, chain }: WalletConnectClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+interface LuteConnectOptions {
+    siteName?: string;
+}
+declare class LuteWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.LUTE>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, algosdkStatic, network }: InitParams<PROVIDER_ID.WALLETCONNECT>): Promise<BaseClient | null>;
-    connect(): Promise<Wallet>;
-    reconnect(): Promise<{
-        accounts: {
-            name: string;
-            address: string;
-            providerId: PROVIDER_ID;
-        }[];
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    } | null>;
+    private initializeClient;
+    private getGenesisId;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-type MagicAuthConnectOptions = {
-    apiKey: string;
-};
-type MagicAuthConstructor = {
-    metadata: Metadata;
-    client: InstanceWithExtensions<SDKBase, {
-        algorand: AlgorandExtension;
-    }>;
-    clientOptions: MagicAuthConnectOptions;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
+type MnemonicOptions = {
+    persistToStorage?: boolean;
 };
-
-declare class MagicAuth extends BaseClient {
-    #private;
-    clientOptions?: MagicAuthConnectOptions;
-    network: Network;
-    constructor({ metadata, client, clientOptions, algosdk, algodClient, network }: MagicAuthConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+declare class MnemonicWallet extends BaseWallet {
+    private account;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.MNEMONIC>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, clientStatic, getDynamicClient, extensionStatic, getDynamicExtension, algosdkStatic, network }: InitParams<PROVIDER_ID.MAGIC>): Promise<BaseClient | null>;
-    connect(_: () => void, arg?: any): Promise<Wallet>;
-    reconnect(): Promise<{
-        accounts: {
-            name: string;
-            address: string;
-            providerId: PROVIDER_ID;
-            email: string;
-        }[];
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    } | null>;
+    private initializeAccount;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-declare class KMDWalletClient extends BaseClient {
-    #private;
-    walletId: string;
-    network: Network;
-    constructor({ metadata, client, wallet, password, algosdk, algodClient, network }: KMDWalletClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+interface PeraWalletConnectOptions {
+    bridge?: string;
+    shouldShowSignTxnToast?: boolean;
+    chainId?: 416001 | 416002 | 416003 | 4160;
+    compactMode?: boolean;
+}
+declare class PeraWallet extends BaseWallet {
+    private client;
+    private options;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.PERA>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.KMD>): Promise<BaseClient | null>;
-    connect(): Promise<Wallet>;
+    private initializeClient;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    reconnect(): Promise<Wallet | null>;
-    requestPassword(): 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>>;
-    getWalletId(): Promise<string>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-type MnemonicWalletClientConstructor = {
-    metadata: Metadata;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    network: Network;
-};
-
-declare class MnemonicWalletClient extends BaseClient {
-    #private;
-    network: Network;
-    constructor({ metadata, algosdk, algodClient, network }: MnemonicWalletClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
+interface SignClientOptions {
+    projectId: string;
+    relayUrl?: string;
+    metadata?: SignClientTypes.Metadata;
+}
+type WalletConnectModalOptions = Pick<WalletConnectModalConfig, 'enableExplorer' | 'explorerRecommendedWalletIds' | 'privacyPolicyUrl' | 'termsOfServiceUrl' | 'themeMode' | 'themeVariables'>;
+type WalletConnectOptions = SignClientOptions & WalletConnectModalOptions;
+declare class WalletConnect extends BaseWallet {
+    private client;
+    private options;
+    private modal;
+    private modalOptions;
+    private session;
+    private chains;
+    protected store: Store<State>;
+    constructor({ id, store, subscribe, getAlgodClient, options, metadata }: WalletConstructor<WalletId.WALLETCONNECT>);
+    static defaultMetadata: {
         name: string;
         icon: string;
-        isWalletConnect: boolean;
     };
-    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.MNEMONIC>): Promise<BaseClient | null>;
-    connect(): Promise<{
-        accounts: {
-            name: string;
-            address: string;
-            providerId: PROVIDER_ID;
-        }[];
-        id: PROVIDER_ID;
-        name: string;
-        icon: string;
-        isWalletConnect: boolean;
-    }>;
+    private initializeClient;
+    private initializeModal;
+    private onSessionConnected;
+    connect(): Promise<WalletAccount[]>;
     disconnect(): Promise<void>;
-    reconnect(): Promise<null>;
-    requestPassword(): string;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
-    signEncodedTransactions(_transactions: TransactionsArray): Promise<Uint8Array[]>;
+    resumeSession(): Promise<void>;
+    signTransactions: (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean) => Promise<Uint8Array[]>;
+    transactionSigner: (txnGroup: algosdk.Transaction[], indexesToSign: number[]) => Promise<Uint8Array[]>;
 }
 
-declare class CustomWalletClient extends BaseClient {
-    network: Network;
-    providerProxy: CustomProvider;
-    static metadata: Metadata;
-    constructor({ providerProxy, metadata, algosdk, algodClient, network }: CustomWalletClientConstructor);
-    static init({ clientOptions, algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.CUSTOM>): Promise<BaseClient | null>;
-    connect(): Promise<Wallet>;
-    disconnect(): Promise<void>;
-    reconnect(): Promise<Wallet | null>;
-    signTransactions(connectedAccounts: string[], txnGroups: Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
-}
-
-interface Arc0027Account {
-    address: string;
-    name?: string;
+declare enum WalletId {
+    DEFLY = "defly",
+    EXODUS = "exodus",
+    KIBISIS = "kibisis",
+    KMD = "kmd",
+    LUTE = "lute",
+    MNEMONIC = "mnemonic",
+    PERA = "pera",
+    WALLETCONNECT = "walletconnect"
 }
-interface KibisisClientConstructor {
-    metadata: Metadata;
-    algosdk: typeof algosdk;
-    algodClient: algosdk.Algodv2;
-    genesisHash: string;
-    methods: ProviderMethods[];
-    network: Network;
+type WalletMap = {
+    [WalletId.DEFLY]: typeof DeflyWallet;
+    [WalletId.EXODUS]: typeof ExodusWallet;
+    [WalletId.KIBISIS]: typeof KibisisWallet;
+    [WalletId.KMD]: typeof KmdWallet;
+    [WalletId.LUTE]: typeof LuteWallet;
+    [WalletId.MNEMONIC]: typeof MnemonicWallet;
+    [WalletId.PERA]: typeof PeraWallet;
+    [WalletId.WALLETCONNECT]: typeof WalletConnect;
+};
+type WalletOptionsMap = {
+    [WalletId.DEFLY]: DeflyWalletConnectOptions;
+    [WalletId.EXODUS]: ExodusOptions;
+    [WalletId.KIBISIS]: Record<string, never>;
+    [WalletId.KMD]: KmdOptions;
+    [WalletId.LUTE]: LuteConnectOptions;
+    [WalletId.MNEMONIC]: MnemonicOptions;
+    [WalletId.PERA]: PeraWalletConnectOptions;
+    [WalletId.WALLETCONNECT]: WalletConnectOptions;
+};
+type SupportedWallet = WalletIdConfig<WalletId> | WalletId;
+type WalletConfigMap = {
+    [K in keyof WalletOptionsMap]: {
+        options?: WalletOptionsMap[K];
+        metadata?: Partial<WalletMetadata>;
+    };
+};
+type WalletOptions<T extends keyof WalletOptionsMap> = WalletOptionsMap[T];
+type WalletConfig<T extends keyof WalletConfigMap> = WalletConfigMap[T];
+type WalletIdConfig<T extends keyof WalletConfigMap> = {
+    [K in T]: {
+        id: K;
+    } & WalletConfigMap[K];
+}[T];
+type NonEmptyArray<T> = [T, ...T[]];
+type SupportedWallets = NonEmptyArray<SupportedWallet>;
+type WalletMetadata = {
+    name: string;
+    icon: string;
+};
+interface BaseWalletConstructor {
+    id: WalletId;
+    metadata: Partial<WalletMetadata> | undefined;
+    getAlgodClient: () => algosdk.Algodv2;
+    store: Store<State>;
+    subscribe: (callback: (state: State) => void) => () => void;
 }
-type ProviderMethods = 'enable' | 'getProviders' | 'postTxns' | 'signAndPostTxns' | 'signBytes' | 'signTxns';
-interface SendRequestWithTimeoutOptions<Params> {
-    method: ProviderMethods;
-    params: Params;
-    reference: string;
-    timeout?: number;
+type WalletConstructor<T extends keyof WalletOptionsMap> = BaseWalletConstructor & {
+    options?: WalletOptions<T>;
+    defaultMetadata?: WalletMetadata;
+};
+type WalletAccount = {
+    name: string;
+    address: string;
+};
+/** @see https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#interface-multisigmetadata */
+interface MultisigMetadata {
+    /**
+     * Multisig version.
+     */
+    version: number;
+    /**
+     * Multisig threshold value. Authorization requires a subset of signatures,
+     * equal to or greater than the threshold value.
+     */
+    threshold: number;
+    /**
+     * List of Algorand addresses of possible signers for this
+     * multisig. Order is important.
+     */
+    addrs: string[];
 }
-
-declare class KibisisClient extends BaseClient {
-    genesisHash: string;
-    methods: ProviderMethods[];
-    network: Network;
-    constructor({ metadata, algosdk, algodClient, genesisHash, methods, network }: KibisisClientConstructor);
-    static metadata: {
-        id: PROVIDER_ID;
-        icon: string;
-        isWalletConnect: boolean;
-        name: string;
-    };
+/** @see https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#interface-wallettransaction */
+interface WalletTransaction {
     /**
-     * public static functions
+     * Base64 encoding of the canonical msgpack encoding of a Transaction.
      */
-    static init({ algodOptions, algosdkStatic, network }: InitParams<PROVIDER_ID.KIBISIS>): Promise<BaseClient | null>;
-    static mapAccountsToWallet(accounts: Arc0027Account[]): Wallet;
-    static sendRequestWithTimeout<Params, Result>({ method, params, timeout, reference }: SendRequestWithTimeoutOptions<Params>): Promise<Result | undefined>;
+    txn: string;
     /**
-     * private functions
+     * Optional authorized address used to sign the transaction when the account
+     * is rekeyed. Also called the signor/sgnr.
      */
-    private convertBytesToBase64;
-    private convertBase64ToBytes;
+    authAddr?: string;
     /**
-     * Calls the enable method on the provider that returns the authorized accounts.
-     * @returns {Arc0027Account[]} the authorized accounts.
-     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
-     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
-     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
-     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
-     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     * Multisig metadata used to sign the transaction
      */
-    private enable;
+    msig?: MultisigMetadata;
     /**
-     * Convenience function that gets the provider information and updates the supported methods. This should be called
-     * before interacting with the provider to ensure methods are supported.
-     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
-     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
-     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     * Optional list of addresses that must sign the transactions
      */
-    private refreshSupportedMethods;
+    signers?: string[];
     /**
-     * Calls the signTxns methods to sign the supplied transactions.
-     * @param {Arc0001SignTxns[]} txns -  the unsigned or signed transactions as defined in ARC-0001.
-     * @returns {(string | null)[]} the authorized accounts.
-     * @throws {INVALID_INPUT_ERROR} if computed group ID for the txns does not match the assigned group ID.
-     * @throws {INVALID_GROUP_ID_ERROR} if the unsigned txns is malformed or not conforming to ARC-0001.
-     * @throws {METHOD_CANCELED_ERROR} if the method was cancelled by the user.
-     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
-     * @throws {METHOD_TIMED_OUT_ERROR} if the method timed out by lack of response.
-     * @throws {NETWORK_NOT_SUPPORTED_ERROR} if the network is not supported for the configured network.
-     * @throws {UNAUTHORIZED_SIGNER_ERROR} if a signer in the request is not authorized by the provider.
-     * @throws {UNKNOWN_ERROR} if the response result was empty.
+     * Optional base64 encoding of the canonical msgpack encoding of a
+     * SignedTxn corresponding to txn, when signers=[]
      */
-    private signTxns;
+    stxn?: string;
     /**
-     * Validates whether a method is supported with the provider.
-     * @param {ProviderMethods} method -  the method to validate.
-     * @throws {METHOD_NOT_SUPPORTED_ERROR} if the method is not supported for the configured network.
+     * Optional message explaining the reason of the transaction
      */
-    private validateMethod;
+    message?: string;
     /**
-     * public functions
+     * Optional message explaining the reason of this group of transaction
+     * Field only allowed in the first transaction of a group
      */
-    connect(): Promise<Wallet>;
-    disconnect(): Promise<void>;
-    reconnect(): Promise<Wallet | null>;
-    signTransactions(connectedAccounts: string[], transactions: Uint8Array[], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    groupMessage?: string;
+}
+/** @see https://github.com/perawallet/connect/blob/1.3.3/src/util/model/peraWalletModels.ts */
+interface SignerTransaction {
+    txn: algosdk.Transaction;
+    /**
+     * Optional authorized address used to sign the transaction when
+     * the account is rekeyed. Also called the signor/sgnr.
+     */
+    authAddr?: string;
+    /**
+     * 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[];
+    /**
+     * Optional message explaining the reason of the transaction
+     */
+    message?: string;
+}
+interface JsonRpcRequest<T = any> {
+    id: number;
+    jsonrpc: string;
+    method: string;
+    params: T;
 }
 
-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[]>;
+declare abstract class BaseWallet {
+    readonly id: WalletId;
+    readonly metadata: WalletMetadata;
+    protected store: Store<State>;
+    protected getAlgodClient: () => algosdk.Algodv2;
+    subscribe: (callback: (state: State) => void) => () => void;
+    protected constructor({ id, metadata, store, subscribe, getAlgodClient }: WalletConstructor<WalletId>);
+    static defaultMetadata: WalletMetadata;
+    abstract connect(): Promise<WalletAccount[]>;
+    abstract disconnect(): Promise<void>;
+    abstract resumeSession(): Promise<void>;
+    setActive(): void;
+    setActiveAccount(account: string): void;
+    abstract signTransactions(txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[], returnGroup?: boolean): Promise<Uint8Array[]>;
+    abstract transactionSigner(txnGroup: algosdk.Transaction[], indexesToSign: number[]): Promise<Uint8Array[]>;
+    get name(): string;
+    get accounts(): WalletAccount[];
+    get addresses(): string[];
+    get activeAccount(): WalletAccount | null;
+    get activeAddress(): string | null;
+    get activeNetwork(): NetworkId;
+    get isConnected(): boolean;
+    get isActive(): boolean;
+    protected onDisconnect(): void;
+}
+
+type WalletState = {
+    accounts: WalletAccount[];
+    activeAccount: WalletAccount | null;
 };
+type WalletStateMap = Partial<Record<WalletId, WalletState>>;
+interface State {
+    wallets: WalletStateMap;
+    activeWallet: WalletId | null;
+    activeNetwork: NetworkId;
+}
+declare const defaultState: State;
+
+interface WalletManagerConfig {
+    wallets?: SupportedWallet[];
+    network?: NetworkId;
+    algod?: NetworkConfig;
+}
+declare class WalletManager {
+    _clients: Map<WalletId, BaseWallet>;
+    networkConfig: NetworkConfigMap;
+    algodClient: algosdk.Algodv2;
+    store: Store<State>;
+    subscribe: (callback: (state: State) => void) => () => void;
+    constructor({ wallets, network, algod }?: WalletManagerConfig);
+    private loadPersistedState;
+    private savePersistedState;
+    private initializeWallets;
+    get wallets(): BaseWallet[];
+    getWallet(walletId: WalletId): BaseWallet | undefined;
+    resumeSessions(): Promise<void>;
+    private initNetworkConfig;
+    private createAlgodClient;
+    getAlgodClient: () => algosdk.Algodv2;
+    setActiveNetwork(networkId: NetworkId): void;
+    get activeNetwork(): NetworkId;
+    get activeWallet(): BaseWallet | null;
+    get activeWalletAccounts(): WalletAccount[] | null;
+    get activeWalletAddresses(): string[] | null;
+    get activeAccount(): WalletAccount | null;
+    get activeAddress(): string | null;
+    get signTransactions(): (txnGroup: algosdk.Transaction[] | algosdk.Transaction[][] | Uint8Array[] | Uint8Array[][], indexesToSign?: number[] | undefined, returnGroup?: boolean | undefined) => Promise<Uint8Array[]>;
+    /**
+     * A function which can sign transactions from an atomic transaction group. The logic will be
+     * specific to each wallet, but the function will always return a promise that resolves to an
+     * array of encoded signed transactions matching the length of the indexesToSign array.
+     *
+     * @see https://github.com/algorand/js-algorand-sdk/blob/v2.6.0/src/signer.ts#L7-L18
+     *
+     * @param txnGroup - The atomic group containing transactions to be signed
+     * @param indexesToSign - An array of indexes in the atomic transaction group that should be signed
+     * @returns A promise which resolves an array of encoded signed transactions. The length of the
+     *   array will be the same as the length of indexesToSign, and each index i in the array
+     *   corresponds to the signed transaction from txnGroup[indexesToSign[i]]
+     */
+    get transactionSigner(): algosdk.TransactionSigner;
+}
 
-interface InitializeProvidersOptions {
-    providers: ProvidersArray;
-    nodeConfig?: NodeConfig;
-    algosdkStatic?: typeof algosdk;
-    debug?: boolean;
+declare class StorageAdapter {
+    static getItem(key: string): string | null;
+    static setItem(key: string, value: string): void;
 }
-declare function useInitializeProviders({ providers, nodeConfig, algosdkStatic, debug }: InitializeProvidersOptions): Partial<Record<PROVIDER_ID, BaseClient | null>> | null;
 
-export { Account, AccountInfo, AlgodClientOptions, Asset, ClientOptions, CommonInitParams, ConfirmedTxn, CustomProvider, 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, WalletProvider, AlgoSignerClient as algosigner, CustomWalletClient as custom, DeflyWalletClient as defly, encodeNFDTransactionsArray, ExodusClient as exodus, KibisisClient as kibisis, KMDWalletClient as kmd, LuteClient as lute, MagicAuth as magic, MnemonicWalletClient as mnemonic, MyAlgoWalletClient as myalgo, PeraWalletClient as pera, reconnectProviders, useInitializeProviders, useWallet, WalletConnectClient as walletconnect };
+export { BaseWallet, type BaseWalletConstructor, DeflyWallet, type DeflyWalletConnectOptions, type EnableResult, type Exodus, type ExodusOptions, ExodusWallet, type JsonRpcRequest, type KmdOptions, KmdWallet, type MnemonicOptions, MnemonicWallet, type MultisigMetadata, NetworkId, PeraWallet, type PeraWalletConnectOptions, type SignTxnsResult, type SignerTransaction, type State, StorageAdapter, type SupportedWallet, type SupportedWallets, type WalletAccount, type WalletConfig, type WalletConfigMap, WalletConnect, type WalletConnectOptions, type WalletConstructor, WalletId, type WalletIdConfig, WalletManager, type WalletManagerConfig, type WalletMap, type WalletMetadata, type WalletOptions, type WalletOptionsMap, type WalletState, type WalletTransaction, type WindowExtended, defaultState };