@aeternity/aepp-sdk 10.0.0 → 11.0.0

package/src/tx/tx-object.js

@@ -9,6 +9,7 @@ import { buildTx, calculateFee, unpackTx } from './builder'
 import { TX_TYPE } from './builder/schema'
 import { encode } from './builder/helpers'
 import { isHex } from '../utils/string'
+import { InvalidTxError, TypeError, UnknownTxError, InvalidSignatureError } from '../utils/errors'
 
 /**
  * Build transaction from object
@@ -22,8 +23,8 @@ import { isHex } from '../utils/string'
  * }}
  */
 const buildTransaction = (type, params, options = {}) => {
-  if (typeof params !== 'object') throw new Error('"params" should be an object')
-  if (typeof type !== 'string' || !Object.values(TX_TYPE).includes(type)) throw new Error(`Unknown transaction type ${type}`)
+  if (typeof params !== 'object') throw new TypeError('tx "params" should be an object')
+  if (typeof type !== 'string' || !Object.values(TX_TYPE).includes(type)) throw new UnknownTxError(`Unknown transaction type ${type}`)
   const fee = calculateFee(params.fee, type, { gas: params.gas, params, vsn: params.vsn })
   const { rlpEncoded, binary, tx: encodedTx, txObject } = buildTx(
     { ...params, fee }, type, { vsn: params.vsn, ...options }
@@ -34,22 +35,23 @@ const buildTransaction = (type, params, options = {}) => {
 /**
  * Unpack transaction from RLP encoded binary or base64c string
  * @alias module:@aeternity/aepp-sdk/es/tx/tx-object
- * @param {Buffer|String} tx RLP encoded binary or base64c(rlpBinary) string
+ * @param {Uint8Array|String} tx RLP encoded binary or base64c(rlpBinary) string
  * @throws {Error} Arguments validation error's
  * @return {{
  *   encodedTx: String, binary: Array<Buffer>, rlpEncoded: Buffer, type: String, params: Object
  * }}
  */
 const unpackTransaction = (tx) => {
-  if (!tx) throw new Error(`Invalid transaction: ${tx}`)
+  if (!tx) throw new InvalidTxError(`Invalid transaction: ${tx}`)
   if (typeof tx === 'string') {
     const { txType: type, tx: params, rlpEncoded, binary } = unpackTx(tx)
     return { encodedTx: tx, type, params, rlpEncoded, binary }
   }
-  if (Buffer.isBuffer(tx)) {
+  if (tx instanceof Uint8Array) {
     const { txType: type, tx: params, rlpEncoded, binary } = unpackTx(tx, true)
     return { encodedTx: encode(tx, 'tx'), type, params, rlpEncoded, binary }
   }
+  throw new InvalidTxError(`"tx" should be a string or Uint8Array, got ${tx} instead`)
 }
 
 /**
@@ -68,7 +70,7 @@ const unpackTransaction = (tx) => {
 const initTransaction = ({ tx, params, type, options = {} } = {}) => {
   if (params && type) return buildTransaction(type, params, options)
   if (tx) return unpackTransaction(tx)
-  throw new Error('Invalid TxObject arguments. Please provide one of { tx: "tx_asdasd23..." } or { type: "spendTx", params: {...} }')
+  throw new InvalidTxError('Invalid TxObject arguments. Please provide one of { tx: "tx_asdasd23..." } or { type: "spendTx", params: {...} }')
 }
 
 /**
@@ -127,7 +129,7 @@ export const TxObject = stampit({
      * @return {TxObject}
      */
     setProp (props = {}, options = {}) {
-      if (typeof props !== 'object') throw new Error('Props should be an object')
+      if (typeof props !== 'object') throw new TypeError('Props should be an object')
       this.isSigned = false
       this.signatures = []
       Object.assign(
@@ -144,7 +146,6 @@ export const TxObject = stampit({
      * @return {Array} Array of signatures
      */
     getSignatures () {
-      if (!this.isSigned) throw new Error('Signature not found, transaction is not signed')
       return this.signatures
     },
     /**
@@ -155,7 +156,7 @@ export const TxObject = stampit({
      */
     addSignature (signature) {
       signature = isHex(signature) ? Buffer.from(signature, 'hex') : signature
-      if (!Buffer.isBuffer(signature) && !(signature instanceof Uint8Array)) throw new Error('Invalid signature, signature must be of type Buffer or Uint8Array')
+      if (!Buffer.isBuffer(signature) && !(signature instanceof Uint8Array)) throw new InvalidSignatureError('Invalid signature, signature must be of type Buffer or Uint8Array')
       Object.assign(
         this,
         buildTransaction(

package/src/tx/tx.js

@@ -26,8 +26,15 @@ import ChainNode from '../chain/node'
 import Tx from './'
 import { buildTx, calculateFee, unpackTx } from './builder'
 import { ABI_VERSIONS, MIN_GAS_PRICE, PROTOCOL_VM_ABI, TX_TYPE, TX_TTL } from './builder/schema'
-import { buildContractId } from './builder/helpers'
+import { buildContractId, encode } from './builder/helpers'
 import { TxObject } from './tx-object'
+import {
+  ArgumentError,
+  UnsupportedABIversionError,
+  UnsupportedVMversionError,
+  UnsupportedProtocolError,
+  UnknownTxError
+} from '../utils/errors'
 
 async function spendTx ({ senderId, recipientId, amount, payload = '' }) {
   // Calculate fee, get absolute ttl (ttl + height), get account nonce
@@ -96,7 +103,9 @@ async function nameClaimTx ({ accountId, name, nameSalt, vsn = 2 }) {
           type: TX_TYPE.nameClaim
         }).encodedTx
       }
-    : await this.api.postNameClaim({ ...arguments[0], nonce, ttl, fee: parseInt(fee) })
+    : await this.api.postNameClaim({
+      ...arguments[0], nonce, ttl, fee: parseInt(fee), name: encode(name, 'nm')
+    })
 
   return tx
 }
@@ -161,7 +170,7 @@ async function nameRevokeTx ({ accountId, nameId }) {
 }
 
 async function contractCreateTx ({
-  ownerId, code, vmVersion, abiVersion, deposit, amount, gas, gasPrice = MIN_GAS_PRICE, callData
+  ownerId, code, vmVersion, abiVersion, amount, gas, gasPrice = MIN_GAS_PRICE, callData
 }) {
   // Get VM_ABI version
   const ctVersion = this.getVmVersion(TX_TYPE.contractCreate, arguments[0])
@@ -493,17 +502,17 @@ async function payingForTx ({ tx, payerId, ...args }) {
 function getVmVersion (txType, { vmVersion, abiVersion } = {}) {
   const { consensusProtocolVersion } = this.getNodeInfo()
   const supportedProtocol = PROTOCOL_VM_ABI[consensusProtocolVersion]
-  if (!supportedProtocol) throw new Error('Not supported consensus protocol version')
+  if (!supportedProtocol) throw new UnsupportedProtocolError('Not supported consensus protocol version')
   const protocolForTX = supportedProtocol[txType]
-  if (!protocolForTX) throw new Error('Not supported tx type')
+  if (!protocolForTX) throw new UnknownTxError('Not supported tx type')
 
   abiVersion = abiVersion || protocolForTX.abiVersion[0]
   vmVersion = vmVersion || protocolForTX.vmVersion[0]
   if (!protocolForTX.vmVersion.includes(vmVersion)) {
-    throw new Error(`VM VERSION ${vmVersion} do not support by this node. Supported: [${protocolForTX.vmVersion}]`)
+    throw new UnsupportedVMversionError(`VM VERSION ${vmVersion} do not support by this node. Supported: [${protocolForTX.vmVersion}]`)
   }
   if (!protocolForTX.abiVersion.includes(abiVersion)) {
-    throw new Error(`ABI VERSION ${abiVersion} do not support by this node. Supported: [${protocolForTX.abiVersion}]`)
+    throw new UnsupportedABIversionError(`ABI VERSION ${abiVersion} do not support by this node. Supported: [${protocolForTX.abiVersion}]`)
   }
 
   return { vmVersion, abiVersion }
@@ -518,7 +527,7 @@ function getVmVersion (txType, { vmVersion, abiVersion } = {}) {
  */
 async function calculateTtl (ttl = TX_TTL, relative = true) {
   if (ttl === 0) return 0
-  if (ttl < 0) throw new Error('ttl must be greater than 0')
+  if (ttl < 0) throw new ArgumentError('ttl', 'greater or equal to 0', ttl)
 
   if (relative) {
     const { height } = await this.api.getCurrentKeyBlock()

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'),
@@ -104,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]
@@ -117,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']
+      }]
+    }
   }
 ]
 
@@ -146,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

@@ -28,6 +28,11 @@ import stampit from '@stamp/it'
 
 import WalletConnection from '.'
 import { getBrowserAPI } from '../helpers'
+import {
+  RpcConnectionError,
+  AlreadyConnectedError,
+  NoWalletConnectedError
+} from '../../errors'
 
 /**
  * Disconnect
@@ -54,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)
@@ -75,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)
 }
@@ -105,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

@@ -28,9 +28,14 @@
  */
 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
@@ -56,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
@@ -80,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
 }
@@ -141,8 +146,8 @@ export default stampit({
     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)}]`)
+    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
@@ -155,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/content-script-bridge.js

@@ -25,6 +25,7 @@
  * from '@aeternity/aepp-sdk/es/utils/wallet-communication/content-script-bridge
  */
 import stampit from '@stamp/it'
+import { UnsupportedPlatformError, MissingParamError } from '../errors'
 
 /**
  * Start message proxy
@@ -66,7 +67,7 @@ function stop () {
  * @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/\
+ * (@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)
@@ -74,9 +75,9 @@ function stop () {
  */
 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 {}
 }
 
@@ -57,14 +57,4 @@ export const responseMessage = (id, method, { error, result } = {}) =>
 export const sendResponseMessage = (client) => (id, method, data) =>
   client.sendMessage(responseMessage(id, method, data), true)
 
-export const voidFn = () => undefined
-
 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

@@ -7,22 +7,33 @@
  * import ContentScriptBridge
  * from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc'
  */
-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,14 +43,14 @@ 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) {
         if (msg.result.address) {
@@ -52,13 +63,13 @@ const RESPONSES = {
 
       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]
       )
     },
-  [METHODS.aepp.signMessage]: (instance) =>
+  [METHODS.signMessage]: (instance) =>
     (msg) => {
       instance.rpcClient.processResponse(msg, ({ id, result }) => [result.signature])
     }
@@ -92,14 +103,16 @@ const handleMessage = (instance) => async (msg) => {
 export default Ae.compose({
   async init ({
     name,
-    onAddressChange = voidFn,
-    onDisconnect = voidFn,
-    onNetworkChange = voidFn,
     connection,
-    forceValidation = false,
-    debug = false
+    debug = false,
+    ...other
   }) {
-    const eventsHandlers = ['onDisconnect', 'onAddressChange', 'onNetworkChange']
+    ['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
@@ -108,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)]
     },
     /**
@@ -131,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 }),
@@ -142,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
@@ -153,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
     },
     /**
@@ -173,9 +189,9 @@ 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
@@ -187,8 +203,8 @@ export default Ae.compose({
      * @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
@@ -199,11 +215,13 @@ 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}`)
+      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.aepp.sign,
+        METHODS.sign,
         { ...opt, tx, returnSigned: true, networkId: this.getNetworkId() }
       )
     },
@@ -216,24 +234,28 @@ 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
         }
       )
     },
@@ -251,18 +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}`)
+      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,
+        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' }
   }
 })