@aeternity/aepp-sdk 13.0.0 → 13.1.0

package/src/apis/middleware/models/parameters.ts

@@ -0,0 +1,463 @@
+import {
+  OperationParameter,
+  OperationURLParameter,
+  OperationQueryParameter
+} from "@azure/core-client";
+
+export const accept: OperationParameter = {
+  parameterPath: "accept",
+  mapper: {
+    defaultValue: "application/json",
+    isConstant: true,
+    serializedName: "Accept",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const $host: OperationURLParameter = {
+  parameterPath: "$host",
+  mapper: {
+    serializedName: "$host",
+    required: true,
+    type: {
+      name: "String"
+    }
+  },
+  skipEncoding: true
+};
+
+export const id: OperationURLParameter = {
+  parameterPath: "id",
+  mapper: {
+    serializedName: "id",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const ownedOnly: OperationQueryParameter = {
+  parameterPath: ["options", "ownedOnly"],
+  mapper: {
+    serializedName: "owned_only",
+    type: {
+      name: "Boolean"
+    }
+  }
+};
+
+export const type: OperationQueryParameter = {
+  parameterPath: ["options", "type"],
+  mapper: {
+    serializedName: "type",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const limit: OperationQueryParameter = {
+  parameterPath: "limit",
+  mapper: {
+    defaultValue: 10,
+    constraints: {
+      InclusiveMaximum: 100,
+      InclusiveMinimum: 1
+    },
+    serializedName: "limit",
+    type: {
+      name: "Number"
+    }
+  }
+};
+
+export const scope: OperationQueryParameter = {
+  parameterPath: "scope",
+  mapper: {
+    constraints: {
+      Pattern: new RegExp("(txi|gen):\\d+(-\\d+)?")
+    },
+    serializedName: "scope",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const direction: OperationQueryParameter = {
+  parameterPath: "direction",
+  mapper: {
+    serializedName: "direction",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const by: OperationQueryParameter = {
+  parameterPath: ["options", "by"],
+  mapper: {
+    serializedName: "by",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const prefix: OperationQueryParameter = {
+  parameterPath: ["options", "prefix"],
+  mapper: {
+    serializedName: "prefix",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const accountId: OperationURLParameter = {
+  parameterPath: "accountId",
+  mapper: {
+    serializedName: "accountId",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const contractId: OperationURLParameter = {
+  parameterPath: "contractId",
+  mapper: {
+    serializedName: "contractId",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const tokenId: OperationURLParameter = {
+  parameterPath: "tokenId",
+  mapper: {
+    serializedName: "tokenId",
+    required: true,
+    type: {
+      name: "Number"
+    }
+  }
+};
+
+export const templateId: OperationURLParameter = {
+  parameterPath: "templateId",
+  mapper: {
+    serializedName: "templateId",
+    required: true,
+    type: {
+      name: "Number"
+    }
+  }
+};
+
+export const accountId1: OperationURLParameter = {
+  parameterPath: "accountId",
+  mapper: {
+    serializedName: "account_id",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const sender: OperationURLParameter = {
+  parameterPath: "sender",
+  mapper: {
+    serializedName: "sender",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const recipient: OperationURLParameter = {
+  parameterPath: "recipient",
+  mapper: {
+    serializedName: "recipient",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const hash: OperationQueryParameter = {
+  parameterPath: "hash",
+  mapper: {
+    serializedName: "hash",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const hashOrKbi: OperationURLParameter = {
+  parameterPath: "hashOrKbi",
+  mapper: {
+    serializedName: "hash_or_kbi",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const kbi: OperationURLParameter = {
+  parameterPath: "kbi",
+  mapper: {
+    serializedName: "kbi",
+    required: true,
+    type: {
+      name: "Number"
+    }
+  }
+};
+
+export const mbi: OperationURLParameter = {
+  parameterPath: "mbi",
+  mapper: {
+    serializedName: "mbi",
+    required: true,
+    type: {
+      name: "Number"
+    }
+  }
+};
+
+export const state: OperationQueryParameter = {
+  parameterPath: ["options", "state"],
+  mapper: {
+    serializedName: "state",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const contractId1: OperationQueryParameter = {
+  parameterPath: ["options", "contractId"],
+  mapper: {
+    serializedName: "contract_id",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const event: OperationQueryParameter = {
+  parameterPath: ["options", "event"],
+  mapper: {
+    serializedName: "event",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const functionPrefix: OperationQueryParameter = {
+  parameterPath: ["options", "functionPrefix"],
+  mapper: {
+    serializedName: "function_prefix",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const data: OperationQueryParameter = {
+  parameterPath: ["options", "data"],
+  mapper: {
+    serializedName: "data",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const aexnArgs: OperationQueryParameter = {
+  parameterPath: ["options", "aexnArgs"],
+  mapper: {
+    serializedName: "aexn-args",
+    type: {
+      name: "Boolean"
+    }
+  }
+};
+
+export const hash1: OperationURLParameter = {
+  parameterPath: "hash",
+  mapper: {
+    serializedName: "hash",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const ownedBy: OperationQueryParameter = {
+  parameterPath: ["options", "ownedBy"],
+  mapper: {
+    serializedName: "owned_by",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const state1: OperationQueryParameter = {
+  parameterPath: ["options", "state"],
+  mapper: {
+    serializedName: "state",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const type1: OperationQueryParameter = {
+  parameterPath: ["options", "type"],
+  mapper: {
+    serializedName: "type",
+    type: {
+      name: "Sequence",
+      element: {
+        type: {
+          name: "String"
+        }
+      }
+    }
+  },
+  collectionFormat: "Multi"
+};
+
+export const typeGroup: OperationQueryParameter = {
+  parameterPath: ["options", "typeGroup"],
+  mapper: {
+    serializedName: "type_group",
+    type: {
+      name: "Sequence",
+      element: {
+        type: {
+          name: "String"
+        }
+      }
+    }
+  },
+  collectionFormat: "Multi"
+};
+
+export const account: OperationQueryParameter = {
+  parameterPath: ["options", "account"],
+  mapper: {
+    serializedName: "account",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const contract: OperationQueryParameter = {
+  parameterPath: ["options", "contract"],
+  mapper: {
+    serializedName: "contract",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const channel: OperationQueryParameter = {
+  parameterPath: ["options", "channel"],
+  mapper: {
+    serializedName: "channel",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const oracle: OperationQueryParameter = {
+  parameterPath: ["options", "oracle"],
+  mapper: {
+    serializedName: "oracle",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const senderId: OperationQueryParameter = {
+  parameterPath: ["options", "senderId"],
+  mapper: {
+    serializedName: "sender_id",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const recipientId: OperationQueryParameter = {
+  parameterPath: ["options", "recipientId"],
+  mapper: {
+    serializedName: "recipient_id",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const entrypoint: OperationQueryParameter = {
+  parameterPath: ["options", "entrypoint"],
+  mapper: {
+    serializedName: "entrypoint",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const txType: OperationQueryParameter = {
+  parameterPath: ["options", "txType"],
+  mapper: {
+    serializedName: "tx_type",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const id1: OperationQueryParameter = {
+  parameterPath: ["options", "id"],
+  mapper: {
+    serializedName: "id",
+    type: {
+      name: "String"
+    }
+  }
+};
+
+export const hashOrIndex: OperationURLParameter = {
+  parameterPath: "hashOrIndex",
+  mapper: {
+    serializedName: "hash_or_index",
+    required: true,
+    type: {
+      name: "String"
+    }
+  }
+};

package/src/chain.ts

@@ -1,6 +1,6 @@
 import { AE_AMOUNT_FORMATS, formatAmount } from './utils/amount-formatter';
 import verifyTransaction, { ValidatorResult } from './tx/validator';
-import { isAccountNotFoundError, pause } from './utils/other';
+import { ensureError, isAccountNotFoundError, pause } from './utils/other';
 import { isNameValid, produceNameId } from './tx/builder/helpers';
 import { DRY_RUN_ACCOUNT } from './tx/builder/schema';
 import { AensName } from './tx/builder/constants';
@@ -23,7 +23,7 @@ import { buildTxHash } from './tx/builder';
  * @category chain
  */
 export function _getPollInterval(
-  type: 'block' | 'microblock',
+  type: 'block' | 'microblock', // TODO: rename to 'key-block' | 'micro-block'
   { _expectedMineRate = 180000, _microBlockCycle = 3000, _maxPollInterval = 5000 }:
   { _expectedMineRate?: number; _microBlockCycle?: number; _maxPollInterval?: number },
 ): number {
@@ -208,6 +208,7 @@ export async function sendTransaction(
     }
     return { hash: txHash, rawTx: tx };
   } catch (error) {
+    ensureError(error);
     throw Object.assign(error, {
       rawTx: tx,
       verifyTx: async () => verifyTransaction(tx, onNode),

package/src/channel/Base.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from 'events';
+import EventEmitter from 'events';
 import { w3cwebsocket as W3CWebSocket } from 'websocket';
 import { snakeToPascal } from '../utils/string';
 import { buildTx, unpackTx } from '../tx/builder';
@@ -55,7 +55,7 @@ function snakeToPascalObjKeys<Type>(obj: object): Type {
 export default class Channel {
   _eventEmitter = new EventEmitter();
 
-  _pingTimeoutId: NodeJS.Timeout;
+  _pingTimeoutId!: NodeJS.Timeout;
 
   _nextRpcMessageId = 0;
 
@@ -73,13 +73,13 @@ export default class Channel {
 
   _status: ChannelStatus = 'disconnected';
 
-  _fsm: ChannelFsm;
+  _fsm!: ChannelFsm;
 
-  _websocket: W3CWebSocket;
+  _websocket!: W3CWebSocket;
 
   _state: Encoded.Transaction | '' = '';
 
-  _options: ChannelOptions;
+  _options!: ChannelOptions;
 
   _channelId?: Encoded.Channel;
 

package/src/channel/internal.ts

@@ -15,6 +15,7 @@ import {
 } from '../utils/errors';
 import { encodeContractAddress } from '../utils/crypto';
 import { buildTx } from '../tx/builder';
+import { ensureError } from '../utils/other';
 
 export interface ChannelEvents {
   statusChanged: (status: ChannelStatus) => void;
@@ -240,6 +241,7 @@ async function dequeueMessage(channel: Channel): Promise<void> {
     try {
       await handleMessage(channel, message);
     } catch (error) {
+      ensureError(error);
       emit(channel, 'error', new ChannelIncomingMessageError(error, message));
     }
   }

package/src/contract/Contract.ts

@@ -72,7 +72,7 @@ type TxData = Awaited<ReturnType<typeof sendTransaction>>;
 interface SendAndProcessReturnType {
   result?: ContractCallObject;
   hash: TxData['hash'];
-  tx: TxUnpacked & { tag: Tag.ContractCallTx | Tag.ContractCreateTx };
+  tx: TxUnpacked & { tag: Tag.SignedTx | Tag.ContractCallTx | Tag.ContractCreateTx };
   txData: TxData;
   rawTx: Encoded.Transaction;
 }
@@ -324,6 +324,7 @@ class Contract<M extends ContractMethodsBase> {
       const useFallbackAccount = callStatic === true && (
         (error instanceof TypeError && error.message === 'Account should be an address (ak-prefixed string), or instance of AccountBase, got undefined instead')
         || (error instanceof NoWalletConnectedError)
+        || (error instanceof InternalError && error.message === 'Use fallback account')
       );
       if (!useFallbackAccount) throw error;
       callerId = DRY_RUN_ACCOUNT.pub;

package/src/contract/compiler/Base.ts

@@ -55,6 +55,32 @@ export default abstract class CompilerBase {
     aci: Aci;
   }>;
 
+  /**
+   * 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

package/src/contract/compiler/Cli.ts

@@ -7,6 +7,7 @@ import CompilerBase, { Aci } 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 => {
   const path = dirname(fileURLToPath(import.meta.url));
@@ -22,7 +23,7 @@ const getPackagePath = (): string => {
 export default class CompilerCli extends CompilerBase {
   #path: string;
 
-  #ensureCompatibleVersion: Promise<void>;
+  #ensureCompatibleVersion = Promise.resolve();
 
   constructor(
     compilerPath = resolve(getPackagePath(), './bin/aesophia_cli'),
@@ -32,7 +33,7 @@ export default class CompilerCli extends CompilerBase {
     this.#path = compilerPath;
     if (ignoreVersion !== true) {
       this.#ensureCompatibleVersion = this.version().then((version) => {
-        const versions = [version, '7.0.1', '8.0.0'] as const;
+        const versions = [version, '7.2.1', '8.0.0'] as const;
         if (!semverSatisfies(...versions)) throw new UnsupportedVersionError('compiler', ...versions);
       });
     }
@@ -78,9 +79,10 @@ export default class CompilerCli extends CompilerBase {
       ]);
       return {
         bytecode: bytecode.trimEnd() as Encoded.ContractBytearray,
-        aci: aci as Aci,
+        aci,
       };
     } catch (error) {
+      ensureError(error);
       throw new CompilerError(error.message);
     }
   }
@@ -97,6 +99,28 @@ export default class CompilerCli extends CompilerBase {
     }
   }
 
+  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 {

package/src/contract/compiler/Http.ts

@@ -55,7 +55,7 @@ export default class CompilerHttp extends CompilerBase {
       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'),
+        genVersionCheckPolicy('compiler', '/api-version', versionPromise, '7.3.0', '8.0.0'),
       );
     }
   }
@@ -70,7 +70,7 @@ export default class CompilerHttp extends CompilerBase {
       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 new CompilerError(error.message);
       }
       throw error;
     }
@@ -81,6 +81,25 @@ export default class CompilerHttp extends CompilerBase {
     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,

package/src/contract/compiler/HttpNode.ts

@@ -18,6 +18,12 @@ export default class CompilerHttpNode extends HttpBrowser {
     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');