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

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

@@ -3,24 +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 { 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 '../../../node'
 
 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) => {
@@ -30,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])
     }
@@ -82,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
@@ -92,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)]
     },
     /**
@@ -115,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 }),
@@ -126,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
@@ -137,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
     },
     /**
@@ -157,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
@@ -183,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
@@ -197,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
@@ -231,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}`)
+      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' }
   }
 })

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

@@ -3,12 +3,19 @@
  *
  * @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'
 
 import { METHODS, RPC_STATUS, SUBSCRIPTION_TYPES } from '../schema'
 import { sendMessage, message, isValidAccounts } from '../helpers'
+import {
+  InvalidRpcMessageError,
+  TypeError,
+  DuplicateCallbackError,
+  MissingCallbackError
+} from '../../errors'
 
 /**
  * Contain functionality for using RPC conection
@@ -18,7 +25,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({
@@ -42,7 +51,7 @@ export default stampit({
 
     const handleMessage = (msg, origin) => {
       if (!msg || !msg.jsonrpc || msg.jsonrpc !== '2.0' || !msg.method) {
-        throw new Error(`Received invalid message: ${msg}`)
+        throw new InvalidRpcMessageError(msg)
       }
       onMessage(msg, origin)
     }
@@ -120,7 +129,8 @@ export default stampit({
      * @return {Boolean} is connected
      */
     isConnected () {
-      return this.connection.isConnected() && this.info.status === RPC_STATUS.CONNECTED
+      return this.connection.isConnected() &&
+        (this.info.status === RPC_STATUS.CONNECTED || this.info.status === RPC_STATUS.NODE_BINDED)
     },
     /**
      * Get selected account
@@ -148,17 +158,18 @@ 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: {} }`')
+        throw new TypeError('Invalid accounts object. Should be object like: `{ connected: {}, selected: {} }`')
       }
       this.accounts = accounts
       if (!forceNotification) {
         // Sent notification about account updates
-        this.sendMessage(message(METHODS.wallet.updateAddress, this.accounts), true)
+        this.sendMessage(message(METHODS.updateAddress, this.accounts), true)
       }
     },
     /**
@@ -190,7 +201,9 @@ export default stampit({
      */
     request (name, params) {
       const msgId = this.sendMessage(message(name, params))
-      if (Object.prototype.hasOwnProperty.call(this.callbacks, msgId)) throw new Error('Callback Already exist')
+      if (Object.prototype.hasOwnProperty.call(this.callbacks, msgId)) {
+        throw new DuplicateCallbackError()
+      }
       return new Promise((resolve, reject) => {
         this.callbacks[msgId] = { resolve, reject }
       })
@@ -205,7 +218,7 @@ export default stampit({
      * @return {void}
      */
     processResponse ({ id, error, result }, transformResult) {
-      if (!this.callbacks[id]) throw new Error(`Can't find callback for this messageId ${id}`)
+      if (!this.callbacks[id]) throw new MissingCallbackError(id)
       if (result) {
         this.callbacks[id].resolve(...typeof transformResult === 'function'
           ? transformResult({ id, result })