@aeternity/aepp-sdk 13.0.0 → 13.1.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

@@ -2,6 +2,7 @@ import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
 import { Int } from '../tx/builder/constants';
+import { AciValue, Domain } from '../utils/typed-data';
 
 interface AuthData {
   fee?: Int;
@@ -42,7 +43,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 +53,32 @@ 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
+   */
+  abstract signTypedData(
+    data: Encoded.ContractBytearray,
+    aci: AciValue,
+    options?: Domain & {
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+  ): Promise<Encoded.Signature>;
+
   /**
    * 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,11 @@ 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');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],

package/src/account/Ledger.ts

@@ -40,6 +40,11 @@ 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');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},

package/src/account/Memory.ts

@@ -7,6 +7,7 @@ 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';
 
@@ -74,4 +75,18 @@ 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);
+  }
 }

package/src/account/Rpc.ts

@@ -28,20 +28,17 @@ export default class AccountRpc extends AccountBase {
     throw new NotImplementedError('RAW signing using wallet');
   }
 
-  /**
-   * @returns Signed transaction
-   */
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},
   ): Promise<Encoded.Transaction> {
-    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');
     if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
     const res = await this._rpcClient.request(METHODS.sign, {
       onAccount: this.address,
       tx,
       returnSigned: true,
       networkId,
+      innerTx,
     });
     if (res.signedTransaction == null) {
       throw new UnsupportedProtocolError('signedTransaction is missed in wallet response');
@@ -49,12 +46,27 @@ export default class AccountRpc extends AccountBase {
     return res.signedTransaction;
   }
 
-  /**
-   * @returns Signed message
-   */
   override async signMessage(message: string): Promise<Uint8Array> {
     const { signature } = await this._rpcClient
       .request(METHODS.signMessage, { onAccount: this.address, message });
     return Buffer.from(signature, 'hex');
   }
+
+  override async signTypedData(
+    data: Encoded.ContractBytearray,
+    aci: Parameters<AccountBase['signTypedData']>[1],
+    {
+      name, version, contractAddress, networkId,
+    }: Parameters<AccountBase['signTypedData']>[2] = {},
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signTypedData, {
+      onAccount: this.address,
+      domain: {
+        name, version, networkId, contractAddress,
+      },
+      aci,
+      data,
+    });
+    return signature;
+  }
 }

package/src/aens.ts

@@ -379,7 +379,7 @@ interface AensPreclaimOptions extends
  * @example
  * ```js
  * const name = 'test.chain'
- * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ * const bidFee = computeBidFee(name, { startFee, increment: 0.42 })
  *
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  * ```

package/src/aepp-wallet-communication/rpc/RpcClient.ts

@@ -1,6 +1,7 @@
 import { RpcError, RpcInternalError, RpcMethodNotFoundError } from '../schema';
 import BrowserConnection from '../connection/Browser';
 import { InvalidRpcMessageError, MissingCallbackError } from '../../utils/errors';
+import { ensureError } from '../../utils/other';
 
 interface JsonRpcRequest {
   jsonrpc: '2.0';
@@ -64,17 +65,24 @@ export default class RpcClient <
 
     const request = msg as JsonRpcRequest;
     let result;
-    let error;
+    let error: Error | undefined;
     try {
       if (!(request.method in this.#methods)) throw new RpcMethodNotFoundError();
       const methodName = request.method as keyof LocalApi;
       result = await this.#methods[methodName](request.params, origin);
     } catch (e) {
-      error = e instanceof RpcError ? e : new RpcInternalError();
+      ensureError(e);
+      error = e;
     }
     if (request.id != null) {
-      this.#sendResponse(request.id, request.method as keyof LocalApi, result, error);
+      this.#sendResponse(
+        request.id,
+        request.method as keyof LocalApi,
+        result,
+        error == null || error instanceof RpcError ? error : new RpcInternalError(),
+      );
     }
+    if (error != null && !(error instanceof RpcError)) throw error;
   }
 
   #sendRequest(

package/src/aepp-wallet-communication/rpc/types.ts

@@ -1,4 +1,5 @@
 import { Encoded } from '../../utils/encoder';
+import { Domain, AciValue } from '../../utils/typed-data';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
 import { TransformNodeType } from '../../Node';
 import { SignedTx } from '../../apis/node';
@@ -55,6 +56,7 @@ export interface WalletApi {
        * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
        */
       networkId: string;
+      innerTx?: boolean;
     }
   ) => Promise<{
     /**
@@ -71,6 +73,15 @@ export interface WalletApi {
   [METHODS.signMessage]: (
     p: { message: string; onAccount: Encoded.AccountAddress }
   ) => Promise<{ signature: string }>;
+
+  [METHODS.signTypedData]: (
+    p: {
+      domain: Domain;
+      aci: AciValue;
+      data: Encoded.ContractBytearray;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
 }
 
 export interface AeppApi {

package/src/aepp-wallet-communication/schema.ts

@@ -36,6 +36,7 @@ export const enum METHODS {
   connect = 'connection.open',
   sign = 'transaction.sign',
   signMessage = 'message.sign',
+  signTypedData = 'typedData.sign',
   subscribeAddress = 'address.subscribe',
   updateNetwork = 'networkId.update',
   closeConnection = 'connection.close',
@@ -64,7 +65,7 @@ const rpcErrors: Array<(new (data?: any) => RpcError) & { code: number }> = [];
 export abstract class RpcError extends BaseError {
   static code: number;
 
-  code: number;
+  code!: number;
 
   data?: any;
 
@@ -99,22 +100,6 @@ export class RpcInvalidTransactionError extends RpcError {
 }
 rpcErrors.push(RpcInvalidTransactionError);
 
-/**
- * @category exception
- */
-export class RpcBroadcastError extends RpcError {
-  static override code = 3;
-
-  override code = 3;
-
-  constructor(data?: any) {
-    super('Broadcast failed');
-    this.data = data;
-    this.name = 'RpcBroadcastError';
-  }
-}
-rpcErrors.push(RpcBroadcastError);
-
 /**
  * @category exception
  */

package/src/aepp-wallet-communication/wallet-detector.ts

@@ -22,7 +22,7 @@ interface Wallets { [key: string]: Wallet }
  */
 export default (
   connection: BrowserConnection,
-  onDetected: ({ wallets, newWallet }: { wallets: Wallets; newWallet?: Wallet }) => void,
+  onDetected: ({ wallets, newWallet }: { wallets: Wallets; newWallet: Wallet }) => void,
 ): () => void => {
   if (window == null) throw new UnsupportedPlatformError('Window object not found, you can run wallet detector only in browser');
   const wallets: Wallets = {};
@@ -49,7 +49,6 @@ export default (
     wallets[wallet.info.id] = wallet;
     onDetected({ wallets, newWallet: wallet });
   }, () => {});
-  if (Object.keys(wallets).length > 0) onDetected({ wallets });
 
   return () => connection.disconnect();
 };

package/src/apis/compiler/compiler.ts

@@ -260,7 +260,14 @@ const generateACIOperationSpec: coreClient.OperationSpec = {
   httpMethod: "POST",
   responses: {
     200: {
-      bodyMapper: Mappers.Aci
+      bodyMapper: {
+        type: {
+          name: "Sequence",
+          element: {
+            type: { name: "Dictionary", value: { type: { name: "any" } } }
+          }
+        }
+      }
     },
     400: {
       bodyMapper: {

package/src/apis/compiler/models/index.ts

@@ -12,13 +12,6 @@ export interface CompileOpts {
   srcFile?: string;
 }
 
-export interface Aci {
-  /** Any object */
-  encodedAci: Record<string, unknown>;
-  externalEncodedAci?: Record<string, unknown>[];
-  interface: string;
-}
-
 export interface CompilerError {
   type: string;
   pos: ErrorPos;
@@ -151,7 +144,7 @@ export interface GenerateACIOptionalParams
   extends coreClient.OperationOptions {}
 
 /** Contains response data for the generateACI operation. */
-export type GenerateACIResponse = Aci;
+export type GenerateACIResponse = Record<string, unknown>[];
 
 /** Optional parameters. */
 export interface CompileContractOptionalParams

package/src/apis/compiler/models/mappers.ts

@@ -45,42 +45,6 @@ export const CompileOpts: coreClient.CompositeMapper = {
   }
 };
 
-export const Aci: coreClient.CompositeMapper = {
-  type: {
-    name: "Composite",
-    className: "Aci",
-    modelProperties: {
-      encodedAci: {
-        serializedName: "encoded_aci",
-        required: true,
-        type: {
-          name: "Dictionary",
-          value: { type: { name: "any" } }
-        }
-      },
-      externalEncodedAci: {
-        serializedName: "external_encoded_aci",
-        type: {
-          name: "Sequence",
-          element: {
-            type: {
-              name: "Dictionary",
-              value: { type: { name: "any" } }
-            }
-          }
-        }
-      },
-      interface: {
-        serializedName: "interface",
-        required: true,
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
-
 export const CompilerError: coreClient.CompositeMapper = {
   type: {
     name: "Composite",

package/src/apis/middleware/index.ts

@@ -0,0 +1,2 @@
+export * from "./models";
+export { Middleware } from "./middleware";