@aeternity/aepp-sdk 13.0.1 → 13.2.0

package/src/Middleware.ts

@@ -0,0 +1,141 @@
+// eslint-disable-next-line max-classes-per-file
+import BigNumber from 'bignumber.js';
+import { OperationArguments, OperationSpec } from '@azure/core-client';
+import {
+  genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
+  genVersionCheckPolicy, genRetryOnFailurePolicy,
+} from './utils/autorest';
+import { Middleware as MiddlewareApi, MiddlewareOptionalParams, ErrorResponse } from './apis/middleware';
+import { mapObject } from './utils/other';
+import { Encoded } from './utils/encoder';
+import { ConsensusProtocolVersion } from './tx/builder/constants';
+
+const bigIntPropertyNames = [] as const;
+
+const numberPropertyNames = [] as const;
+
+class MiddlewareTransformed extends MiddlewareApi {
+  override async sendOperationRequest(
+    operationArguments: OperationArguments,
+    operationSpec: OperationSpec,
+  ): Promise<any> {
+    const args = mapObject(
+      operationArguments,
+      ([key, value]) => [key, this.#encodeArg(value)],
+    ) as OperationArguments;
+    return this.#decodeRes(await super.sendOperationRequest(args, operationSpec));
+  }
+
+  #mapData(data: any, transform: {
+    bigInt: (v: any) => any;
+    number: (v: any) => any;
+  }): unknown {
+    if (Array.isArray(data)) return data.map((d) => this.#mapData(d, transform));
+    if (data != null && typeof data === 'object') {
+      return mapObject(data, ([key, value]) => {
+        if (value == null) return [key, value];
+        if (bigIntPropertyNames.some((k) => k === key)) return [key, transform.bigInt(value)];
+        if (numberPropertyNames.some((k) => k === key)) return [key, transform.number(value)];
+        return [key, this.#mapData(value, transform)];
+      });
+    }
+    return data;
+  }
+
+  #encodeArg(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => {
+        if (value instanceof BigNumber) return value.toFixed();
+        return value.toString();
+      },
+      number: (value) => value.toString(),
+    });
+  }
+
+  #decodeRes(data: any): any {
+    return this.#mapData(data, {
+      bigInt: (value) => BigInt(value),
+      number: (value) => +value,
+    });
+  }
+}
+
+type BigIntPropertyNames = typeof bigIntPropertyNames[number];
+type NumberPropertyNames = typeof numberPropertyNames[number];
+type PreserveOptional<NewType, OrigType> =
+  OrigType extends undefined ? NewType | undefined : NewType;
+export type TransformMiddlewareType<Type> =
+  Type extends (...args: infer Args) => infer Ret
+    ? (...args: TransformMiddlewareType<Args>) => TransformMiddlewareType<Ret>
+    : Type extends [infer Item, ...infer Rest]
+      ? [TransformMiddlewareType<Item>, ...TransformMiddlewareType<Rest>]
+      : Type extends Array<infer Item>
+        ? Array<TransformMiddlewareType<Item>>
+        : Type extends Promise<infer T>
+          ? Promise<TransformMiddlewareType<T>>
+          : Type extends { [P in any]: any }
+            ? {
+              [Property in keyof Type]:
+              Property extends BigIntPropertyNames
+                ? PreserveOptional<bigint, Type[Property]>
+                : Property extends NumberPropertyNames
+                  ? PreserveOptional<number, Type[Property]>
+                  : Property extends 'txHash'
+                    ? PreserveOptional<Encoded.TxHash, Type[Property]>
+                    : Property extends 'bytecode'
+                      ? PreserveOptional<Encoded.ContractBytearray, Type[Property]>
+                      : TransformMiddlewareType<Type[Property]>
+            }
+            : Type;
+type MiddlewareTransformedApi = new (...args: ConstructorParameters<typeof MiddlewareApi>) => {
+  [Name in keyof InstanceType<typeof MiddlewareApi>]:
+  Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest'
+    ? MiddlewareApi[Name] : TransformMiddlewareType<MiddlewareApi[Name]>
+};
+
+export interface MiddlewareInfo {
+  url: string;
+  nodeNetworkId: string;
+  version: string;
+  consensusProtocolVersion: ConsensusProtocolVersion;
+}
+
+export default class Middleware
+  extends (MiddlewareTransformed as unknown as MiddlewareTransformedApi) {
+  /**
+   * @param url - Url for middleware API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check node version
+   * @param options.retryCount - Amount of extra requests to do in case of failure
+   * @param options.retryOverallDelay - Time in ms to wait between all retries
+   */
+  constructor(
+    url: string,
+    {
+      ignoreVersion = false, retryCount = 3, retryOverallDelay = 800, ...options
+    }: MiddlewareOptionalParams & {
+      ignoreVersion?: boolean;
+      retryCount?: number;
+      retryOverallDelay?: number;
+    } = {},
+  ) {
+    // eslint-disable-next-line constructor-super
+    super(url, {
+      allowInsecureConnection: true,
+      additionalPolicies: [
+        genRequestQueuesPolicy(),
+        genCombineGetRequestsPolicy(),
+        genRetryOnFailurePolicy(retryCount, retryOverallDelay),
+        genErrorFormatterPolicy((body: ErrorResponse) => ` ${body.error}`),
+      ],
+      ...options,
+    });
+    if (!ignoreVersion) {
+      const statusPromise = this.getStatus();
+      const versionPromise = statusPromise.then(({ mdwVersion }) => mdwVersion, (error) => error);
+      this.pipeline.addPolicy(
+        genVersionCheckPolicy('middleware', '/v2/status', versionPromise, '1.47.0', '2.0.0'),
+      );
+    }
+  }
+}

package/src/MiddlewareSubscriber.ts

@@ -0,0 +1,207 @@
+/* eslint-disable max-classes-per-file */
+import WebSocket from 'isomorphic-ws';
+import { BaseError, UnexpectedTsError, InternalError } from './utils/errors';
+import { Encoded } from './utils/encoder';
+
+interface Message {
+  payload: Object;
+  source: Source.Middleware | Source.Node;
+  subscription: 'KeyBlocks' | 'MicroBlocks' | 'Transactions' | 'Object';
+  target?: string;
+}
+
+enum Source {
+  Middleware = 'mdw',
+  Node = 'node',
+  All = 'all',
+}
+
+export class MiddlewareSubscriberError extends BaseError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MiddlewareSubscriberError';
+  }
+}
+
+export class MiddlewareSubscriberDisconnected extends MiddlewareSubscriberError {
+  constructor(readonly closeEvent: WebSocket.CloseEvent) {
+    super('Connection closed');
+    this.name = 'MiddlewareSubscriberDisconnected';
+  }
+}
+
+export default class MiddlewareSubscriber {
+  #subscriptions: Array<
+  readonly [target: string, s: Source, cb: (p?: Object, e?: Error) => void]
+  > = [];
+
+  #requestQueue: Array<[isSubscribe: boolean, target: string]> = [];
+
+  #webSocket?: WebSocket;
+
+  get webSocket(): WebSocket | undefined {
+    return this.#webSocket;
+  }
+
+  get #targets(): Set<string> {
+    return new Set(this.#subscriptions.map(([target]) => target));
+  }
+
+  #sendMessage(message: any): void {
+    if (this.#webSocket == null) throw new UnexpectedTsError();
+    this.#webSocket.send(JSON.stringify(message));
+  }
+
+  #sendSubscribe(isSubscribe: boolean, target: string): void {
+    if (this.#webSocket == null) return;
+    const payload = ['KeyBlocks', 'MicroBlocks', 'Transactions'].includes(target)
+      ? target : 'Object';
+    this.#sendMessage({
+      op: isSubscribe ? 'Subscribe' : 'Unsubscribe',
+      payload,
+      ...payload === 'Object' && { target },
+    });
+    this.#requestQueue.push([isSubscribe, target]);
+  }
+
+  #emit(condition: (target: string, source: Source) => boolean, p?: Object, e?: Error): void {
+    this.#subscriptions
+      .filter(([target, source]) => condition(target, source))
+      .forEach(([, , cb]) => cb(p, e));
+  }
+
+  constructor(readonly url: string) {
+  }
+
+  #disconnect(onlyReset = false): void {
+    if (this.#webSocket == null) return;
+    if (!onlyReset) this.#webSocket.close();
+    Object.assign(this.#webSocket, {
+      onopen: undefined,
+      onerror: undefined,
+      onmessage: undefined,
+    });
+    this.#webSocket = undefined;
+  }
+
+  async reconnect(): Promise<void> {
+    this.#disconnect();
+    this.#webSocket = await new Promise((resolve) => {
+      const webSocket = new WebSocket(this.url);
+      Object.assign(webSocket, {
+        onopen: () => resolve(webSocket),
+        onerror: (errorEvent: WebSocket.ErrorEvent) => {
+          this.#emit(() => true, undefined, errorEvent.error);
+        },
+        onmessage: (event: WebSocket.MessageEvent) => {
+          if (typeof event.data !== 'string') {
+            throw new InternalError(`Unknown incoming message type: ${typeof event.data}`);
+          }
+          this.#messageHandler(JSON.parse(event.data));
+        },
+        onclose: (event: WebSocket.CloseEvent) => {
+          this.#emit(() => true, undefined, new MiddlewareSubscriberDisconnected(event));
+          this.#disconnect(true);
+        },
+      });
+    });
+    await Promise.all([...this.#targets].map((target) => this.#sendSubscribe(true, target)));
+  }
+
+  #messageHandler(message: string | string[] | Message): void {
+    if (typeof message === 'string' || Array.isArray(message)) {
+      const request = this.#requestQueue.shift();
+      if (request == null) throw new InternalError('Request queue is empty');
+      const [isSubscribe, target] = request;
+      let error;
+      if (typeof message === 'string') error = new MiddlewareSubscriberError(message);
+      if (message.includes(target) !== isSubscribe) {
+        error = new InternalError(`Expected ${target} to be${isSubscribe ? '' : ' not'} included into ${message}`);
+      }
+      if (error != null) this.#emit((t) => target === t, undefined, error);
+      return;
+    }
+    this.#emit(
+      (target, source) => (target === message.subscription || target === message.target)
+        && (source === message.source || source === Source.All),
+      message.payload,
+    );
+  }
+
+  #subscribe(target: string, source: Source, cb: (p?: Object, e?: Error) => void): () => void {
+    const subscription = [target, source, cb] as const;
+    if (this.#targets.size === 0) this.reconnect();
+    if (!this.#targets.has(target)) this.#sendSubscribe(true, target);
+    this.#subscriptions.push(subscription);
+    return () => {
+      this.#subscriptions = this.#subscriptions.filter((item) => item !== subscription);
+      if (!this.#targets.has(target)) this.#sendSubscribe(false, target);
+      if (this.#targets.size === 0) this.#disconnect();
+    };
+  }
+
+  // TODO: replace p?: any with a proper type definition
+
+  subscribeKeyBlocks(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('KeyBlocks', Source.Middleware, cb);
+  }
+
+  subscribeKeyBlocksNode(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('KeyBlocks', Source.Node, cb);
+  }
+
+  subscribeKeyBlocksAll(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('KeyBlocks', Source.All, cb);
+  }
+
+  subscribeMicroBlocks(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('MicroBlocks', Source.Middleware, cb);
+  }
+
+  subscribeMicroBlocksNode(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('MicroBlocks', Source.Node, cb);
+  }
+
+  subscribeMicroBlocksAll(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('MicroBlocks', Source.All, cb);
+  }
+
+  subscribeTransactions(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('Transactions', Source.Middleware, cb);
+  }
+
+  subscribeTransactionsNode(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('Transactions', Source.Node, cb);
+  }
+
+  subscribeTransactionsAll(cb: (p?: any, e?: Error) => void): () => void {
+    return this.#subscribe('Transactions', Source.All, cb);
+  }
+
+  subscribeObject(
+    target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress
+    | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress
+    | Encoded.Name | `${string}.chain`,
+    cb: (p?: any, e?: Error) => void,
+  ): () => void {
+    return this.#subscribe(target, Source.Middleware, cb);
+  }
+
+  subscribeObjectNode(
+    target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress
+    | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress
+    | Encoded.Name | `${string}.chain`,
+    cb: (p?: any, e?: Error) => void,
+  ): () => void {
+    return this.#subscribe(target, Source.Node, cb);
+  }
+
+  subscribeObjectAll(
+    target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress
+    | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress
+    | Encoded.Name | `${string}.chain`,
+    cb: (p?: any, e?: Error) => void,
+  ): () => void {
+    return this.#subscribe(target, Source.All, cb);
+  }
+}

package/src/Node.ts

@@ -103,7 +103,7 @@ type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) =
     ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>
 };
 
-export interface NodeInfo {
+interface NodeInfo {
   url: string;
   nodeNetworkId: string;
   version: string;

package/src/account/Base.ts

@@ -1,7 +1,9 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
-import { Int } from '../tx/builder/constants';
+import { AensName, Int } from '../tx/builder/constants';
+import { AciValue, Domain } from '../utils/typed-data';
+import { NotImplementedError } from '../utils/errors';
 
 interface AuthData {
   fee?: Int;
@@ -42,7 +44,7 @@ export default abstract class AccountBase {
    * Sign message
    * @param message - Message to sign
    * @param options - Options
-   * @returns Signature as hex string of Uint8Array
+   * @returns Signature
    */
   abstract signMessage(
     message: string,
@@ -52,16 +54,112 @@ export default abstract class AccountBase {
     },
   ): Promise<Uint8Array>;
 
+  /**
+   * Sign typed data
+   * @param type - Type of data to sign
+   * @param data - Encoded data to sign
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signTypedData(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    data: Encoded.ContractBytearray,
+    aci: AciValue,
+    options?: Domain & {
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signTypedData method');
+  }
+
+  /**
+   * Sign delegation of AENS, oracle operations to a contract
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signDelegationToContract method');
+  }
+
+  /**
+   * Sign delegation of an AENS name to a contract
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param name - AENS name to manage by a contract
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signNameDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signNameDelegationToContract method');
+  }
+
+  /**
+   * Sign delegation of oracle query to a contract
+   *
+   * Warning! Implementations needs to ensure that decoded oracle query id is not equal to decoded
+   * current account address unless https://github.com/aeternity/aesophia/issues/475 is fixed.
+   *
+   * Warning! Implementations needs to ensure that oracle query and contract exists unless
+   * https://github.com/aeternity/aesophia/issues/474 is fixed.
+   *
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param oracleQueryId - Oracle query ID to reply by a contract
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signOracleQueryDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signOracleQueryDelegationToContract method');
+  }
+
   /**
    * Sign data blob
    * @param data - Data blob to sign
    * @param options - Options
-   * @returns Signed data blob
+   * @returns Signature
    */
   abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
 
   /**
    * Account address
    */
-  readonly address: Encoded.AccountAddress;
+  readonly address!: Encoded.AccountAddress;
 }

package/src/account/Generalized.ts

@@ -38,6 +38,26 @@ export default class AccountGeneralized extends AccountBase {
     throw new NotImplementedError('Can\'t sign using generalized account');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signTypedData(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('Can\'t sign using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signNameDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],

package/src/account/Ledger.ts

@@ -40,6 +40,26 @@ export default class AccountLedger extends AccountBase {
     throw new NotImplementedError('RAW signing using Ledger HW');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signTypedData(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('Typed data signing using Ledger HW');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signNameDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},

package/src/account/Memory.ts

@@ -7,8 +7,10 @@ import {
   decode, encode, Encoded, Encoding,
 } from '../utils/encoder';
 import { concatBuffers } from '../utils/other';
+import { hashTypedData, AciValue } from '../utils/typed-data';
 import { buildTx } from '../tx/builder';
-import { Tag } from '../tx/builder/constants';
+import { Tag, AensName } from '../tx/builder/constants';
+import { produceNameId } from '../tx/builder/helpers';
 
 const secretKeys = new WeakMap();
 
@@ -74,4 +76,69 @@ export default class AccountMemory extends AccountBase {
   override async signMessage(message: string, options?: any): Promise<Uint8Array> {
     return this.sign(messageToHash(message), options);
   }
+
+  override async signTypedData(
+    data: Encoded.ContractBytearray,
+    aci: AciValue,
+    {
+      name, version, networkId, contractAddress, ...options
+    }: Parameters<AccountBase['signTypedData']>[2] = {},
+  ): Promise<Encoded.Signature> {
+    const dHash = hashTypedData(data, aci, {
+      name, version, networkId, contractAddress,
+    });
+    const signature = await this.sign(dHash, options);
+    return encode(signature, Encoding.Signature);
+  }
+
+  override async signDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      decode(this.address),
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+
+  override async signNameDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      decode(this.address),
+      decode(produceNameId(name)),
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+
+  override async signOracleQueryDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    const oracleQueryIdDecoded = decode(oracleQueryId);
+    const addressDecoded = decode(this.address);
+    // TODO: remove after fixing https://github.com/aeternity/aesophia/issues/475
+    if (oracleQueryIdDecoded.compare(addressDecoded) === 0) {
+      throw new ArgumentError('oracleQueryId', 'not equal to account address', oracleQueryId);
+    }
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      oracleQueryIdDecoded,
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
 }