@aeternity/aepp-sdk 9.0.1 → 11.0.0

package/src/chain/index.js

@@ -37,13 +37,32 @@ import { required } from '@stamp/required'
  * @return {Object} Chain instance
  */
 const Chain = stampit({
-  deepProps: { Ae: { defaults: { waitMined: true, verify: true } } }
+  deepProps: {
+    Ae: {
+      defaults: {
+        waitMined: true,
+        verify: true,
+        _expectedMineRate: 180000,
+        _microBlockCycle: 3000,
+        _maxPollInterval: 5000
+      }
+    }
+  },
+  methods: {
+    _getPollInterval (type) {
+      const base = {
+        block: this.Ae.defaults._expectedMineRate,
+        microblock: this.Ae.defaults._microBlockCycle
+      }[type]
+      if (!base) throw new Error(`Unknown poll type: ${type}`)
+      return Math.min(base / 3, this.Ae.defaults._maxPollInterval)
+    }
+  }
 }, required({
   methods: {
     sendTransaction: required,
     height: required,
     awaitHeight: required,
-    topBlock: required,
     poll: required,
     balance: required,
     getBalance: required,
@@ -113,8 +132,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
  */
 
@@ -126,7 +147,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
  */
 
@@ -239,7 +261,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,15 +14,23 @@
  *  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 verifyTransaction from '../tx/validator'
 import NodePool from '../node-pool'
 import { pause } from '../utils/other'
 import { isNameValid, produceNameId, decode } from '../tx/builder/helpers'
-import { DRY_RUN_ACCOUNT, NAME_ID_KEY } from '../tx/builder/schema'
+import { DRY_RUN_ACCOUNT } from '../tx/builder/schema'
+import {
+  AensPointerContextError,
+  DryRunError,
+  InvalidAensNameError,
+  InvalidTxError,
+  RequestTimedOutError,
+  TxTimedOutError,
+  TxNotInChainError,
+  ArgumentError
+} from '../utils/errors'
 
 /**
  * ChainNode module
@@ -34,13 +42,13 @@ 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)
-  if (verify) {
+  const opt = { ...this.Ae.defaults, ...options }
+  if (opt.verify) {
     const validation = await verifyTransaction(tx, this.selectedNode.instance)
     if (validation.length) {
       const message = 'Transaction verification errors: ' +
         validation.map(v => v.message).join(', ')
-      throw Object.assign(new Error(message), {
+      throw Object.assign(new InvalidTxError(message), {
         code: 'TX_VERIFICATION_ERROR',
         validation,
         transaction: tx
@@ -49,9 +57,11 @@ async function sendTransaction (tx, options = {}) {
   }
 
   try {
-    const { txHash } = await this.api.postTransaction({ tx })
+    const { txHash } = await this.api.postTransaction({ tx }, {
+      __queue: `tx-${await this.address?.(options).catch(() => '')}`
+    })
 
-    if (waitMined) {
+    if (opt.waitMined) {
       const txData = { ...await this.poll(txHash, options), rawTx: tx }
       // wait for transaction confirmation
       if (options.confirm) {
@@ -61,18 +71,21 @@ async function sendTransaction (tx, options = {}) {
     }
     return { hash: txHash, rawTx: tx }
   } catch (error) {
-    throw Object.assign(error, { rawTx: tx, verifyTx: () => verifyTransaction(tx, this.selectedNode.instance) })
+    throw Object.assign(error, {
+      rawTx: tx,
+      verifyTx: () => verifyTransaction(tx, this.selectedNode.instance)
+    })
   }
 }
 
 async function waitForTxConfirm (txHash, options = { confirm: 3 }) {
   options.confirm = options.confirm === true ? 3 : options.confirm
-  const { blockHeight } = await this.tx(txHash)
+  const { blockHeight } = await this.api.getTransactionByHash(txHash)
   const height = await this.awaitHeight(blockHeight + options.confirm, options)
-  const { blockHeight: newBlockHeight } = await this.tx(txHash)
+  const { blockHeight: newBlockHeight } = await this.api.getTransactionByHash(txHash)
   switch (newBlockHeight) {
     case -1:
-      throw new Error(`Transaction ${txHash} is removed from chain`)
+      throw new TxNotInChainError(txHash)
     case blockHeight:
       return height
     default:
@@ -102,6 +115,9 @@ async function getBalance (address, { height, hash, format = AE_AMOUNT_FORMATS.A
   return formatAmount(balance, { targetDenomination: format }).toString()
 }
 
+/**
+ * @deprecated use `sdk.api.getTransactionByHash/getTransactionInfoByHash` instead
+ */
 async function tx (hash, info = true) {
   const tx = await this.api.getTransactionByHash(hash)
   if (['ContractCreateTx', 'ContractCallTx', 'ChannelForceProgressTx'].includes(tx.tx.type) && info && tx.blockHeight !== -1) {
@@ -113,45 +129,36 @@ async function tx (hash, info = true) {
 }
 
 async function height () {
-  try {
-    if (!this._heightPromise) {
-      this._heightPromise = this.api.getCurrentKeyBlockHeight()
-    }
-    return (await this._heightPromise).height
-  } finally {
-    delete this._heightPromise
-  }
+  return (await this.api.getCurrentKeyBlockHeight()).height
 }
 
-async function awaitHeight (height, { interval = 5000, attempts = 20 } = {}) {
+async function awaitHeight (
+  height,
+  { interval = this._getPollInterval('block'), attempts = 20 } = {}
+) {
   let currentHeight
   for (let i = 0; i < attempts; i++) {
     if (i) await pause(interval)
     currentHeight = await this.height()
     if (currentHeight >= height) return currentHeight
   }
-  throw new Error(`Giving up after ${(attempts - 1) * interval}ms, current height: ${currentHeight}, desired height: ${height}`)
-}
-
-/**
- * @deprecated
- */
-async function topBlock () {
-  return this.api.getTopHeader()
+  throw new RequestTimedOutError((attempts - 1) * interval, currentHeight, height)
 }
 
-async function poll (th, { blocks = 10, interval = 5000, allowUnsynced = false } = {}) {
+async function poll (th, { blocks = 10, interval = this._getPollInterval('microblock') } = {}) {
   const max = await this.height() + blocks
   do {
-    const tx = await this.tx(th).catch(_ => null)
-    if (tx && (tx.blockHeight !== -1 || (allowUnsynced && tx.height))) {
-      return tx
-    }
+    const tx = await this.api.getTransactionByHash(th)
+    if (tx.blockHeight !== -1) return tx
     await pause(interval)
   } while (await this.height() < max)
-  throw new Error(`Giving up after ${blocks} blocks mined, transaction hash: ${th}`)
+  const status = this.api.getCheckTxInPool && (await this.api.getCheckTxInPool(th)).status
+  throw new TxTimedOutError(blocks, th, status)
 }
 
+/**
+ * @deprecated use `sdk.api.getTransactionInfoByHash` instead
+ */
 async function getTxInfo (hash) {
   const result = await this.api.getTransactionInfoByHash(hash)
   return result.callInfo || result
@@ -168,7 +175,7 @@ async function getCurrentGeneration () {
 async function getGeneration (hashOrHeight) {
   if (typeof hashOrHeight === 'string') return this.api.getGenerationByHash(hashOrHeight)
   if (typeof hashOrHeight === 'number') return this.api.getGenerationByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
+  throw new ArgumentError('hashOrHeight', 'a string or number', hashOrHeight)
 }
 
 async function getMicroBlockTransactions (hash) {
@@ -178,30 +185,53 @@ async function getMicroBlockTransactions (hash) {
 async function getKeyBlock (hashOrHeight) {
   if (typeof hashOrHeight === 'string') return this.api.getKeyBlockByHash(hashOrHeight)
   if (typeof hashOrHeight === 'number') return this.api.getKeyBlockByHeight(hashOrHeight)
-  throw new Error('Invalid param, param must be hash or height')
+  throw new ArgumentError('hashOrHeight', 'a string or number', hashOrHeight)
 }
 
 async function getMicroBlockHeader (hash) {
   return this.api.getMicroBlockHeaderByHash(hash)
 }
 
-async function txDryRun (tx, accountAddress, options) {
-  const { results: [{ result, reason, ...resultPayload }], ...other } =
-    await this.api.protectedDryRunTxs({
-      ...options,
-      txs: [{ tx }],
-      accounts: [{
-        pubKey: accountAddress,
-        amount: DRY_RUN_ACCOUNT.amount
-      }]
+async function txDryRunHandler (key) {
+  const rs = this._txDryRun[key]
+  delete this._txDryRun[key]
+
+  let dryRunRes
+  try {
+    dryRunRes = await this.api.protectedDryRunTxs({
+      top: rs[0].top,
+      txEvents: rs[0].txEvents,
+      txs: rs.map(req => ({ tx: req.tx })),
+      accounts: Array.from(new Set(rs.map(req => req.accountAddress)))
+        .map(pubKey => ({ pubKey, amount: DRY_RUN_ACCOUNT.amount }))
     })
+  } catch (error) {
+    rs.forEach(({ reject }) => reject(error))
+    return
+  }
 
-  if (result === 'ok') return { ...resultPayload, ...other }
+  const { results, txEvents } = dryRunRes
+  results.forEach(({ result, reason, ...resultPayload }, idx) => {
+    const { resolve, reject, tx, options, accountAddress } = rs[idx]
+    if (result === 'ok') return resolve({ ...resultPayload, txEvents })
+    reject(Object.assign(
+      new DryRunError(reason), { tx, accountAddress, options }
+    ))
+  })
+}
 
-  throw Object.assign(
-    new Error('Dry run error, ' + reason),
-    { tx, accountAddress, options }
-  )
+async function txDryRun (tx, accountAddress, { top, txEvents, combine }) {
+  const key = combine ? [top, txEvents].join() : 'immediate'
+  this._txDryRun ??= {}
+  this._txDryRun[key] ??= []
+  return new Promise((resolve, reject) => {
+    this._txDryRun[key].push({ tx, accountAddress, top, txEvents, resolve, reject })
+    if (!combine) {
+      txDryRunHandler.call(this, key)
+      return
+    }
+    this._txDryRun[key].timeout ??= setTimeout(txDryRunHandler.bind(this, key))
+  })
 }
 
 async function getContractByteCode (contractId) {
@@ -219,42 +249,41 @@ 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] 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
+ * // 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(`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 InvalidAensNameError(`Name or address should be a string: ${nameOrId}`)
   }
   try {
-    decode(nameOrId, prefix)
+    decode(nameOrId)
     return nameOrId
   } catch (error) {}
   if (isNameValid(nameOrId)) {
     if (verify || resolveByNode) {
-      const name = await this.getName(nameOrId).catch(_ => null)
-      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} don't have pointers for ${prefix}`)
+      const name = await this.api.getNameEntryByName(nameOrId)
+      const pointer = name.pointers.find(pointer => pointer.key === key)
+      if (!pointer) {
+        throw new AensPointerContextError(`Name ${nameOrId} don't have pointers for ${key}`)
+      }
       if (resolveByNode) return pointer.id
     }
     return produceNameId(nameOrId)
   }
-  throw new Error(`Invalid name or address: ${nameOrId}`)
+  throw new InvalidAensNameError(`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
@@ -268,7 +297,6 @@ const ChainNode = Chain.compose(NodePool, {
     balance,
     getBalance,
     getAccount,
-    topBlock,
     tx,
     height,
     awaitHeight,

package/src/channel/handlers.js

@@ -15,7 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { generateKeyPair, encodeContractAddress, encodeBase64Check } from '../utils/crypto'
+import { generateKeyPair, encodeContractAddress } from '../utils/crypto'
 import {
   options,
   changeStatus,
@@ -28,20 +28,23 @@ import {
   fsmId
 } from './internal'
 import { unpackTx, buildTx } from '../tx/builder'
-
-function encodeRlpTx (rlpBinary) {
-  return `tx_${encodeBase64Check(rlpBinary)}`
-}
+import { encode } from '../tx/builder/helpers'
+import {
+  IllegalArgumentError,
+  InsufficientBalanceError,
+  ChannelConnectionError,
+  UnexpectedChannelMessageError
+} from '../utils/errors'
 
 async function appendSignature (tx, signFn) {
   const { signatures, encodedTx } = unpackTx(tx).tx
-  const result = await signFn(encodeRlpTx(encodedTx.rlpEncoded))
+  const result = await signFn(encode(encodedTx.rlpEncoded, 'tx'))
   if (typeof result === 'string') {
     const { tx: signedTx, txType } = unpackTx(result)
-    return encodeRlpTx(buildTx({
+    return buildTx({
       signatures: signatures.concat(signedTx.signatures),
       encodedTx: signedTx.encodedTx.rlpEncoded
-    }, txType).rlpEncoded)
+    }, txType).tx
   }
   return result
 }
@@ -49,7 +52,7 @@ async function appendSignature (tx, signFn) {
 function handleUnexpectedMessage (channel, message, state) {
   if (state && state.reject) {
     state.reject(Object.assign(
-      new Error(`Unexpected message received:\n\n${JSON.stringify(message)}`),
+      new UnexpectedChannelMessageError(`Unexpected message received:\n\n${JSON.stringify(message)}`),
       { wsMessage: message }
     ))
   }
@@ -75,7 +78,7 @@ export function awaitingConnection (channel, message, state) {
     return { handler: awaitingConnection }
   }
   if (message.method === 'channels.error') {
-    emit(channel, 'error', new Error(message.payload.message))
+    emit(channel, 'error', new ChannelConnectionError(message.payload.message))
     return { handler: channelClosed }
   }
 }
@@ -102,7 +105,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 }
   }
@@ -249,17 +254,17 @@ export async function awaitingOffChainTx (channel, message, state) {
     }
   }
   if (message.method === 'channels.error') {
-    state.reject(new Error(message.data.message))
+    state.reject(new ChannelConnectionError(message.data.message))
     return { handler: channelOpen }
   }
   if (message.error) {
     const { data = [] } = message.error
     if (data.find(i => i.code === 1001)) {
-      state.reject(new Error('Insufficient balance'))
+      state.reject(new InsufficientBalanceError('Insufficient balance'))
     } else if (data.find(i => i.code === 1002)) {
-      state.reject(new Error('Amount cannot be negative'))
+      state.reject(new IllegalArgumentError('Amount cannot be negative'))
     } else {
-      state.reject(new Error(message.error.message))
+      state.reject(new ChannelConnectionError(message.error.message))
     }
     return { handler: channelOpen }
   }
@@ -301,7 +306,7 @@ export function awaitingOffChainUpdate (channel, message, state) {
     }
   }
   if (message.error) {
-    state.reject(new Error(message.error.message))
+    state.reject(new ChannelConnectionError(message.error.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -385,7 +390,7 @@ export function awaitingLeave (channel, message, state) {
     return { handler: channelClosed }
   }
   if (message.method === 'channels.error') {
-    state.reject(new Error(message.data.message))
+    state.reject(new ChannelConnectionError(message.data.message))
     return { handler: channelOpen }
   }
   return handleUnexpectedMessage(channel, message, state)
@@ -574,11 +579,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 +613,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)
@@ -645,7 +654,7 @@ export function awaitingCallsPruned (channels, message, state) {
     state.resolve()
     return { handler: channelOpen }
   }
-  state.reject(new Error('Unexpected message received'))
+  state.reject(new UnexpectedChannelMessageError('Unexpected message received'))
   return { handler: channelClosed }
 }
 

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