@aeternity/aepp-sdk 8.2.1 → 10.0.0

package/src/tx/validator.js

@@ -1,229 +1,161 @@
-import {
-  verify,
-  decodeBase58Check,
-  assertedType
-} from '../utils/crypto'
-import { encode } from '../tx/builder/helpers'
+import { verify, hash } from '../utils/crypto'
+import { encode, decode } from './builder/helpers'
 
 import BigNumber from 'bignumber.js'
-import {
-  BASE_VERIFICATION_SCHEMA,
-  CONTRACT_VERIFICATION_SCHEMA,
-  MIN_GAS_PRICE,
-  NAME_CLAIM_VERIFICATION_SCHEMA,
-  OBJECT_ID_TX_TYPE,
-  OBJECT_TAG_SIGNED_TRANSACTION,
-  PROTOCOL_VM_ABI,
-  SIGNATURE_VERIFICATION_SCHEMA,
-  TX_TYPE
-} from './builder/schema'
-import { buildTxHash, calculateFee, unpackTx } from './builder'
-import NodePool from '../node-pool'
+import { MIN_GAS_PRICE, PROTOCOL_VM_ABI, TX_TYPE } from './builder/schema'
+import { calculateFee, unpackTx } from './builder'
 
 /**
  * Transaction validator
  * @module @aeternity/aepp-sdk/es/tx/validator
- * @export TransactionValidator
- * @example import { TransactionValidator } from '@aeternity/aepp-sdk'
+ * @export verifyTransaction
+ * @example import { verifyTransaction } from '@aeternity/aepp-sdk'
  */
 
-const VALIDATORS = {
-  // VALIDATE SIGNATURE
-  signature ({ rlpEncoded, signature, ownerPublicKey, networkId = 'ae_mainnet' }) {
-    const txWithNetworkId = Buffer.concat([Buffer.from(networkId), rlpEncoded])
-    const txHashWithNetworkId = Buffer.concat([Buffer.from(networkId), buildTxHash(rlpEncoded, { raw: true })])
-    const decodedPub = decodeBase58Check(assertedType(ownerPublicKey, 'ak'))
-    return verify(txWithNetworkId, signature, decodedPub) || verify(txHashWithNetworkId, signature, decodedPub)
+const validators = [
+  async ({ encodedTx, signatures }, { account, node, parentTxTypes }) => {
+    if ((encodedTx ?? signatures) === undefined) return []
+    if (signatures.length !== 1) return [] // TODO: Support multisignature?
+    const prefix = Buffer.from([
+      node.nodeNetworkId,
+      ...parentTxTypes.includes(TX_TYPE.payingFor) ? ['inner_tx'] : []
+    ].join('-'))
+    const txWithNetworkId = Buffer.concat([prefix, encodedTx.rlpEncoded])
+    const txHashWithNetworkId = Buffer.concat([prefix, hash(encodedTx.rlpEncoded)])
+    const decodedPub = decode(account.id, 'ak')
+    if (verify(txWithNetworkId, signatures[0], decodedPub) ||
+      verify(txHashWithNetworkId, signatures[0], decodedPub)) return []
+    return [{
+      message: 'Signature cannot be verified, please ensure that you transaction have' +
+        ' the correct prefix and the correct private key for the sender address',
+      key: 'InvalidSignature',
+      checkedKeys: ['encodedTx', 'signatures']
+    }]
   },
-  // VALIDATE IF ENOUGH FEE
-  insufficientFee ({ minFee, fee }) {
-    return BigNumber(minFee).lte(BigNumber(fee))
+  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
+    if ((encodedTx ?? tx) === undefined) return []
+    return verifyTransaction(
+      encode((encodedTx ?? tx).rlpEncoded, 'tx'),
+      node,
+      [...parentTxTypes, txType]
+    )
   },
-  // VALIDATE IF TTL VALID
-  expiredTTL ({ ttl, height }) {
-    return BigNumber(ttl).eq(0) || BigNumber(ttl).gte(BigNumber(height))
-  },
-  // Insufficient Balance for Amount plus Fee
-  insufficientBalanceForAmountFee ({ balance, amount = 0, fee }) {
-    return BigNumber(balance).gte(BigNumber(amount).plus(fee))
+  (tx, { txType }) => {
+    if (tx.fee === undefined) return []
+    const minFee = calculateFee(0, txType, {
+      gas: +tx.gas || 0, params: tx, showWarning: false, vsn: tx.VSN
+    })
+    if (new BigNumber(minFee).lte(tx.fee)) return []
+    return [{
+      message: `Fee ${tx.fee} is too low, minimum fee for this transaction is ${minFee}`,
+      key: 'InsufficientFee',
+      checkedKeys: ['fee']
+    }]
   },
-  // Insufficient Balance for Amount
-  insufficientBalanceForAmount ({ balance, amount = 0 }) {
-    return BigNumber(balance).gte(BigNumber(amount))
+  ({ ttl }, { height }) => {
+    if (ttl === undefined) return []
+    ttl = +ttl
+    if (ttl === 0 || ttl >= height) return []
+    return [{
+      message: `TTL ${ttl} is already expired, current height is ${height}`,
+      key: 'ExpiredTTL',
+      checkedKeys: ['ttl']
+    }]
   },
-  // IF NONCE USED
-  nonceUsed ({ accountNonce, nonce }) {
-    return BigNumber(nonce).gt(BigNumber(accountNonce))
+  ({ amount, fee, nameFee, tx }, { account, parentTxTypes, txType }) => {
+    if ((amount ?? fee ?? nameFee) === undefined) return []
+    const cost = new BigNumber(fee).plus(nameFee || 0).plus(amount || 0)
+      .plus(txType === TX_TYPE.payingFor ? tx.tx.encodedTx.tx.fee : 0)
+      .minus(parentTxTypes.includes(TX_TYPE.payingFor) ? fee : 0)
+    if (cost.lte(account.balance)) return []
+    return [{
+      message: `Account balance ${account.balance} is not enough to execute the transaction that costs ${cost.toFixed()}`,
+      key: 'InsufficientBalance',
+      checkedKeys: ['amount', 'fee', 'nameFee']
+    }]
   },
-  // IF NONCE TO HIGH
-  nonceHigh ({ accountNonce, nonce }) {
-    return !(BigNumber(nonce).gt(BigNumber(accountNonce).plus(1)))
+  ({ nonce }, { account, parentTxTypes }) => {
+    if (nonce === undefined || parentTxTypes.includes(TX_TYPE.gaMeta)) return []
+    nonce = +nonce
+    const validNonce = account.nonce + 1
+    if (nonce === validNonce) return []
+    return [{
+      ...nonce < validNonce
+        ? {
+            message: `Nonce ${nonce} is already used, valid nonce is ${validNonce}`,
+            key: 'NonceAlreadyUsed'
+          }
+        : {
+            message: `Nonce ${nonce} is too high, valid nonce is ${validNonce}`,
+            key: 'NonceHigh'
+          },
+      checkedKeys: ['nonce']
+    }]
   },
-  minGasPrice ({ gasPrice }) {
-    return isNaN(gasPrice) || BigNumber(gasPrice).gte(BigNumber(MIN_GAS_PRICE))
+  ({ gasPrice }) => {
+    if (gasPrice === undefined) return []
+    if (gasPrice >= MIN_GAS_PRICE) return []
+    return [{
+      message: `Gas price ${gasPrice} must be bigger then ${MIN_GAS_PRICE}`,
+      key: 'MinGasPrice',
+      checkedKeys: ['gasPrice']
+    }]
   },
-  // VM/ABI version validation based on consensus protocol version
-  vmAndAbiVersion ({ ctVersion, abiVersion, consensusProtocolVersion, txType }) {
-    // If not contract tx
+  ({ ctVersion, abiVersion }, { txType, node }) => {
+    const { consensusProtocolVersion } = node.getNodeInfo()
+    const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
+    if (!protocol) throw new Error(`Unsupported protocol: ${consensusProtocolVersion}`)
+    // If not contract create tx
     if (!ctVersion) ctVersion = { abiVersion }
-    const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
-    // If protocol not implemented
-    if (!supportedProtocol) return true
-    // If protocol for tx type not implemented
-    const txProtocol = supportedProtocol[txType]
-
-    return !Object.entries(ctVersion)
-      .reduce((acc, [key, value]) =>
-        [...acc, value === undefined ? true : txProtocol[key].includes(parseInt(value))],
-      []).includes(false)
-  },
-  insufficientBalanceForFeeNameFee ({ nameFee, fee, balance, VSN }) {
-    return VSN === 1 || BigNumber(balance).gte(BigNumber(nameFee).plus(fee))
-  }
-}
-
-const resolveDataForBase = async (chain, { ownerPublicKey }) => {
-  let accountNonce = 0
-  let accountBalance = 0
-  try {
-    const { nonce, balance } = await chain.api.getAccountByPubkey(ownerPublicKey)
-    accountNonce = nonce
-    accountBalance = balance
-  } catch (e) { console.log('We can not get info about this publicKey') }
-  return {
-    height: (await chain.api.getCurrentKeyBlockHeight()).height,
-    balance: accountBalance,
-    accountNonce,
-    ownerPublicKey,
-    ...chain.getNodeInfo()
-  }
-}
-
-// Verification using SCHEMA
-const verifySchema = (schema, data) => {
-  // Verify through schema
-  return schema.reduce(
-    (acc, [msg, validatorKey, { key, type, txKey }]) => {
-      if (!VALIDATORS[validatorKey](data)) acc.push({ msg: msg(data), txKey, type })
-      return acc
-    },
-    []
-  )
-}
-
-/**
- * Unpack and verify transaction (verify nonce, ttl, fee, signature, account balance)
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/validator
- *
- * @param {String} txHash Base64Check transaction hash
- * @param {Object} [options={}] Options
- * @param {String} [options.networkId] networkId Use in signature verification
- * @return {Promise<Object>} Object with verification errors and warnings
- */
-async function unpackAndVerify (txHash, { networkId } = {}) {
-  const { tx: unpackedTx, rlpEncoded, txType } = unpackTx(txHash)
-
-  if (+unpackedTx.tag === OBJECT_TAG_SIGNED_TRANSACTION) {
-    const { txType, tx } = unpackedTx.encodedTx
-    const signatures = unpackedTx.signatures.map(raw => ({ raw, hash: encode(raw, 'sg') }))
-    const rlpEncodedTx = unpackedTx.encodedTx.rlpEncoded
-
-    return {
-      validation: await this.verifyTx({ tx, signatures, rlpEncoded: rlpEncodedTx }, networkId),
-      tx,
-      signatures,
-      txType
+    const txProtocol = protocol[txType]
+    if (!txProtocol) return []
+    if (Object.entries(ctVersion).some(([key, value]) => !txProtocol[key].includes(+value))) {
+      return [{
+        message: `ABI/VM version ${JSON.stringify(ctVersion)} is wrong, supported is: ${JSON.stringify(txProtocol)}`,
+        key: 'VmAndAbiVersionMismatch',
+        checkedKeys: ['ctVersion', 'abiVersion']
+      }]
     }
+    return []
   }
-  return {
-    validation: await this.verifyTx({ tx: unpackedTx, rlpEncoded }, networkId),
-    tx: unpackedTx,
-    txType
-  }
-}
+]
 
-const getOwnerPublicKey = (tx) =>
-  tx[['senderId', 'accountId', 'ownerId', 'callerId', 'oracleId', 'fromId', 'initiator', 'gaId'].find(key => tx[key])].replace('ok_', 'ak_')
+const getSenderAddress = tx => [
+  'senderId', 'accountId', 'ownerId', 'callerId',
+  'oracleId', 'fromId', 'initiator', 'gaId', 'payerId'
+]
+  .map(key => tx[key])
+  .filter(a => a)
+  .map(a => a.replace(/^ok_/, 'ak_'))[0]
 
 /**
- * Verify transaction (verify nonce, ttl, fee, signature, account balance)
+ * Transaction Validator
+ * This function validates some of transaction properties,
+ * to make sure it can be posted it to the chain
  * @function
  * @alias module:@aeternity/aepp-sdk/es/tx/validator
- *
- * @param {Object} [data={}] data TX data object
- * @param {String} [data.tx] tx Transaction hash
- * @param {Array} [data.signatures] signatures Transaction signature's
- * @param {Array} [data.rlpEncoded] rlpEncoded RLP encoded transaction
- * @param {String} networkId networkId Use in signature verification
- * @return {Promise<Array>} Object with verification errors and warnings
+ * @rtype (tx: String, node) => void
+ * @param {String} transaction Base64Check-encoded transaction
+ * @param {Object} node Node to validate transaction against
+ * @param {String[]} [parentTxTypes] Types of parent transactions
+ * @return {Promise<Object[]>} Array with verification errors
+ * @example const errors = await verifyTransaction(transaction, node)
  */
-async function verifyTx ({ tx, signatures, rlpEncoded }, networkId) {
-  networkId = networkId || this.getNetworkId() || 'ae_mainnet'
-  // Fetch data for verification
-  const ownerPublicKey = getOwnerPublicKey(tx)
-  const gas = Object.prototype.hasOwnProperty.call(tx, 'gas') ? +tx.gas : 0
-  const txType = OBJECT_ID_TX_TYPE[+tx.tag]
-  const resolvedData = {
-    minFee: calculateFee(0, txType, { gas, params: tx, showWarning: false, vsn: tx.VSN }),
-    ...(await resolveDataForBase(this, { ownerPublicKey })),
-    ...tx,
-    txType
-  }
-  const signatureVerification = signatures && signatures.length
-    ? verifySchema(SIGNATURE_VERIFICATION_SCHEMA, {
-      rlpEncoded,
-      signature: signatures[0].raw,
-      ownerPublicKey,
-      networkId
-    })
-    : []
-  const baseVerification = verifySchema(BASE_VERIFICATION_SCHEMA, resolvedData)
+export default async function verifyTransaction (transaction, node, parentTxTypes = []) {
+  const { tx, txType } = unpackTx(transaction)
 
-  return [
-    ...baseVerification,
-    ...signatureVerification,
-    ...customVerification(txType, resolvedData)
-  ]
-}
+  const address = getSenderAddress(tx) ??
+    (txType === TX_TYPE.signed ? getSenderAddress(tx.encodedTx.tx) : null)
+  const [account, height] = await Promise.all([
+    address && node.api.getAccountByPubkey(address).catch(() => ({
+      id: address,
+      balance: new BigNumber(0),
+      nonce: 0
+    })),
+    node.api.getCurrentKeyBlockHeight().then(({ height }) => height)
+  ])
 
-/**
- * Verification for speciific txType
- * @param txType
- * @param data
- * @return {Array}
- */
-function customVerification (txType, data) {
-  switch (txType) {
-    case TX_TYPE.contractCreate:
-    case TX_TYPE.contractCall:
-    case TX_TYPE.oracleRegister:
-      return verifySchema(CONTRACT_VERIFICATION_SCHEMA, data)
-    case TX_TYPE.nameClaim:
-      return verifySchema(NAME_CLAIM_VERIFICATION_SCHEMA, data)
-    default:
-      return []
-  }
+  return (await Promise.all(
+    validators.map(v => v(tx, { txType, node, account, height, parentTxTypes })))
+  ).flat()
 }
-
-/**
- * Transaction Validator Stamp
- * This stamp give us possibility to unpack and validate some of transaction properties,
- * to make sure we can post it to the chain
- * @function
- * @alias module:@aeternity/aepp-sdk/es/tx/validator
- * @rtype Stamp
- * @param {Object} [options={}] - Initializer object
- * @param {Object} [options.url] - Node url
- * @param {Object} [options.internalUrl] - Node internal url
- * @return {Object} Transaction Validator instance
- * @example TransactionValidator({url: 'https://testnet.aeternity.io'})
- */
-const TransactionValidator = NodePool.compose({
-  methods: {
-    verifyTx,
-    unpackAndVerify
-  }
-})
-
-export default TransactionValidator

package/src/utils/aepp-wallet-communication/connection/browser-runtime.js

@@ -18,10 +18,11 @@
 /**
  * Browser runtime connector module
  *
- * This is the complement to {@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection}.
+ * This is the complement to
+ * {@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection}.
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-runtime
  * @export BrowserRuntimeConnection
- * @example import BrowserRuntimeConnection from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-runtime'
+ * @example import { BrowserRuntimeConnection } from '@aeternity/aepp-sdk'
  */
 import stampit from '@stamp/it'
 

package/src/utils/aepp-wallet-communication/connection/browser-window-message.js

@@ -18,10 +18,13 @@
 /**
  * Browser window Post Message connector module
  *
- * This is the complement to {@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection}.
+ * This is the complement to
+ * {@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection}.
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-window-message
  * @export BrowserWindowMessageConnection
- * @example import BrowserWindowMessageConnection from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-window-message'
+ * @example
+ * import BrowserWindowMessageConnection
+ * from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-window-message'
  */
 import stampit from '@stamp/it'
 import WalletConnection from '.'
@@ -102,27 +105,42 @@ const getTarget = () => {
   const isContentScript = isExtensionContext && isWeb
   if (isContentScript) return window
   // When we is the main page we need to decide the target by our self
-  // Probably can be implemented some algo for checking DOM for Iframes and somehow decide which Iframe to talk
+  // Probably can be implemented some algo for checking DOM for Iframes and somehow decide which
+  // Iframe to talk
   return isInIframe() ? window.parent : undefined
 }
 
 /**
  * BrowserWindowMessageConnection
  * @function
- * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-window-message
+ * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication\
+ * /connection/browser-window-message
  * @rtype Stamp
  * @param {Object} [params={}] - Initializer object
  * @param {Object} [params.target=window.parent] - Target window for message
  * @param {Object} [params.self=window] - Host window for message
  * @param {Object} [params.origin] - Origin of receiver
- * @param {Object} [params.sendDirection] - Optional field for wrapping messages in additional structure({ type: 'to_aepp' || 'to_waellet', data }).Used for handling messages netween content script and page
- * @param {Object} [params.receiveDirection='to_aepp'] - Optional(default: 'to_aepp') field for unwrapping messages from additional structure({ type: 'to_aepp' || 'to_waellet', data }).Used for handling messages netween content script and page
+ * @param {String} [params.sendDirection] Wrapping messages into additional struct
+ * ({ type: 'to_aepp' || 'to_waellet', data })
+ * Used for handling messages between content script and page
+ * @param {String} [params.receiveDirection='to_aepp'] Unwrapping messages from additional struct
+ * ({ type: 'to_aepp' || 'to_waellet', data })
+ * Used for handling messages between content script and page
  * @param {Object} [params.connectionInfo={}] - Connection info object
  * @param {Boolean} [params.debug=false] - Debug flag
  * @return {Object}
  */
 export default stampit({
-  init ({ connectionInfo = {}, target = getTarget(), self = window, origin, sendDirection, receiveDirection = MESSAGE_DIRECTION.to_aepp, debug = false, forceOrigin = false } = {}) {
+  init ({
+    connectionInfo = {},
+    target = getTarget(),
+    self = window,
+    origin,
+    sendDirection,
+    receiveDirection = MESSAGE_DIRECTION.to_aepp,
+    debug = false,
+    forceOrigin = false
+  } = {}) {
     if (sendDirection && !Object.keys(MESSAGE_DIRECTION).includes(sendDirection)) throw new Error(`sendDirection must be one of [${Object.keys(MESSAGE_DIRECTION)}]`)
     if (!Object.keys(MESSAGE_DIRECTION).includes(receiveDirection)) throw new Error(`receiveDirection must be one of [${Object.keys(MESSAGE_DIRECTION)}]`)
     this.connectionInfo = { id: uuid(), ...connectionInfo }

package/src/utils/aepp-wallet-communication/connection/index.js

@@ -19,7 +19,8 @@
  * Wallet Connection base module
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection
  * @export WalletConnection
- * @example import WalletConnection from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection'
+ * @example
+ * import WalletConnection from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection'
  */
 
 import { required } from '@stamp/required'

package/src/utils/aepp-wallet-communication/content-script-bridge.js

@@ -20,7 +20,9 @@
  *
  * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/content-script-bridge
  * @export ContentScriptBridge
- * @example import ContentScriptBridge from '@aeternity/aepp-sdk/es/utils/wallet-communication/content-script-bridge
+ * @example
+ * import ContentScriptBridge
+ * from '@aeternity/aepp-sdk/es/utils/wallet-communication/content-script-bridge
  */
 import stampit from '@stamp/it'
 
@@ -56,14 +58,18 @@ function stop () {
 
 /**
  * ContentScriptBridge stamp
- * Provide functionality to easly redirect messages from page to extension and from extension to page through content script
+ * Provide functionality to easly redirect messages from page to extension and from extension to
+ * page through content script
  * Using Runtime(Extension) and WindowPostMessage(Web-Page) connections
  * @function
  * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/content-script-bridge
  * @rtype Stamp
  * @param {Object} params - Initializer object
- * @param {Object} params.pageConnection - Page connection object(@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-window-message)
- * @param {Object} params.extConnection - Extension connection object(module: @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-runtime)
+ * @param {Object} params.pageConnection - Page connection object
+ * (@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/\
+ * browser-window-message)
+ * @param {Object} params.extConnection - Extension connection object
+ * (@link module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/connection/browser-runtime)
  * @return {Object}
  */
 export default stampit({

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,11 +3,11 @@
  *
  * @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 * as R from 'ramda'
 import { v4 as uuid } from 'uuid'
-
 import Ae from '../../../ae'
 import RpcClient from './rpc-client'
 import { getHandler, message, voidFn } from '../helpers'
@@ -42,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) => {
@@ -84,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
@@ -168,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
      */
@@ -188,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
@@ -223,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
@@ -236,12 +254,15 @@ 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 (options.onAccount && !this.rpcClient.hasAccessToAccount(options.onAccount)) throw new Error(`You do not have access to account ${options.onAccount}`)
-      const opt = R.merge(this.Ae.defaults, options)
+      const opt = { ...this.Ae.defaults, ...options }
       if (!opt.walletBroadcast) {
         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: {} }`')
       }