From 668e7f1bf4bb9d1c909399b48b88a5ff7b88649b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C5=82=20Powaga?= Date: Fri, 17 May 2019 13:20:38 +0100 Subject: [PATCH] =?UTF-8?q?feat(State=20Channels):=20Make=20state=20channe?= =?UTF-8?q?ls=20compatible=20with=20aeternity=20v=E2=80=A6=20(#415)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * feat(State Channels): Make state channels compatible with aeternity v3.0.0 * Fix lint error --- es/channel/handlers.js | 18 +- es/tx/builder/index.js | 11 +- es/tx/builder/schema.js | 337 +++++++++++++++++++++++++++--------- test/integration/channel.js | 185 +++++++++++++++++--- 4 files changed, 436 insertions(+), 115 deletions(-) diff --git a/es/channel/handlers.js b/es/channel/handlers.js index 3b80b6a515..d18dbd27fa 100644 --- a/es/channel/handlers.js +++ b/es/channel/handlers.js @@ -151,7 +151,7 @@ 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) + 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 } } @@ -194,7 +194,11 @@ 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) + 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 } @@ -256,7 +260,10 @@ 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)) + 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 } }) return { handler: awaitingWithdrawCompletion, state } } @@ -296,7 +303,10 @@ 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)) + 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 } }) return { handler: awaitingDepositCompletion, state } } diff --git a/es/tx/builder/index.js b/es/tx/builder/index.js index 92af16e967..08b3f73b9c 100644 --- a/es/tx/builder/index.js +++ b/es/tx/builder/index.js @@ -302,7 +302,10 @@ export function buildTx (params, type, { excludeKeys = [], prefix = 'tx' } = {}) if (!TX_SERIALIZATION_SCHEMA[type]) { throw new Error('Transaction serialization not implemented for ' + type) } - const [schema, tag] = TX_SERIALIZATION_SCHEMA[type] + if (!TX_SERIALIZATION_SCHEMA[type][VSN]) { + throw new Error('Transaction serialization not implemented for ' + type + ' version ' + VSN) + } + const [schema, tag] = TX_SERIALIZATION_SCHEMA[type][VSN] const binary = buildRawTx({ ...params, VSN, tag }, schema, { excludeKeys }).filter(e => e !== undefined) const rlpEncoded = rlp.encode(binary) @@ -327,7 +330,11 @@ export function unpackTx (encodedTx, fromRlpBinary = false) { if (!TX_DESERIALIZATION_SCHEMA[objId]) { return { message: 'Transaction deserialization not implemented for tag ' + objId } } - const [schema] = TX_DESERIALIZATION_SCHEMA[objId] + const vsn = readInt(binary[1]) + if (!TX_DESERIALIZATION_SCHEMA[objId][vsn]) { + return { message: 'Transaction deserialization not implemented for tag ' + objId + ' version ' + vsn } + } + const [schema] = TX_DESERIALIZATION_SCHEMA[objId][vsn] return { txType: OBJECT_ID_TX_TYPE[objId], tx: unpackRawTx(binary, schema), rlpEncoded, binary } } diff --git a/es/tx/builder/schema.js b/es/tx/builder/schema.js index 8502655b02..0674cb8f5b 100644 --- a/es/tx/builder/schema.js +++ b/es/tx/builder/schema.js @@ -587,6 +587,13 @@ const CHANNEL_OFFCHAIN_TX = [ TX_FIELD('stateHash', FIELD_TYPES.binary, 'st') ] +const CHANNEL_OFFCHAIN_TX_2 = [ + ...BASE_TX, + TX_FIELD('channelId', FIELD_TYPES.id, 'ch'), + TX_FIELD('round', FIELD_TYPES.int), + TX_FIELD('stateHash', FIELD_TYPES.binary, 'st') +] + const CHANNEL_TX = [ ...BASE_TX, TX_FIELD('initiator', FIELD_TYPES.id, 'ak'), @@ -715,91 +722,257 @@ const ACCOUNTS_TREE_TX = [ ] export const TX_SERIALIZATION_SCHEMA = { - [TX_TYPE.account]: TX_SCHEMA_FIELD(ACCOUNT_TX, OBJECT_TAG_ACCOUNT), - [TX_TYPE.signed]: TX_SCHEMA_FIELD(SIGNED_TX, OBJECT_TAG_SIGNED_TRANSACTION), - [TX_TYPE.spend]: TX_SCHEMA_FIELD(SPEND_TX, OBJECT_TAG_SPEND_TRANSACTION), - [TX_TYPE.namePreClaim]: TX_SCHEMA_FIELD(NAME_PRE_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION), - [TX_TYPE.nameClaim]: TX_SCHEMA_FIELD(NAME_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION), - [TX_TYPE.nameUpdate]: TX_SCHEMA_FIELD(NAME_UPDATE_TX, OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION), - [TX_TYPE.nameTransfer]: TX_SCHEMA_FIELD(NAME_TRANSFER_TX, OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION), - [TX_TYPE.nameRevoke]: TX_SCHEMA_FIELD(NAME_REVOKE_TX, OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION), - [TX_TYPE.contract]: TX_SCHEMA_FIELD(CONTRACT_TX, OBJECT_TAG_CONTRACT), - [TX_TYPE.contractCreate]: TX_SCHEMA_FIELD(CONTRACT_CREATE_TX, OBJECT_TAG_CONTRACT_CREATE_TRANSACTION), - [TX_TYPE.contractCall]: TX_SCHEMA_FIELD(CONTRACT_CALL_TX, OBJECT_TAG_CONTRACT_CALL_TRANSACTION), - [TX_TYPE.contractCallResult]: TX_SCHEMA_FIELD(CONTRACT_CALL_RESULT_TX, OBJECT_TAG_CONTRACT_CALL), - [TX_TYPE.oracleRegister]: TX_SCHEMA_FIELD(ORACLE_REGISTER_TX, OBJECT_TAG_ORACLE_REGISTER_TRANSACTION), - [TX_TYPE.oracleExtend]: TX_SCHEMA_FIELD(ORACLE_EXTEND_TX, OBJECT_TAG_ORACLE_EXTEND_TRANSACTION), - [TX_TYPE.oracleQuery]: TX_SCHEMA_FIELD(ORACLE_QUERY_TX, OBJECT_TAG_ORACLE_QUERY_TRANSACTION), - [TX_TYPE.oracleResponse]: TX_SCHEMA_FIELD(ORACLE_RESPOND_TX, OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION), - [TX_TYPE.channelCreate]: TX_SCHEMA_FIELD(CHANNEL_CREATE_TX, OBJECT_TAG_CHANNEL_CREATE_TX), - [TX_TYPE.channelCloseMutual]: TX_SCHEMA_FIELD(CHANNEL_CLOSE_MUTUAL_TX, OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX), - [TX_TYPE.channelCloseSolo]: TX_SCHEMA_FIELD(CHANNEL_CLOSE_SOLO_TX, OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX), - [TX_TYPE.channelSlash]: TX_SCHEMA_FIELD(CHANNEL_SLASH_TX, OBJECT_TAG_CHANNEL_SLASH_TX), - [TX_TYPE.channelDeposit]: TX_SCHEMA_FIELD(CHANNEL_DEPOSIT_TX, OBJECT_TAG_CHANNEL_DEPOSIT_TX), - [TX_TYPE.channelWithdraw]: TX_SCHEMA_FIELD(CHANNEL_WITHDRAW_TX, OBJECT_TAG_CHANNEL_WITHRAW_TX), - [TX_TYPE.channelSettle]: TX_SCHEMA_FIELD(CHANNEL_SETTLE_TX, OBJECT_TAG_CHANNEL_SETTLE_TX), - [TX_TYPE.channelOffChain]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_TX), - [TX_TYPE.channel]: TX_SCHEMA_FIELD(CHANNEL_TX, OBJECT_TAG_CHANNEL), - [TX_TYPE.channelSnapshotSolo]: TX_SCHEMA_FIELD(CHANNEL_SNAPSHOT_SOLO_TX, OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX), - [TX_TYPE.channelOffChainUpdateTransfer]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX), - [TX_TYPE.channelOffChainUpdateDeposit]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX), - [TX_TYPE.channelOffChainUpdateWithdrawal]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX), - [TX_TYPE.channelOffChainCreateContract]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX), - [TX_TYPE.channelOffChainCallContract]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CALL_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX), - [TX_TYPE.proofOfInclusion]: TX_SCHEMA_FIELD(PROOF_OF_INCLUSION_TX, OBJECT_TAG_PROOF_OF_INCLUSION), - [TX_TYPE.stateTrees]: TX_SCHEMA_FIELD(STATE_TREES_TX, OBJECT_TAG_STATE_TREES), - [TX_TYPE.merklePatriciaTree]: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE), - [TX_TYPE.merklePatriciaTreeValue]: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_VALUE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE), - [TX_TYPE.contractsTree]: TX_SCHEMA_FIELD(CONTRACTS_TREE_TX, OBJECT_TAG_CONTRACTS_TREE), - [TX_TYPE.contractCallsTree]: TX_SCHEMA_FIELD(CONTRACT_CALLS_TREE_TX, OBJECT_TAG_CONTRACT_CALLS_TREE), - [TX_TYPE.channelsTree]: TX_SCHEMA_FIELD(CHANNELS_TREE_TX, OBJECT_TAG_CHANNELS_TREE), - [TX_TYPE.nameserviceTree]: TX_SCHEMA_FIELD(NAMESERVICE_TREE_TX, OBJECT_TAG_NAMESERVICE_TREE), - [TX_TYPE.oraclesTree]: TX_SCHEMA_FIELD(ORACLES_TREE_TX, OBJECT_TAG_ORACLES_TREE), - [TX_TYPE.accountsTree]: TX_SCHEMA_FIELD(ACCOUNTS_TREE_TX, OBJECT_TAG_ACCOUNTS_TREE) + [TX_TYPE.account]: { + 1: TX_SCHEMA_FIELD(ACCOUNT_TX, OBJECT_TAG_ACCOUNT) + }, + [TX_TYPE.signed]: { + 1: TX_SCHEMA_FIELD(SIGNED_TX, OBJECT_TAG_SIGNED_TRANSACTION) + }, + [TX_TYPE.spend]: { + 1: TX_SCHEMA_FIELD(SPEND_TX, OBJECT_TAG_SPEND_TRANSACTION) + }, + [TX_TYPE.namePreClaim]: { + 1: TX_SCHEMA_FIELD(NAME_PRE_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION) + }, + [TX_TYPE.nameClaim]: { + 1: TX_SCHEMA_FIELD(NAME_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION) + }, + [TX_TYPE.nameUpdate]: { + 1: TX_SCHEMA_FIELD(NAME_UPDATE_TX, OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION) + }, + [TX_TYPE.nameTransfer]: { + 1: TX_SCHEMA_FIELD(NAME_TRANSFER_TX, OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION) + }, + [TX_TYPE.nameRevoke]: { + 1: TX_SCHEMA_FIELD(NAME_REVOKE_TX, OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION) + }, + [TX_TYPE.contract]: { + 1: TX_SCHEMA_FIELD(CONTRACT_TX, OBJECT_TAG_CONTRACT) + }, + [TX_TYPE.contractCreate]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CREATE_TX, OBJECT_TAG_CONTRACT_CREATE_TRANSACTION) + }, + [TX_TYPE.contractCall]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALL_TX, OBJECT_TAG_CONTRACT_CALL_TRANSACTION) + }, + [TX_TYPE.contractCallResult]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALL_RESULT_TX, OBJECT_TAG_CONTRACT_CALL) + }, + [TX_TYPE.oracleRegister]: { + 1: TX_SCHEMA_FIELD(ORACLE_REGISTER_TX, OBJECT_TAG_ORACLE_REGISTER_TRANSACTION) + }, + [TX_TYPE.oracleExtend]: { + 1: TX_SCHEMA_FIELD(ORACLE_EXTEND_TX, OBJECT_TAG_ORACLE_EXTEND_TRANSACTION) + }, + [TX_TYPE.oracleQuery]: { + 1: TX_SCHEMA_FIELD(ORACLE_QUERY_TX, OBJECT_TAG_ORACLE_QUERY_TRANSACTION) + }, + [TX_TYPE.oracleResponse]: { + 1: TX_SCHEMA_FIELD(ORACLE_RESPOND_TX, OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION) + }, + [TX_TYPE.channelCreate]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CREATE_TX, OBJECT_TAG_CHANNEL_CREATE_TX) + }, + [TX_TYPE.channelCloseMutual]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CLOSE_MUTUAL_TX, OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX) + }, + [TX_TYPE.channelCloseSolo]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CLOSE_SOLO_TX, OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX) + }, + [TX_TYPE.channelSlash]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SLASH_TX, OBJECT_TAG_CHANNEL_SLASH_TX) + }, + [TX_TYPE.channelDeposit]: { + 1: TX_SCHEMA_FIELD(CHANNEL_DEPOSIT_TX, OBJECT_TAG_CHANNEL_DEPOSIT_TX) + }, + [TX_TYPE.channelWithdraw]: { + 1: TX_SCHEMA_FIELD(CHANNEL_WITHDRAW_TX, OBJECT_TAG_CHANNEL_WITHRAW_TX) + }, + [TX_TYPE.channelSettle]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SETTLE_TX, OBJECT_TAG_CHANNEL_SETTLE_TX) + }, + [TX_TYPE.channelOffChain]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_TX), + 2: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX_2, OBJECT_TAG_CHANNEL_OFFCHAIN_TX) + }, + [TX_TYPE.channel]: { + 1: TX_SCHEMA_FIELD(CHANNEL_TX, OBJECT_TAG_CHANNEL) + }, + [TX_TYPE.channelSnapshotSolo]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SNAPSHOT_SOLO_TX, OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX) + }, + [TX_TYPE.channelOffChainUpdateTransfer]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX) + }, + [TX_TYPE.channelOffChainUpdateDeposit]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX) + }, + [TX_TYPE.channelOffChainUpdateWithdrawal]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX) + }, + [TX_TYPE.channelOffChainCreateContract]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX) + }, + [TX_TYPE.channelOffChainCallContract]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CALL_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX) + }, + [TX_TYPE.proofOfInclusion]: { + 1: TX_SCHEMA_FIELD(PROOF_OF_INCLUSION_TX, OBJECT_TAG_PROOF_OF_INCLUSION) + }, + [TX_TYPE.stateTrees]: { + 1: TX_SCHEMA_FIELD(STATE_TREES_TX, OBJECT_TAG_STATE_TREES) + }, + [TX_TYPE.merklePatriciaTree]: { + 1: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE) + }, + [TX_TYPE.merklePatriciaTreeValue]: { + 1: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_VALUE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE) + }, + [TX_TYPE.contractsTree]: { + 1: TX_SCHEMA_FIELD(CONTRACTS_TREE_TX, OBJECT_TAG_CONTRACTS_TREE) + }, + [TX_TYPE.contractCallsTree]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALLS_TREE_TX, OBJECT_TAG_CONTRACT_CALLS_TREE) + }, + [TX_TYPE.channelsTree]: { + 1: TX_SCHEMA_FIELD(CHANNELS_TREE_TX, OBJECT_TAG_CHANNELS_TREE) + }, + [TX_TYPE.nameserviceTree]: { + 1: TX_SCHEMA_FIELD(NAMESERVICE_TREE_TX, OBJECT_TAG_NAMESERVICE_TREE) + }, + [TX_TYPE.oraclesTree]: { + 1: TX_SCHEMA_FIELD(ORACLES_TREE_TX, OBJECT_TAG_ORACLES_TREE) + }, + [TX_TYPE.accountsTree]: { + 1: TX_SCHEMA_FIELD(ACCOUNTS_TREE_TX, OBJECT_TAG_ACCOUNTS_TREE) + } } export const TX_DESERIALIZATION_SCHEMA = { - [OBJECT_TAG_ACCOUNT]: TX_SCHEMA_FIELD(ACCOUNT_TX, OBJECT_TAG_ACCOUNT), - [OBJECT_TAG_SIGNED_TRANSACTION]: TX_SCHEMA_FIELD(SIGNED_TX, OBJECT_TAG_SIGNED_TRANSACTION), - [OBJECT_TAG_SPEND_TRANSACTION]: TX_SCHEMA_FIELD(SPEND_TX, OBJECT_TAG_SPEND_TRANSACTION), - [OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION]: TX_SCHEMA_FIELD(NAME_PRE_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION), - [OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION]: TX_SCHEMA_FIELD(NAME_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION), - [OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION]: TX_SCHEMA_FIELD(NAME_UPDATE_TX, OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION), - [OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION]: TX_SCHEMA_FIELD(NAME_TRANSFER_TX, OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION), - [OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION]: TX_SCHEMA_FIELD(NAME_REVOKE_TX, OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION), - [OBJECT_TAG_CONTRACT]: TX_SCHEMA_FIELD(CONTRACT_TX, OBJECT_TAG_CONTRACT), - [OBJECT_TAG_CONTRACT_CREATE_TRANSACTION]: TX_SCHEMA_FIELD(CONTRACT_CREATE_TX, OBJECT_TAG_CONTRACT_CREATE_TRANSACTION), - [OBJECT_TAG_CONTRACT_CALL_TRANSACTION]: TX_SCHEMA_FIELD(CONTRACT_CALL_TX, OBJECT_TAG_CONTRACT_CALL_TRANSACTION), - [OBJECT_TAG_CONTRACT_CALL]: TX_SCHEMA_FIELD(CONTRACT_CALL_RESULT_TX, OBJECT_TAG_CONTRACT_CALL), - [OBJECT_TAG_ORACLE_REGISTER_TRANSACTION]: TX_SCHEMA_FIELD(ORACLE_REGISTER_TX, OBJECT_TAG_ORACLE_REGISTER_TRANSACTION), - [OBJECT_TAG_ORACLE_EXTEND_TRANSACTION]: TX_SCHEMA_FIELD(ORACLE_EXTEND_TX, OBJECT_TAG_ORACLE_EXTEND_TRANSACTION), - [OBJECT_TAG_ORACLE_QUERY_TRANSACTION]: TX_SCHEMA_FIELD(ORACLE_QUERY_TX, OBJECT_TAG_ORACLE_QUERY_TRANSACTION), - [OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION]: TX_SCHEMA_FIELD(ORACLE_RESPOND_TX, OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION), - [OBJECT_TAG_CHANNEL_CREATE_TX]: TX_SCHEMA_FIELD(CHANNEL_CREATE_TX, OBJECT_TAG_CHANNEL_CREATE_TX), - [OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX]: TX_SCHEMA_FIELD(CHANNEL_CLOSE_MUTUAL_TX, OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX), - [OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX]: TX_SCHEMA_FIELD(CHANNEL_CLOSE_SOLO_TX, OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX), - [OBJECT_TAG_CHANNEL_SLASH_TX]: TX_SCHEMA_FIELD(CHANNEL_SLASH_TX, OBJECT_TAG_CHANNEL_SLASH_TX), - [OBJECT_TAG_CHANNEL_DEPOSIT_TX]: TX_SCHEMA_FIELD(CHANNEL_DEPOSIT_TX, OBJECT_TAG_CHANNEL_DEPOSIT_TX), - [OBJECT_TAG_CHANNEL_WITHRAW_TX]: TX_SCHEMA_FIELD(CHANNEL_WITHDRAW_TX, OBJECT_TAG_CHANNEL_WITHRAW_TX), - [OBJECT_TAG_CHANNEL_SETTLE_TX]: TX_SCHEMA_FIELD(CHANNEL_SETTLE_TX, OBJECT_TAG_CHANNEL_SETTLE_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_TX), - [OBJECT_TAG_CHANNEL]: TX_SCHEMA_FIELD(CHANNEL_TX, OBJECT_TAG_CHANNEL), - [OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX]: TX_SCHEMA_FIELD(CHANNEL_SNAPSHOT_SOLO_TX, OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX), - [OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX]: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CALL_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX), - [OBJECT_TAG_PROOF_OF_INCLUSION]: TX_SCHEMA_FIELD(PROOF_OF_INCLUSION_TX, OBJECT_TAG_PROOF_OF_INCLUSION), - [OBJECT_TAG_STATE_TREES]: TX_SCHEMA_FIELD(STATE_TREES_TX, OBJECT_TAG_STATE_TREES), - [OBJECT_TAG_MERKLE_PATRICIA_TREE]: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE), - [OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE]: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_VALUE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE), - [OBJECT_TAG_CONTRACTS_TREE]: TX_SCHEMA_FIELD(CONTRACTS_TREE_TX, OBJECT_TAG_CONTRACTS_TREE), - [OBJECT_TAG_CONTRACT_CALLS_TREE]: TX_SCHEMA_FIELD(CONTRACT_CALLS_TREE_TX, OBJECT_TAG_CONTRACT_CALLS_TREE), - [OBJECT_TAG_CHANNELS_TREE]: TX_SCHEMA_FIELD(CHANNELS_TREE_TX, OBJECT_TAG_CHANNELS_TREE), - [OBJECT_TAG_NAMESERVICE_TREE]: TX_SCHEMA_FIELD(NAMESERVICE_TREE_TX, OBJECT_TAG_NAMESERVICE_TREE), - [OBJECT_TAG_ORACLES_TREE]: TX_SCHEMA_FIELD(ORACLES_TREE_TX, OBJECT_TAG_ORACLES_TREE), - [OBJECT_TAG_ACCOUNTS_TREE]: TX_SCHEMA_FIELD(ACCOUNTS_TREE_TX, OBJECT_TAG_ACCOUNTS_TREE) + [OBJECT_TAG_ACCOUNT]: { + 1: TX_SCHEMA_FIELD(ACCOUNT_TX, OBJECT_TAG_ACCOUNT) + }, + [OBJECT_TAG_SIGNED_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(SIGNED_TX, OBJECT_TAG_SIGNED_TRANSACTION) + }, + [OBJECT_TAG_SPEND_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(SPEND_TX, OBJECT_TAG_SPEND_TRANSACTION) + }, + [OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(NAME_PRE_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_PRECLAIM_TRANSACTION) + }, + [OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(NAME_CLAIM_TX, OBJECT_TAG_NAME_SERVICE_CLAIM_TRANSACTION) + }, + [OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(NAME_UPDATE_TX, OBJECT_TAG_NAME_SERVICE_UPDATE_TRANSACTION) + }, + [OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(NAME_TRANSFER_TX, OBJECT_TAG_NAME_SERVICE_TRANSFER_TRANSACTION) + }, + [OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(NAME_REVOKE_TX, OBJECT_TAG_NAME_SERVICE_REVOKE_TRANSACTION) + }, + [OBJECT_TAG_CONTRACT]: { + 1: TX_SCHEMA_FIELD(CONTRACT_TX, OBJECT_TAG_CONTRACT) + }, + [OBJECT_TAG_CONTRACT_CREATE_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CREATE_TX, OBJECT_TAG_CONTRACT_CREATE_TRANSACTION) + }, + [OBJECT_TAG_CONTRACT_CALL_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALL_TX, OBJECT_TAG_CONTRACT_CALL_TRANSACTION) + }, + [OBJECT_TAG_CONTRACT_CALL]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALL_RESULT_TX, OBJECT_TAG_CONTRACT_CALL) + }, + [OBJECT_TAG_ORACLE_REGISTER_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(ORACLE_REGISTER_TX, OBJECT_TAG_ORACLE_REGISTER_TRANSACTION) + }, + [OBJECT_TAG_ORACLE_EXTEND_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(ORACLE_EXTEND_TX, OBJECT_TAG_ORACLE_EXTEND_TRANSACTION) + }, + [OBJECT_TAG_ORACLE_QUERY_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(ORACLE_QUERY_TX, OBJECT_TAG_ORACLE_QUERY_TRANSACTION) + }, + [OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION]: { + 1: TX_SCHEMA_FIELD(ORACLE_RESPOND_TX, OBJECT_TAG_ORACLE_RESPONSE_TRANSACTION) + }, + [OBJECT_TAG_CHANNEL_CREATE_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CREATE_TX, OBJECT_TAG_CHANNEL_CREATE_TX) + }, + [OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CLOSE_MUTUAL_TX, OBJECT_TAG_CHANNEL_CLOSE_MUTUAL_TX) + }, + [OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_CLOSE_SOLO_TX, OBJECT_TAG_CHANNEL_CLOSE_SOLO_TX) + }, + [OBJECT_TAG_CHANNEL_SLASH_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SLASH_TX, OBJECT_TAG_CHANNEL_SLASH_TX) + }, + [OBJECT_TAG_CHANNEL_DEPOSIT_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_DEPOSIT_TX, OBJECT_TAG_CHANNEL_DEPOSIT_TX) + }, + [OBJECT_TAG_CHANNEL_WITHRAW_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_WITHDRAW_TX, OBJECT_TAG_CHANNEL_WITHRAW_TX) + }, + [OBJECT_TAG_CHANNEL_SETTLE_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SETTLE_TX, OBJECT_TAG_CHANNEL_SETTLE_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_TX), + 2: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_TX_2, OBJECT_TAG_CHANNEL_OFFCHAIN_TX) + }, + [OBJECT_TAG_CHANNEL]: { + 1: TX_SCHEMA_FIELD(CHANNEL_TX, OBJECT_TAG_CHANNEL) + }, + [OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_SNAPSHOT_SOLO_TX, OBJECT_TAG_CHANNEL_SNAPSHOT_SOLO_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_TRANSFER_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_DEPOSIT_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_UPDATE_WITHDRAWAL_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CREATE_CONTRACT_TX) + }, + [OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX]: { + 1: TX_SCHEMA_FIELD(CHANNEL_OFFCHAIN_CALL_CONTRACT_TX, OBJECT_TAG_CHANNEL_OFFCHAIN_CALL_CONTRACT_TX) + }, + [OBJECT_TAG_PROOF_OF_INCLUSION]: { + 1: TX_SCHEMA_FIELD(PROOF_OF_INCLUSION_TX, OBJECT_TAG_PROOF_OF_INCLUSION) + }, + [OBJECT_TAG_STATE_TREES]: { + 1: TX_SCHEMA_FIELD(STATE_TREES_TX, OBJECT_TAG_STATE_TREES) + }, + [OBJECT_TAG_MERKLE_PATRICIA_TREE]: { + 1: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE) + }, + [OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE]: { + 1: TX_SCHEMA_FIELD(MERKLE_PATRICIA_TREE_VALUE_TX, OBJECT_TAG_MERKLE_PATRICIA_TREE_VALUE) + }, + [OBJECT_TAG_CONTRACTS_TREE]: { + 1: TX_SCHEMA_FIELD(CONTRACTS_TREE_TX, OBJECT_TAG_CONTRACTS_TREE) + }, + [OBJECT_TAG_CONTRACT_CALLS_TREE]: { + 1: TX_SCHEMA_FIELD(CONTRACT_CALLS_TREE_TX, OBJECT_TAG_CONTRACT_CALLS_TREE) + }, + [OBJECT_TAG_CHANNELS_TREE]: { + 1: TX_SCHEMA_FIELD(CHANNELS_TREE_TX, OBJECT_TAG_CHANNELS_TREE) + }, + [OBJECT_TAG_NAMESERVICE_TREE]: { + 1: TX_SCHEMA_FIELD(NAMESERVICE_TREE_TX, OBJECT_TAG_NAMESERVICE_TREE) + }, + [OBJECT_TAG_ORACLES_TREE]: { + 1: TX_SCHEMA_FIELD(ORACLES_TREE_TX, OBJECT_TAG_ORACLES_TREE) + }, + [OBJECT_TAG_ACCOUNTS_TREE]: { + 1: TX_SCHEMA_FIELD(ACCOUNTS_TREE_TX, OBJECT_TAG_ACCOUNTS_TREE) + } } // VERIFICATION SCHEMA diff --git a/test/integration/channel.js b/test/integration/channel.js index b6b3501982..205dd87557 100644 --- a/test/integration/channel.js +++ b/test/integration/channel.js @@ -147,17 +147,43 @@ describe.skip('Channel', function () { result.signedTx.should.be.a('string') sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('update_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('update_ack'), + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount: sinon.match(amount), + from: sinon.match(await initiator.address()), + to: sinon.match(await responder.address()), + op: sinon.match('OffChainTransfer') + }]) + }) + ) sinon.assert.calledOnce(sign) - sinon.assert.calledWithExactly(sign, sinon.match.string) - const { txType, tx: { updates } } = unpackTx(sign.firstCall.args[0]) + sinon.assert.calledWithExactly( + sign, + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount: sinon.match(amount), + from: sinon.match(await initiator.address()), + to: sinon.match(await responder.address()), + op: sinon.match('OffChainTransfer') + }]) + }) + ) + const { txType } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelOffChain') - updates[0].txType.should.equal('channelOffChainUpdateTransfer') - updates[0].tx.should.eql({ - ...updates[0].tx, - from: await initiator.address(), - to: await responder.address(), - amount: amount.toString() + sign.firstCall.args[1].should.eql({ + updates: [ + { + amount, + from: await initiator.address(), + to: await responder.address(), + op: 'OffChainTransfer' + } + ] }) }) @@ -174,17 +200,43 @@ describe.skip('Channel', function () { result.accepted.should.equal(false) sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('update_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('update_ack'), + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount: sinon.match(amount), + from: sinon.match(await responder.address()), + to: sinon.match(await initiator.address()), + op: sinon.match('OffChainTransfer') + }]) + }) + ) sinon.assert.calledOnce(sign) - sinon.assert.calledWithExactly(sign, sinon.match.string) - const { txType, tx: { updates } } = unpackTx(sign.firstCall.args[0]) + sinon.assert.calledWithExactly( + sign, + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount: sinon.match(amount), + from: sinon.match(await responder.address()), + to: sinon.match(await initiator.address()), + op: sinon.match('OffChainTransfer') + }]) + }) + ) + const { txType } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelOffChain') - updates[0].txType.should.equal('channelOffChainUpdateTransfer') - updates[0].tx.should.eql({ - ...updates[0].tx, - from: await responder.address(), - to: await initiator.address(), - amount: amount.toString() + sign.firstCall.args[1].should.eql({ + updates: [ + { + amount, + from: await responder.address(), + to: await initiator.address(), + op: 'OffChainTransfer' + } + ] }) }) @@ -250,9 +302,30 @@ describe.skip('Channel', function () { sinon.assert.calledOnce(onWithdrawLocked) sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('withdraw_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('withdraw_ack'), + sinon.match.string, + sinon.match({ + updates: [{ + amount, + op: 'OffChainWithdrawal', + to: await initiator.address() + }] + }) + ) sinon.assert.calledOnce(sign) - sinon.assert.calledWithExactly(sign, sinon.match.string) + sinon.assert.calledWithExactly( + sign, + sinon.match.string, + sinon.match({ + updates: [{ + amount, + op: 'OffChainWithdrawal', + to: await initiator.address() + }] + }) + ) const { txType, tx } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelWithdraw') tx.should.eql({ @@ -280,9 +353,30 @@ describe.skip('Channel', function () { sinon.assert.notCalled(onWithdrawLocked) sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('withdraw_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('withdraw_ack'), + sinon.match.string, + sinon.match({ + updates: [{ + amount, + op: 'OffChainWithdrawal', + to: await initiator.address() + }] + }) + ) sinon.assert.calledOnce(sign) - sinon.assert.calledWithExactly(sign, sinon.match.string) + sinon.assert.calledWithExactly( + sign, + sinon.match.string, + sinon.match({ + updates: [{ + amount, + op: 'OffChainWithdrawal', + to: await initiator.address() + }] + }) + ) const { txType, tx } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelWithdraw') tx.should.eql({ @@ -311,9 +405,30 @@ describe.skip('Channel', function () { sinon.assert.calledOnce(onDepositLocked) sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('deposit_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('deposit_ack'), + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount, + op: 'OffChainDeposit', + from: await initiator.address() + }]) + }) + ) sinon.assert.calledOnce(sign) - sinon.assert.calledWithExactly(sign, sinon.match.string) + sinon.assert.calledWithExactly( + sign, + sinon.match.string, + sinon.match({ + updates: sinon.match([{ + amount, + op: 'OffChainDeposit', + from: await initiator.address() + }]) + }) + ) const { txType, tx } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelDeposit') tx.should.eql({ @@ -341,7 +456,18 @@ describe.skip('Channel', function () { sinon.assert.notCalled(onDepositLocked) sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('deposit_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('deposit_ack'), + sinon.match.string, + sinon.match({ + updates: [{ + amount, + op: 'OffChainDeposit', + from: await initiator.address() + }] + }) + ) const { txType, tx } = unpackTx(sign.firstCall.args[0]) txType.should.equal('channelDeposit') tx.should.eql({ @@ -357,7 +483,12 @@ describe.skip('Channel', function () { result.should.be.a('string') sinon.assert.notCalled(initiatorSign) sinon.assert.calledOnce(responderSign) - sinon.assert.calledWithExactly(responderSign, sinon.match('shutdown_sign_ack'), sinon.match.string) + sinon.assert.calledWithExactly( + responderSign, + sinon.match('shutdown_sign_ack'), + sinon.match.string, + sinon.match.any + ) sinon.assert.calledOnce(sign) sinon.assert.calledWithExactly(sign, sinon.match.string) const { txType, tx } = unpackTx(sign.firstCall.args[0]) @@ -715,7 +846,7 @@ describe.skip('Channel', function () { }) it('when posting incorrect update tx', async () => { - return update({ sign: () => 'abcdefg' }).should.eventually.be.rejectedWith('Internal error') + return update({ sign: () => 'abcdefg' }).should.eventually.be.rejectedWith('Rejected') }) }) })