@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/src/contract/compiler/Base.ts

@@ -1,123 +0,0 @@
-import { Encoded } from '../../utils/encoder';
-
-interface FunctionAci {
-  arguments: any[];
-  name: string;
-  payable: boolean;
-  returns: any;
-  stateful: boolean;
-}
-
-export type Aci = Array<{
-  contract?: {
-    name: string;
-    event?: any;
-    functions: FunctionAci[];
-    kind: string; // known values: 'contract_main'
-    payable: boolean;
-    typedefs: any[];
-  };
-}>;
-
-export type CompileResult = Promise<{
-  bytecode: Encoded.ContractBytearray;
-  aci: Aci;
-  warnings: Array<{
-    message: string;
-    pos: {
-      file?: string;
-      line: number;
-      col: number;
-    };
-  }>;
-}>;
-
-/**
- * A base class for all compiler implementations
- */
-export default abstract class CompilerBase {
-  /**
-   * Compile contract by contract's path
-   * Available only in Node.js
-   * @param path - Path to contract source code
-   * @returns ACI and bytecode
-   */
-  abstract compile(path: string): CompileResult;
-
-  /**
-   * Compile contract by contract's source code
-   * @param sourceCode - Contract source code as string
-   * @param fileSystem - A map of contract filename to the corresponding contract source code to
-   * include into the main contract
-   * @example
-   * ```js
-   * {
-   *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-   * }
-   * ```
-   * @returns ACI and bytecode
-   */
-  abstract compileBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): CompileResult;
-
-  /**
-   * Generate contract's ACI by contract's path
-   * Available only in Node.js
-   * @param path - Path to contract source code
-   * @returns ACI
-   */
-  abstract generateAci(path: string): Promise<Aci>;
-
-  /**
-   * Generate contract's ACI by contract's source code
-   * @param sourceCode - Contract source code as string
-   * @param fileSystem - A map of contract filename to the corresponding contract source code to
-   * include into the main contract
-   * @example
-   * ```js
-   * {
-   *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-   * }
-   * ```
-   * @returns ACI
-   */
-  abstract generateAciBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): Promise<Aci>;
-
-  /**
-   * Verify that a contract bytecode is the result of compiling the given source code
-   * Available only in Node.js
-   * @param bytecode - Contract bytecode to verify
-   * @param path - Path to contract source code
-   * @returns ACI and bytecode
-   */
-  abstract validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
-
-  /**
-   * Verify that a contract bytecode is the result of compiling the given source code
-   * @param bytecode - Contract bytecode to verify
-   * @param sourceCode - Contract source code as string
-   * @param fileSystem - A map of contract filename to the corresponding contract source code to
-   * include into the main contract
-   * @example
-   * ```js
-   * {
-   *   'library.aes': 'namespace TestLib =\n  function sum(x: int, y: int) : int = x + y'
-   * }
-   * ```
-   */
-  abstract validateBySourceCode(
-    bytecode: Encoded.ContractBytearray,
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): Promise<boolean>;
-
-  /**
-   * @returns Compiler version
-   */
-  abstract version(): Promise<string>;
-}

package/src/contract/compiler/Cli.ts

@@ -1,173 +0,0 @@
-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, CompileResult } from './Base';
-import { Encoded } from '../../utils/encoder';
-import { CompilerError, InternalError, UnsupportedVersionError } from '../../utils/errors';
-import semverSatisfies from '../../utils/semver-satisfies';
-import { ensureError } from '../../utils/other';
-
-export 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.
- * Requires Erlang installed, assumes that `escript` is available in PATH.
- * @category contract
- */
-export default class CompilerCli extends CompilerBase {
-  readonly #path: string;
-
-  readonly #ensureCompatibleVersion = Promise.resolve();
-
-  /**
-   * @param compilerPath - A path to aesophia_cli binary, by default uses the integrated one
-   * @param options - Options
-   * @param options.ignoreVersion - Don't ensure that the compiler is supported
-   */
-  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.2.1', '9.0.0'] as const;
-        if (!semverSatisfies(...versions)) throw new UnsupportedVersionError('compiler', ...versions);
-      });
-    }
-  }
-
-  async #runWithStderr(...parameters: string[]): Promise<{ stderr: string; stdout: string }> {
-    return new Promise((pResolve, pReject) => {
-      execFile('escript', [this.#path, ...parameters], (error, stdout, stderr) => {
-        if (error != null) pReject(error);
-        else pResolve({ stdout, stderr });
-      });
-    });
-  }
-
-  async #run(...parameters: string[]): Promise<string> {
-    const { stderr, stdout } = await this.#runWithStderr(...parameters);
-    if (stderr !== '') throw new CompilerError(stderr);
-    return 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): CompileResult {
-    await this.#ensureCompatibleVersion;
-    try {
-      const [compileRes, aci] = await Promise.all([
-        this.#runWithStderr(path),
-        this.generateAci(path),
-      ]);
-      return {
-        bytecode: compileRes.stdout.trimEnd() as Encoded.ContractBytearray,
-        aci,
-        warnings: compileRes.stderr.split('Warning in ').slice(1).map((warning) => {
-          const reg = /^'(.+)' at line (\d+), col (\d+):\n(.+)$/s;
-          const match = warning.match(reg);
-          if (match == null) throw new InternalError(`Can't parse compiler output: "${warning}"`);
-          return {
-            message: match[4].trimEnd(),
-            pos: {
-              ...match[1] !== path && { file: match[1] },
-              line: +match[2],
-              col: +match[3],
-            },
-          };
-        }),
-      };
-    } catch (error) {
-      ensureError(error);
-      throw new CompilerError(error.message);
-    }
-  }
-
-  async compileBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): CompileResult {
-    const tmp = await CompilerCli.#saveContractToTmpDir(sourceCode, fileSystem);
-    try {
-      return await this.compile(tmp);
-    } finally {
-      await rm(dirname(tmp), { recursive: true });
-    }
-  }
-
-  async generateAci(path: string): Promise<Aci> {
-    await this.#ensureCompatibleVersion;
-    try {
-      return JSON.parse(await this.#run('--no_code', '--create_json_aci', path));
-    } catch (error) {
-      ensureError(error);
-      throw new CompilerError(error.message);
-    }
-  }
-
-  async generateAciBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): Promise<Aci> {
-    const tmp = await CompilerCli.#saveContractToTmpDir(sourceCode, fileSystem);
-    try {
-      return await this.generateAci(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/Cli8.ts

@@ -1,17 +0,0 @@
-import { resolve } from 'path';
-import CompilerCli, { getPackagePath } from './Cli';
-
-/**
- * @category contract
- */
-export default class CompilerCli8 extends CompilerCli {
-  /**
-   * @param options - Options
-   * @param options.ignoreVersion - Don't ensure that the compiler is supported
-   */
-  constructor(
-    { ignoreVersion }: { ignoreVersion?: boolean } = {},
-  ) {
-    super(resolve(getPackagePath(), './bin/aesophia_cli_8'), { ignoreVersion });
-  }
-}

package/src/contract/compiler/Http.ts

@@ -1,134 +0,0 @@
-import {
-  RestError, userAgentPolicyName, setClientRequestIdPolicyName,
-} from '@azure/core-rest-pipeline';
-import { OperationOptions } from '@azure/core-client';
-import {
-  Compiler as CompilerApi,
-  ErrorModel,
-  CompilerError as CompilerErrorApi,
-} from '../../apis/compiler';
-import { genErrorFormatterPolicy, genVersionCheckPolicy } from '../../utils/autorest';
-import CompilerBase, { Aci, CompileResult } 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 = false }: { ignoreVersion?: boolean } = {}) {
-    super();
-
-    let version: string | undefined;
-    const getVersion = async (opts: OperationOptions): Promise<string> => {
-      if (version != null) return version;
-      version = (await this.api.apiVersion(opts)).apiVersion;
-      return version;
-    };
-
-    this.api = new CompilerApi(compilerUrl, {
-      allowInsecureConnection: true,
-      additionalPolicies: [
-        ...ignoreVersion ? [] : [genVersionCheckPolicy('compiler', getVersion, '7.3.0', '9.0.0')],
-        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;
-        }),
-      ],
-    });
-    this.api.pipeline.removePolicy({ name: userAgentPolicyName });
-    this.api.pipeline.removePolicy({ name: setClientRequestIdPolicyName });
-  }
-
-  async compileBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): CompileResult {
-    try {
-      const cmpOut = await this.api.compileContract({ code: sourceCode, options: { fileSystem } });
-      cmpOut.warnings ??= []; // TODO: remove after requiring http compiler above or equal to 8.0.0
-      const warnings = cmpOut.warnings.map(({ type, ...warning }) => warning);
-      const res = { ...cmpOut, warnings };
-      // TODO: should be fixed when the compiledAci interface gets updated
-      return res as Awaited<CompileResult>;
-    } catch (error) {
-      if (error instanceof RestError && error.statusCode === 400) {
-        throw new CompilerError(error.message);
-      }
-      throw error;
-    }
-  }
-
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  async compile(path: string): CompileResult {
-    throw new NotImplementedError('File system access, use CompilerHttpNode instead');
-  }
-
-  async generateAciBySourceCode(
-    sourceCode: string,
-    fileSystem?: Record<string, string>,
-  ): Promise<Aci> {
-    try {
-      return await this.api.generateACI({ code: sourceCode, options: { fileSystem } });
-    } catch (error) {
-      if (error instanceof RestError && error.statusCode === 400) {
-        throw new CompilerError(error.message);
-      }
-      throw error;
-    }
-  }
-
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  async generateAci(path: string): Promise<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

@@ -1,32 +0,0 @@
-import { readFile } from 'fs/promises';
-import HttpBrowser from './Http';
-import { Aci, CompileResult } 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): CompileResult {
-    const fileSystem = await getFileSystem(path);
-    const sourceCode = await readFile(path, 'utf8');
-    return this.compileBySourceCode(sourceCode, fileSystem);
-  }
-
-  override async generateAci(path: string): Promise<Aci> {
-    const fileSystem = await getFileSystem(path);
-    const sourceCode = await readFile(path, 'utf8');
-    return this.generateAciBySourceCode(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

@@ -1,42 +0,0 @@
-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/delegation-signature.ts

@@ -1,88 +0,0 @@
-import { decode, Encoded } from '../utils/encoder';
-import { ArgumentError } from '../utils/errors';
-import { AensName } from '../tx/builder/constants';
-import AccountBase from '../account/Base';
-import { isNameValid } from '../tx/builder/helpers';
-import Node from '../Node';
-
-function ensureOracleQuery(oq: string): asserts oq is Encoded.OracleQueryId {
-  if (!oq.startsWith('oq_')) throw new ArgumentError('oq', 'oracle query', oq);
-}
-
-/**
- * Helper to generate a signature to delegate
- *  - pre-claim/claim/transfer/revoke of a name to a contract.
- *  - register/extend/respond of an Oracle to a contract.
- * @category contract
- * @param contractAddress - Address of contract to delegate access
- * @param ids - The list of id's to prepend
- * @param options - Options
- * @param options.omitAddress - Prepend delegation signature with an account address
- * @param options.onAccount - Account to use
- * @param options.onNode - Node to use
- * @returns Signature
- * @deprecated use methods `sign*DelegationToContract` of Account instance instead
- * @example
- * ```js
- * const aeSdk = new AeSdk({ ... })
- * const contractAddress = 'ct_asd2ks...'
- * const aensName = 'example.chain'
- * const onAccount = new MemoryAccount(...) // Sign with a specific account
- * // Preclaim signature
- * const preclaimSig = await aeSdk.createDelegationSignature(contractAddress, [], { onAccount })
- * // Claim, transfer and revoke signature
- * const aensDelegationSig = await aeSdk
- *   .createDelegationSignature(contractAddress, [aensName], { onAccount })
- *
- * const oracleQueryId = 'oq_...'
- * const onAccount = new MemoryAccount(...) // Sign with a specific account
- * // Oracle register and extend signature
- * const oracleDelegationSig = await aeSdk
- *   .createDelegationSignature(contractAddress, [], { onAccount })
- * // Oracle respond signature
- * const respondSig = await aeSdk
- *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
- * ```
- */
-export default async function createDelegationSignature(
-  contractAddress: Encoded.ContractAddress,
-  ids: Array<Encoded.Any | AensName>,
-  {
-    onAccount, omitAddress, isOracle, ...options
-  }: {
-    omitAddress?: boolean;
-    onAccount: AccountBase;
-    isOracle?: boolean;
-    onNode: Node;
-  },
-): Promise<Uint8Array> {
-  if (ids.length > 1) throw new ArgumentError('ids', 'shorter than 2', ids);
-  const { nodeNetworkId, consensusProtocolVersion } = await options.onNode.getNodeInfo();
-  const signOpts = { networkId: nodeNetworkId, consensusProtocolVersion };
-  if (ids.length === 0) {
-    if (omitAddress === true) {
-      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
-    }
-    return decode(
-      await onAccount.signDelegationToContract(contractAddress, { ...signOpts, isOracle }),
-    );
-  }
-
-  const [payload] = ids;
-  if (isNameValid(payload)) {
-    if (omitAddress === true) {
-      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
-    }
-    return decode(
-      await onAccount.signNameDelegationToContract(contractAddress, payload, signOpts),
-    );
-  }
-
-  ensureOracleQuery(payload);
-  if (omitAddress !== true) {
-    throw new ArgumentError('omitAddress', 'equal true', omitAddress);
-  }
-  return decode(
-    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, signOpts),
-  );
-}