@aeternity/aepp-sdk 13.2.2 → 13.3.1

package/src/contract/Contract.ts

@@ -6,8 +6,9 @@
  */
 
 import { Encoder as Calldata } from '@aeternity/aepp-calldata';
-import { DRY_RUN_ACCOUNT } from '../tx/builder/schema';
-import { Tag, AensName } from '../tx/builder/constants';
+import {
+  Tag, AensName, ConsensusProtocolVersion, DRY_RUN_ACCOUNT,
+} from '../tx/builder/constants';
 import {
   buildContractIdByContractTx, unpackTx, buildTxAsync, BuildTxOptions, buildTxHash,
 } from '../tx/builder';
@@ -39,12 +40,13 @@ import {
 import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
 import {
-  getAccount, getContract, getContractByteCode, resolveName, txDryRun, sendTransaction,
-  SendTransactionOptions,
+  getAccount, getContract, getContractByteCode, resolveName, txDryRun,
 } from '../chain';
+import { sendTransaction, SendTransactionOptions } from '../send-transaction';
 import AccountBase from '../account/Base';
 import { TxUnpacked } from '../tx/builder/schema.generated';
 import { isAccountNotFoundError } from '../utils/other';
+import { isNameValid, produceNameId } from '../tx/builder/helpers';
 
 type ContractAci = NonNullable<Aci[0]['contract']>;
 type FunctionAci = ContractAci['functions'][0];
@@ -246,6 +248,7 @@ class Contract<M extends ContractMethodsBase> {
     const ownerId = opt.onAccount.address;
     if (this.$options.bytecode == null) throw new IllegalArgumentError('Can\'t deploy without bytecode');
     const tx = await buildTxAsync({
+      _isInternalBuild: true,
       ...opt,
       tag: Tag.ContractCreateTx,
       gasLimit: opt.gasLimit ?? await this._estimateGas('init', params, opt),
@@ -258,7 +261,7 @@ class Contract<M extends ContractMethodsBase> {
       'init',
       { ...opt, onAccount: opt.onAccount },
     );
-    this.$options.address = buildContractIdByContractTx(tx);
+    this.$options.address = buildContractIdByContractTx(other.rawTx);
     return {
       ...other,
       ...other.result?.log != null && {
@@ -287,7 +290,7 @@ class Contract<M extends ContractMethodsBase> {
         arguments: [], name: 'init', payable: false, returns: 'unit', stateful: true,
       };
     }
-    throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`);
+    throw new NoSuchContractFunctionError(name);
   }
 
   /**
@@ -308,7 +311,9 @@ class Contract<M extends ContractMethodsBase> {
   ): Promise<SendAndProcessReturnType & Partial<GetCallResultByHashReturnType<M, Fn>>> {
     const { callStatic, top, ...opt } = { ...this.$options, ...options };
     const fnAci = this.#getFunctionAci(fn);
-    const contractId = this.$options.address;
+    const { address, name } = this.$options;
+    // TODO: call `produceNameId` on buildTx side
+    const contractId = name != null ? produceNameId(name) : address;
     const { onNode } = opt;
 
     if (fn == null) throw new MissingFunctionNameError();
@@ -375,6 +380,7 @@ class Contract<M extends ContractMethodsBase> {
     if (top != null) throw new IllegalArgumentError('Can\'t handle `top` option in on-chain contract call');
     if (contractId == null) throw new MissingContractAddressError('Can\'t call contract without address');
     const tx = await buildTxAsync({
+      _isInternalBuild: true,
       ...opt,
       tag: Tag.ContractCallTx,
       gasLimit: opt.gasLimit ?? await this._estimateGas(fn, params, opt),
@@ -485,12 +491,16 @@ class Contract<M extends ContractMethodsBase> {
     }
     if (aci == null) throw new MissingContractDefError();
 
+    let name;
     if (address != null) {
       address = await resolveName(
         address,
         'contract_pubkey',
         { resolveByNode: true, onNode },
       ) as Encoded.ContractAddress;
+      const isIris = (await onNode.getNodeInfo())
+        .consensusProtocolVersion === ConsensusProtocolVersion.Iris;
+      if (!isIris && isNameValid(address)) name = address;
     }
 
     if (address == null && sourceCode == null && sourceCodePath == null && bytecode == null) {
@@ -527,6 +537,7 @@ class Contract<M extends ContractMethodsBase> {
       bytecode,
       aci,
       address,
+      name,
       fileSystem,
       ...otherOptions,
     });
@@ -534,7 +545,7 @@ class Contract<M extends ContractMethodsBase> {
 
   _aci: Aci;
 
-  #aciContract: ContractAci;
+  readonly #aciContract: ContractAci;
 
   _name: string;
 
@@ -542,12 +553,19 @@ class Contract<M extends ContractMethodsBase> {
 
   $options: Omit<ConstructorParameters<typeof Contract>[0], 'aci'>;
 
+  /**
+   * @param options - Options
+   */
   constructor({ aci, ...otherOptions }: {
     onCompiler?: CompilerBase;
     onNode: Node;
     bytecode?: Encoded.ContractBytearray;
     aci: Aci;
     address?: Encoded.ContractAddress;
+    /**
+     * Supported only in Ceres
+     */
+    name?: AensName;
     sourceCodePath?: Parameters<CompilerBase['compile']>[0];
     sourceCode?: Parameters<CompilerBase['compileBySourceCode']>[0];
     fileSystem?: Parameters<CompilerBase['compileBySourceCode']>[1];

package/src/contract/compiler/Base.ts

@@ -19,6 +19,19 @@ export type Aci = Array<{
   };
 }>;
 
+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
  */
@@ -29,10 +42,7 @@ export default abstract class CompilerBase {
    * @param path - Path to contract source code
    * @returns ACI and bytecode
    */
-  abstract compile(path: string): Promise<{
-    bytecode: Encoded.ContractBytearray;
-    aci: Aci;
-  }>;
+  abstract compile(path: string): CompileResult;
 
   /**
    * Compile contract by contract's source code
@@ -50,10 +60,7 @@ export default abstract class CompilerBase {
   abstract compileBySourceCode(
     sourceCode: string,
     fileSystem?: Record<string, string>,
-  ): Promise<{
-    bytecode: Encoded.ContractBytearray;
-    aci: Aci;
-  }>;
+  ): CompileResult;
 
   /**
    * Generate contract's ACI by contract's path

package/src/contract/compiler/Cli.ts

@@ -3,13 +3,13 @@ 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 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';
 
-const getPackagePath = (): string => {
+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, '../../..');
@@ -19,11 +19,12 @@ const getPackagePath = (): string => {
 /**
  * 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 {
-  #path: string;
+  readonly #path: string;
 
-  #ensureCompatibleVersion = Promise.resolve();
+  readonly #ensureCompatibleVersion = Promise.resolve();
 
   /**
    * @param compilerPath - A path to aesophia_cli binary, by default uses the integrated one
@@ -38,22 +39,27 @@ export default class CompilerCli extends CompilerBase {
     this.#path = compilerPath;
     if (ignoreVersion !== true) {
       this.#ensureCompatibleVersion = this.version().then((version) => {
-        const versions = [version, '7.2.1', '8.0.0'] as const;
+        const versions = [version, '7.2.1', '9.0.0'] as const;
         if (!semverSatisfies(...versions)) throw new UnsupportedVersionError('compiler', ...versions);
       });
     }
   }
 
-  async #run(...parameters: string[]): Promise<string> {
+  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 if (stderr !== '') pReject(new CompilerError(stderr));
-        else pResolve(stdout);
+        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> = {},
@@ -72,19 +78,29 @@ export default class CompilerCli extends CompilerBase {
     return sourceCodePath;
   }
 
-  async compile(path: string): Promise<{
-    bytecode: Encoded.ContractBytearray;
-    aci: Aci;
-  }> {
+  async compile(path: string): CompileResult {
     await this.#ensureCompatibleVersion;
     try {
-      const [bytecode, aci] = await Promise.all([
-        this.#run(path),
-        this.#run('--create_json_aci', path).then((res) => JSON.parse(res)),
+      const [compileRes, aci] = await Promise.all([
+        this.#runWithStderr(path),
+        this.generateAci(path),
       ]);
       return {
-        bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
+        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);
@@ -92,10 +108,10 @@ export default class CompilerCli extends CompilerBase {
     }
   }
 
-  async compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-    bytecode: Encoded.ContractBytearray;
-    aci: Aci;
-  }> {
+  async compileBySourceCode(
+    sourceCode: string,
+    fileSystem?: Record<string, string>,
+  ): CompileResult {
     const tmp = await CompilerCli.#saveContractToTmpDir(sourceCode, fileSystem);
     try {
       return await this.compile(tmp);
@@ -150,7 +166,7 @@ export default class CompilerCli extends CompilerBase {
 
   async version(): Promise<string> {
     const verMessage = await this.#run('--version');
-    const ver = verMessage.match(/Sophia compiler version ([\d.]+)\n/)?.[1];
+    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

@@ -0,0 +1,17 @@
+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,11 +1,14 @@
-import { RestError } from '@azure/core-rest-pipeline';
+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 } from './Base';
+import CompilerBase, { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 import { CompilerError, NotImplementedError } from '../../utils/errors';
 
@@ -29,11 +32,20 @@ export default class CompilerHttp extends CompilerBase {
    * @param options - Options
    * @param options.ignoreVersion - Don't check compiler version
    */
-  constructor(compilerUrl: string, { ignoreVersion }: { ignoreVersion?: boolean } = {}) {
+  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) {
@@ -51,23 +63,21 @@ export default class CompilerHttp extends CompilerBase {
         }),
       ],
     });
-    if (ignoreVersion !== true) {
-      const versionPromise = this.api.apiVersion()
-        .then(({ apiVersion }) => apiVersion, (error) => error);
-      this.api.pipeline.addPolicy(
-        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.3.0', '8.0.0'),
-      );
-    }
+    this.api.pipeline.removePolicy({ name: userAgentPolicyName });
+    this.api.pipeline.removePolicy({ name: setClientRequestIdPolicyName });
   }
 
   async compileBySourceCode(
     sourceCode: string,
     fileSystem?: Record<string, string>,
-  ): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+  ): CompileResult {
     try {
-      const res = await this.api.compileContract({ code: sourceCode, options: { fileSystem } });
+      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 { bytecode: Encoded.ContractBytearray; aci: Aci };
+      return res as Awaited<CompileResult>;
     } catch (error) {
       if (error instanceof RestError && error.statusCode === 400) {
         throw new CompilerError(error.message);
@@ -77,7 +87,7 @@ export default class CompilerHttp extends CompilerBase {
   }
 
   // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  async compile(path: string): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+  async compile(path: string): CompileResult {
     throw new NotImplementedError('File system access, use CompilerHttpNode instead');
   }
 

package/src/contract/compiler/HttpNode.ts

@@ -1,6 +1,6 @@
 import { readFile } from 'fs/promises';
 import HttpBrowser from './Http';
-import { Aci } from './Base';
+import { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 import getFileSystem from './getFileSystem';
 
@@ -12,7 +12,7 @@ import getFileSystem from './getFileSystem';
  * @example CompilerHttpNode('COMPILER_URL')
  */
 export default class CompilerHttpNode extends HttpBrowser {
-  override async compile(path: string): Promise<{ bytecode: Encoded.ContractBytearray; aci: Aci }> {
+  override async compile(path: string): CompileResult {
     const fileSystem = await getFileSystem(path);
     const sourceCode = await readFile(path, 'utf8');
     return this.compileBySourceCode(sourceCode, fileSystem);

package/src/contract/delegation-signature.ts

@@ -47,19 +47,25 @@ function ensureOracleQuery(oq: string): asserts oq is Encoded.OracleQueryId {
 export default async function createDelegationSignature(
   contractAddress: Encoded.ContractAddress,
   ids: Array<Encoded.Any | AensName>,
-  { onAccount, omitAddress, ...options }: {
+  {
+    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 networkId = await options.onNode.getNetworkId();
+  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, { networkId }));
+    return decode(
+      await onAccount.signDelegationToContract(contractAddress, { ...signOpts, isOracle }),
+    );
   }
 
   const [payload] = ids;
@@ -68,7 +74,7 @@ export default async function createDelegationSignature(
       throw new ArgumentError('omitAddress', 'equal false', omitAddress);
     }
     return decode(
-      await onAccount.signNameDelegationToContract(contractAddress, payload, { networkId }),
+      await onAccount.signNameDelegationToContract(contractAddress, payload, signOpts),
     );
   }
 
@@ -77,6 +83,6 @@ export default async function createDelegationSignature(
     throw new ArgumentError('omitAddress', 'equal true', omitAddress);
   }
   return decode(
-    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, { networkId }),
+    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, signOpts),
   );
 }

package/src/contract/ga.ts

@@ -15,14 +15,14 @@ import { concatBuffers } from '../utils/other';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
 import Node from '../Node';
-import { sendTransaction, SendTransactionOptions, getAccount } from '../chain';
+import { getAccount } from '../chain';
+import { sendTransaction, SendTransactionOptions } from '../send-transaction';
 import CompilerBase from './compiler/Base';
 
 /**
  * Convert current account to GA
  * @category contract
  * @param authFnName - Authorization function name
- * @param sourceCode - Auth contract source code
  * @param args - init arguments
  * @param options - Options
  * @returns General Account Object
@@ -49,6 +49,7 @@ export async function createGeneralizedAccount(
   });
 
   const tx = await buildTxAsync({
+    _isInternalBuild: true,
     ...options,
     tag: Tag.GaAttachTx,
     onNode,
@@ -58,10 +59,10 @@ export async function createGeneralizedAccount(
     callData: contract._calldata.encode(contract._name, 'init', args),
     authFun: hash(authFnName),
   });
-  const contractId = buildContractIdByContractTx(tx);
   const { hash: transaction, rawTx } = await sendTransaction(tx, {
     onNode, onAccount, onCompiler, ...options,
   });
+  const contractId = buildContractIdByContractTx(rawTx);
 
   return Object.freeze({
     owner: ownerId,

package/src/deprecated.ts

@@ -2,6 +2,7 @@ import { TypeResolver, ContractByteArrayEncoder } from '@aeternity/aepp-calldata
 import { AciValue } from './utils/typed-data';
 import { Encoded } from './utils/encoder';
 import { RpcError } from './aepp-wallet-communication/schema';
+import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 
 /**
  * @category exception
@@ -39,3 +40,38 @@ export function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue)
   const valueType = new TypeResolver().resolveType(aci, {});
   return new ContractByteArrayEncoder().decodeWithType(value, valueType);
 }
+
+/**
+ * @deprecated inlined in buildTx or use `180000`
+ */
+export const NAME_TTL = 180000;
+
+/**
+ * @deprecated inlined in buildTx or use `36000`
+ */
+export const NAME_MAX_TTL = 36000;
+
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export const NAME_MAX_CLIENT_TTL = 60 * 60;
+
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export const CLIENT_TTL = NAME_MAX_CLIENT_TTL;
+
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 500 }`
+ */
+export const ORACLE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 500 };
+
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export const QUERY_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };
+
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export const RESPONSE_TTL = { type: ORACLE_TTL_TYPES.delta, value: 10 };

package/src/index-browser.ts

@@ -1,14 +1,19 @@
 export {
-  _getPollInterval, InvalidTxError, getHeight, poll, awaitHeight, waitForTxConfirm, sendTransaction,
+  _getPollInterval, getHeight, poll, awaitHeight, waitForTxConfirm,
   getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions,
   getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName,
   resolveName,
 } from './chain';
+export { InvalidTxError, sendTransaction } from './send-transaction';
 export {
   getAddressFromPriv, isAddressValid, genSalt, encodeUnsigned, hash, encodeContractAddress,
   generateKeyPairFromSecret, generateKeyPair, sign, verify, messageToHash, signMessage,
   verifyMessage, isValidKeypair,
 } from './utils/crypto';
+export {
+  signJwt, unpackJwt, verifyJwt, isJwt, ensureJwt,
+} from './utils/jwt';
+export type { Jwt } from './utils/jwt';
 export { recover, dump } from './utils/keystore';
 export type { Keystore } from './utils/keystore';
 export { toBytes } from './utils/bytes';
@@ -20,15 +25,15 @@ export {
   getDefaultPointerKey, getMinimumNameFee, computeBidFee, computeAuctionEndBlock, isAuctionName,
 } from './tx/builder/helpers';
 export {
-  MAX_AUTH_FUN_GAS, NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL, MIN_GAS_PRICE,
+  MAX_AUTH_FUN_GAS, MIN_GAS_PRICE,
   NAME_FEE_MULTIPLIER, NAME_FEE_BID_INCREMENT, NAME_BID_TIMEOUT_BLOCKS, NAME_MAX_LENGTH_FEE,
-  NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag,
+  NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag, DRY_RUN_ACCOUNT,
 } from './tx/builder/constants';
 export type { Int, AensName } 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 { ORACLE_TTL_TYPES, CallReturnType } from './tx/builder/schema';
+export { DelegationTag } from './tx/builder/delegation/schema';
+export { packDelegation, unpackDelegation } from './tx/builder/delegation';
 export {
   getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode,
 } from './tx/execution-cost';
@@ -93,7 +98,7 @@ export {
   CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError,
   ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError,
   RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError,
-  UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, InternalError,
+  UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, LogicError, InternalError,
   UnexpectedTsError, UnavailableAccountError, AensPointerContextError, InsufficientNameFeeError,
   InvalidAensNameError, InvalidRpcMessageError, MissingCallbackError, UnAuthorizedAccountError,
   UnknownRpcClientError, UnsubscribedAccountError, ChannelCallError, ChannelConnectionError,
@@ -111,4 +116,6 @@ export {
 } from './utils/errors';
 export {
   RpcBroadcastError, NAME_BID_MAX_LENGTH, encodeFateValue, decodeFateValue,
+  NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL,
+  ORACLE_TTL, QUERY_TTL, RESPONSE_TTL,
 } from './deprecated';

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './index-browser';
 
 export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as CompilerCli8 } from './contract/compiler/Cli8';
 export { default as getFileSystem } from './contract/compiler/getFileSystem';
 export { default as CompilerHttpNode } from './contract/compiler/HttpNode';