Class AeSdkWallet

Contain functionality for aepp interaction and managing multiple aepps

Hierarchy (View Summary)

AeSdk
- AeSdkWallet

Index

Constructors

constructor

Accessors

address api compilerApi

Constructors

constructor

new AeSdkWallet(
    options: {
        id: string;
        name: string;
        onAskAccounts: OnAskAccounts;
        onAskToSelectNetwork: OnAskToSelectNetwork;
        onConnection: OnConnection;
        onDisconnect: OnDisconnect;
        onSubscription: OnSubscription;
        type: WALLET_TYPE;
    } & { accounts?: AccountBase[] } & AeSdkMethodsOptions & {
        nodes?: { instance: Node; name: string }[];
    },
): AeSdkWallet
Parameters
- options: {
      id: string;
      name: string;
      onAskAccounts: OnAskAccounts;
      onAskToSelectNetwork: OnAskToSelectNetwork;
      onConnection: OnConnection;
      onDisconnect: OnDisconnect;
      onSubscription: OnSubscription;
      type: WALLET_TYPE;
  } & { accounts?: AccountBase[] } & AeSdkMethodsOptions & {
      nodes?: { instance: Node; name: string }[];
  }
  Options
  - id: string
    Wallet id
  - name: string
    Wallet name
  - onAskAccounts: OnAskAccounts
    Call-back function for incoming AEPP get address request
  - onAskToSelectNetwork: OnAskToSelectNetwork
    Call-back function for incoming AEPP select network request. If the request is fine then this function should change the current network.
  - onConnection: OnConnection
    Call-back function for incoming AEPP connection
  - onDisconnect: OnDisconnect
    Call-back function for disconnect event
  - onSubscription: OnSubscription
    Call-back function for incoming AEPP account subscription
  - type: WALLET_TYPE
    Wallet type
  - Optionalaccounts?: AccountBase[]
  - Optionalnodes?: { instance: Node; name: string }[]
Returns AeSdkWallet
Overrides AeSdk.constructor
- Defined in AeSdkWallet.ts:96

Properties

_clients

_clients: Map<string, RpcClientsInfo> = ...

_getPollInterval

_getPollInterval: (
    ...args:
        | [type: "key-block" | "micro-block"]
        | [
            type: "key-block"
            | "micro-block",
            Omit<
                {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

_options

_options: AeSdkMethodsOptions = {}

_type

_type: WALLET_TYPE

accounts

accounts: { [key: `ak_${string}`]: AccountBase } = {}

awaitHeight

awaitHeight: (
    ...args:
        | [height: number]
        | [
            height: number,
            Omit<
                { interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

buildAuthTxHash

buildAuthTxHash: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<
                { fee?: Int; gasPrice?: Int; onNode: Node },
                "onNode" | "onAccount" | "onCompiler",
            > & Partial<{ fee?: Int; gasPrice?: Int; onNode: Node }>,
        ],
) => Promise

buildAuthTxHashByGaMetaTx

buildAuthTxHashByGaMetaTx: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

createGeneralizedAccount

createGeneralizedAccount: (
    ...args:
        | [authFnName: string, args: any[]]
        | [
            authFnName: string,
            args: any[],
            Omit<
                CreateGeneralizedAccountOptions,
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                Omit<CreateGeneralizedAccountOptions, "onAccount"> & {
                    onAccount: OnAccount;
                },
            >,
        ],
) => Promise

getAccount

getAccount: (
    ...args:
        | [address: `ct_${string}` | `ak_${string}`]
        | [
            address: `ct_${string}`
            | `ak_${string}`,
            Omit<
                {
                    hash?: `kh_${string}`
                    | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    hash?: `kh_${string}`
                    | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getBalance

getBalance: (
    ...args:
        | [address: `ct_${string}` | `ok_${string}` | `ak_${string}`]
        | [
            address: `ct_${string}`
            | `ok_${string}`
            | `ak_${string}`,
            Omit<
                { format?: AE_AMOUNT_FORMATS } & {
                    hash?: `kh_${string}` | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { format?: AE_AMOUNT_FORMATS } & {
                    hash?: `kh_${string}` | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getContract

getContract: (
    ...args:
        | [contractId: `ct_${string}`]
        | [
            contractId: `ct_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getContractByteCode

getContractByteCode: (
    ...args:
        | [contractId: `ct_${string}`]
        | [
            contractId: `ct_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getCurrentGeneration

getCurrentGeneration: (
    ...args:
        | []
        | [
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getGeneration

getGeneration: (
    ...args:
        | [hashOrHeight: number | `kh_${string}`]
        | [
            hashOrHeight: number
            | `kh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getHeight

getHeight: (
    ...args:
        | []
        | [
            Omit<
                { cached?: boolean; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { cached?: boolean; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getKeyBlock

getKeyBlock: (
    ...args:
        | [hashOrHeight: number | `kh_${string}`]
        | [
            hashOrHeight: number
            | `kh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getMicroBlockHeader

getMicroBlockHeader: (
    ...args:
        | [hash: `mh_${string}`]
        | [
            hash: `mh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getMicroBlockTransactions

getMicroBlockTransactions: (
    ...args:
        | [hash: `mh_${string}`]
        | [
            hash: `mh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getName

getName: (
    ...args:
        | [name: `${string}.chain`]
        | [
            name: `${string}.chain`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

id

id: string

name

name: string

onAskAccounts

onAskAccounts: OnAskAccounts

onAskToSelectNetwork

onAskToSelectNetwork: OnAskToSelectNetwork

onConnection

onConnection: OnConnection

onDisconnect

onDisconnect: OnDisconnect

onSubscription

onSubscription: OnSubscription

payForTransaction

payForTransaction: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<PayForTransactionOptions, "onAccount"> & {
                    onAccount: OnAccount;
                },
            >,
        ],
) => Promise

poll

poll: (
    ...args:
        | [th: `th_${string}`]
        | [
            th: `th_${string}`,
            Omit<
                { blocks?: number; interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { blocks?: number; interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

pool

pool: Map<string, Node> = ...

resolveName

resolveName: (
    ...args:
        | [
            nameOrId: `${string}.chain`
            | `ct_${string}`
            | `ak_${string}`,
            key: string,
        ]
        | [
            nameOrId: `${string}.chain`
            | `ct_${string}`
            | `ak_${string}`,
            key: string,
            Omit<
                { onNode: Node; resolveByNode?: boolean; verify?: boolean },
                "onNode" | "onAccount" | "onCompiler",
            > & Partial<{ onNode: Node; resolveByNode?: boolean; verify?: boolean }>,
        ],
) => Promise

`Optional`selectedAddress

selectedAddress?: `ak_${string}`

`Optional`selectedNodeName

selectedNodeName?: string

sendTransaction

sendTransaction: (
    ...args:
        | [txUnsigned: `tx_${string}`]
        | [
            txUnsigned: `tx_${string}`,
            Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<SendTransactionOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

spend

spend: (
    ...args:
        | [
            amount: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
        ]
        | [
            amount: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
            Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<SpendOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

transferFunds

transferFunds: (
    ...args:
        | [
            fraction: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
        ]
        | [
            fraction: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
            Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<TransferFundsOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

txDryRun

txDryRun: (
    ...args:
        | [tx: `tx_${string}`, accountAddress: `ak_${string}`]
        | [
            tx: `tx_${string}`,
            accountAddress: `ak_${string}`,
            Omit<
                {
                    combine?: boolean;
                    onNode: Node;
                    top?: number
                    | `kh_${string}`
                    | `mh_${string}`;
                    txEvents?: boolean;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    combine?: boolean;
                    onNode: Node;
                    top?: number
                    | `kh_${string}`
                    | `mh_${string}`;
                    txEvents?: boolean;
                },
            >,
        ],
) => Promise

waitForTxConfirm

waitForTxConfirm: (
    ...args:
        | [txHash: `th_${string}`]
        | [
            txHash: `th_${string}`,
            Omit<
                { confirm?: number; onNode: Node } & {
                    interval?: number;
                    onNode: Node;
                } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { confirm?: number; onNode: Node } & {
                    interval?: number;
                    onNode: Node;
                } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

Accessors

address

get address(): `ak_${string}`
Returns `ak_${string}`
Inherited from AeSdk.address
- Defined in AeSdkBase.ts:159

api

get api(): Node
Returns Node
Inherited from AeSdk.api
- Defined in AeSdkBase.ts:61

compilerApi

get compilerApi(): CompilerBase
Returns CompilerBase
Inherited from AeSdk.compilerApi
- Defined in AeSdkBase.ts:54

Methods

_disconnectRpcClient

_disconnectRpcClient(clientId: string): void
Parameters
- clientId: string
Returns void
- Defined in AeSdkWallet.ts:189

_getAccountsForClient

_getAccountsForClient(__namedParameters: RpcClientsInfo): Accounts
Parameters
- __namedParameters: RpcClientsInfo
Returns Accounts
- Defined in AeSdkWallet.ts:127

_getClient

_getClient(clientId: string): RpcClientsInfo
Parameters
- clientId: string
Returns RpcClientsInfo
- Defined in AeSdkWallet.ts:176

_getNode

_getNode(): { node: undefined | Node }
Returns { node: undefined | Node }
- Defined in AeSdkWallet.ts:157

_isRpcClientConnected

_isRpcClientConnected(clientId: string): boolean
Parameters
- clientId: string
Returns boolean
- Defined in AeSdkWallet.ts:182

_pushAccountsToApps

_pushAccountsToApps(): void
Returns void
- Defined in AeSdkWallet.ts:136

_resolveAccount

_resolveAccount(account?: OnAccount): AccountBase
Resolves an account
Parameters
- account: OnAccount = ...
  ak-address, instance of AccountBase, or keypair
Returns AccountBase
Inherited from AeSdk._resolveAccount
- Defined in AeSdk.ts:23

addAccount

addAccount(account: AccountBase, options?: { select?: boolean }): void
Add specific account
Parameters
- account: AccountBase
  Account instance
- Optionaloptions: { select?: boolean }
  Options
  - Optionalselect?: boolean
    Select account
Returns void
Example
```
addAccount(account)
```
Overrides AeSdk.addAccount
- Defined in AeSdkWallet.ts:152

addNode

addNode(name: string, node: Node, select?: boolean): void
Add Node
Parameters
- name: string
  Node name
- node: Node
  Node instance
- select: boolean = false
  Select this node as current
Returns void
Example
```
// add and select new node with name 'testNode'
aeSdkBase.addNode('testNode', new Node({ url }), true)
```
Inherited from AeSdk.addNode
- Defined in AeSdkBase.ts:77

addresses

addresses(): `ak_${string}`[]
Get accounts addresses

Returns `ak_${string}`[]
Example
```
addresses()
```
Inherited from AeSdk.addresses
- Defined in AeSdk.ts:37

addRpcClient

addRpcClient(clientConnection: default): string
Add new client by AEPP connection
Parameters
- clientConnection: default
  AEPP connection object
Returns string
Client ID
- Defined in AeSdkWallet.ts:210

buildTx

buildTx(options: TxParamsAsync): Promise<`tx_${string}`>
Parameters
- options: TxParamsAsync
Returns Promise<`tx_${string}`>
Inherited from AeSdk.buildTx
- Defined in AeSdkMethods.ts:84

`Protected`ensureNodeConnected

ensureNodeConnected(): asserts this is AeSdkBase & { selectedNodeName: string }
Returns asserts this is AeSdkBase & { selectedNodeName: string }
Inherited from AeSdk.ensureNodeConnected
- Defined in AeSdkBase.ts:106

getAccounts

getAccounts(): Accounts
Get Wallet accounts

Returns Accounts
Object with accounts information ({ connected: Object, current: Object })
- Defined in AeSdkWallet.ts:386

getContext

getContext(
mergeWith?: AeSdkMethodsOptions,
): AeSdkMethodsOptions & WrappedOptions
The same as AeSdkMethods:getContext, but it would resolve ak_-prefixed address in mergeWith.onAccount to AccountBase.
Parameters
- mergeWith: AeSdkMethodsOptions = {}
Returns AeSdkMethodsOptions & WrappedOptions
Inherited from AeSdk.getContext
- Defined in AeSdkBase.ts:257

getNodeInfo

getNodeInfo(): Promise<NodeInfo>
Get information about node

Returns Promise<NodeInfo>
Example
```
nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
```
Inherited from AeSdk.getNodeInfo
- Defined in AeSdkBase.ts:119

getNodesInPool

getNodesInPool(): Promise<NodeInfo[]>
Get array of available nodes

Returns Promise<NodeInfo[]>
Example
```
nodePool.getNodesInPool()
```
Inherited from AeSdk.getNodesInPool
- Defined in AeSdkBase.ts:132

getWalletInfo

getWalletInfo(): Promise<WalletInfo>
Get Wallet info object

Returns Promise<WalletInfo>
Object with wallet information
- Defined in AeSdkWallet.ts:371

isNodeConnected

isNodeConnected(): this is AeSdkBase & { selectedNodeName: string }
Check if you have selected node

Returns this is AeSdkBase & { selectedNodeName: string }
Example
```
nodePool.isNodeConnected()
```
Inherited from AeSdk.isNodeConnected
- Defined in AeSdkBase.ts:102

removeAccount

removeAccount(address: `ak_${string}`): void
Remove specific account
Parameters
- address: `ak_${string}`
  Address of account to remove
Returns void
Example
```
removeAccount(address)
```
Inherited from AeSdk.removeAccount
- Defined in AeSdk.ts:59

removeRpcClient

removeRpcClient(id: string): void
Remove specific RpcClient by ID
Parameters
- id: string
  Client ID
Returns void
- Defined in AeSdkWallet.ts:200

selectAccount

selectAccount(address: `ak_${string}`): void
Select specific account
Parameters
- address: `ak_${string}`
  Address of account to select
Returns void
Example
```
selectAccount('ak_xxxxxxxx')
```
Overrides AeSdk.selectAccount
- Defined in AeSdkWallet.ts:147

selectNode

selectNode(name: string): Promise<void>
Select Node
Parameters
- name: string
  Node name
Returns Promise<void>
Example
```
nodePool.selectNode('testNode')
```
Overrides AeSdk.selectNode
- Defined in AeSdkWallet.ts:162

shareWalletInfo

shareWalletInfo(clientId: string): Promise<void>
Send shareWalletInfo message to notify AEPP about wallet
Parameters
- clientId: string
  ID of RPC client send message to
Returns Promise<void>
- Defined in AeSdkWallet.ts:363

sign

sign(
data: string | Uint8Array,
options?: { onAccount?: OnAccount },
): Promise<Uint8Array>
Sign data blob
Parameters
- data: string | Uint8Array
  Data to sign
- options: { onAccount?: OnAccount } = {}
  Options
Returns Promise<Uint8Array>
Deprecated
Use unsafeSign method instead
Inherited from AeSdk.sign
- Defined in AeSdkBase.ts:169

signDelegation

signDelegation(
    delegation: `ba_${string}`,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
        networkId?: string;
    },
): Promise<`sg_${string}`>
Sign delegation, works only in Ceres
Parameters
- delegation: `ba_${string}`
  Delegation to sign
- options: { onAccount?: OnAccount } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      networkId?: string;
  } = {}
  Options
Returns Promise<`sg_${string}`>
Inherited from AeSdk.signDelegation
- Defined in AeSdkBase.ts:241

signMessage

signMessage(
    message: string,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
    },
): Promise<Uint8Array>
Sign message
Parameters
- message: string
  Message to sign
- options: { onAccount?: OnAccount } & { aeppOrigin?: string; aeppRpcClientId?: string } = {}
  Options
Returns Promise<Uint8Array>
Inherited from AeSdk.signMessage
- Defined in AeSdkBase.ts:209

signTransaction

signTransaction(
    tx: `tx_${string}`,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
        authData?: AuthData | (tx: `tx_${string}`) => Promise<AuthData>;
        innerTx?: boolean;
        networkId?: string;
        onCompiler?: CompilerBase;
        onNode?: Node;
    },
): Promise<`tx_${string}`>
Sign encoded transaction
Parameters
- tx: `tx_${string}`
  Transaction to sign
- options: { onAccount?: OnAccount } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      authData?: AuthData | (tx: `tx_${string}`) => Promise<AuthData>;
      innerTx?: boolean;
      networkId?: string;
      onCompiler?: CompilerBase;
      onNode?: Node;
  } = {}
  Options
Returns Promise<`tx_${string}`>
Inherited from AeSdk.signTransaction
- Defined in AeSdkBase.ts:193

signTypedData

signTypedData(
    data: `cb_${string}`,
    aci: AciValue,
    options?: { onAccount?: OnAccount } & Domain & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
    },
): Promise<`sg_${string}`>
Sign typed data
Parameters
- data: `cb_${string}`
  Encoded data to sign
- aci: AciValue
  Type of data to sign
- options: { onAccount?: OnAccount } & Domain & {
  aeppOrigin?: string;
  aeppRpcClientId?: string;
  } = {}
  Options
Returns Promise<`sg_${string}`>
Inherited from AeSdk.signTypedData
- Defined in AeSdkBase.ts:225

unsafeSign

unsafeSign(
data: string | Uint8Array,
options?: { onAccount?: OnAccount },
): Promise<Uint8Array>
Sign data blob
Parameters
- data: string | Uint8Array
  Data to sign
- options: { onAccount?: OnAccount } = {}
  Options
Returns Promise<Uint8Array>
Inherited from AeSdk.unsafeSign
- Defined in AeSdkBase.ts:181

Class AeSdkWallet

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

id: string

name: string

onAskAccounts: OnAskAccounts

onAskToSelectNetwork: OnAskToSelectNetwork

onConnection: OnConnection

onDisconnect: OnDisconnect

onSubscription: OnSubscription

type: WALLET_TYPE

Optionalaccounts?: AccountBase[]

Optionalnodes?: { instance: Node; name: string }[]

Returns AeSdkWallet

Properties

_clients

_getPollInterval

_options

_type

accounts

awaitHeight

buildAuthTxHash

buildAuthTxHashByGaMetaTx

createGeneralizedAccount

getAccount

getBalance

getContract

getContractByteCode

getCurrentGeneration

getGeneration

getHeight

getKeyBlock

getMicroBlockHeader

getMicroBlockTransactions

getName

id

name

onAskAccounts

onAskToSelectNetwork

onConnection

onDisconnect

onSubscription

payForTransaction

poll

pool

resolveName

OptionalselectedAddress

OptionalselectedNodeName

sendTransaction

spend

transferFunds

txDryRun

waitForTxConfirm

Accessors

address

Returns `ak_${string}`

api

Returns Node

compilerApi

Returns CompilerBase

Methods

_disconnectRpcClient

Parameters

Returns void

_getAccountsForClient

Parameters

Returns Accounts

_getClient

Parameters

Returns RpcClientsInfo

_getNode

Returns { node: undefined | Node }

_isRpcClientConnected

`Optional`accounts?: AccountBase[]

`Optional`nodes?: { instance: Node; name: string }[]

`Optional`selectedAddress

`Optional`selectedNodeName

`Optional`select?: boolean

`Protected`ensureNodeConnected