@aeternity/aepp-sdk 13.0.1 → 13.1.0

package/src/AeSdkMethods.ts

@@ -11,25 +11,27 @@ import Node from './Node';
 import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import { ArgumentError, NotImplementedError, TypeError } from './utils/errors';
+import CompilerBase from './contract/compiler/Base';
 
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 
-export function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value {
-  return new Proxy({}, {
-    ...Object.fromEntries([
+export function getValueOrErrorProxy<Value extends object | undefined>(
+  valueCb: () => Value,
+): NonNullable<Value> {
+  return new Proxy(
+    {},
+    Object.fromEntries(([
       'apply', 'construct', 'defineProperty', 'deleteProperty', 'getOwnPropertyDescriptor',
       'getPrototypeOf', 'isExtensible', 'ownKeys', 'preventExtensions', 'set', 'setPrototypeOf',
-    ].map((name) => [name, () => { throw new NotImplementedError(`${name} proxy request`); }])),
-    get(t: {}, property: string | symbol, receiver: any) {
-      const target = valueCb();
-      const value = Reflect.get(target, property, receiver);
-      return typeof value === 'function' ? value.bind(target) : value;
-    },
-    has(t: {}, property: string | symbol) {
-      return Reflect.has(valueCb(), property);
-    },
-  }) as Value;
+      'get', 'has',
+    ] as const).map((name) => [name, (t: {}, ...args: unknown[]) => {
+      const target = valueCb() as object; // to get a native exception in case it missed
+      const res = (Reflect[name] as any)(target, ...args);
+      return typeof res === 'function' && name === 'get'
+        ? res.bind(target) // otherwise it fails with attempted to get private field on non-instance
+        : res;
+    }])),
+  ) as NonNullable<Value>;
 }
 
 const { InvalidTxError: _2, ...chainMethodsOther } = chainMethods;
@@ -51,9 +53,8 @@ type GetMethodsOptions <Methods extends { [key: string]: Function }> =
       ? Args[Decrement<Args['length']>] : never
   };
 type MethodsOptions = GetMethodsOptions<typeof methods>;
-interface AeSdkMethodsOptions
+export interface AeSdkMethodsOptions
   extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
-  nodes?: Array<{ name: string; instance: Node }>;
 }
 
 /**
@@ -79,24 +80,15 @@ class AeSdkMethods {
     Object.assign(this._options, options);
   }
 
-  /**
-   * Resolves an account
-   * @param account - ak-address, instance of AccountBase, or keypair
-   */
-  // eslint-disable-next-line class-methods-use-this
-  _resolveAccount(account?: OnAccount): AccountBase {
-    if (typeof account === 'string') throw new NotImplementedError('Address in AccountResolver');
-    if (typeof account === 'object') return account;
-    throw new TypeError(
-      'Account should be an address (ak-prefixed string), '
-      + `or instance of AccountBase, got ${String(account)} instead`,
-    );
-  }
-
-  _getOptions(): AeSdkMethodsOptions & { onAccount: AccountBase } {
+  _getOptions(
+    callOptions: AeSdkMethodsOptions = {},
+  ): AeSdkMethodsOptions & { onAccount: AccountBase; onCompiler: CompilerBase; onNode: Node } {
     return {
       ...this._options,
-      onAccount: getValueOrErrorProxy(() => this._resolveAccount()),
+      onAccount: getValueOrErrorProxy(() => this._options.onAccount),
+      onNode: getValueOrErrorProxy(() => this._options.onNode),
+      onCompiler: getValueOrErrorProxy(() => this._options.onCompiler),
+      ...callOptions,
     };
   }
 
@@ -107,16 +99,7 @@ class AeSdkMethods {
   async initializeContract<Methods extends ContractMethodsBase>(
     options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & { onNode?: Node },
   ): Promise<Contract<Methods>> {
-    const { onNode, onCompiler, ...otherOptions } = this._getOptions();
-    if (onCompiler == null || onNode == null) {
-      throw new ArgumentError('onCompiler, onNode', 'provided', null);
-    }
-    return Contract.initialize<Methods>({
-      ...otherOptions,
-      onNode,
-      onCompiler,
-      ...options,
-    });
+    return Contract.initialize<Methods>(this._getOptions(options as AeSdkMethodsOptions));
   }
 }
 
@@ -147,18 +130,16 @@ Object.assign(AeSdkMethods.prototype, mapObject<Function, Function>(
   methods,
   ([name, handler]) => [
     name,
-    function methodWrapper(...args: any[]) {
+    function methodWrapper(this: AeSdkMethods, ...args: any[]) {
       args.length = handler.length;
       const options = args[args.length - 1];
-      args[args.length - 1] = {
-        ...this._getOptions(),
-        ...options,
-        ...options?.onAccount != null && { onAccount: this._resolveAccount(options.onAccount) },
-      };
+      args[args.length - 1] = this._getOptions(options);
       return handler(...args);
     },
   ],
 ));
 
-export default AeSdkMethods as new (options?: ConstructorParameters<typeof AeSdkMethods>[0]) =>
-AeSdkMethods & AeSdkMethodsTransformed;
+type AeSdkMethodsTyped = AeSdkMethods & AeSdkMethodsTransformed;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+const AeSdkMethodsTyped = AeSdkMethods as new (options?: AeSdkMethodsOptions) => AeSdkMethodsTyped;
+export default AeSdkMethodsTyped;

package/src/AeSdkWallet.ts

@@ -4,7 +4,7 @@ import verifyTransaction from './tx/validator';
 import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
 import {
   METHODS, RPC_STATUS, SUBSCRIPTION_TYPES, WALLET_TYPE,
-  RpcBroadcastError, RpcInvalidTransactionError,
+  RpcInvalidTransactionError,
   RpcNotAuthorizeError, RpcPermissionDenyError, RpcUnsupportedProtocolError,
 } from './aepp-wallet-communication/schema';
 import { InternalError, UnknownRpcClientError } from './utils/errors';
@@ -242,14 +242,21 @@ export default class AeSdkWallet extends AeSdk {
             await this.onAskAccounts(id, params, origin);
             return this.addresses();
           },
-          [METHODS.sign]: async ({ tx, onAccount = this.address, returnSigned }, origin) => {
+          [METHODS.sign]: async (
+            {
+              tx, onAccount = this.address, returnSigned, innerTx,
+            },
+            origin,
+          ) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             if (!this.addresses().includes(onAccount)) {
               throw new RpcPermissionDenyError(onAccount);
             }
 
-            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
-            if (returnSigned) {
+            const parameters = {
+              onAccount, aeppOrigin: origin, aeppRpcClientId: id, innerTx,
+            };
+            if (returnSigned || innerTx === true) {
               return { signedTransaction: await this.signTransaction(tx, parameters) };
             }
             try {
@@ -259,7 +266,7 @@ export default class AeSdkWallet extends AeSdk {
             } catch (error) {
               const validation = await verifyTransaction(tx, this.api);
               if (validation.length > 0) throw new RpcInvalidTransactionError(validation);
-              throw new RpcBroadcastError(error.message);
+              throw error;
             }
           },
           [METHODS.signMessage]: async ({ message, onAccount = this.address }, origin) => {
@@ -273,6 +280,21 @@ export default class AeSdkWallet extends AeSdk {
               signature: Buffer.from(await this.signMessage(message, parameters)).toString('hex'),
             };
           },
+          [METHODS.signTypedData]: async ({
+            domain, aci, data, onAccount = this.address,
+          }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            if (!this.addresses().includes(onAccount)) {
+              throw new RpcPermissionDenyError(onAccount);
+            }
+
+            const parameters = {
+              ...domain, onAccount, aeppOrigin: origin, aeppRpcClientId: id,
+            };
+            return {
+              signature: await this.signTypedData(data, aci, parameters),
+            };
+          },
         },
       ),
     };

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

@@ -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);
+  }
 }