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

package/src/contract/compiler/Base.ts

@@ -0,0 +1,87 @@
+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[];
+  };
+}>;
+
+/**
+ * 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): Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: Aci;
+  }>;
+
+  /**
+   * 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>,
+  ): Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: 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

@@ -0,0 +1,128 @@
+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;
+    try {
+      const [bytecode, aci] = await Promise.all([
+        this.#run(path),
+        this.#run('--create_json_aci', path).then((res) => JSON.parse(res)),
+      ]);
+      return {
+        bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
+        aci: aci as Aci,
+      };
+    } catch (error) {
+      throw new CompilerError(error.message);
+    }
+  }
+
+  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,105 @@
+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, (error) => error);
+      this.api.pipeline.addPolicy(
+        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.1.1', '8.0.0'),
+      );
+    }
+  }
+
+  async compileBySourceCode(
+    sourceCode: string,
+    fileSystem?: Record<string, string>,
+  ): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+    try {
+      const res = await this.api.compileContract({ code: sourceCode, options: { fileSystem } });
+      // TODO: should be fixed when the compiledAci interface gets updated
+      return res as { bytecode: Encoded.ContractBytearray; aci: 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/delegation-signature.ts

@@ -0,0 +1,56 @@
+import { decode, Encoded } from '../utils/encoder';
+import { AensName } from '../tx/builder/constants';
+import AccountBase from '../account/Base';
+import { concatBuffers } from '../utils/other';
+import { isNameValid, produceNameId } from '../tx/builder/helpers';
+import Node from '../Node';
+
+/**
+ * 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
+ * @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>,
+  options: { omitAddress?: boolean; onAccount: AccountBase; onNode: Node },
+): Promise<Uint8Array> {
+  return options.onAccount.sign(
+    concatBuffers([
+      Buffer.from(await options.onNode.getNetworkId()),
+      ...options.omitAddress === true ? [] : [decode(options.onAccount.address)],
+      ...ids.map((e) => (isNameValid(e) ? produceNameId(e) : e)).map((e) => decode(e)),
+      decode(contractAddress),
+    ]),
+    options,
+  );
+}

package/src/contract/ga.ts

@@ -1,37 +1,22 @@
-/*
- * 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.
- */
-
 /**
  * Generalized Account module - routines to use generalized account
  */
 
-import { Tag } from '../tx/builder/constants';
-import { buildContractIdByContractTx } from '../tx/builder';
-import { _buildTx, BuildTxOptions } from '../tx';
+import { ConsensusProtocolVersion, Int, Tag } from '../tx/builder/constants';
+import {
+  buildContractIdByContractTx, buildTx, buildTxAsync, BuildTxOptions, unpackTx,
+} from '../tx/builder';
 import { hash } from '../utils/crypto';
-import { decode, Encoded } from '../utils/encoder';
-import { IllegalArgumentError } from '../utils/errors';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../utils/encoder';
+import { ArgumentError, IllegalArgumentError } from '../utils/errors';
 import { concatBuffers } from '../utils/other';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
-import { send, SendOptions } from '../spend';
 import Node from '../Node';
-import { getAccount } from '../chain';
-import CompilerHttp from './CompilerHttp';
+import { sendTransaction, SendTransactionOptions, getAccount } from '../chain';
+import CompilerBase from './compiler/Base';
 
 /**
  * Convert current account to GA
@@ -44,10 +29,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,11 +45,12 @@ 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, {
+  const tx = await buildTxAsync({
     ...options,
+    tag: Tag.GaAttachTx,
     onNode,
     code: await contract.$compile(),
     gasLimit: options.gasLimit ?? await contract._estimateGas('init', args, options),
@@ -74,7 +59,7 @@ export async function createGeneralizedAccount(
     authFun: hash(authFnName),
   });
   const contractId = buildContractIdByContractTx(tx);
-  const { hash: transaction, rawTx } = await send(tx, {
+  const { hash: transaction, rawTx } = await sendTransaction(tx, {
     onNode, onAccount, onCompiler, ...options,
   });
 
@@ -88,26 +73,65 @@ export async function createGeneralizedAccount(
 
 interface CreateGeneralizedAccountOptions extends
   BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>,
-  SendOptions {
+  SendTransactionOptions,
+  Pick<
+  Parameters<typeof Contract.initialize>[0],
+  'bytecode' | 'aci' | 'sourceCodePath' | 'sourceCode' | 'fileSystem'
+  > {
   onAccount: AccountBase;
-  onCompiler: CompilerHttp;
+  onCompiler: CompilerBase;
   onNode: Node;
   gasLimit?: number;
 }
 
 /**
- * Build a transaction hash the same as `Auth.tx_hash`
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx payload
  * @category contract
  * @param transaction - tx-encoded transaction
  * @param options - Options
+ * @param options.fee - GaMetaTx fee, required in Ceres
+ * @param options.gasPrice - GaMetaTx gasPrice, required in Ceres
  * @param options.onNode - Node to use
  * @returns Transaction hash
  */
 export async function buildAuthTxHash(
+  transaction: Encoded.Transaction,
+  { fee, gasPrice, onNode }: { fee?: Int; gasPrice?: Int; onNode: Node },
+): Promise<Buffer> {
+  const { nodeNetworkId, consensusProtocolVersion } = await onNode.getNodeInfo();
+  let payload = hash(concatBuffers([Buffer.from(nodeNetworkId), decode(transaction)]));
+  if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
+    if (fee == null) throw new ArgumentError('fee', 'provided (in Ceres)', fee);
+    if (gasPrice == null) throw new ArgumentError('gasPrice', 'provided (in Ceres)', gasPrice);
+    payload = hash(decode(buildTx({
+      tag: Tag.GaMetaTxAuthData,
+      fee,
+      gasPrice,
+      txHash: encode(payload, Encoding.TxHash),
+    })));
+  }
+  return payload;
+}
+
+/**
+ * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx
+ * @category contract
+ * @param transaction - tx-encoded signed GaMeta transaction
+ * @param options - Options
+ * @param options.onNode - Node to use
+ * @returns Transaction hash
+ */
+export async function buildAuthTxHashByGaMetaTx(
   transaction: Encoded.Transaction,
   { onNode }: { onNode: Node },
-): Promise<Uint8Array> {
-  return new Uint8Array(hash(
-    concatBuffers([Buffer.from(await onNode.getNetworkId()), decode(transaction)]),
-  ));
+): Promise<Buffer> {
+  const txParams = unpackTx(transaction, Tag.SignedTx);
+  if (txParams.encodedTx.tag !== Tag.GaMetaTx) {
+    throw new ArgumentError('transaction', 'to include GaMetaTx', Tag[txParams.encodedTx.tag]);
+  }
+  return buildAuthTxHash(buildTx(txParams.encodedTx.tx.encodedTx), {
+    fee: txParams.encodedTx.fee,
+    gasPrice: txParams.encodedTx.gasPrice,
+    onNode,
+  });
 }

package/src/index-browser.ts

@@ -0,0 +1,50 @@
+// TODO: avoid `export * from`
+export * from './chain';
+export * from './utils/crypto';
+export * from './utils/keystore';
+export * from './utils/bytes';
+export {
+  buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx,
+} from './tx/builder';
+export * from './tx/builder/helpers';
+export * from './tx/builder/constants';
+// TODO: move to constants
+export {
+  ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType,
+} from './tx/builder/schema';
+export {
+  getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
+} from './tx/execution-cost';
+export { default as getTransactionSignerAddress } from './tx/transaction-signer';
+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';