@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/src/Node.ts

@@ -0,0 +1,173 @@
+// eslint-disable-next-line max-classes-per-file
+import BigNumber from 'bignumber.js';
+import { OperationArguments, OperationSpec } from '@azure/core-client';
+import {
+  genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
+  genVersionCheckPolicy,
+} from './utils/autorest';
+import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node';
+import { mapObject } from './utils/other';
+import { Encoded } from './utils/encoder';
+import { MissingParamError } from './utils/errors';
+
+/**
+ * Obtain networkId from account or node
+ */
+export async function getNetworkId({ networkId }: { networkId?: string } = {}): Promise<string> {
+  const res = networkId ?? this.networkId ?? (await this.api?.getStatus())?.networkId;
+  if (res != null) return res;
+  throw new MissingParamError('networkId is not provided');
+}
+
+const bigIntPropertyNames = [
+  'balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount',
+  'initiatorAmount', 'responderAmount', 'channelReserve', 'initiatorAmountFinal',
+  'responderAmountFinal', 'gasPrice', 'deposit',
+] as const;
+
+const numberPropertyNames = [
+  'time', 'gas', 'gasUsed', 'nameSalt',
+  'nonce', 'nextNonce', 'height', 'blockHeight', 'top', 'topBlockHeight',
+  'ttl', 'nameTtl', 'clientTtl',
+  'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight',
+  'version', 'solutions', 'round',
+] as const;
+
+class NodeTransformed extends NodeApi {
+  async sendOperationRequest(
+    operationArguments: OperationArguments,
+    operationSpec: OperationSpec,
+  ): Promise<any> {
+    const args = mapObject(
+      operationArguments,
+      ([key, value]) => [key, this.#encodeArg(value)],
+    ) as OperationArguments;
+    return this.#decodeRes(await super.sendOperationRequest(args, operationSpec));
+  }
+
+  #mapData(data: any, transform: {
+    bigInt: (v: any) => any;
+    number: (v: any) => any;
+  }): unknown {
+    if (Array.isArray(data)) return data.map((d) => this.#mapData(d, transform));
+    if (data != null && typeof data === 'object') {
+      return mapObject(data, ([key, value]) => {
+        if (value == null) return [key, value];
+        if (bigIntPropertyNames.some((k) => k === key)) return [key, transform.bigInt(value)];
+        if (numberPropertyNames.some((k) => k === key)) return [key, transform.number(value)];
+        return [key, this.#mapData(value, transform)];
+      });
+    }
+    return data;
+  }
+
+  #encodeArg(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => {
+        if (value instanceof BigNumber) return value.toFixed();
+        return value.toString();
+      },
+      number: (value) => value.toString(),
+    });
+  }
+
+  #decodeRes(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => BigInt(value),
+      number: (value) => +value,
+    });
+  }
+}
+
+type BigIntPropertyNames = typeof bigIntPropertyNames[number];
+type NumberPropertyNames = typeof numberPropertyNames[number];
+type PreserveOptional<NewType, OrigType> =
+  OrigType extends undefined ? NewType | undefined : NewType;
+export type TransformNodeType<Type> =
+  Type extends (...args: infer Args) => infer Ret
+    ? (...args: TransformNodeType<Args>) => TransformNodeType<Ret>
+    : Type extends [infer Item, ...infer Rest]
+      ? [TransformNodeType<Item>, ...TransformNodeType<Rest>]
+      : Type extends Array<infer Item>
+        ? Array<TransformNodeType<Item>>
+        : Type extends Promise<infer T>
+          ? Promise<TransformNodeType<T>>
+          : Type extends { [P in any]: any }
+            ? {
+              [Property in keyof Type]:
+              Property extends BigIntPropertyNames
+                ? PreserveOptional<bigint, Type[Property]>
+                : Property extends NumberPropertyNames
+                  ? PreserveOptional<number, Type[Property]>
+                  : Property extends 'txHash'
+                    ? PreserveOptional<Encoded.TxHash, Type[Property]>
+                    : TransformNodeType<Type[Property]>
+            }
+            : Type;
+type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
+  [Name in keyof InstanceType<typeof NodeApi>]:
+  Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest'
+    ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>
+};
+
+export interface NodeInfo {
+  url: string;
+  nodeNetworkId: string;
+  version: string;
+  consensusProtocolVersion: number;
+}
+
+export default class Node extends (NodeTransformed as unknown as NodeTransformedApi) {
+  url: string;
+
+  /**
+   * @param url - Url for node API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check node version
+   */
+  constructor(
+    url: string,
+    { ignoreVersion = false, ...options }: NodeOptionalParams & { ignoreVersion?: boolean } = {},
+  ) {
+    // eslint-disable-next-line constructor-super
+    super(url, {
+      allowInsecureConnection: true,
+      additionalPolicies: [
+        genRequestQueuesPolicy(),
+        genCombineGetRequestsPolicy(),
+        genErrorFormatterPolicy((body: ErrorModel) => ` ${body.reason}`),
+      ],
+      ...options,
+    });
+    this.url = url;
+    if (!ignoreVersion) {
+      const versionPromise = this.getStatus().then(({ nodeVersion }) => nodeVersion);
+      this.pipeline.addPolicy(
+        genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'),
+      );
+    }
+    this.intAsString = true;
+  }
+
+  async getNodeInfo(): Promise<NodeInfo> {
+    const {
+      nodeVersion: version,
+      networkId: nodeNetworkId,
+      protocols,
+      topBlockHeight,
+    } = await this.getStatus();
+    const consensusProtocolVersion = protocols
+      .filter(({ effectiveAtHeight }) => topBlockHeight >= effectiveAtHeight)
+      .reduce(
+        (acc, p) => (p.effectiveAtHeight > acc.effectiveAtHeight ? p : acc),
+        { effectiveAtHeight: -1, version: 0 },
+      )
+      .version;
+    return {
+      url: this.url,
+      nodeNetworkId,
+      version,
+      consensusProtocolVersion,
+    };
+  }
+}

package/src/account/Base.ts

@@ -0,0 +1,124 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto';
+import { buildTx } from '../tx/builder';
+import { decode, Encoded } from '../utils/encoder';
+import { Tag } from '../tx/builder/constants';
+import { getNetworkId } from '../Node';
+import { concatBuffers } from '../utils/other';
+import type { createMetaTx } from '../contract/ga';
+
+/**
+ * Check is provided object looks like an instance of AccountBase
+ * @param acc - Object to check
+ */
+export const isAccountBase = (acc: AccountBase | any): boolean => (
+  !['sign', 'address', 'signTransaction', 'signMessage'].some((f) => typeof acc[f] !== 'function')
+);
+
+/**
+ * Account is one of the three basic building blocks of an
+ * {@link AeSdk} and provides access to a signing key pair.
+ */
+export default abstract class AccountBase {
+  networkId?: string;
+
+  /**
+   * @param options - Options
+   * @param options.networkId - Using for signing transactions
+   */
+  constructor({ networkId }: { networkId?: string } = {}) {
+    this.networkId ??= networkId;
+  }
+
+  /**
+   * Sign encoded transaction
+   * @param tx - Transaction to sign
+   * @param opt - Options
+   * @param opt.innerTx - Sign as inner transaction for PayingFor
+   * @returns Signed transaction
+   */
+  async signTransaction(
+    tx: Encoded.Transaction,
+    { innerTx, networkId, ...options }: {
+      innerTx?: boolean;
+      networkId?: string;
+      authData?: Parameters<typeof createMetaTx>[1];
+      authFun?: Parameters<typeof createMetaTx>[2];
+    } & Omit<Partial<Parameters<typeof createMetaTx>[3]>, 'onAccount'> = {},
+  ): Promise<Encoded.Transaction> {
+    const prefixes = [await this.getNetworkId({ networkId })];
+    if (innerTx === true) prefixes.push('inner_tx');
+    const rlpBinaryTx = decode(tx);
+    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
+
+    const signatures = [await this.sign(txWithNetworkId, options)];
+    return buildTx({ encodedTx: rlpBinaryTx, signatures }, Tag.SignedTx).tx;
+  }
+
+  /**
+   * Get network Id
+   * @returns Network Id
+   */
+  readonly getNetworkId = getNetworkId;
+
+  /**
+   * Sign message
+   * @param message - Message to sign
+   * @param opt - Options
+   * @returns Signature as hex string of Uint8Array
+   */
+  async signMessage(
+    message: string,
+    { returnHex = false, ...options }: { returnHex?: boolean } = {},
+  ): Promise<string | Uint8Array> {
+    const sig = await this.sign(messageToHash(message), options);
+    return returnHex ? Buffer.from(sig).toString('hex') : sig;
+  }
+
+  /**
+   * Verify message
+   * @param message - Message to verify
+   * @param signature - Signature
+   * @param options - Options
+   */
+  async verifyMessage(
+    message: string,
+    signature: string | Uint8Array,
+    options?: object,
+  ): Promise<boolean> {
+    return verifyMessageCrypto(
+      message,
+      typeof signature === 'string' ? Buffer.from(signature, 'hex') : signature,
+      decode(await this.address(options)),
+    );
+  }
+
+  /**
+   * Sign data blob
+   * @param data - Data blob to sign
+   * @param options - Options
+   * @returns Signed data blob
+   */
+  abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
+
+  /**
+   * Obtain account address
+   * @returns Public account address
+   */
+  abstract address(opt?: object): Promise<Encoded.AccountAddress>;
+}

package/src/account/Memory.ts

@@ -0,0 +1,98 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2018 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import AccountBase from './Base';
+import { sign, isValidKeypair } from '../utils/crypto';
+import { isHex } from '../utils/string';
+import { ArgumentError, InvalidKeypairError, MissingParamError } from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { createMetaTx } from '../contract/ga';
+
+const secrets = new WeakMap();
+
+export interface Keypair {
+  publicKey: Encoded.AccountAddress;
+  secretKey: string | Uint8Array;
+}
+
+/**
+ * In-memory account class
+ */
+export default class AccountMemory extends AccountBase {
+  isGa: boolean;
+
+  /**
+   * @param options - Options
+   * @param options.keypair - Key pair to use
+   * @param options.keypair.publicKey - Public key
+   * @param options.keypair.secretKey - Private key
+   * @param options.gaId - Address of generalized account
+   */
+  constructor(
+    { keypair, gaId, ...options }: { keypair?: Keypair; gaId?: Encoded.AccountAddress }
+    & ConstructorParameters<typeof AccountBase>[0],
+  ) {
+    super(options);
+
+    this.isGa = gaId != null;
+    if (this.isGa && gaId != null) {
+      decode(gaId);
+      secrets.set(this, { publicKey: gaId });
+      return;
+    }
+
+    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required');
+
+    if (
+      !Buffer.isBuffer(keypair.secretKey)
+      && typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)
+    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer');
+    const secretKey = typeof keypair.secretKey === 'string'
+      ? Buffer.from(keypair.secretKey, 'hex')
+      : keypair.secretKey;
+    if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {
+      throw new InvalidKeypairError('Invalid Key Pair');
+    }
+
+    secrets.set(this, {
+      secretKey,
+      publicKey: keypair.publicKey,
+    });
+  }
+
+  async sign(data: string | Uint8Array): Promise<Uint8Array> {
+    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair');
+    return sign(data, secrets.get(this).secretKey);
+  }
+
+  async signTransaction(
+    tx: Encoded.Transaction,
+    options: Parameters<AccountBase['signTransaction']>[1] = {},
+  ): Promise<Encoded.Transaction> {
+    if (!this.isGa || options.innerTx === true) return super.signTransaction(tx, options);
+    const {
+      authData, authFun, onCompiler, onNode,
+    } = options;
+    if (authFun == null || authData == null || onCompiler == null || onNode == null) {
+      throw new ArgumentError('authData, authFun, onCompiler, onNode', 'provided', null);
+    }
+    return createMetaTx(tx, authData, authFun, { onCompiler, onNode, onAccount: this });
+  }
+
+  async address(): Promise<Encoded.AccountAddress> {
+    return secrets.get(this).publicKey;
+  }
+}

package/src/account/Rpc.ts

@@ -0,0 +1,69 @@
+import AccountBase from './Base';
+import { METHODS } from '../aepp-wallet-communication/schema';
+import { NotImplementedError } from '../utils/errors';
+import { Encoded } from '../utils/encoder';
+
+/**
+ * Account provided by wallet
+ * @param params - Params
+ * @param params.rpcClient - RpcClient instance
+ * @param params.address - RPC account address
+ * @returns AccountRpc instance
+ */
+export default class AccountRpc extends AccountBase {
+  _rpcClient: any;
+
+  _address: Encoded.AccountAddress;
+
+  constructor(
+    { rpcClient, address, ...options }: { rpcClient: any; address: Encoded.AccountAddress }
+    & ConstructorParameters<typeof AccountBase>[0],
+  ) {
+    super(options);
+    this._rpcClient = rpcClient;
+    this._address = address;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async sign(): Promise<Uint8Array> {
+    throw new NotImplementedError('RAW signing using wallet');
+  }
+
+  async address(): Promise<Encoded.AccountAddress> {
+    return this._address;
+  }
+
+  /**
+   * @returns Signed transaction
+   */
+  async signTransaction(
+    tx: Encoded.Transaction,
+    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},
+  ): Promise<Encoded.Transaction> {
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');
+    const res = await this._rpcClient.request(METHODS.sign, {
+      onAccount: this._address,
+      tx,
+      returnSigned: true,
+      /**
+       * @deprecated Wallet provided networkId will be used (current network)
+       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
+       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
+       */
+      networkId,
+    });
+    return res.signedTransaction;
+  }
+
+  /**
+   * @returns Signed message
+   */
+  async signMessage(
+    message: string,
+    { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {},
+  ): Promise<string | Uint8Array> {
+    const { signature } = await this._rpcClient
+      .request(METHODS.signMessage, { onAccount: this._address, message });
+    return returnHex ? signature : Buffer.from(signature, 'hex');
+  }
+}