@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/src/tx/index.ts

@@ -0,0 +1,192 @@
+/*
+ * 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.
+ */
+
+/**
+ * Transaction methods
+ *
+ * This is implementation of [Tx](api/tx.md) relays
+ * the creation of transactions to {@link Node}.
+ * These methods provide ability to create native transactions.
+ */
+import BigNumber from 'bignumber.js';
+import {
+  ABI_VERSIONS, CtVersion, PROTOCOL_VM_ABI, TX_TTL, TxParamsCommon,
+} from './builder/schema';
+import { Tag } from './builder/constants';
+import {
+  ArgumentError, UnsupportedProtocolError, UnknownTxError, InvalidTxParamsError,
+} from '../utils/errors';
+import Node from '../Node';
+import { Encoded } from '../utils/encoder';
+import { buildTx as syncBuildTx, unpackTx } from './builder/index';
+import { isKeyOfObject } from '../utils/other';
+import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter';
+
+type Int = number | string | BigNumber;
+
+export type BuildTxOptions <TxType extends Tag, OmitFields extends string> =
+  Omit<Parameters<typeof _buildTx<TxType>>[1], OmitFields>;
+
+/**
+ * Validated vm/abi version or get default based on transaction type and NODE version
+ * @category transaction builder
+ * @param txType - Type of transaction
+ * @param ctVersion - Object with vm and abi version fields
+ * @returns Object with vm/abi version
+ */
+export async function getVmVersion(
+  txType: Tag.ContractCreateTx, ctVersion: Partial<CtVersion> & { onNode: Node }
+): Promise<CtVersion>;
+export async function getVmVersion(
+  txType: Tag, ctVersion: Partial<Pick<CtVersion, 'abiVersion'>> & { onNode: Node }
+): Promise<Pick<CtVersion, 'abiVersion'>>;
+export async function getVmVersion(
+  txType: Tag,
+  { vmVersion, abiVersion, onNode }: Partial<CtVersion> & { onNode: Node },
+): Promise<Partial<CtVersion>> {
+  const { consensusProtocolVersion } = await onNode.getNodeInfo();
+  if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
+    throw new UnsupportedProtocolError('Not supported consensus protocol version');
+  }
+  const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
+  if (!isKeyOfObject(txType, supportedProtocol)) {
+    throw new UnknownTxError('Not supported tx type');
+  }
+  const protocolForTX = supportedProtocol[txType];
+  abiVersion ??= protocolForTX.abiVersion[0];
+  vmVersion ??= protocolForTX.vmVersion[0];
+  return { vmVersion, abiVersion };
+}
+
+/**
+ * Calculate fee, get absolute ttl (ttl + height), get account nonce
+ * @category transaction builder
+ * @param txType - Type of transaction
+ * @param params - Object which contains all tx data
+ * @returns Object with account nonce, absolute ttl and transaction fee
+ */
+export async function prepareTxParams(
+  txType: Tag,
+  {
+    senderId,
+    nonce,
+    ttl = TX_TTL,
+    absoluteTtl,
+    strategy,
+    onNode,
+  }: PrepareTxParamsOptions,
+): Promise<{ ttl: number; nonce: number }> {
+  nonce ??= (
+    await onNode.getAccountNextNonce(senderId, { strategy }).catch(() => ({ nextNonce: 1 }))
+  ).nextNonce;
+
+  if (ttl !== 0) {
+    if (ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', ttl);
+    ttl += absoluteTtl === true ? 0 : (await onNode.getCurrentKeyBlock()).height;
+  }
+
+  return { ttl, nonce };
+}
+
+interface PrepareTxParamsOptions extends Pick<TxParamsCommon, 'nonce' | 'ttl'> {
+  senderId: Encoded.AccountAddress;
+  absoluteTtl?: boolean;
+  strategy?: 'continuity' | 'max';
+  onNode: Node;
+}
+
+// TODO: find a better name or rearrange methods
+/**
+ * @category transaction builder
+ */
+export async function _buildTx<TxType extends Tag>(
+  txType: TxType,
+  { denomination, absoluteTtl, ..._params }:
+  Omit<Parameters<typeof syncBuildTx<TxType, 'tx'>>[0], 'fee' | 'nonce' | 'ttl' | 'ctVersion' | 'abiVersion'>
+  & {
+    onNode: Node;
+    fee?: Int;
+    nonce?: number;
+    ttl?: number;
+    denomination?: AE_AMOUNT_FORMATS;
+    absoluteTtl?: boolean;
+  }
+  & (TxType extends Tag.OracleExtendTx | Tag.OracleResponseTx
+    ? { callerId: Encoded.AccountAddress } : {})
+  & (TxType extends Tag.ContractCreateTx | Tag.GaAttachTx ? { ctVersion?: CtVersion } : {})
+  & (TxType extends Tag.ContractCallTx | Tag.OracleRegisterTx
+    ? { abiVersion?: ABI_VERSIONS } : {}),
+): Promise<Encoded.Transaction> {
+  // TODO: avoid this assertion
+  const params = _params as unknown as TxParamsCommon & { onNode: Node };
+  let senderKey: keyof TxParamsCommon | '<absent>';
+  switch (txType) {
+    case Tag.SpendTx:
+    case Tag.OracleQueryTx:
+      senderKey = 'senderId';
+      break;
+    case Tag.NameClaimTx:
+    case Tag.NameUpdateTx:
+    case Tag.NameRevokeTx:
+    case Tag.NameTransferTx:
+    case Tag.NamePreclaimTx:
+    case Tag.OracleRegisterTx:
+      senderKey = 'accountId';
+      break;
+    case Tag.ContractCreateTx:
+    case Tag.GaAttachTx:
+      senderKey = 'ownerId';
+      break;
+    case Tag.ContractCallTx:
+    case Tag.OracleExtendTx:
+    case Tag.OracleResponseTx:
+      senderKey = 'callerId';
+      break;
+    case Tag.ChannelCloseSoloTx:
+    case Tag.ChannelSlashTx:
+    case Tag.ChannelSettleTx:
+    case Tag.ChannelSnapshotSoloTx:
+      senderKey = 'fromId';
+      break;
+    case Tag.PayingForTx:
+      senderKey = 'payerId';
+      break;
+    default:
+      throw new ArgumentError('txType', 'valid transaction type', txType);
+  }
+  // TODO: move specific cases to field-types
+  if ([Tag.ContractCreateTx, Tag.GaAttachTx].includes(txType)) {
+    params.ctVersion = await getVmVersion(
+      Tag.ContractCreateTx,
+      { ...params, ...params.ctVersion },
+    );
+  }
+  if (txType === Tag.ContractCallTx) {
+    params.abiVersion = (await getVmVersion(Tag.ContractCallTx, params)).abiVersion;
+  }
+  if (txType === Tag.OracleRegisterTx) {
+    params.abiVersion ??= ABI_VERSIONS.NO_ABI;
+  }
+  if (txType === Tag.PayingForTx) {
+    params.tx = unpackTx(params.tx);
+  }
+  const senderId = params[senderKey];
+  // TODO: do this check on TypeScript level
+  if (senderId == null) throw new InvalidTxParamsError(`Transaction field ${senderKey} is missed`);
+  const extraParams = await prepareTxParams(txType, { ...params, senderId, absoluteTtl });
+  return syncBuildTx({ ...params, ...extraParams } as any, txType, { denomination }).tx;
+}

package/src/tx/validator.ts

@@ -0,0 +1,230 @@
+import BigNumber from 'bignumber.js';
+import { hash, verify } from '../utils/crypto';
+import {
+  CtVersion,
+  PROTOCOL_VM_ABI,
+  RawTxObject,
+  TxParamsCommon,
+  TxSchema,
+  TxTypeSchemas,
+} from './builder/schema';
+import { Tag } from './builder/constants';
+import { TxUnpacked, unpackTx } from './builder';
+import { UnsupportedProtocolError } from '../utils/errors';
+import { concatBuffers, isKeyOfObject } from '../utils/other';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../utils/encoder';
+import Node from '../Node';
+
+interface Account {
+  balance: bigint;
+  id: Encoded.AccountAddress;
+  nonce: number;
+}
+
+export interface ValidatorResult {
+  message: string;
+  key: string;
+  checkedKeys: string[];
+}
+
+type Validator = (
+  tx: {
+    encodedTx: TxUnpacked<TxSchema>;
+    signatures: Buffer[];
+    tx: TxUnpacked<TxSchema> & {
+      tx: TxTypeSchemas[Tag.SignedTx];
+    };
+    nonce?: number;
+    ttl?: number;
+    amount?: number;
+    fee?: number;
+    nameFee?: number;
+    ctVersion?: Partial<CtVersion>;
+    abiVersion?: number;
+    contractId?: Encoded.ContractAddress;
+  },
+  options: {
+    account?: Account;
+    nodeNetworkId: string;
+    parentTxTypes: Tag[];
+    node: Node;
+    txType: Tag;
+    height: number;
+    consensusProtocolVersion: number;
+  }
+) => ValidatorResult[] | Promise<ValidatorResult[]>;
+
+const validators: Validator[] = [];
+
+const getSenderAddress = (
+  tx: TxParamsCommon | RawTxObject<TxSchema>,
+): Encoded.AccountAddress | undefined => [
+  'senderId', 'accountId', 'ownerId', 'callerId',
+  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId',
+]
+  .map((key: keyof TxSchema) => tx[key])
+  .filter((a) => a)
+  .map((a) => a?.toString().replace(/^ok_/, 'ak_'))[0] as Encoded.AccountAddress | undefined;
+
+/**
+ * Transaction Validator
+ * This function validates some of transaction properties,
+ * to make sure it can be posted it to the chain
+ * @category transaction builder
+ * @param transaction - Base64Check-encoded transaction
+ * @param node - Node to validate transaction against
+ * @param parentTxTypes - Types of parent transactions
+ * @returns Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
+ */
+export default async function verifyTransaction(
+  transaction: Encoded.Transaction | Encoded.Poi,
+  node: Node,
+  parentTxTypes: Tag[] = [],
+): Promise<ValidatorResult[]> {
+  const { tx, txType } = unpackTx<Tag.SignedTx>(transaction);
+  const address = getSenderAddress(tx)
+    ?? (txType === Tag.SignedTx ? getSenderAddress(tx.encodedTx.tx) : undefined);
+  const [account, { height }, { consensusProtocolVersion, nodeNetworkId }] = await Promise.all([
+    address == null
+      ? undefined
+      : node.getAccountByPubkey(address)
+        .catch(() => ({ id: address, balance: 0n, nonce: 0 }))
+        // TODO: remove after fixing https://github.com/aeternity/aepp-sdk-js/issues/1537
+        .then((acc) => ({ ...acc, id: acc.id as Encoded.AccountAddress })),
+    node.getCurrentKeyBlockHeight(),
+    node.getNodeInfo(),
+  ]);
+
+  return (await Promise.all(
+    validators.map((v) => v(
+      tx as any,
+      {
+        txType, node, account, height, consensusProtocolVersion, nodeNetworkId, parentTxTypes,
+      },
+    )),
+  )).flat();
+}
+
+validators.push(
+  ({ encodedTx, signatures }, { account, nodeNetworkId, parentTxTypes }) => {
+    if ((encodedTx ?? signatures) === undefined) return [];
+    if (account == null) return [];
+    if (signatures.length !== 1) return []; // TODO: Support multisignature?
+    const prefix = Buffer.from([
+      nodeNetworkId,
+      ...parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [],
+    ].join('-'));
+    const txWithNetworkId = concatBuffers([prefix, encodedTx.rlpEncoded]);
+    const txHashWithNetworkId = concatBuffers([prefix, hash(encodedTx.rlpEncoded)]);
+    const decodedPub = decode(account.id);
+    if (verify(txWithNetworkId, signatures[0], decodedPub)
+      || verify(txHashWithNetworkId, signatures[0], decodedPub)) return [];
+    return [{
+      message: 'Signature cannot be verified, please ensure that you transaction have'
+        + ' the correct prefix and the correct private key for the sender address',
+      key: 'InvalidSignature',
+      checkedKeys: ['encodedTx', 'signatures'],
+    }];
+  },
+  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
+    if ((encodedTx ?? tx) === undefined) return [];
+    return verifyTransaction(
+      encode((encodedTx ?? tx).rlpEncoded, Encoding.Transaction),
+      node,
+      [...parentTxTypes, txType],
+    );
+  },
+  ({ ttl }, { height }) => {
+    if (ttl === undefined) return [];
+    ttl = +ttl;
+    if (ttl === 0 || ttl >= height) return [];
+    return [{
+      message: `TTL ${ttl} is already expired, current height is ${height}`,
+      key: 'ExpiredTTL',
+      checkedKeys: ['ttl'],
+    }];
+  },
+  ({
+    amount, fee, nameFee, tx,
+  }, { account, parentTxTypes, txType }) => {
+    if (account == null) return [];
+    if ((amount ?? fee ?? nameFee) === undefined) return [];
+    fee ??= 0;
+    const cost = new BigNumber(fee).plus(nameFee ?? 0).plus(amount ?? 0)
+      .plus(txType === Tag.PayingForTx ? (tx.tx.encodedTx.tx).fee : 0)
+      .minus(parentTxTypes.includes(Tag.PayingForTx) ? fee : 0);
+    if (cost.lte(account.balance.toString())) return [];
+    return [{
+      message: `Account balance ${account.balance.toString()} is not enough to execute the transaction that costs ${cost.toFixed()}`,
+      key: 'InsufficientBalance',
+      checkedKeys: ['amount', 'fee', 'nameFee'],
+    }];
+  },
+  ({ nonce }, { account, parentTxTypes }) => {
+    if (nonce == null || account == null || parentTxTypes.includes(Tag.GaMetaTx)) return [];
+    nonce = +nonce;
+    const validNonce = account.nonce + 1;
+    if (nonce === validNonce) return [];
+    return [{
+      ...nonce < validNonce
+        ? {
+          message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
+          key: 'NonceAlreadyUsed',
+        }
+        : {
+          message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
+          key: 'NonceHigh',
+        },
+      checkedKeys: ['nonce'],
+    }];
+  },
+  ({ ctVersion, abiVersion }, { txType, consensusProtocolVersion }) => {
+    if (!isKeyOfObject(consensusProtocolVersion, PROTOCOL_VM_ABI)) {
+      throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`);
+    }
+    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion];
+
+    // If not contract create tx
+    if (ctVersion == null) ctVersion = { abiVersion };
+    const txProtocol = protocol[txType as keyof typeof protocol];
+    if (txProtocol == null) return [];
+    if (Object.entries(ctVersion).some(
+      ([
+        key,
+        value,
+      ]: [
+        key:keyof typeof txProtocol,
+        value:any]) => !(txProtocol[key].includes(+value as never)),
+    )) {
+      return [{
+        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
+        key: 'VmAndAbiVersionMismatch',
+        checkedKeys: ['ctVersion', 'abiVersion'],
+      }];
+    }
+    return [];
+  },
+  async ({ contractId }, { txType, node }) => {
+    if (Tag.ContractCallTx !== txType) return [];
+    contractId = contractId as Encoded.ContractAddress;
+    try {
+      const { active } = await node.getContract(contractId);
+      if (active) return [];
+      return [{
+        message: `Contract ${contractId} is not active`,
+        key: 'ContractNotActive',
+        checkedKeys: ['contractId'],
+      }];
+    } catch (error) {
+      if (error.response?.parsedBody?.reason == null) throw error;
+      return [{
+        message: error.response.parsedBody.reason,
+        key: 'ContractNotFound',
+        checkedKeys: ['contractId'],
+      }];
+    }
+  },
+);

package/src/typings/@aeternity__argon2-browser/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@aeternity/argon2-browser/dist/argon2-bundled.min.js' {
+  export * from 'argon2-browser';
+}

package/src/typings/@aeternity__uuid/index.d.ts

@@ -0,0 +1,5 @@
+declare module '@aeternity/uuid' {
+  // Already depends on @types/uuid
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  export * from 'uuid';
+}

package/src/typings/bip32-path/index.d.ts

@@ -0,0 +1,33 @@
+// TODO: remove after solving https://github.com/axic/bip32-path/issues/5
+
+declare module 'bip32-path' {
+  interface BipPath {
+    toPathArray: () => number[];
+    /**
+     * returns a text encoded path. Set to noRoot to true to omit the m/ prefix.
+     * Set oldStyle true to use h instead of ' for marking hardened nodes.
+     */
+    toString: (noRoot: boolean, oldStyle: boolean) => string;
+
+    /**
+     * returns true if the input is a valid path string
+     */
+    validateString: (path: string) => boolean;
+
+    /**
+     * returns true if the input is a valid binary path array
+     */
+    validatePathArray: (path: string) => boolean;
+  }
+
+  /**
+   * creates an instance from a path written as text.
+   * Set reqRoot to true if the m/ prefix is mandatory.
+   */
+  export const fromString: (text: string, reqRoot?: boolean) => BipPath;
+
+  /**
+   * creates an instance from a binary path array
+   */
+  export const fromPathArray: (path: string) => BipPath;
+}

package/src/typings/blakejs/index.d.ts

@@ -1,33 +1,5 @@
-declare module 'blakejs' {
-  interface Context {
-    b: Uint8Array
-    h: Uint32Array
-    t: number
-    c: number
-    outlen: number
-  }
-
-  export type Data = Buffer | Uint8Array | string
-
-  type Key = Uint8Array | null
-
-  export const blake2b: (data: Data, key?: Key, outlen?: number) => Uint8Array
-
-  export const blake2bFinal: (context: Context) => Uint8Array
-
-  export const blake2bHex: (data: Data, key?: Key, outlen?: number) => string
-
-  export const blake2bInit: (outlen?: number, key?: Key) => Context
-
-  export const blake2bUpdate: (context: Context, data: Data) => void
-
-  export const blake2s: (data: Data, key?: Key, outlen?: number) => Uint8Array
-
-  export const blake2sFinal: (context: Context) => Uint8Array
-
-  export const blake2sHex: (data: Data, key?: Key, outlen?: number) => string
-
-  export const blake2sInit: (outlen?: number, key?: Key) => Context
-
-  export const blake2sUpdate: (context: Context, data: Data) => void
+declare module 'blakejs/blake2b.js' {
+  export {
+    Blake2bCTX, blake2bInit, blake2bUpdate, blake2bFinal, blake2b, blake2bHex,
+  } from 'blakejs';
 }

package/src/typings/sha-js/index.d.ts

@@ -0,0 +1,5 @@
+declare module 'sha.js/sha256.js' {
+  import { sha256 } from 'sha.js';
+
+  export default sha256;
+}

package/src/typings/tweetnacl-auth/index.d.ts

@@ -0,0 +1,14 @@
+// TODO: remove after solving https://github.com/dchest/tweetnacl-auth-js/issues/3
+
+declare module 'tweetnacl-auth' {
+  /**
+   * Authenticates the given message with the secret key.
+   * (In other words, returns HMAC-SHA-512-256 of the message under the key.)
+   */
+  export default function (message: Uint8Array, key: Uint8Array): Uint8Array;
+
+  /**
+   * Returns HMAC-SHA-512 (without truncation) of the message under the key
+   */
+  export const full: (message: Uint8Array, key: Uint8Array) => Uint8Array;
+}