Merge pull request #250 from aeternity/release/2.2.1-next

Pre-Release 2.2.1-next

Author: nduchak

CHANGELOG.md

@@ -2,6 +2,25 @@
 All notable changes to this project will be documented in this file. This change
 log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
 
+## [2.2.1-next]
+### Added
+- Add `deserialization` schema for `Channel` transactions(`channelCreate`, `channelCloseMutual`, `channelDeposit`, `channelWithdraw`, `channelSettle`) 
+- Add `rawTx` and `verifyTx` to error from poll function(when you wait for transaction will mined)
+
+### Changed
+- Change Channel `legacy` API to `JSON RPC`
+- Change `minFee` calculation, multiply min fee by 10^9
+
+### Removed
+- none
+
+### Breaking Changes
+- none
+
+### Notes and known Issues
+- Depend on `bip39` from npm instead of git repo 
+
+
 ## [2.1.1-0.1.0-next]
 ### Added
 - none
@@ -464,3 +483,4 @@ log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
 [2.0.0]: https://github.com/aeternity/aepp-sdk-js/compare/1.3.2...2.0.0
 [2.1.0]: https://github.com/aeternity/aepp-sdk-js/compare/2.0.0...2.1.0
 [2.1.1-0.1.0-next]: https://github.com/aeternity/aepp-sdk-js/compare/2.1.0...2.1.1-0.1.0-next
+[2.2.1-next]: https://github.com/aeternity/aepp-sdk-js/compare/2.1.1-0.1.0-next...2.2.1-next

docker/accounts_test.json

@@ -1,3 +1,3 @@
 {
-  "ak_2a1j2Mk9YSmC1gioUq4PWRm3bsv887MbuRVwyv4KaUGoR1eiKi": 100000000000001000000000000000000
+  "ak_2a1j2Mk9YSmC1gioUq4PWRm3bsv887MbuRVwyv4KaUGoR1eiKi": 100000000000001000000000000000000000
 }

es/chain/node.js

@@ -34,7 +34,7 @@ import TransactionValidator from '../tx/validator'
 async function sendTransaction (tx, options = {}) {
   const { waitMined, verify } = R.merge(this.Chain.defaults, options)
   // Verify transaction before broadcast
-  if (verify) {
+  if (this.verifyTxBeforeSend || verify) {
     const { validation, tx: txObject, txType } = await this.unpackAndVerify(tx)
     if (validation.length) {
       throw Object.assign({
@@ -46,7 +46,7 @@ async function sendTransaction (tx, options = {}) {
   }
 
   const { txHash } = await this.api.postTransaction({ tx })
-  return waitMined ? { ...(await this.poll(txHash, options)), rawTx: tx } : { hash: txHash, rawTx: tx }
+  return waitMined ? { ...(await this.poll(txHash, options, tx)), rawTx: tx } : { hash: txHash, rawTx: tx }
 }
 
 async function balance (address, { height, hash, format = false } = {}) {
@@ -97,7 +97,7 @@ async function topBlock () {
   return top[R.head(R.keys(top))]
 }
 
-async function poll (th, { blocks = 10, interval = 5000 } = {}) {
+async function poll (th, { blocks = 10, interval = 5000 } = {}, raw) {
   const instance = this
   const max = await this.height() + blocks
 
@@ -110,7 +110,12 @@ async function poll (th, { blocks = 10, interval = 5000 } = {}) {
       await pause(interval)
       return probe()
     }
-    throw Error(`Giving up after ${blocks} blocks mined`)
+    throw Object.assign(
+      (new Error(`Giving up after ${blocks} blocks mined.`)),
+      {
+        verifyTx: () => instance.unpackAndVerify(raw)
+      }
+    )
   }
 
   return probe()
@@ -165,6 +170,9 @@ async function txDryRun (txs, accounts, top) {
  * @example ChainNode({url: 'https://sdk-testnet.aepps.com/'})
  */
 const ChainNode = Chain.compose(Node, Oracle, Contract, TransactionValidator, {
+  init ({ verifyTx = false }) {
+    this.verifyTxBeforeSend = verifyTx
+  },
   methods: {
     sendTransaction,
     balance,

es/channel/handlers.js

@@ -26,41 +26,45 @@ import {
 import * as R from 'ramda'
 
 export function awaitingConnection (channel, message, state) {
-  if (message.action === 'info') {
-    if (['channel_accept', 'funding_created'].includes(message.payload.event)) {
+  if (message.method === 'channels.info') {
+    if (['channel_accept', 'funding_created'].includes(message.params.data.event)) {
       changeStatus(channel, {
         channel_accept: 'accepted',
         funding_created: 'halfSigned'
-      }[message.payload.event])
+      }[message.params.data.event])
       return { handler: awaitingChannelCreateTx }
     }
-    if (message.payload.event === 'channel_reestablished') {
+    if (message.params.data.event === 'channel_reestablished') {
       return { handler: awaitingOpenConfirmation }
     }
     return { handler: awaitingConnection }
   }
-  if (message.action === 'error') {
+  if (message.method === 'channels.error') {
     emit(channel, 'error', new Error(message.payload.message))
     return { handler: channelClosed }
   }
 }
 
 export async function awaitingChannelCreateTx (channel, message, state) {
-  if (message.action === 'sign') {
-    const signedTx = await options.get(channel).sign(message.tag, message.payload.tx)
-    send(channel, { action: message.tag, payload: { tx: signedTx } })
+  const tag = {
+    initiator: 'initiator_sign',
+    responder: 'responder_sign'
+  }[options.get(channel).role]
+  if (message.method === `channels.sign.${tag}`) {
+    const signedTx = await options.get(channel).sign(message.tag, message.params.data.tx)
+    send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { tx: signedTx } })
     return { handler: awaitingOnChainTx }
   }
 }
 
 export function awaitingOnChainTx (channel, message, state) {
-  if (message.action === 'on_chain_tx') {
-    emit(channel, 'onChainTx', message.payload.tx)
+  if (message.method === 'channels.on_chain_tx') {
+    emit(channel, 'onChainTx', message.params.data.tx)
     return { handler: awaitingBlockInclusion }
   }
   if (
-    message.action === 'info' &&
-    message.payload.event === 'funding_signed' &&
+    message.method === 'channels.info' &&
+    message.params.data.event === 'funding_signed' &&
     options.get(channel).role === 'initiator'
   ) {
     changeStatus(channel, 'signed')
@@ -69,59 +73,59 @@ export function awaitingOnChainTx (channel, message, state) {
 }
 
 export function awaitingBlockInclusion (channel, message, state) {
-  if (message.action === 'info') {
+  if (message.method === 'channels.info') {
     const handler = {
       own_funding_locked: awaitingBlockInclusion,
       funding_locked: awaitingOpenConfirmation
-    }[message.payload.event]
+    }[message.params.data.event]
     if (handler) {
       return { handler }
     }
   }
 }
 
 export function awaitingOpenConfirmation (channel, message, state) {
-  if (message.action === 'info' && message.payload.event === 'open') {
+  if (message.method === 'channels.info' && message.params.data.event === 'open') {
     return { handler: awaitingInitialState }
   }
 }
 
 export function awaitingInitialState (channel, message, state) {
-  if (message.action === 'update') {
-    changeState(channel, message.payload.state)
+  if (message.method === 'channels.update') {
+    changeState(channel, message.params.data.state)
     return { handler: channelOpen }
   }
 }
 
 export async function channelOpen (channel, message, state) {
-  if (message.action === 'info') {
-    if (message.payload.event === 'died') {
+  if (message.method === 'channels.info') {
+    if (message.params.data.event === 'died') {
       changeStatus(channel, 'died')
     }
     const handler = {
       update: awaitingUpdateTxSignRequest,
       close_mutual: channelOpen,
       died: channelClosed
-    }[message.payload.event]
+    }[message.params.data.event]
     if (handler) {
       return { handler }
     }
   }
-  if (message.action === 'sign' && message.tag === 'shutdown_sign_ack') {
-    const signedTx = await Promise.resolve(options.get(channel).sign(message.tag, message.payload.tx))
-    send(channel, { action: message.tag, payload: { tx: signedTx } })
+  if (message.method === 'channels.sign.shutdown_sign_ack') {
+    const signedTx = await Promise.resolve(options.get(channel).sign(message.tag, message.params.data.tx))
+    send(channel, { jsonrpc: '2.0', method: 'channels.shutdown_sign_ack', params: { tx: signedTx } })
     return { handler: channelOpen }
   }
-  if (message.action === 'on_chain_tx') {
-    emit(channel, 'onChainTx', message.payload.tx)
+  if (message.method === 'channels.on_chain_tx') {
+    emit(channel, 'onChainTx', message.params.data.tx)
     return { handler: channelOpen }
   }
-  if (message.action === 'leave') {
+  if (message.method === 'channels.leave') {
     // TODO: emit event
     return { handler: channelOpen }
   }
-  if (message.action === 'message') {
-    emit(channel, 'message', message.payload.message)
+  if (message.method === 'channels.message') {
+    emit(channel, 'message', message.params.data.message)
     return { handler: channelOpen }
   }
 }
@@ -130,44 +134,44 @@ channelOpen.enter = (channel) => {
 }
 
 export async function awaitingOffChainTx (channel, message, state) {
-  if (message.action === 'sign' && message.tag === 'update') {
+  if (message.method === 'channels.sign.update') {
     const { sign } = state
-    const signedTx = await sign(message.payload.tx)
-    send(channel, { action: message.tag, payload: { tx: signedTx } })
+    const signedTx = await sign(message.params.data.tx)
+    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
     return { handler: awaitingOffChainUpdate, state }
   }
-  if (message.action === 'error') {
-    state.reject(new Error(JSON.stringify(message.payload)))
+  if (message.method === 'channels.error') {
+    state.reject(new Error(message.data.message))
     return { handler: channelOpen }
   }
 }
 
 export function awaitingOffChainUpdate (channel, message, state) {
-  if (message.action === 'update') {
-    changeState(channel, message.payload.state)
-    state.resolve({ accepted: true, state: message.payload.state })
+  if (message.method === 'channels.update') {
+    changeState(channel, message.params.data.state)
+    state.resolve({ accepted: true, state: message.params.data.state })
     return { handler: channelOpen }
   }
-  if (message.action === 'conflict') {
+  if (message.method === 'channels.conflict') {
     state.resolve({ accepted: false })
     return { handler: channelOpen }
   }
 }
 
 export async function awaitingUpdateTxSignRequest (channel, message, state) {
-  if (message.action === 'sign' && message.tag === 'update_ack') {
-    const signedTx = await options.get(channel).sign(message.tag, message.payload.tx)
+  if (message.method === 'channels.sign.update_ack') {
+    const signedTx = await options.get(channel).sign(message.tag, message.params.data.tx)
     if (signedTx) {
-      send(channel, { action: message.tag, payload: { tx: signedTx } })
+      send(channel, { jsonrpc: '2.0', method: 'channels.update_ack', params: { tx: signedTx } })
       return { handler: awaitingUpdateTx }
     }
     // soft-reject via competing update
     send(channel, {
-      action: 'update',
-      tag: 'new',
-      payload: {
-        from: generateKeyPair().pub,
-        to: generateKeyPair().pub,
+      jsonrpc: '2.0',
+      method: 'channels.update.new',
+      params: {
+        from: generateKeyPair().publicKey,
+        to: generateKeyPair().publicKey,
         amount: 1
       }
     })
@@ -176,63 +180,70 @@ export async function awaitingUpdateTxSignRequest (channel, message, state) {
 }
 
 export function awaitingUpdateTx (channel, message, state) {
-  if (message.action === 'update') {
+  if (message.method === 'channels.update') {
+    // TODO: change state to `message.params.data.state`
     return { handler: channelOpen }
   }
 }
 
 export function awaitingUpdateConflict (channel, message, state) {
-  if (message.action === 'error' && message.payload.reason === 'conflict') {
+  if (message.error) {
     return { handler: awaitingUpdateConflict }
   }
-  if (message.action === 'conflict') {
+  if (message.method === 'channels.conflict') {
     return { handler: channelOpen }
   }
 }
 
 export function awaitingProofOfInclusion (channel, message, state) {
-  if (message.action === 'get' && message.tag === 'poi') {
-    state.resolve(message.payload.poi)
+  if (message.id === state.messageId) {
+    state.resolve(message.result.poi)
     return { handler: channelOpen }
   }
-  if (message.action === 'error') {
-    state.reject(new Error(message.payload.reason))
+  if (message.method === 'channels.error') {
+    state.reject(new Error(message.data.message))
     return { handler: channelOpen }
   }
 }
 
 export function awaitingBalances (channel, message, state) {
-  if (message.action === 'get' && message.tag === 'balances') {
+  if (message.id === state.messageId) {
     state.resolve(R.reduce((acc, item) => ({
       ...acc,
       [item.account]: item.balance
-    }), {}, message.payload))
+    }), {}, message.result))
     return { handler: channelOpen }
   }
-  if (message.action === 'error') {
-    state.reject(new Error(message.payload.reason))
+  if (message.method === 'channels.error') {
+    state.reject(new Error(message.data.message))
     return { handler: channelOpen }
   }
 }
 
 export async function awaitingShutdownTx (channel, message, state) {
-  if (message.action === 'sign' && message.tag === 'shutdown_sign') {
-    const signedTx = await Promise.resolve(state.sign(message.payload.tx))
-    send(channel, { action: message.tag, payload: { tx: signedTx } })
+  if (message.method === 'channels.sign.shutdown_sign') {
+    const signedTx = await Promise.resolve(state.sign(message.params.data.tx))
+    send(channel, { jsonrpc: '2.0', method: 'channels.shutdown_sign', params: { tx: signedTx } })
     return { handler: awaitingShutdownOnChainTx, state }
   }
 }
 
 export function awaitingShutdownOnChainTx (channel, message, state) {
-  if (message.action === 'on_chain_tx') {
-    state.resolveShutdownPromise(message.payload.tx)
+  if (message.method === 'channels.on_chain_tx') {
+    state.resolveShutdownPromise(message.params.data.tx)
     return { handler: channelClosed }
   }
 }
 
 export function awaitingLeave (channel, message, state) {
-  state.resolve({ channelId: message.channel_id, state: message.payload.state })
-  return { handler: channelClosed }
+  if (message.method === 'channels.leave') {
+    state.resolve({ channelId: message.params.channel_id, state: message.params.data.state })
+    return { handler: channelClosed }
+  }
+  if (message.method === 'channels.error') {
+    state.reject(new Error(message.data.message))
+    return { handler: channelOpen }
+  }
 }
 
 export function channelClosed (channel, message, state) {