Class AccountManager

constructor

• new AccountManager(logger?: SoloLogger, k8Factory?: K8Factory): AccountManager

  Parameters

  • Optionallogger: SoloLogger
  • Optionalk8Factory: K8Factory

  Returns AccountManager

_nodeClient

_getNodeClient

• _getNodeClient(
      namespace: NamespaceName,
      networkNodeServicesMap: Map<string, NetworkNodeServices>,
      operatorId: string,
      operatorKey: string,
      skipNodeAlias: string,
  ): Promise<NodeClient>

  Returns a node client that can be used to make calls against

  Parameters

  • namespace: NamespaceName

    the namespace for which the node client resides
  • networkNodeServicesMap: Map<string, NetworkNodeServices>

    a map of the service objects that proxy the nodes
  • operatorId: string

    the account id of the operator of the transactions
  • operatorKey: string

    the private key of the operator of the transactions
  • skipNodeAlias: string

    the node alias to skip

  Returns Promise<NodeClient>

  a node client that can be used to call transactions

accountInfoQuery

• accountInfoQuery(accountId: string | AccountId): Promise<AccountInfo>

  gets the account info from Hedera network

  Parameters

  • accountId: string | AccountId

    the account

  Returns Promise<AccountInfo>

  the private key of the account

batchAccounts

• batchAccounts(accountRange?: number[][]): number[][]

  batch up the accounts into sets to be processed

  Parameters

  • OptionalaccountRange: number[][] = constants.SYSTEM_ACCOUNTS

  Returns number[][]

  an array of arrays of numbers representing the accounts to update

close

• close(): Promise<void>

  stops and closes the port forwards and the _nodeClient

  Returns Promise<void>

createNewAccount

• createNewAccount(
      namespace: NamespaceName,
      privateKey: PrivateKey,
      amount: number,
      setAlias?: boolean,
  ): Promise<
      {
          accountAlias?: string;
          accountId: string;
          balance: number;
          privateKey: string;
          publicKey: string;
      },
  >

  creates a new Hedera account

  Parameters

  • namespace: NamespaceName

    the namespace to store the Kubernetes key secret into
  • privateKey: PrivateKey

    the private key of type PrivateKey
  • amount: number

    the amount of HBAR to add to the account
  • OptionalsetAlias: boolean = false

    whether to set the alias of the account to the public key, requires the ed25519PrivateKey supplied to be ECDSA

  Returns Promise<
      {
          accountAlias?: string;
          accountId: string;
          balance: number;
          privateKey: string;
          publicKey: string;
      },
  >

  a custom object with the account information in it

getAccountKeys

• getAccountKeys(accountId: string | AccountId): Promise<Key[]>

  gets the account private and public key from the Kubernetes secret from which it is stored

  Parameters

  • accountId: string | AccountId

    the account

  Returns Promise<Key[]>

  the private key of the account

getAccountKeysFromSecret

• getAccountKeysFromSecret(
      accountId: string,
      namespace: NamespaceName,
      context?: string,
  ): Promise<AccountIdWithKeyPairObject>

  Gets the account keys from the Kubernetes secret from which it is stored

  Parameters

  • accountId: string

    the account ID for which we want its keys
  • namespace: NamespaceName

    the namespace storing the secret
  • Optionalcontext: string

  Returns Promise<AccountIdWithKeyPairObject>

getFileContents

• getFileContents(
      namespace: NamespaceName,
      fileNum: number,
      clusterRefs?: ClusterRefs,
      deployment?: string,
      forcePortForward?: boolean,
      context?: string,
  ): Promise<string>

  Parameters

  • namespace: NamespaceName
  • fileNum: number
  • OptionalclusterRefs: ClusterRefs
  • Optionaldeployment: string
  • OptionalforcePortForward: boolean
  • Optionalcontext: string

  Returns Promise<string>

getNodeServiceMap

• getNodeServiceMap(
      namespace: NamespaceName,
      clusterRefs?: ClusterRefs,
      deployment?: string,
  ): Promise<Map<`node${number}`, NetworkNodeServices>>

  Gets a Map of the Hedera node services and the attributes needed, throws a SoloError if anything fails

  Parameters

  • namespace: NamespaceName

    the namespace of the solo network deployment
  • OptionalclusterRefs: ClusterRefs

    the cluster references to use
  • Optionaldeployment: string

    the deployment to use

  Returns Promise<Map<`node${number}`, NetworkNodeServices>>

  a map of the network node services

getTreasuryAccountKeys

• getTreasuryAccountKeys(
      namespace: NamespaceName,
      context?: string,
  ): Promise<AccountIdWithKeyPairObject>

  Gets the treasury account private key from Kubernetes secret if it exists, else returns the Genesis private key, then will return an AccountInfo object with the accountId, ed25519PrivateKey, publicKey

  Parameters

  • namespace: NamespaceName

    the namespace that the secret is in
  • Optionalcontext: string

  Returns Promise<AccountIdWithKeyPairObject>

loadNodeClient

• loadNodeClient(
      namespace: NamespaceName,
      clusterRefs?: ClusterRefs,
      deployment?: string,
      forcePortForward?: boolean,
      context?: string,
  ): Promise<NodeClient>

  loads and initializes the Node Client

  Parameters

  • namespace: NamespaceName

    the namespace of the network
  • OptionalclusterRefs: ClusterRefs

    the cluster references to use
  • Optionaldeployment: string

    k8 deployment name
  • OptionalforcePortForward: boolean

    whether to force the port forward
  • Optionalcontext: string

    k8 context name

  Returns Promise<NodeClient>

prepareAddressBookBase64

• prepareAddressBookBase64(
      namespace: NamespaceName,
      clusterRefs?: ClusterRefs,
      deployment?: string,
      operatorId?: string,
      operatorKey?: string,
      forcePortForward?: boolean,
      context?: string,
  ): Promise<string>

  Fetch and prepare address book as a base64 string

  Parameters

  • namespace: NamespaceName
  • OptionalclusterRefs: ClusterRefs
  • Optionaldeployment: string
  • OptionaloperatorId: string
  • OptionaloperatorKey: string
  • OptionalforcePortForward: boolean
  • Optionalcontext: string

  Returns Promise<string>

refreshNodeClient

• refreshNodeClient(
      namespace: NamespaceName,
      skipNodeAlias?: `node${number}`,
      clusterRefs?: ClusterRefs,
      deployment?: string,
      context?: string,
      forcePortForward?: boolean,
  ): Promise<NodeClient>

  loads and initializes the Node Client, throws a SoloError if anything fails

  Parameters

  • namespace: NamespaceName

    the namespace of the network
  • OptionalskipNodeAlias: `node${number}`

    the node alias to skip
  • OptionalclusterRefs: ClusterRefs
  • Optionaldeployment: string
  • Optionalcontext: string
  • OptionalforcePortForward: boolean

    whether to force the port forward

  Returns Promise<NodeClient>

sendAccountKeyUpdate

• sendAccountKeyUpdate(
      accountId: string | AccountId,
      newPrivateKey: string | PrivateKey,
      oldPrivateKey: string | PrivateKey,
  ): Promise<boolean>

  send an account key update transaction to the network of nodes

  Parameters

  • accountId: string | AccountId

    the account that will get its keys updated
  • newPrivateKey: string | PrivateKey

    the new private key
  • oldPrivateKey: string | PrivateKey

    the genesis key that is the current key

  Returns Promise<boolean>

  whether the update was successful

transferAmount

• transferAmount(
      fromAccountId: string | AccountId,
      toAccountId: string | AccountId,
      hbarAmount: number,
  ): Promise<boolean>

  transfer the specified amount of HBAR from one account to another

  Parameters

  • fromAccountId: string | AccountId

    the account to pull the HBAR from
  • toAccountId: string | AccountId

    the account to put the HBAR
  • hbarAmount: number

    the amount of HBAR

  Returns Promise<boolean>

  if the transaction was successfully posted

updateAccountKeys

• updateAccountKeys(
      namespace: NamespaceName,
      accountId: AccountId,
      genesisKey: PrivateKey,
      updateSecrets: boolean,
      contexts?: string[],
  ): Promise<
      | { status: string; value: string }
      | { reason: string; status: string; value: string },
  >

  update the account keys for a given account and store its new key in a Kubernetes secret

  Parameters

  • namespace: NamespaceName

    the namespace of the nodes network
  • accountId: AccountId

    the account that will get its keys updated
  • genesisKey: PrivateKey

    the genesis key to compare against
  • updateSecrets: boolean

    whether to delete the secret before creating a new secret
  • Optionalcontexts: string[]

  Returns Promise<
      | { status: string; value: string }
      | { reason: string; status: string; value: string },
  >

  the result of the call

updateSpecialAccountsKeys

• updateSpecialAccountsKeys(
      namespace: NamespaceName,
      currentSet: number[],
      updateSecrets: boolean,
      resultTracker: {
          fulfilledCount: number;
          rejectedCount: number;
          skippedCount: number;
      },
      contexts: string[],
  ): Promise<
      { fulfilledCount: number; rejectedCount: number; skippedCount: number },
  >

  updates a set of special accounts keys with a newly generated key and stores them in a Kubernetes secret

  Parameters

  • namespace: NamespaceName

    the namespace of the nodes network
  • currentSet: number[]

    the accounts to update
  • updateSecrets: boolean

    whether to delete the secret prior to creating a new secret
  • resultTracker: { fulfilledCount: number; rejectedCount: number; skippedCount: number }

    an object to keep track of the results from the accounts that are being updated
  • contexts: string[]

  Returns Promise<{ fulfilledCount: number; rejectedCount: number; skippedCount: number }>

  the updated resultTracker object