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

package/src/ae/aens.js

@@ -27,16 +27,10 @@
  */
 
 import { salt } from '../utils/crypto'
-import {
-  commitmentHash,
-  ensureNameValid,
-  getMinimumNameFee,
-  classify,
-  isAuctionName,
-  validatePointers, encode, produceNameId
-} from '../tx/builder/helpers'
+import { commitmentHash, ensureNameValid, isAuctionName } from '../tx/builder/helpers'
 import Ae from './'
-import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
+import { CLIENT_TTL, NAME_TTL } from '../tx/builder/schema'
+import { ArgumentError } from '../utils/errors'
 
 /**
  * Revoke a name
@@ -46,11 +40,11 @@ import { CLIENT_TTL, NAME_FEE, NAME_TTL } from '../tx/builder/schema'
  * @category async
  * @param {String} name Name hash
  * @param {Object} [options={}] options
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
  * @return {Promise<Object>} Transaction result
  * @example
  * const name = 'test.chain'
@@ -66,7 +60,7 @@ async function revoke (name, options = {}) {
 
   const nameRevokeTx = await this.nameRevokeTx({
     ...opt,
-    nameId: produceNameId(name),
+    nameId: name,
     accountId: await this.address(opt)
   })
 
@@ -80,16 +74,19 @@ async function revoke (name, options = {}) {
  * @category async
  * @alias module:@aeternity/aepp-sdk/es/ae/aens
  * @param {String} name AENS name
- * @param {String[]} pointers Array of name pointers. Can be oracle|account|contract|channel public key
+ * @param {Object.<string, string>} pointers Map of pointer keys to corresponding addresses
  * @param {Object} [options={}]
- * @param {Boolean} [options.extendPointers=false] extendPointers Get the pointers from the node and merge with provided one. Pointers with the same type will be overwrited
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
- * @param {(Number|String|BigNumber)} [options.nameTtl=50000] nameTtl Name ttl represented in number of blocks (Max value is 50000 blocks)
- * @param {(Number|String|BigNumber)} [options.clientTtl=84600] clientTtl a suggestion as to how long any clients should cache this information
+ * @param {Boolean} [options.extendPointers] Get the pointers from the node and merge with provided
+ * ones. Pointers with the same type will be overwritten
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you
+ * pass publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
+ * @param {Number|String|BigNumber} [options.nameTtl=50000] Name ttl represented in number of
+ * blocks (Max value is 50000 blocks)
+ * @param {Number|String|BigNumber} [options.clientTtl=84600] a suggestion as to how long any
+ * clients should cache this information
  * @return {Promise<Object>}
  * @throws Invalid pointer array error
  * @example
@@ -99,22 +96,23 @@ async function revoke (name, options = {}) {
  *
  * await sdkInstance.aensUpdate(name, pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
  * // or
- * await nameObject.update(pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
+ * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
  */
-async function update (name, pointers = [], options = { extendPointers: false }) {
+async function update (name, pointers = {}, options = {}) {
   ensureNameValid(name)
   const opt = { ...this.Ae.defaults, ...options }
-  if (!validatePointers(pointers)) throw new Error('Invalid pointers array')
+  const allPointers = {
+    ...options.extendPointers && Object.fromEntries(
+      (await this.getName(name)).pointers.map(({ key, id }) => [key, id])
+    ),
+    ...pointers
+  }
 
-  pointers = [
-    ...options.extendPointers ? (await this.getName(name)).pointers : [],
-    ...pointers.map(p => Object.fromEntries([['id', p], ['key', classify(p)]]))
-  ].reduce((acc, el) => [...acc.filter(p => p.key !== el.key), el], [])
   const nameUpdateTx = await this.nameUpdateTx({
     ...opt,
-    nameId: produceNameId(name),
+    nameId: name,
     accountId: await this.address(opt),
-    pointers
+    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id }))
   })
 
   return this.send(nameUpdateTx, opt)
@@ -129,11 +127,11 @@ async function update (name, pointers = [], options = { extendPointers: false })
  * @param {String} name AENS name
  * @param {String} account Recipient account publick key
  * @param {Object} [options={}]
- * @param {(String|Object)} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
- * @param {(Number|String|BigNumber)} [options.fee] fee
- * @param {(Number|String|BigNumber)} [options.ttl] ttl
- * @param {(Number|String|BigNumber)} [options.nonce] nonce
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {Number|String|BigNumber} [options.fee] fee
+ * @param {Number|String|BigNumber} [options.ttl] ttl
+ * @param {Number|String|BigNumber} [options.nonce] nonce
  * @return {Promise<Object>} Transaction result
  * @example
  * const name = 'test.chain'
@@ -150,7 +148,7 @@ async function transfer (name, account, options = {}) {
 
   const nameTransferTx = await this.nameTransferTx({
     ...opt,
-    nameId: produceNameId(name),
+    nameId: name,
     accountId: await this.address(opt),
     recipientId: account
   })
@@ -186,7 +184,7 @@ async function query (name, opt = {}) {
 
   return Object.freeze(Object.assign(o, {
     pointers: o.pointers || [],
-    update: async (pointers = [], options = {}) => {
+    update: async (pointers, options = {}) => {
       return {
         ...(await this.aensUpdate(name, pointers, { ...opt, ...options })),
         ...(await this.aensQuery(name))
@@ -200,11 +198,13 @@ async function query (name, opt = {}) {
     },
     revoke: async (options = {}) => this.aensRevoke(name, { ...opt, ...options }),
     extendTtl: async (nameTtl = NAME_TTL, options = {}) => {
-      if (!nameTtl || typeof nameTtl !== 'number' || nameTtl > NAME_TTL) throw new Error('Ttl must be an number and less then 180000 blocks')
+      if (typeof nameTtl !== 'number' || nameTtl > NAME_TTL || nameTtl <= 0) {
+        throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, nameTtl)
+      }
 
       return {
-        ...(await this.aensUpdate(name, o.pointers.map(p => p.id), { ...opt, ...options, nameTtl })),
-        ...(await this.aensQuery(name))
+        ...await this.aensUpdate(name, {}, { ...opt, ...options, nameTtl, extendPointers: true }),
+        ...await this.aensQuery(name)
       }
     }
   }))
@@ -220,8 +220,8 @@ async function query (name, opt = {}) {
  * @param {String} name
  * @param {Number} salt Salt from pre-claim, or 0 if it's a bid
  * @param {Object} [options] options
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -237,16 +237,11 @@ async function claim (name, salt, options) {
   ensureNameValid(name)
   const opt = { ...this.Ae.defaults, ...options }
 
-  const minNameFee = getMinimumNameFee(name)
-  if (opt.nameFee !== this.Ae.defaults.nameFee && minNameFee.gt(opt.nameFee)) {
-    throw new Error(`the provided fee ${opt.nameFee} is not enough to execute the claim, required: ${minNameFee}`)
-  }
-  opt.nameFee = opt.nameFee !== this.Ae.defaults.nameFee ? opt.nameFee : minNameFee
   const claimTx = await this.nameClaimTx({
     ...opt,
     accountId: await this.address(opt),
     nameSalt: salt,
-    name: encode(name, 'nm')
+    name
   })
 
   const result = await this.send(claimTx, opt)
@@ -265,8 +260,8 @@ async function claim (name, salt, options) {
  * @alias module:@aeternity/aepp-sdk/es/ae/aens
  * @param {String} name
  * @param {Object} [options={}]
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -316,8 +311,8 @@ async function preclaim (name, options = {}) {
  * @param {String} name Domain name
  * @param {String|Number} nameFee Name fee (bid fee)
  * @param {Object} [options={}]
- * @param {String|Object} [options.onAccount] onAccount Make operation on specific account from sdk(you pass publickKey) or
- * using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param {String|Object} [options.onAccount] Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
  * @param {Number|String|BigNumber} [options.fee] fee
  * @param {Number|String|BigNumber} [options.ttl] ttl
  * @param {Number|String|BigNumber} [options.nonce] nonce
@@ -328,7 +323,7 @@ async function preclaim (name, options = {}) {
  *
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  */
-async function bid (name, nameFee = NAME_FEE, options = {}) {
+async function bid (name, nameFee, options = {}) {
   return this.aensClaim(name, 0, { ...options, nameFee, vsn: 2 })
 }
 
@@ -357,8 +352,7 @@ const Aens = Ae.compose({
     Ae: {
       defaults: {
         clientTtl: CLIENT_TTL,
-        nameTtl: NAME_TTL, // aec_governance:name_claim_max_expiration() => 50000
-        nameFee: NAME_FEE
+        nameTtl: NAME_TTL // aec_governance:name_claim_max_expiration() => 50000
       }
     }
   }

package/src/ae/aepp.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
@@ -24,7 +24,7 @@
 
 import Ae from './'
 import Aens from './aens'
-import { ContractWithCompiler as Contract } from './contract'
+import Contract from './contract'
 import AeppRpc from '../utils/aepp-wallet-communication/rpc/aepp-rpc'
 import Chain from '../chain/node'
 import Tx from '../tx/tx'

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,128 +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
- * @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
- * @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
@@ -163,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
@@ -172,7 +54,8 @@ async function delegateSignatureCommon (ids = [], opt = {}) {
 }
 
 /**
- * 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
@@ -181,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
+  )
 }
 
 /**
@@ -206,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 })
@@ -218,7 +106,7 @@ async function createAensDelegationSignature ({ contractId, name }, opt = {}) {
  * const respondSig = await contract.createOracleDelegationSignature(params, queryId)
  */
 async function createOracleDelegationSignature ({ contractId, queryId }, opt = {}) {
-  return this.delegateSignatureCommon([...queryId ? [queryId] : [], contractId], opt)
+  return this.delegateSignatureCommon([queryId ?? await this.address(opt), contractId], opt)
 }
 
 /**
@@ -232,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
@@ -267,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
@@ -37,7 +38,8 @@ 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 = {}) {
@@ -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,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)
   }
 }
 
@@ -116,7 +131,11 @@ 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)
@@ -125,7 +144,7 @@ export async function pollForQueryResponse (oracleId, queryId, { attempts = 20,
       return String(responseBuffer)
     }
   }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms`)
+  throw new RequestTimedOutError((attempts - 1) * interval)
 }
 
 /**
@@ -137,10 +156,10 @@ 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
  */

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
+)