@aeternity/aepp-sdk 8.2.1 → 10.0.0

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

@@ -3,10 +3,12 @@
  *
  * @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 Ae from '../../../ae'
+import verifyTransaction from '../../../tx/validator'
 import AccountMultiple from '../../../account/multiple'
 import TxObject from '../../../tx/tx-object'
 import RpcClient from './rpc-client'
@@ -73,7 +75,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },
@@ -88,20 +90,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.aepp.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({ account: address }) }
+    }
     // NetworkId check
-    if (!networkId || networkId !== instance.getNetworkId()) return { error: ERRORS.unsupportedNetwork() }
+    if (!networkId || networkId !== instance.getNetworkId()) {
+      return { error: ERRORS.unsupportedNetwork() }
+    }
 
     return callInstance(
       'onSign',
@@ -111,22 +121,20 @@ const REQUESTS = {
         try {
           onAcc = resolveOnAccount(instance.addresses(), address, opt)
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: 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
-            const validationResult = await instance.unpackAndVerify(rawTx || tx)
-            if (validationResult.validation.length) return { error: ERRORS.invalidTransaction(validationResult) }
+            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) }
           }
@@ -140,7 +148,9 @@ const REQUESTS = {
     // 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({ account: address }) }
+    }
 
     return callInstance(
       'onMessageSign',
@@ -157,7 +167,7 @@ const REQUESTS = {
             }
           }
         } catch (e) {
-          console.error(e)
+          if (instance.debug) console.error(e)
           return { error: ERRORS.internalError({ msg: e.message }) }
         }
       },
@@ -169,7 +179,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)
@@ -189,7 +201,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)
   }
@@ -202,18 +216,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,
+    onConnection,
+    onSubscription,
+    onSign,
+    onDisconnect,
+    onAskAccounts,
+    onMessageSign,
+    forceValidation = false,
+    debug = false
+  } = {}) {
     this.debug = debug
-    const eventsHandlers = ['onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onMessageSign']
+    const eventsHandlers = [
+      'onConnection', 'onSubscription', 'onSign', 'onDisconnect', 'onMessageSign'
+    ]
     // CallBacks for events
     this.onConnection = onConnection
     this.onSubscription = onSubscription
@@ -224,7 +251,9 @@ export default Ae.compose(AccountMultiple, {
     this.rpcClients = {}
 
     eventsHandlers.forEach(event => {
-      if (!forceValidation && typeof this[event] !== 'function') throw new Error(`Call-back for ${event} must be an function!`)
+      if (!forceValidation && typeof this[event] !== 'function') {
+        throw new Error(`Call-back for ${event} must be an function!`)
+      }
     })
     //
     this.name = name
@@ -299,7 +328,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,

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

@@ -1,6 +1,4 @@
-import * as R from 'ramda'
-
-const asEnum = (array) => R.zipObj(array, array)
+const asEnum = (array) => Object.fromEntries(array.map(a => [a, a]))
 
 export const VERSION = 1
 

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

@@ -52,7 +52,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.wallet.readyToConnect || wallets[params.id]
+        ) return
 
         const wallet = {
           ...params,

package/src/utils/amount-formatter.ts

@@ -88,7 +88,7 @@ export const formatAmount = (
   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 (!isBigNumber(value)) throw new Error(`Value ${value?.toString()} is not type of number`)
 
   return new BigNumber(value)
     .shiftedBy(DENOMINATION_MAGNITUDE[denomination] - DENOMINATION_MAGNITUDE[targetDenomination])

package/src/utils/bignumber.ts

@@ -19,7 +19,8 @@ export const parseBigNumber = (number: string | number | BigNumber): string =>
  * @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/crypto.js

@@ -22,12 +22,12 @@
  */
 
 import bs58check from 'bs58check'
-import ed2curve from 'ed2curve'
 import nacl from 'tweetnacl'
 import aesjs from 'aes-js'
 import shajs from 'sha.js'
 
 import { str2buf, toBytes } from './bytes'
+import { decode } from '../tx/builder/helpers'
 import { hash } from './crypto-ts'
 
 export * from './crypto-ts'
@@ -56,7 +56,7 @@ export function getAddressFromPriv (secret) {
 export function isAddressValid (address, prefix = 'ak') {
   if (typeof address !== 'string') return false
   try {
-    return decodeBase58Check(assertedType(address, prefix)).length === 32
+    return decode(address, prefix).length === 32
   } catch (e) {
     return false
   }
@@ -173,7 +173,7 @@ export function encodeUnsigned (value) {
  * @return {String} - Contract address
  */
 export function encodeContractAddress (owner, nonce) {
-  const publicKey = decodeBase58Check(assertedType(owner, 'ak'))
+  const publicKey = decode(owner, 'ak')
   const binary = Buffer.concat([publicKey, encodeUnsigned(nonce)])
   return `ct_${encodeBase58Check(hash(binary))}`
 }
@@ -192,7 +192,7 @@ export function generateKeyPairFromSecret (secret) {
 
 /**
  * Generate a random ED25519 keypair
- * @rtype (raw: Boolean) => {publicKey: String, secretKey: String} | {publicKey: Buffer, secretKey: Buffer}
+ * @rtype (raw: Boolean) => {publicKey: String | Buffer, secretKey: String | Buffer}
  * @param {Boolean} raw - Whether to return raw (binary) keys
  * @return {Object} Key pair
  */
@@ -296,20 +296,6 @@ export function aeEncodeKey (binaryKey) {
   return `ak_${pubKeyAddress}`
 }
 
-/**
- * Assert encoded type and return its payload
- * @rtype (data: String, type: String) => String, throws: Error
- * @param {String} data - ae data
- * @param {String} type - Prefix
- * @param {Boolean} omitError - Return false instead of throwing the error if data doesn't match expected type
- * @return {String|Boolean} Payload
- */
-export function assertedType (data, type, omitError) {
-  if (RegExp(`^${type}_.+$`).test(data)) return data.split('_')[1]
-  else if (omitError) return false
-  else throw new Error(`Data doesn't match expected type ${type}`)
-}
-
 /**
  * Check key pair for validity
  *
@@ -324,53 +310,3 @@ export function isValidKeypair (privateKey, publicKey) {
   const signature = sign(message, privateKey)
   return verify(message, signature, publicKey)
 }
-
-/**
- * This function encrypts a message using base58check encoded and 'ak' prefixed
- * publicKey such that only the corresponding secretKey will
- * be able to decrypt
- * @rtype (msg: String, publicKey: String) => Object
- * @param {Buffer} msg - Data to encode
- * @param {String} publicKey - Public key
- * @return {Object}
- */
-export function encryptData (msg, publicKey) {
-  const ephemeralKeyPair = nacl.box.keyPair()
-  const pubKeyUInt8Array = decodeBase58Check(assertedType(publicKey, 'ak'))
-  const nonce = nacl.randomBytes(nacl.box.nonceLength)
-
-  const encryptedMessage = nacl.box(
-    Buffer.from(msg),
-    nonce,
-    ed2curve.convertPublicKey(pubKeyUInt8Array),
-    ephemeralKeyPair.secretKey
-  )
-
-  return {
-    ciphertext: Buffer.from(encryptedMessage).toString('hex'),
-    ephemPubKey: Buffer.from(ephemeralKeyPair.publicKey).toString('hex'),
-    nonce: Buffer.from(nonce).toString('hex'),
-    version: 'x25519-xsalsa20-poly1305'
-  }
-}
-
-/**
- * This function decrypt a message using secret key
- * @rtype (secretKey: String, encryptedData: Object) => Buffer|null
- * @param {String} secretKey - Secret key
- * @param {Object} encryptedData - Encrypted data
- * @return {Buffer|null}
- */
-export function decryptData (secretKey, encryptedData) {
-  const receiverSecretKeyUint8Array = ed2curve.convertSecretKey(Buffer.from(secretKey, 'hex'))
-  const nonce = Buffer.from(encryptedData.nonce, 'hex')
-  const ciphertext = Buffer.from(encryptedData.ciphertext, 'hex')
-  const ephemPubKey = Buffer.from(encryptedData.ephemPubKey, 'hex')
-  const decrypted = nacl.box.open(
-    ciphertext,
-    nonce,
-    ephemPubKey,
-    receiverSecretKeyUint8Array
-  )
-  return decrypted ? Buffer.from(decrypted) : decrypted
-}

package/src/utils/keystore.js

@@ -189,7 +189,14 @@ export async function recover (password, keyObject) {
  * @param {Object=} options.kdfparams KDF parameters (default: constants.<kdf>).
  * @return {Object}
  */
-export async function dump (name, password, privateKey, nonce = nacl.randomBytes(24), salt = nacl.randomBytes(16), options = {}) {
+export async function dump (
+  name,
+  password,
+  privateKey,
+  nonce = nacl.randomBytes(24),
+  salt = nacl.randomBytes(16),
+  options = {}
+) {
   const opt = Object.assign({}, DEFAULTS.crypto, options)
   return marshal(
     name,
@@ -208,7 +215,8 @@ export function validateKeyObj (obj) {
   const missingRootKeys = root.filter(key => !Object.prototype.hasOwnProperty.call(obj, key))
   if (missingRootKeys.length) throw new Error(`Invalid key file format. Require properties: ${missingRootKeys}`)
 
-  const missingCryptoKeys = cryptoKeys.filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))
+  const missingCryptoKeys = cryptoKeys
+    .filter(key => !Object.prototype.hasOwnProperty.call(obj.crypto, key))
   if (missingCryptoKeys.length) throw new Error(`Invalid key file format. Require properties: ${missingCryptoKeys}`)
 
   return true

package/src/utils/other.ts

@@ -1,6 +1,6 @@
 import { snakeToPascal, pascalToSnake } from './string'
 
-export const pause = async (duration: number): Promise<undefined> =>
+export const pause = async (duration: number): Promise<void> =>
   await new Promise(resolve => setTimeout(resolve, duration))
 
 export const mapObject = (

package/src/utils/semver-satisfies.ts

@@ -1,6 +1,6 @@
 export default function (version: string, geVersion: string, ltVersion: string): boolean {
   const getComponents = (v: string): number[] => v
-    .split('-')[0].split('.').map(i => +i)
+    .split(/[-+]/)[0].split('.').map(i => +i)
 
   const versionComponents = getComponents(version)
   const geComponents = getComponents(geVersion)

package/src/utils/swagger.js

@@ -39,15 +39,24 @@ let warnedAboutInternalApiUsage = false
  * @param {String} [options.internalUrl] - Node internal URL
  * @param {Boolean} [options.disableBigNumbers]
  * @param {Boolean} [options.disableCaseConversion]
+ * @param {Function} [options.responseInterceptor]
  * @return {Object} Swagger client
  * @example (await genSwaggerClient('https://mainnet.aeternity.io/api')).getAccountByPubkey('ak_jupBUgZNbcC4krDLR3tAkw1iBZoBbkNeShAq4atBtpFWmz36r')
  */
-export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCaseConversion } = {}) => {
+export default async (
+  specUrl,
+  { spec, internalUrl, disableBigNumbers, disableCaseConversion, responseInterceptor } = {}
+) => {
   spec = spec || await (await fetch(specUrl)).json()
   const jsonImp = disableBigNumbers ? JSON : JsonBig
 
-  if (['https://compiler.aepps.com', 'https://latest.compiler.aepps.com']
-    .includes(new URL(specUrl).origin)) {
+  if (
+    [
+      'https://compiler.aepps.com',
+      'https://latest.compiler.aepps.com'
+    ].includes(new URL(specUrl).origin) ||
+    new URL(specUrl).origin.includes('https://')
+  ) {
     spec.schemes = ['https']
   }
 
@@ -57,11 +66,12 @@ export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCa
       url,
       spec,
       responseInterceptor: response => {
-        if (!response.text) return response
+        if (response.text === '' || response.text?.size === 0) return response
         const body = jsonImp.parse(response.text)
-        return Object.assign(response, {
+        Object.assign(response, {
           body: disableCaseConversion ? body : pascalizeKeys(body)
         })
+        return (responseInterceptor && responseInterceptor(response)) || response
       }
     })
   }))
@@ -92,11 +102,13 @@ export default async (specUrl, { spec, internalUrl, disableBigNumbers, disableCa
       const opSpec = opSpecs[opId]
       const parameters = [
         ...opSpec.parameters,
-        ...opSpec.requestBody ? [{
-          required: opSpec.requestBody.required,
-          schema: Object.values(opSpec.requestBody.content)[0].schema,
-          name: '__requestBody'
-        }] : []
+        ...opSpec.requestBody
+          ? [{
+              required: opSpec.requestBody.required,
+              schema: Object.values(opSpec.requestBody.content)[0].schema,
+              name: '__requestBody'
+            }]
+          : []
       ]
       const required = parameters.filter(param => param.required).map(p => p.name)
       if (args.length < required.length) throw new Error('swagger: Not enough arguments')

package/src/contract/aci/helpers.js

@@ -1,140 +0,0 @@
-import * as R from 'ramda'
-import { unpackTx } from '../../tx/builder'
-import { decodeEvents as unpackEvents, transform, transformDecodedData, validateArguments } from './transformation'
-
-/**
- * Get function schema from contract ACI object
- * @param {Object} aci Contract ACI object
- * @param {String} name Function name
- * @param external
- * @return {Object} function ACI
- */
-export function getFunctionACI (aci, name, { external }) {
-  if (!aci) throw new Error('ACI required')
-  const fn = aci.functions.find(f => f.name === name)
-  if (!fn && name !== 'init') throw new Error(`Function ${name} doesn't exist in contract`)
-
-  return {
-    ...fn,
-    bindings: [
-      {
-        state: aci.state,
-        type_defs: aci.type_defs,
-        name: aci.name
-      },
-      ...external.map(R.pick(['state', 'type_defs', 'name']))
-    ],
-    event: aci.event ? aci.event.variant : []
-  }
-}
-
-/**
- * Build contract methods base on ACI
- * @return {Object} Contract instance methods
- */
-export const buildContractMethods = (instance) => () => ({
-  ...instance.aci
-    ? instance
-      .aci
-      .functions
-      .reduce(
-        (acc, { name, arguments: aciArgs, stateful }) => ({
-          ...acc,
-          [name]: Object.assign(
-            function () {
-              const { opt, args } = parseArguments(aciArgs)(arguments)
-              if (name === 'init') return instance.deploy(args, opt)
-              return instance.call(name, args, { callStatic: !stateful, ...opt })
-            },
-            {
-              get () {
-                const { opt, args } = parseArguments(aciArgs)(arguments)
-                return instance.call(name, args, { ...opt, callStatic: true })
-              },
-              send () {
-                const { opt, args } = parseArguments(aciArgs)(arguments)
-                if (name === 'init') return instance.deploy(args, opt)
-                return instance.call(name, args, { ...opt, callStatic: false })
-              },
-              decodeEvents (events) {
-                return instance.decodeEvents(name, events)
-              }
-            }
-          )
-        }),
-        {}
-      )
-    : {},
-  ...instance.aci ? {
-    init: Object.assign(
-      function () {
-        const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-        const { opt, args } = parseArguments(aciArgs)(arguments)
-        return instance.deploy(args, opt)
-      },
-      {
-        get () {
-          const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-          const { opt, args } = parseArguments(aciArgs)(arguments)
-          return instance.deploy(args, { ...opt, callStatic: true })
-        },
-        send () {
-          const { arguments: aciArgs } = getFunctionACI(instance.aci, 'init', { external: instance.externalAci })
-          const { opt, args } = parseArguments(aciArgs)(arguments)
-          return instance.deploy(args, { ...opt, callStatic: false })
-        }
-      }
-    )
-  } : {}
-})
-
-export const parseArguments = (aciArgs = []) => (args) => ({
-  opt: args.length > aciArgs.length ? R.last(args) : {},
-  args: Object.values(args).slice(0, aciArgs.length)
-})
-
-export const unpackByteCode = (bytecode) => unpackTx(bytecode, false, 'cb').tx
-
-/**
- * Validated contract call arguments using contract ACI
- * @function validateCallParams
- * @rtype (aci: Object, params: Array) => Object
- * @param {Object} aci Contract ACI
- * @param {Array} params Contract call arguments
- * @return Promise{Array} Object with validation errors
- */
-export const prepareArgsForEncode = async (aci, params) => {
-  if (!aci || !aci.arguments) return params
-  // Validation
-  if (aci.arguments.length > params.length) {
-    throw new Error(`Function "${aci.name}" require ${aci.arguments.length} arguments of types [${aci.arguments.map(a => JSON.stringify(a.type))}] but get [${params.map(JSON.stringify)}]`)
-  }
-
-  validateArguments(aci, params)
-  const bindings = aci.bindings
-  // Cast argument from JS to Sophia type
-  return Promise.all(aci.arguments.map(async ({ type }, i) => transform(type, params[i], {
-    bindings
-  })))
-}
-
-export const decodeEvents = (events, fnACI) => {
-  if (!fnACI || !fnACI.event || !fnACI.event.length) return []
-
-  const eventsSchema = fnACI.event.map(e => {
-    const name = Object.keys(e)[0]
-    return { name, types: e[name] }
-  })
-  return unpackEvents(events, { schema: eventsSchema })
-}
-
-export const decodeCallResult = async (result, fnACI, opt) => {
-  return {
-    decodedResult: await transformDecodedData(
-      fnACI.returns,
-      await result.decode(),
-      { ...opt, bindings: fnACI.bindings }
-    ),
-    decodedEvents: decodeEvents(result.result.log, fnACI)
-  }
-}