@aeternity/aepp-sdk 11.0.1 → 12.0.0

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

@@ -1,401 +0,0 @@
-/**
- * RPC handler for WAELLET side
- *
- * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc
- * @export WalletRpc
- * @example
- * import WalletRpc from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc'
- */
-import { v4 as uuid } from '@aeternity/uuid'
-import Ae from '../../../ae'
-import verifyTransaction from '../../../tx/validator'
-import AccountMultiple from '../../../account/multiple'
-import TxObject from '../../../tx/tx-object'
-import RpcClient from './rpc-client'
-import { getBrowserAPI, getHandler, isValidAccounts, message, sendResponseMessage } from '../helpers'
-import { ERRORS, METHODS, RPC_STATUS, VERSION, WALLET_TYPE } from '../schema'
-import { ArgumentError, TypeError, UnknownRpcClientError } from '../../errors'
-import { isAccountBase } from '../../../account/base'
-
-const resolveOnAccount = (addresses, onAccount, opt = {}) => {
-  if (!addresses.find(a => a === onAccount)) {
-    if (typeof opt.onAccount !== 'object' || !isAccountBase(opt.onAccount)) throw new TypeError('Provided onAccount should be an AccountBase')
-    onAccount = opt.onAccount
-  }
-  return onAccount
-}
-
-const NOTIFICATIONS = {
-  [METHODS.closeConnection]: (instance, { client }) =>
-    async (msg) => {
-      client.disconnect(true)
-      instance.onDisconnect(msg.params, client)
-    }
-}
-
-const RESPONSES = {}
-
-const REQUESTS = {
-  // Store client info and prepare two fn for each client `connect` and `denyConnection`
-  // which automatically prepare and send response for that client
-  [METHODS.connect] (
-    callInstance,
-    instance,
-    client,
-    { name, networkId, version, icons, connectNode }) {
-    // Check if protocol and network is compatible with wallet
-    if (version !== VERSION) return { error: ERRORS.unsupportedProtocol() }
-    // Store new AEPP and wait for connection approve
-    client.updateInfo({
-      status: RPC_STATUS.WAITING_FOR_CONNECTION_APPROVE,
-      name,
-      networkId,
-      icons,
-      version,
-      origin: window.location.origin,
-      connectNode
-    })
-
-    // Call onConnection callBack to notice Wallet about new AEPP
-    return callInstance(
-      'onConnection',
-      { name, networkId, version },
-      ({ shareNode } = {}) => {
-        client.updateInfo({ status: shareNode ? RPC_STATUS.NODE_BINDED : RPC_STATUS.CONNECTED })
-        return {
-          result: {
-            ...instance.getWalletInfo(),
-            ...(shareNode && { node: instance.selectedNode })
-          }
-        }
-      },
-      (error) => {
-        client.updateInfo({ status: RPC_STATUS.CONNECTION_REJECTED })
-        return { error: ERRORS.connectionDeny(error) }
-      }
-    )
-  },
-  [METHODS.subscribeAddress] (callInstance, instance, client, { type, value }) {
-    // Authorization check
-    if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
-
-    return callInstance(
-      'onSubscription',
-      { type, value },
-      async ({ accounts } = {}) => {
-        try {
-          const clientAccounts = accounts || instance.getAccounts()
-          if (!isValidAccounts(clientAccounts)) {
-            throw new TypeError('Invalid provided accounts object')
-          }
-          const subscription = client.updateSubscription(type, value)
-          client.setAccounts(clientAccounts, { forceNotification: true })
-          return {
-            result: {
-              subscription,
-              address: clientAccounts
-            }
-          }
-        } catch (e) {
-          if (instance.debug) console.error(e)
-          return { error: ERRORS.internalError(e.message) }
-        }
-      },
-      (error) => ({ error: ERRORS.rejectedByUser(error) })
-    )
-  },
-  [METHODS.address] (callInstance, instance, client) {
-    // Authorization check
-    if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
-    if (!client.isSubscribed()) return { error: ERRORS.notAuthorize() }
-
-    return callInstance(
-      'onAskAccounts',
-      {},
-      ({ accounts } = {}) => ({
-        result: accounts ||
-          [...Object.keys(client.accounts.current), ...Object.keys(client.accounts.connected)]
-      }),
-      (error) => ({ error: ERRORS.rejectedByUser(error) })
-    )
-  },
-  [METHODS.sign] (callInstance, instance, client, options) {
-    const { tx, onAccount, networkId, returnSigned = false } = options
-    const address = onAccount || client.currentAccount
-    // Update client with new networkId
-    networkId && client.updateInfo({ networkId })
-    // Authorization check
-    if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
-    // Account permission check
-    if (!client.hasAccessToAccount(address)) {
-      return { error: ERRORS.permissionDeny(address) }
-    }
-    // NetworkId check
-    if (!networkId || networkId !== instance.getNetworkId()) {
-      return { error: ERRORS.unsupportedNetwork() }
-    }
-
-    return callInstance(
-      'onSign',
-      { tx, returnSigned, onAccount: address, txObject: TxObject.fromString(tx) },
-      async (rawTx, opt = {}) => {
-        let onAcc
-        try {
-          onAcc = resolveOnAccount(instance.addresses(), address, opt)
-        } catch (e) {
-          if (instance.debug) console.error(e)
-          return { error: ERRORS.internalError(e.message) }
-        }
-        try {
-          const t = rawTx || tx
-          const result = returnSigned
-            ? { signedTransaction: await instance.signTransaction(t, { onAccount: onAcc }) }
-            : { transactionHash: await instance.send(t, { onAccount: onAcc, verify: false }) }
-          return { result }
-        } catch (e) {
-          if (!returnSigned) {
-            // Validate transaction
-            const validation = await verifyTransaction(rawTx || tx, instance.selectedNode.instance)
-            if (validation.length) return { error: ERRORS.invalidTransaction(validation) }
-            // Send broadcast failed error to aepp
-            return { error: ERRORS.broadcastFailed(e.message) }
-          }
-          throw e
-        }
-      },
-      (error) => ({ error: ERRORS.rejectedByUser(error) })
-    )
-  },
-  [METHODS.signMessage] (callInstance, instance, client, { message, onAccount }) {
-    // Authorization check
-    if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
-    const address = onAccount || client.currentAccount
-    if (!client.hasAccessToAccount(address)) {
-      return { error: ERRORS.permissionDeny(address) }
-    }
-
-    return callInstance(
-      'onMessageSign',
-      { message, onAccount: address },
-      async (opt = {}) => {
-        try {
-          const onAcc = resolveOnAccount(instance.addresses(), address, opt)
-          return {
-            result: {
-              signature: await instance.signMessage(message, {
-                onAccount: onAcc,
-                returnHex: true
-              })
-            }
-          }
-        } catch (e) {
-          if (instance.debug) console.error(e)
-          return { error: ERRORS.internalError(e.message) }
-        }
-      },
-      (error) => ({ error: ERRORS.rejectedByUser(error) })
-    )
-  }
-}
-
-const handleMessage = (instance, id) => async (msg, origin) => {
-  const client = instance.rpcClients[id]
-  if (!msg.id) {
-    return getHandler(
-      NOTIFICATIONS, msg, { debug: instance.debug }
-    )(instance, { client })(msg, origin)
-  }
-  if (Object.prototype.hasOwnProperty.call(client.callbacks, msg.id)) {
-    return getHandler(RESPONSES, msg, { debug: instance.debug })(instance, { client })(msg, origin)
-  } else {
-    const { id, method } = msg
-    const callInstance = (methodName, params, accept, deny) => () => new Promise(resolve => {
-      instance[methodName](
-        client,
-        {
-          id,
-          method,
-          params,
-          accept: (...args) => resolve(accept(...args)),
-          deny: (...args) => resolve(deny(...args))
-        },
-        origin
-      )
-    })
-    // TODO make one structure for handler functions
-    const errorObjectOrHandler = getHandler(REQUESTS, msg, { debug: instance.debug })(
-      callInstance, instance, client, msg.params
-    )
-    const response = typeof errorObjectOrHandler === 'function' ? await errorObjectOrHandler() : errorObjectOrHandler
-    sendResponseMessage(client)(id, method, response)
-  }
-}
-
-/**
- * Contain functionality for aepp interaction and managing multiple aepps
- * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc
- * @function
- * @rtype Stamp
- * @param {Object} param Init params object
- * @param {String=} [param.name] Wallet name
- * @param {Function} onConnection Call-back function for incoming AEPP connection
- * @param {Function} onSubscription Call-back function for incoming AEPP account subscription
- * @param {Function} onSign Call-back function for incoming AEPP sign request
- * @param {Function} onAskAccounts Call-back function for incoming AEPP get address request
- * @param {Function} onMessageSign Call-back function for incoming AEPP sign message request
-   * Second argument of incoming call-backs contain function for accept/deny request
- * @param {Function} onDisconnect Call-back function for disconnect event
- * @return {Object}
- */
-export default Ae.compose(AccountMultiple, {
-  init ({
-    name,
-    debug = false,
-    ...other
-  } = {}) {
-    [
-      'onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onAskAccounts', 'onMessageSign'
-    ].forEach(event => {
-      const handler = other[event]
-      if (typeof handler !== 'function') throw new ArgumentError(event, 'a function', handler)
-      this[event] = handler
-    })
-
-    this.debug = debug
-    this.rpcClients = {}
-    this.name = name
-    this.id = uuid()
-
-    const _selectAccount = this.selectAccount.bind(this)
-    const _addAccount = this.addAccount.bind(this)
-    const _selectNode = this.selectNode.bind(this)
-
-    // Overwrite AE methods
-    this.selectAccount = (address, { condition = () => true } = {}) => {
-      _selectAccount(address)
-      Object.values(this.rpcClients)
-        .filter(client => client.isConnected() && client.isSubscribed() &&
-          client.hasAccessToAccount(address) && condition(client))
-        .forEach(client => client.setAccounts({
-          current: { [address]: {} },
-          connected: {
-            ...client.accounts.current,
-            ...Object.entries(client.accounts.connected)
-              .filter(([k, v]) => k !== address)
-              .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {})
-          }
-        }))
-    }
-    this.addAccount = async (account, { select, meta = {}, condition = () => true } = {}) => {
-      await _addAccount(account, { select })
-      const address = await account.address()
-      // Send notification 'update.address' to all Aepp which are subscribed for connected accounts
-      Object.values(this.rpcClients)
-        .filter(client => client.isConnected() && client.isSubscribed() && condition(client))
-        .forEach(client => client.setAccounts({
-          current: { ...select ? { [address]: meta } : client.accounts.current },
-          connected: {
-            ...select ? client.accounts.current : { [address]: meta },
-            ...client.accounts.connected
-          }
-        }))
-    }
-    this.selectNode = (name) => {
-      _selectNode(name)
-      // Send notification 'update.network' to all Aepp which connected
-      Object.values(this.rpcClients)
-        .filter(client => client.isConnected())
-        .forEach(client => {
-          client.sendMessage(
-            message(METHODS.updateNetwork, {
-              networkId: this.getNetworkId(),
-              ...(client.info.status === RPC_STATUS.NODE_BINDED && { node: this.selectedNode })
-            }), true)
-        })
-    }
-  },
-  methods: {
-    /**
-     * Remove specific RpcClient by ID
-     * @function removeRpcClient
-     * @instance
-     * @rtype (id: string) => void
-     * @param {String} id Client ID
-     * @param {Object} [opt = {}]
-     * @return {void}
-     */
-    removeRpcClient (id, { forceConnectionClose = false } = {}) {
-      const client = this.rpcClients[id]
-      if (!client) throw new UnknownRpcClientError(id)
-      client.disconnect(forceConnectionClose)
-      delete this.rpcClients[id]
-    },
-    /**
-     * Add new client by AEPP connection
-     * @function addRpcClient
-     * @instance
-     * @rtype (clientConnection: Object) => Object
-     * @param {Object} clientConnection AEPP connection object
-     * @return {String} Client ID
-     */
-    addRpcClient (clientConnection) {
-      // @TODO  detect if aepp has some history based on origin????
-      // if yes use this instance for connection
-      const id = uuid()
-      this.rpcClients[id] = RpcClient({
-        id,
-        info: { status: RPC_STATUS.WAITING_FOR_CONNECTION_REQUEST },
-        connection: clientConnection,
-        handlers: [handleMessage(this, id), this.onDisconnect]
-      })
-      return id
-    },
-    /**
-     * Share wallet info
-     * Send shareWalletInfo message to notify AEPP about wallet
-     * @function shareWalletInfo
-     * @instance
-     * @rtype (postFn: Function) => void
-     * @param {Function} postFn Send message function like `(msg) => void`
-     * @return {void}
-     */
-    shareWalletInfo (postFn) {
-      postFn({
-        jsonrpc: '2.0',
-        ...message(METHODS.readyToConnect, this.getWalletInfo())
-      })
-    },
-    /**
-     * Get Wallet info object
-     * @function getWalletInfo
-     * @instance
-     * @rtype () => Object
-     * @return {Object} Object with wallet information(id, name, network, ...)
-     */
-    getWalletInfo () {
-      const runtime = getBrowserAPI(true).runtime
-      return {
-        id: runtime && runtime.id ? runtime.id : this.id,
-        name: this.name,
-        networkId: this.getNetworkId(),
-        origin: window.location.origin,
-        type: runtime && runtime.id ? WALLET_TYPE.extension : WALLET_TYPE.window
-      }
-    },
-    /**
-     * Get Wallet accounts
-     * @function getAccounts
-     * @instance
-     * @rtype () => Object
-     * @return {Object} Object with accounts information({ connected: Object, current: Object })
-     */
-    getAccounts () {
-      return {
-        current: this.selectedAddress ? { [this.selectedAddress]: {} } : {},
-        connected: this.addresses()
-          .filter(a => a !== this.selectedAddress)
-          .reduce((acc, a) => ({ ...acc, [a]: {} }), {})
-      }
-    }
-  }
-})

package/src/utils/aepp-wallet-communication/schema.ts

@@ -1,80 +0,0 @@
-export const VERSION = 1
-
-export const enum MESSAGE_DIRECTION {
-  to_waellet = 'to_waellet',
-  to_aepp = 'to_aepp'
-}
-
-export const enum WALLET_TYPE {
-  window = 'window',
-  extension = 'extension'
-}
-
-export const enum SUBSCRIPTION_TYPES {
-  subscribe = 'subscribe',
-  unsubscribe = 'unsubscribe'
-}
-
-export const enum METHODS {
-  readyToConnect = 'connection.announcePresence',
-  updateAddress = 'address.update',
-  address = 'address.get',
-  connect = 'connection.open',
-  sign = 'transaction.sign',
-  signMessage = 'message.sign',
-  subscribeAddress = 'address.subscribe',
-  updateNetwork = 'networkId.update',
-  closeConnection = 'connection.close'
-}
-
-export const enum RPC_STATUS {
-  CONNECTED = 'CONNECTED',
-  NODE_BINDED = 'NODE_BINDED',
-  DISCONNECTED = 'DISCONNECTED',
-  CONNECTION_REJECTED = 'CONNECTION_REJECTED',
-  WAITING_FOR_CONNECTION_APPROVE = 'WAITING_FOR_CONNECTION_APPROVE',
-  WAITING_FOR_CONNECTION_REQUEST = 'WAITING_FOR_CONNECTION_REQUEST'
-}
-
-export const ERRORS = {
-  broadcastFailed: (error = {}) => ({
-    code: 3,
-    data: error,
-    message: 'Broadcast failed'
-  }),
-  invalidTransaction: (error = {}) => ({
-    code: 2,
-    data: error,
-    message: 'Invalid transaction'
-  }),
-  rejectedByUser: (error = {}) => ({
-    code: 4,
-    data: error,
-    message: 'Operation rejected by user'
-  }),
-  connectionDeny: (error = {}) => ({
-    code: 9,
-    data: error,
-    message: 'Wallet deny your connection request'
-  }),
-  permissionDeny: (address: string) => ({
-    code: 11,
-    message: `You are not subscribed for account ${address}`
-  }),
-  internalError: (message: string) => ({
-    code: 12,
-    message
-  }),
-  notAuthorize: () => ({
-    code: 10,
-    message: 'You are not connected to the wallet'
-  }),
-  unsupportedProtocol: () => ({
-    code: 5,
-    message: 'Unsupported Protocol Version'
-  }),
-  unsupportedNetwork: () => ({
-    code: 8,
-    message: 'Unsupported Network'
-  })
-}

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

@@ -1,92 +0,0 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
-/**
- * Wallet Detector
- *
- * This is the complement to {@link module:@aeternity/aepp-sdk/es/utils}.
- * @module @aeternity/aepp-sdk/es/utils/aepp-wallet-communication/wallet-detector
- * @export WalletDetector
- */
-import stampit from '@stamp/it'
-import BrowserWindowMessageConnection from './connection/browser-window-message'
-import { MESSAGE_DIRECTION, METHODS } from './schema'
-import { UnsupportedPlatformError } from '../errors'
-
-/**
- * WalletDetector stamp
- * @function
- * @alias module:@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/wallet-detector
- * @rtype Stamp
- * @param {Object} params={} - Initializer object
- * @param {WalletConnection} params.connection - Connection for listening for wallets
- * @return {WalletDetector}
- */
-export default stampit({
-  init ({ connection } = {}) {
-    if (!window) throw new UnsupportedPlatformError('Window object not found, you can run wallet detector only in browser')
-    this.connection = connection || BrowserWindowMessageConnection({ connectionInfo: { id: 'spy' } })
-    this.wallets = {}
-  },
-  methods: {
-    /**
-     * Start scanning
-     * @function scan
-     * @instance
-     * @param {Function} onDetected Call-back function which trigger on new wallet
-     * @return {void}
-     */
-    scan (onDetected) {
-      const { wallets } = this
-      this.connection.connect(({ method, params }, origin, source) => {
-        if (
-          !method || !params ||
-          method !== METHODS.readyToConnect || wallets[params.id]
-        ) return
-
-        const wallet = {
-          ...params,
-          async getConnection () {
-            // if detect extension wallet or page wallet
-            const isExtension = this.type === 'extension'
-            const origin = isExtension ? window.origin : this.origin
-            return BrowserWindowMessageConnection({
-              connectionInfo: this,
-              sendDirection: isExtension ? MESSAGE_DIRECTION.to_waellet : undefined,
-              receiveDirection: isExtension ? MESSAGE_DIRECTION.to_aepp : undefined,
-              target: source,
-              origin
-            })
-          }
-        }
-        wallets[wallet.id] = wallet
-        onDetected({ wallets, newWallet: wallet })
-      })
-      if (Object.keys(wallets).length) onDetected({ wallets })
-    },
-
-    /**
-    * Stop scanning
-    * @function stopScan
-    * @instance
-    * @return {void}
-    */
-    stopScan () {
-      this.connection.disconnect()
-    }
-  }
-})

package/src/utils/async-init.js

@@ -1,45 +0,0 @@
-/*
- * ISC License (ISC)
- * Copyright (c) 2022 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
-import stampit from '@stamp/it'
-
-function asyncInit (options = {}, { stamp, args, instance }) {
-  return stamp.compose.deepConfiguration.AsyncInit.initializers.reduce(async (instance, init) => {
-    instance = await Promise.resolve(instance)
-    if (typeof init === 'function') {
-      const ret = await Promise.resolve(init.call(instance, options, { stamp, args, instance }))
-      return ret === undefined ? instance : ret
-    }
-    return instance
-  }, instance)
-}
-
-export default stampit({
-  deepConf: { AsyncInit: { initializers: [] } },
-  composers ({ stamp, composables }) {
-    const conf = stamp.compose.deepConfiguration.AsyncInit
-    conf.initializers = composables
-      .map(c =>
-        c?.compose?.deepConfiguration?.AsyncInit?.initializers ||
-        (c.compose || c).initializers ||
-        [])
-      .flat(Infinity)
-      .filter((f, idx, arr) => !arr.slice(0, idx).includes(f))
-      .filter(f => f !== asyncInit)
-    stamp.compose.initializers = [asyncInit]
-  }
-})