@aeternity/aepp-sdk 10.0.0-beta.1 → 11.0.1

package/src/channel/internal.js

@@ -19,7 +19,7 @@ import { w3cwebsocket as W3CWebSocket } from 'websocket'
 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 +49,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 +109,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 +139,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 +155,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 +169,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 +180,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 })
   })
@@ -191,14 +195,15 @@ export function disconnect (channel) {
   clearTimeout(pongTimeoutId.get(channel))
 }
 
-export async function initialize (channel, { url, ...channelOptions }) {
+export async function initialize (
+  channel, connectionHandler, openHandler, { url, ...channelOptions }
+) {
   options.set(channel, channelOptions)
-  fsm.set(channel, {
-    handler: channelOptions.existingFsmId ? awaitingReconnection : awaitingConnection
-  })
+  fsm.set(channel, { handler: connectionHandler })
   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)
@@ -213,7 +218,7 @@ export async function initialize (channel, { url, ...channelOptions }) {
       resolve()
       changeStatus(channel, 'connected')
       if (channelOptions.reconnectTx) {
-        enterState(channel, { handler: channelOpen })
+        enterState(channel, { handler: openHandler })
         setTimeout(async () => changeState(channel,
           (await call(channel, 'channels.get.offchain_state', {})).signed_tx
         ))

package/src/contract/aci.js

@@ -0,0 +1,376 @@
+/*
+ * 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.
+ */
+
+/**
+ * ContractACI module
+ *
+ * @module @aeternity/aepp-sdk/es/contract/aci
+ * @export getContractInstance
+ */
+
+import { Encoder as Calldata } from '@aeternity/aepp-calldata'
+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
+ * creating a reference to already deployed contracts
+ * @alias module:@aeternity/aepp-sdk/es/contract/aci
+ * @param {Object} [options={}] Options object
+ * @param {String} [options.source] Contract source code
+ * @param {String} [options.bytecode] Contract bytecode
+ * @param {Object} [options.aci] Contract ACI
+ * @param {String} [options.contractAddress] Contract address
+ * @param {Object} [options.filesystem] Contact source external namespaces map
+ * @param {Boolean} [options.validateBytecode] Compare source code with on-chain version
+ * @return {ContractInstance} JS Contract API
+ * @example
+ * 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)
+ * const staticCallResult = await contractIns.call('setState', [123], { callStatic: true }) or
+ * await contractIns.methods.setState.get(123, options)
+ * Also you can call contract like: await contractIns.methods.setState(123, options)
+ * Then sdk decide to make on-chain or static call(dry-run API) transaction based on function is
+ * stateful or not
+ */
+export default async function getContractInstance ({
+  source,
+  bytecode,
+  aci: _aci,
+  contractAddress,
+  filesystem = {},
+  validateBytecode,
+  ...otherOptions
+} = {}) {
+  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 MissingContractAddressError('Can\'t create instance by ACI without address')
+  }
+
+  if (contractAddress) {
+    const contract = await this.getContract(contractAddress)
+    if (!contract.active) throw new InactiveContractError(contractAddress)
+  }
+
+  const instance = {
+    _aci,
+    _name: _aci.encoded_aci.contract.name,
+    calldata: new Calldata([_aci.encoded_aci, ..._aci.external_encoded_aci]),
+    source,
+    bytecode,
+    deployInfo: { address: contractAddress },
+    options: {
+      ...this.Ae.defaults,
+      callStatic: false,
+      filesystem,
+      ...otherOptions
+    },
+    compilerVersion: this.compilerVersion
+  }
+
+  if (validateBytecode) {
+    if (!contractAddress) throw new MissingContractAddressError('Can\'t validate bytecode without contract address')
+    const onChanBytecode = (await this.getContractByteCode(contractAddress)).bytecode
+    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')
+  }
+
+  /**
+   * Compile contract
+   * @alias module:@aeternity/aepp-sdk/es/contract/aci
+   * @rtype () => ContractInstance: Object
+   * @return {String} bytecode bytecode
+   */
+  instance.compile = async (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
+  }
+
+  const sendAndProcess = async (tx, options) => {
+    const txData = await this.send(tx, options)
+    const result = {
+      hash: txData.hash, tx: TxObject({ tx: txData.rawTx }), txData, rawTx: txData.rawTx
+    }
+    if (options.waitMined === false) return result
+    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 }) => {
+    let message
+    // TODO: ensure that it works correctly https://github.com/aeternity/aepp-calldata-js/issues/88
+    switch (returnType) {
+      case 'ok': return
+      case 'revert':
+        message = instance.calldata.decodeFateString(returnValue)
+        break
+      case 'error':
+        message = decode(returnValue).toString()
+        break
+      default: throw new InternalError(`Unknown returnType: ${returnType}`)
+    }
+    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)
+  }
+
+  /**
+   * Deploy contract
+   * @alias module:@aeternity/aepp-sdk/es/contract/aci
+   * @rtype (init: Array, options: Object) => ContractInstance: Object
+   * @param {Array} params Contract init function arguments array
+   * @param {Object} [options] options
+   * @return {Object} deploy info
+   */
+  instance.deploy = async (params = [], options) => {
+    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 DuplicateContractError()
+
+    const ownerId = await this.address(opt)
+    const { tx, contractId } = await this.contractCreateTx({
+      ...opt,
+      gas: opt.gas ?? await instance._estimateGas('init', params, opt),
+      callData: instance.calldata.encode(instance._name, 'init', params),
+      code: instance.bytecode,
+      ownerId
+    })
+    const { hash, rawTx, result, txData } = await sendAndProcess(tx, opt)
+    instance.deployInfo = Object.freeze({
+      result,
+      owner: ownerId,
+      transaction: hash,
+      rawTx,
+      txData,
+      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
+   * @rtype (init: Array, options: Object = { callStatic: false }) => CallResult: Object
+   * @param {String} fn Function name
+   * @param {Array} params Array of function arguments
+   * @param {Object} [options={}] Array of function arguments
+   * @param {Boolean} [options.callStatic=false] Static function call
+   * @return {Object} CallResult
+   */
+  instance.call = async (fn, params = [], options = {}) => {
+    const opt = { ...instance.options, ...options }
+    const fnACI = getFunctionACI(fn)
+    const contractId = instance.deployInfo.address
+
+    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 (fn !== 'init' && 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._name, fn, params)
+
+    let res
+    if (opt.callStatic) {
+      if (typeof opt.top === 'number') {
+        opt.top = (await this.getKeyBlock(opt.top)).hash
+      }
+      const txOpt = {
+        ...opt,
+        gas: opt.gas ?? GAS_MAX,
+        callData,
+        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
+        : await this.contractCallTx({ ...txOpt, callerId, contractId })
+
+      const { callObj, ...dryRunOther } = await this.txDryRun(tx, callerId, opt)
+      await handleCallError(callObj)
+      res = { ...dryRunOther, tx: TxObject({ tx }), result: callObj }
+    } else {
+      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._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 {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, { 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
+        }
+      }
+    })
+    .filter(e => e)
+
+  /**
+   * Generate proto function based on contract function using Contract ACI schema
+   * All function can be called like:
+   * 'await contract.methods.testFunction()' -> then sdk will decide to use dry-run or send tx
+   * on-chain base on if function stateful or not.
+   * Also you can manually do that:
+   * `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.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 TypeError(`Options should be an object: ${options}`)
+        if (name === 'init') return instance.deploy(args, { callStatic, ...options })
+        return instance.call(name, args, { callStatic, ...options })
+      }
+      return [
+        name,
+        Object.assign(
+          genHandler(name === 'init' ? false : !stateful),
+          {
+            get: genHandler(true),
+            send: genHandler(false)
+          }
+        )
+      ]
+    })
+  )
+
+  return instance
+}

package/src/contract/compiler.js

@@ -1,6 +1,6 @@
 /*
  * ISC License (ISC)
- * Copyright (c) 2018 aeternity developers
+ * Copyright (c) 2021 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,18 +16,18 @@
  */
 
 /**
- * ContractCompilerAPI module
+ * ContractCompilerHttp module
  *
- * This is the complement to {@link module:@aeternity/aepp-sdk/es/contract}.
  * @module @aeternity/aepp-sdk/es/contract/compiler
- * @export ContractCompilerAPI
- * @example import { ContractCompilerAPI } from '@aeternity/aepp-sdk'
+ * @export ContractCompilerHttp
+ * @example import { ContractCompilerHttp } from '@aeternity/aepp-sdk'
  */
 
-import ContractBase from './index'
 import semverSatisfies from '../utils/semver-satisfies'
 import AsyncInit from '../utils/async-init'
 import genSwaggerClient from '../utils/swagger'
+import { MissingParamError, UnsupportedVersionError } from '../utils/errors'
+import { mapObject } from '../utils/other'
 
 /**
  * Contract Compiler Stamp
@@ -39,16 +39,16 @@ import genSwaggerClient from '../utils/swagger'
  * @param {Object} [options={}] - Initializer object
  * @param {String} [options.compilerUrl] compilerUrl - Url for compiler API
  * @return {Object} Contract compiler instance
- * @example ContractCompilerAPI({ compilerUrl: 'COMPILER_URL' })
+ * @example ContractCompilerHttp({ compilerUrl: 'COMPILER_URL' })
  */
-export default AsyncInit.compose(ContractBase, {
+export default AsyncInit.compose({
   async init ({ compilerUrl, ignoreVersion }) {
     if (!compilerUrl) return
     await this.setCompilerUrl(compilerUrl, { ignoreVersion })
   },
   methods: {
     async setCompilerUrl (compilerUrl, { ignoreVersion = false } = {}) {
-      if (!compilerUrl) throw new Error('"compilerUrl" required')
+      if (!compilerUrl) throw new MissingParamError('compilerUrl required')
       compilerUrl = compilerUrl.replace(/\/$/, '')
       const client = await genSwaggerClient(`${compilerUrl}/api`, {
         disableBigNumbers: true,
@@ -73,113 +73,22 @@ export default AsyncInit.compose(ContractBase, {
         }
       })
       this.compilerVersion = client.spec.info.version
-      this._compilerApi = client.api
+      this.compilerApi = mapObject(
+        client.api,
+        ([key, fn]) => [
+          key,
+          ({ options: { filesystem, ...options } = {}, ...args } = {}) => fn({
+            ...args, options: { ...options, file_system: filesystem }
+          })
+        ]
+      )
 
       if (ignoreVersion) return
       if (!semverSatisfies(this.compilerVersion, COMPILER_GE_VERSION, COMPILER_LT_VERSION)) {
-        throw new Error(`Unsupported compiler version ${this.compilerVersion}. ` +
-          `Supported: >= ${COMPILER_GE_VERSION} < ${COMPILER_LT_VERSION}`)
+        throw new UnsupportedVersionError(
+          'compiler', this.compilerVersion, COMPILER_GE_VERSION, COMPILER_LT_VERSION
+        )
       }
-    },
-    _ensureCompilerReady () {
-      if (!this._compilerApi) throw new Error('Compiler is not ready')
-    },
-    _prepareCompilerOptions ({ filesystem = {} } = {}) {
-      return { file_system: filesystem }
-    },
-    getCompilerVersion () {
-      this._ensureCompilerReady()
-      return Promise.resolve(this.compilerVersion)
-    },
-    /**
-     * Encode call data for contract call
-     * @function
-     * @category async
-     * @param {String} source Contract source code
-     * @param {String} name Name of function to call
-     * @param {Array} args Argument's for call
-     * @param {Object} [options={}]  Options
-     * @param {Object} [options.filesystem={}] Contract external namespaces map
-     * @return {Promise<String>}
-     */
-    async contractEncodeCallDataAPI (source, name, args = [], options) {
-      this._ensureCompilerReady()
-      const { calldata } = await this._compilerApi.encodeCalldata({
-        source,
-        function: name,
-        arguments: args,
-        options: this._prepareCompilerOptions(options)
-      })
-      return calldata
-    },
-    async compileContractAPI (code, options) {
-      this._ensureCompilerReady()
-      const { bytecode } = await this._compilerApi.compileContract({
-        code,
-        options: this._prepareCompilerOptions(options)
-      })
-      return bytecode
-    },
-    contractGetACI (code, options) {
-      this._ensureCompilerReady()
-      return this._compilerApi.generateACI({ code, options: this._prepareCompilerOptions(options) })
-    },
-    contractDecodeCallDataByCodeAPI (bytecode, calldata) {
-      this._ensureCompilerReady()
-      return this._compilerApi.decodeCalldataBytecode({ bytecode, calldata })
-    },
-    contractDecodeCallDataBySourceAPI (source, fn, callData, options) {
-      this._ensureCompilerReady()
-      return this._compilerApi.decodeCalldataSource({
-        function: fn,
-        source,
-        calldata: callData,
-        options: this._prepareCompilerOptions(options)
-      })
-    },
-    /**
-     * Decode contract call result data
-     * @function
-     * @category async
-     * @param {String} source - source code
-     * @param {String } fn - function name
-     * @param {String} callValue - result call data
-     * @param {String} callResult - result status
-     * @param {Object} [options={}]  Options
-     * @param {Object} [options.filesystem={}] Contract external namespaces map
-     * @return {Promise<String>} Result object
-     * @example
-     * const decodedData = await sdk.contractDecodeCallResultAPI(SourceCode ,'functionName', 'cb_asdasdasd...', 'ok|revert')lt
-     */
-    contractDecodeCallResultAPI (source, fn, callValue, callResult, options) {
-      this._ensureCompilerReady()
-      return this._compilerApi.decodeCallResult({
-        function: fn,
-        source,
-        'call-result': callResult,
-        'call-value': callValue,
-        options: this._prepareCompilerOptions(options)
-      })
-    },
-    async validateByteCodeAPI (bytecode, source, options) {
-      this._ensureCompilerReady()
-      const res = await this._compilerApi.validateByteCode({
-        bytecode,
-        source,
-        options: this._prepareCompilerOptions(options)
-      })
-      return typeof res === 'object' ? true : res
-    },
-    getFateAssembler (bytecode, options) {
-      this._ensureCompilerReady()
-      return this._compilerApi.getFateAssemblerCode({ bytecode, options: this._prepareCompilerOptions(options) })
-    },
-    getBytecodeCompilerVersion (bytecode, options) {
-      this._ensureCompilerReady()
-      return this._compilerApi.getCompilerVersion({
-        bytecode,
-        options: this._prepareCompilerOptions(options)
-      })
     }
   },
   props: {
@@ -187,5 +96,5 @@ export default AsyncInit.compose(ContractBase, {
   }
 })
 
-const COMPILER_GE_VERSION = '6.0.0'
+const COMPILER_GE_VERSION = '6.1.0'
 const COMPILER_LT_VERSION = '7.0.0'