@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/ae/contract.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
@@ -27,253 +27,10 @@
  */
 
 import Ae from './'
-import * as R from 'ramda'
-import ContractCompilerAPI from '../contract/compiler'
-import ContractBase from '../contract'
+import ContractCompilerHttp from '../contract/compiler'
 import getContractInstance from '../contract/aci'
-import NodePool from '../node-pool'
-import { AMOUNT, DEPOSIT, DRY_RUN_ACCOUNT, GAS, MIN_GAS_PRICE } from '../tx/builder/schema'
+import { AMOUNT, MIN_GAS_PRICE } from '../tx/builder/schema'
 import { decode, produceNameId } from '../tx/builder/helpers'
-import TxObject from '../tx/tx-object'
-
-async function _sendAndProcess (tx, source, name, 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 txInfo = await this.getTxInfo(txData.hash)
-  await this._handleCallError(source, name, txInfo)
-  return { ...result, result: txInfo }
-}
-
-/**
- * Handle contract call error
- * @function
- * @private
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source contract source code
- * @param {String} name name of called method
- * @param {Object} result call result object
- * @throws Error Decoded error
- * @return {Promise<void>}
- */
-async function _handleCallError (source, name, result) {
-  if (result.returnType === 'ok') return
-  const error = await this.contractDecodeCallResultAPI(source, name, result.returnValue, result.returnType)
-  const message = error[{ revert: 'abort' }[result.returnType] || result.returnType][0]
-  throw new Error(`Invocation failed${message ? `: "${message}"` : ''}`)
-}
-
-/**
- * Encode call data for contract call
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @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 function contractEncodeCall (source, name, args, options) {
-  return this.contractEncodeCallDataAPI(source, name, args, options)
-}
-
-/**
- * Decode contract call result data
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @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 client.contractDecodeData(SourceCode ,'functionName', 'cb_asdasdasd...', 'ok|revert')lt
- */
-async function contractDecodeData (source, fn, callValue, callResult, options) {
-  return this.contractDecodeCallResultAPI(source, fn, callValue, callResult, options)
-}
-
-/**
- * Static contract call(using dry-run)
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source Contract source code
- * @param {String} address Contract address
- * @param {String} name Name of function to call
- * @param {Array|String} args Argument's or callData for call/deploy transaction
- * @param {Object} [options]
- * @param {Number|String} [options.top] Block height or hash on which you want to call contract
- * @param {String} [options.bytecode] Block hash on which you want to call contract
- * @param {Object} [options.filesystem] Contract external namespaces map
- * @return {Promise<Object>} Result object
- * @example
- * const callResult = await client.contractCallStatic(source, address, fnName, args)
- * {
- *   result: TX_DATA,
- *   decode: (type) => Decode call result
- * }
- */
-async function contractCallStatic (source, address, name, args = [], options = {}) {
-  const callerId = await this.address(options).catch(() => DRY_RUN_ACCOUNT.pub)
-  if (typeof options.top === 'number') {
-    options.top = (await this.getKeyBlock(options.top)).hash
-  }
-  const txOpt = {
-    ...this.Ae.defaults,
-    ...options,
-    callData: Array.isArray(args) ? await this.contractEncodeCall(source, name, args, options) : args,
-    nonce: options.top && (await this.getAccount(callerId, { hash: options.top })).nonce + 1
-  }
-  const tx = name === 'init'
-    ? (await this.contractCreateTx({
-      ...txOpt,
-      code: options.bytecode,
-      ownerId: callerId
-    })).tx
-    : await this.contractCallTx({
-      ...txOpt,
-      callerId,
-      contractId: await this.resolveName(address, 'ct', { resolveByNode: true })
-    })
-
-  const { callObj, ...dryRunOther } = await this.txDryRun(tx, callerId, options)
-
-  await this._handleCallError(source, name, callObj)
-  const { returnType, returnValue } = callObj
-  return {
-    ...dryRunOther,
-    tx: TxObject({ tx }),
-    result: callObj,
-    decode: () => this.contractDecodeData(source, name, returnValue, returnType, options)
-  }
-}
-
-/**
- * Call contract function
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source Contract source code
- * @param {String} address Contract address or AENS name
- * @param {String} name Name of function to call
- * @param {Array|String} argsOrCallData Argument's array or callData for call function
- * @param {Object} [options={}] Transaction options (fee, ttl, gas, amount, deposit)
- * @param {Object} [options.filesystem={}] Contract external namespaces map* @return {Promise<Object>} Result object
- * @example
- * const callResult = await client.contractCall(source, address, fnName, args = [], options)
- * {
- *   hash: TX_HASH,
- *   result: TX_DATA,
- *   decode: (type) => Decode call result
- * }
- */
-async function contractCall (source, address, name, argsOrCallData = [], options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
-
-  const tx = await this.contractCallTx(R.merge(opt, {
-    callerId: await this.address(opt),
-    contractId: await this.resolveName(address, 'ct', { resolveByNode: true }),
-    callData: Array.isArray(argsOrCallData) ? await this.contractEncodeCall(source, name, argsOrCallData, opt) : argsOrCallData
-  }))
-
-  const { hash, rawTx, result, txData } = await this._sendAndProcess(tx, source, name, opt)
-  return {
-    hash,
-    rawTx,
-    result,
-    txData,
-    decode: () => result ? this.contractDecodeData(source, name, result.returnValue, result.returnType, opt) : {}
-  }
-}
-
-/**
- * Deploy contract to the node
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} code Compiled contract
- * @param {String} source Contract source code
- * @param {Array|String} initState Arguments of contract constructor(init) function. Can be array of arguments or callData string
- * @param {Object} [options={}] Transaction options (fee, ttl, gas, amount, deposit)
- * @param {Object} [options.filesystem={}] Contract external namespaces map* @return {Promise<Object>} Result object
- * @return {Promise<Object>} Result object
- * @example
- * const deployed = await client.contractDeploy(bytecode, source, init = [], options)
- * {
- *   owner: OWNER_PUB_KEY,
- *   transaction: TX_HASH,
- *   address: CONTRACT_ADDRESS,
- *   createdAt: Date,
- *   result: DEPLOY_TX_DATA,
- *   call: (fnName, args = [], options) => Call contract function,
- *   callStatic: (fnName, args = [], options) => Static all contract function
- * }
- */
-async function contractDeploy (code, source, initState = [], options = {}) {
-  const opt = { ...this.Ae.defaults, ...options, deposit: DEPOSIT }
-  const callData = Array.isArray(initState) ? await this.contractEncodeCall(source, 'init', initState, opt) : initState
-  const ownerId = await this.address(opt)
-
-  const { tx, contractId } = await this.contractCreateTx(R.merge(opt, {
-    callData,
-    code,
-    ownerId
-  }))
-
-  const { hash, rawTx, result, txData } = await this._sendAndProcess(tx, source, 'init', opt)
-  return Object.freeze({
-    result,
-    owner: ownerId,
-    transaction: hash,
-    rawTx,
-    txData,
-    address: contractId,
-    call: (name, args, options) =>
-      this.contractCall(source, contractId, name, args, { ...opt, ...options }),
-    callStatic: (name, args, options) =>
-      this.contractCallStatic(source, contractId, name, args, { ...opt, ...options }),
-    createdAt: new Date()
-  })
-}
-
-/**
- * Compile contract source code
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @param {String} source Contract sourece code
- * @param {Object} [options={}] Transaction options (fee, ttl, gas, amount, deposit)
- * @param {Object} [options.filesystem={}] Contract external namespaces map* @return {Promise<Object>} Result object
- * @return {Promise<Object>} Result object
- * @example
- * const compiled = await client.contractCompile(SOURCE_CODE)
- * {
- *   bytecode: CONTRACT_BYTE_CODE,
- *   deploy: (init = [], options = {}) => Deploy Contract,
- *   encodeCall: (fnName, args = []) => Prepare callData
- * }
- */
-async function contractCompile (source, options = {}) {
-  const opt = { ...this.Ae.defaults, ...options }
-  const bytecode = await this.compileContractAPI(source, options)
-  return Object.freeze({
-    encodeCall: (name, args) => this.contractEncodeCall(source, name, args, opt),
-    deploy: (init, options) => this.contractDeploy(bytecode, source, init, { ...opt, ...options }),
-    deployStatic: (init, options) => this.contractCallStatic(source, null, 'init', init, {
-      ...opt,
-      ...options,
-      bytecode
-    }),
-    bytecode
-  })
-}
 
 /**
  * Utility method to create a delegate signature for a contract
@@ -286,20 +43,19 @@ async function contractCompile (source, options = {}) {
  * @return {Promise<String>} Signature in hex representation
  */
 async function delegateSignatureCommon (ids = [], opt = {}) {
-  return this.sign(
-    Buffer.concat(
-      [
-        Buffer.from(this.getNetworkId(opt)),
-        ...(Object.prototype.hasOwnProperty.call(opt, 'onAccount') ? [decode(await this.address(opt))] : []),
-        ...ids.map(e => decode(e))
-      ]
-    ),
+  const signature = await this.sign(
+    Buffer.concat([
+      Buffer.from(this.getNetworkId(opt)),
+      ...ids.map(e => decode(e))
+    ]),
     opt
-  ).then(s => Buffer.from(s).toString('hex'))
+  )
+  return Buffer.from(signature).toString('hex')
 }
 
 /**
- * Helper to generate a signature to delegate pre-claim/claim/transfer/revoke of a name to a contract.
+ * Helper to generate a signature to delegate pre-claim/claim/transfer/revoke of a name to
+ * a contract.
  * @function
  * @alias module:@aeternity/aepp-sdk/es/ae/contract
  * @category async
@@ -308,19 +64,24 @@ async function delegateSignatureCommon (ids = [], opt = {}) {
  * @param {{ onAccount: String | Object }} [opt={}] opt Options
  * @return {Promise<String>} Signature for delegation
  * @example
- * const client = await Universal({ ... })
+ * const aeSdk = await Universal({ ... })
  * const contractId = 'ct_asd2ks...' // contract address
  * const name = 'example.chain' // AENS name
- * const onAccount = await client.address() // Sign with a specific account
+ * const onAccount = await aeSdk.address() // Sign with a specific account
  * // Preclaim signature
  * const params = { contractId }
- * const preclaimSig = await client.createAensDelegationSignature(params, { onAccount: current })
+ * const preclaimSig = await aeSdk.createAensDelegationSignature(params, { onAccount: current })
  * // Claim, transfer and revoke signature
  * const params = { contractId, name }
- * const aensDelegationSig = await contract.createAensDelegationSignature(params, name, { onAccount: current })
+ * const aensDelegationSig = await contract.createAensDelegationSignature(
+ *   params, name, { onAccount: current }
+ * )
  */
 async function createAensDelegationSignature ({ contractId, name }, opt = {}) {
-  return this.delegateSignatureCommon([...name ? [produceNameId(name)] : [], contractId], opt)
+  return this.delegateSignatureCommon(
+    [await this.address(opt), ...name ? [produceNameId(name)] : [], contractId],
+    opt
+  )
 }
 
 /**
@@ -333,10 +94,10 @@ async function createAensDelegationSignature ({ contractId, name }, opt = {}) {
  * @param {{ onAccount: String | Object }} [opt={}] opt Options
  * @return {Promise<String>} Signature for delegation
  * @example
- * const client = await Universal({ ... })
+ * const aeSdk = await Universal({ ... })
  * const contractId = 'ct_asd2ks...' // contract address
  * const queryId = 'oq_...' // Oracle Query Id
- * const onAccount = await client.address() // Sign with a specific account
+ * const onAccount = await aeSdk.address() // Sign with a specific account
  * // Oracle register and extend signature
  * const params = { contractId }
  * const oracleDelegationSig = await contract.createOracleDelegationSignature(params, { onAccount })
@@ -359,35 +120,16 @@ async function createOracleDelegationSignature ({ contractId, queryId }, opt = {
  * @param {Object} [options={}] - Initializer object
  * @return {Object} Contract instance
  * @example
- * import Transaction from '@aeternity/aepp-sdk/es/tx/tx
- * import MemoryAccount from '@aeternity/aepp-sdk/es/account/memory
- * import ChainNode from '@aeternity/aepp-sdk/es/chain/node
- * import ContractCompilerAPI from '@aeternity/aepp-sdk/es/contract/compiler
- * // or using bundle
- * import {
- *   Transaction,
- *   MemoryAccount,
- *   ChainNode,
- *   ContractCompilerAPI
- * } from '@aeternity/aepp-sdk
+ * import { Transaction, MemoryAccount, ChainNode } from '@aeternity/aepp-sdk
  *
  * const ContractWithAE = await Contract
  *    .compose(Transaction, MemoryAccount, ChainNode) // AE implementation
- *    .compose(ContractCompilerAPI) // ContractBase implementation
  * const client = await ContractWithAe({ url, internalUrl, compilerUrl, keypair, ... })
  *
  */
-export const ContractAPI = Ae.compose(ContractBase, {
+export default Ae.compose(ContractCompilerHttp, {
   methods: {
     getContractInstance,
-    contractCompile,
-    contractCallStatic,
-    contractDeploy,
-    contractCall,
-    contractEncodeCall,
-    contractDecodeData,
-    _handleCallError,
-    _sendAndProcess,
     // Delegation for contract
     delegateSignatureCommon,
     // AENS
@@ -398,15 +140,9 @@ export const ContractAPI = Ae.compose(ContractBase, {
   deepProps: {
     Ae: {
       defaults: {
-        deposit: DEPOSIT,
         gasPrice: MIN_GAS_PRICE,
-        amount: AMOUNT,
-        gas: GAS
+        amount: AMOUNT
       }
     }
   }
 })
-
-export const Contract = ContractAPI.compose(NodePool)
-export const ContractWithCompiler = Contract.compose(ContractCompilerAPI)
-export default ContractWithCompiler

package/src/ae/index.js

@@ -27,9 +27,9 @@ import Tx from '../tx'
 import Chain from '../chain'
 import AccountBase from '../account/base'
 import TxBuilder from '../tx/builder'
-import * as R from 'ramda'
 import BigNumber from 'bignumber.js'
 import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
+import { ArgumentError } from '../utils/errors'
 
 /**
  * Sign and post a transaction to the chain
@@ -38,13 +38,15 @@ import { AE_AMOUNT_FORMATS } from '../utils/amount-formatter'
  * @rtype (tx: String, options: Object) => Promise[String]
  * @param {String} tx - Transaction
  * @param {Object} [options={}] options - Options
- * @param {Object} [options.verify=true] verify - Verify transaction before broadcast, throw error if not valid
+ * @param {Object} [options.verify=true] - Verify transaction before broadcast, throw error if not
+ * valid
  * @return {Object} Transaction
  */
 async function send (tx, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   const { contractId, authFun } = options.innerTx
-    ? { contractId: false } : await this.getAccount(await this.address(opt))
+    ? { contractId: false }
+    : await this.getAccount(await this.address(opt))
   const signed = contractId
     ? await this.signUsingGA(tx, { ...opt, authFun })
     : await this.signTransaction(tx, opt)
@@ -73,7 +75,7 @@ async function spend (amount, recipientIdOrName, options) {
     await this.spendTx({
       ...opt,
       senderId: await this.address(opt),
-      recipientId: await this.resolveName(recipientIdOrName, 'ak', opt),
+      recipientId: await this.resolveName(recipientIdOrName, 'account_pubkey', opt),
       amount
     }),
     opt
@@ -93,10 +95,10 @@ async function spend (amount, recipientIdOrName, options) {
  */
 async function transferFunds (fraction, recipientIdOrName, options) {
   if (fraction < 0 || fraction > 1) {
-    throw new Error(`Fraction should be a number between 0 and 1, got ${fraction}`)
+    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction)
   }
   const opt = { ...this.Ae.defaults, ...options }
-  const recipientId = await this.resolveName(recipientIdOrName, 'ak', opt)
+  const recipientId = await this.resolveName(recipientIdOrName, 'account_pubkey', opt)
   const senderId = await this.address(opt)
   const balance = new BigNumber(await this.balance(senderId))
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP)

package/src/ae/oracle.js

@@ -27,12 +27,11 @@
  */
 
 import Ae from './'
-import * as R from 'ramda'
-import { decodeBase64Check } from '../utils/crypto'
 import { pause } from '../utils/other'
 import { oracleQueryId, decode } from '../tx/builder/helpers'
 import { unpackTx } from '../tx/builder'
 import { ORACLE_TTL, QUERY_FEE, QUERY_TTL, RESPONSE_TTL } from '../tx/builder/schema'
+import { RequestTimedOutError } from '../utils/errors'
 
 /**
  * Constructor for Oracle Object (helper object for using Oracle)
@@ -68,7 +67,11 @@ async function getOracleObject (oracleId) {
  * @param {Number} [options.interval] Poll interval(default: 5000)
  * @return {Function} stopPolling - Stop polling function
  */
-function pollForQueries (oracleId, onQuery, { interval = 5000 } = {}) {
+function pollForQueries (
+  oracleId,
+  onQuery,
+  { interval = this._getPollInterval('microblock') } = {}
+) {
   const knownQueryIds = new Set()
   const checkNewQueries = async () => {
     const queries = ((await this.api.getOracleQueriesByPubkey(oracleId)).oracleQueries || [])
@@ -77,9 +80,15 @@ function pollForQueries (oracleId, onQuery, { interval = 5000 } = {}) {
     if (queries.length) onQuery(queries)
   }
 
-  checkNewQueries()
-  const intervalId = setInterval(checkNewQueries, interval)
-  return () => clearInterval(intervalId)
+  let stopped
+  (async () => {
+    while (!stopped) { // eslint-disable-line no-unmodified-loop-condition
+      // TODO: allow to handle this error somehow
+      await checkNewQueries().catch(console.error)
+      await pause(interval)
+    }
+  })()
+  return () => { stopped = true }
 }
 
 /**
@@ -96,11 +105,16 @@ async function getQueryObject (oracleId, queryId) {
   const q = await this.api.getOracleQueryByPubkeyAndQueryId(oracleId, queryId)
   return {
     ...q,
-    decodedQuery: decodeBase64Check(q.query.slice(3)).toString(),
-    decodedResponse: decodeBase64Check(q.response.slice(3)).toString(),
+    decodedQuery: decode(q.query).toString(),
+    decodedResponse: decode(q.response).toString(),
     respond: this.respondToQuery.bind(this, oracleId, queryId),
     pollForResponse: this.pollForQueryResponse.bind(this, oracleId, queryId),
-    decode: (data) => decodeBase64Check(data.slice(3))
+    /**
+     * @deprecated use TxBuilderHelper.decode instead
+     * @param data
+     * @returns {Buffer}
+     */
+    decode: (data) => decode(data)
   }
 }
 
@@ -117,16 +131,20 @@ async function getQueryObject (oracleId, queryId) {
  * @param {Object} [options.interval] Poll interval(default: 5000)
  * @return {Promise<Object>} OracleQuery object
  */
-export async function pollForQueryResponse (oracleId, queryId, { attempts = 20, interval = 5000 } = {}) {
+export async function pollForQueryResponse (
+  oracleId,
+  queryId,
+  { attempts = 20, interval = this._getPollInterval('microblock') } = {}
+) {
   for (let i = 0; i < attempts; i++) {
     if (i) await pause(interval)
     const { response } = await this.api.getOracleQueryByPubkeyAndQueryId(oracleId, queryId)
     const responseBuffer = decode(response, 'or')
     if (responseBuffer.length) {
-      return { response, decode: () => responseBuffer } // TODO: Return just responseBuffer
+      return String(responseBuffer)
     }
   }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms`)
+  throw new RequestTimedOutError((attempts - 1) * interval)
 }
 
 /**
@@ -138,22 +156,23 @@ export async function pollForQueryResponse (oracleId, queryId, { attempts = 20,
  * @param {String} queryFormat Format of query
  * @param {String} responseFormat Format of query response
  * @param {Object} [options={}] Options
- * @param {String|Number} [options.queryFee] queryFee Oracle query Fee
- * @param {Object} [options.oracleTtl] oracleTtl OracleTtl object {type: 'delta|block', value: 'number'}
- * @param {Number} [options.abiVersion] abiVersion Always 0 (do not use virtual machine)
- * @param {Number|String} [options.fee] fee Transaction fee
+ * @param {String|Number} [options.queryFee] Oracle query Fee
+ * @param {Object} [options.oracleTtl] OracleTtl object {type: 'delta|block', value: 'number'}
+ * @param {Number} [options.abiVersion] Always 0 (do not use virtual machine)
+ * @param {Number|String} [options.fee] Transaction fee
  * @param {Number|String} [options.ttl] Transaction time to leave
  * @return {Promise<Object>} Oracle object
  */
 async function registerOracle (queryFormat, responseFormat, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options) // Preset VmVersion for oracle
+  const opt = { ...this.Ae.defaults, ...options } // Preset VmVersion for oracle
   const accountId = await this.address(opt)
 
-  const oracleRegisterTx = await this.oracleRegisterTx(R.merge(opt, {
+  const oracleRegisterTx = await this.oracleRegisterTx({
+    ...opt,
     accountId,
     queryFormat,
     responseFormat
-  }))
+  })
   return {
     ...await this.send(oracleRegisterTx, opt),
     ...await this.getOracleObject(`ok_${accountId.slice(3)}`)
@@ -177,14 +196,16 @@ async function registerOracle (queryFormat, responseFormat, options = {}) {
  * @return {Promise<Object>} Query object
  */
 async function postQueryToOracle (oracleId, query, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
+  const queryFee = options.queryFee || (await this.api.getOracleByPubkey(oracleId)).queryFee
+  const opt = { ...this.Ae.defaults, queryFee, ...options }
   const senderId = await this.address(opt)
 
-  const oracleRegisterTx = await this.oraclePostQueryTx(R.merge(opt, {
+  const oracleRegisterTx = await this.oraclePostQueryTx({
+    ...opt,
     oracleId,
     senderId,
     query
-  }))
+  })
   const queryId = oracleQueryId(senderId, unpackTx(oracleRegisterTx).tx.nonce, oracleId)
   return {
     ...await this.send(oracleRegisterTx, opt),
@@ -206,14 +227,15 @@ async function postQueryToOracle (oracleId, query, options = {}) {
  * @return {Promise<Object>} Oracle object
  */
 async function extendOracleTtl (oracleId, oracleTtl, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   const callerId = await this.address(opt)
 
-  const oracleExtendTx = await this.oracleExtendTx(R.merge(opt, {
+  const oracleExtendTx = await this.oracleExtendTx({
+    ...opt,
     oracleId,
     callerId,
     oracleTtl
-  }))
+  })
   return {
     ...await this.send(oracleExtendTx, opt),
     ...await this.getOracleObject(oracleId)
@@ -236,15 +258,16 @@ async function extendOracleTtl (oracleId, oracleTtl, options = {}) {
  * @return {Promise<Object>} Oracle object
  */
 async function respondToQuery (oracleId, queryId, response, options = {}) {
-  const opt = R.merge(this.Ae.defaults, options)
+  const opt = { ...this.Ae.defaults, ...options }
   const callerId = await this.address(opt)
 
-  const oracleRespondTx = await this.oracleRespondTx(R.merge(opt, {
+  const oracleRespondTx = await this.oracleRespondTx({
+    ...opt,
     oracleId,
     queryId,
     callerId,
     response
-  }))
+  })
   return {
     ...await this.send(oracleRespondTx, opt),
     ...await this.getOracleObject(oracleId)

package/src/ae/universal.js

@@ -27,7 +27,7 @@ import Chain from '../chain/node'
 import Aens from './aens'
 import Transaction from '../tx/tx'
 import Oracle from './oracle'
-import GeneralizeAccount from '../contract/ga'
+import GeneralizedAccount from '../contract/ga'
 import AccountMultiple from '../account/multiple'
 import Contract from './contract'
 
@@ -42,4 +42,6 @@ import Contract from './contract'
  * @param {Object} [options={}] - Initializer object
  * @return {Object} Universal instance
  */
-export default Ae.compose(AccountMultiple, Chain, Transaction, Aens, Contract, Oracle, GeneralizeAccount)
+export default Ae.compose(
+  AccountMultiple, Chain, Transaction, Aens, Contract, Oracle, GeneralizedAccount
+)

package/src/ae/wallet.js

@@ -26,7 +26,7 @@ import Ae from './'
 import Chain from '../chain/node'
 import Tx from '../tx/tx'
 import Contract from './contract'
-import GeneralizeAccount from '../contract/ga'
+import GeneralizedAccount from '../contract/ga'
 import WalletRpc from '../utils/aepp-wallet-communication/rpc/wallet-rpc'
 import Oracle from './oracle'
 import Aens from './aens'
@@ -47,4 +47,4 @@ import Aens from './aens'
   address: keypair.publicKey,
 })
  */
-export default Ae.compose(WalletRpc, Tx, Contract, Oracle, Aens, GeneralizeAccount, Chain)
+export default Ae.compose(WalletRpc, Tx, Contract, Oracle, Aens, GeneralizedAccount, Chain)