@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/src/utils/autorest.ts

@@ -1,5 +1,5 @@
-import { RestError, PipelineResponse, PipelinePolicy } from '@azure/core-rest-pipeline';
-import { AdditionalPolicyConfig } from '@azure/core-client';
+import { RestError, PipelineResponse } from '@azure/core-rest-pipeline';
+import { AdditionalPolicyConfig, FullOperationResponse, OperationOptions } from '@azure/core-client';
 import { pause } from './other';
 import semverSatisfies from './semver-satisfies';
 import { UnsupportedVersionError } from './errors';
@@ -16,9 +16,7 @@ export const genRequestQueuesPolicy = (): AdditionalPolicyConfig => {
         const getResponse = async (): Promise<PipelineResponse> => next(request);
         if (key == null) return getResponse();
         const req = (requestQueues.get(key) ?? Promise.resolve()).then(getResponse);
-        // TODO: remove pause after fixing https://github.com/aeternity/aeternity/issues/3803
-        // gap to ensure that node won't reject the nonce
-        requestQueues.set(key, req.then(async () => pause(750), () => {}));
+        requestQueues.set(key, req.catch(() => {}));
         return req;
       },
     },
@@ -76,16 +74,16 @@ export const genErrorFormatterPolicy = (
         return await next(request);
       } catch (error) {
         if (!(error instanceof RestError) || error.request == null) throw error;
-        if (error.response?.bodyAsText == null) throw error;
+        const prefix = `${new URL(error.request.url).pathname.slice(1)} error`;
 
-        let body;
-        try {
-          body = JSON.parse(error.response.bodyAsText);
-        } catch (e) {
+        if (error.response?.bodyAsText == null) {
+          if (error.message === '') error.message = `${prefix}: ${error.code}`;
           throw error;
         }
-        error.message = `${new URL(error.request.url).pathname.slice(1)} error`;
-        const message = getMessage(body);
+
+        const body = (error.response as FullOperationResponse).parsedBody;
+        error.message = prefix;
+        const message = body == null ? ` ${error.response.status} status code` : getMessage(body);
         if (message !== '') error.message += `:${message}`;
         throw error;
       }
@@ -96,20 +94,24 @@ export const genErrorFormatterPolicy = (
 
 export const genVersionCheckPolicy = (
   name: string,
-  ignorePath: string,
-  versionPromise: Promise<string | Error>,
+  versionCb: (options: OperationOptions) => Promise<string>,
   geVersion: string,
   ltVersion: string,
-): PipelinePolicy => ({
-  name: 'version-check',
-  async sendRequest(request, next) {
-    if (new URL(request.url).pathname === ignorePath) return next(request);
-    const version = await versionPromise;
-    if (version instanceof Error) throw version;
-    const args = [version, geVersion, ltVersion] as const;
-    if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args);
-    return next(request);
+): AdditionalPolicyConfig => ({
+  policy: {
+    name: 'version-check',
+    async sendRequest(request, next) {
+      if (request.headers.has('__version-check')) {
+        request.headers.delete('__version-check');
+        return next(request);
+      }
+      const options = { requestOptions: { customHeaders: { '__version-check': 'true' } } };
+      const args = [await versionCb(options), geVersion, ltVersion] as const;
+      if (!semverSatisfies(...args)) throw new UnsupportedVersionError(name, ...args);
+      return next(request);
+    },
   },
+  position: 'perCall',
 });
 
 export const genRetryOnFailurePolicy = (
@@ -119,16 +121,23 @@ export const genRetryOnFailurePolicy = (
   policy: {
     name: 'retry-on-failure',
     async sendRequest(request, next) {
-      const statusesToNotRetry = [200, 400, 403, 500];
+      const retryCode = request.headers.get('__retry-code') ?? NaN;
+      request.headers.delete('__retry-code');
+      const statusesToNotRetry = [200, 400, 403, 410, 500].filter((c) => c !== +retryCode);
 
       const intervals = new Array(retryCount).fill(0)
         .map((_, idx) => ((idx + 1) / retryCount) ** 2);
-      const intervalSum = intervals.reduce((a, b) => a + b);
-      const intervalsInMs = intervals.map((el) => (el / intervalSum) * retryOverallDelay);
+      const intervalSum = intervals.reduce((a, b) => a + b, 0);
+      const intervalsInMs = intervals.map((e) => Math.floor((e / intervalSum) * retryOverallDelay));
 
       let error = new RestError('Not expected to be thrown');
       for (let attempt = 0; attempt <= retryCount; attempt += 1) {
-        if (attempt !== 0) await pause(intervalsInMs[attempt - 1]);
+        if (attempt !== 0) {
+          await pause(intervalsInMs[attempt - 1]);
+          const urlParsed = new URL(request.url);
+          urlParsed.searchParams.set('__sdk-retry', attempt.toString());
+          request.url = urlParsed.toString();
+        }
         try {
           return await next(request);
         } catch (e) {

package/src/utils/crypto.ts

@@ -4,7 +4,7 @@ import nacl, { SignKeyPair } from 'tweetnacl';
 import { blake2b } from 'blakejs/blake2b.js';
 import { encode as varuintEncode } from 'varuint-bitcoin';
 
-import { concatBuffers } from './other';
+import { concatBuffers, isItemOfArray } from './other';
 import {
   decode, encode, Encoded, Encoding,
 } from './encoder';
@@ -23,22 +23,32 @@ export function getAddressFromPriv(secret: string | Uint8Array): Encoded.Account
 
 /**
  * Check if address is valid
- * @param address - Address
- * @param prefix - Transaction prefix. Default: 'ak'
- * @returns is valid
+ * @param maybeAddress - Address to check
  */
-export function isAddressValid(
-  address: string,
-  prefix: Encoding = Encoding.AccountAddress,
-): boolean {
+export function isAddressValid(maybeAddress: string): maybeAddress is Encoded.AccountAddress;
+/**
+ * Check if data is encoded in one of provided encodings
+ * @param maybeEncoded - Data to check
+ * @param encodings - Rest parameters with encodings to check against
+ */
+export function isAddressValid<E extends Encoding>(
+  maybeEncoded: string,
+  ...encodings: E[]
+): maybeEncoded is Encoded.Generic<E>;
+export function isAddressValid(maybeEncoded: string, ...encodings: Encoding[]): boolean {
+  if (encodings.length === 0) encodings = [Encoding.AccountAddress];
   try {
-    decode(address as Encoded.Generic<typeof prefix>);
-    const actualPrefix = address.split('_')[0];
-    if (actualPrefix !== prefix) {
-      throw new ArgumentError('Encoded string type', prefix, actualPrefix);
+    decode(maybeEncoded as Encoded.Any);
+    const encoding = maybeEncoded.split('_')[0];
+    if (!isItemOfArray(encoding, encodings)) {
+      throw new ArgumentError(
+        'Encoded string type',
+        encodings.length > 1 ? `one of ${encodings.join(', ')}` : encodings[0],
+        encoding,
+      );
     }
     return true;
-  } catch (e) {
+  } catch (error) {
     return false;
   }
 }

package/src/utils/errors.ts

@@ -247,6 +247,16 @@ export class UnsupportedVersionError extends BaseError {
   }
 }
 
+/**
+ * @category exception
+ */
+export class LogicError extends BaseError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'LogicError';
+  }
+}
+
 /**
  * @category exception
  */

package/src/utils/hd-wallet.ts

@@ -71,6 +71,8 @@ type Bip32Path<MaxLen extends number> =
 
 /**
  * @category hd-wallet
+ * @param keyTreeNode - A node of key tree
+ * @param index - index of child node to derive
  */
 export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
   if (index < HARDENED_OFFSET) {

package/src/utils/jwt.ts

@@ -0,0 +1,126 @@
+import canonicalize from 'canonicalize';
+import AccountBase from '../account/Base';
+import {
+  Encoded, Encoding, decode, encode,
+} from './encoder';
+import { verify } from './crypto';
+import { ArgumentError, InvalidSignatureError } from './errors';
+
+// TODO: use Buffer.from(data, 'base64url') after solving https://github.com/feross/buffer/issues/309
+const toBase64Url = (data: Buffer | Uint8Array | string): string => Buffer
+  .from(data)
+  .toString('base64')
+  .replaceAll('/', '_')
+  .replaceAll('+', '-')
+  .replace(/=+$/, '');
+
+const fromBase64Url = (data: string): Buffer => Buffer
+  .from(data.replaceAll('_', '/').replaceAll('-', '+'), 'base64');
+
+const objectToBase64Url = (data: any): string => toBase64Url(canonicalize(data) ?? '');
+
+const header = 'eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9'; // objectToBase64Url({ alg: 'EdDSA', typ: 'JWT' })
+
+/**
+ * JWT including specific header
+ * @category JWT
+ */
+export type Jwt = `${typeof header}.${string}.${string}`;
+
+/**
+ * Generate a signed JWT
+ * Provide `"sub_jwk": undefined` in payload to omit signer public key added by default.
+ * @param originalPayload - Payload to sign
+ * @param account - Account to sign by
+ * @category JWT
+ */
+export async function signJwt(originalPayload: any, account: AccountBase): Promise<Jwt> {
+  const payload = { ...originalPayload };
+  if (!('sub_jwk' in payload)) {
+    payload.sub_jwk = {
+      kty: 'OKP',
+      crv: 'Ed25519',
+      x: toBase64Url(decode(account.address)),
+    };
+  }
+  if (payload.sub_jwk === undefined) delete payload.sub_jwk;
+  const body = `${header}.${objectToBase64Url(payload)}` as const;
+  const signature = await account.sign(body);
+  return `${body}.${toBase64Url(signature)}`;
+}
+
+/**
+ * Unpack JWT. It will check signature if address or "sub_jwk" provided.
+ * @param jwt - JWT to unpack
+ * @param address - Address to check signature
+ * @category JWT
+ */
+export function unpackJwt(jwt: Jwt, address?: Encoded.AccountAddress): {
+  /**
+   * JWT payload as object
+   */
+  payload: any;
+  /**
+   * Undefined returned in case signature is not checked
+   */
+  signer: Encoded.AccountAddress | undefined;
+} {
+  const components = jwt.split('.');
+  if (components.length !== 3) throw new ArgumentError('JWT components count', 3, components.length);
+  const [h, payloadEncoded, signature] = components;
+  if (h !== header) throw new ArgumentError('JWT header', header, h);
+  const payload = JSON.parse(fromBase64Url(payloadEncoded).toString());
+  const jwk = payload.sub_jwk ?? {};
+  const signer = jwk.x == null || jwk.kty !== 'OKP' || jwk.crv !== 'Ed25519'
+    ? address
+    : encode(fromBase64Url(jwk.x), Encoding.AccountAddress);
+  if (address != null && signer !== address) {
+    throw new ArgumentError('address', `${signer} ("sub_jwk")`, address);
+  }
+  if (
+    signer != null
+    && !verify(Buffer.from(`${h}.${payloadEncoded}`), fromBase64Url(signature), signer)
+  ) {
+    throw new InvalidSignatureError(`JWT is not signed by ${signer}`);
+  }
+  return { payload, signer };
+}
+
+/**
+ * Check is string a JWT or not. Use to validate the user input.
+ * @param maybeJwt - A string to check
+ * @returns True if argument is a JWT
+ * @category JWT
+ */
+export function isJwt(maybeJwt: string): maybeJwt is Jwt {
+  try {
+    unpackJwt(maybeJwt as Jwt);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Throws an error if argument is not JWT. Use to ensure that a value is JWT.
+ * @param maybeJwt - A string to check
+ * @category JWT
+ */
+export function ensureJwt(maybeJwt: string): asserts maybeJwt is Jwt {
+  unpackJwt(maybeJwt as Jwt);
+}
+
+/**
+ * Check is JWT signed by address from arguments or "sub_jwk"
+ * @param jwt - JWT to check
+ * @param address - Address to check signature
+ * @category JWT
+ */
+export function verifyJwt(jwt: Jwt, address?: Encoded.AccountAddress): boolean {
+  try {
+    const { signer } = unpackJwt(jwt, address);
+    return signer != null;
+  } catch (error) {
+    return false;
+  }
+}

package/src/utils/keystore.ts

@@ -45,7 +45,13 @@ export interface Keystore {
     cipher_params: {
       nonce: string;
     };
+    /**
+     * Key derivation function name.
+     */
     kdf: keyof typeof DERIVED_KEY_FUNCTIONS;
+    /**
+     * Key derivation function parameters.
+     */
     kdf_params: {
       memlimit_kib: number;
       opslimit: number;
@@ -149,8 +155,6 @@ export async function recover(
  * @param nonce - Randomly generated 24byte nonce.
  * @param salt - Randomly generated 16byte salt.
  * @param options - Encryption parameters.
- * @param options.kdf - Key derivation function.
- * @param options.kdf_params - KDF parameters.
  */
 export async function dump(
   name: string,

package/src/utils/wrap-proxy.ts

@@ -0,0 +1,24 @@
+import { ArgumentError } from './errors';
+
+export function wrapWithProxy<Value extends object | undefined>(
+  valueCb: () => Value,
+): NonNullable<Value> {
+  return new Proxy(
+    {},
+    Object.fromEntries(([
+      'apply', 'construct', 'defineProperty', 'deleteProperty', 'getOwnPropertyDescriptor',
+      'getPrototypeOf', 'isExtensible', 'ownKeys', 'preventExtensions', 'set', 'setPrototypeOf',
+      'get', 'has',
+    ] as const).map((name) => [name, (t: {}, ...args: unknown[]) => {
+      const target = valueCb();
+      if (target == null) throw new ArgumentError('wrapped value', 'defined', target);
+      if (name === 'get' && args[0] === '_wrappedValue') return target;
+      const res = (Reflect[name] as any)(target, ...args);
+      return typeof res === 'function' && name === 'get' ? res.bind(target) : res;
+    }])),
+  ) as NonNullable<Value>;
+}
+
+export function unwrapProxy<Value extends object>(value: Value): Value {
+  return (value as { _wrappedValue?: Value })._wrappedValue ?? value;
+}

package/types-legacy/ts4.2/AeSdk.d.ts

@@ -7,6 +7,9 @@ export default class AeSdk extends AeSdkBase {
         [key: string]: AccountBase;
     };
     selectedAddress?: Encoded.AccountAddress;
+    /**
+     * @param options - Options
+     */
     constructor({ accounts, ...options }?: {
         accounts?: AccountBase[];
     } & ConstructorParameters<typeof AeSdkBase>[0]);

package/types-legacy/ts4.2/AeSdkAepp.d.ts

@@ -39,7 +39,6 @@ export default class AeSdkAepp extends AeSdkBase {
      * @param options - Options
      * @param options.connectNode - Request wallet to bind node
      * @param options.name - Node name
-     * @param options.select - Select this node as current
      */
     connectToWallet(connection: BrowserConnection, { connectNode, name }?: {
         connectNode?: boolean;

package/types-legacy/ts4.2/AeSdkBase.d.ts

@@ -2,7 +2,7 @@ import Node from './Node';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
 import CompilerBase from './contract/compiler/Base';
-import AeSdkMethods, { OnAccount, AeSdkMethodsOptions } from './AeSdkMethods';
+import AeSdkMethods, { OnAccount, AeSdkMethodsOptions, WrappedOptions } from './AeSdkMethods';
 import { AensName } from './tx/builder/constants';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
@@ -14,6 +14,7 @@ type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
  * - wrappers of account methods mapped to the current account.
  */
 export default class AeSdkBase extends AeSdkMethods {
+    #private;
     pool: Map<string, Node>;
     selectedNodeName?: string;
     /**
@@ -79,31 +80,85 @@ export default class AeSdkBase extends AeSdkMethods {
      */
     _resolveAccount(account?: OnAccount): AccountBase;
     get address(): Encoded.AccountAddress;
+    /**
+     * Sign data blob
+     * @param data - Data to sign
+     * @param options - Options
+     */
     sign(data: string | Uint8Array, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     }): Promise<Uint8Array>;
+    /**
+     * Sign encoded transaction
+     * @param tx - Transaction to sign
+     * @param options - Options
+     */
     signTransaction(tx: Encoded.Transaction, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    /**
+     * Sign message
+     * @param message - Message to sign
+     * @param options - Options
+     */
     signMessage(message: string, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signMessage']>[1]): Promise<Uint8Array>;
+    /**
+     * Sign typed data
+     * @param data - Encoded data to sign
+     * @param aci - Type of data to sign
+     * @param options - Options
+     */
     signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
+    /**
+     * @deprecated use AeSdkBase:signDelegation in Ceres
+     * @param contractAddress - Contract address
+     * @param options - Options
+     */
     signDelegationToContract(contractAddress: Encoded.ContractAddress, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signDelegationToContract']>[1]): Promise<Encoded.Signature>;
+    /**
+     * @deprecated use AeSdkBase:signDelegation in Ceres
+     * @param contractAddress - Contract address
+     * @param name - AENS name
+     * @param options - Options
+     */
     signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signNameDelegationToContract']>[2]): Promise<Encoded.Signature>;
+    /**
+     * @deprecated use AeSdkBase:signDelegation in Ceres
+     * @param contractAddress - Contract address
+     * @param options - Options
+     */
+    signAllNamesDelegationToContract(contractAddress: Encoded.ContractAddress, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signAllNamesDelegationToContract']>[1]): Promise<Encoded.Signature>;
+    /**
+     * @deprecated use AeSdkBase:signDelegation in Ceres
+     * @param contractAddress - Contract address
+     * @param oracleQueryId - Oracle query id
+     * @param options - Options
+     */
     signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signOracleQueryDelegationToContract']>[2]): Promise<Encoded.Signature>;
-    _getOptions(callOptions?: AeSdkMethodsOptions): {
-        onNode: Node;
-        onAccount: AccountBase;
-        onCompiler: CompilerBase;
-    };
+    /**
+     * Sign delegation, works only in Ceres
+     * @param delegation - Delegation to sign
+     * @param options - Options
+     */
+    signDelegation(delegation: Encoded.Bytearray, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signDelegation']>[1]): Promise<Encoded.Signature>;
+    /**
+     * The same as AeSdkMethods:getContext, but it would resolve ak_-prefixed address in
+     * `mergeWith.onAccount` to AccountBase.
+     */
+    getContext(mergeWith?: AeSdkMethodsOptions): AeSdkMethodsOptions & WrappedOptions;
 }
 export {};

package/types-legacy/ts4.2/AeSdkMethods.d.ts

@@ -1,4 +1,5 @@
 import * as chainMethods from './chain';
+import { sendTransaction } from './send-transaction';
 import * as aensMethods from './aens';
 import * as spendMethods from './spend';
 import * as oracleMethods from './oracle';
@@ -12,7 +13,6 @@ import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
 import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
-export declare function getValueOrErrorProxy<Value extends object | undefined>(valueCb: () => Value): NonNullable<Value>;
 declare const methods: {
     readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
     readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
@@ -36,12 +36,12 @@ declare const methods: {
     readonly aensClaim: typeof aensMethods.aensClaim;
     readonly aensPreclaim: typeof aensMethods.aensPreclaim;
     readonly aensBid: typeof aensMethods.aensBid;
+    readonly sendTransaction: typeof sendTransaction;
     readonly _getPollInterval: typeof chainMethods._getPollInterval;
     readonly getHeight: typeof chainMethods.getHeight;
     readonly poll: typeof chainMethods.poll;
     readonly awaitHeight: typeof chainMethods.awaitHeight;
     readonly waitForTxConfirm: typeof chainMethods.waitForTxConfirm;
-    readonly sendTransaction: typeof chainMethods.sendTransaction;
     readonly getAccount: typeof chainMethods.getAccount;
     readonly getBalance: typeof chainMethods.getBalance;
     readonly getCurrentGeneration: typeof chainMethods.getCurrentGeneration;
@@ -72,6 +72,11 @@ type GetMethodsOptions<Methods extends {
 type MethodsOptions = GetMethodsOptions<typeof methods>;
 export interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
 }
+export interface WrappedOptions {
+    onAccount: AccountBase;
+    onCompiler: CompilerBase;
+    onNode: Node;
+}
 /**
  * AeSdkMethods is the composition of:
  * - chain methods
@@ -86,16 +91,19 @@ export interface AeSdkMethodsOptions extends Partial<UnionToIntersection<Methods
  * their context (current account, network, and compiler to use).
  */
 declare class AeSdkMethods {
+    #private;
     _options: AeSdkMethodsOptions;
     /**
      * @param options - Options
      */
     constructor(options?: AeSdkMethodsOptions);
-    _getOptions(callOptions?: AeSdkMethodsOptions): AeSdkMethodsOptions & {
-        onAccount: AccountBase;
-        onCompiler: CompilerBase;
-        onNode: Node;
-    };
+    /**
+     * Returns sdk instance options with references to current account, node, compiler.
+     * Used to create an instance (Contract, Oracle) bound to AeSdk state.
+     * @param mergeWith - Merge context with these extra options
+     * @returns Context object
+     */
+    getContext(mergeWith?: AeSdkMethodsOptions): AeSdkMethodsOptions & WrappedOptions;
     buildTx(options: TxParamsAsync): Promise<Encoded.Transaction>;
     initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
         onNode?: Node;
@@ -111,6 +119,10 @@ type OptionalIfNotRequired<T extends [
 type ReplaceOnAccount<Options> = Options extends {
     onAccount: any;
 } ? Omit<Options, 'onAccount'> & {
+    /**
+     * Make operation on specific account by providing address (to use account from sdk) or instance
+     * of AccountBase (like MemoryAccount)
+     */
     onAccount: OnAccount;
 } : Options;
 type MakeOptional<Options> = OptionalIfNotRequired<[

package/types-legacy/ts4.2/Node.d.ts

@@ -1,3 +1,4 @@
+import { OperationOptions } from '@azure/core-client';
 import { Node as NodeApi, NodeOptionalParams } from './apis/node';
 import { Encoded } from './utils/encoder';
 import { ConsensusProtocolVersion } from './tx/builder/constants';
@@ -14,6 +15,7 @@ declare const bigIntPropertyNames: readonly [
     "initiatorAmountFinal",
     "responderAmountFinal",
     "gasPrice",
+    "minGasPrice",
     "deposit"
 ];
 declare const numberPropertyNames: readonly [
@@ -36,7 +38,11 @@ declare const numberPropertyNames: readonly [
     "effectiveAtHeight",
     "version",
     "solutions",
-    "round"
+    "round",
+    "minutes",
+    "utilization",
+    "difficulty",
+    "hashrate"
 ];
 type BigIntPropertyNames = typeof bigIntPropertyNames[number];
 type NumberPropertyNames = typeof numberPropertyNames[number];
@@ -76,6 +82,13 @@ export default class Node extends Node_base {
         retryCount?: number;
         retryOverallDelay?: number;
     });
+    _getCachedStatus(options?: OperationOptions): ReturnType<Node['getStatus']>;
+    /** @ts-expect-error use code generation to create node class? */
+    getStatus(...args: Parameters<InstanceType<NodeTransformedApi>['getStatus']>): ReturnType<InstanceType<NodeTransformedApi>['getStatus']>;
+    /**
+     * Returns network ID provided by node.
+     * This method won't do extra requests on subsequent calls.
+     */
     getNetworkId(): Promise<string>;
     getNodeInfo(): Promise<NodeInfo>;
 }