Merge pull request #547 from aeternity/release/4.2.0

Release 4.2.0

Author: nduchak

.env

@@ -1,2 +1,2 @@
-TAG=v3.0.1
-COMPILER_TAG=v3.1.0
+TAG=v3.3.0
+COMPILER_TAG=v3.2.0

CHANGELOG.md

@@ -1,3 +1,27 @@
+# [4.2.0](https://github.com/aeternity/aepp-sdk-js/compare/2.4.0...4.2.0) (2019-07-15)
+
+
+### Bug Fixes
+
+* **package:** update libsodium-wrappers-sumo to version 0.7.5 ([#541](https://github.com/aeternity/aepp-sdk-js/issues/541)) ([956ed75](https://github.com/aeternity/aepp-sdk-js/commit/956ed75))
+* **rpc-server:** Fix type 'object' check ([#526](https://github.com/aeternity/aepp-sdk-js/issues/526)) ([48c42e4](https://github.com/aeternity/aepp-sdk-js/commit/48c42e4))
+
+
+### Code Refactoring
+
+* **swagger:** Speedup initialisation
+* **AENS:** Remove unused param from claim method
+* **AENS:** Fix exception if not waiting for mining(claim)
+* **Test:** Add test for contract namespaces
+
+### Features
+
+* **Node:** Add 4.0.0 node compatibility
+* **Compiler:** Add compatibility with compiler 3.2.0
+* **Channel:** Implement GA awareness of State Channels
+
+
+
 # [4.1.0](https://github.com/aeternity/aepp-sdk-js/compare/4.0.1...4.1.0) (2019-06-22)
 
 

README.md

@@ -3,7 +3,7 @@
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 [![Build Status](https://ci.aepps.com/buildStatus/icon?job=aepp-sdk-js/develop)](https://ci.aepps.com/job/aepp-sdk-js/job/develop/)
 [![npm](https://img.shields.io/npm/v/@aeternity/aepp-sdk.svg)](https://www.npmjs.com/package/@aeternity/aepp-sdk)
-[![npm](https://img.shields.io/npm/l/@aeternity/aepp-sdk.svg)](https://www.npmjs.com/package/@aeternity/aepp-sdk)
+[![npm](https://img.shields.io/npm/l/@aeternity/aepp-sdk.svg)](https://www.npmjs.com/package/@aeternity/aepp-sdk) [![Greenkeeper badge](https://badges.greenkeeper.io/aeternity/aepp-sdk-js.svg)](https://greenkeeper.io/)
 
 JavaScript SDK for the revolutionary [æternity] blockchain, targeting the
 [æternity node] implementation. Aepp-sdk is [hosted on GitHub].
@@ -12,20 +12,10 @@ JavaScript SDK for the revolutionary [æternity] blockchain, targeting the
 [æternity node]: https://github.com/aeternity/aeternity
 [hosted on GitHub]: https://github.com/aeternity/aepp-sdk-js
 
-#### Disclaimer
-
-This SDK is in continuos development where things can easily break, especially if you're not an officially released version. We aim to make all our
- releases as stable as possible, neverless it should not be taken as
-production-ready.
-
-To catch up with the more edgy state of development please
-check out the [develop branch].
-
 [develop branch]: https://github.com/aeternity/aepp-sdk-js/tree/develop
 
 ## Table of content
 - [Æternity's Javascript SDK](#%C3%86ternitys-Javascript-SDK)
-      - [Disclaimer](#Disclaimer)
   - [Table of content](#Table-of-content)
   - [Quick Start](#Quick-Start)
     - [1. Install SDK](#1-Install-SDK)
@@ -68,6 +58,23 @@ npm i @aeternity/aepp-sdk@next
 npm i https://github.com/aeternity/aepp-sdk-js#develop
 ```
 
+**Note** : If you experience errors during the installation, you might need to install build tools for your OS.
+
+Windows: Windows Build Tools
+```
+npm install -g windows-build-tools
+```
+Ubuntu / Debian: Build Essential
+```
+sudo apt-get update
+sudo apt-get install build-essential
+```
+Mac:
+Download [Xcode](https://apps.apple.com/de/app/xcode/id497799835?mt=12) from AppStore, then run
+```
+xcode-select --install
+```
+
 ### 2. Create an Account
 You can do many more things now, but you'll probably have to start with:
 
@@ -159,4 +166,3 @@ INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
 THIS SOFTWARE.
-

es/ae/aens.js

@@ -159,14 +159,11 @@ async function query (name) {
  * @alias module:@aeternity/aepp-sdk/es/ae/aens
  * @param {String} name
  * @param {String} salt
- * @param {Number} waitForHeight
  * @param {Record} [options={}]
  * @return {Promise<Object>} the result of the claim
  */
-async function claim (name, salt, waitForHeight, options = {}) {
+async function claim (name, salt, options = {}) {
   const opt = R.merge(this.Ae.defaults, options)
-  // wait until block was mined before send claim transaction
-  // if (waitForHeight) await this.awaitHeight(waitForHeight, { attempts: 200 })
   const claimTx = await this.nameClaimTx(R.merge(opt, {
     accountId: await this.address(),
     nameSalt: salt,
@@ -177,7 +174,7 @@ async function claim (name, salt, waitForHeight, options = {}) {
 
   return {
     ...result,
-    ...(await this.aensQuery(name))
+    ...opt.waitMined && await this.aensQuery(name)
   }
 }
 

es/channel/handlers.js

@@ -15,7 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { generateKeyPair, encodeContractAddress } from '../utils/crypto'
+import { generateKeyPair, encodeContractAddress, encodeBase64Check } from '../utils/crypto'
 import {
   options,
   changeStatus,
@@ -25,7 +25,23 @@ import {
   channelId,
   disconnect
 } from './internal'
-import { unpackTx } from '../tx/builder'
+import { unpackTx, buildTx } from '../tx/builder'
+
+function encodeRlpTx (rlpBinary) {
+  return `tx_${encodeBase64Check(rlpBinary)}`
+}
+
+async function appendSignature (tx, signFn) {
+  const { signatures, encodedTx } = unpackTx(tx).tx
+  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded))
+  if (result) {
+    const { tx: signedTx, txType } = unpackTx(result)
+    return encodeRlpTx(buildTx({
+      signatures: signatures.concat(signedTx.signatures),
+      encodedTx: signedTx.encodedTx.rlpEncoded
+    }, txType).rlpEncoded)
+  }
+}
 
 function handleUnexpectedMessage (channel, message, state) {
   if (state.reject) {
@@ -63,15 +79,35 @@ export async function awaitingChannelCreateTx (channel, message, state) {
     responder: 'responder_sign'
   }[options.get(channel).role]
   if (message.method === `channels.sign.${tag}`) {
-    const signedTx = await options.get(channel).sign(tag, message.params.data.tx)
-    send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { tx: signedTx } })
+    if (message.params.data.tx) {
+      const signedTx = await options.get(channel).sign(tag, message.params.data.tx)
+      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))
+    send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { signed_tx: signedTx } })
     return { handler: awaitingOnChainTx }
   }
 }
 
 export function awaitingOnChainTx (channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
-    emit(channel, 'onChainTx', message.params.data.tx)
+    if (
+      message.params.data.info === 'funding_signed' &&
+      options.get(channel).role === 'initiator'
+    ) {
+      return { handler: awaitingOnChainTx }
+    }
+    if (
+      message.params.data.info === 'funding_created' &&
+      options.get(channel).role === 'responder'
+    ) {
+      return { handler: awaitingOnChainTx }
+    }
+    emit(channel, 'onChainTx', message.params.data.signed_tx, {
+      info: message.params.data.info,
+      type: message.params.data.type
+    })
     return { handler: awaitingBlockInclusion }
   }
   if (
@@ -126,13 +162,22 @@ export async function channelOpen (channel, message, state) {
           return { handler: channelOpen }
         case 'close_mutual':
           return { handler: channelOpen }
+        case 'closing':
+          changeStatus(channel, 'closing')
+          return { handler: channelOpen }
+        case 'closed_confirmed':
+          changeStatus(channel, 'closed')
+          return { handler: channelClosed }
         case 'died':
           changeStatus(channel, 'died')
           return { handler: channelClosed }
       }
       break
     case 'channels.on_chain_tx':
-      emit(channel, 'onChainTx', message.params.data.tx)
+      emit(channel, 'onChainTx', message.params.data.signed_tx, {
+        info: message.params.data.info,
+        type: message.params.data.type
+      })
       return { handler: channelOpen }
     case 'channels.leave':
       // TODO: emit event
@@ -151,8 +196,15 @@ channelOpen.enter = (channel) => {
 export async function awaitingOffChainTx (channel, message, state) {
   if (message.method === 'channels.sign.update') {
     const { sign } = state
-    const signedTx = await sign(message.params.data.tx, { updates: message.params.data.updates })
-    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, { updates: message.params.data.updates })
+      send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
+      return { handler: awaitingOffChainUpdate, state }
+    }
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx =>
+      sign(tx, { updates: message.params.data.updates })
+    )
+    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
     return { handler: awaitingOffChainUpdate, state }
   }
   if (message.method === 'channels.error') {
@@ -194,14 +246,22 @@ export async function awaitingTxSignRequest (channel, message, state) {
   // eslint-disable-next-line no-useless-escape
   const [, tag] = message.method.match(/^channels\.sign\.([^\.]+)$/) || []
   if (tag) {
-    const signedTx = await options.get(channel).sign(
-      tag,
-      message.params.data.tx,
-      { updates: message.params.data.updates }
-    )
-    if (signedTx) {
-      send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { tx: signedTx } })
-      return { handler: channelOpen }
+    if (message.params.data.tx) {
+      const signedTx = await options.get(channel).sign(tag, message.params.data.tx, {
+        updates: message.params.data.updates
+      })
+      if (signedTx) {
+        send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { tx: signedTx } })
+        return { handler: channelOpen }
+      }
+    } else {
+      const signedTx = await appendSignature(message.params.data.signed_tx, tx =>
+        options.get(channel).sign(tag, tx, { updates: message.params.data.updates })
+      )
+      if (signedTx) {
+        send(channel, { jsonrpc: '2.0', method: `channels.${tag}`, params: { signed_tx: signedTx } })
+        return { handler: channelOpen }
+      }
     }
     // soft-reject via competing update
     send(channel, {
@@ -230,8 +290,13 @@ export function awaitingUpdateConflict (channel, message, state) {
 
 export async function awaitingShutdownTx (channel, message, state) {
   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 } })
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx)
+      send(channel, { jsonrpc: '2.0', method: 'channels.shutdown_sign', params: { tx: signedTx } })
+      return { handler: awaitingShutdownOnChainTx, state }
+    }
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx))
+    send(channel, { jsonrpc: '2.0', method: 'channels.shutdown_sign', params: { signed_tx: signedTx } })
     return { handler: awaitingShutdownOnChainTx, state }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -260,11 +325,16 @@ export function awaitingLeave (channel, message, state) {
 
 export async function awaitingWithdrawTx (channel, message, state) {
   if (message.method === 'channels.sign.withdraw_tx') {
-    const signedTx = await Promise.resolve(state.sign(
-      message.params.data.tx,
-      { updates: message.params.data.updates }
-    ))
-    send(channel, { jsonrpc: '2.0', method: 'channels.withdraw_tx', params: { tx: signedTx } })
+    const { sign } = state
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, { updates: message.params.data.updates })
+      send(channel, { jsonrpc: '2.0', method: 'channels.withdraw_tx', params: { tx: signedTx } })
+      return { handler: awaitingWithdrawCompletion, state }
+    }
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx =>
+      sign(tx, { updates: message.params.data.updates })
+    )
+    send(channel, { jsonrpc: '2.0', method: 'channels.withdraw_tx', params: { signed_tx: signedTx } })
     return { handler: awaitingWithdrawCompletion, state }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -273,7 +343,7 @@ export async function awaitingWithdrawTx (channel, message, state) {
 export function awaitingWithdrawCompletion (channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
-      state.onOnChainTx(message.params.data.tx)
+      state.onOnChainTx(message.params.data.signed_tx)
     }
     return { handler: awaitingWithdrawCompletion, state }
   }
@@ -303,11 +373,16 @@ export function awaitingWithdrawCompletion (channel, message, state) {
 
 export async function awaitingDepositTx (channel, message, state) {
   if (message.method === 'channels.sign.deposit_tx') {
-    const signedTx = await Promise.resolve(state.sign(
-      message.params.data.tx,
-      { updates: message.params.data.updates }
-    ))
-    send(channel, { jsonrpc: '2.0', method: 'channels.deposit_tx', params: { tx: signedTx } })
+    const { sign } = state
+    if (message.params.data.tx) {
+      const signedTx = await sign(message.params.data.tx, { updates: message.params.data.updates })
+      send(channel, { jsonrpc: '2.0', method: 'channels.deposit_tx', params: { tx: signedTx } })
+      return { handler: awaitingDepositCompletion, state }
+    }
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx =>
+      sign(tx, { updates: message.params.data.updates })
+    )
+    send(channel, { jsonrpc: '2.0', method: 'channels.deposit_tx', params: { signed_tx: signedTx } })
     return { handler: awaitingDepositCompletion, state }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -316,7 +391,7 @@ export async function awaitingDepositTx (channel, message, state) {
 export function awaitingDepositCompletion (channel, message, state) {
   if (message.method === 'channels.on_chain_tx') {
     if (state.onOnChainTx) {
-      state.onOnChainTx(message.params.data.tx)
+      state.onOnChainTx(message.params.data.signed_tx)
     }
     return { handler: awaitingDepositCompletion, state }
   }
@@ -346,8 +421,13 @@ export function awaitingDepositCompletion (channel, message, state) {
 
 export async function awaitingNewContractTx (channel, message, state) {
   if (message.method === 'channels.sign.update') {
-    const signedTx = await Promise.resolve(state.sign(message.params.data.tx))
-    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx)
+      send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
+      return { handler: awaitingNewContractCompletion, state }
+    }
+    const signedTx = await appendSignature(message.params.data.signed_tx, tx => state.sign(tx))
+    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
     return { handler: awaitingNewContractCompletion, state }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -378,8 +458,13 @@ export function awaitingNewContractCompletion (channel, message, state) {
 
 export async function awaitingCallContractUpdateTx (channel, message, state) {
   if (message.method === 'channels.sign.update') {
-    const signedTx = await Promise.resolve(state.sign(message.params.data.tx))
-    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { tx: signedTx } })
+    if (message.params.data.tx) {
+      const signedTx = await state.sign(message.params.data.tx)
+      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))
+    send(channel, { jsonrpc: '2.0', method: 'channels.update', params: { signed_tx: signedTx } })
     return { handler: awaitingCallContractCompletion, state }
   }
   return handleUnexpectedMessage(channel, message, state)

es/node.js

@@ -152,6 +152,6 @@ const Node = stampit({
 })
 
 const NODE_GE_VERSION = '3.0.1'
-const NODE_LT_VERSION = '4.0.0'
+const NODE_LT_VERSION = '5.0.0'
 
 export default Node

es/rpc/server.js

@@ -42,7 +42,7 @@ async function receive ({ data, origin, source }) {
     (this.rpcMethods[method] || error).bind(this),
     { params, session: this.rpcSessions[session], origin }
   ).then(result => {
-    const resolve = typeof result === 'object'
+    const resolve = typeof result === 'object' && Object.prototype.toString.call(result) === '[object Object]'
       ? Object.entries(result)
         .filter(([key, value]) => typeof value !== 'function')
         .reduce((p, [key, value]) => ({ ...p, [key]: value }), {})