@aeternity/aepp-sdk 12.1.3 → 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

@@ -19,55 +19,34 @@
  * Generalized Account module - routines to use generalized account
  */
 
-import { MAX_AUTH_FUN_GAS, TxSchema } from '../tx/builder/schema';
 import { Tag } from '../tx/builder/constants';
-import {
-  buildContractIdByContractTx, buildTx, BuiltTx, TxUnpacked, unpackTx,
-} from '../tx/builder';
-import {
-  _buildTx, BuildTxOptions, getVmVersion, prepareTxParams,
-} from '../tx';
+import { buildContractIdByContractTx } from '../tx/builder';
+import { _buildTx, BuildTxOptions } from '../tx';
 import { hash } from '../utils/crypto';
-import { decode, Encoded, Encoding } from '../utils/encoder';
-import { IllegalArgumentError, MissingParamError, InvalidAuthDataError } from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { IllegalArgumentError } from '../utils/errors';
 import { concatBuffers } from '../utils/other';
 import AccountBase from '../account/Base';
-import { getContractInstance } from './methods';
+import Contract from './Contract';
 import { send, SendOptions } from '../spend';
 import Node from '../Node';
 import { getAccount } from '../chain';
-import Compiler from './Compiler';
-
-/**
- * Check if account is GA
- * @category contract
- * @param address - Account address
- * @param options - Options
- * @returns if account is GA
- */
-export async function isGA(
-  address: Encoded.AccountAddress,
-  options: Parameters<typeof getAccount>[1],
-): Promise<boolean> {
-  const { contractId } = await getAccount(address, options);
-  return contractId != null;
-}
+import CompilerBase from './compiler/Base';
 
 /**
  * Convert current account to GA
  * @category contract
  * @param authFnName - Authorization function name
- * @param source - Auth contract source code
+ * @param sourceCode - Auth contract source code
  * @param args - init arguments
  * @param options - Options
  * @returns General Account Object
  */
 export async function createGeneralizedAccount(
   authFnName: string,
-  source: string,
   args: any[],
   {
-    onAccount, onCompiler, onNode, ...options
+    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem, ...options
   }: CreateGeneralizedAccountOptions,
 ): Promise<Readonly<{
     owner: Encoded.AccountAddress;
@@ -75,20 +54,22 @@ export async function createGeneralizedAccount(
     rawTx: Encoded.Transaction;
     gaContractId: Encoded.ContractAddress;
   }>> {
-  const ownerId = await onAccount.address(options);
-  if (await isGA(ownerId, { onNode })) throw new IllegalArgumentError(`Account ${ownerId} is already GA`);
+  const ownerId = onAccount.address;
+  if ((await getAccount(ownerId, { onNode })).kind === 'generalized') {
+    throw new IllegalArgumentError(`Account ${ownerId} is already GA`);
+  }
 
-  const contract = await getContractInstance({
-    onAccount, onCompiler, onNode, source,
+  const contract = await Contract.initialize<{ init: (...a: any[]) => void }>({
+    onAccount, onCompiler, onNode, bytecode, aci, sourceCodePath, sourceCode, fileSystem,
   });
 
   const tx = await _buildTx(Tag.GaAttachTx, {
     ...options,
     onNode,
-    code: await contract.compile(),
+    code: await contract.$compile(),
     gasLimit: options.gasLimit ?? await contract._estimateGas('init', args, options),
     ownerId,
-    callData: contract.calldata.encode(contract._name, 'init', args),
+    callData: contract._calldata.encode(contract._name, 'init', args),
     authFun: hash(authFnName),
   });
   const contractId = buildContractIdByContractTx(tx);
@@ -106,80 +87,17 @@ 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: Compiler;
+  onCompiler: CompilerBase;
   onNode: Node;
   gasLimit?: number;
 }
 
-/**
- * Create a metaTx transaction
- * @category contract
- * @param rawTransaction - Inner transaction
- * @param authData - Object with gaMeta params
- * @param authFnName - Authorization function name
- * @param options - Options
- * @param options.onAccount - Account to use
- * @returns Transaction string
- */
-export async function createMetaTx(
-  rawTransaction: Encoded.Transaction,
-  authData: {
-    gasLimit?: number;
-    callData?: Encoded.ContractBytearray;
-    source?: string;
-    args?: any[];
-  },
-  authFnName: string,
-  {
-    onAccount, onCompiler, onNode, ...options
-  }:
-  { onAccount: AccountBase; onCompiler: Compiler; onNode: Node }
-  & Parameters<AccountBase['address']>[0],
-): Promise<Encoded.Transaction> {
-  const wrapInEmptySignedTx = (
-    tx: Encoded.Transaction | Uint8Array | TxUnpacked<TxSchema>,
-  ): BuiltTx<TxSchema, Encoding.Transaction> => (
-    buildTx({ encodedTx: tx, signatures: [] }, Tag.SignedTx)
-  );
-
-  if (Object.keys(authData).length <= 0) throw new MissingParamError('authData is required');
-
-  const gasLimit = authData.gasLimit ?? MAX_AUTH_FUN_GAS;
-  if (gasLimit > MAX_AUTH_FUN_GAS) {
-    throw new InvalidAuthDataError(`the maximum gasLimit value for ga authFun is ${MAX_AUTH_FUN_GAS}, got ${gasLimit}`);
-  }
-
-  const authCallData = authData.callData ?? await (async () => {
-    if (authData.source == null || authData.args == null) throw new InvalidAuthDataError('Auth data must contain source code and arguments.');
-    const contract = await getContractInstance({
-      onCompiler, onNode, source: authData.source,
-    });
-    return contract.calldata.encode(contract._name, authFnName, authData.args);
-  })();
-
-  const { abiVersion } = await getVmVersion(Tag.ContractCallTx, { onNode });
-  const wrappedTx = wrapInEmptySignedTx(unpackTx<Tag.SignedTx>(rawTransaction));
-  const params = {
-    ...options,
-    tx: {
-      ...wrappedTx,
-      tx: wrappedTx.txObject,
-    },
-    // TODO: accept an address instead
-    gaId: await onAccount.address(options),
-    abiVersion,
-    authData: authCallData,
-    gasLimit,
-    vsn: 2,
-  };
-  // @ts-expect-error createMetaTx needs to be integrated into tx builder
-  const { fee } = await prepareTxParams(Tag.GaMetaTx, { ...params, onNode });
-  const { rlpEncoded: metaTxRlp } = buildTx({ ...params, fee }, Tag.GaMetaTx);
-  return wrapInEmptySignedTx(metaTxRlp).tx;
-}
-
 /**
  * Build a transaction hash the same as `Auth.tx_hash`
  * @category contract
@@ -192,8 +110,7 @@ export async function buildAuthTxHash(
   transaction: Encoded.Transaction,
   { onNode }: { onNode: Node },
 ): Promise<Uint8Array> {
-  const { networkId } = await onNode.getStatus();
   return new Uint8Array(hash(
-    concatBuffers([Buffer.from(networkId), decode(transaction)]),
+    concatBuffers([Buffer.from(await onNode.getNetworkId()), decode(transaction)]),
   ));
 }

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,56 +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 './tx/builder/address';
-export * from './utils/amount-formatter';
-export * from './utils/hd-wallet';
-export {
-  sha256hash, encode, decode, Encoding,
-} from './utils/encoder';
-export * from './aens';
-export * from './contract/methods';
-export * from './oracle';
-export * from './spend';
-export * from './contract/ga';
-export * from './deprecated';
-
-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 Compiler } from './contract/Compiler';
-export { default as Channel } from './channel';
-
-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';