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

package/src/utils/encoder.ts

@@ -18,7 +18,6 @@ export { Encoded, Encoding };
  * Calculate SHA256 hash of `input`
  * @param input - Data to hash
  * @returns Hash
- * @deprecated use `SubtleCrypto.digest` or `sha.js` package instead
  */
 export function sha256hash(input: Uint8Array | string): Buffer {
   return new Sha256().update(input).digest();

package/src/utils/errors.ts

@@ -1,5 +1,6 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
+import { Int } from '../tx/builder/constants';
 
 /**
  * aepp-sdk originated error
@@ -116,8 +117,8 @@ export class WalletError extends BaseError {
  * @category exception
  */
 export class ArgumentError extends BaseError {
-  constructor(argumentName: string, requirement: string, argumentValue: any) {
-    super(`${argumentName} should be ${requirement}, got ${String(argumentValue)} instead`);
+  constructor(argumentName: string, requirement: unknown, argumentValue: unknown) {
+    super(`${argumentName} should be ${requirement}, got ${argumentValue} instead`);
     this.name = 'ArgumentError';
   }
 }
@@ -265,16 +266,6 @@ export class UnexpectedTsError extends InternalError {
   }
 }
 
-/**
- * @category exception
- */
-export class InvalidKeypairError extends AccountError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InvalidKeypairError';
-  }
-}
-
 /**
  * @category exception
  */
@@ -405,6 +396,22 @@ export class UnexpectedChannelMessageError extends ChannelError {
   }
 }
 
+/**
+ * @category exception
+ */
+export class ChannelIncomingMessageError extends ChannelError {
+  handlerError: BaseError;
+
+  incomingMessage: { [key: string]: any };
+
+  constructor(handlerError: BaseError, incomingMessage: { [key: string]: any }) {
+    super(handlerError.message);
+    this.handlerError = handlerError;
+    this.incomingMessage = incomingMessage;
+    this.name = 'ChannelIncomingMessageError';
+  }
+}
+
 /**
  * @category exception
  */
@@ -522,7 +529,7 @@ export class NoSuchContractFunctionError extends ContractError {
  * @category exception
  */
 export class NotPayableFunctionError extends ContractError {
-  constructor(amount: string, fn: string) {
+  constructor(amount: Int, fn: string) {
     super(
       `You try to pay "${amount}" to function "${fn}" which is not payable. `
       + 'Only payable function can accept coins',
@@ -550,8 +557,8 @@ export class MissingEventDefinitionError extends ContractError {
 export class AmbiguousEventDefinitionError extends ContractError {
   constructor(eventAddress: string, matchedEvents: Array<[string, string]>) {
     super(
-      `Found multiple definitions of "${matchedEvents[0][1]}" event emitted by ${eventAddress}`
-      + ` in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
+      `Found multiple definitions of "${matchedEvents[0][1]}" event with different types emitted by`
+      + ` ${eventAddress} in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
       + ' (use contractAddressToName option to specify contract name corresponding to address)',
     );
     this.name = 'AmbiguousEventDefinitionError';
@@ -738,16 +745,6 @@ export class TxNotInChainError extends TransactionError {
   }
 }
 
-/**
- * @category exception
- */
-export class UnknownTxError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnknownTxError';
-  }
-}
-
 /**
  * @category exception
  */

package/src/utils/hd-wallet.ts

@@ -4,20 +4,18 @@ import { fromString } from 'bip32-path';
 import aesjs from 'aes-js';
 import { sha256hash, encode, Encoding } from './encoder';
 import { CryptographyError } from './errors';
-import { bytesToHex } from './bytes';
 import { concatBuffers } from './other';
 
 const Ecb = aesjs.ModeOfOperation.ecb;
 
-// TODO: at least don't export `encryptKey` and `decryptKey`
+// TODO: use mnemonic encryption instead of AES
 /**
  * Encrypt given data using `password`
  * @param password - Password to encrypt with
  * @param binaryData - Data to encrypt
  * @returns Encrypted data
- * @deprecated use 'sha.js' and 'aes-js' packages directly instead
  */
-export function encryptKey(password: string, binaryData: Uint8Array): Uint8Array {
+function encryptKey(password: string, binaryData: Uint8Array): Uint8Array {
   const hashedPasswordBytes = sha256hash(password);
   const aesEcb = new Ecb(hashedPasswordBytes);
   return aesEcb.encrypt(binaryData);
@@ -28,9 +26,8 @@ export function encryptKey(password: string, binaryData: Uint8Array): Uint8Array
  * @param password - Password to decrypt with
  * @param encrypted - Data to decrypt
  * @returns Decrypted data
- * @deprecated use 'sha.js' and 'aes-js' packages directly instead
  */
-export function decryptKey(password: string, encrypted: Uint8Array): Uint8Array {
+function decryptKey(password: string, encrypted: Uint8Array): Uint8Array {
   const encryptedBytes = Buffer.from(encrypted);
   const hashedPasswordBytes = sha256hash(password);
   const aesEcb = new Ecb(hashedPasswordBytes);
@@ -72,6 +69,9 @@ type Bip32PathT<MaxLen extends number, H extends 'H' | 'h' | '\''> = MaxLen exte
 type Bip32Path<MaxLen extends number> =
   '' | Bip32PathT<MaxLen, 'H'> | Bip32PathT<MaxLen, 'h'> | Bip32PathT<MaxLen, '\''>;
 
+/**
+ * @category hd-wallet
+ */
 export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number): KeyTreeNode {
   if (index < HARDENED_OFFSET) {
     throw new DerivationError(`Segment ${index} is not hardened`);
@@ -90,6 +90,9 @@ export function deriveChild({ secretKey, chainCode }: KeyTreeNode, index: number
   };
 }
 
+/**
+ * @category hd-wallet
+ */
 export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTreeNode {
   const segments = path === '' ? [] : fromString(path).toPathArray();
   segments.forEach((segment, i) => {
@@ -101,6 +104,9 @@ export function derivePathFromKey(path: Bip32Path<5>, key: KeyTreeNode): KeyTree
   return segments.reduce((parentKey, segment) => deriveChild(parentKey, segment), key);
 }
 
+/**
+ * @category hd-wallet
+ */
 export function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode {
   const I = hmac(seed, ED25519_CURVE);
   const IL = I.slice(0, 32);
@@ -111,6 +117,9 @@ export function getMasterKeyFromSeed(seed: Uint8Array): KeyTreeNode {
   };
 }
 
+/**
+ * @category hd-wallet
+ */
 export function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8Array): KeyTreeNode {
   if (!['m', 'm/'].includes(path.slice(0, 2))) {
     throw new DerivationError('Root element is required');
@@ -122,23 +131,32 @@ export function derivePathFromSeed(path: 'm' | `m/${Bip32Path<5>}`, seed: Uint8A
 function formatAccount(keys: nacl.SignKeyPair): Account {
   const { secretKey, publicKey } = keys;
   return {
-    secretKey: bytesToHex(secretKey),
+    secretKey: Buffer.from(secretKey).toString('hex'),
     publicKey: encode(publicKey, Encoding.AccountAddress),
   };
 }
 
+/**
+ * @category hd-wallet
+ */
 export function getKeyPair(secretKey: Uint8Array): nacl.SignKeyPair {
   return nacl.sign.keyPair.fromSeed(secretKey);
 }
 
+/**
+ * @category hd-wallet
+ */
 export function generateSaveHDWalletFromSeed(seed: Uint8Array, password: string): HDWallet {
   const walletKey = derivePathFromSeed('m/44h/457h', seed);
   return {
-    secretKey: bytesToHex(encryptKey(password, walletKey.secretKey)),
-    chainCode: bytesToHex(encryptKey(password, walletKey.chainCode)),
+    secretKey: Buffer.from(encryptKey(password, walletKey.secretKey)).toString('hex'),
+    chainCode: Buffer.from(encryptKey(password, walletKey.chainCode)).toString('hex'),
   };
 }
 
+/**
+ * @category hd-wallet
+ */
 export function getSaveHDWalletAccounts(
   saveHDWallet: HDWallet,
   password: string,
@@ -152,6 +170,9 @@ export function getSaveHDWalletAccounts(
     .map((_, idx) => formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)));
 }
 
+/**
+ * @category hd-wallet
+ */
 export const getHdWalletAccountFromSeed = (
   seed: Uint8Array,
   accountIdx: number,

package/src/utils/keystore.ts

@@ -1,10 +1,7 @@
 import nacl from 'tweetnacl';
 import { v4 as uuid } from '@aeternity/uuid';
-// js extension is required for mjs build
-// eslint-disable-next-line import/extensions
-import { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js';
+import { hash, argon2id } from '@aeternity/argon2';
 import { getAddressFromPriv } from './crypto';
-import { bytesToHex, hexToBytes } from './bytes';
 import { InvalidPasswordError } from './errors';
 
 const DERIVED_KEY_FUNCTIONS = {
@@ -13,16 +10,15 @@ const DERIVED_KEY_FUNCTIONS = {
     salt: string | Uint8Array,
     params: Partial<Keystore['crypto']['kdf_params']>,
   ): Promise<Uint8Array> {
-    const { memlimit_kib: mem, opslimit: time } = params;
+    const { memlimit_kib: memoryCost, opslimit: timeCost } = params;
 
-    return (await hash({
-      hashLen: 32,
-      pass,
+    return hash(pass, {
+      hashLength: 32,
       salt,
-      time,
-      mem,
-      type: ArgonType.Argon2id,
-    })).hash;
+      timeCost,
+      memoryCost,
+      type: argon2id,
+    });
   },
 };
 
@@ -72,6 +68,7 @@ const CRYPTO_DEFAULTS = {
 
 /**
  * Symmetric private key encryption using secret (derived) key.
+ * @category keystore
  * @param plaintext - Data to be encrypted.
  * @param key - Secret key.
  * @param nonce - Randomly generated nonce.
@@ -89,6 +86,7 @@ function encrypt(
 
 /**
  * Symmetric private key decryption using secret (derived) key.
+ * @category keystore
  * @param ciphertext - Data to be decrypted.
  * @param key - Secret key.
  * @param nonce - Nonce from key-object.
@@ -106,6 +104,7 @@ function decrypt(
 
 /**
  * Derive secret key from password with key derivation function.
+ * @category keystore
  * @param password - User-supplied password.
  * @param nonce - Randomly generated nonce.
  * @param kdf - Key derivation function.
@@ -123,6 +122,7 @@ async function deriveKey(
 
 /**
  * Recover plaintext private key from secret-storage key object.
+ * @category keystore
  * @param password - Keystore object password.
  * @param keystore - Keystore object.
  * @returns Plaintext private key.
@@ -131,17 +131,18 @@ export async function recover(
   password: string | Uint8Array,
   { crypto }: Keystore,
 ): Promise<string> {
-  const salt = hexToBytes(crypto.kdf_params.salt);
-  return bytesToHex(decrypt(
-    hexToBytes(crypto.ciphertext),
+  const salt = Buffer.from(crypto.kdf_params.salt, 'hex');
+  return Buffer.from(decrypt(
+    Buffer.from(crypto.ciphertext, 'hex'),
     await deriveKey(password, salt, crypto.kdf, crypto.kdf_params),
-    hexToBytes(crypto.cipher_params.nonce),
+    Buffer.from(crypto.cipher_params.nonce, 'hex'),
     crypto.symmetric_alg,
-  ));
+  )).toString('hex');
 }
 
 /**
  * Export private key to keystore secret-storage format.
+ * @category keystore
  * @param name - Key name.
  * @param password - User-supplied password.
  * @param privateKey - Private key as hex-string or a Buffer.
@@ -161,7 +162,7 @@ export async function dump(
 ): Promise<Keystore> {
   const opt = { ...CRYPTO_DEFAULTS, ...options };
   const derivedKey = await deriveKey(password, salt, opt.kdf, opt.kdf_params);
-  const payload = typeof privateKey === 'string' ? hexToBytes(privateKey) : privateKey;
+  const payload = typeof privateKey === 'string' ? Buffer.from(privateKey, 'hex') : privateKey;
   return {
     name,
     version: 1,
@@ -170,12 +171,14 @@ export async function dump(
     crypto: {
       secret_type: opt.secret_type,
       symmetric_alg: opt.symmetric_alg,
-      ciphertext: bytesToHex(encrypt(payload, derivedKey, nonce, opt.symmetric_alg)),
-      cipher_params: { nonce: bytesToHex(nonce) },
+      ciphertext: Buffer.from(
+        encrypt(payload, derivedKey, nonce, opt.symmetric_alg),
+      ).toString('hex'),
+      cipher_params: { nonce: Buffer.from(nonce).toString('hex') },
       kdf: opt.kdf,
       kdf_params: {
         ...opt.kdf_params,
-        salt: bytesToHex(salt),
+        salt: Buffer.from(salt).toString('hex'),
       },
     },
   };

package/src/utils/other.ts

@@ -1,3 +1,5 @@
+import { RestError } from '@azure/core-rest-pipeline';
+
 export const pause = async (duration: number): Promise<void> => new Promise((resolve) => {
   setTimeout(resolve, duration);
 });
@@ -30,7 +32,10 @@ export const concatBuffers = isWebpack4Buffer
  * @param key - Maybe object key
  * @param object - Object
  */
-export function isKeyOfObject<T>(key: string | number | symbol, object: T): key is keyof T {
+export function isKeyOfObject<T extends object>(
+  key: string | number | symbol,
+  object: T,
+): key is keyof T {
   return key in object;
 }
 
@@ -42,3 +47,13 @@ export function isKeyOfObject<T>(key: string | number | symbol, object: T): key
 export function isItemOfArray<T>(item: any, array: readonly T[]): item is T {
   return array.includes(item);
 }
+
+export function isAccountNotFoundError(error: Error): boolean {
+  return error instanceof RestError && error.statusCode === 404
+    && error.message.includes('Account not found');
+}
+
+// based on https://stackoverflow.com/a/50375286/6176994
+export type UnionToIntersection<Union> =
+  (Union extends any ? (k: Union) => void : never) extends ((k: infer Intersection) => void)
+    ? Intersection : never;

package/src/utils/string.ts

@@ -32,23 +32,3 @@ export function snakeToPascal(s: string): string {
 export function pascalToSnake(s: string): string {
   return s.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`);
 }
-
-/**
- * Check whether a string is valid hex.
- * @param str - String to validate.
- * @returns True if the string is valid hex, false otherwise.
- */
-export function isHex(str: string): boolean {
-  return str.length % 2 === 0 && /^[0-9a-f]+$/i.test(str);
-}
-
-/**
- * Check whether a string is valid base-64.
- * @param str - String to validate.
- * @returns True if the string is valid base-64, false otherwise.
- */
-export function isBase64(str: string): boolean {
-  if (str.length % 4 > 0 || /[^0-9a-z+/=]/i.test(str)) return false;
-  const index = str.indexOf('=');
-  return index === -1 || /={1,2}/.test(str.slice(index));
-}

package/types-legacy/ts4.2/AeSdk.d.ts

@@ -0,0 +1,41 @@
+import AeSdkBase from './AeSdkBase';
+import { OnAccount } from './AeSdkMethods';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+export default class AeSdk extends AeSdkBase {
+    accounts: {
+        [key: string]: AccountBase;
+    };
+    selectedAddress?: Encoded.AccountAddress;
+    constructor({ accounts, ...options }?: {
+        accounts?: AccountBase[];
+    } & ConstructorParameters<typeof AeSdkBase>[0]);
+    _resolveAccount(account?: OnAccount): AccountBase;
+    /**
+     * Get accounts addresses
+     * @example addresses()
+     */
+    addresses(): Encoded.AccountAddress[];
+    /**
+     * Add specific account
+     * @param account - Account instance
+     * @param options - Options
+     * @param options.select - Select account
+     * @example addAccount(account)
+     */
+    addAccount(account: AccountBase, { select }?: {
+        select?: boolean;
+    }): void;
+    /**
+     * Remove specific account
+     * @param address - Address of account to remove
+     * @example removeAccount(address)
+     */
+    removeAccount(address: Encoded.AccountAddress): void;
+    /**
+     * Select specific account
+     * @param address - Address of account to select
+     * @example selectAccount('ak_xxxxxxxx')
+     */
+    selectAccount(address: Encoded.AccountAddress): void;
+}

package/types-legacy/ts4.2/AeSdkAepp.d.ts

@@ -0,0 +1,71 @@
+import AeSdkBase from './AeSdkBase';
+import { OnAccount } from './AeSdkMethods';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import { Accounts, WalletInfo, Network, WalletApi, AeppApi } from './aepp-wallet-communication/rpc/types';
+import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
+import { METHODS, SUBSCRIPTION_TYPES } from './aepp-wallet-communication/schema';
+import BrowserConnection from './aepp-wallet-communication/connection/Browser';
+/**
+ * RPC handler for AEPP side
+ * Contain functionality for wallet interaction and connect it to sdk
+ * @category aepp wallet communication
+ */
+export default class AeSdkAepp extends AeSdkBase {
+    name: string;
+    onAddressChange: (a: Accounts) => void;
+    onDisconnect: (p: any) => void;
+    onNetworkChange: (a: Network) => void;
+    rpcClient?: RpcClient<WalletApi, AeppApi>;
+    _accounts?: Accounts;
+    /**
+     * @param options - Options
+     * @param options.name - Aepp name
+     * @param options.onAddressChange - Call-back function for update address event
+     * @param options.onDisconnect - Call-back function for disconnect event
+     * @param options.onNetworkChange - Call-back function for update network event
+     */
+    constructor({ name, onAddressChange, onDisconnect, onNetworkChange, ...other }: {
+        name: string;
+        onAddressChange?: (a: Accounts) => void;
+        onDisconnect?: (p: any) => void;
+        onNetworkChange?: (a: Network) => void;
+    } & ConstructorParameters<typeof AeSdkBase>[0]);
+    _resolveAccount(account?: OnAccount): AccountBase;
+    addresses(): Encoded.AccountAddress[];
+    /**
+     * Connect to wallet
+     * @param connection - Wallet connection object
+     * @param options - Options
+     * @param options.connectNode - Request wallet to bind node
+     * @param options.name - Node name
+     * @param options.select - Select this node as current
+     */
+    connectToWallet(connection: BrowserConnection, { connectNode, name, select }?: {
+        connectNode?: boolean;
+        name?: string;
+        select?: boolean;
+    }): Promise<WalletInfo>;
+    /**
+     * Disconnect from wallet
+     */
+    disconnectWallet(): void;
+    /**
+     * Ask addresses from wallet
+     * @returns Addresses from wallet
+     */
+    askAddresses(): Promise<Encoded.AccountAddress[]>;
+    /**
+     * Subscribe for addresses from wallet
+     * @param type - Subscription type
+     * @param value - Should be one of 'current' (the selected account), 'connected' (all)
+     * @returns Accounts from wallet
+     */
+    subscribeAddress(type: SUBSCRIPTION_TYPES, value: 'current' | 'connected'): Promise<ReturnType<WalletApi[METHODS.subscribeAddress]>>;
+    _ensureConnected(): asserts this is AeSdkAepp & {
+        rpcClient: NonNullable<AeSdkAepp['rpcClient']>;
+    };
+    _ensureAccountAccess(): asserts this is AeSdkAepp & {
+        rpcClient: NonNullable<AeSdkAepp['rpcClient']>;
+    };
+}

package/types-legacy/ts4.2/AeSdkBase.d.ts

@@ -0,0 +1,91 @@
+import Node from './Node';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
+import AeSdkMethods, { OnAccount } from './AeSdkMethods';
+type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
+    name: string;
+};
+/**
+ * Basic AeSdk class implements:
+ * - node selector,
+ * - integrated compiler support,
+ * - wrappers of account methods mapped to the current account.
+ */
+export default class AeSdkBase extends AeSdkMethods {
+    pool: Map<string, Node>;
+    selectedNodeName?: string;
+    /**
+     * @param options - Options
+     * @param options.nodes - Array of nodes
+     */
+    constructor({ nodes, ...options }?: ConstructorParameters<typeof AeSdkMethods>[0] & {
+        nodes?: Array<{
+            name: string;
+            instance: Node;
+        }>;
+    });
+    get compilerApi(): CompilerBase;
+    get api(): Node;
+    /**
+     * Add Node
+     * @param name - Node name
+     * @param node - Node instance
+     * @param select - Select this node as current
+     * @example
+     * ```js
+     * // add and select new node with name 'testNode'
+     * aeSdkBase.addNode('testNode', new Node({ url }), true)
+     * ```
+     */
+    addNode(name: string, node: Node, select?: boolean): void;
+    /**
+     * Select Node
+     * @param name - Node name
+     * @example
+     * nodePool.selectNode('testNode')
+     */
+    selectNode(name: string): void;
+    /**
+     * Check if you have selected node
+     * @example
+     * nodePool.isNodeConnected()
+     */
+    isNodeConnected(): this is AeSdkBase & {
+        selectedNodeName: string;
+    };
+    protected ensureNodeConnected(): asserts this is AeSdkBase & {
+        selectedNodeName: string;
+    };
+    /**
+     * Get information about node
+     * @example
+     * ```js
+     * nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
+     * ```
+     */
+    getNodeInfo(): Promise<NodeInfo>;
+    /**
+     * Get array of available nodes
+     * @example
+     * nodePool.getNodesInPool()
+     */
+    getNodesInPool(): Promise<NodeInfo[]>;
+    addresses(): Encoded.AccountAddress[];
+    get address(): Encoded.AccountAddress;
+    sign(data: string | Uint8Array, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    }): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    signMessage(message: string, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signMessage']>[1]): Promise<Uint8Array>;
+    _getOptions(): {
+        onNode: Node;
+        onAccount: AccountBase;
+        onCompiler: CompilerBase;
+    };
+}
+export {};