Class AnyWalletState

Hierarchy

AnyWalletState

Constructors

constructor

new AnyWalletState(config?): AnyWalletState
Parameters
- Optional config: AnyWalletStateConfig
Returns AnyWalletState
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:594

Properties

activeAccount

activeAccount: null | Account

allWallets

allWallets: {
    algosigner: {
        accounts: Account[];
        client: null | AlgoSignerClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    defly: {
        accounts: Account[];
        client: null | DeflyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    exodus: {
        accounts: Account[];
        client: null | ExodusClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    inkey: {
        accounts: Account[];
        client: null | InkeyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    mnemonic: {
        accounts: Account[];
        client: null | MnemonicClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    myalgo: {
        accounts: Account[];
        client: null | MyAlgoClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    pera: {
        accounts: Account[];
        client: null | PeraClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
}

Type declaration

algosigner: {
    accounts: Account[];
    client: null | AlgoSignerClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | AlgoSignerClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
defly: {
    accounts: Account[];
    client: null | DeflyClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | DeflyClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
exodus: {
    accounts: Account[];
    client: null | ExodusClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | ExodusClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
inkey: {
    accounts: Account[];
    client: null | InkeyClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | InkeyClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
mnemonic: {
    accounts: Account[];
    client: null | MnemonicClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | MnemonicClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
myalgo: {
    accounts: Account[];
    client: null | MyAlgoClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | MyAlgoClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
pera: {
    accounts: Account[];
    client: null | PeraClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Readonly accounts: Account[]
- client: null | PeraClient
- connect: ((p?) => Promise<Account[]>)
  - - (p?): Promise<Account[]>
    - Parameters
      
      Optional p: any
      Returns Promise<Account[]>
- connecting: boolean
- disconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- id: W_ID
- initParams: boolean | ClientInitParams
- inited: boolean
- initing: boolean
- Readonly isActive: boolean
- Readonly isConnected: boolean
- loadClient: (() => Promise<boolean>)
  - - (): Promise<boolean>
    - Returns Promise<boolean>
- metadata: ClientMetadata
- reconnect: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>
- removeAccounts: (() => void)
  - - (): void
    - Returns void
- setAsActiveWallet: (() => void)
  - - (): void
    - Returns void
- signTransactions: ((transactions) => Promise<Uint8Array[]>)
  - - (transactions): Promise<Uint8Array[]>
    - Parameters
      
      transactions: Uint8Array[]
      Returns Promise<Uint8Array[]>
- signing: boolean
- unloadClient: (() => Promise<void>)
  - - (): Promise<void>
    - Returns Promise<void>

arr

arr: IObservableArray<number[]>

changedAccountHandlers

changedAccountHandlers: Set<any>

connectWallet

connectWallet: (<W, P>(wId, wInitParams?) => Promise<Account[]>)

Type declaration

- <W, P>(wId, wInitParams?): Promise<Account[]>
- Type Parameters
  - W extends W_ID
  - P extends undefined | string | boolean | {
        config?: InkeyConfig;
        id?: "inkey";
        sdk?: {
            frameBus: FrameBus;
            connect(payload?) => Promise<InkeyAccount[]>;
            disconnect() => Promise<InkeyResponseBase>;
            hide() => void;
            ping<R, T>(data, options?) => Promise<R>;
            show(routepath?) => void;
            signTxns(txns, connectedAccounts?) => Promise<InkeySignTxnResponse>;
            signTxnsUint8Array(txns, connectedAccounts?) => Promise<InkeySignTxnResponse>;
        };
    } | {
        config?: SdkConfig$6;
        id?: "pera";
        sdk?: PeraSdk;
    } | {
        config?: SdkConfig$4;
        id?: "myalgo";
        sdk?: default;
    } | {
        config?: SdkConfig$3;
        id?: "algosigner";
        sdk?: AlgoSignerSdk;
    } | {
        config?: SdkConfig$2;
        id?: "exodus";
        sdk?: ExodusSdk;
    } | {
        config?: SdkConfig$1;
        id?: "defly";
        sdk?: DeflySdk;
    } | {
        config?: SdkConfig;
        id?: "mnemonic";
        sdk?: default;
    }
  Parameters
  - wId: W
  - Optional wInitParams: P
  Returns Promise<Account[]>

connectedAccounts

connectedAccounts: Account[]

disconnectAllWallets

disconnectAllWallets: (() => Promise<void>)

Type declaration

- (): Promise<void>
- Returns Promise<void>

disconnectWallet

disconnectWallet: (<W>(wId) => Promise<void>)

Type declaration

- <W>(wId): Promise<void>
- Type Parameters
  - W extends W_ID
  Parameters
  - wId: W
  Returns Promise<void>

emitSyncStates

emitSyncStates: (() => void)

Type declaration

- (): void
- Returns void

getAccountsByWalletId

getAccountsByWalletId: ((id) => Account[])

Type declaration

- (id): Account[]
- Parameters
  - id: W_ID
  Returns Account[]

initWallet

initWallet: (<W, P>(wId, wInitParams) => {
    algosigner: {
        accounts: Account[];
        client: null | AlgoSignerClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    defly: {
        accounts: Account[];
        client: null | DeflyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    exodus: {
        accounts: Account[];
        client: null | ExodusClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    inkey: {
        accounts: Account[];
        client: null | InkeyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    mnemonic: {
        accounts: Account[];
        client: null | MnemonicClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    myalgo: {
        accounts: Account[];
        client: null | MyAlgoClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    pera: {
        accounts: Account[];
        client: null | PeraClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
}[W])

Type declaration

- <W, P>(wId, wInitParams): {
      algosigner: {
          accounts: Account[];
          client: null | AlgoSignerClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      defly: {
          accounts: Account[];
          client: null | DeflyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      exodus: {
          accounts: Account[];
          client: null | ExodusClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      inkey: {
          accounts: Account[];
          client: null | InkeyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      mnemonic: {
          accounts: Account[];
          client: null | MnemonicClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      myalgo: {
          accounts: Account[];
          client: null | MyAlgoClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      pera: {
          accounts: Account[];
          client: null | PeraClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
  }[W]
- Type Parameters
  - W extends W_ID
  - P extends undefined | string | boolean | {
        config?: InkeyConfig;
        id?: "inkey";
        sdk?: {
            frameBus: FrameBus;
            connect(payload?) => Promise<InkeyAccount[]>;
            disconnect() => Promise<InkeyResponseBase>;
            hide() => void;
            ping<R, T>(data, options?) => Promise<R>;
            show(routepath?) => void;
            signTxns(txns, connectedAccounts?) => Promise<InkeySignTxnResponse>;
            signTxnsUint8Array(txns, connectedAccounts?) => Promise<InkeySignTxnResponse>;
        };
    } | {
        config?: SdkConfig$6;
        id?: "pera";
        sdk?: PeraSdk;
    } | {
        config?: SdkConfig$4;
        id?: "myalgo";
        sdk?: default;
    } | {
        config?: SdkConfig$3;
        id?: "algosigner";
        sdk?: AlgoSignerSdk;
    } | {
        config?: SdkConfig$2;
        id?: "exodus";
        sdk?: ExodusSdk;
    } | {
        config?: SdkConfig$1;
        id?: "defly";
        sdk?: DeflySdk;
    } | {
        config?: SdkConfig;
        id?: "mnemonic";
        sdk?: default;
    }
  Parameters
  - wId: W
  - wInitParams: P
  Returns {
      algosigner: {
          accounts: Account[];
          client: null | AlgoSignerClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      defly: {
          accounts: Account[];
          client: null | DeflyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      exodus: {
          accounts: Account[];
          client: null | ExodusClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      inkey: {
          accounts: Account[];
          client: null | InkeyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      mnemonic: {
          accounts: Account[];
          client: null | MnemonicClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      myalgo: {
          accounts: Account[];
          client: null | MyAlgoClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      pera: {
          accounts: Account[];
          client: null | PeraClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
  }[W]

initWallets

initWallets: ((walletInits) => {
    algosigner: {
        accounts: Account[];
        client: null | AlgoSignerClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    defly: {
        accounts: Account[];
        client: null | DeflyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    exodus: {
        accounts: Account[];
        client: null | ExodusClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    inkey: {
        accounts: Account[];
        client: null | InkeyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    mnemonic: {
        accounts: Account[];
        client: null | MnemonicClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    myalgo: {
        accounts: Account[];
        client: null | MyAlgoClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
    pera: {
        accounts: Account[];
        client: null | PeraClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    };
})

Type declaration

- (walletInits): {
      algosigner: {
          accounts: Account[];
          client: null | AlgoSignerClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      defly: {
          accounts: Account[];
          client: null | DeflyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      exodus: {
          accounts: Account[];
          client: null | ExodusClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      inkey: {
          accounts: Account[];
          client: null | InkeyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      mnemonic: {
          accounts: Account[];
          client: null | MnemonicClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      myalgo: {
          accounts: Account[];
          client: null | MyAlgoClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      pera: {
          accounts: Account[];
          client: null | PeraClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
  }
- Parameters
  - walletInits: WalletInitParamsObj
  Returns {
      algosigner: {
          accounts: Account[];
          client: null | AlgoSignerClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      defly: {
          accounts: Account[];
          client: null | DeflyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      exodus: {
          accounts: Account[];
          client: null | ExodusClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      inkey: {
          accounts: Account[];
          client: null | InkeyClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      mnemonic: {
          accounts: Account[];
          client: null | MnemonicClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      myalgo: {
          accounts: Account[];
          client: null | MyAlgoClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
      pera: {
          accounts: Account[];
          client: null | PeraClient;
          connect: ((p?) => Promise<Account[]>);
          connecting: boolean;
          disconnect: (() => Promise<void>);
          id: W_ID;
          initParams: boolean | ClientInitParams;
          inited: boolean;
          initing: boolean;
          isActive: boolean;
          isConnected: boolean;
          loadClient: (() => Promise<boolean>);
          metadata: ClientMetadata;
          reconnect: (() => Promise<void>);
          removeAccounts: (() => void);
          setAsActiveWallet: (() => void);
          signTransactions: ((transactions) => Promise<Uint8Array[]>);
          signing: boolean;
          unloadClient: (() => Promise<void>);
      };
  }
  - algosigner: {
        accounts: Account[];
        client: null | AlgoSignerClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | AlgoSignerClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - defly: {
        accounts: Account[];
        client: null | DeflyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | DeflyClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - exodus: {
        accounts: Account[];
        client: null | ExodusClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | ExodusClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - inkey: {
        accounts: Account[];
        client: null | InkeyClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | InkeyClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - mnemonic: {
        accounts: Account[];
        client: null | MnemonicClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | MnemonicClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - myalgo: {
        accounts: Account[];
        client: null | MyAlgoClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | MyAlgoClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
  - pera: {
        accounts: Account[];
        client: null | PeraClient;
        connect: ((p?) => Promise<Account[]>);
        connecting: boolean;
        disconnect: (() => Promise<void>);
        id: W_ID;
        initParams: boolean | ClientInitParams;
        inited: boolean;
        initing: boolean;
        isActive: boolean;
        isConnected: boolean;
        loadClient: (() => Promise<boolean>);
        metadata: ClientMetadata;
        reconnect: (() => Promise<void>);
        removeAccounts: (() => void);
        setAsActiveWallet: (() => void);
        signTransactions: ((transactions) => Promise<Uint8Array[]>);
        signing: boolean;
        unloadClient: (() => Promise<void>);
    }
    - Readonly accounts: Account[]
    - client: null | PeraClient
    - connect: ((p?) => Promise<Account[]>)
      - (p?): Promise<Account[]>
        
        Parameters
        
        Optional p: any
        
        Returns Promise<Account[]>
    - connecting: boolean
    - disconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - id: W_ID
    - initParams: boolean | ClientInitParams
    - inited: boolean
    - initing: boolean
    - Readonly isActive: boolean
    - Readonly isConnected: boolean
    - loadClient: (() => Promise<boolean>)
      - (): Promise<boolean>
        
        Returns Promise<boolean>
    - metadata: ClientMetadata
    - reconnect: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>
    - removeAccounts: (() => void)
      - (): void
        
        Returns void
    - setAsActiveWallet: (() => void)
      - (): void
        
        Returns void
    - signTransactions: ((transactions) => Promise<Uint8Array[]>)
      - (transactions): Promise<Uint8Array[]>
        
        Parameters
        
        transactions: Uint8Array[]
        
        Returns Promise<Uint8Array[]>
    - signing: boolean
    - unloadClient: (() => Promise<void>)
      - (): Promise<void>
        
        Returns Promise<void>

removeAccount

removeAccount: ((acct) => void)

Type declaration

- (acct): void
- Parameters
  - acct: Account
  Returns void

removeAccountsByWalletId

removeAccountsByWalletId: ((id) => void)

Type declaration

- (id): void
- Parameters
  - id: W_ID
  Returns void

removeAllAccounts

removeAllAccounts: (() => void)

Type declaration

- (): void
- Returns void

selfId

selfId: string

setAsActiveAccount

setAsActiveAccount: ((acct) => void)

Type declaration

- (acct): void
- Parameters
  - acct: Account
  Returns void

signTransactions

signTransactions: ((txns) => Promise<Uint8Array[]>)

Type declaration

- (txns): Promise<Uint8Array[]>
- Parameters
  - txns: Uint8Array[]
  Returns Promise<Uint8Array[]>

storageController

storageController: undefined | StorageController

storageKey

storageKey: undefined | string

subscribeToAccountChanges

subscribeToAccountChanges: ((handler, opts?) => (() => void))

Type declaration

- (handler, opts?): (() => void)
- Parameters
  - handler: ((a) => void)
    - (a): void
      
      Parameters
      
      a: null | Account
      
      Returns void
  - Optional opts: {
    callOnSet: boolean;
    }
    - callOnSet: boolean
  Returns (() => void)
  - - (): void
    - Returns void

Accessors

activeAddress

get activeAddress(): string
Returns string
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:911

activeWallet

get activeWallet(): undefined | {
    accounts: Account[];
    client: null | InkeyClient | PeraClient | MyAlgoClient | AlgoSignerClient | ExodusClient | DeflyClient | MnemonicClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
Returns undefined | {
    accounts: Account[];
    client: null | InkeyClient | PeraClient | MyAlgoClient | AlgoSignerClient | ExodusClient | DeflyClient | MnemonicClient;
    connect: ((p?) => Promise<Account[]>);
    connecting: boolean;
    disconnect: (() => Promise<void>);
    id: W_ID;
    initParams: boolean | ClientInitParams;
    inited: boolean;
    initing: boolean;
    isActive: boolean;
    isConnected: boolean;
    loadClient: (() => Promise<boolean>);
    metadata: ClientMetadata;
    reconnect: (() => Promise<void>);
    removeAccounts: (() => void);
    setAsActiveWallet: (() => void);
    signTransactions: ((transactions) => Promise<Uint8Array[]>);
    signing: boolean;
    unloadClient: (() => Promise<void>);
}
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:913

activeWalletId

get activeWalletId(): null | W_ID
Returns null | W_ID
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:912

isIniting

get isIniting(): boolean
Returns boolean
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:935

isSigning

get isSigning(): boolean
Returns boolean
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:934

Methods

addConnectedAccounts

addConnectedAccounts(accounts): void
Parameters
- accounts: Account[]
Returns void
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:600

initVars

initVars(): void
Returns void
- Defined in node_modules/.pnpm/@thencc+any-wallet@0.2.5_algosdk@2.3.0/node_modules/@thencc/any-wallet/dist/index.d.ts:599

Class AnyWalletState

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Optional config: AnyWalletStateConfig

Returns AnyWalletState

Properties

activeAccount

allWallets

Type declaration

Readonly accounts: Account[]

client: null | AlgoSignerClient

connect: ((p?) => Promise<Account[]>)

Parameters

Optional p: any

Returns Promise<Account[]>

connecting: boolean

disconnect: (() => Promise<void>)

Returns Promise<void>

id: W_ID

initParams: boolean | ClientInitParams

inited: boolean

initing: boolean

Readonly isActive: boolean

Readonly isConnected: boolean

loadClient: (() => Promise<boolean>)

Returns Promise<boolean>

metadata: ClientMetadata

reconnect: (() => Promise<void>)

Returns Promise<void>

removeAccounts: (() => void)

Returns void

setAsActiveWallet: (() => void)

Returns void

signTransactions: ((transactions) => Promise<Uint8Array[]>)

Parameters

transactions: Uint8Array[]

Returns Promise<Uint8Array[]>

signing: boolean

unloadClient: (() => Promise<void>)

Returns Promise<void>

Readonly accounts: Account[]

client: null | DeflyClient

connect: ((p?) => Promise<Account[]>)

Parameters

Optional p: any

Returns Promise<Account[]>

connecting: boolean

disconnect: (() => Promise<void>)

Returns Promise<void>

id: W_ID

initParams: boolean | ClientInitParams

inited: boolean

initing: boolean

Readonly isActive: boolean

Readonly isConnected: boolean

loadClient: (() => Promise<boolean>)

Returns Promise<boolean>

metadata: ClientMetadata

reconnect: (() => Promise<void>)

Returns Promise<void>

removeAccounts: (() => void)

Returns void

setAsActiveWallet: (() => void)

Returns void

signTransactions: ((transactions) => Promise<Uint8Array[]>)

Parameters

transactions: Uint8Array[]

Returns Promise<Uint8Array[]>

signing: boolean

unloadClient: (() => Promise<void>)

Returns Promise<void>

Readonly accounts: Account[]

client: null | ExodusClient

`Optional` config: AnyWalletStateConfig

`Readonly` accounts: Account[]

`Optional` p: any

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

`Readonly` accounts: Account[]

`Optional` p: any

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

`Readonly` accounts: Account[]

`Optional` p: any

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

`Readonly` accounts: Account[]

`Optional` p: any

`Readonly` isActive: boolean

`Readonly` isConnected: boolean

`Readonly` accounts: Account[]

`Optional` p: any