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

package/src/ae/oracle.js

@@ -27,10 +27,9 @@
  */
 
 import Ae from './'
-import * as R from 'ramda'
-import { decodeBase64Check, assertedType } from '../utils/crypto'
+import { decodeBase64Check } from '../utils/crypto'
 import { pause } from '../utils/other'
-import { oracleQueryId } from '../tx/builder/helpers'
+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'
 
@@ -121,9 +120,9 @@ export async function pollForQueryResponse (oracleId, queryId, { attempts = 20,
   for (let i = 0; i < attempts; i++) {
     if (i) await pause(interval)
     const { response } = await this.api.getOracleQueryByPubkeyAndQueryId(oracleId, queryId)
-    const responseBuffer = decodeBase64Check(assertedType(response, 'or'))
+    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`)
@@ -146,14 +145,15 @@ export async function pollForQueryResponse (oracleId, queryId, { attempts = 20,
  * @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 +177,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 +208,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 +239,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/chain/index.js

@@ -37,8 +37,7 @@ import { required } from '@stamp/required'
  * @return {Object} Chain instance
  */
 const Chain = stampit({
-  deepProps: { Ae: { defaults: { waitMined: true } } },
-  statics: { waitMined (bool) { return this.deepProps({ Ae: { defaults: { waitMined: bool } } }) } }
+  deepProps: { Ae: { defaults: { waitMined: true, verify: true } } }
 }, required({
   methods: {
     sendTransaction: required,
@@ -56,15 +55,6 @@ const Chain = stampit({
   }
 }))
 
-/**
- * Reconfigure Stamp to (not) wait until transactions are mined
- * @function waitMined
- * @static
- * @rtype (bool: Boolean) => Stamp
- * @param {boolean} bool - Whether to wait for transactions
- * @return {Stamp} Reconfigured Chain Stamp
- */
-
 /**
  * Submit a signed transaction for mining
  * @function sendTransaction
@@ -74,7 +64,7 @@ const Chain = stampit({
  * @rtype (tx: String, options?: Object) => tx: Promise[Object]|txHash: Promise[String]
  * @param {String} tx - Transaction to submit
  * @param {String} [options={}] - Options to pass to the implementation
- * @param {String} [options.verify = false] - Verify transaction before broadcast.
+ * @param {String} [options.verify=true] - Verify transaction before broadcast.
  * @return {Object} Transaction
  */
 

package/src/chain/node.js

@@ -14,15 +14,12 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import * as R from 'ramda'
-
 import Chain from './'
 import { AE_AMOUNT_FORMATS, formatAmount } from '../utils/amount-formatter'
-import TransactionValidator from '../tx/validator'
+import verifyTransaction from '../tx/validator'
 import NodePool from '../node-pool'
-import { assertedType } from '../utils/crypto'
 import { pause } from '../utils/other'
-import { isNameValid, produceNameId } from '../tx/builder/helpers'
+import { isNameValid, produceNameId, decode } from '../tx/builder/helpers'
 import { DRY_RUN_ACCOUNT, NAME_ID_KEY } from '../tx/builder/schema'
 
 /**
@@ -35,15 +32,16 @@ import { DRY_RUN_ACCOUNT, NAME_ID_KEY } from '../tx/builder/schema'
  */
 
 async function sendTransaction (tx, options = {}) {
-  const { waitMined, verify } = R.merge(this.Ae.defaults, options)
-  // Verify transaction before broadcast
-  if (verify || (typeof verify !== 'boolean' && this.verifyTxBeforeSend)) {
-    const { validation, tx: txObject, txType } = await this.unpackAndVerify(tx)
+  const { waitMined, verify } = { ...this.Ae.defaults, ...options }
+  if (verify) {
+    const validation = await verifyTransaction(tx, this.selectedNode.instance)
     if (validation.length) {
-      throw Object.assign(new Error('Transaction verification error: ' + JSON.stringify(validation)), {
+      const message = 'Transaction verification errors: ' +
+        validation.map(v => v.message).join(', ')
+      throw Object.assign(new Error(message), {
         code: 'TX_VERIFICATION_ERROR',
-        errorData: { validation, tx: txObject, txType },
-        txHash: tx
+        validation,
+        transaction: tx
       })
     }
   }
@@ -61,7 +59,7 @@ async function sendTransaction (tx, options = {}) {
     }
     return { hash: txHash, rawTx: tx }
   } catch (error) {
-    throw Object.assign(error, { rawTx: tx, verifyTx: () => this.unpackAndVerify(tx) })
+    throw Object.assign(error, { rawTx: tx, verifyTx: () => verifyTransaction(tx, this.selectedNode.instance) })
   }
 }
 
@@ -140,7 +138,7 @@ async function topBlock () {
   return this.api.getTopHeader()
 }
 
-async function poll (th, { blocks = 10, interval = 5000, allowUnsynced = false } = {}) {
+async function poll (th, { blocks = 10, interval = 500, allowUnsynced = false } = {}) {
   const max = await this.height() + blocks
   do {
     const tx = await this.tx(th).catch(_ => null)
@@ -221,31 +219,33 @@ async function getName (name) {
  * @param {String} nameOrId
  * @param {String} prefix
  * @param {Object} [options]
- * @param {Boolean} [options.verify] Enables resolving by node, needed for compatibility with `verify` option of other methods
- * @param {Boolean} [options.resolveByNode] Enables pointer resolving using node (isn't more durable to resolve it on the node side?)
+ * @param {Boolean} [options.verify] To ensure that name exist and have a corresponding pointer
+ * @param {Boolean} [options.resolveByNode] Enables pointer resolving using node // TODO: avoid that to don't trust to current api gateway
  * @return {String} Address or AENS name hash
  */
 async function resolveName (nameOrId, prefix, { verify, resolveByNode } = {}) {
   if (!nameOrId || typeof nameOrId !== 'string') {
-    throw new Error('Invalid name or address. Should be a string')
+    throw new Error(`Name or address should be a string: ${nameOrId}`)
   }
   const prefixes = Object.keys(NAME_ID_KEY)
   if (!prefixes.includes(prefix)) {
-    throw new Error(`Invalid prefix ${prefix}. Should be one of [${prefixes}]`)
+    throw new Error(`Invalid prefix ${prefix}, should be one of [${prefixes}]`)
   }
-  if (assertedType(nameOrId, prefix, true)) return nameOrId
-
+  try {
+    decode(nameOrId, prefix)
+    return nameOrId
+  } catch (error) {}
   if (isNameValid(nameOrId)) {
-    if (resolveByNode || verify) {
+    if (verify || resolveByNode) {
       const name = await this.getName(nameOrId).catch(_ => null)
-      if (!name) throw new Error('Name not found')
+      if (!name) throw new Error(`Name not found: ${nameOrId}`)
       const pointer = name.pointers.find(({ id }) => id.split('_')[0] === prefix)
-      if (!pointer) throw new Error(`Name ${nameOrId} do not have pointers for ${prefix}`)
-      return pointer.id
+      if (!pointer) throw new Error(`Name ${nameOrId} don't have pointers for ${prefix}`)
+      if (resolveByNode) return pointer.id
     }
     return produceNameId(nameOrId)
   }
-  throw new Error('Invalid name or address')
+  throw new Error(`Invalid name or address: ${nameOrId}`)
 }
 
 /**
@@ -260,10 +260,7 @@ async function resolveName (nameOrId, prefix, { verify, resolveByNode } = {}) {
  * @return {Object} ChainNode instance
  * @example ChainNode({url: 'https://testnet.aeternity.io/'})
  */
-const ChainNode = Chain.compose(TransactionValidator, NodePool, {
-  init ({ verifyTx = true }) {
-    this.verifyTxBeforeSend = verifyTx
-  },
+const ChainNode = Chain.compose(NodePool, {
   methods: {
     sendTransaction,
     balance,

package/src/channel/handlers.js

@@ -603,7 +603,6 @@ export async function awaitingCallContractForceProgressUpdate (channel, message,
 }
 
 export function awaitingForceProgressCompletion (channel, message, state) {
-  console.log('From force progress await completion ->', message)
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
       state.onOnChainTx(message.params.data)

package/src/channel/index.js

@@ -39,7 +39,6 @@ import {
   disconnect as channelDisconnect,
   fsmId as channelFsmId
 } from './internal'
-import * as R from 'ramda'
 
 function snakeToPascalObjKeys (obj) {
   return Object.entries(obj).reduce((result, [key, val]) => ({
@@ -238,10 +237,10 @@ async function poi ({ accounts, contracts }) {
  * )
  */
 async function balances (accounts) {
-  return R.reduce((acc, item) => ({
-    ...acc,
-    [item.account]: item.balance
-  }), {}, await call(this, 'channels.get.balances', { accounts }))
+  return Object.fromEntries(
+    (await call(this, 'channels.get.balances', { accounts }))
+      .map(item => [item.account, item.balance])
+  )
 }
 
 /**