@aeternity/aepp-sdk 13.0.0-alpha.1 → 13.0.0

package/src/tx/builder/field-types/name-fee.ts

@@ -25,7 +25,8 @@ export default {
   serialize(
     value: Int | undefined,
     txFields: { name: AensName } & Parameters<typeof coinAmount['serialize']>[1],
+    parameters: Parameters<typeof coinAmount['serialize']>[2],
   ): Buffer {
-    return coinAmount.serialize.call(this, value, txFields);
+    return coinAmount.serialize.call(this, value, txFields, parameters);
   },
 };

package/src/tx/builder/field-types/nonce.ts

@@ -0,0 +1,40 @@
+import { isAccountNotFoundError } from '../../../utils/other';
+import shortUInt from './short-u-int';
+import Node from '../../../Node';
+import { ArgumentError } from '../../../utils/errors';
+import { NextNonceStrategy } from '../../../apis/node';
+
+export default function genNonceField<SenderKey extends string>(senderKey: SenderKey): {
+  serialize: (value: number) => Buffer;
+  // TODO: (value: number) => Promise<number> | (value: undefined, ...) => Promise<number>
+  prepare: (
+    value: number | undefined,
+    params: {},
+    // TODO: replace `string` with AddressEncodings
+    options: { [key in SenderKey]: string } & { strategy?: NextNonceStrategy; onNode?: Node },
+  ) => Promise<number>;
+  deserialize: (value: Buffer) => number;
+  senderKey: string;
+} {
+  return {
+    ...shortUInt,
+
+    async prepare(value, params, options) {
+      if (value != null) return value;
+      const { onNode, strategy } = options;
+      const senderId = options[senderKey];
+      const requirement = 'provided (or provide `nonce` instead)';
+      if (onNode == null) throw new ArgumentError('onNode', requirement, onNode);
+      if (senderId == null) throw new ArgumentError('senderId', requirement, senderId);
+      return (
+        await onNode.getAccountNextNonce(senderId.replace(/^ok_/, 'ak_'), { strategy })
+          .catch((error) => {
+            if (!isAccountNotFoundError(error)) throw error;
+            return { nextNonce: 1 };
+          })
+      ).nextNonce;
+    },
+
+    senderKey,
+  };
+}

package/src/tx/builder/field-types/short-u-int-const.ts

@@ -1,20 +1,30 @@
 import { ArgumentError } from '../../../utils/errors';
 import shortUInt from './short-u-int';
 
-export default function genShortUIntConstField<Value extends number>(value: Value): {
-  serialize: (value?: Value) => Buffer;
+export default function genShortUIntConstField<
+  Value extends number, Optional extends boolean = false,
+>(constValue: Value, optional?: Optional): {
+  serialize: Optional extends true ? (value?: Value) => Buffer : (value: Value) => Buffer;
   deserialize: (value: Buffer) => Value;
+  constValue: Value;
+  constValueOptional: boolean;
 } {
   return {
-    serialize(val) {
-      if (val != null && val !== value) throw new ArgumentError('ShortUIntConst', value, val);
-      return shortUInt.serialize(value);
+    serialize(value?: Value) {
+      if ((optional !== true || value != null) && value !== constValue) {
+        throw new ArgumentError('ShortUIntConst', constValue, value);
+      }
+      return shortUInt.serialize(constValue);
     },
 
     deserialize(buf) {
-      const val = shortUInt.deserialize(buf);
-      if (val !== value) throw new ArgumentError('ShortUIntConst', value, val);
-      return value;
+      const value = shortUInt.deserialize(buf);
+      if (value !== constValue) throw new ArgumentError('ShortUIntConst', constValue, value);
+      return constValue;
     },
+
+    constValue,
+
+    constValueOptional: optional === true,
   };
 }

package/src/tx/builder/field-types/ttl.ts

@@ -0,0 +1,24 @@
+import shortUInt from './short-u-int';
+import Node from '../../../Node';
+import { ArgumentError } from '../../../utils/errors';
+
+export default {
+  ...shortUInt,
+
+  serialize(value: number | undefined): Buffer {
+    return shortUInt.serialize(value ?? 0);
+  },
+
+  async prepare(
+    value: number | undefined,
+    params: {},
+    // TODO: { absoluteTtl: true } | { absoluteTtl: false, onNode: Node }
+    { onNode, absoluteTtl }: { onNode?: Node; absoluteTtl?: boolean },
+  ) {
+    if (absoluteTtl !== true && value !== 0 && value != null) {
+      if (onNode == null) throw new ArgumentError('onNode', 'provided', onNode);
+      value += (await onNode.getCurrentKeyBlock()).height;
+    }
+    return value;
+  },
+};

package/src/tx/builder/field-types/wrapped.ts

@@ -0,0 +1,32 @@
+import { Tag } from '../constants';
+import { encode, Encoding, decode } from '../../../utils/encoder';
+import type { unpackTx as unpackTxType, buildTx as buildTxType } from '../index';
+
+type TagWrapping = Tag.AccountsMtree | Tag.CallsMtree | Tag.ChannelsMtree | Tag.ContractsMtree
+| Tag.NameserviceMtree | Tag.OraclesMtree;
+
+export default function genWrappedField<T extends TagWrapping>(tag: T): {
+  serialize: (
+    // TODO: replace with `(TxParams & { tag: T })['payload']`,
+    //  but fix TS2502 value is referenced directly or indirectly in its own type annotation
+    value: any, options: { buildTx: typeof buildTxType }
+  ) => Buffer;
+  deserialize: (
+    value: Buffer, options: { unpackTx: typeof unpackTxType },
+    // TODO: replace with `(TxUnpacked & { tag: T })['payload']`,
+    //  TS2577 Return type annotation circularly references itself
+  ) => any;
+  recursiveType: true;
+} {
+  return {
+    serialize(payload, { buildTx }) {
+      return decode(buildTx({ tag, payload }));
+    },
+
+    deserialize(buffer, { unpackTx }) {
+      return unpackTx<TagWrapping>(encode(buffer, Encoding.Transaction), tag).payload;
+    },
+
+    recursiveType: true,
+  };
+}

package/src/tx/builder/index.ts

@@ -1,49 +1,26 @@
-import { decode as rlpDecode, encode as rlpEncode, NestedUint8Array } from 'rlp';
+import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
 import {
   decode, encode, Encoded, Encoding,
 } from '../../utils/encoder';
-import { AE_AMOUNT_FORMATS } from '../../utils/amount-formatter';
 import { hash } from '../../utils/crypto';
 import { BinaryData, Field } from './field-types';
-import {
-  RawTxObject, TX_SCHEMA, TxField, TxSchema, TxTypeSchemas,
-} from './schema';
+import { txSchema } from './schema';
+import { TxUnpacked, TxParams, TxParamsAsync } from './schema.generated';
 import { Tag } from './constants';
 import { buildContractId, readInt } from './helpers';
 import { ArgumentError, DecodeError, SchemaNotFoundError } from '../../utils/errors';
-import { isKeyOfObject } from '../../utils/other';
 
 /**
  * JavaScript-based Transaction builder
  */
 
-/**
- * Unpack binary transaction
- * @category transaction builder
- * @param binary - Array with binary transaction field's
- * @param schema - Transaction schema
- * @returns Object with transaction field's
- */
-function unpackRawTx<Tx extends TxSchema>(
-  binary: Uint8Array | NestedUint8Array,
-  schema: TxField[],
-): RawTxObject<Tx> {
-  if (binary.length !== schema.length) {
-    throw new ArgumentError('Transaction RLP length', schema.length, binary.length);
-  }
-  return schema
-    .reduce<any>(
-    (
-      acc,
-      [name, field],
-      index,
-    ) => {
-      // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      const deserialized = field.deserialize(binary[index] as BinaryData, { unpackTx });
-      return { ...acc, [name]: deserialized };
-    },
-    {},
-  );
+export function getSchema(tag: Tag, version?: number): Array<[string, Field]> {
+  const schemas = txSchema.filter((s) => s.tag.constValue === tag);
+  if (schemas.length === 0) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, 0);
+  version ??= Math.max(...schemas.map((schema) => schema.version.constValue));
+  const schema = schemas.find((s) => s.version.constValue === version);
+  if (schema == null) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, version);
+  return Object.entries(schema);
 }
 
 /**
@@ -51,52 +28,35 @@ function unpackRawTx<Tx extends TxSchema>(
  * @category transaction builder
  * @param params - Object with tx params
  * @param options - options
- * @param options.denomination - Denomination of amounts
  * @param options.prefix - Prefix of transaction
- * @throws {@link InvalidTxParamsError}
- * @returns object
- * @returns object.tx Base64Check transaction hash with 'tx_' prefix
- * @returns object.rlpEncoded rlp encoded transaction
- * @returns object.binary binary transaction
+ * @returns object Base64Check transaction hash with 'tx_' prefix
  */
 export function buildTx<
-  TxType extends Tag,
   E extends Encoding = Encoding.Transaction,
 >(
-  params: { tag: TxType; version?: number } & Omit<TxTypeSchemas[TxType], 'tag' | 'version'>
-  // TODO: get it from gas-limit.ts somehow
-  & (TxType extends Tag.ContractCreateTx | Tag.ContractCallTx
-  | Tag.ChannelOffChainUpdateCallContract | Tag.GaAttachTx | Tag.GaMetaTx
-    ? { gasMax?: number } : {}),
+  params: TxParams,
   {
     prefix,
-    denomination = AE_AMOUNT_FORMATS.AETTOS,
   }: {
     prefix?: E;
-    denomination?: AE_AMOUNT_FORMATS;
   } = {},
 ): Encoded.Generic<E> {
-  const schemas = TX_SCHEMA[params.tag];
-  params.version ??= Math.max(...Object.keys(schemas).map((a) => +a));
-  if (!isKeyOfObject(params.version, schemas)) {
-    throw new SchemaNotFoundError('serialization', Tag[params.tag], params.version);
-  }
-  const schema = schemas[params.version] as unknown as TxField[];
+  const schema = getSchema(params.tag, params.version);
 
-  const binary = schema.map(([key, field]: [keyof TxSchema, Field]) => (
+  const binary = schema.map(([key, field]) => (
     field.serialize(
+      // @ts-expect-error the type of `params[key]` can't be determined accurately
       params[key],
       {
         ...params,
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         unpackTx,
         buildTx,
-        denomination,
         rebuildTx: (overrideParams: any) => buildTx(
           { ...params, ...overrideParams },
-          { denomination },
         ),
       },
+      params,
     )
   ));
 
@@ -104,27 +64,53 @@ export function buildTx<
   return encode(rlpEncode(binary), prefix ?? Encoding.Transaction);
 }
 
+export type BuildTxOptions <TxType extends Tag, OmitFields extends string> =
+  Omit<TxParamsAsync & { tag: TxType }, 'tag' | OmitFields>;
+
+/**
+ * @category transaction builder
+ */
+export async function buildTxAsync(params: TxParamsAsync): Promise<Encoded.Transaction> {
+  await Promise.all(
+    getSchema(params.tag, params.version)
+      .map(async ([key, field]) => {
+        if (field.prepare == null) return;
+        // @ts-expect-error the type of `params[key]` can't be determined accurately
+        params[key] = await field.prepare(params[key], params, params);
+      }),
+  );
+
+  // @ts-expect-error after preparation properties should be compatible with sync tx builder
+  return buildTx(params);
+}
+
 /**
- * Unpack transaction hash
+ * Unpack transaction encoded as string
  * @category transaction builder
  * @param encodedTx - Transaction to unpack
  * @param txType - Expected transaction type
- * @returns object
- * @returns object.tx Object with transaction param's
- * @returns object.txType Transaction type
+ * @returns Object with transaction param's
  */
 export function unpackTx<TxType extends Tag>(
-  encodedTx: Encoded.Transaction | Encoded.Poi,
+  encodedTx: Encoded.Transaction | Encoded.Poi | Encoded.StateTrees | Encoded.CallStateTree,
   txType?: TxType,
-): RawTxObject<TxTypeSchemas[TxType]> {
+): TxUnpacked & { tag: TxType } {
   const binary = rlpDecode(decode(encodedTx));
   const tag = +readInt(binary[0] as Buffer);
-  if (!isKeyOfObject(tag, TX_SCHEMA)) throw new DecodeError(`Unknown transaction tag: ${tag}`);
-  if (txType != null && txType !== tag) throw new DecodeError(`Expected transaction to have ${Tag[txType]} tag, got ${Tag[tag]} instead`);
   const version = +readInt(binary[1] as Buffer);
-  if (!isKeyOfObject(version, TX_SCHEMA[tag])) throw new SchemaNotFoundError('deserialization', `tag ${tag}`, version);
-  const schema = TX_SCHEMA[tag][version];
-  return unpackRawTx<TxTypeSchemas[TxType]>(binary, schema);
+  const schema = getSchema(tag, version);
+  if (txType != null && txType !== tag) throw new DecodeError(`Expected transaction to have ${Tag[txType]} tag, got ${Tag[tag]} instead`);
+  if (binary.length !== schema.length) {
+    throw new ArgumentError('Transaction RLP length', schema.length, binary.length);
+  }
+  return schema.reduce<any>(
+    (acc, [name, field], index) => {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      const deserialized = field.deserialize(binary[index] as BinaryData, { unpackTx });
+      return { ...acc, [name]: deserialized };
+    },
+    {},
+  ) as any;
 }
 
 /**
@@ -149,9 +135,9 @@ export function buildTxHash(rawTx: Encoded.Transaction | Uint8Array): Encoded.Tx
 export function buildContractIdByContractTx(
   contractTx: Encoded.Transaction,
 ): Encoded.ContractAddress {
-  const { tag, ownerId, nonce } = unpackTx<Tag.ContractCreateTx | Tag.GaAttachTx>(contractTx);
-  if (![Tag.ContractCreateTx, Tag.GaAttachTx].includes(tag)) {
-    throw new ArgumentError('contractCreateTx', 'a contractCreateTx or gaAttach', tag);
+  const params = unpackTx(contractTx);
+  if (Tag.ContractCreateTx !== params.tag && Tag.GaAttachTx !== params.tag) {
+    throw new ArgumentError('contractTx', 'a contractCreateTx or gaAttach', params.tag);
   }
-  return buildContractId(ownerId, +nonce);
+  return buildContractId(params.ownerId, params.nonce);
 }