@aeternity/aepp-sdk 9.0.1 → 11.0.0

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 })

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

@@ -3,16 +3,27 @@
  *
  * @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'
+ * @example
+ * import WalletRpc from '@aeternity/aepp-sdk/es/utils/aepp-wallet-communication/rpc/wallet-rpc'
  */
-import { v4 as uuid } from 'uuid'
+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, resolveOnAccount, sendResponseMessage } from '../helpers'
+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 }) =>
@@ -27,26 +38,36 @@ 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.aepp.connect] (callInstance, instance, client, { name, networkId, version, icons }) {
+  [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
+      version,
+      origin: window.location.origin,
+      connectNode
     })
 
     // Call onConnection callBack to notice Wallet about new AEPP
     return callInstance(
       'onConnection',
       { name, networkId, version },
-      () => {
-        client.updateInfo({ status: RPC_STATUS.CONNECTED })
-        return { result: instance.getWalletInfo() }
+      ({ 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 })
@@ -54,7 +75,7 @@ const REQUESTS = {
       }
     )
   },
-  [METHODS.aepp.subscribeAddress] (callInstance, instance, client, { type, value }) {
+  [METHODS.subscribeAddress] (callInstance, instance, client, { type, value }) {
     // Authorization check
     if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
 
@@ -64,7 +85,9 @@ const REQUESTS = {
       async ({ accounts } = {}) => {
         try {
           const clientAccounts = accounts || instance.getAccounts()
-          if (!isValidAccounts(clientAccounts)) throw new Error('Invalid provided accounts object')
+          if (!isValidAccounts(clientAccounts)) {
+            throw new TypeError('Invalid provided accounts object')
+          }
           const subscription = client.updateSubscription(type, value)
           client.setAccounts(clientAccounts, { forceNotification: true })
           return {
@@ -74,14 +97,14 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
-          return { error: ERRORS.internalError({ msg: e.message }) }
+          if (instance.debug) console.error(e)
+          return { error: ERRORS.internalError(e.message) }
         }
       },
       (error) => ({ error: ERRORS.rejectedByUser(error) })
     )
   },
-  [METHODS.aepp.address] (callInstance, instance, client) {
+  [METHODS.address] (callInstance, instance, client) {
     // Authorization check
     if (!client.isConnected()) return { error: ERRORS.notAuthorize() }
     if (!client.isSubscribed()) return { error: ERRORS.notAuthorize() }
@@ -89,20 +112,28 @@ const REQUESTS = {
     return callInstance(
       'onAskAccounts',
       {},
-      ({ accounts } = {}) => ({ result: accounts || [...Object.keys(client.accounts.current), ...Object.keys(client.accounts.connected)] }),
+      ({ accounts } = {}) => ({
+        result: accounts ||
+          [...Object.keys(client.accounts.current), ...Object.keys(client.accounts.connected)]
+      }),
       (error) => ({ error: ERRORS.rejectedByUser(error) })
     )
   },
-  [METHODS.aepp.sign] (callInstance, instance, client, { tx, onAccount, networkId, returnSigned = false }) {
+  [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({ account: address }) }
+    if (!client.hasAccessToAccount(address)) {
+      return { error: ERRORS.permissionDeny(address) }
+    }
     // NetworkId check
-    if (!networkId || networkId !== instance.getNetworkId()) return { error: ERRORS.unsupportedNetwork() }
+    if (!networkId || networkId !== instance.getNetworkId()) {
+      return { error: ERRORS.unsupportedNetwork() }
+    }
 
     return callInstance(
       'onSign',
@@ -112,15 +143,15 @@ const REQUESTS = {
         try {
           onAcc = resolveOnAccount(instance.addresses(), address, opt)
         } catch (e) {
-          console.error(e)
-          return { error: ERRORS.internalError({ msg: e.message }) }
+          if (instance.debug) console.error(e)
+          return { error: ERRORS.internalError(e.message) }
         }
         try {
-          return {
-            result: returnSigned
-              ? { signedTransaction: await instance.signTransaction(rawTx || tx, { onAccount: onAcc }) }
-              : { transactionHash: await instance.send(rawTx || tx, { onAccount: onAcc, verify: false }) }
-          }
+          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
@@ -135,11 +166,13 @@ const REQUESTS = {
       (error) => ({ error: ERRORS.rejectedByUser(error) })
     )
   },
-  [METHODS.aepp.signMessage] (callInstance, instance, client, { message, onAccount }) {
+  [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({ account: address }) }
+    if (!client.hasAccessToAccount(address)) {
+      return { error: ERRORS.permissionDeny(address) }
+    }
 
     return callInstance(
       'onMessageSign',
@@ -156,8 +189,8 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
-          return { error: ERRORS.internalError({ msg: e.message }) }
+          if (instance.debug) console.error(e)
+          return { error: ERRORS.internalError(e.message) }
         }
       },
       (error) => ({ error: ERRORS.rejectedByUser(error) })
@@ -168,7 +201,9 @@ const REQUESTS = {
 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)
+    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)
@@ -188,7 +223,9 @@ const handleMessage = (instance, id) => async (msg, origin) => {
       )
     })
     // TODO make one structure for handler functions
-    const errorObjectOrHandler = getHandler(REQUESTS, msg, { debug: instance.debug })(callInstance, instance, client, msg.params)
+    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)
   }
@@ -201,31 +238,31 @@ const handleMessage = (instance, id) => async (msg, origin) => {
  * @rtype Stamp
  * @param {Object} param Init params object
  * @param {String=} [param.name] Wallet name
- * @param {Function} onConnection Call-back function for incoming AEPP connection (Second argument contain function for accept/deny request)
- * @param {Function} onSubscription Call-back function for incoming AEPP account subscription (Second argument contain function for accept/deny request)
- * @param {Function} onSign Call-back function for incoming AEPP sign request (Second argument contain function for accept/deny request)
- * @param {Function} onAskAccounts Call-back function for incoming AEPP get address request (Second argument contain function for accept/deny request)
- * @param {Function} onMessageSign Call-back function for incoming AEPP sign message request (Second argument contain function for accept/deny request)
+ * @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, onConnection, onSubscription, onSign, onDisconnect, onAskAccounts, onMessageSign, forceValidation = false, debug = false } = {}) {
+  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
-    const eventsHandlers = ['onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onMessageSign']
-    // CallBacks for events
-    this.onConnection = onConnection
-    this.onSubscription = onSubscription
-    this.onSign = onSign
-    this.onDisconnect = onDisconnect
-    this.onAskAccounts = onAskAccounts
-    this.onMessageSign = onMessageSign
     this.rpcClients = {}
-
-    eventsHandlers.forEach(event => {
-      if (!forceValidation && typeof this[event] !== 'function') throw new Error(`Call-back for ${event} must be an function!`)
-    })
-    //
     this.name = name
     this.id = uuid()
 
@@ -268,9 +305,13 @@ export default Ae.compose(AccountMultiple, {
       // 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() }), true
-        ))
+        .forEach(client => {
+          client.sendMessage(
+            message(METHODS.updateNetwork, {
+              networkId: this.getNetworkId(),
+              ...(client.info.status === RPC_STATUS.NODE_BINDED && { node: this.selectedNode })
+            }), true)
+        })
     }
   },
   methods: {
@@ -285,7 +326,7 @@ export default Ae.compose(AccountMultiple, {
      */
     removeRpcClient (id, { forceConnectionClose = false } = {}) {
       const client = this.rpcClients[id]
-      if (!client) throw new Error(`RpcClient with id ${id} do not exist`)
+      if (!client) throw new UnknownRpcClientError(id)
       client.disconnect(forceConnectionClose)
       delete this.rpcClients[id]
     },
@@ -298,7 +339,8 @@ export default Ae.compose(AccountMultiple, {
      * @return {String} Client ID
      */
     addRpcClient (clientConnection) {
-      // @TODO  detect if aepp has some history based on origin????: if yes use this instance for connection
+      // @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,
@@ -320,7 +362,7 @@ export default Ae.compose(AccountMultiple, {
     shareWalletInfo (postFn) {
       postFn({
         jsonrpc: '2.0',
-        ...message(METHODS.wallet.readyToConnect, this.getWalletInfo())
+        ...message(METHODS.readyToConnect, this.getWalletInfo())
       })
     },
     /**

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

@@ -0,0 +1,80 @@
+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

@@ -25,6 +25,7 @@
 import stampit from '@stamp/it'
 import BrowserWindowMessageConnection from './connection/browser-window-message'
 import { MESSAGE_DIRECTION, METHODS } from './schema'
+import { UnsupportedPlatformError } from '../errors'
 
 /**
  * WalletDetector stamp
@@ -37,7 +38,7 @@ import { MESSAGE_DIRECTION, METHODS } from './schema'
  */
 export default stampit({
   init ({ connection } = {}) {
-    if (!window) throw new Error('Window object not found, you can run wallet detector only in browser')
+    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 = {}
   },
@@ -52,7 +53,10 @@ export default stampit({
     scan (onDetected) {
       const { wallets } = this
       this.connection.connect(({ method, params }, origin, source) => {
-        if (!method || !params || method !== METHODS.wallet.readyToConnect || wallets[params.id]) return
+        if (
+          !method || !params ||
+          method !== METHODS.readyToConnect || wallets[params.id]
+        ) return
 
         const wallet = {
           ...params,

package/src/utils/amount-formatter.ts

@@ -22,6 +22,7 @@
  */
 import BigNumber from 'bignumber.js'
 import { isBigNumber } from './bignumber'
+import { ArgumentError, InvalidDenominationError } from './errors'
 
 /**
  * AE amount formats
@@ -86,9 +87,9 @@ export const formatAmount = (
   { denomination = AE_AMOUNT_FORMATS.AETTOS, targetDenomination = AE_AMOUNT_FORMATS.AETTOS } = {}
 ): string => {
   const denominations = Object.values(AE_AMOUNT_FORMATS)
-  if (!denominations.includes(denomination)) throw new Error(`Invalid denomination: ${denomination}`)
-  if (!denominations.includes(targetDenomination)) throw new Error(`Invalid target denomination: ${targetDenomination}`)
-  if (!isBigNumber(value)) throw new Error(`Value ${value?.toString()} is not type of number`)
+  if (!denominations.includes(denomination)) throw new InvalidDenominationError(`Invalid denomination: ${denomination}`)
+  if (!denominations.includes(targetDenomination)) throw new InvalidDenominationError(`Invalid target denomination: ${targetDenomination}`)
+  if (!isBigNumber(value)) throw new ArgumentError('value', `a number`, value)
 
   return new BigNumber(value)
     .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])

package/src/utils/async-init.js

@@ -1,6 +1,6 @@
 /*
  * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
+ * 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
@@ -16,7 +16,6 @@
  */
 
 import stampit from '@stamp/it'
-import * as R from 'ramda'
 
 function asyncInit (options = {}, { stamp, args, instance }) {
   return stamp.compose.deepConfiguration.AsyncInit.initializers.reduce(async (instance, init) => {
@@ -29,13 +28,18 @@ function asyncInit (options = {}, { stamp, args, instance }) {
   }, instance)
 }
 
-const AsyncInit = stampit({
+export default stampit({
   deepConf: { AsyncInit: { initializers: [] } },
   composers ({ stamp, composables }) {
     const conf = stamp.compose.deepConfiguration.AsyncInit
-    conf.initializers = R.without([asyncInit], R.uniqWith(R.identical, R.flatten(composables.map(c => R.path(['compose', 'deepConfiguration', 'AsyncInit', 'initializers'], c) || (c.compose || c).initializers || []))))
+    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]
   }
 })
-
-export default AsyncInit

package/src/utils/bignumber.ts

@@ -1,25 +1,18 @@
 /**
  * Big Number Helpers
  * @module @aeternity/aepp-sdk/es/utils/bignumber
- * @example import { parseBigNumber, isBigNumber, ceil } from '@aeternity/aepp-sdk/es/utils/bignumber'
+ * @example import { isBigNumber, ceil } from '@aeternity/aepp-sdk/es/utils/bignumber'
  */
 import BigNumber from 'bignumber.js'
 
-/**
- * Convert number to string
- * @param {String|Number|BigNumber} number number to convert
- * @return {String}
- */
-export const parseBigNumber = (number: string | number | BigNumber): string =>
-  new BigNumber(number.toString()).toString(10)
-
 /**
  * Check if value is BigNumber, Number or number string representation
  * @param {String|Number|BigNumber} number number to convert
  * @return {Boolean}
  */
 export const isBigNumber = (number: string | number | BigNumber): boolean =>
-  !isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number)
+  ['number', 'object', 'string', 'bigint'].includes(typeof number) &&
+  (!isNaN(number as number) || Number.isInteger(number) || BigNumber.isBigNumber(number))
 
 /**
  * BigNumber ceil operation

package/src/utils/bytes.ts

@@ -15,6 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 import BigNumber from 'bignumber.js'
+import { NoSerializerFoundError, TypeError } from './errors'
 import { isBase64, isHex } from './string'
 
 /**
@@ -29,7 +30,7 @@ import { isBase64, isHex } from './string'
  * @return Buffer
  */
 export function bigNumberToByteArray (x: BigNumber): Buffer {
-  if (!x.isInteger()) throw new Error(`Unexpected not integer value: ${x.toFixed()}`)
+  if (!x.isInteger()) throw new TypeError(`Unexpected not integer value: ${x.toFixed()}`)
   let hexString = x.toString(16)
   if (hexString.length % 2 === 1) hexString = '0' + hexString
   return Buffer.from(hexString, 'hex')
@@ -54,7 +55,7 @@ export function toBytes (val?: null | string | number | BigNumber, big: boolean
   if (typeof val === 'string') {
     return Buffer.from(val)
   }
-  throw new Error('Byte serialization not supported')
+  throw new NoSerializerFoundError()
 }
 
 /**

package/src/utils/crypto-ts.ts

@@ -15,7 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { blake2b } from 'blakejs'
+import { blake2b } from '@aeternity/blakejs'
 import type { Data } from 'blakejs'
 
 /**
@@ -25,5 +25,5 @@ import type { Data } from 'blakejs'
  * @return {Buffer} Hash
  */
 export function hash (input: Data): Buffer {
-  return Buffer.from(blake2b(input, null, 32)) // 256 bits
+  return Buffer.from(blake2b(input, undefined, 32)) // 256 bits
 }