Variable methodsConst

Type declaration

• _getPollInterval: (
      type: "key-block" | "micro-block",
      options: {
          _expectedMineRate?: number;
          _microBlockCycle?: number;
          onNode: Node;
      },
  ) => Promise<number>

• awaitHeight: (
      height: number,
      options: { interval?: number; onNode: Node } & {
          _expectedMineRate?: number;
          _microBlockCycle?: number;
          onNode: Node;
      },
  ) => Promise<number>

• buildAuthTxHash: (
      transaction: `tx_${string}`,
      options: { fee?: Int; gasPrice?: Int; onNode: Node },
  ) => Promise<Buffer>

• buildAuthTxHashByGaMetaTx: (transaction: `tx_${string}`, options: { onNode: Node }) => Promise<Buffer>

• createGeneralizedAccount: (
      authFnName: string,
      args: any[],
      options: CreateGeneralizedAccountOptions,
  ) => Promise<
      Readonly<
          {
              gaContractId: `ct_${string}`;
              owner: `ak_${string}`;
              rawTx: `tx_${string}`;
              transaction: `th_${string}`;
          },
      >,
  >

• getAccount: (
      address: `ct_${string}` | `ak_${string}`,
      options: {
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      },
  ) => Promise<Account>

• getBalance: (
      address: `ct_${string}` | `ok_${string}` | `ak_${string}`,
      options: { format?: AE_AMOUNT_FORMATS } & {
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      },
  ) => Promise<string>

• getContract: (
      contractId: `ct_${string}`,
      options: { onNode: Node },
  ) => Promise<ContractObject>

• getContractByteCode: (contractId: `ct_${string}`, options: { onNode: Node }) => Promise<ByteCode>

• getCurrentGeneration: (options: { onNode: Node }) => Promise<Generation>

• getGeneration: (
      hashOrHeight: number | `kh_${string}`,
      options: { onNode: Node },
  ) => Promise<Generation>

• getHeight: (
      options: { cached?: boolean; onNode: Node } & {
          _expectedMineRate?: number;
          _microBlockCycle?: number;
          onNode: Node;
      },
  ) => Promise<number>

• getKeyBlock: (
      hashOrHeight: number | `kh_${string}`,
      options: { onNode: Node },
  ) => Promise<KeyBlock>

• getMicroBlockHeader: (hash: `mh_${string}`, options: { onNode: Node }) => Promise<MicroBlockHeader>

• getMicroBlockTransactions: (hash: `mh_${string}`, options: { onNode: Node }) => Promise<SignedTx[]>

• getName: (name: `${string}.chain`, options: { onNode: Node }) => Promise<NameEntry>

• payForTransaction: (
      transaction: `tx_${string}`,
      options: PayForTransactionOptions,
  ) => Promise<SendTransactionReturnType>

• poll: (
      th: `th_${string}`,
      options: { blocks?: number; interval?: number; onNode: Node } & {
          _expectedMineRate?: number;
          _microBlockCycle?: number;
          onNode: Node;
      },
  ) => Promise<SignedTx>

• resolveName: <Type extends ContractAddress | AccountAddress>(
      nameOrId: `${string}.chain` | `${Type}_${string}`,
      key: string,
      options: { onNode: Node; resolveByNode?: boolean; verify?: boolean },
  ) => Promise<`nm_${string}` | `${Type}_${string}`>

• sendTransaction: (
      txUnsigned: `tx_${string}`,
      options: SendTransactionOptions,
  ) => Promise<SendTransactionReturnType>

• spend: (
      amount: string | number,
      recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
      options: SpendOptions,
  ) => Promise<SendTransactionReturnType>

• transferFunds: (
      fraction: string | number,
      recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
      options: TransferFundsOptions,
  ) => Promise<SendTransactionReturnType>

• txDryRun: (
      tx: `tx_${string}`,
      accountAddress: `ak_${string}`,
      options: {
          combine?: boolean;
          onNode: Node;
          top?: number | `kh_${string}` | `mh_${string}`;
          txEvents?: boolean;
      },
  ) => Promise<{ txEvents?: Record<string, unknown>[] } & DryRunResult>

• waitForTxConfirm: (
      txHash: `th_${string}`,
      options: { confirm?: number; onNode: Node } & {
          interval?: number;
          onNode: Node;
      } & { _expectedMineRate?: number; _microBlockCycle?: number; onNode: Node },
  ) => Promise<number>