@aeternity/aepp-sdk 11.0.0 → 12.1.0

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

@@ -1,294 +0,0 @@
-/**
- * RPC handler for AEPP side
- *
- * @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'
- */
-import { v4 as uuid } from '@aeternity/uuid'
-import Ae from '../../../ae'
-import RpcClient from './rpc-client'
-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.updateAddress]: (instance) =>
-    ({ params }) => {
-      instance.rpcClient.accounts = params
-      instance.onAddressChange(params)
-    },
-  [METHODS.updateNetwork]: (instance) =>
-    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) => {
-      instance.disconnectWallet()
-      instance.onDisconnect(msg.params)
-    }
-}
-
-const RESPONSES = {
-  [METHODS.address]: (instance) =>
-    (msg) => instance.rpcClient.processResponse(msg),
-  [METHODS.connect]: (instance) =>
-    (msg) => {
-      if (msg.result) instance.rpcClient.info.status = RPC_STATUS.CONNECTED
-      instance.rpcClient.processResponse(msg)
-    },
-  [METHODS.subscribeAddress]: (instance) =>
-    (msg) => {
-      if (msg.result) {
-        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.sign]: (instance) =>
-    (msg) => {
-      instance.rpcClient.processResponse(
-        msg, ({ id, result }) => [result.signedTransaction || result.transactionHash]
-      )
-    },
-  [METHODS.signMessage]: (instance) =>
-    (msg) => {
-      instance.rpcClient.processResponse(msg, ({ id, result }) => [result.signature])
-    }
-}
-
-const REQUESTS = {}
-
-const handleMessage = (instance) => async (msg) => {
-  if (!msg.id) {
-    return getHandler(NOTIFICATIONS, msg, { debug: instance.debug })(instance)(msg)
-  } else if (Object.prototype.hasOwnProperty.call(instance.rpcClient.callbacks, msg.id)) {
-    return getHandler(RESPONSES, msg, { debug: instance.debug })(instance)(msg)
-  } else {
-    return getHandler(REQUESTS, msg, { debug: instance.debug })(instance)(msg)
-  }
-}
-
-/**
- * Contain functionality for wallet interaction and connect it to sdk
- * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/aepp-rpc
- * @function
- * @rtype Stamp
- * @param {Object} param Init params object
- * @param {String=} [param.name] Aepp name
- * @param {Function} onAddressChange Call-back function for update address event
- * @param {Function} onDisconnect Call-back function for disconnect event
- * @param {Function} onNetworkChange Call-back function for update network event
- * @param {Object} connection Wallet connection object
- * @return {Object}
- */
-export default Ae.compose({
-  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
-
-    if (connection) {
-      // Init RPCClient
-      await this.connectToWallet(connection)
-    }
-  },
-  deepProps: { Ae: { defaults: { walletBroadcast: true } } },
-  methods: {
-    sign () {
-    },
-    addresses () {
-      if (!this.isSubscribedAccount()) throw new UnsubscribedAccountError()
-      return [this.rpcClient.currentAccount, ...Object.keys(this.rpcClient.accounts.connected)]
-    },
-    /**
-     * Connect to wallet
-     * @function connectToWallet
-     * @instance
-     * @rtype (connection: Object) => void
-     * @param {Object} connection Wallet connection object
-     * @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, { 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 }),
-        ...connection.connectionInfo,
-        id: uuid(),
-        handlers: [handleMessage(this), this.onDisconnect]
-      })
-      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
-     * @function disconnectWallet
-     * @instance
-     * @rtype (force: Boolean = false) => void
-     * @param {Boolean} sendDisconnect=false Force sending close connection message
-     * @return {void}
-     */
-    async disconnectWallet (sendDisconnect = true) {
-      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.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
-      const current = this.rpcClient.currentAccount
-      if (!current) throw new UnsubscribedAccountError()
-      if (onAccount && !this.rpcClient.hasAccessToAccount(onAccount)) {
-        throw new UnAuthorizedAccountError(onAccount)
-      }
-      return onAccount || current
-    },
-    /**
-     * Ask address from wallet
-     * @function askAddresses
-     * @instance
-     * @rtype () => Promise
-     * @return {Promise} Address from wallet
-     */
-    async askAddresses () {
-      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 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.isConnected()) throw new NoWalletConnectedError('You are not connected to Wallet')
-      return this.rpcClient.request(METHODS.subscribeAddress, { type, value })
-    },
-    /**
-     * Overwriting of `signTransaction` AE method
-     * All sdk API which use it will be send notification to wallet and wait for callBack
-     * @function signTransaction
-     * @instance
-     * @rtype (tx: String, options = {}) => Promise
-     * @return {Promise<String>} Signed transaction
-     */
-    async signTransaction (tx, opt = {}) {
-      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
-     * All sdk API which use it will be send notification to wallet and wait for callBack
-     * @function signMessage
-     * @instance
-     * @rtype (msg: String, options = {}) => Promise
-     * @return {Promise<String>} Signed transaction
-     */
-    async signMessage (msg, opt = {}) {
-      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 (connectNode) {
-      return this.rpcClient.request(
-        METHODS.connect, {
-          name: this.name,
-          version: VERSION,
-          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
-     * @function send
-     * @instance
-     * @rtype (tx: String, options = {}) => Promise
-     * @param {String} tx
-     * @param {Object} [options={}]
-     * @param {Object} [options.walletBroadcast=true]
-     * @return {Promise<Object>} Transaction broadcast result
-     */
-    async send (tx, 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.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

@@ -1,232 +0,0 @@
-/**
- * RpcClient module
- *
- * @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'
- */
-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
- * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/rpc-client
- * @function
- * @rtype Stamp
- * @param {Object} param Init params object
- * @param {String} param.name Client name
- * @param {Object} param.connection Connection object
- * @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({
-  init ({ id, name, networkId, icons, connection, handlers: [onMessage, onDisconnect] }) {
-    this.id = id
-    this.connection = connection
-    this.info = { name, networkId, icons }
-    // {
-    //    [msg.id]: { resolve, reject }
-    // }
-    this.callbacks = {}
-    // ['connected', 'current']
-    this.addressSubscription = []
-    // {
-    //    connected: { [pub]: {...meta} },
-    //    current: { [pub]: {...meta} }
-    // }
-    this.accounts = {}
-
-    this.sendMessage = sendMessage(this.connection)
-
-    const handleMessage = (msg, origin) => {
-      if (!msg || !msg.jsonrpc || msg.jsonrpc !== '2.0' || !msg.method) {
-        throw new InvalidRpcMessageError(msg)
-      }
-      onMessage(msg, origin)
-    }
-
-    const disconnect = (aepp, connection) => {
-      this.disconnect(true)
-      typeof onDisconnect === 'function' && onDisconnect(connection, this)
-    }
-
-    connection.connect(handleMessage, disconnect)
-  },
-  propertyDescriptors: {
-    currentAccount: {
-      enumerable: true,
-      configurable: false,
-      get () {
-        return this.isHasAccounts()
-          ? Object.keys(this.accounts.current)[0]
-          : undefined
-      }
-    },
-    addresses: {
-      enumerable: true,
-      configurable: false,
-      get () {
-        return this.isHasAccounts()
-          ? [...Object.keys(this.accounts.current), ...Object.keys(this.accounts.connected)]
-          : []
-      }
-    },
-    origin: {
-      enumerable: true,
-      configurable: false,
-      get () {
-        return this.connection
-      }
-    }
-  },
-  methods: {
-    /**
-     * Update info
-     * @function updateInfo
-     * @instance
-     * @rtype (info: Object) => void
-     * @param {Object} info Info to update (will be merged with current info object)
-     * @return {void}
-     */
-    updateInfo (info) {
-      Object.assign(this.info, info)
-    },
-    isHasAccounts () {
-      return typeof this.accounts === 'object' &&
-        typeof this.accounts.connected === 'object' &&
-        typeof this.accounts.current === 'object'
-    },
-    isSubscribed () {
-      return this.addressSubscription.length && this.isHasAccounts()
-    },
-    /**
-     * Check if aepp has access to account
-     * @function hasAccessToAccount
-     * @instance
-     * @rtype (address: String) => Boolean
-     * @param {String} address Account address
-     * @return {Boolean} is connected
-     */
-    hasAccessToAccount (address) {
-      return !!address && this.addresses.find(a => a === address)
-    },
-    /**
-     * Check if is connected
-     * @function isConnected
-     * @instance
-     * @rtype () => Boolean
-     * @return {Boolean} is connected
-     */
-    isConnected () {
-      return this.connection.isConnected() &&
-        (this.info.status === RPC_STATUS.CONNECTED || this.info.status === RPC_STATUS.NODE_BINDED)
-    },
-    /**
-     * Get selected account
-     * @function getCurrentAccount
-     * @instance
-     * @rtype ({ onAccount } = {}) => String
-     * @param {Object} options Options
-     * @return {String}
-     */
-    getCurrentAccount ({ onAccount } = {}) {
-      return onAccount || Object.keys(this.accounts.current)[0]
-    },
-    /**
-     * Disconnect
-     * @function disconnect
-     * @instance
-     * @rtype () => void
-     * @return {void}
-     */
-    disconnect (forceConnectionClose = false) {
-      this.info.status = RPC_STATUS.DISCONNECTED
-      this.addressSubscription = []
-      this.accounts = {}
-      forceConnectionClose || this.connection.disconnect()
-    },
-    /**
-     * Update accounts and sent `update.address` 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 } = {}) {
-      if (!isValidAccounts(accounts)) {
-        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.updateAddress, this.accounts), true)
-      }
-    },
-    /**
-     * Update subscription
-     * @function updateSubscription
-     * @instance
-     * @rtype (type: String, value: String) => void
-     * @param {String} type Subscription type
-     * @param {String} value Subscription value
-     * @return {String[]}
-     */
-    updateSubscription (type, value) {
-      if (type === SUBSCRIPTION_TYPES.subscribe && !this.addressSubscription.includes(value)) {
-        this.addressSubscription.push(value)
-      }
-      if (type === SUBSCRIPTION_TYPES.unsubscribe && this.addressSubscription.includes(value)) {
-        this.addressSubscription = this.addressSubscription.filter(s => s !== value)
-      }
-      return this.addressSubscription
-    },
-    /**
-     * Make a request
-     * @function request
-     * @instance
-     * @rtype (name: String, params: Object) => Promise
-     * @param {String} name Method name
-     * @param {Object} params Method params
-     * @return {Promise} Promise which will be resolved after receiving response message
-     */
-    request (name, params) {
-      const msgId = this.sendMessage(message(name, params))
-      if (Object.prototype.hasOwnProperty.call(this.callbacks, msgId)) {
-        throw new DuplicateCallbackError()
-      }
-      return new Promise((resolve, reject) => {
-        this.callbacks[msgId] = { resolve, reject }
-      })
-    },
-    /**
-     * Process response message
-     * @function processResponse
-     * @instance
-     * @rtype (msg: Object, transformResult: Function) => void
-     * @param {Object} msg Message object
-     * @param {Function=} transformResult Optional parser function for message
-     * @return {void}
-     */
-    processResponse ({ id, error, result }, transformResult) {
-      if (!this.callbacks[id]) throw new MissingCallbackError(id)
-      if (result) {
-        this.callbacks[id].resolve(...typeof transformResult === 'function'
-          ? transformResult({ id, result })
-          : [result])
-      } else {
-        this.callbacks[id].reject(error)
-      }
-      delete this.callbacks[id]
-    }
-  }
-})