@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.0

package/src/account/Ledger.ts

@@ -0,0 +1,131 @@
+import type Transport from '@ledgerhq/hw-transport';
+import AccountBase from './Base';
+import { ArgumentError, NotImplementedError } from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { buildTx } from '../tx/builder';
+import { Tag } from '../tx/builder/constants';
+
+export const CLA = 0xe0;
+export const GET_ADDRESS = 0x02;
+export const SIGN_TRANSACTION = 0x04;
+export const GET_APP_CONFIGURATION = 0x06;
+export const SIGN_PERSONAL_MESSAGE = 0x08;
+
+/**
+ * Ledger wallet account class
+ */
+export default class AccountLedger extends AccountBase {
+  readonly transport: Transport;
+
+  override readonly address: Encoded.AccountAddress;
+
+  readonly index: number;
+
+  /**
+   * @param transport - Connection to Ledger to use
+   * @param index - Index of account
+   * @param address - Address of account
+   */
+  constructor(transport: Transport, index: number, address: Encoded.AccountAddress) {
+    super();
+    this.transport = transport;
+    this.index = index;
+    this.address = address;
+    const scrambleKey = 'w0w';
+    transport.decorateAppAPIMethods(this, ['signTransaction', 'signMessage'], scrambleKey);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async sign(): Promise<Uint8Array> {
+    throw new NotImplementedError('RAW signing using Ledger HW');
+  }
+
+  override async signTransaction(
+    tx: Encoded.Transaction,
+    { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},
+  ): Promise<Encoded.Transaction> {
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountLedger');
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+
+    const rawTx = decode(tx);
+    let offset = 0;
+    const headerLength = 4 + 1 + 4;
+    const networkIdBuffer = Buffer.from(networkId);
+    const toSend = [];
+    while (offset !== rawTx.length) {
+      const maxChunkSize = offset === 0 ? 150 - headerLength - networkIdBuffer.length : 150;
+      const chunkSize = offset + maxChunkSize > rawTx.length
+        ? rawTx.length - offset : maxChunkSize;
+      const buffer = Buffer.alloc(
+        offset === 0 ? headerLength + networkIdBuffer.length + chunkSize : chunkSize,
+      );
+      if (offset === 0) {
+        let bufferOffset = buffer.writeUInt32BE(this.index, 0);
+        bufferOffset = buffer.writeUInt32BE(rawTx.length, bufferOffset);
+        bufferOffset = buffer.writeUInt8(networkIdBuffer.length, bufferOffset);
+        bufferOffset += networkIdBuffer.copy(
+          buffer,
+          bufferOffset,
+          0,
+          networkIdBuffer.length,
+        );
+        rawTx.copy(buffer, bufferOffset, 0, 150 - bufferOffset);
+      } else {
+        rawTx.copy(buffer, 0, offset, offset + chunkSize);
+      }
+      toSend.push(buffer);
+      offset += chunkSize;
+    }
+    const response = await toSend.reduce(
+      async (previous, data, i) => {
+        await previous;
+        return this.transport.send(
+          CLA,
+          SIGN_TRANSACTION,
+          i === 0 ? 0x00 : 0x80,
+          0x00,
+          data,
+        );
+      },
+      Promise.resolve(Buffer.alloc(0)),
+    );
+    const signatures = [response.subarray(0, 64)];
+
+    return buildTx({ encodedTx: rawTx, signatures }, Tag.SignedTx).tx;
+  }
+
+  override async signMessage(messageStr: string): Promise<Uint8Array> {
+    let offset = 0;
+    const message = Buffer.from(messageStr);
+    const toSend = [];
+    while (offset !== message.length) {
+      const maxChunkSize = offset === 0 ? 150 - 4 - 4 : 150;
+      const chunkSize = offset + maxChunkSize > message.length
+        ? message.length - offset : maxChunkSize;
+      const buffer = Buffer.alloc(offset === 0 ? 4 + 4 + chunkSize : chunkSize);
+      if (offset === 0) {
+        buffer.writeUInt32BE(this.index, 0);
+        buffer.writeUInt32BE(message.length, 4);
+        message.copy(buffer, 4 + 4, offset, offset + chunkSize);
+      } else {
+        message.copy(buffer, 0, offset, offset + chunkSize);
+      }
+      toSend.push(buffer);
+      offset += chunkSize;
+    }
+    const response = await toSend.reduce(
+      async (previous, data, i) => {
+        await previous;
+        return this.transport.send(
+          CLA,
+          SIGN_PERSONAL_MESSAGE,
+          i === 0 ? 0x00 : 0x80,
+          0x00,
+          data,
+        );
+      },
+      Promise.resolve(Buffer.alloc(0)),
+    );
+    return response.subarray(0, 64);
+  }
+}

package/src/account/LedgerFactory.ts

@@ -0,0 +1,86 @@
+import type Transport from '@ledgerhq/hw-transport';
+import AccountLedger, { CLA, GET_ADDRESS, GET_APP_CONFIGURATION } from './Ledger';
+import { UnsupportedVersionError } from '../utils/errors';
+import { Encoded } from '../utils/encoder';
+import semverSatisfies from '../utils/semver-satisfies';
+import Node from '../Node';
+
+/**
+ * A factory class that generates instances of AccountLedger based on provided transport.
+ */
+export default class AccountLedgerFactory {
+  readonly transport: Transport;
+
+  private readonly versionCheckPromise: Promise<void>;
+
+  /**
+   * @param transport - Connection to Ledger to use
+   */
+  constructor(transport: Transport) {
+    this.transport = transport;
+    this.versionCheckPromise = this.getAppConfiguration().then(({ version }) => {
+      const args = [version, '0.4.4', '0.5.0'] as const;
+      if (!semverSatisfies(...args)) throw new UnsupportedVersionError('app on ledger', ...args);
+    });
+    const scrambleKey = 'w0w';
+    transport.decorateAppAPIMethods(this, ['getAddress', 'getAppConfiguration'], scrambleKey);
+  }
+
+  /**
+   * @returns the version of app installed on Ledger wallet
+   */
+  async getAppConfiguration(): Promise<{ version: string }> {
+    await this.versionCheckPromise;
+    const response = await this.transport.send(CLA, GET_APP_CONFIGURATION, 0x00, 0x00);
+    return {
+      version: [response[1], response[2], response[3]].join('.'),
+    };
+  }
+
+  /**
+   * Get `ak_`-prefixed address for a given account index.
+   * @param accountIndex - Index of account
+   * @param verify - Ask user to confirm address by showing it on the device screen
+   */
+  async getAddress(accountIndex: number, verify = false): Promise<Encoded.AccountAddress> {
+    await this.versionCheckPromise;
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32BE(accountIndex, 0);
+    const response = await this.transport.send(
+      CLA,
+      GET_ADDRESS,
+      verify ? 0x01 : 0x00,
+      0x00,
+      buffer,
+    );
+    const addressLength = response[0];
+    return response.subarray(1, 1 + addressLength).toString('ascii') as Encoded.AccountAddress;
+  }
+
+  /**
+   * Get an instance of AccountLedger for a given account index.
+   * @param accountIndex - Index of account
+   */
+  async initialize(accountIndex: number): Promise<AccountLedger> {
+    await this.versionCheckPromise;
+    return new AccountLedger(this.transport, accountIndex, await this.getAddress(accountIndex));
+  }
+
+  /**
+   * Discovers accounts on Ledger that already have been used (has any on-chain transactions).
+   * It returns an empty array if none of accounts been used.
+   * If a used account is preceded by an unused account then it would be ignored.
+   * @param node - Instance of Node to get account information from
+   */
+  async discover(node: Node): Promise<AccountLedger[]> {
+    let index = 0;
+    const result = [];
+    let account;
+    do {
+      if (account != null) result.push(account);
+      account = await this.initialize(index);
+      index += 1;
+    } while (await node.getAccountByPubkey(account.address).then(() => true, () => false));
+    return result;
+  }
+}

package/src/account/Memory.ts

@@ -1,6 +1,6 @@
 /*
  * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
+ * Copyright (c) 2022 aeternity developers
  *
  *  Permission to use, copy, modify, and/or distribute this software for any
  *  purpose with or without fee is hereby granted, provided that the above
@@ -15,84 +15,70 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 import AccountBase from './Base';
-import { sign, isValidKeypair } from '../utils/crypto';
-import { isHex } from '../utils/string';
-import { ArgumentError, InvalidKeypairError, MissingParamError } from '../utils/errors';
-import { decode, Encoded } from '../utils/encoder';
-import { createMetaTx } from '../contract/ga';
+import {
+  generateKeyPairFromSecret, sign, generateKeyPair, hash, messageToHash,
+} from '../utils/crypto';
+import { ArgumentError } from '../utils/errors';
+import {
+  decode, encode, Encoded, Encoding,
+} from '../utils/encoder';
+import { concatBuffers } from '../utils/other';
+import { buildTx } from '../tx/builder';
+import { Tag } from '../tx/builder/constants';
 
-const secrets = new WeakMap();
-
-export interface Keypair {
-  publicKey: Encoded.AccountAddress;
-  secretKey: string | Uint8Array;
-}
+const secretKeys = new WeakMap();
 
 /**
  * In-memory account class
  */
 export default class AccountMemory extends AccountBase {
-  isGa: boolean;
+  override readonly address: Encoded.AccountAddress;
 
   /**
-   * @param options - Options
-   * @param options.keypair - Key pair to use
-   * @param options.keypair.publicKey - Public key
-   * @param options.keypair.secretKey - Private key
-   * @param options.gaId - Address of generalized account
+   * @param secretKey - Secret key
    */
-  constructor(
-    { keypair, gaId, ...options }: { keypair?: Keypair; gaId?: Encoded.AccountAddress }
-    & ConstructorParameters<typeof AccountBase>[0],
-  ) {
-    super(options);
-
-    this.isGa = gaId != null;
-    if (this.isGa && gaId != null) {
-      decode(gaId);
-      secrets.set(this, { publicKey: gaId });
-      return;
-    }
-
-    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required');
-
-    if (
-      !Buffer.isBuffer(keypair.secretKey)
-      && typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)
-    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer');
-    const secretKey = typeof keypair.secretKey === 'string'
-      ? Buffer.from(keypair.secretKey, 'hex')
-      : keypair.secretKey;
-    if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {
-      throw new InvalidKeypairError('Invalid Key Pair');
+  constructor(secretKey: string | Uint8Array) {
+    super();
+    secretKey = typeof secretKey === 'string' ? Buffer.from(secretKey, 'hex') : secretKey;
+    if (secretKey.length !== 64) {
+      throw new ArgumentError('secretKey', '64 bytes', secretKey.length);
     }
+    secretKeys.set(this, secretKey);
+    this.address = encode(
+      generateKeyPairFromSecret(secretKeys.get(this)).publicKey,
+      Encoding.AccountAddress,
+    );
+  }
 
-    secrets.set(this, {
-      secretKey,
-      publicKey: keypair.publicKey,
-    });
+  /**
+   * Generates a new AccountMemory using a random secret key
+   */
+  static generate(): AccountMemory {
+    return new AccountMemory(generateKeyPair().secretKey);
   }
 
-  async sign(data: string | Uint8Array): Promise<Uint8Array> {
-    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair');
-    return sign(data, secrets.get(this).secretKey);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  override async sign(data: string | Uint8Array, options?: any): Promise<Uint8Array> {
+    return sign(data, secretKeys.get(this));
   }
 
-  async signTransaction(
+  override async signTransaction(
     tx: Encoded.Transaction,
-    options: Parameters<AccountBase['signTransaction']>[1] = {},
+    { innerTx, networkId, ...options }: { innerTx?: boolean; networkId?: string } = {},
   ): Promise<Encoded.Transaction> {
-    if (!this.isGa || options.innerTx === true) return super.signTransaction(tx, options);
-    const {
-      authData, authFun, onCompiler, onNode,
-    } = options;
-    if (authFun == null || authData == null || onCompiler == null || onNode == null) {
-      throw new ArgumentError('authData, authFun, onCompiler, onNode', 'provided', null);
+    if (networkId == null) {
+      throw new ArgumentError('networkId', 'provided', networkId);
     }
-    return createMetaTx(tx, authData, authFun, { onCompiler, onNode, onAccount: this });
+    const prefixes = [networkId];
+    if (innerTx === true) prefixes.push('inner_tx');
+    const rlpBinaryTx = decode(tx);
+    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
+
+    const signatures = [await this.sign(txWithNetworkId, options)];
+    return buildTx({ encodedTx: rlpBinaryTx, signatures }, Tag.SignedTx).tx;
   }
 
-  async address(): Promise<Encoded.AccountAddress> {
-    return secrets.get(this).publicKey;
+  override async signMessage(message: string, options?: any): Promise<Uint8Array> {
+    return this.sign(messageToHash(message), options);
   }
 }

package/src/account/Rpc.ts

@@ -1,7 +1,9 @@
 import AccountBase from './Base';
 import { METHODS } from '../aepp-wallet-communication/schema';
-import { NotImplementedError } from '../utils/errors';
+import { ArgumentError, NotImplementedError, UnsupportedProtocolError } from '../utils/errors';
 import { Encoded } from '../utils/encoder';
+import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
+import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
 
 /**
  * Account provided by wallet
@@ -11,17 +13,14 @@ import { Encoded } from '../utils/encoder';
  * @returns AccountRpc instance
  */
 export default class AccountRpc extends AccountBase {
-  _rpcClient: any;
+  _rpcClient: RpcClient<WalletApi, AeppApi>;
 
-  _address: Encoded.AccountAddress;
+  override readonly address: Encoded.AccountAddress;
 
-  constructor(
-    { rpcClient, address, ...options }: { rpcClient: any; address: Encoded.AccountAddress }
-    & ConstructorParameters<typeof AccountBase>[0],
-  ) {
-    super(options);
+  constructor(rpcClient: RpcClient<WalletApi, AeppApi>, address: Encoded.AccountAddress) {
+    super();
     this._rpcClient = rpcClient;
-    this._address = address;
+    this.address = address;
   }
 
   // eslint-disable-next-line class-methods-use-this
@@ -29,41 +28,33 @@ export default class AccountRpc extends AccountBase {
     throw new NotImplementedError('RAW signing using wallet');
   }
 
-  async address(): Promise<Encoded.AccountAddress> {
-    return this._address;
-  }
-
   /**
    * @returns Signed transaction
    */
-  async signTransaction(
+  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,
+      onAccount: this.address,
       tx,
       returnSigned: true,
-      /**
-       * @deprecated Wallet provided networkId will be used (current network)
-       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
-       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
-       */
       networkId,
     });
+    if (res.signedTransaction == null) {
+      throw new UnsupportedProtocolError('signedTransaction is missed in wallet response');
+    }
     return res.signedTransaction;
   }
 
   /**
    * @returns Signed message
    */
-  async signMessage(
-    message: string,
-    { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {},
-  ): Promise<string | Uint8Array> {
+  override async signMessage(message: string): Promise<Uint8Array> {
     const { signature } = await this._rpcClient
-      .request(METHODS.signMessage, { onAccount: this._address, message });
-    return returnHex ? signature : Buffer.from(signature, 'hex');
+      .request(METHODS.signMessage, { onAccount: this.address, message });
+    return Buffer.from(signature, 'hex');
   }
 }

package/src/aens.ts

@@ -37,9 +37,10 @@ import { _buildTx, BuildTxOptions } from './tx';
 import { TransformNodeType } from './Node';
 import { NameEntry, NamePointer } from './apis/node';
 import AccountBase from './account/Base';
+import { AddressEncodings } from './tx/builder/field-types/address';
 
 interface KeyPointers {
-  [key: string]: string | Buffer;
+  [key: string]: Encoded.Generic<AddressEncodings>;
 }
 
 /**
@@ -70,7 +71,7 @@ export async function aensRevoke(
   const nameRevokeTx = await _buildTx(Tag.NameRevokeTx, {
     ...options,
     nameId: name,
-    accountId: await options.onAccount.address(options),
+    accountId: options.onAccount.address,
   });
   return send(nameRevokeTx, options);
 }
@@ -115,8 +116,7 @@ export async function aensUpdate(
 ): ReturnType<typeof send> {
   const allPointers = {
     ...extendPointers === true && Object.fromEntries(
-      (await getName(name, options)).pointers
-        .map(({ key, id }: { key: string; id: string }) => [key, id]),
+      (await getName(name, options)).pointers.map(({ key, id }) => [key, id]),
     ),
     ...pointers,
   };
@@ -126,8 +126,9 @@ export async function aensUpdate(
     nameTtl: NAME_TTL,
     ...options,
     nameId: name,
-    accountId: await options.onAccount.address(options),
-    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id: id.toString() })),
+    accountId: options.onAccount.address,
+    pointers: Object.entries(allPointers)
+      .map(([key, id]: [string, Encoded.Generic<AddressEncodings>]) => ({ key, id })),
   });
 
   return send(nameUpdateTx, options);
@@ -172,7 +173,7 @@ export async function aensTransfer(
   const nameTransferTx = await _buildTx(Tag.NameTransferTx, {
     ...options,
     nameId: name,
-    accountId: await options.onAccount.address(options),
+    accountId: options.onAccount.address,
     recipientId: account,
   });
 
@@ -298,7 +299,7 @@ export async function aensClaim(
 ): Promise<AensClaimReturnType> {
   const claimTx = await _buildTx(Tag.NameClaimTx, {
     ...options,
-    accountId: await options.onAccount.address(options),
+    accountId: options.onAccount.address,
     nameSalt: salt,
     name,
   });
@@ -358,7 +359,7 @@ Awaited<ReturnType<typeof send>> & {
 
   const preclaimTx = await _buildTx(Tag.NamePreclaimTx, {
     ...options,
-    accountId: await options.onAccount.address(options),
+    accountId: options.onAccount.address,
     commitmentId,
   });
 

package/src/aepp-wallet-communication/connection/BrowserRuntime.ts

@@ -31,24 +31,25 @@ export default class BrowserRuntimeConnection extends BrowserConnection {
     this.port = port;
   }
 
-  disconnect(): void {
+  override disconnect(): void {
     super.disconnect();
     this.port.disconnect();
   }
 
-  connect(
+  override connect(
     onMessage: (message: any, origin: string, source: Runtime.Port) => void,
     onDisconnect: () => void,
   ): void {
     super.connect(onMessage, onDisconnect);
     this.port.onMessage.addListener((message, port) => {
       this.receiveMessage(message);
-      onMessage(message, port.name, port);
+      // TODO: make `origin` optional because sender url is not available on aepp side
+      onMessage(message, port.sender?.url ?? '', port);
     });
     this.port.onDisconnect.addListener(onDisconnect);
   }
 
-  sendMessage(message: any): void {
+  override sendMessage(message: any): void {
     super.sendMessage(message);
     this.port.postMessage(message);
   }

package/src/aepp-wallet-communication/connection/BrowserWindowMessage.ts

@@ -77,7 +77,7 @@ export default class BrowserWindowMessageConnection extends BrowserConnection {
     return this.listener != null;
   }
 
-  connect(
+  override connect(
     onMessage: (message: any, origin: string, source: MessageEventSource | null) => void,
     onDisconnect: () => void,
   ): void {
@@ -102,7 +102,7 @@ export default class BrowserWindowMessageConnection extends BrowserConnection {
     this.#onDisconnect = onDisconnect;
   }
 
-  disconnect(): void {
+  override disconnect(): void {
     super.disconnect();
     if (this.listener == null || this.#onDisconnect == null) {
       throw new InternalError('Expected to not happen, required for TS');
@@ -113,7 +113,7 @@ export default class BrowserWindowMessageConnection extends BrowserConnection {
     this.#onDisconnect = undefined;
   }
 
-  sendMessage(msg: any): void {
+  override sendMessage(msg: any): void {
     if (this.#target == null) throw new RpcConnectionError('Can\'t send messages without target');
     const message = this.sendDirection != null ? { type: this.sendDirection, data: msg } : msg;
     super.sendMessage(message);

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

@@ -63,8 +63,8 @@ export default class RpcClient <
     }
 
     const request = msg as JsonRpcRequest;
-    let result; let
-      error;
+    let result;
+    let error;
     try {
       if (!(request.method in this.#methods)) throw new RpcMethodNotFoundError();
       const methodName = request.method as keyof LocalApi;

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

@@ -43,7 +43,17 @@ export interface WalletApi {
   [METHODS.address]: () => Promise<Encoded.AccountAddress[]>;
 
   [METHODS.sign]: ((
-    p: { tx: Encoded.Transaction; onAccount: Encoded.AccountAddress; returnSigned: boolean }
+    p: {
+      tx: Encoded.Transaction;
+      onAccount: Encoded.AccountAddress;
+      returnSigned: boolean;
+      /**
+       * @deprecated Wallet provided networkId will be used (current network)
+       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
+       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
+       */
+      networkId: string;
+    }
   ) => Promise<{
     /**
      * @deprecated this is not a hash at all, will be removed later at the same time