@aeternity/aepp-sdk 10.0.0 → 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,129 +27,11 @@
  */
 
 import Ae from './'
-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, GAS, MIN_GAS_PRICE } from '../tx/builder/schema'
+import { AMOUNT, MIN_GAS_PRICE } from '../tx/builder/schema'
 import { decode, produceNameId } from '../tx/builder/helpers'
 
-/**
- * Static contract call(using dry-run)
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @deprecated
- * @param {String} source Contract source code
- * @param {String} contractAddress Contract address
- * @param {String} name Name of function to call
- * @param {Array} args Arguments array 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, contractAddress, name, args = [], options) {
-  const contract = await this.getContractInstance({ ...options, source, contractAddress })
-  return contract.call(name, args, { ...options, callStatic: true })
-}
-
-/**
- * Call contract function
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @deprecated
- * @param {String} source Contract source code
- * @param {String} contractAddress Contract address or AENS name
- * @param {String} name Name of function to call
- * @param {Array} args Arguments array for call/deploy transaction
- * @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, contractAddress, name, args, options) {
-  const contract = await this.getContractInstance({ ...options, source, contractAddress })
-  return contract.call(name, args, options)
-}
-
-/**
- * Deploy contract to the node
- * @function
- * @alias module:@aeternity/aepp-sdk/es/ae/contract
- * @category async
- * @deprecated
- * @param {String} code Compiled contract
- * @param {String} source Contract source code
- * @param {Array} params 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
- * @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, params, options) {
-  const contract = await this.getContractInstance({ ...options, source })
-  contract.bytecode = code
-  return contract.deploy(params, options)
-}
-
-/**
- * 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
- * @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.contractEncodeCallDataAPI(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
  * @function
@@ -164,7 +46,6 @@ async function delegateSignatureCommon (ids = [], opt = {}) {
   const signature = await 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))
     ]),
     opt
@@ -183,13 +64,13 @@ 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(
@@ -197,7 +78,10 @@ async function delegateSignatureCommon (ids = [], opt = {}) {
  * )
  */
 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
+  )
 }
 
 /**
@@ -210,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 })
@@ -236,31 +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,
     // Delegation for contract
     delegateSignatureCommon,
     // AENS
@@ -271,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

@@ -29,6 +29,7 @@ import AccountBase from '../account/base'
 import TxBuilder from '../tx/builder'
 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
@@ -94,7 +95,7 @@ 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, 'account_pubkey', opt)

package/src/ae/oracle.js

@@ -27,11 +27,11 @@
  */
 
 import Ae from './'
-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)
@@ -67,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 || [])
@@ -76,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 }
 }
 
 /**
@@ -95,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)
   }
 }
 
@@ -119,7 +134,7 @@ async function getQueryObject (oracleId, queryId) {
 export async function pollForQueryResponse (
   oracleId,
   queryId,
-  { attempts = 20, interval = 5000 } = {}
+  { attempts = 20, interval = this._getPollInterval('microblock') } = {}
 ) {
   for (let i = 0; i < attempts; i++) {
     if (i) await pause(interval)
@@ -129,7 +144,7 @@ export async function pollForQueryResponse (
       return String(responseBuffer)
     }
   }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms`)
+  throw new RequestTimedOutError((attempts - 1) * interval)
 }
 
 /**

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'
 
@@ -43,5 +43,5 @@ import Contract from './contract'
  * @return {Object} Universal instance
  */
 export default Ae.compose(
-  AccountMultiple, Chain, Transaction, Aens, Contract, Oracle, GeneralizeAccount
+  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)

package/src/chain/index.js

@@ -37,13 +37,32 @@ import { required } from '@stamp/required'
  * @return {Object} Chain instance
  */
 const Chain = stampit({
-  deepProps: { Ae: { defaults: { waitMined: true, verify: true } } }
+  deepProps: {
+    Ae: {
+      defaults: {
+        waitMined: true,
+        verify: true,
+        _expectedMineRate: 180000,
+        _microBlockCycle: 3000,
+        _maxPollInterval: 5000
+      }
+    }
+  },
+  methods: {
+    _getPollInterval (type) {
+      const base = {
+        block: this.Ae.defaults._expectedMineRate,
+        microblock: this.Ae.defaults._microBlockCycle
+      }[type]
+      if (!base) throw new Error(`Unknown poll type: ${type}`)
+      return Math.min(base / 3, this.Ae.defaults._maxPollInterval)
+    }
+  }
 }, required({
   methods: {
     sendTransaction: required,
     height: required,
     awaitHeight: required,
-    topBlock: required,
     poll: required,
     balance: required,
     getBalance: required,

package/src/chain/node.js

@@ -21,6 +21,16 @@ import NodePool from '../node-pool'
 import { pause } from '../utils/other'
 import { isNameValid, produceNameId, decode } from '../tx/builder/helpers'
 import { DRY_RUN_ACCOUNT } from '../tx/builder/schema'
+import {
+  AensPointerContextError,
+  DryRunError,
+  InvalidAensNameError,
+  InvalidTxError,
+  RequestTimedOutError,
+  TxTimedOutError,
+  TxNotInChainError,
+  ArgumentError
+} from '../utils/errors'
 
 /**
  * ChainNode module
@@ -32,13 +42,13 @@ import { DRY_RUN_ACCOUNT } from '../tx/builder/schema'
  */
 
 async function sendTransaction (tx, options = {}) {
-  const { waitMined, verify } = { ...this.Ae.defaults, ...options }
-  if (verify) {
+  const opt = { ...this.Ae.defaults, ...options }
+  if (opt.verify) {
     const validation = await verifyTransaction(tx, this.selectedNode.instance)
     if (validation.length) {
       const message = 'Transaction verification errors: ' +
         validation.map(v => v.message).join(', ')
-      throw Object.assign(new Error(message), {
+      throw Object.assign(new InvalidTxError(message), {
         code: 'TX_VERIFICATION_ERROR',
         validation,
         transaction: tx
@@ -47,9 +57,11 @@ async function sendTransaction (tx, options = {}) {
   }
 
   try {
-    const { txHash } = await this.api.postTransaction({ tx })
+    const { txHash } = await this.api.postTransaction({ tx }, {
+      __queue: `tx-${await this.address?.(options).catch(() => '')}`
+    })
 
-    if (waitMined) {
+    if (opt.waitMined) {
       const txData = { ...await this.poll(txHash, options), rawTx: tx }
       // wait for transaction confirmation
       if (options.confirm) {
@@ -68,12 +80,12 @@ async function sendTransaction (tx, options = {}) {
 
 async function waitForTxConfirm (txHash, options = { confirm: 3 }) {
   options.confirm = options.confirm === true ? 3 : options.confirm
-  const { blockHeight } = await this.tx(txHash)
+  const { blockHeight } = await this.api.getTransactionByHash(txHash)
   const height = await this.awaitHeight(blockHeight + options.confirm, options)
-  const { blockHeight: newBlockHeight } = await this.tx(txHash)
+  const { blockHeight: newBlockHeight } = await this.api.getTransactionByHash(txHash)
   switch (newBlockHeight) {
     case -1:
-      throw new Error(`Transaction ${txHash} is removed from chain`)
+      throw new TxNotInChainError(txHash)
     case blockHeight:
       return height
     default:
@@ -103,6 +115,9 @@ async function getBalance (address, { height, hash, format = AE_AMOUNT_FORMATS.A
   return formatAmount(balance, { targetDenomination: format }).toString()
 }
 
+/**
+ * @deprecated use `sdk.api.getTransactionByHash/getTransactionInfoByHash` instead
+ */
 async function tx (hash, info = true) {
   const tx = await this.api.getTransactionByHash(hash)
   if (['ContractCreateTx', 'ContractCallTx', 'ChannelForceProgressTx'].includes(tx.tx.type) && info && tx.blockHeight !== -1) {
@@ -114,45 +129,36 @@ async function tx (hash, info = true) {
 }
 
 async function height () {
-  try {
-    if (!this._heightPromise) {
-      this._heightPromise = this.api.getCurrentKeyBlockHeight()
-    }
-    return (await this._heightPromise).height
-  } finally {
-    delete this._heightPromise
-  }
+  return (await this.api.getCurrentKeyBlockHeight()).height
 }
 
-async function awaitHeight (height, { interval = 5000, attempts = 20 } = {}) {
+async function awaitHeight (
+  height,
+  { interval = this._getPollInterval('block'), attempts = 20 } = {}
+) {
   let currentHeight
   for (let i = 0; i < attempts; i++) {
     if (i) await pause(interval)
     currentHeight = await this.height()
     if (currentHeight >= height) return currentHeight
   }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms, current height: ${currentHeight}, desired height: ${height}`)
-}
-
-/**
- * @deprecated
- */
-async function topBlock () {
-  return this.api.getTopHeader()
+  throw new RequestTimedOutError((attempts - 1) * interval, currentHeight, height)
 }
 
-async function poll (th, { blocks = 10, interval = 500, allowUnsynced = false } = {}) {
+async function poll (th, { blocks = 10, interval = this._getPollInterval('microblock') } = {}) {
   const max = await this.height() + blocks
   do {
-    const tx = await this.tx(th).catch(_ => null)
-    if (tx && (tx.blockHeight !== -1 || (allowUnsynced && tx.height))) {
-      return tx
-    }
+    const tx = await this.api.getTransactionByHash(th)
+    if (tx.blockHeight !== -1) return tx
     await pause(interval)
   } while (await this.height() < max)
-  throw new Error(`Giving up after ${blocks} blocks mined, transaction hash: ${th}`)
+  const status = this.api.getCheckTxInPool && (await this.api.getCheckTxInPool(th)).status
+  throw new TxTimedOutError(blocks, th, status)
 }
 
+/**
+ * @deprecated use `sdk.api.getTransactionInfoByHash` instead
+ */
 async function getTxInfo (hash) {
   const result = await this.api.getTransactionInfoByHash(hash)
   return result.callInfo || result
@@ -169,7 +175,7 @@ async function getCurrentGeneration () {
 async function getGeneration (hashOrHeight) {
   if (typeof hashOrHeight === 'string') return this.api.getGenerationByHash(hashOrHeight)
   if (typeof hashOrHeight === 'number') return this.api.getGenerationByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
+  throw new ArgumentError('hashOrHeight', 'a string or number', hashOrHeight)
 }
 
 async function getMicroBlockTransactions (hash) {
@@ -179,30 +185,53 @@ async function getMicroBlockTransactions (hash) {
 async function getKeyBlock (hashOrHeight) {
   if (typeof hashOrHeight === 'string') return this.api.getKeyBlockByHash(hashOrHeight)
   if (typeof hashOrHeight === 'number') return this.api.getKeyBlockByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
+  throw new ArgumentError('hashOrHeight', 'a string or number', hashOrHeight)
 }
 
 async function getMicroBlockHeader (hash) {
   return this.api.getMicroBlockHeaderByHash(hash)
 }
 
-async function txDryRun (tx, accountAddress, options) {
-  const { results: [{ result, reason, ...resultPayload }], ...other } =
-    await this.api.protectedDryRunTxs({
-      ...options,
-      txs: [{ tx }],
-      accounts: [{
-        pubKey: accountAddress,
-        amount: DRY_RUN_ACCOUNT.amount
-      }]
+async function txDryRunHandler (key) {
+  const rs = this._txDryRun[key]
+  delete this._txDryRun[key]
+
+  let dryRunRes
+  try {
+    dryRunRes = await this.api.protectedDryRunTxs({
+      top: rs[0].top,
+      txEvents: rs[0].txEvents,
+      txs: rs.map(req => ({ tx: req.tx })),
+      accounts: Array.from(new Set(rs.map(req => req.accountAddress)))
+        .map(pubKey => ({ pubKey, amount: DRY_RUN_ACCOUNT.amount }))
     })
+  } catch (error) {
+    rs.forEach(({ reject }) => reject(error))
+    return
+  }
 
-  if (result === 'ok') return { ...resultPayload, ...other }
+  const { results, txEvents } = dryRunRes
+  results.forEach(({ result, reason, ...resultPayload }, idx) => {
+    const { resolve, reject, tx, options, accountAddress } = rs[idx]
+    if (result === 'ok') return resolve({ ...resultPayload, txEvents })
+    reject(Object.assign(
+      new DryRunError(reason), { tx, accountAddress, options }
+    ))
+  })
+}
 
-  throw Object.assign(
-    new Error('Dry run error, ' + reason),
-    { tx, accountAddress, options }
-  )
+async function txDryRun (tx, accountAddress, { top, txEvents, combine }) {
+  const key = combine ? [top, txEvents].join() : 'immediate'
+  this._txDryRun ??= {}
+  this._txDryRun[key] ??= []
+  return new Promise((resolve, reject) => {
+    this._txDryRun[key].push({ tx, accountAddress, top, txEvents, resolve, reject })
+    if (!combine) {
+      txDryRunHandler.call(this, key)
+      return
+    }
+    this._txDryRun[key].timeout ??= setTimeout(txDryRunHandler.bind(this, key))
+  })
 }
 
 async function getContractByteCode (contractId) {
@@ -229,7 +258,7 @@ async function getName (name) {
  */
 async function resolveName (nameOrId, key, { verify, resolveByNode } = {}) {
   if (!nameOrId || typeof nameOrId !== 'string') {
-    throw new Error(`Name or address should be a string: ${nameOrId}`)
+    throw new InvalidAensNameError(`Name or address should be a string: ${nameOrId}`)
   }
   try {
     decode(nameOrId)
@@ -237,17 +266,16 @@ async function resolveName (nameOrId, key, { verify, resolveByNode } = {}) {
   } catch (error) {}
   if (isNameValid(nameOrId)) {
     if (verify || resolveByNode) {
-      const name = await this.api.getNameEntryByName(nameOrId).catch(_ => null)
-      if (!name) throw new Error(`Name not found: ${nameOrId}`)
+      const name = await this.api.getNameEntryByName(nameOrId)
       const pointer = name.pointers.find(pointer => pointer.key === key)
       if (!pointer) {
-        throw new Error(`Name ${nameOrId} don't have pointers for ${key}`)
+        throw new AensPointerContextError(`Name ${nameOrId} don't have pointers for ${key}`)
       }
       if (resolveByNode) return pointer.id
     }
     return produceNameId(nameOrId)
   }
-  throw new Error(`Invalid name or address: ${nameOrId}`)
+  throw new InvalidAensNameError(`Invalid name or address: ${nameOrId}`)
 }
 
 /**
@@ -269,7 +297,6 @@ const ChainNode = Chain.compose(NodePool, {
     balance,
     getBalance,
     getAccount,
-    topBlock,
     tx,
     height,
     awaitHeight,