@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/utils/hd-wallet.js

@@ -1,8 +1,11 @@
 import nacl from 'tweetnacl'
 import { full as hmac } from 'tweetnacl-auth'
 import { fromString } from 'bip32-path'
-import { validateMnemonic, mnemonicToSeed, generateMnemonic as genMnemonic } from '@aeternity/bip39'
-import { decryptKey, encodeBase58Check, encryptKey } from './crypto'
+import { decryptKey, encryptKey } from './crypto'
+import { encode } from '../tx/builder/helpers'
+import {
+  InvalidDerivationPathError, NotHardenedSegmentError, UnsupportedChildIndexError
+} from './errors'
 
 const ED25519_CURVE = Buffer.from('ed25519 seed')
 const HARDENED_OFFSET = 0x80000000
@@ -13,7 +16,7 @@ export function derivePathFromKey (path, key) {
   const segments = path === '' ? [] : fromString(path).toPathArray()
   segments.forEach((segment, i) => {
     if (segment < HARDENED_OFFSET) {
-      throw new Error(`Segment #${i + 1} is not hardened`)
+      throw new NotHardenedSegmentError(`Segment #${i + 1} is not hardened`)
     }
   })
 
@@ -22,7 +25,7 @@ export function derivePathFromKey (path, key) {
 
 export function derivePathFromSeed (path, seed) {
   if (!['m', 'm/'].includes(path.slice(0, 2))) {
-    throw new Error('Invalid path')
+    throw new InvalidDerivationPathError()
   }
   const masterKey = getMasterKeyFromSeed(seed)
   return derivePathFromKey(path.slice(2), masterKey)
@@ -32,7 +35,7 @@ function formatAccount (keys) {
   const { secretKey, publicKey } = keys
   return {
     secretKey: toHex(secretKey),
-    publicKey: `ak_${encodeBase58Check(publicKey)}`
+    publicKey: encode(publicKey, 'ak')
   }
 }
 
@@ -40,10 +43,6 @@ export function getKeyPair (secretKey) {
   return nacl.sign.keyPair.fromSeed(secretKey)
 }
 
-export function generateMnemonic () {
-  return genMnemonic()
-}
-
 export function getMasterKeyFromSeed (seed) {
   const I = hmac(seed, ED25519_CURVE)
   const IL = I.slice(0, 32)
@@ -56,7 +55,7 @@ export function getMasterKeyFromSeed (seed) {
 
 export function deriveChild ({ secretKey, chainCode }, index) {
   if (index < HARDENED_OFFSET) {
-    throw new Error(`Child index #${index} is not supported`)
+    throw new UnsupportedChildIndexError(index)
   }
   const indexBuffer = Buffer.allocUnsafe(4)
   indexBuffer.writeUInt32BE(index, 0)
@@ -72,11 +71,7 @@ export function deriveChild ({ secretKey, chainCode }, index) {
   }
 }
 
-export function generateSaveHDWallet (mnemonic, password) {
-  if (!validateMnemonic(mnemonic)) {
-    throw new Error('Invalid mnemonic')
-  }
-  const seed = mnemonicToSeed(mnemonic)
+export function generateSaveHDWalletFromSeed (seed, password) {
   const walletKey = derivePathFromSeed('m/44h/457h', seed)
   return {
     secretKey: toHex(encryptKey(password, walletKey.secretKey)),
@@ -94,8 +89,7 @@ export function getSaveHDWalletAccounts (saveHDWallet, password, accountCount) {
       formatAccount(getKeyPair(derivePathFromKey(`${idx}h/0h/0h`, walletKey).secretKey)))
 }
 
-export const getHdWalletAccountFromMnemonic = (mnemonic, accountIdx) => {
-  const seed = mnemonicToSeed(mnemonic)
+export const getHdWalletAccountFromSeed = (seed, accountIdx) => {
   const walletKey = derivePathFromSeed('m/44h/457h', seed)
   const derived = derivePathFromKey(`${accountIdx}h/0h/0h`, walletKey)
   const keyPair = getKeyPair(derived.secretKey)
@@ -104,12 +98,3 @@ export const getHdWalletAccountFromMnemonic = (mnemonic, accountIdx) => {
     idx: accountIdx
   }
 }
-
-export default {
-  getHdWalletAccountFromMnemonic,
-  getSaveHDWalletAccounts,
-  generateSaveHDWallet,
-  generateMnemonic,
-  deriveChild,
-  getMasterKeyFromSeed
-}

package/src/utils/keystore.js

@@ -1,10 +1,11 @@
 import nacl from 'tweetnacl'
-import { v4 as uuid } from 'uuid'
-
-import { encodeBase58Check } from './crypto'
+import { v4 as uuid } from '@aeternity/uuid'
+import { ArgonType, hash } from '@aeternity/argon2-browser/dist/argon2-bundled.min.js'
+import { encode } from '../tx/builder/helpers'
 import { str2buf } from './bytes'
-
-const _sodium = require('libsodium-wrappers-sumo')
+import {
+  ArgumentError, InvalidKeyError, UnsupportedAlgorithmError, InvalidPasswordError
+} from './errors'
 
 /**
  * KeyStore module
@@ -31,24 +32,18 @@ const DERIVED_KEY_FUNCTIONS = {
   argon2id: deriveKeyUsingArgon2id
 }
 
-export async function deriveKeyUsingArgon2id (password, salt, options) {
-  const { memlimit_kib: memoryCost, opslimit: timeCost } = options.kdf_params
-  // const isBrowser = !(typeof module !== 'undefined' && module.exports)
-
-  return _sodium.ready.then(async () => {
-    // tslint:disable-next-line:typedef
-    const sodium = _sodium
-
-    const result = sodium.crypto_pwhash(
-      32,
-      password,
-      salt,
-      timeCost,
-      memoryCost * 1024,
-      sodium.crypto_pwhash_ALG_ARGON2ID13
-    )
-    return Buffer.from(result)
-  })
+export async function deriveKeyUsingArgon2id (pass, salt, options) {
+  const { memlimit_kib: mem, opslimit: time } = options.kdf_params
+
+  const result = (await hash({
+    hashLen: 32,
+    pass,
+    salt,
+    time,
+    mem,
+    type: ArgonType.Argon2id
+  })).hash
+  return Buffer.from(result)
 }
 
 // CRYPTO PART
@@ -62,65 +57,66 @@ function encryptXsalsa20Poly1305 ({ plaintext, key, nonce }) {
 
 function decryptXsalsa20Poly1305 ({ ciphertext, key, nonce }) {
   const res = nacl.secretbox.open(ciphertext, nonce, key)
-  if (!res) throw new Error('Invalid password or nonce')
+  if (!res) throw new InvalidPasswordError('Invalid password or nonce')
   return res
 }
 
 /**
  * Symmetric private key encryption using secret (derived) key.
- * @param {buffer|string} plaintext Data to be encrypted.
- * @param {buffer|string} key Secret key.
- * @param {buffer|string} nonce Randomly generated nonce.
+ * @param {Buffer|string} plaintext Data to be encrypted.
+ * @param {Buffer|string} key Secret key.
+ * @param {Buffer|string} nonce Randomly generated nonce.
  * @param {string=} algo Encryption algorithm (default: DEFAULTS.crypto.symmetric_alg).
- * @return {buffer} Encrypted data.
+ * @return {Buffer} Encrypted data.
  */
 function encrypt (plaintext, key, nonce, algo = DEFAULTS.crypto.symmetric_alg) {
-  if (!CRYPTO_FUNCTIONS[algo]) throw new Error(algo + ' is not available')
+  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)
   return CRYPTO_FUNCTIONS[algo].encrypt({ plaintext, nonce, key })
 }
 
 /**
  * Symmetric private key decryption using secret (derived) key.
- * @param {buffer|Uint8Array} ciphertext Data to be decrypted.
- * @param {buffer|Uint8Array} key Secret key.
- * @param {buffer|Uint8Array} nonce Nonce from key-object.
+ * @param {Buffer|Uint8Array} ciphertext Data to be decrypted.
+ * @param {Buffer|Uint8Array} key Secret key.
+ * @param {Buffer|Uint8Array} nonce Nonce from key-object.
  * @param {string=} algo Encryption algorithm.
- * @return {buffer} Decrypted data.
+ * @return {Buffer} Decrypted data.
  */
 function decrypt (ciphertext, key, nonce, algo) {
-  if (!CRYPTO_FUNCTIONS[algo]) throw new Error(algo + ' is not available')
+  if (!CRYPTO_FUNCTIONS[algo]) throw new UnsupportedAlgorithmError(algo)
   return CRYPTO_FUNCTIONS[algo].decrypt({ ciphertext, nonce, key })
 }
 
 /**
  * Derive secret key from password with key derivation function.
  * @param {string} password User-supplied password.
- * @param {buffer|Uint8Array} nonce Randomly generated nonce.
+ * @param {Buffer|Uint8Array} nonce Randomly generated nonce.
  * @param {Object=} options Encryption parameters.
  * @param {string=} options.kdf Key derivation function (default: DEFAULTS.crypto.kdf).
  * @param {Object=} options.kdf_params KDF parameters (default: DEFAULTS.crypto.kdf_params).
- * @return {buffer} Secret key derived from password.
+ * @return {Buffer} Secret key derived from password.
  */
 async function deriveKey (password, nonce, options = {
   kdf_params: DEFAULTS.crypto.kdf_params,
   kdf: DEFAULTS.crypto.kdf
 }) {
-  if (typeof password === 'undefined' || password === null || !nonce) {
-    throw new Error('Must provide password and nonce to derive a key')
-  }
+  if (!nonce) throw new ArgumentError('nonce', 'provided', nonce)
+  if (password == null) throw new ArgumentError('password', 'provided', password)
 
-  if (!Object.prototype.hasOwnProperty.call(DERIVED_KEY_FUNCTIONS, options.kdf)) throw new Error('Unsupported kdf type')
+  if (!Object.prototype.hasOwnProperty.call(DERIVED_KEY_FUNCTIONS, options.kdf)) {
+    throw new UnsupportedAlgorithmError(options.kdf)
+  }
 
   return DERIVED_KEY_FUNCTIONS[options.kdf](password, nonce, options)
 }
 
 /**
  * Assemble key data object in secret-storage format.
- * @param {buffer} name Key name.
- * @param {buffer} derivedKey Password-derived secret key.
- * @param {buffer} privateKey Private key.
- * @param {buffer} nonce Randomly generated 24byte nonce.
- * @param {buffer} salt Randomly generated 16byte salt.
+ * @param {Buffer} name Key name.
+ * @param {Buffer} derivedKey Password-derived secret key.
+ * @param {Buffer} privateKey Private key.
+ * @param {Buffer} nonce Randomly generated 24byte nonce.
+ * @param {Buffer} salt Randomly generated 16byte salt.
  * @param {Object=} options Encryption parameters.
  * @param {string=} options.kdf Key derivation function (default: argon2id).
  * @param {string=} options.cipher Symmetric cipher (default: constants.cipher).
@@ -148,7 +144,7 @@ function marshal (name, derivedKey, privateKey, nonce, salt, options = {}) {
 export function getAddressFromPriv (secret) {
   const keys = nacl.sign.keyPair.fromSecretKey(str2buf(secret))
   const publicBuffer = Buffer.from(keys.publicKey)
-  return `ak_${encodeBase58Check(publicBuffer)}`
+  return encode(publicBuffer, 'ak')
 }
 
 /**
@@ -170,7 +166,7 @@ export async function recover (password, keyObject) {
     nonce,
     keyObject.crypto.symmetric_alg
   )
-  if (!key) throw new Error('Invalid password')
+  if (!key) throw new InvalidPasswordError('Invalid password')
 
   if (Buffer.from(key).length === 64) return Buffer.from(key).toString('hex')
   return Buffer.from(key).toString('utf-8')
@@ -180,7 +176,7 @@ export async function recover (password, keyObject) {
  * Export private key to keystore secret-storage format.
  * @param {String} name Key name.
  * @param {String} password User-supplied password.
- * @param {String} privateKey Private key.
+ * @param {String|Buffer} privateKey Private key as hex-string or a Buffer.
  * @param {Buffer} nonce Randomly generated 24byte nonce.
  * @param {Buffer} salt Randomly generated 16byte salt.
  * @param {Object=} options Encryption parameters.
@@ -189,12 +185,19 @@ export async function recover (password, keyObject) {
  * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
  * @return {Object}
  */
-export async function dump (name, password, privateKey, nonce = nacl.randomBytes(24), salt = nacl.randomBytes(16), options = {}) {
+export async function dump (
+  name,
+  password,
+  privateKey,
+  nonce = nacl.randomBytes(24),
+  salt = nacl.randomBytes(16),
+  options = {}
+) {
   const opt = Object.assign({}, DEFAULTS.crypto, options)
   return marshal(
     name,
     await deriveKey(password, salt, opt),
-    privateKey,
+    typeof privateKey === 'string' ? Buffer.from(privateKey, 'hex') : privateKey,
     nonce,
     salt,
     opt
@@ -206,10 +209,11 @@ export function validateKeyObj (obj) {
   const cryptoKeys = ['cipher_params', 'ciphertext', 'symmetric_alg', 'kdf', 'kdf_params']
 
   const missingRootKeys = root.filter(key => !Object.prototype.hasOwnProperty.call(obj, key))
-  if (missingRootKeys.length) throw new Error(`Invalid key file format. Require properties: ${missingRootKeys}`)
+  if (missingRootKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingRootKeys}`)
 
-  const missingCryptoKeys = cryptoKeys.filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))
-  if (missingCryptoKeys.length) throw new Error(`Invalid key file format. Require properties: ${missingCryptoKeys}`)
+  const missingCryptoKeys = cryptoKeys
+    .filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))
+  if (missingCryptoKeys.length) throw new InvalidKeyError(`Invalid key file format. Require properties: ${missingCryptoKeys}`)
 
   return true
 }

package/src/utils/mptree.ts

@@ -18,6 +18,12 @@
 import { encode as rlpEncode } from 'rlp'
 import type { Input } from 'rlp'
 import { hash } from './crypto-ts'
+import {
+  MerkleTreeHashMismatchError,
+  MissingNodeInTreeError,
+  UnknownPathNibbleError,
+  UnknownNodeLengthError
+} from './errors'
 
 enum NodeType {
   Branch,
@@ -47,9 +53,9 @@ export default class MPTree {
       binary[1].map((node) => [node[0].toString('hex'), node[1]])
     )
 
-    if (this.nodes[this.rootHash] === undefined) throw new Error('Can\'t find a node by root hash')
+    if (this.nodes[this.rootHash] === undefined) throw new MissingNodeInTreeError('Can\'t find a node by root hash')
     Object.entries(this.nodes).forEach(([key, node]) => {
-      if (MPTree.nodeHash(node) !== key) throw new Error('Node hash is not equal to provided one')
+      if (MPTree.nodeHash(node) !== key) throw new MerkleTreeHashMismatchError()
       const { type, payload } = MPTree.parseNode(node)
       switch (type) {
         case NodeType.Branch:
@@ -58,13 +64,13 @@ export default class MPTree {
             .filter(n => n.length)
             .forEach((n) => {
               if (this.nodes[n.toString('hex')] === undefined) {
-                throw new Error('Can\'t find a node by hash in branch node')
+                throw new MissingNodeInTreeError('Can\'t find a node by hash in branch node')
               }
             })
           break
         case NodeType.Extension:
           if (this.nodes[payload[0].toString('hex')] === undefined) {
-            throw new Error('Can\'t find a node by hash in extension node')
+            throw new MissingNodeInTreeError('Can\'t find a node by hash in extension node')
           }
       }
     })
@@ -81,13 +87,13 @@ export default class MPTree {
       case 2: {
         const path = node[0].toString('hex')
         const nibble = parseInt(path[0], 16)
-        if (nibble > 3) throw new Error(`Unknown path nibble: ${nibble}`)
+        if (nibble > 3) throw new UnknownPathNibbleError(nibble)
         const type = nibble <= 1 ? NodeType.Extension : NodeType.Leaf
         const slice = [0, 2].includes(nibble) ? 2 : 1
         return { type, payload: [node[1]], path: path.slice(slice) }
       }
       default:
-        throw new Error(`Unknown node length: ${node.length}`)
+        throw new UnknownNodeLengthError(node.length)
     }
   }
 

package/src/utils/other.ts

@@ -1,6 +1,6 @@
 import { snakeToPascal, pascalToSnake } from './string'
 
-export const pause = async (duration: number): Promise<undefined> =>
+export const pause = async (duration: number): Promise<void> =>
   await new Promise(resolve => setTimeout(resolve, duration))
 
 export const mapObject = (

package/src/utils/semver-satisfies.ts

@@ -1,6 +1,6 @@
 export default function (version: string, geVersion: string, ltVersion: string): boolean {
   const getComponents = (v: string): number[] => v
-    .split('-')[0].split('.').map(i => +i)
+    .split(/[-+]/)[0].split('.').map(i => +i)
 
   const versionComponents = getComponents(version)
   const geComponents = getComponents(geVersion)

package/src/utils/swagger.js

@@ -25,6 +25,8 @@ import SwaggerClient from 'swagger-client'
 import fetch from 'cross-fetch'
 import JsonBig from './json-big'
 import { snakizeKeys, pascalizeKeys, mapObject, filterObject } from './other'
+import { ArgumentCountMismatchError } from './errors'
+import { snakeToPascal } from './string'
 
 let warnedAboutInternalApiUsage = false
 
@@ -39,40 +41,52 @@ let warnedAboutInternalApiUsage = false
  * @param {String} [options.internalUrl] - Node internal URL
  * @param {Boolean} [options.disableBigNumbers]
  * @param {Boolean} [options.disableCaseConversion]
+ * @param {Function} [options.responseInterceptor]
  * @return {Object} Swagger client
  * @example (await genSwaggerClient('https://mainnet.aeternity.io/api')).getAccountByPubkey('ak_jupBUgZNbcC4krDLR3tAkw1iBZoBbkNeShAq4atBtpFWmz36r')
  */
-export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCaseConversion } = {}) => {
+export default async (
+  specUrl,
+  { spec, internalUrl, disableBigNumbers, disableCaseConversion, responseInterceptor } = {}
+) => {
   spec = spec || await (await fetch(specUrl)).json()
   const jsonImp = disableBigNumbers ? JSON : JsonBig
 
-  if (
-    [
-      'https://compiler.aepps.com',
-      'https://latest.compiler.aepps.com'
-    ].includes(new URL(specUrl).origin) ||
-    new URL(specUrl).origin.includes('https://')
-  ) {
-    spec.schemes = ['https']
-  }
-
   const [external, internal] = await Promise.all([specUrl, internalUrl].map((url) => {
     if (!url) return null
+    const pendingGetRequests = {}
     return SwaggerClient({
       url,
       spec,
+      requestInterceptor: request => {
+        if (request.method !== 'GET') return
+        return {
+          ...request,
+          userFetch: async (url, request) => {
+            const key = JSON.stringify({ ...request, url })
+            pendingGetRequests[key] ??= fetch(url, request)
+            try {
+              return (await pendingGetRequests[key]).clone()
+            } finally {
+              delete pendingGetRequests[key]
+            }
+          }
+        }
+      },
       responseInterceptor: response => {
-        if (!response.text) return response
+        if (response.text === '' || response.text?.size === 0) return response
         const body = jsonImp.parse(response.text)
-        return Object.assign(response, {
+        Object.assign(response, {
           body: disableCaseConversion ? body : pascalizeKeys(body)
         })
+        return (responseInterceptor && responseInterceptor(response)) || response
       }
     })
   }))
 
-  const combinedApi = [
-    ...Object.values(external.apis),
+  const combinedApi = Object.assign(
+    {},
+    ...external.apis.external ? [external.apis.external] : Object.values(external.apis),
     mapObject(internal?.apis.internal || {}, ([key, handler]) => [key, (...args) => {
       if (!warnedAboutInternalApiUsage) {
         console.warn(
@@ -84,43 +98,59 @@ export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCa
       }
       return handler(...args)
     }])
-  ].reduce((acc, n) => ({ ...acc, ...n }))
+  )
 
   const opSpecs = Object.values(spec.paths)
     .map(paths => Object.values(paths))
     .flat()
     .reduce((acc, n) => ({ ...acc, [n.operationId]: n }), {})
 
-  const api = mapObject(combinedApi, ([opId, handler]) => [
-    opId.slice(0, 1).toLowerCase() + opId.slice(1),
-    async (...args) => {
-      const opSpec = opSpecs[opId]
-      const parameters = [
-        ...opSpec.parameters,
-        ...opSpec.requestBody ? [{
-          required: opSpec.requestBody.required,
-          schema: Object.values(opSpec.requestBody.content)[0].schema,
-          name: '__requestBody'
-        }] : []
-      ]
-      const required = parameters.filter(param => param.required).map(p => p.name)
-      if (args.length < required.length) throw new Error('swagger: Not enough arguments')
-      const values = required.reduce(
-        (acc, req, idx) => ({ ...acc, [req]: args[idx] }),
-        args[required.length] || {}
-      )
-      const { __requestBody, ...stringified } = mapObject(values, ([param, value]) => {
-        if (typeof value !== 'object') return [param, value]
-        const rootKeys = Object.keys(parameters.find(p => p.name === param).schema.properties)
-        const filteredValue = filterObject(
-          disableCaseConversion ? value : snakizeKeys(value),
-          ([key]) => rootKeys.includes(key)
+  const requestQueues = {}
+  const api = mapObject(combinedApi, ([opId, handler]) => {
+    const functionName = opId.slice(0, 1).toLowerCase() + snakeToPascal(opId.slice(1))
+    return [
+      functionName,
+      async (...args) => {
+        const opSpec = opSpecs[opId]
+        const parameters = [
+          ...opSpec.parameters,
+          ...opSpec.requestBody
+            ? [{
+                required: opSpec.requestBody.required,
+                schema: Object.values(opSpec.requestBody.content)[0].schema,
+                name: '__requestBody'
+              }]
+            : []
+        ]
+        const required = parameters.filter(param => param.required).map(p => p.name)
+        if (![0, 1].includes(args.length - required.length)) {
+          throw new ArgumentCountMismatchError(functionName, required.length, args.length)
+        }
+        const values = required.reduce(
+          (acc, req, idx) => ({ ...acc, [req]: args[idx] }),
+          args[required.length] || {}
         )
-        return [param, jsonImp.stringify(filteredValue)]
-      })
-      return (await handler(stringified, { requestBody: __requestBody })).body
-    }
-  ])
+        const { __requestBody, __queue, ...stringified } = mapObject(values, ([param, value]) => {
+          if (typeof value !== 'object') return [param, value]
+          const rootKeys = Object.keys(parameters.find(p => p.name === param).schema.properties)
+          const filteredValue = filterObject(
+            disableCaseConversion ? value : snakizeKeys(value),
+            ([key]) => rootKeys.includes(key)
+          )
+          return [param, jsonImp.stringify(filteredValue)]
+        })
+
+        const request = async () => (await handler(stringified, { requestBody: __requestBody }))
+          .body
+        if (!__queue) return request()
+        const res = (requestQueues[__queue] ?? Promise.resolve()).then(request, request)
+        // TODO: remove after fixing https://github.com/aeternity/aeternity/issues/3803
+        // gap to ensure that node won't reject the nonce
+        requestQueues[__queue] = res.then(() => new Promise(resolve => setTimeout(resolve, 750)))
+        return res
+      }
+    ]
+  })
 
   return Object.assign(external, { api })
 }