@aeternity/aepp-sdk 10.0.0 → 11.0.0

package/src/channel/handlers.js

@@ -15,7 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { generateKeyPair, encodeContractAddress, encodeBase64Check } from '../utils/crypto'
+import { generateKeyPair, encodeContractAddress } from '../utils/crypto'
 import {
   options,
   changeStatus,
@@ -28,20 +28,23 @@ import {
   fsmId
 } from './internal'
 import { unpackTx, buildTx } from '../tx/builder'
-
-function encodeRlpTx (rlpBinary) {
-  return `tx_${encodeBase64Check(rlpBinary)}`
-}
+import { encode } from '../tx/builder/helpers'
+import {
+  IllegalArgumentError,
+  InsufficientBalanceError,
+  ChannelConnectionError,
+  UnexpectedChannelMessageError
+} from '../utils/errors'
 
 async function appendSignature (tx, signFn) {
   const { signatures, encodedTx } = unpackTx(tx).tx
-  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded))
+  const result = await signFn(encode(encodedTx.rlpEncoded, 'tx'))
   if (typeof result === 'string') {
     const { tx: signedTx, txType } = unpackTx(result)
-    return encodeRlpTx(buildTx({
+    return buildTx({
       signatures: signatures.concat(signedTx.signatures),
       encodedTx: signedTx.encodedTx.rlpEncoded
-    }, txType).rlpEncoded)
+    }, txType).tx
   }
   return result
 }
@@ -49,7 +52,7 @@ async function appendSignature (tx, signFn) {
 function handleUnexpectedMessage (channel, message, state) {
   if (state && state.reject) {
     state.reject(Object.assign(
-      new Error(`Unexpected message received:\n\n${JSON.stringify(message)}`),
+      new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`),
       { wsMessage: message }
     ))
   }
@@ -75,7 +78,7 @@ export function awaitingConnection (channel, message, state) {
     return { handler: awaitingConnection }
   }
   if (message.method === 'channels.error') {
-    emit(channel, 'error', new Error(message.payload.message))
+    emit(channel, 'error', new ChannelConnectionError(message.payload.message))
     return { handler: channelClosed }
   }
 }
@@ -251,17 +254,17 @@ export async function awaitingOffChainTx (channel, message, state) {
     }
   }
   if (message.method === 'channels.error') {
-    state.reject(new Error(message.data.message))
+    state.reject(new ChannelConnectionError(message.data.message))
     return { handler: channelOpen }
   }
   if (message.error) {
     const { data = [] } = message.error
     if (data.find(i => i.code === 1001)) {
-      state.reject(new Error('Insufficient balance'))
+      state.reject(new InsufficientBalanceError('Insufficient balance'))
     } else if (data.find(i => i.code === 1002)) {
-      state.reject(new Error('Amount cannot be negative'))
+      state.reject(new IllegalArgumentError('Amount cannot be negative'))
     } else {
-      state.reject(new Error(message.error.message))
+      state.reject(new ChannelConnectionError(message.error.message))
     }
     return { handler: channelOpen }
   }
@@ -303,7 +306,7 @@ export function awaitingOffChainUpdate (channel, message, state) {
     }
   }
   if (message.error) {
-    state.reject(new Error(message.error.message))
+    state.reject(new ChannelConnectionError(message.error.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -387,7 +390,7 @@ export function awaitingLeave (channel, message, state) {
     return { handler: channelClosed }
   }
   if (message.method === 'channels.error') {
-    state.reject(new Error(message.data.message))
+    state.reject(new ChannelConnectionError(message.data.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -651,7 +654,7 @@ export function awaitingCallsPruned (channels, message, state) {
     state.resolve()
     return { handler: channelOpen }
   }
-  state.reject(new Error('Unexpected message received'))
+  state.reject(new UnexpectedChannelMessageError('Unexpected message received'))
   return { handler: channelClosed }
 }
 

package/src/channel/internal.js

@@ -20,6 +20,7 @@ import { EventEmitter } from 'events'
 import JsonBig from '../utils/json-big'
 import { pascalToSnake } from '../utils/string'
 import { awaitingConnection, awaitingReconnection, channelOpen } from './handlers'
+import { ChannelCallError, ChannelPingTimedOutError, UnknownChannelStateError } from '../utils/errors'
 
 // Send ping message every 10 seconds
 const PING_TIMEOUT_MS = 10000
@@ -49,7 +50,7 @@ export function emit (channel, ...args) {
 
 function enterState (channel, nextState) {
   if (!nextState) {
-    throw new Error('State Channels FSM entered unknown state')
+    throw new UnknownChannelStateError()
   }
   fsm.set(channel, nextState)
   if (nextState.handler.enter) {
@@ -109,16 +110,21 @@ async function handleMessage (channel, message) {
 }
 
 async function dequeueMessage (channel) {
-  const queue = messageQueue.get(channel)
-  if (messageQueueLocked.get(channel) || !queue.length) {
-    return
-  }
-  const [message, ...remaining] = queue
-  messageQueue.set(channel, remaining || [])
+  if (messageQueueLocked.get(channel)) return
+  const messages = messageQueue.get(channel)
+  if (!messages.length) return
   messageQueueLocked.set(channel, true)
-  await handleMessage(channel, message)
+  while (messages.length) {
+    const message = messages.shift()
+    try {
+      await handleMessage(channel, message)
+    } catch (error) {
+      console.error('Error handling incoming message:')
+      console.error(message)
+      console.error(error)
+    }
+  }
   messageQueueLocked.set(channel, false)
-  dequeueMessage(channel)
 }
 
 function ping (channel) {
@@ -134,7 +140,7 @@ function ping (channel) {
     })
     pongTimeoutId.set(channel, setTimeout(() => {
       disconnect(channel)
-      emit(channel, 'error', new Error('Server pong timed out'))
+      emit(channel, 'error', new ChannelPingTimedOutError())
     }, PONG_TIMEOUT_MS))
   }, PING_TIMEOUT_MS))
 }
@@ -150,9 +156,13 @@ function onMessage (channel, data) {
     } finally {
       rpcCallbacks.get(channel).delete(message.id)
     }
-  } else if (message.method === 'channels.message') {
+    return
+  }
+  if (message.method === 'channels.message') {
     emit(channel, 'message', message.params.data.message)
-  } else if (message.method === 'channels.system.pong') {
+    return
+  }
+  if (message.method === 'channels.system.pong') {
     if (
       (message.params.channel_id === channelId.get(channel)) ||
       // Skip channelId check if channelId is not known yet
@@ -160,18 +170,10 @@ function onMessage (channel, data) {
     ) {
       ping(channel)
     }
-  } else {
-    messageQueue.set(channel, [...(messageQueue.get(channel) || []), message])
-    dequeueMessage(channel)
-  }
-}
-
-function wrapCallErrorMessage (message) {
-  const [{ message: details } = {}] = message.error.data || []
-  if (details) {
-    return new Error(`${message.error.message}: ${details}`)
+    return
   }
-  return new Error(message.error.message)
+  messageQueue.get(channel).push(message)
+  dequeueMessage(channel)
 }
 
 export function call (channel, method, params) {
@@ -179,7 +181,10 @@ export function call (channel, method, params) {
     const id = sequence.set(channel, sequence.get(channel) + 1).get(channel)
     rpcCallbacks.get(channel).set(id, (message) => {
       if (message.result) return resolve(message.result)
-      if (message.error) return reject(wrapCallErrorMessage(message))
+      if (message.error) {
+        const [{ message: details } = {}] = message.error.data || []
+        return reject(new ChannelCallError(message.error.message + (details ? `: ${details}` : '')))
+      }
     })
     send(channel, { jsonrpc: '2.0', method, id, params })
   })
@@ -199,6 +204,7 @@ export async function initialize (channel, { url, ...channelOptions }) {
   eventEmitters.set(channel, new EventEmitter())
   sequence.set(channel, 0)
   rpcCallbacks.set(channel, new Map())
+  messageQueue.set(channel, [])
 
   const wsUrl = new URL(url)
   Object.entries(channelOptions)

package/src/contract/{aci/index.js → aci.js}

@@ -22,38 +22,28 @@
  * @export getContractInstance
  */
 
-import * as R from 'ramda'
-import BigNumber from 'bignumber.js'
 import { Encoder as Calldata } from '@aeternity/aepp-calldata'
-import { decodeEvents } from './transformation'
-import { DRY_RUN_ACCOUNT, DEPOSIT } from '../../tx/builder/schema'
-import TxObject from '../../tx/tx-object'
-import { decode } from '../../tx/builder/helpers'
-
-/**
- * Get function schema from contract ACI object
- * @param {Object} aci Contract ACI object
- * @param {String} name Function name
- * @param external
- * @return {Object} function ACI
- */
-function getFunctionACI (aci, name, external) {
-  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 : []
-  }
-}
+import { DRY_RUN_ACCOUNT, GAS_MAX } from '../tx/builder/schema'
+import TxObject from '../tx/tx-object'
+import { decode } from '../tx/builder/helpers'
+import {
+  MissingContractDefError,
+  MissingContractAddressError,
+  InactiveContractError,
+  BytecodeMismatchError,
+  InternalError,
+  DuplicateContractError,
+  MissingFunctionNameError,
+  InvalidMethodInvocationError,
+  NotPayableFunctionError,
+  TypeError,
+  NodeInvocationError,
+  IllegalArgumentError,
+  NoSuchContractFunctionError,
+  MissingEventDefinitionError,
+  AmbiguousEventDefinitionError
+} from '../utils/errors'
+import { hash } from '../utils/crypto-ts'
 
 /**
  * Generate contract ACI object with predefined js methods for contract usage - can be used for
@@ -68,7 +58,7 @@ function getFunctionACI (aci, name, external) {
  * @param {Boolean} [options.validateBytecode] Compare source code with on-chain version
  * @return {ContractInstance} JS Contract API
  * @example
- * const contractIns = await client.getContractInstance({ source })
+ * const contractIns = await aeSdk.getContractInstance({ source })
  * await contractIns.deploy([321]) or await contractIns.methods.init(321)
  * const callResult = await contractIns.call('setState', [123]) or
  * await contractIns.methods.setState.send(123, options)
@@ -81,30 +71,32 @@ function getFunctionACI (aci, name, external) {
 export default async function getContractInstance ({
   source,
   bytecode,
-  aci,
+  aci: _aci,
   contractAddress,
   filesystem = {},
   validateBytecode,
   ...otherOptions
 } = {}) {
-  aci = aci || (source && await this.contractGetACI(source, { filesystem }))
-  if (!aci) throw new Error('Either ACI or source code is required')
+  if (!_aci && source) {
+    _aci = await this.compilerApi.generateACI({ code: source, options: { filesystem } })
+  }
+  if (!_aci) throw new MissingContractDefError()
   contractAddress = contractAddress && await this.resolveName(
     contractAddress, 'contract_pubkey', { resolveByNode: true }
   )
-  if (!contractAddress && !source && !bytecode) throw new Error('Can\'t create instance by ACI without address')
+  if (!contractAddress && !source && !bytecode) {
+    throw new MissingContractAddressError('Can\'t create instance by ACI without address')
+  }
 
   if (contractAddress) {
-    const contract = await this.getContract(contractAddress).catch(() => null)
-    if (!contract) throw new Error(`Contract with address ${contractAddress} not found on-chain`)
-    if (!contract.active) throw new Error(`Contract with address ${contractAddress} not active`)
+    const contract = await this.getContract(contractAddress)
+    if (!contract.active) throw new InactiveContractError(contractAddress)
   }
 
   const instance = {
-    interface: R.defaultTo(null, R.prop('interface', aci)),
-    aci: R.defaultTo(null, R.path(['encoded_aci', 'contract'], aci)),
-    calldata: new Calldata([aci.encoded_aci, ...aci.external_encoded_aci]),
-    externalAci: (aci.external_encoded_aci ?? []).map(a => a.contract || a.namespace),
+    _aci,
+    _name: _aci.encoded_aci.contract.name,
+    calldata: new Calldata([_aci.encoded_aci, ..._aci.external_encoded_aci]),
     source,
     bytecode,
     deployInfo: { address: contractAddress },
@@ -118,12 +110,14 @@ export default async function getContractInstance ({
   }
 
   if (validateBytecode) {
-    if (!contractAddress) throw new Error('Can\'t validate bytecode without contract address')
+    if (!contractAddress) throw new MissingContractAddressError('Can\'t validate bytecode without contract address')
     const onChanBytecode = (await this.getContractByteCode(contractAddress)).bytecode
-    const isValid = (source && await this
-      .validateByteCodeAPI(onChanBytecode, source, instance.options).catch(() => false)) ||
-      bytecode === onChanBytecode
-    if (!isValid) throw new Error(`Contract ${source ? 'source' : 'bytecode'} do not correspond to the bytecode deployed on the chain`)
+    const isValid = source
+      ? await this.compilerApi.validateByteCode(
+        { bytecode: onChanBytecode, source, options: instance.options }
+      ).then((res) => Object.entries(res).length === 0, () => false)
+      : bytecode === onChanBytecode
+    if (!isValid) throw new BytecodeMismatchError(source ? 'source' : 'bytecode')
   }
 
   /**
@@ -133,11 +127,11 @@ export default async function getContractInstance ({
    * @return {String} bytecode bytecode
    */
   instance.compile = async (options = {}) => {
-    if (instance.bytecode) throw new Error('Contract already compiled')
-    if (!instance.source) throw new Error('Can\'t compile without source code')
-    const { bytecode } = await this.contractCompile(
-      instance.source, { ...instance.options, ...options }
-    )
+    if (instance.bytecode) throw new IllegalArgumentError('Contract already compiled')
+    if (!instance.source) throw new IllegalArgumentError('Can\'t compile without source code')
+    const { bytecode } = await this.compilerApi.compileContract({
+      code: instance.source, options: { ...instance.options, ...options }
+    })
     instance.bytecode = bytecode
     return instance.bytecode
   }
@@ -148,9 +142,10 @@ export default async function getContractInstance ({
       hash: txData.hash, tx: TxObject({ tx: txData.rawTx }), txData, rawTx: txData.rawTx
     }
     if (options.waitMined === false) return result
-    const txInfo = await this.getTxInfo(txData.hash)
-    await handleCallError(txInfo)
-    return { ...result, result: txInfo }
+    const { callInfo } = await this.api.getTransactionInfoByHash(txData.hash)
+    Object.assign(result.txData, callInfo) // TODO: don't duplicate data in result
+    await handleCallError(callInfo)
+    return { ...result, result: callInfo }
   }
 
   const handleCallError = ({ returnType, returnValue }) => {
@@ -164,9 +159,16 @@ export default async function getContractInstance ({
       case 'error':
         message = decode(returnValue).toString()
         break
-      default: throw new Error(`Unknown returnType: ${returnType}`)
+      default: throw new InternalError(`Unknown returnType: ${returnType}`)
     }
-    throw new Error(`Invocation failed${message ? `: "${message}"` : ''}`)
+    throw new NodeInvocationError(message)
+  }
+
+  instance._estimateGas = async (name, params, options) => {
+    const { result: { gasUsed } } =
+      await instance.call(name, params, { ...options, callStatic: true })
+    // taken from https://github.com/aeternity/aepp-sdk-js/issues/1286#issuecomment-977814771
+    return Math.floor(gasUsed * 1.25)
   }
 
   /**
@@ -178,15 +180,16 @@ export default async function getContractInstance ({
    * @return {Object} deploy info
    */
   instance.deploy = async (params = [], options) => {
-    const opt = { ...instance.options, ...options, deposit: DEPOSIT }
+    const opt = { ...instance.options, ...options }
     if (!instance.bytecode) await instance.compile(opt)
     if (opt.callStatic) return instance.call('init', params, opt)
-    if (instance.deployInfo.address) throw new Error('Contract already deployed')
+    if (instance.deployInfo.address) throw new DuplicateContractError()
 
     const ownerId = await this.address(opt)
     const { tx, contractId } = await this.contractCreateTx({
       ...opt,
-      callData: instance.calldata.encode(instance.aci.name, 'init', params),
+      gas: opt.gas ?? await instance._estimateGas('init', params, opt),
+      callData: instance.calldata.encode(instance._name, 'init', params),
       code: instance.bytecode,
       ownerId
     })
@@ -197,16 +200,23 @@ export default async function getContractInstance ({
       transaction: hash,
       rawTx,
       txData,
-      address: contractId,
-      call: (name, args, options) =>
-        this.contractCall(instance.source, contractId, name, args, { ...opt, ...options }),
-      callStatic: (name, args, options) =>
-        this.contractCallStatic(instance.source, contractId, name, args, { ...opt, ...options }),
-      createdAt: new Date()
+      address: contractId
     })
     return instance.deployInfo
   }
 
+  /**
+   * Get function schema from contract ACI object
+   * @param {String} name Function name
+   * @return {Object} function ACI
+   */
+  function getFunctionACI (name) {
+    const fn = instance._aci.encoded_aci.contract.functions.find(f => f.name === name)
+    if (fn) return fn
+    if (name === 'init') return { payable: false }
+    throw new NoSuchContractFunctionError(`Function ${name} doesn't exist in contract`)
+  }
+
   /**
    * Call contract function
    * @alias module:@aeternity/aepp-sdk/es/contract/aci
@@ -219,22 +229,19 @@ export default async function getContractInstance ({
    */
   instance.call = async (fn, params = [], options = {}) => {
     const opt = { ...instance.options, ...options }
-    const fnACI = getFunctionACI(instance.aci, fn, instance.externalAci)
+    const fnACI = getFunctionACI(fn)
     const contractId = instance.deployInfo.address
 
-    if (!fn) throw new Error('Function name is required')
-    if (fn === 'init' && !opt.callStatic) throw new Error('"init" can be called only via dryRun')
-    if (!contractId && fn !== 'init') throw new Error('You need to deploy contract before calling!')
-    if (
-      BigNumber(opt.amount).gt(0) &&
-      (Object.prototype.hasOwnProperty.call(fnACI, 'payable') && !fnACI.payable)
-    ) throw new Error(`You try to pay "${opt.amount}" to function "${fn}" which is not payable. Only payable function can accept tokens`)
+    if (!fn) throw new MissingFunctionNameError()
+    if (fn === 'init' && !opt.callStatic) throw new InvalidMethodInvocationError('"init" can be called only via dryRun')
+    if (!contractId && fn !== 'init') throw new InvalidMethodInvocationError('You need to deploy contract before calling!')
+    if (opt.amount > 0 && fnACI.payable === false) throw new NotPayableFunctionError(`You try to pay "${opt.amount}" to function "${fn}" which is not payable. Only payable function can accept coins`)
 
     const callerId = await this.address(opt).catch(error => {
       if (opt.callStatic) return DRY_RUN_ACCOUNT.pub
       else throw error
     })
-    const callData = instance.calldata.encode(instance.aci.name, fn, params)
+    const callData = instance.calldata.encode(instance._name, fn, params)
 
     let res
     if (opt.callStatic) {
@@ -243,8 +250,10 @@ export default async function getContractInstance ({
       }
       const txOpt = {
         ...opt,
+        gas: opt.gas ?? GAS_MAX,
         callData,
-        nonce: opt.top && (await this.getAccount(callerId, { hash: opt.top })).nonce + 1
+        nonce: opt.nonce ??
+          (opt.top && (await this.getAccount(callerId, { hash: opt.top })).nonce + 1)
       }
       const tx = fn === 'init'
         ? (await this.contractCreateTx({ ...txOpt, code: instance.bytecode, ownerId: callerId })).tx
@@ -254,33 +263,84 @@ export default async function getContractInstance ({
       await handleCallError(callObj)
       res = { ...dryRunOther, tx: TxObject({ tx }), result: callObj }
     } else {
-      const tx = await this.contractCallTx({ ...opt, callerId, contractId, callData })
+      const tx = await this.contractCallTx({
+        ...opt,
+        gas: opt.gas ?? await instance._estimateGas(fn, params, opt),
+        callerId,
+        contractId,
+        callData
+      })
       res = await sendAndProcess(tx, opt)
     }
     if (opt.waitMined || opt.callStatic) {
       res.decodedResult = fnACI.returns && fnACI.returns !== 'unit' && fn !== 'init' &&
-        instance.calldata.decode(instance.aci.name, fn, res.result.returnValue)
-      res.decodedEvents = instance.decodeEvents(res.result.log)
+        instance.calldata.decode(instance._name, fn, res.result.returnValue)
+      res.decodedEvents = instance.decodeEvents(res.result.log, opt)
     }
     return res
   }
 
+  /**
+   * @param {String} address Contract address that emitted event
+   * @param {BigInt} nameHash Hash of emitted event name
+   * @param {Object} [options]
+   * @param {Object} [options.contractAddressToName] Map of contract addresses to their names
+   * @return {String} Contract name
+   * @throws {MissingEventDefinitionError}
+   * @throws {AmbiguousEventDefinitionError}
+   */
+  function getContractNameByEvent (address, nameHash, { contractAddressToName }) {
+    const addressToName = { ...instance.options.contractAddressToName, ...contractAddressToName }
+    if (addressToName[address]) return addressToName[address]
+
+    const matchedEvents = [
+      instance._aci.encoded_aci,
+      ...instance._aci.external_encoded_aci
+    ]
+      .filter(({ contract }) => contract?.event)
+      .map(({ contract }) => [contract.name, contract.event.variant])
+      .map(([name, events]) => events.map(event => [name, Object.keys(event)[0]]))
+      .flat()
+      .filter(([, eventName]) => BigInt('0x' + hash(eventName).toString('hex')) === nameHash)
+    switch (matchedEvents.length) {
+      case 0: throw new MissingEventDefinitionError(nameHash, address)
+      case 1: return matchedEvents[0][0]
+      default: throw new AmbiguousEventDefinitionError(address, matchedEvents)
+    }
+  }
+
   /**
    * Decode Events
    * @alias module:@aeternity/aepp-sdk/es/contract/aci
    * @rtype (events: Array) => DecodedEvents: Array
-   * @param {Array} events Array of encoded events(callRes.result.log)
+   * @param {Array} events Array of encoded events (callRes.result.log)
+   * @param {Object} [options]
+   * @param {Boolean} [options.omitUnknown] Omit events that can't be decoded in case ACI is not
+   * complete
    * @return {Object} DecodedEvents
    */
-  instance.decodeEvents = (events) => {
-    const eventsACI = instance.aci.event ? instance.aci.event.variant : []
-    const eventsSchema = eventsACI.map(e => {
-      const name = Object.keys(e)[0]
-      return { name, types: e[name] }
+  instance.decodeEvents = (events, { omitUnknown, ...opt } = {}) => events
+    .map(event => {
+      const topics = event.topics.map(t => BigInt(t))
+      let contractName
+      try {
+        contractName = getContractNameByEvent(event.address, topics[0], opt)
+      } catch (error) {
+        if (omitUnknown && error instanceof MissingEventDefinitionError) return null
+        throw error
+      }
+      const decoded = instance.calldata.decodeEvent(contractName, event.data, topics)
+      const [name, args] = Object.entries(decoded)[0]
+      return {
+        name,
+        args,
+        contract: {
+          name: contractName,
+          address: event.address
+        }
+      }
     })
-
-    return decodeEvents(events, eventsSchema)
-  }
+    .filter(e => e)
 
   /**
    * Generate proto function based on contract function using Contract ACI schema
@@ -291,11 +351,11 @@ export default async function getContractInstance ({
    * `await contract.methods.testFunction.get()` -> use call-static(dry-run)
    * `await contract.methods.testFunction.send()` -> send tx on-chain
    */
-  instance.methods = Object.fromEntries(instance.aci.functions
+  instance.methods = Object.fromEntries(instance._aci.encoded_aci.contract.functions
     .map(({ name, arguments: aciArgs, stateful }) => {
       const genHandler = callStatic => (...args) => {
         const options = args.length === aciArgs.length + 1 ? args.pop() : {}
-        if (typeof options !== 'object') throw new Error(`Options should be an object: ${options}`)
+        if (typeof options !== 'object') throw new TypeError(`Options should be an object: ${options}`)
         if (name === 'init') return instance.deploy(args, { callStatic, ...options })
         return instance.call(name, args, { callStatic, ...options })
       }
@@ -305,8 +365,7 @@ export default async function getContractInstance ({
           genHandler(name === 'init' ? false : !stateful),
           {
             get: genHandler(true),
-            send: genHandler(false),
-            decodeEvents: events => instance.decodeEvents(events)
+            send: genHandler(false)
           }
         )
       ]