@aeternity/aepp-sdk 8.2.1 → 10.0.0

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
  */
 
@@ -123,8 +113,10 @@ const Chain = stampit({
  * @rtype (address: String, options?: Object) => balance: Number
  * @param {String} address - The public account address to obtain the balance for
  * @param {Object} [options={}] - Options
- * @param {Number} options.height - The chain height at which to obtain the balance for (default: top of chain)
- * @param {String} options.hash - The block hash on which to obtain the balance for (default: top of chain)
+ * @param {Number} options.height - The chain height at which to obtain the balance for (default:
+ * top of chain)
+ * @param {String} options.hash - The block hash on which to obtain the balance for (default: top
+ * of chain)
  * @return {Object} The transaction as it was mined
  */
 
@@ -136,7 +128,8 @@ const Chain = stampit({
  * @category async
  * @rtype (hash: String, info = false) => tx: Object
  * @param {String} hash - Transaction hash
- * @param {Boolean} info - Retrieve additional transaction date. Works only for (ContractCreate and ContractCall transaction's)
+ * @param {Boolean} info - Retrieve additional transaction date. Works only for (ContractCreate and
+ * ContractCall transaction's)
  * @return {Object} Transaction
  */
 
@@ -249,7 +242,8 @@ const Chain = stampit({
  * @param {String} tx - transaction to execute
  * @param {String} accountAddress - address that will be used to execute transaction
  * @param {String|Number} [options.top] - hash of block on which to make dry-run
- * @param {Boolean} [options.txEvents] - collect and return on-chain tx events that would result from the call
+ * @param {Boolean} [options.txEvents] - collect and return on-chain tx events that would result
+ * from the call
  * @return {Object} Result
  */
 

package/src/chain/node.js

@@ -14,16 +14,13 @@
  *  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 { DRY_RUN_ACCOUNT, NAME_ID_KEY } from '../tx/builder/schema'
+import { isNameValid, produceNameId, decode } from '../tx/builder/helpers'
+import { DRY_RUN_ACCOUNT } from '../tx/builder/schema'
 
 /**
  * ChainNode module
@@ -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,10 @@ 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 +141,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)
@@ -219,40 +220,42 @@ async function getName (name) {
 /**
  * Resolve AENS name and return name hash
  * @param {String} nameOrId
- * @param {String} prefix
+ * @param {String} key in AENS pointers record
  * @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
+ * // TODO: avoid that to don't trust to current api gateway
+ * @param {Boolean} [options.resolveByNode] Enables pointer resolving using node
  * @return {String} Address or AENS name hash
  */
-async function resolveName (nameOrId, prefix, { verify, resolveByNode } = {}) {
+async function resolveName (nameOrId, key, { verify, resolveByNode } = {}) {
   if (!nameOrId || typeof nameOrId !== 'string') {
-    throw new Error('Invalid name or address. Should be a string')
-  }
-  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(`Name or address should be a string: ${nameOrId}`)
   }
-  if (assertedType(nameOrId, prefix, true)) return nameOrId
-
+  try {
+    decode(nameOrId)
+    return nameOrId
+  } catch (error) {}
   if (isNameValid(nameOrId)) {
-    if (resolveByNode || verify) {
-      const name = await this.getName(nameOrId).catch(_ => null)
-      if (!name) throw new Error('Name not found')
-      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 (verify || resolveByNode) {
+      const name = await this.api.getNameEntryByName(nameOrId).catch(_ => null)
+      if (!name) throw new Error(`Name not found: ${nameOrId}`)
+      const pointer = name.pointers.find(pointer => pointer.key === key)
+      if (!pointer) {
+        throw new Error(`Name ${nameOrId} don't have pointers for ${key}`)
+      }
+      if (resolveByNode) return pointer.id
     }
     return produceNameId(nameOrId)
   }
-  throw new Error('Invalid name or address')
+  throw new Error(`Invalid name or address: ${nameOrId}`)
 }
 
 /**
  * ChainNode Stamp
  *
  * This is implementation of {@link module:@aeternity/aepp-sdk/es/chain--Chain}
- * composed with {@link module:@aeternity/aepp-sdk/es/contract/node--ContractNodeAPI} and {@link module:@aeternity/aepp-sdk/es/oracle/node--OracleNodeAPI}
+ * composed with {@link module:@aeternity/aepp-sdk/es/contract/node--ContractNodeAPI} and
+ * {@link module:@aeternity/aepp-sdk/es/oracle/node--OracleNodeAPI}
  * @function
  * @alias module:@aeternity/aepp-sdk/es/chain/node
  * @rtype Stamp
@@ -260,10 +263,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

@@ -102,7 +102,9 @@ export async function awaitingChannelCreateTx (channel, message, state) {
       send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { tx: signedTx } })
       return { handler: awaitingOnChainTx }
     }
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => options.get(channel).sign(tag, tx))
+    const signedTx = await appendSignature(
+      message.params.data.signed_tx, tx => options.get(channel).sign(tag, tx)
+    )
     send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { signed_tx: signedTx } })
     return { handler: awaitingOnChainTx }
   }
@@ -574,11 +576,16 @@ export function awaitingNewContractCompletion (channel, message, state) {
 export async function awaitingCallContractUpdateTx (channel, message, state) {
   if (message.method === 'channels.sign.update') {
     if (message.params.data.tx) {
-      const signedTx = await state.sign(message.params.data.tx, { updates: message.params.data.updates })
+      const signedTx = await state.sign(
+        message.params.data.tx, { updates: message.params.data.updates }
+      )
       send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
       return { handler: awaitingCallContractCompletion, state }
     }
-    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx, { updates: message.params.data.updates }))
+    const signedTx = await appendSignature(
+      message.params.data.signed_tx,
+      tx => state.sign(tx, { updates: message.params.data.updates })
+    )
     if (typeof signedTx === 'string') {
       send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
       return { handler: awaitingCallContractCompletion, state }
@@ -603,7 +610,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])
+  )
 }
 
 /**
@@ -339,7 +338,8 @@ function shutdown (sign) {
  * @param {Number} amount - Amount of tokens to withdraw
  * @param {Function} sign - Function which verifies and signs withdraw transaction
  * @param {Object} [callbacks]
- * @param {Function} [callbacks.onOnChainTx] - Called when withdraw transaction has been posted on chain
+ * @param {Function} [callbacks.onOnChainTx] - Called when withdraw transaction has been posted
+ * on chain
  * @param {Function} [callbacks.onOwnWithdrawLocked]
  * @param {Function} [callbacks.onWithdrawLocked]
  * @return {Promise<Object>}
@@ -408,7 +408,8 @@ function withdraw (amount, sign, { onOnChainTx, onOwnWithdrawLocked, onWithdrawL
  * @param {Number} amount - Amount of tokens to deposit
  * @param {Function} sign - Function which verifies and signs deposit transaction
  * @param {Object} [callbacks]
- * @param {Function} [callbacks.onOnChainTx] - Called when deposit transaction has been posted on chain
+ * @param {Function} [callbacks.onOnChainTx] - Called when deposit transaction has been posted
+ * on chain
  * @param {Function} [callbacks.onOwnDepositLocked]
  * @param {Function} [callbacks.onDepositLocked]
  * @return {Promise<Object>}
@@ -598,7 +599,11 @@ function callContract ({ amount, callData, contract, abiVersion }, sign) {
  *   }
  * })
  */
-function forceProgress ({ amount, callData, contract, abiVersion, gas = 1000000, gasPrice = 1000000000, nonce }, sign, { onOnChainTx } = {}) {
+function forceProgress (
+  { amount, callData, contract, abiVersion, gas = 1000000, gasPrice = 1000000000, nonce },
+  sign,
+  { onOnChainTx } = {}
+) {
   return new Promise((resolve, reject) => {
     enqueueAction(
       this,
@@ -801,23 +806,42 @@ async function reconnect (options, txParams) {
  * @param {String} options.initiatorId - Initiator's public key
  * @param {String} options.responderId - Responder's public key
  * @param {Number} options.pushAmount - Initial deposit in favour of the responder by the initiator
- * @param {Number} options.initiatorAmount - Amount of tokens the initiator has committed to the channel
- * @param {Number} options.responderAmount - Amount of tokens the responder has committed to the channel
+ * @param {Number} options.initiatorAmount - Amount of tokens the initiator has committed to
+ * the channel
+ * @param {Number} options.responderAmount - Amount of tokens the responder has committed to
+ * the channel
  * @param {Number} options.channelReserve - The minimum amount both peers need to maintain
  * @param {Number} [options.ttl] - Minimum block height to include the channel_create_tx
  * @param {String} options.host - Host of the responder's node
  * @param {Number} options.port - The port of the responders node
  * @param {Number} options.lockPeriod - Amount of blocks for disputing a solo close
- * @param {Number} [options.existingChannelId] - Existing channel id (required if reestablishing a channel)
- * @param {Number} [options.offchainTx] - Offchain transaction (required if reestablishing a channel)
- * @param {Number} [options.timeoutIdle] - The time waiting for a new event to be initiated (default: 600000)
- * @param {Number} [options.timeoutFundingCreate] - The time waiting for the initiator to produce the create channel transaction after the noise session had been established (default: 120000)
- * @param {Number} [options.timeoutFundingSign] - The time frame the other client has to sign an off-chain update after our client had initiated and signed it. This applies only for double signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc. (default: 120000)
- * @param {Number} [options.timeoutFundingLock] - The time frame the other client has to confirm an on-chain transaction reaching maturity (passing minimum depth) after the local node has detected this. This applies only for double signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc. (default: 360000)
- * @param {Number} [options.timeoutSign] - The time frame the client has to return a signed off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
- * @param {Number} [options.timeoutAccept] - The time frame the other client has to react to an event. This applies for all off-chain updates that are not meant to land on-chain, as well as some special cases: opening a noise connection, mutual closing acknowledgement and reestablishing an existing channel (default: 120000)
- * @param {Number} [options.timeoutInitialized] - the time frame the responder has to accept an incoming noise session. Applicable only for initiator (default: timeout_accept's value)
- * @param {Number} [options.timeoutAwaitingOpen] - The time frame the initiator has to start an outgoing noise session to the responder's node. Applicable only for responder (default: timeout_idle's value)
+ * @param {Number} [options.existingChannelId] - Existing channel id (required if reestablishing a
+ * channel)
+ * @param {Number} [options.offchainTx] - Offchain transaction (required if reestablishing
+ * a channel)
+ * @param {Number} [options.timeoutIdle] - The time waiting for a new event to be initiated
+ * (default: 600000)
+ * @param {Number} [options.timeoutFundingCreate] - The time waiting for the initiator to produce
+ * the create channel transaction after the noise session had been established (default: 120000)
+ * @param {Number} [options.timeoutFundingSign] - The time frame the other client has to sign an
+ * off-chain update after our client had initiated and signed it. This applies only for double
+ * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+ * (default: 120000)
+ * @param {Number} [options.timeoutFundingLock] - The time frame the other client has to confirm an
+ * on-chain transaction reaching maturity (passing minimum depth) after the local node has detected
+ * this. This applies only for double signed on-chain intended updates: channel create transaction,
+ * deposit, withdrawal and etc. (default: 360000)
+ * @param {Number} [options.timeoutSign] - The time frame the client has to return a signed
+ * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
+ * @param {Number} [options.timeoutAccept] - The time frame the other client has to react to an
+ * event. This applies for all off-chain updates that are not meant to land on-chain, as well as
+ * some special cases: opening a noise connection, mutual closing acknowledgement and
+ * reestablishing an existing channel (default: 120000)
+ * @param {Number} [options.timeoutInitialized] - the time frame the responder has to accept an
+ * incoming noise session. Applicable only for initiator (default: timeout_accept's value)
+ * @param {Number} [options.timeoutAwaitingOpen] - The time frame the initiator has to start an
+ * outgoing noise session to the responder's node. Applicable only for responder (default:
+ * timeout_idle's value)
  * @param {Number} [options.debug=false] - Log websocket communication
  * @param {Function} options.sign - Function which verifies and signs transactions
  * @return {Promise<Object>} Channel instance