@aeternity/aepp-sdk 10.0.0-beta.1 → 10.0.0

package/src/utils/aepp-wallet-communication/helpers.js

@@ -51,9 +51,11 @@ export const getHandler = (schema, msg, { debug = false } = {}) => {
 
 export const message = (method, params = {}) => ({ method, params })
 
-export const responseMessage = (id, method, { error, result } = {}) => ({ id, method, ...(error ? { error } : { result }) })
+export const responseMessage = (id, method, { error, result } = {}) =>
+  ({ id, method, ...(error ? { error } : { result }) })
 
-export const sendResponseMessage = (client) => (id, method, data) => client.sendMessage(responseMessage(id, method, data), true)
+export const sendResponseMessage = (client) => (id, method, data) =>
+  client.sendMessage(responseMessage(id, method, data), true)
 
 export const voidFn = () => undefined
 

package/src/utils/aepp-wallet-communication/rpc/aepp-rpc.js

@@ -3,7 +3,9 @@
  *
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc
  * @export AeppRpc
- * @example import ContentScriptBridge from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
+ * @example
+ * import ContentScriptBridge
+ * from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
  */
 import { v4 as uuid } from 'uuid'
 import Ae from '../../../ae'
@@ -40,15 +42,21 @@ const RESPONSES = {
   [METHODS.aepp.subscribeAddress]: (instance) =>
     (msg) => {
       if (msg.result) {
-        msg.result.address && (instance.rpcClient.accounts = msg.result.address)
-        msg.result.subscription && (instance.rpcClient.addressSubscription = msg.result.subscription)
+        if (msg.result.address) {
+          instance.rpcClient.accounts = msg.result.address
+        }
+        if (msg.result.subscription) {
+          instance.rpcClient.addressSubscription = msg.result.subscription
+        }
       }
 
       instance.rpcClient.processResponse(msg, ({ id, result }) => [result])
     },
   [METHODS.aepp.sign]: (instance) =>
     (msg) => {
-      instance.rpcClient.processResponse(msg, ({ id, result }) => [result.signedTransaction || result.transactionHash])
+      instance.rpcClient.processResponse(
+        msg, ({ id, result }) => [result.signedTransaction || result.transactionHash]
+      )
     },
   [METHODS.aepp.signMessage]: (instance) =>
     (msg) => {
@@ -82,7 +90,15 @@ const handleMessage = (instance) => async (msg) => {
  * @return {Object}
  */
 export default Ae.compose({
-  async init ({ name, onAddressChange = voidFn, onDisconnect = voidFn, onNetworkChange = voidFn, connection, forceValidation = false, debug = false }) {
+  async init ({
+    name,
+    onAddressChange = voidFn,
+    onDisconnect = voidFn,
+    onNetworkChange = voidFn,
+    connection,
+    forceValidation = false,
+    debug = false
+  }) {
     const eventsHandlers = ['onDisconnect', 'onAddressChange', 'onNetworkChange']
     this.connection = connection
     this.name = name
@@ -166,7 +182,7 @@ export default Ae.compose({
      * @function subscribeAddress
      * @instance
      * @rtype (type: String, value: String) => Promise
-     * @param {String} type Type of subscription can be one of ['current'(just for selected account updates), 'connected(all accounts)']
+     * @param {String} type Should be one of 'current' (the selected account), 'connected' (all)
      * @param {String} value Subscription action('subscribe'|'unsubscribe')
      * @return {Promise} Address from wallet
      */
@@ -186,7 +202,10 @@ export default Ae.compose({
       if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
       if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.')
       if (opt.onAccount && !this.rpcClient.hasAccessToAccount(opt.onAccount)) throw new Error(`You do not have access to account ${opt.onAccount}`)
-      return this.rpcClient.request(METHODS.aepp.sign, { ...opt, tx, returnSigned: true, networkId: this.getNetworkId() })
+      return this.rpcClient.request(
+        METHODS.aepp.sign,
+        { ...opt, tx, returnSigned: true, networkId: this.getNetworkId() }
+      )
     },
     /**
      * Overwriting of `signMessage` AE method
@@ -221,7 +240,8 @@ export default Ae.compose({
     /**
      * Overwriting of `send` AE method
      * All sdk API which use it will be send notification to wallet and wait for callBack
-     * This method will sign, broadcast and wait until transaction will be accepted using rpc communication with wallet
+     * This method will sign, broadcast and wait until transaction will be accepted using rpc
+     * communication with wallet
      * @function send
      * @instance
      * @rtype (tx: String, options = {}) => Promise
@@ -239,7 +259,10 @@ export default Ae.compose({
         const signed = await this.signTransaction(tx, { onAccount: opt.onAccount })
         return this.sendTransaction(signed, opt)
       }
-      return this.rpcClient.request(METHODS.aepp.sign, { onAccount: opt.onAccount, tx, returnSigned: false, networkId: this.getNetworkId() })
+      return this.rpcClient.request(
+        METHODS.aepp.sign,
+        { onAccount: opt.onAccount, tx, returnSigned: false, networkId: this.getNetworkId() }
+      )
     }
   }
 })

package/src/utils/aepp-wallet-communication/rpc/rpc-client.js

@@ -3,7 +3,8 @@
  *
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/rpc-client
  * @export { RpcClient, RpcClients }
- * @example import RpcClient from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/rpc-client'
+ * @example
+ * import RpcClient from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/rpc-client'
  */
 import stampit from '@stamp/it'
 
@@ -18,7 +19,9 @@ import { sendMessage, message, isValidAccounts } from '../helpers'
  * @param {Object} param Init params object
  * @param {String} param.name Client name
  * @param {Object} param.connection Connection object
- * @param {Function[]} param.handlers Arrays with two function for handling messages ([ onMessage: Function, onDisconnect: Function])
+ * @param {Function[]} param.handlers Array with two function for message handling
+ * @param {Function} param.handlers[0] Message handler
+ * @param {Function} param.handlers[1] Disconnect callback
  * @return {Object}
  */
 export default stampit({
@@ -148,10 +151,11 @@ export default stampit({
     },
     /**
      * Update accounts and sent `update.address` notification to AEPP
-     * @param {{ current: Object, connected: Object }} accounts Object with current and connected accounts
-     * @param {{ forceNotification: Boolean }} [options={ forceNotification: false }] Don not sent update notification to AEPP
+     * @param {{ current: Object, connected: Object }} accounts Current and connected accounts
+     * @param {Object} [options]
+     * @param {Boolean} [options.forceNotification] Don't sent update notification to AEPP
      */
-    setAccounts (accounts, { forceNotification = false } = {}) {
+    setAccounts (accounts, { forceNotification } = {}) {
       if (!isValidAccounts(accounts)) {
         throw new Error('Invalid accounts object. Should be object like: `{ connected: {}, selected: {} }`')
       }

package/src/utils/aepp-wallet-communication/rpc/wallet-rpc.js

@@ -3,7 +3,8 @@
  *
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc
  * @export WalletRpc
- * @example import WalletRpc from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc'
+ * @example
+ * import WalletRpc from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc'
  */
 import { v4 as uuid } from 'uuid'
 import Ae from '../../../ae'
@@ -89,20 +90,28 @@ const REQUESTS = {
     return callInstance(
       'onAskAccounts',
       {},
-      ({ accounts } = {}) => ({ result: accounts || [...Object.keys(client.accounts.current), ...Object.keys(client.accounts.connected)] }),
+      ({ accounts } = {}) => ({
+        result: accounts ||
+          [...Object.keys(client.accounts.current), ...Object.keys(client.accounts.connected)]
+      }),
       (error) => ({ error: ERRORS.rejectedByUser(error) })
     )
   },
-  [METHODS.aepp.sign] (callInstance, instance, client, { tx, onAccount, networkId, returnSigned = false }) {
+  [METHODS.aepp.sign] (callInstance, instance, client, options) {
+    const { tx, onAccount, networkId, returnSigned = false } = options
     const address = onAccount || client.currentAccount
     // Update client with new networkId
     networkId && client.updateInfo({ networkId })
     // Authorization check
     if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
     // Account permission check
-    if (!client.hasAccessToAccount(address)) return { error: ERRORS.permissionDeny({ account: address }) }
+    if (!client.hasAccessToAccount(address)) {
+      return { error: ERRORS.permissionDeny({ account: address }) }
+    }
     // NetworkId check
-    if (!networkId || networkId !== instance.getNetworkId()) return { error: ERRORS.unsupportedNetwork() }
+    if (!networkId || networkId !== instance.getNetworkId()) {
+      return { error: ERRORS.unsupportedNetwork() }
+    }
 
     return callInstance(
       'onSign',
@@ -116,11 +125,11 @@ const REQUESTS = {
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
         try {
-          return {
-            result: returnSigned
-              ? { signedTransaction: await instance.signTransaction(rawTx || tx, { onAccount: onAcc }) }
-              : { transactionHash: await instance.send(rawTx || tx, { onAccount: onAcc, verify: false }) }
-          }
+          const t = rawTx || tx
+          const result = returnSigned
+            ? { signedTransaction: await instance.signTransaction(t, { onAccount: onAcc }) }
+            : { transactionHash: await instance.send(t, { onAccount: onAcc, verify: false }) }
+          return { result }
         } catch (e) {
           if (!returnSigned) {
             // Validate transaction
@@ -139,7 +148,9 @@ const REQUESTS = {
     // Authorization check
     if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
     const address = onAccount || client.currentAccount
-    if (!client.hasAccessToAccount(address)) return { error: ERRORS.permissionDeny({ account: address }) }
+    if (!client.hasAccessToAccount(address)) {
+      return { error: ERRORS.permissionDeny({ account: address }) }
+    }
 
     return callInstance(
       'onMessageSign',
@@ -168,7 +179,9 @@ const REQUESTS = {
 const handleMessage = (instance, id) => async (msg, origin) => {
   const client = instance.rpcClients[id]
   if (!msg.id) {
-    return getHandler(NOTIFICATIONS, msg, { debug: instance.debug })(instance, { client })(msg, origin)
+    return getHandler(
+      NOTIFICATIONS, msg, { debug: instance.debug }
+    )(instance, { client })(msg, origin)
   }
   if (Object.prototype.hasOwnProperty.call(client.callbacks, msg.id)) {
     return getHandler(RESPONSES, msg, { debug: instance.debug })(instance, { client })(msg, origin)
@@ -188,7 +201,9 @@ const handleMessage = (instance, id) => async (msg, origin) => {
       )
     })
     // TODO make one structure for handler functions
-    const errorObjectOrHandler = getHandler(REQUESTS, msg, { debug: instance.debug })(callInstance, instance, client, msg.params)
+    const errorObjectOrHandler = getHandler(REQUESTS, msg, { debug: instance.debug })(
+      callInstance, instance, client, msg.params
+    )
     const response = typeof errorObjectOrHandler === 'function' ? await errorObjectOrHandler() : errorObjectOrHandler
     sendResponseMessage(client)(id, method, response)
   }
@@ -201,18 +216,31 @@ const handleMessage = (instance, id) => async (msg, origin) => {
  * @rtype Stamp
  * @param {Object} param Init params object
  * @param {String=} [param.name] Wallet name
- * @param {Function} onConnection Call-back function for incoming AEPP connection (Second argument contain function for accept/deny request)
- * @param {Function} onSubscription Call-back function for incoming AEPP account subscription (Second argument contain function for accept/deny request)
- * @param {Function} onSign Call-back function for incoming AEPP sign request (Second argument contain function for accept/deny request)
- * @param {Function} onAskAccounts Call-back function for incoming AEPP get address request (Second argument contain function for accept/deny request)
- * @param {Function} onMessageSign Call-back function for incoming AEPP sign message request (Second argument contain function for accept/deny request)
+ * @param {Function} onConnection Call-back function for incoming AEPP connection
+ * @param {Function} onSubscription Call-back function for incoming AEPP account subscription
+ * @param {Function} onSign Call-back function for incoming AEPP sign request
+ * @param {Function} onAskAccounts Call-back function for incoming AEPP get address request
+ * @param {Function} onMessageSign Call-back function for incoming AEPP sign message request
+ * Second argument of incoming call-backs contain function for accept/deny request
  * @param {Function} onDisconnect Call-back function for disconnect event
  * @return {Object}
  */
 export default Ae.compose(AccountMultiple, {
-  init ({ name, onConnection, onSubscription, onSign, onDisconnect, onAskAccounts, onMessageSign, forceValidation = false, debug = false } = {}) {
+  init ({
+    name,
+    onConnection,
+    onSubscription,
+    onSign,
+    onDisconnect,
+    onAskAccounts,
+    onMessageSign,
+    forceValidation = false,
+    debug = false
+  } = {}) {
     this.debug = debug
-    const eventsHandlers = ['onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onMessageSign']
+    const eventsHandlers = [
+      'onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onMessageSign'
+    ]
     // CallBacks for events
     this.onConnection = onConnection
     this.onSubscription = onSubscription
@@ -223,7 +251,9 @@ export default Ae.compose(AccountMultiple, {
     this.rpcClients = {}
 
     eventsHandlers.forEach(event => {
-      if (!forceValidation && typeof this[event] !== 'function') throw new Error(`Call-back for ${event} must be an function!`)
+      if (!forceValidation && typeof this[event] !== 'function') {
+        throw new Error(`Call-back for ${event} must be an function!`)
+      }
     })
     //
     this.name = name
@@ -298,7 +328,8 @@ export default Ae.compose(AccountMultiple, {
      * @return {String} Client ID
      */
     addRpcClient (clientConnection) {
-      // @TODO  detect if aepp has some history based on origin????: if yes use this instance for connection
+      // @TODO  detect if aepp has some history based on origin????
+      // if yes use this instance for connection
       const id = uuid()
       this.rpcClients[id] = RpcClient({
         id,

package/src/utils/aepp-wallet-communication/wallet-detector.js

@@ -52,7 +52,10 @@ export default stampit({
     scan (onDetected) {
       const { wallets } = this
       this.connection.connect(({ method, params }, origin, source) => {
-        if (!method || !params || method !== METHODS.wallet.readyToConnect || wallets[params.id]) return
+        if (
+          !method || !params ||
+          method !== METHODS.wallet.readyToConnect || wallets[params.id]
+        ) return
 
         const wallet = {
           ...params,

package/src/utils/crypto.js

@@ -22,7 +22,6 @@
  */
 
 import bs58check from 'bs58check'
-import ed2curve from 'ed2curve'
 import nacl from 'tweetnacl'
 import aesjs from 'aes-js'
 import shajs from 'sha.js'
@@ -193,7 +192,7 @@ export function generateKeyPairFromSecret (secret) {
 
 /**
  * Generate a random ED25519 keypair
- * @rtype (raw: Boolean) => {publicKey: String, secretKey: String} | {publicKey: Buffer, secretKey: Buffer}
+ * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}
  * @param {Boolean} raw - Whether to return raw (binary) keys
  * @return {Object} Key pair
  */
@@ -311,53 +310,3 @@ export function isValidKeypair (privateKey, publicKey) {
   const signature = sign(message, privateKey)
   return verify(message, signature, publicKey)
 }
-
-/**
- * This function encrypts a message using base58check encoded and 'ak' prefixed
- * publicKey such that only the corresponding secretKey will
- * be able to decrypt
- * @rtype (msg: String, publicKey: String) => Object
- * @param {Buffer} msg - Data to encode
- * @param {String} publicKey - Public key
- * @return {Object}
- */
-export function encryptData (msg, publicKey) {
-  const ephemeralKeyPair = nacl.box.keyPair()
-  const pubKeyUInt8Array = decode(publicKey, 'ak')
-  const nonce = nacl.randomBytes(nacl.box.nonceLength)
-
-  const encryptedMessage = nacl.box(
-    Buffer.from(msg),
-    nonce,
-    ed2curve.convertPublicKey(pubKeyUInt8Array),
-    ephemeralKeyPair.secretKey
-  )
-
-  return {
-    ciphertext: Buffer.from(encryptedMessage).toString('hex'),
-    ephemPubKey: Buffer.from(ephemeralKeyPair.publicKey).toString('hex'),
-    nonce: Buffer.from(nonce).toString('hex'),
-    version: 'x25519-xsalsa20-poly1305'
-  }
-}
-
-/**
- * This function decrypt a message using secret key
- * @rtype (secretKey: String, encryptedData: Object) => Buffer|null
- * @param {String} secretKey - Secret key
- * @param {Object} encryptedData - Encrypted data
- * @return {Buffer|null}
- */
-export function decryptData (secretKey, encryptedData) {
-  const receiverSecretKeyUint8Array = ed2curve.convertSecretKey(Buffer.from(secretKey, 'hex'))
-  const nonce = Buffer.from(encryptedData.nonce, 'hex')
-  const ciphertext = Buffer.from(encryptedData.ciphertext, 'hex')
-  const ephemPubKey = Buffer.from(encryptedData.ephemPubKey, 'hex')
-  const decrypted = nacl.box.open(
-    ciphertext,
-    nonce,
-    ephemPubKey,
-    receiverSecretKeyUint8Array
-  )
-  return decrypted ? Buffer.from(decrypted) : decrypted
-}

package/src/utils/keystore.js

@@ -189,7 +189,14 @@ 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,
@@ -208,7 +215,8 @@ export function validateKeyObj (obj) {
   const missingRootKeys = root.filter(key => !Object.prototype.hasOwnProperty.call(obj, key))
   if (missingRootKeys.length) throw new Error(`Invalid key file format. Require properties: ${missingRootKeys}`)
 
-  const missingCryptoKeys = cryptoKeys.filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))
+  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}`)
 
   return true

package/src/utils/swagger.js

@@ -66,7 +66,7 @@ export default async (
       url,
       spec,
       responseInterceptor: response => {
-        if (!response.text) return response
+        if (response.text === '' || response.text?.size === 0) return response
         const body = jsonImp.parse(response.text)
         Object.assign(response, {
           body: disableCaseConversion ? body : pascalizeKeys(body)