@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/tx/validator.js

@@ -4,6 +4,7 @@ import { encode, decode } from './builder/helpers'
 import BigNumber from 'bignumber.js'
 import { MIN_GAS_PRICE, PROTOCOL_VM_ABI, TX_TYPE } from './builder/schema'
 import { calculateFee, unpackTx } from './builder'
+import { UnsupportedProtocolError } from '../utils/errors'
 
 /**
  * Transaction validator
@@ -13,7 +14,7 @@ import { calculateFee, unpackTx } from './builder'
  */
 
 const validators = [
-  async ({ encodedTx, signatures }, { account, node, parentTxTypes }) => {
+  ({ encodedTx, signatures }, { account, node, parentTxTypes }) => {
     if ((encodedTx ?? signatures) === undefined) return []
     if (signatures.length !== 1) return [] // TODO: Support multisignature?
     const prefix = Buffer.from([
@@ -32,7 +33,7 @@ const validators = [
       checkedKeys: ['encodedTx', 'signatures']
     }]
   },
-  async ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
+  ({ encodedTx, tx }, { node, parentTxTypes, txType }) => {
     if ((encodedTx ?? tx) === undefined) return []
     return verifyTransaction(
       encode((encodedTx ?? tx).rlpEncoded, 'tx'),
@@ -80,13 +81,15 @@ const validators = [
     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'
-      },
+      ...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']
     }]
   },
@@ -102,7 +105,7 @@ const validators = [
   ({ ctVersion, abiVersion }, { txType, node }) => {
     const { consensusProtocolVersion } = node.getNodeInfo()
     const protocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
-    if (!protocol) throw new Error(`Unsupported protocol: ${consensusProtocolVersion}`)
+    if (!protocol) throw new UnsupportedProtocolError(`Unsupported protocol: ${consensusProtocolVersion}`)
     // If not contract create tx
     if (!ctVersion) ctVersion = { abiVersion }
     const txProtocol = protocol[txType]
@@ -115,6 +118,25 @@ const validators = [
       }]
     }
     return []
+  },
+  async ({ contractId }, { txType, node }) => {
+    if (TX_TYPE.contractCall !== txType) return []
+    try {
+      const { active } = await node.api.getContract(contractId)
+      if (active) return []
+      return [{
+        message: `Contract ${contractId} is not active`,
+        key: 'ContractNotActive',
+        checkedKeys: ['contractId']
+      }]
+    } catch (error) {
+      if (!error.response?.body?.reason) throw error
+      return [{
+        message: error.response.body.reason,
+        key: 'ContractNotFound',
+        checkedKeys: ['contractId']
+      }]
+    }
   }
 ]
 
@@ -144,13 +166,13 @@ export default async function verifyTransaction (transaction, node, parentTxType
 
   const address = getSenderAddress(tx) ??
     (txType === TX_TYPE.signed ? getSenderAddress(tx.encodedTx.tx) : null)
-  const [account, height] = await Promise.all([
+  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)
+    node.api.getCurrentKeyBlockHeight()
   ])
 
   return (await Promise.all(

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

@@ -18,15 +18,21 @@
 /**
  * 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'
 
 import WalletConnection from '.'
 import { getBrowserAPI } from '../helpers'
+import {
+  RpcConnectionError,
+  AlreadyConnectedError,
+  NoWalletConnectedError
+} from '../../errors'
 
 /**
  * Disconnect
@@ -53,7 +59,7 @@ function disconnect () {
  * @return {void}
  */
 function connect (onMessage, onDisconnect) {
-  if (this.isConnected()) throw new Error('You already connected')
+  if (this.isConnected()) throw new AlreadyConnectedError('You already connected')
   this.handler = (msg, source) => {
     if (this.debug) console.log('Receive message: ', msg)
     onMessage(msg, source)
@@ -74,7 +80,7 @@ function connect (onMessage, onDisconnect) {
  * @return {void}
  */
 function sendMessage (msg) {
-  if (!this.port) throw new Error('You dont have connection. Please connect before')
+  if (!this.port) throw new NoWalletConnectedError('You dont have connection. Please connect before')
   if (this.debug) console.log('Send message: ', msg)
   this.port.postMessage(msg)
 }
@@ -104,7 +110,7 @@ function isConnected () {
  */
 export default stampit({
   init ({ connectionInfo = {}, port, debug = false }) {
-    if (!getBrowserAPI().runtime) throw new Error('Runtime is not accessible in your environment')
+    if (!getBrowserAPI().runtime) throw new RpcConnectionError('Runtime is not accessible in your environment')
     this.debug = debug
     this.connectionInfo = connectionInfo
     this.port = port || getBrowserAPI().runtime.connect(...[connectionInfo.id || undefined])

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

@@ -18,16 +18,24 @@
 /**
  * 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 '.'
-import { v4 as uuid } from 'uuid'
+import { v4 as uuid } from '@aeternity/uuid'
 import { MESSAGE_DIRECTION } from '../schema'
 import { getBrowserAPI, isInIframe } from '../helpers'
+import {
+  AlreadyConnectedError,
+  NoWalletConnectedError,
+  MessageDirectionError
+} from '../../errors'
 
 /**
  * Check if connected
@@ -53,7 +61,7 @@ function connect (onMessage) {
   const receiveDirection = this.receiveDirection
   const debug = this.debug
   const forceOrigin = this.forceOrigin
-  if (this.listener) throw new Error('You already connected')
+  if (this.listener) throw new AlreadyConnectedError('You already connected')
 
   this.listener = (msg, source) => {
     if (!msg || typeof msg.data !== 'object') return
@@ -77,7 +85,7 @@ function connect (onMessage) {
  * @return {void}
  */
 function disconnect () {
-  if (!this.listener) throw new Error('You dont have connection. Please connect before')
+  if (!this.listener) throw new NoWalletConnectedError('You dont have connection. Please connect before')
   this.unsubscribeFn(this.listener)
   this.listener = null
 }
@@ -102,29 +110,44 @@ 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 } = {}) {
-    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)}]`)
+  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 MessageDirectionError(`sendDirection must be one of [${Object.keys(MESSAGE_DIRECTION)}]`)
+    if (!Object.keys(MESSAGE_DIRECTION).includes(receiveDirection)) throw new MessageDirectionError(`receiveDirection must be one of [${Object.keys(MESSAGE_DIRECTION)}]`)
     this.connectionInfo = { id: uuid(), ...connectionInfo }
 
     const selfP = self
@@ -137,7 +160,6 @@ export default stampit({
     this.subscribeFn = (listener) => selfP.addEventListener('message', listener, false)
     this.unsubscribeFn = (listener) => selfP.removeEventListener('message', listener, false)
     this.postFn = (msg) => targetP.postMessage(msg, this.origin || '*')
-    if (!this.connectionInfo.id) throw new Error('ID required.')
   },
   methods: { connect, sendMessage, disconnect, isConnected }
 }, WalletConnection)

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,9 +20,12 @@
  *
  * @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'
+import { UnsupportedPlatformError, MissingParamError } from '../errors'
 
 /**
  * Start message proxy
@@ -56,21 +59,25 @@ 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({
   init ({ pageConnection, extConnection, allowCrossOrigin = false }) {
-    if (!window) throw new Error('Window object not found, you can run bridge only in browser')
-    if (!pageConnection) throw new Error('pageConnection required')
-    if (!extConnection) throw new Error('extConnection required')
+    if (!window) throw new UnsupportedPlatformError('Window object not found, you can run bridge only in browser')
+    if (!pageConnection) throw new MissingParamError('pageConnection required')
+    if (!extConnection) throw new MissingParamError('extConnection required')
     this.allowCrossOrigin = allowCrossOrigin
     this.pageConnection = pageConnection
     this.extConnection = extConnection

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

@@ -1,7 +1,7 @@
 /**
  * Browser helper functions
  */
-import { isAccountBase } from '../../account/base'
+import { NoBrowserFoundError } from '../errors'
 
 export const getBrowserAPI = (force = false) => {
   const { chrome, browser } = window
@@ -9,7 +9,7 @@ export const getBrowserAPI = (force = false) => {
   if (typeof chrome !== 'undefined' && chrome === Object(chrome)) return chrome
   // Firefox support
   if (typeof browser !== 'undefined' && browser === Object(browser)) return browser
-  if (!force) throw new Error('Browser is not detected')
+  if (!force) throw new NoBrowserFoundError()
   return {}
 }
 
@@ -51,18 +51,10 @@ 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 voidFn = () => undefined
+export const sendResponseMessage = (client) => (id, method, data) =>
+  client.sendMessage(responseMessage(id, method, data), true)
 
 export const isValidAccounts = (accounts) => (['', 'connected', 'current'].filter(k => typeof (k ? accounts[k] : accounts) === 'object')).length === 3
-
-export const resolveOnAccount = (addresses, onAccount, opt = {}) => {
-  if (!addresses.find(a => a === onAccount)) {
-    if (typeof opt.onAccount !== 'object' || !isAccountBase(opt.onAccount)) throw new Error('Provided onAccount should be an AccountBase')
-    onAccount = opt.onAccount
-  }
-  return onAccount
-}

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

@@ -3,26 +3,37 @@
  *
  * @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 { v4 as uuid } from '@aeternity/uuid'
 import Ae from '../../../ae'
 import RpcClient from './rpc-client'
-import { getHandler, message, voidFn } from '../helpers'
+import { getHandler, message } from '../helpers'
 import { METHODS, RPC_STATUS, VERSION } from '../schema'
+import {
+  AlreadyConnectedError,
+  NoWalletConnectedError,
+  UnsubscribedAccountError,
+  UnAuthorizedAccountError,
+  ArgumentError,
+  RpcConnectionError
+} from '../../errors'
+import { Node } from '../../../index'
 
 const NOTIFICATIONS = {
-  [METHODS.wallet.updateAddress]: (instance) =>
+  [METHODS.updateAddress]: (instance) =>
     ({ params }) => {
       instance.rpcClient.accounts = params
       instance.onAddressChange(params)
     },
   [METHODS.updateNetwork]: (instance) =>
-    (msg) => {
-      instance.rpcClient.info.networkId = msg.params.networkId
-      instance.onNetworkChange(msg.params)
+    async ({ params }) => {
+      const { networkId, node } = params
+      instance.rpcClient.info.networkId = networkId
+      node && instance.addNode(node.name, await Node(node), true)
+      instance.onNetworkChange(params)
     },
   [METHODS.closeConnection]: (instance) =>
     (msg) => {
@@ -32,27 +43,33 @@ const NOTIFICATIONS = {
 }
 
 const RESPONSES = {
-  [METHODS.aepp.address]: (instance) =>
+  [METHODS.address]: (instance) =>
     (msg) => instance.rpcClient.processResponse(msg),
-  [METHODS.aepp.connect]: (instance) =>
+  [METHODS.connect]: (instance) =>
     (msg) => {
       if (msg.result) instance.rpcClient.info.status = RPC_STATUS.CONNECTED
       instance.rpcClient.processResponse(msg)
     },
-  [METHODS.aepp.subscribeAddress]: (instance) =>
+  [METHODS.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) =>
+  [METHODS.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) =>
+  [METHODS.signMessage]: (instance) =>
     (msg) => {
       instance.rpcClient.processResponse(msg, ({ id, result }) => [result.signature])
     }
@@ -84,8 +101,18 @@ 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 }) {
-    const eventsHandlers = ['onDisconnect', 'onAddressChange', 'onNetworkChange']
+  async init ({
+    name,
+    connection,
+    debug = false,
+    ...other
+  }) {
+    ['onAddressChange', 'onDisconnect', 'onNetworkChange'].forEach(event => {
+      const handler = other[event] ?? (() => {})
+      if (typeof handler !== 'function') throw new ArgumentError(event, 'a function', handler)
+      this[event] = handler
+    })
+
     this.connection = connection
     this.name = name
     this.debug = debug
@@ -94,21 +121,13 @@ export default Ae.compose({
       // Init RPCClient
       await this.connectToWallet(connection)
     }
-    // Event callbacks
-    this.onDisconnect = onDisconnect
-    this.onAddressChange = onAddressChange
-    this.onNetworkChange = onNetworkChange
-    // validation
-    eventsHandlers.forEach(event => {
-      if (!forceValidation && typeof this[event] !== 'function') throw new Error(`Call-back for ${event} must be an function!`)
-    })
   },
   deepProps: { Ae: { defaults: { walletBroadcast: true } } },
   methods: {
     sign () {
     },
     addresses () {
-      if (!this.rpcClient.currentAccount) throw new Error('You are not subscribed for an account.')
+      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
       return [this.rpcClient.currentAccount, ...Object.keys(this.rpcClient.accounts.connected)]
     },
     /**
@@ -117,10 +136,14 @@ export default Ae.compose({
      * @instance
      * @rtype (connection: Object) => void
      * @param {Object} connection Wallet connection object
-     * @return {void}
+     * @param {Object} [options={}]
+     * @param {Boolean} [options.connectNode=true] - Request wallet to bind node
+     * @param {String}  [options.name=wallet-node] - Node name
+     * @param {Boolean} [options.select=false] - Select this node as current
+     * @return {Object}
      */
-    async connectToWallet (connection) {
-      if (this.rpcClient && this.rpcClient.isConnected()) throw new Error('You are already connected to wallet ' + this.rpcClient)
+    async connectToWallet (connection, { connectNode = false, name = 'wallet-node', select = false } = {}) {
+      if (this.rpcClient && this.rpcClient.isConnected()) throw new AlreadyConnectedError('You are already connected to wallet ' + this.rpcClient)
       this.rpcClient = RpcClient({
         connection,
         networkId: this.getNetworkId({ force: true }),
@@ -128,7 +151,12 @@ export default Ae.compose({
         id: uuid(),
         handlers: [handleMessage(this), this.onDisconnect]
       })
-      return this.sendConnectRequest()
+      const walletInfo = await this.sendConnectRequest(connectNode)
+      if (connectNode && !Object.prototype.hasOwnProperty.call(walletInfo, 'node')) {
+        throw new RpcConnectionError('Missing URLs of the Node')
+      }
+      connectNode && this.addNode(name, await Node(walletInfo.node), select)
+      return walletInfo
     },
     /**
      * Disconnect from wallet
@@ -139,16 +167,18 @@ export default Ae.compose({
      * @return {void}
      */
     async disconnectWallet (sendDisconnect = true) {
-      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
       sendDisconnect && this.rpcClient.sendMessage(message(METHODS.closeConnection, { reason: 'bye' }), true)
       this.rpcClient.disconnect()
       this.rpcClient = null
     },
     async address ({ onAccount } = {}) {
-      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
       const current = this.rpcClient.currentAccount
-      if (!current) throw new Error('You are not subscribed for an account.')
-      if (onAccount && !this.rpcClient.hasAccessToAccount(onAccount)) throw new Error(`You do not have access to account ${onAccount}`)
+      if (!current) throw new UnsubscribedAccountError()
+      if (onAccount && !this.rpcClient.hasAccessToAccount(onAccount)) {
+        throw new UnAuthorizedAccountError(onAccount)
+      }
       return onAccount || current
     },
     /**
@@ -159,22 +189,22 @@ export default Ae.compose({
      * @return {Promise} Address from wallet
      */
     async askAddresses () {
-      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.')
-      return this.rpcClient.request(METHODS.aepp.address)
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
+      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
+      return this.rpcClient.request(METHODS.address)
     },
     /**
      * Subscribe for addresses from wallet
      * @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
      */
     async subscribeAddress (type, value) {
-      if (!this.rpcClient || !this.rpcClient.isConnected()) throw new Error('You are not connected to Wallet')
-      return this.rpcClient.request(METHODS.aepp.subscribeAddress, { type, value })
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
+      return this.rpcClient.request(METHODS.subscribeAddress, { type, value })
     },
     /**
      * Overwriting of `signTransaction` AE method
@@ -185,10 +215,15 @@ export default Ae.compose({
      * @return {Promise<String>} Signed transaction
      */
     async signTransaction (tx, opt = {}) {
-      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() })
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
+      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
+      if (opt.onAccount && !this.rpcClient.hasAccessToAccount(opt.onAccount)) {
+        throw new UnAuthorizedAccountError(opt.onAccount)
+      }
+      return this.rpcClient.request(
+        METHODS.sign,
+        { ...opt, tx, returnSigned: true, networkId: this.getNetworkId() }
+      )
     },
     /**
      * Overwriting of `signMessage` AE method
@@ -199,31 +234,36 @@ export default Ae.compose({
      * @return {Promise<String>} Signed transaction
      */
     async signMessage (msg, opt = {}) {
-      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.signMessage, { ...opt, message: msg })
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
+      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
+      if (opt.onAccount && !this.rpcClient.hasAccessToAccount(opt.onAccount)) {
+        throw new UnAuthorizedAccountError(opt.onAccount)
+      }
+      return this.rpcClient.request(METHODS.signMessage, { ...opt, message: msg })
     },
     /**
      * Send connection request to wallet
      * @function sendConnectRequest
      * @instance
+     * @param {Boolean} connectNode - Request wallet to bind node
      * @rtype () => Promise
      * @return {Promise} Connection response
      */
-    async sendConnectRequest () {
+    async sendConnectRequest (connectNode) {
       return this.rpcClient.request(
-        METHODS.aepp.connect, {
+        METHODS.connect, {
           name: this.name,
           version: VERSION,
-          networkId: this.getNetworkId({ force: true })
+          networkId: this.getNetworkId({ force: true }),
+          connectNode
         }
       )
     },
     /**
      * 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
@@ -233,15 +273,22 @@ export default Ae.compose({
      * @return {Promise<Object>} Transaction broadcast result
      */
     async send (tx, options = {}) {
-      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)
+      if (!this.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
+      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
+      if (options.onAccount && !this.rpcClient.hasAccessToAccount(options.onAccount)) {
+        throw new UnAuthorizedAccountError(options.onAccount)
+      }
+      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.sign,
+        { onAccount: opt.onAccount, tx, returnSigned: false, networkId: this.getNetworkId() }
+      )
+    },
+    isConnected () { return (this.rpcClient && this.rpcClient.isConnected()) },
+    isSubscribedAccount () { return typeof this.rpcClient.currentAccount !== 'undefined' }
   }
 })