@aeternity/aepp-sdk 11.0.0 → 12.1.0

package/src/oracle.ts

@@ -0,0 +1,364 @@
+/*
+ * 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.
+ */
+
+/**
+ * Oracle methods - routines to interact with the æternity oracle system
+ *
+ * The high-level description of the oracle system is
+ * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
+ * repository.
+ */
+
+import BigNumber from 'bignumber.js';
+import { send, SendOptions } from './spend';
+import { mapObject, pause } from './utils/other';
+import { oracleQueryId } from './tx/builder/helpers';
+import { unpackTx } from './tx/builder';
+import {
+  ORACLE_TTL,
+  ORACLE_TTL_TYPES,
+  QUERY_FEE,
+  QUERY_TTL,
+  RESPONSE_TTL,
+} from './tx/builder/schema';
+import { Tag } from './tx/builder/constants';
+import { RequestTimedOutError } from './utils/errors';
+import {
+  decode, encode, Encoded, Encoding,
+} from './utils/encoder';
+import { _getPollInterval } from './chain';
+import { _buildTx, BuildTxOptions } from './tx';
+import Node from './Node';
+import AccountBase from './account/Base';
+
+type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
+
+/**
+ * Poll for oracle queries
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param onQuery - OnQuery callback
+ * @param options - Options object
+ * @param options.interval - Poll interval(default: 5000)
+ * @param options.onNode - Node to use
+ * @returns Callback to stop polling function
+ */
+export function pollForQueries(
+  oracleId: Encoded.OracleAddress,
+  onQuery: (queries: OracleQueries) => void,
+  { interval, onNode, ...options }: { interval?: number; onNode: Node }
+  & Parameters<typeof _getPollInterval>[1],
+): () => void {
+  interval ??= _getPollInterval('microblock', options);
+  const knownQueryIds = new Set();
+  const checkNewQueries = async (): Promise<void> => {
+    const queries = ((await onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries ?? [])
+      .filter(({ id }) => !knownQueryIds.has(id));
+    queries.forEach(({ id }) => knownQueryIds.add(id));
+    if (queries.length > 0) onQuery(queries);
+  };
+
+  let stopped = false;
+
+  // eslint-disable-next-line @typescript-eslint/no-floating-promises
+  (async () => {
+    while (!stopped) { // eslint-disable-line no-unmodified-loop-condition
+      // TODO: allow to handle this error somehow
+      await checkNewQueries().catch(console.error);
+      await pause(interval);
+    }
+  })();
+  return () => { stopped = true; };
+}
+
+/**
+ * Poll for oracle query response
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
+ * @param options - Options object
+ * @param options.interval - Poll interval
+ * @param options.onNode - Node to use
+ * @returns OracleQuery object
+ */
+export async function pollForQueryResponse(
+  oracleId: Encoded.OracleAddress,
+  queryId: Encoded.OracleQueryId,
+  { interval, onNode, ...options }:
+  { interval?: number; onNode: Node } & Parameters<typeof _getPollInterval>[1],
+): Promise<string> {
+  interval ??= _getPollInterval('microblock', options);
+  let height;
+  let ttl;
+  let response;
+  do {
+    if (height != null) await pause(interval);
+    ({ response, ttl } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId));
+    const responseBuffer = decode(response as Encoded.OracleResponse);
+    if (responseBuffer.length > 0) return responseBuffer.toString();
+    height = await this.getHeight();
+  } while (ttl >= height);
+  throw new RequestTimedOutError(height);
+}
+
+/**
+ * Constructor for OracleQuery Object (helper object for using OracleQuery)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
+ * @param options - Options
+ * @returns OracleQuery object
+ */
+export async function getQueryObject(
+  oracleId: Encoded.OracleAddress,
+  queryId: Encoded.OracleQueryId,
+  options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2],
+): Promise<GetQueryObjectReturnType> {
+  const record = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId);
+  return {
+    ...record,
+    decodedQuery: decode(record.query as Encoded.OracleQueryId).toString(),
+    decodedResponse: decode(record.response as Encoded.OracleResponse).toString(),
+    respond: async (response, opt) => (
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      respondToQuery(oracleId, queryId, response, { ...options, ...opt })
+    ),
+    pollForResponse: async (opt) => pollForQueryResponse(oracleId, queryId, { ...options, ...opt }),
+  };
+}
+
+interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
+  decodedQuery: string;
+  decodedResponse: string;
+  respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) =>
+  ReturnType<typeof respondToQuery>;
+  pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) =>
+  ReturnType<typeof pollForQueryResponse>;
+}
+
+/**
+ * Post query to oracle
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param query - Oracle query object
+ * @param options - Options object
+ * @param options.queryTtl - queryTtl Oracle query time to leave
+ * @param options.responseTtl - queryFee Oracle query response time to leave
+ * @param options.queryFee - queryFee Oracle query fee
+ * @param options.fee - fee Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Query object
+ */
+export async function postQueryToOracle(
+  oracleId: Encoded.OracleAddress,
+  query: string,
+  options: PostQueryToOracleOptions,
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
+  options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
+  const senderId = await options.onAccount.address(options);
+
+  const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
+    queryTtlType: QUERY_TTL.type,
+    queryTtlValue: QUERY_TTL.value,
+    responseTtlType: RESPONSE_TTL.type,
+    responseTtlValue: RESPONSE_TTL.value,
+    ...options,
+    oracleId,
+    senderId,
+    query,
+  });
+  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx).tx;
+  const queryId = oracleQueryId(senderId, nonce, oracleId);
+  return {
+    ...await send(oracleQueryTx, options),
+    ...await getQueryObject(oracleId, queryId, options),
+  };
+}
+
+type PostQueryToOracleOptionsType = Parameters<typeof send>[1]
+& Parameters<typeof getQueryObject>[2]
+& BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'>
+& {
+  queryTtlType?: ORACLE_TTL_TYPES;
+  queryTtlValue?: number;
+  responseTtlType?: ORACLE_TTL_TYPES;
+  responseTtlValue?: number;
+};
+interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
+
+/**
+ * Extend oracle ttl
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param options - Options object
+ * @param options.fee - fee Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @param options.oracleTtlType - Oracle time to leave for extend
+ * @param options.oracleTtlValue - Oracle time to leave for extend
+ * @returns Oracle object
+ */
+export async function extendOracleTtl(
+  oracleId: Encoded.OracleAddress,
+  options: ExtendOracleTtlOptions,
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const oracleExtendTx = await _buildTx(Tag.OracleExtendTx, {
+    oracleTtlType: ORACLE_TTL.type,
+    oracleTtlValue: ORACLE_TTL.value,
+    ...options,
+    callerId: await options.onAccount.address(options),
+    oracleId,
+  });
+  return {
+    ...await send(oracleExtendTx, options),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    ...await getOracleObject(oracleId, options),
+  };
+}
+
+type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'>
+& { oracleTtlType?: ORACLE_TTL_TYPES; oracleTtlValue?: number };
+interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
+
+/**
+ * Extend oracle ttl
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle query id
+ * @param response - Oracle query response
+ * @param options - Options object
+ * @param options.responseTtl - responseTtl Query response time to leave
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export async function respondToQuery(
+  oracleId: Encoded.OracleAddress,
+  queryId: Encoded.OracleQueryId,
+  response: string,
+  options: RespondToQueryOptions,
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const oracleRespondTx = await _buildTx(Tag.OracleResponseTx, {
+    responseTtlType: RESPONSE_TTL.type,
+    responseTtlValue: RESPONSE_TTL.value,
+    ...options,
+    callerId: await options.onAccount.address(options),
+    oracleId,
+    queryId,
+    response,
+  });
+  return {
+    ...await send(oracleRespondTx, options),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    ...await getOracleObject(oracleId, options),
+  };
+}
+
+type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'>
+& { responseTtlType?: ORACLE_TTL_TYPES; responseTtlValue?: number };
+interface RespondToQueryOptions extends RespondToQueryOptionsType {}
+
+/**
+ * Constructor for Oracle Object (helper object for using Oracle)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param options - Options
+ * @returns Oracle object
+ */
+export async function getOracleObject(
+  oracleId: Encoded.OracleAddress,
+  options: { onNode: Node; onAccount: AccountBase },
+): Promise<GetOracleObjectReturnType> {
+  return {
+    ...await options.onNode.getOracleByPubkey(oracleId),
+    queries: (await options.onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries,
+    ...mapObject<Function, Function>(
+      {
+        pollQueries: pollForQueries,
+        postQuery: postQueryToOracle,
+        respondToQuery,
+        extendOracle: extendOracleTtl,
+        getQuery: getQueryObject,
+      },
+      ([name, handler]) => [
+        name,
+        (...args: any) => {
+          const lastArg = args[args.length - 1];
+          if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
+            Object.assign(lastArg, { ...options, ...lastArg });
+          } else args.push(options);
+          return handler(oracleId, ...args);
+        },
+      ],
+    ),
+  } as any;
+}
+
+interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
+  id: Encoded.OracleAddress;
+  queries: OracleQueries;
+  // TODO: replace getOracleObject with a class
+  pollQueries: (cb: Parameters<typeof pollForQueries>[1]) => ReturnType<typeof pollForQueries>;
+  postQuery: Function;
+  respondToQuery: Function;
+  extendOracle: Function;
+  getQuery: Function;
+}
+
+/**
+ * Register oracle
+ * @category oracle
+ * @param queryFormat - Format of query
+ * @param responseFormat - Format of query response
+ * @param options - Options
+ * @param options.queryFee - Oracle query Fee
+ * @param options - Options object
+ * @param options.abiVersion - Always 0 (do not use virtual machine)
+ * @param options.fee - Transaction fee
+ * @param options.ttl - Transaction time to leave
+ * @returns Oracle object
+ */
+export async function registerOracle(
+  queryFormat: string,
+  responseFormat: string,
+  options: RegisterOracleOptions,
+): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
+  const accountId = await options.onAccount.address(options);
+  const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
+    queryFee: QUERY_FEE,
+    oracleTtlValue: ORACLE_TTL.value,
+    oracleTtlType: ORACLE_TTL.type,
+    ...options,
+    accountId,
+    queryFormat,
+    responseFormat,
+  });
+  return {
+    ...await send(oracleRegisterTx, options),
+    ...await getOracleObject(encode(decode(accountId), Encoding.OracleAddress), options),
+  };
+}
+
+type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1]
+& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'>
+& {
+  queryFee?: number | string | BigNumber;
+  oracleTtlType?: ORACLE_TTL_TYPES;
+  oracleTtlValue?: number;
+};
+interface RegisterOracleOptions extends RegisterOracleOptionsType {}

package/src/spend.ts

@@ -0,0 +1,164 @@
+/*
+ * 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 BigNumber from 'bignumber.js';
+import {
+  sendTransaction, getAccount, getBalance, resolveName,
+} from './chain';
+import { _buildTx, BuildTxOptions } from './tx';
+import { buildTxHash, unpackTx } from './tx/builder';
+import { ArgumentError } from './utils/errors';
+import { Encoded, Encoding } from './utils/encoder';
+import { Tag, AensName } from './tx/builder/constants';
+import AccountBase from './account/Base';
+
+/**
+ * Sign and post a transaction to the chain
+ * @category chain
+ * @param tx - Transaction
+ * @param options - Options
+ * @param options.verify - Verify transaction before broadcast, throw error if not
+ * valid
+ * @returns Transaction
+ */
+export async function send(
+  tx: Encoded.Transaction,
+  options: SendOptions,
+): Promise<SendReturnType> {
+  // TODO: detect authFun in AccountGa
+  const authFun = options.innerTx === true
+    ? undefined
+    : (await getAccount(await options.onAccount.address(options), options)).authFun;
+
+  const signed = await options.onAccount.signTransaction(tx, {
+    ...options,
+    authFun,
+    networkId: (await options.onNode.getStatus()).networkId,
+  });
+
+  return options.innerTx === true
+    ? { hash: buildTxHash(signed), rawTx: signed }
+    : sendTransaction(signed, options);
+}
+
+type SendOptionsType = Parameters<AccountBase['signTransaction']>[1]
+& Parameters<typeof sendTransaction>[1] & { onAccount: AccountBase };
+export interface SendOptions extends SendOptionsType {}
+interface SendReturnType extends Awaited<ReturnType<typeof sendTransaction>> {}
+
+/**
+ * Send coins to another account
+ * @category chain
+ * @param amount - Amount to spend
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export async function spend(
+  amount: number | string,
+  recipientIdOrName: Encoded.AccountAddress | AensName,
+  options: SpendOptions,
+): ReturnType<typeof send> {
+  return send(
+    await _buildTx(Tag.SpendTx, {
+      ...options,
+      senderId: await options.onAccount.address(options),
+      recipientId: await resolveName<Encoding.AccountAddress>(
+        recipientIdOrName,
+        'account_pubkey',
+        options,
+      ),
+      amount,
+    }),
+    options,
+  );
+}
+
+type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+interface SpendOptions extends SpendOptionsType {}
+
+// TODO: Rename to spendFraction
+/**
+ * Send a fraction of coin balance to another account
+ * @category chain
+ * @param fraction - Fraction of balance to spend (between 0 and 1)
+ * @param recipientIdOrName - Address or name of recipient account
+ * @param options - Options
+ * @returns Transaction
+ */
+export async function transferFunds(
+  fraction: number | string,
+  recipientIdOrName: AensName | Encoded.AccountAddress,
+  options: TransferFundsOptions,
+): ReturnType<typeof send> {
+  if (fraction < 0 || fraction > 1) {
+    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
+  }
+  const recipientId = await resolveName<Encoding.AccountAddress>(
+    recipientIdOrName,
+    'account_pubkey',
+    options,
+  );
+  const senderId = await options.onAccount.address(options);
+  const balance = new BigNumber(
+    await getBalance.bind(options.onAccount)(senderId, options),
+  );
+  const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
+  const { tx: { fee } } = unpackTx(
+    await _buildTx(Tag.SpendTx, {
+      ...options, senderId, recipientId, amount: desiredAmount,
+    }),
+    Tag.SpendTx,
+  );
+  // Reducing of the amount may reduce transaction fee, so this is not completely accurate
+  const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount;
+  return send(
+    await _buildTx(Tag.SpendTx, {
+      ...options, senderId, recipientId, amount,
+    }),
+    options,
+  );
+}
+
+type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
+& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendOptions;
+interface TransferFundsOptions extends TransferFundsOptionsType {}
+
+/**
+ * Submit transaction of another account paying for it (fee and gas)
+ * @category chain
+ * @param transaction - tx_<base64>-encoded transaction
+ * @param options - Options
+ * @returns Object Transaction
+ */
+export async function payForTransaction(
+  transaction: Encoded.Transaction,
+  options: PayForTransactionOptions,
+): ReturnType<typeof send> {
+  return send(
+    await _buildTx(
+      Tag.PayingForTx,
+      { ...options, payerId: await options.onAccount.address(options), tx: transaction },
+    ),
+    options,
+  );
+}
+
+interface PayForTransactionOptions extends
+  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx'>, SendOptions {
+  onAccount: AccountBase;
+}

package/src/tx/builder/address.ts

@@ -0,0 +1,50 @@
+import { ArgumentError, PrefixNotFoundError, TagNotFoundError } from '../../utils/errors';
+import { toBytes } from '../../utils/bytes';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../utils/encoder';
+import { isItemOfArray } from '../../utils/other';
+
+/**
+ * Map of prefix to ID tag constant
+ * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
+ */
+const idTagToEncoding = [
+  Encoding.AccountAddress,
+  Encoding.Name,
+  Encoding.Commitment,
+  Encoding.OracleAddress,
+  Encoding.ContractAddress,
+  Encoding.Channel,
+] as const;
+
+type AddressEncodings = typeof idTagToEncoding[number];
+
+/**
+ * Utility function to create and _id type
+ * @category transaction builder
+ * @param hashId - Encoded hash
+ * @returns Buffer Buffer with ID tag and decoded HASh
+ */
+export function writeId(hashId: Encoded.Generic<AddressEncodings>): Buffer {
+  if (typeof hashId !== 'string') throw new ArgumentError('hashId', 'a string', hashId);
+  const encoding = hashId.slice(0, 2);
+  if (!isItemOfArray(encoding, idTagToEncoding)) throw new TagNotFoundError(encoding);
+  const idTag = idTagToEncoding.indexOf(encoding) + 1;
+  return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
+}
+
+/**
+ * Utility function to read and _id type
+ * @category transaction builder
+ * @param buf - Data
+ * @returns Encoided hash string with prefix
+ */
+export function readId(buf: Buffer): Encoded.Generic<AddressEncodings> {
+  const idTag = Buffer.from(buf).readUIntBE(0, 1);
+  const encoding = idTagToEncoding[idTag - 1];
+  if (encoding == null) throw new PrefixNotFoundError(idTag);
+  return encode(buf.slice(1, buf.length), encoding);
+}

package/src/tx/builder/constants.ts

@@ -0,0 +1,126 @@
+import BigNumber from 'bignumber.js';
+import { mapObject } from '../../utils/other';
+
+// # AENS
+export type AensName = `${string}.chain`;
+export const NAME_TTL = 180000;
+// # max number of block into the future that the name is going to be available
+// # https://github.com/aeternity/protocol/blob/epoch-v0.22.0/AENS.md#update
+// # https://github.com/aeternity/protocol/blob/44a93d3aab957ca820183c3520b9daf6b0fedff4/AENS.md#aens-entry
+export const NAME_MAX_TTL = 36000;
+export const NAME_MAX_CLIENT_TTL = 84600;
+export const CLIENT_TTL = NAME_MAX_CLIENT_TTL;
+export const MIN_GAS_PRICE = 1e9;
+// # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L67
+export const NAME_FEE_MULTIPLIER = 1e14; // 100000000000000
+export const NAME_FEE_BID_INCREMENT = 0.05; // # the increment is in percentage
+// # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L272
+export const NAME_BID_TIMEOUT_BLOCKS = 480; // # ~1 day
+// # this is the max length for a domain that requires a base fee to be paid
+export const NAME_MAX_LENGTH_FEE = 31;
+export const NAME_BID_MAX_LENGTH = 12; // # this is the max length for a domain to be part of a bid
+// # https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L290
+// # https://github.com/aeternity/protocol/blob/master/AENS.md#protocol-fees-and-protection-times
+// # bid ranges:
+export const NAME_BID_RANGES = mapObject({
+  31: 3,
+  30: 5,
+  29: 8,
+  28: 13,
+  27: 21,
+  26: 34,
+  25: 55,
+  24: 89,
+  23: 144,
+  22: 233,
+  21: 377,
+  20: 610,
+  19: 987,
+  18: 1597,
+  17: 2584,
+  16: 4181,
+  15: 6765,
+  14: 10946,
+  13: 17711,
+  12: 28657,
+  11: 46368,
+  10: 75025,
+  9: 121393,
+  8: 196418,
+  7: 317811,
+  6: 514229,
+  5: 832040,
+  4: 1346269,
+  3: 2178309,
+  2: 3524578,
+  1: 5702887,
+}, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
+
+/**
+ * Enum with tag types
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/serializations.md#binary-serialization}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_chain_objects.erl#L39-L97}
+ */
+// TODO: implement serialisation for commented-out tags
+export enum Tag {
+  Account = 10,
+  SignedTx = 11,
+  SpendTx = 12,
+  // Oracle = 20,
+  // OracleQuery = 21,
+  OracleRegisterTx = 22,
+  OracleQueryTx = 23,
+  OracleResponseTx = 24,
+  OracleExtendTx = 25,
+  // Name = 30,
+  // NameCommitment = 31,
+  NameClaimTx = 32,
+  NamePreclaimTx = 33,
+  NameUpdateTx = 34,
+  NameRevokeTx = 35,
+  NameTransferTx = 36,
+  // NameAuction = 37,
+  Contract = 40,
+  ContractCall = 41,
+  ContractCreateTx = 42,
+  ContractCallTx = 43,
+  ChannelCreateTx = 50,
+  // ChannelSetDelegatesTx = 501,
+  ChannelDepositTx = 51,
+  ChannelWithdrawTx = 52,
+  ChannelForceProgressTx = 521,
+  ChannelCloseMutualTx = 53,
+  ChannelCloseSoloTx = 54,
+  ChannelSlashTx = 55,
+  ChannelSettleTx = 56,
+  ChannelOffChainTx = 57,
+  ChannelOffChainUpdateTransfer = 570,
+  ChannelOffChainUpdateDeposit = 571,
+  ChannelOffChainUpdateWithdraw = 572,
+  ChannelOffChainUpdateCreateContract = 573,
+  ChannelOffChainUpdateCallContract = 574,
+  // ChannelOffChainUpdateMeta = 576,
+  ChannelClientReconnectTx = 575,
+  Channel = 58,
+  ChannelSnapshotSoloTx = 59,
+  TreesPoi = 60,
+  // TreesDb = 61,
+  StateTrees = 62,
+  Mtree = 63,
+  MtreeValue = 64,
+  ContractsMtree = 621,
+  CallsMtree = 622,
+  ChannelsMtree = 623,
+  NameserviceMtree = 624,
+  OraclesMtree = 625,
+  AccountsMtree = 626,
+  CompilerSophia = 70,
+  GaAttachTx = 80,
+  GaMetaTx = 81,
+  PayingForTx = 82,
+  // KeyBlock = 100,
+  // MicroBlock = 101,
+  // LightMicroBlock = 102,
+  // Pof = 200,
+}