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

package/src/contract/compiler/Cli.ts

@@ -0,0 +1,134 @@
+import { execFile } from 'child_process';
+import { tmpdir } from 'os';
+import { resolve, dirname, basename } from 'path';
+import { mkdir, writeFile, rm } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import CompilerBase, { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+import { CompilerError, InternalError, UnsupportedVersionError } from '../../utils/errors';
+import semverSatisfies from '../../utils/semver-satisfies';
+
+const getPackagePath = (): string => {
+  const path = dirname(fileURLToPath(import.meta.url));
+  if (basename(path) === 'dist') return resolve(path, '..');
+  if (basename(path) === 'compiler') return resolve(path, '../../..');
+  throw new InternalError('Can\'t get package path');
+};
+
+/**
+ * A wrapper around aesophia_cli, available only in Node.js
+ * Assumes that `escript` is available in PATH.
+ */
+export default class CompilerCli extends CompilerBase {
+  #path: string;
+
+  #ensureCompatibleVersion: Promise<void>;
+
+  constructor(
+    compilerPath = resolve(getPackagePath(), './bin/aesophia_cli'),
+    { ignoreVersion }: { ignoreVersion?: boolean } = {},
+  ) {
+    super();
+    this.#path = compilerPath;
+    if (ignoreVersion !== true) {
+      this.#ensureCompatibleVersion = this.version().then((version) => {
+        const versions = [version, '7.0.1', '8.0.0'] as const;
+        if (!semverSatisfies(...versions)) throw new UnsupportedVersionError('compiler', ...versions);
+      });
+    }
+  }
+
+  async #run(...parameters: string[]): Promise<string> {
+    return new Promise((pResolve, pReject) => {
+      execFile('escript', [this.#path, ...parameters], (error, stdout, stderr) => {
+        if (error != null) pReject(error);
+        else if (stderr !== '') pReject(new CompilerError(stderr));
+        else pResolve(stdout);
+      });
+    });
+  }
+
+  static async #saveContractToTmpDir(
+    sourceCode: string,
+    fileSystem: Record<string, string> = {},
+  ): Promise<string> {
+    const randomName = (): string => Math.random().toString(36).slice(2);
+    const path = resolve(tmpdir(), `aepp-sdk-js-${randomName()}`);
+    await mkdir(path);
+    const sourceCodePath = resolve(path, `${randomName()}.aes`);
+    await writeFile(sourceCodePath, sourceCode);
+    await Promise.all(Object.entries(fileSystem)
+      .map(async ([name, src]) => {
+        const p = resolve(path, name);
+        await mkdir(dirname(p), { recursive: true });
+        return writeFile(p, src);
+      }));
+    return sourceCodePath;
+  }
+
+  async compile(path: string): Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: Aci;
+  }> {
+    await this.#ensureCompatibleVersion;
+    let bytecode;
+    let aciCli;
+    try {
+      [bytecode, aciCli] = await Promise.all([
+        this.#run(path),
+        this.#run('--create_json_aci', path).then((res) => JSON.parse(res)),
+      ]);
+    } catch (error) {
+      throw new CompilerError(error.message);
+    }
+    const aci = {
+      encodedAci: aciCli[0],
+      externalEncodedAci: aciCli.slice(1),
+    };
+    return {
+      bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
+      aci: aci as Aci,
+    };
+  }
+
+  async compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: Aci;
+  }> {
+    const tmp = await CompilerCli.#saveContractToTmpDir(sourceCode, fileSystem);
+    try {
+      return await this.compile(tmp);
+    } finally {
+      await rm(dirname(tmp), { recursive: true });
+    }
+  }
+
+  async validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean> {
+    await this.#ensureCompatibleVersion;
+    try {
+      return (await this.#run(path, '--validate', bytecode)).includes('Validation successful.');
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async validateBySourceCode(
+    bytecode: Encoded.ContractBytearray,
+    sourceCode: string,
+    fileSystem?: Record<string, string>,
+  ): Promise<boolean> {
+    const tmp = await CompilerCli.#saveContractToTmpDir(sourceCode, fileSystem);
+    try {
+      return await this.validate(bytecode, tmp);
+    } finally {
+      await rm(dirname(tmp), { recursive: true });
+    }
+  }
+
+  async version(): Promise<string> {
+    const verMessage = await this.#run('--version');
+    const ver = verMessage.match(/Sophia compiler version ([\d.]+)\n/)?.[1];
+    if (ver == null) throw new CompilerError('Can\'t get compiler version');
+    return ver;
+  }
+}

package/src/contract/compiler/Http.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 { RestError } from '@azure/core-rest-pipeline';
+import {
+  Compiler as CompilerApi,
+  ErrorModel,
+  CompilerError as CompilerErrorApi,
+} from '../../apis/compiler';
+import { genErrorFormatterPolicy, genVersionCheckPolicy } from '../../utils/autorest';
+import CompilerBase, { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+import { CompilerError, NotImplementedError } from '../../utils/errors';
+
+type GeneralCompilerError = ErrorModel & {
+  info?: object;
+  parameter?: string;
+};
+
+/**
+ * Contract Compiler over HTTP
+ *
+ * This class include api call's related to contract compiler functionality.
+ * @category contract
+ * @example CompilerHttp('COMPILER_URL')
+ */
+export default class CompilerHttp extends CompilerBase {
+  readonly api: CompilerApi;
+
+  /**
+   * @param compilerUrl - Url for compiler API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check compiler version
+   */
+  constructor(compilerUrl: string, { ignoreVersion }: { ignoreVersion?: boolean } = {}) {
+    super();
+    this.api = new CompilerApi(compilerUrl, {
+      allowInsecureConnection: true,
+      additionalPolicies: [
+        genErrorFormatterPolicy((body: GeneralCompilerError | CompilerErrorApi[]) => {
+          let message = '';
+          if ('reason' in body) {
+            message += ` ${body.reason
+            }${body.parameter != null ? ` in ${body.parameter}` : ''
+              // TODO: revising after improving documentation https://github.com/aeternity/aesophia_http/issues/78
+            }${body.info != null ? ` (${JSON.stringify(body.info)})` : ''}`;
+          }
+          if (Array.isArray(body)) {
+            message += `\n${body
+              .map((e) => `${e.type}:${e.pos.line}:${e.pos.col}: ${e.message}${e.context != null ? `(${e.context})` : ''}`)
+              .join('\n')}`;
+          }
+          return message;
+        }),
+      ],
+    });
+    if (ignoreVersion !== true) {
+      const versionPromise = this.api.apiVersion().then(({ apiVersion }) => apiVersion);
+      this.api.pipeline.addPolicy(
+        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.0.1', '8.0.0'),
+      );
+    }
+  }
+
+  async compileBySourceCode(
+    sourceCode: string,
+    fileSystem?: Record<string, string>,
+  ): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+    try {
+      const [bytecode, aci] = await Promise.all([
+        this.api.compileContract({ code: sourceCode, options: { fileSystem } })
+          .then((res) => res.bytecode as Encoded.ContractBytearray),
+        this.api.generateACI({ code: sourceCode, options: { fileSystem } }),
+      ]);
+      // TODO: should be fixed when the compiledAci interface gets updated
+      return { bytecode, aci: aci as Aci };
+    } catch (error) {
+      if (error instanceof RestError && error.statusCode === 400) {
+        throw new CompilerError(error.message.replace(/^aci error:/, 'compile error:'));
+      }
+      throw error;
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  async compile(path: string): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+    throw new NotImplementedError('File system access, use CompilerHttpNode instead');
+  }
+
+  async validateBySourceCode(
+    bytecode: Encoded.ContractBytearray,
+    sourceCode: string,
+    fileSystem?: Record<string, string>,
+  ): Promise<boolean> {
+    try {
+      await this.api.validateByteCode({ bytecode, source: sourceCode, options: { fileSystem } });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  async validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean> {
+    throw new NotImplementedError('File system access, use CompilerHttpNode instead');
+  }
+
+  async version(): Promise<string> {
+    return (await this.api.version()).version;
+  }
+}

package/src/contract/compiler/HttpNode.ts

@@ -0,0 +1,26 @@
+import { readFile } from 'fs/promises';
+import HttpBrowser from './Http';
+import { Aci } from './Base';
+import { Encoded } from '../../utils/encoder';
+import getFileSystem from './getFileSystem';
+
+/**
+ * Contract Compiler over HTTP for Nodejs
+ *
+ * Inherits CompilerHttp and implements `compile`, `validate` methods
+ * @category contract
+ * @example CompilerHttpNode('COMPILER_URL')
+ */
+export default class CompilerHttpNode extends HttpBrowser {
+  override async compile(path: string): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+    const fileSystem = await getFileSystem(path);
+    const sourceCode = await readFile(path, 'utf8');
+    return this.compileBySourceCode(sourceCode, fileSystem);
+  }
+
+  override async validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean> {
+    const fileSystem = await getFileSystem(path);
+    const sourceCode = await readFile(path, 'utf8');
+    return this.validateBySourceCode(bytecode, sourceCode, fileSystem);
+  }
+}

package/src/contract/compiler/getFileSystem.ts

@@ -0,0 +1,42 @@
+import { readFile } from 'fs/promises';
+import { dirname, resolve, basename } from 'path';
+import { InternalError } from '../../utils/errors';
+
+const defaultIncludes = [
+  'List.aes', 'Option.aes', 'String.aes',
+  'Func.aes', 'Pair.aes', 'Triple.aes',
+  'BLS12_381.aes', 'Frac.aes', 'Set.aes',
+  'Bitwise.aes',
+];
+const includeRegExp = /^include\s*"([\w/.-]+)"/mi;
+const includesRegExp = new RegExp(includeRegExp.source, `${includeRegExp.flags}g`);
+
+async function getFileSystemRec(
+  root: string,
+  relative: string,
+): Promise<Record<string, string>> {
+  const sourceCode = await readFile(resolve(root, relative), 'utf8');
+  const filesystem: Record<string, string> = {};
+  await Promise.all((sourceCode.match(includesRegExp) ?? [])
+    .map((include) => {
+      const m = include.match(includeRegExp);
+      if (m?.length !== 2) throw new InternalError('Unexpected match length');
+      return m[1];
+    })
+    .filter((include) => !defaultIncludes.includes(include))
+    .map(async (include) => {
+      const includePath = resolve(root, include);
+      filesystem[include] = await readFile(includePath, 'utf8');
+      Object.assign(filesystem, await getFileSystemRec(root, include));
+    }));
+  return filesystem;
+}
+
+/**
+ * Reads all files included in the provided contract
+ * Available only in Node.js
+ * @param path - a path to the main contract source code
+ */
+export default async function getFileSystem(path: string): Promise<Record<string, string>> {
+  return getFileSystemRec(dirname(path), basename(path));
+}

package/src/contract/ga.ts

@@ -31,7 +31,7 @@ import Contract from './Contract';
 import { send, SendOptions } from '../spend';
 import Node from '../Node';
 import { getAccount } from '../chain';
-import CompilerHttp from './CompilerHttp';
+import CompilerBase from './compiler/Base';
 
 /**
  * Convert current account to GA
@@ -44,10 +44,9 @@ import CompilerHttp from './CompilerHttp';
  */
 export async function createGeneralizedAccount(
   authFnName: string,
-  sourceCode: string,
   args: any[],
   {
-    onAccount, onCompiler, onNode, ...options
+    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options
   }: CreateGeneralizedAccountOptions,
 ): Promise<Readonly<{
     owner: Encoded.AccountAddress;
@@ -61,7 +60,7 @@ export async function createGeneralizedAccount(
   }
 
   const contract = await Contract.initialize<{ init: (...a: any[]) => void }>({
-    onAccount, onCompiler, onNode, sourceCode,
+    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem,
   });
 
   const tx = await _buildTx(Tag.GaAttachTx, {
@@ -88,9 +87,13 @@ export async function createGeneralizedAccount(
 
 interface CreateGeneralizedAccountOptions extends
   BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>,
-  SendOptions {
+  SendOptions,
+  Pick<
+  Parameters<typeof Contract.initialize>[0],
+  'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'
+  > {
   onAccount: AccountBase;
-  onCompiler: CompilerHttp;
+  onCompiler: CompilerBase;
   onNode: Node;
   gasLimit?: number;
 }

package/src/index-browser.ts

@@ -0,0 +1,58 @@
+/*
+ * 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.
+ */
+
+export * from './chain';
+export * from './utils/crypto';
+export * from './utils/keystore';
+export * from './utils/bytes';
+export * from './tx';
+export * from './tx/builder';
+export * from './tx/builder/helpers';
+export * from './tx/builder/constants';
+export * from './tx/builder/schema';
+export * from './utils/amount-formatter';
+export * from './utils/hd-wallet';
+export { encode, decode, Encoding } from './utils/encoder';
+export * from './aens';
+export { default as Contract } from './contract/Contract';
+export type { ContractMethodsBase } from './contract/Contract';
+export * from './oracle';
+export * from './spend';
+export * from './contract/ga';
+
+export { default as AeSdkMethods } from './AeSdkMethods';
+export { default as AeSdkBase } from './AeSdkBase';
+export { default as AeSdk } from './AeSdk';
+export { default as AeSdkAepp } from './AeSdkAepp';
+export { default as AeSdkWallet } from './AeSdkWallet';
+export { default as Node } from './Node';
+export { default as verifyTransaction } from './tx/validator';
+export { default as AccountBase } from './account/Base';
+export { default as MemoryAccount } from './account/Memory';
+export { default as AccountGeneralized } from './account/Generalized';
+export { default as AccountLedger } from './account/Ledger';
+export { default as AccountLedgerFactory } from './account/LedgerFactory';
+export { default as CompilerBase } from './contract/compiler/Base';
+export { default as CompilerHttp } from './contract/compiler/Http';
+export { default as Channel } from './channel/Contract';
+
+export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
+export * from './aepp-wallet-communication/schema';
+export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
+export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
+export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
+export * from './utils/errors';

package/src/index.ts

@@ -1,57 +1,5 @@
-/*
- * 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.
- */
+export * from './index-browser';
 
-export * from './chain';
-export * from './utils/crypto';
-export * from './utils/keystore';
-export * from './utils/bytes';
-export * from './tx';
-export * from './tx/builder';
-export * from './tx/builder/helpers';
-export * from './tx/builder/constants';
-export * from './tx/builder/schema';
-export * from './utils/amount-formatter';
-export * from './utils/hd-wallet';
-export { encode, decode, Encoding } from './utils/encoder';
-export * from './aens';
-export { default as Contract } from './contract/Contract';
-export type { ContractMethodsBase } from './contract/Contract';
-export * from './oracle';
-export * from './spend';
-export * from './contract/ga';
-
-export { default as AeSdkMethods } from './AeSdkMethods';
-export { default as AeSdkBase } from './AeSdkBase';
-export { default as AeSdk } from './AeSdk';
-export { default as AeSdkAepp } from './AeSdkAepp';
-export { default as AeSdkWallet } from './AeSdkWallet';
-export { default as Node } from './Node';
-export { default as verifyTransaction } from './tx/validator';
-export { default as AccountBase } from './account/Base';
-export { default as MemoryAccount } from './account/Memory';
-export { default as AccountGeneralized } from './account/Generalized';
-export { default as AccountLedger } from './account/Ledger';
-export { default as AccountLedgerFactory } from './account/LedgerFactory';
-export { default as CompilerHttp } from './contract/CompilerHttp';
-export { default as Channel } from './channel/Contract';
-
-export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
-export * from './aepp-wallet-communication/schema';
-export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
-export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
-export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
-export * from './utils/errors';
+export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as getFileSystem } from './contract/compiler/getFileSystem';
+export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/src/oracle.ts

@@ -181,7 +181,7 @@ export async function postQueryToOracle(
     senderId,
     query,
   });
-  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx).tx;
+  const { nonce } = unpackTx(oracleQueryTx, Tag.OracleQueryTx);
   const queryId = oracleQueryId(senderId, nonce, oracleId);
   return {
     ...await send(oracleQueryTx, options),

package/src/spend.ts

@@ -110,7 +110,7 @@ export async function transferFunds(
     await getBalance.bind(options.onAccount)(senderId, options),
   );
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
-  const { tx: { fee } } = unpackTx(
+  const { fee } = unpackTx(
     await _buildTx(Tag.SpendTx, {
       ...options, senderId, recipientId, amount: desiredAmount,
     }),

package/src/tx/builder/constants.ts

@@ -2,6 +2,7 @@ import BigNumber from 'bignumber.js';
 import { mapObject } from '../../utils/other';
 
 export const MAX_AUTH_FUN_GAS = 50000;
+export type Int = number | string | BigNumber;
 // # AENS
 export type AensName = `${string}.chain`;
 export const NAME_TTL = 180000;
@@ -57,6 +58,34 @@ export const NAME_BID_RANGES = mapObject({
   1: 5702887,
 }, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
 
+export enum ConsensusProtocolVersion {
+  Iris = 5,
+}
+
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export enum VmVersion {
+  NoVm = 0,
+  Sophia = 1,
+  SophiaImprovementsMinerva = 3,
+  SophiaImprovementsFortuna = 4,
+  Fate = 5,
+  SophiaImprovementsLima = 6,
+  Fate2 = 7,
+}
+
+/**
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
+ */
+export enum AbiVersion {
+  NoAbi = 0,
+  Sophia = 1,
+  Fate = 3,
+}
+
 /**
  * Enum with tag types
  * @category transaction builder
@@ -68,13 +97,13 @@ export enum Tag {
   Account = 10,
   SignedTx = 11,
   SpendTx = 12,
-  // Oracle = 20,
+  Oracle = 20,
   // OracleQuery = 21,
   OracleRegisterTx = 22,
   OracleQueryTx = 23,
   OracleResponseTx = 24,
   OracleExtendTx = 25,
-  // Name = 30,
+  Name = 30,
   // NameCommitment = 31,
   NameClaimTx = 32,
   NamePreclaimTx = 33,
@@ -116,7 +145,7 @@ export enum Tag {
   NameserviceMtree = 624,
   OraclesMtree = 625,
   AccountsMtree = 626,
-  CompilerSophia = 70,
+  // CompilerSophia = 70,
   GaAttachTx = 80,
   GaMetaTx = 81,
   PayingForTx = 82,

package/src/tx/builder/field-types/abi-version.ts

@@ -0,0 +1,21 @@
+import { Tag, ConsensusProtocolVersion, AbiVersion } from '../constants';
+import { getProtocolDetails } from './ct-version';
+
+export default {
+  serialize(
+    value: AbiVersion | undefined,
+    { tag, consensusProtocolVersion = ConsensusProtocolVersion.Iris }:
+    { tag: Tag; consensusProtocolVersion: ConsensusProtocolVersion },
+  ): Buffer {
+    const result = value ?? getProtocolDetails(
+      consensusProtocolVersion,
+      Tag.ContractCallTx === tag || Tag.GaMetaTx === tag ? 'contract-call' : 'oracle-call',
+    ).abiVersion;
+
+    return Buffer.from([result]);
+  },
+
+  deserialize(buffer: Buffer): AbiVersion {
+    return buffer[0];
+  },
+};

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

@@ -1,6 +1,8 @@
-import { PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
+import { ArgumentError, PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
 import { toBytes } from '../../../utils/bytes';
-import { decode, encode, Encoding } from '../../../utils/encoder';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../../../utils/encoder';
 import { isItemOfArray } from '../../../utils/other';
 
 /**
@@ -9,7 +11,7 @@ import { isItemOfArray } from '../../../utils/other';
  * @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 = [
+export const idTagToEncoding = [
   Encoding.AccountAddress,
   Encoding.Name,
   Encoding.Commitment,
@@ -20,10 +22,12 @@ const idTagToEncoding = [
 
 export type AddressEncodings = typeof idTagToEncoding[number];
 
-export default function genAddressField<Encoding extends AddressEncodings>(): {
-  serialize: (value: `${Encoding}_${string}`) => Buffer;
-  deserialize: (value: Buffer) => `${Encoding}_${string}`;
-} {
+export default function genAddressField<Encoding extends AddressEncodings>(
+  ...encodings: Encoding[]
+): {
+    serialize: (value: Encoded.Generic<Encoding>) => Buffer;
+    deserialize: (value: Buffer) => Encoded.Generic<Encoding>;
+  } {
   return {
     /**
      * Utility function to create and _id type
@@ -31,9 +35,12 @@ export default function genAddressField<Encoding extends AddressEncodings>(): {
      * @returns Buffer Buffer with ID tag and decoded HASh
      */
     serialize(hashId) {
-      const encoding = hashId.slice(0, 2);
-      if (!isItemOfArray(encoding, idTagToEncoding)) throw new TagNotFoundError(encoding);
-      const idTag = idTagToEncoding.indexOf(encoding) + 1;
+      const enc = hashId.slice(0, 2);
+      if (!isItemOfArray(enc, idTagToEncoding)) throw new TagNotFoundError(enc);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      const idTag = idTagToEncoding.indexOf(enc) + 1;
       return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
     },
 
@@ -44,9 +51,12 @@ export default function genAddressField<Encoding extends AddressEncodings>(): {
      */
     deserialize(buf) {
       const idTag = Buffer.from(buf).readUIntBE(0, 1);
-      const encoding = idTagToEncoding[idTag - 1];
-      if (encoding == null) throw new PrefixNotFoundError(idTag);
-      return encode(buf.subarray(1), encoding) as `${Encoding}_${string}`;
+      const enc = idTagToEncoding[idTag - 1];
+      if (enc == null) throw new PrefixNotFoundError(idTag);
+      if (!isItemOfArray(enc, encodings)) {
+        throw new ArgumentError('Address encoding', encodings.join(', '), enc);
+      }
+      return encode(buf.subarray(1), enc) as Encoded.Generic<Encoding>;
     },
   };
 }