@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/rollup/create-block.js

@@ -0,0 +1,333 @@
+/* eslint-disable indent */
+const pick = require('lodash/pick');
+const Error = require('@ocap/util/lib/error');
+const MerkleTree = require('@ocap/merkle-tree');
+const Joi = require('@arcblock/validator');
+const { formatMessage } = require('@ocap/message');
+const { toStakeAddress } = require('@arcblock/did-util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake, rollup, rollupBlock, tx: Tx } = require('@ocap/state');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:create-rollup-block`);
+
+const VerifySigners = require('./pipes/verify-signers');
+const VerifyEvidence = require('./pipes/verify-evidence');
+const VerifyPaused = require('./pipes/verify-paused');
+const { applyTokenChange, ensureBlockReward, getRewardLocker } = require('../../util');
+
+const runner = new Runner();
+
+// 1. verify itx
+const schema = Joi.object({
+  hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  height: Joi.number().integer().greater(0).required(),
+  merkleRoot: Joi.string().regex(Joi.patterns.txHash).required(),
+  previousHash: Joi.string().when('height', {
+    is: 1,
+    then: Joi.string().optional().allow(''),
+    otherwise: Joi.string().regex(Joi.patterns.txHash).required(),
+  }),
+  txsHash: Joi.string().regex(Joi.patterns.txHash).required(),
+  txsList: Joi.array().items(Joi.string().regex(Joi.patterns.txHash).required()).min(1).unique().required(),
+  proposer: Joi.DID().wallet('ethereum').required(),
+  signaturesList: Joi.schemas.multiSig.min(1).required(),
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  minReward: Joi.BN().min(0).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+runner.use((context, next) => {
+  const { tx, itx } = context;
+
+  context.formattedItx = formatMessage('CreateRollupBlockTx', itx);
+
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', error.message));
+  }
+
+  // ensure proposer same with tx.from
+  if (tx.from !== itx.proposer) {
+    return next(new Error('INVALID_TX', 'itx.proposer must be same with tx.from'));
+  }
+
+  // ensure proposer in signer list
+  if (tx.signaturesList.some((x) => x.signer === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer must exist in signatures'));
+  }
+
+  // ensure tx hash match with txs
+  const txsHash = MerkleTree.getListHash(itx.txsList);
+  if (txsHash !== itx.txsHash) {
+    return next(new Error('INVALID_TX', 'itx.txsHash does not match with itx.txs'));
+  }
+
+  // ensure block hash is correct
+  const blockHash = MerkleTree.getBlockHash({
+    ...pick(itx, ['height', 'merkleRoot', 'txsHash']),
+    previousHash: itx.height === 1 ? '' : itx.previousHash,
+  });
+  if (blockHash !== itx.hash) {
+    return next(new Error('INVALID_TX', 'itx.hash invalid'));
+  }
+
+  return next();
+});
+
+// 2. verify rollup state & height
+runner.use(pipes.ExtractState({ from: 'itx.rollup', to: 'rollupState', status: 'INVALID_ROLLUP', table: 'rollup' }));
+runner.use(VerifyPaused());
+runner.use((context, next) => {
+  const { itx, rollupState } = context;
+  if (itx.height !== rollupState.blockHeight + 1) {
+    return next(
+      new Error('INVALID_TX', `Expect new block height to be ${rollupState.blockHeight + 1}, got ${itx.height}`)
+    );
+  }
+
+  // ensure proposer in validator list
+  if (rollupState.validators.some((x) => x.address === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer does not exist in validators'));
+  }
+
+  // ensure block size
+  const blockSize = itx.txsList.length;
+  if (blockSize < rollupState.minBlockSize) {
+    return next(
+      new Error('INVALID_TX', `Expect at least ${rollupState.minBlockSize} tx in the block, got ${blockSize}`)
+    );
+  }
+  if (blockSize > rollupState.maxBlockSize) {
+    return next(
+      new Error('INVALID_TX', `Expect at most ${rollupState.maxBlockSize} tx in the block, got ${blockSize}`)
+    );
+  }
+
+  return next();
+});
+
+// 4. verify evidence signers, signatures, state
+runner.use(VerifySigners({ signersKey: 'itx.signaturesList', allowSender: true }));
+runner.use(VerifyEvidence({ evidenceKey: 'itx.hash', signaturesKey: 'itx.signaturesList', verifyMethod: 'ethVerify' }));
+
+// 3. verify signers & signatures
+runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: true }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
+
+// 4. verify sender and signer states
+runner.use(
+  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
+);
+runner.use(
+  pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })
+);
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 5. verify previous block
+runner.use(pipes.ExtractState({ from: 'itx.previousHash', to: 'previousBlock', status: 'OK', table: 'rollupBlock' }));
+runner.use((context, next) => {
+  const { txTime, itx, previousBlock, rollupState } = context;
+  if (itx.height > 1) {
+    if (!previousBlock) {
+      return next(new Error('INVALID_TX', `Rollup block with height ${itx.height} does not exist`));
+    }
+
+    if (itx.height !== previousBlock.height + 1) {
+      return next(
+        new Error(
+          'INVALID_TX',
+          `Unexpected previous block height, expected ${itx.height - 1}, got ${previousBlock.height}`
+        )
+      );
+    }
+
+    // ensure minBlockInterval
+    const minBlockTime = +new Date(previousBlock.context.genesisTime) + rollupState.minBlockInterval * 1000;
+    const newBlockTime = +new Date(txTime);
+    if (newBlockTime < minBlockTime) {
+      return next(
+        new Error('INVALID_TX', `Block does not comply with minBlockInterval: ${new Date(minBlockTime).toISOString()}`)
+      );
+    }
+  }
+
+  return next();
+});
+
+// 6. verify new block
+runner.use(pipes.ExtractState({ from: 'itx.hash', to: 'newBlock', status: 'OK', table: 'rollupBlock' }));
+runner.use((context, next) => {
+  if (context.newBlock) {
+    return next(new Error('INVALID_TX', `Rollup block with height ${context.itx.height} already exists`));
+  }
+
+  return next();
+});
+
+// 7. verify token state
+runner.use(
+  pipes.ExtractState({ from: 'rollupState.tokenAddress', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })
+);
+
+// 8. verify txs
+runner.use(pipes.ExtractState({ from: 'itx.txsList', to: 'txStates', status: 'INVALID_TX', table: 'tx' }));
+runner.use(({ itx, txStates }, next) => {
+  // ensure not finalized
+  const finalizedTx = txStates.some((x) => x.finalized);
+  if (finalizedTx) {
+    return next(new Error('INVALID_TX', 'Should not include finalized tx in later block'));
+  }
+
+  // ensure tx are successfully executed
+  const invalidStatusTx = txStates.some((x) => x.code !== 'OK');
+  if (invalidStatusTx) {
+    return next(new Error('INVALID_TX', 'Rollup block can only include successful executed transactions'));
+  }
+
+  // ensure tx type
+  const invalidTypeTx = txStates.some((x) => ['deposit_token_v2', 'withdraw_token_v2'].includes(x.type) === false);
+  if (invalidTypeTx) {
+    return next(new Error('INVALID_TX', "Rollup block can only include 'withdraw_token' and 'deposit_token' tx"));
+  }
+
+  // ensure rollup belonging
+  const invalidRollupTx = txStates.some((x) => x.tx.itxJson.rollup !== itx.rollup);
+  if (invalidRollupTx) {
+    return next(new Error('INVALID_TX', `Rollup block can only include tx from rollup ${itx.rollup}`));
+  }
+
+  // ensure merkleRoot
+  const merkleTree = MerkleTree.getBlockMerkleTree(
+    txStates
+      .filter((x) => x.type === 'withdraw_token_v2')
+      .map((x) => ({
+        hash: x.hash,
+        to: x.tx.itxJson.to,
+        amount: x.tx.itxJson.token.value,
+      }))
+  );
+  if (merkleTree.getHexRoot() !== itx.merkleRoot) {
+    return next(new Error('INVALID_TX', 'Invalid rollup block merkle root'));
+  }
+
+  return next();
+});
+
+// 9. verify staking: used for minting & burning
+runner.use((context, next) => {
+  const { itx, txStates } = context;
+
+  const depositProposerStakeAddr = txStates
+    .filter((x) => x.type === 'deposit_token_v2')
+    .map((x) => toStakeAddress(x.tx.itxJson.proposer, itx.rollup));
+
+  const withdrawLockerStakeAddr = txStates
+    .filter((x) => x.type === 'withdraw_token_v2')
+    .map((x) => toStakeAddress(x.tx.from, itx.rollup));
+
+  context.stakeAddress = [...depositProposerStakeAddr, ...withdrawLockerStakeAddr, getRewardLocker(itx.rollup)];
+
+  return next();
+});
+runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeStates', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+
+// 10. ensure block reward and dynamic tx fees
+runner.use((context, next) => {
+  const { itx, txStates, rollupState } = context;
+  try {
+    const result = ensureBlockReward(rollupState, itx.minReward, txStates);
+    context.senders = Object.keys(result.accountUpdates);
+    Object.assign(context, result);
+    return next();
+  } catch (err) {
+    return next(err);
+  }
+});
+runner.use(pipes.ExtractState({ from: 'senders', to: 'senderStates', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+
+// 11. update state: mint tokens for deposits, burn tokens for withdraws
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, rollupState, senderState, stakeStates, txStates, formattedItx } = context;
+    const senderStates = context.senderStates || [];
+
+    const [newSenderState, newStakeStates, newSenderStates, newRollupState, rollupBlockState, newTxStates] =
+      await Promise.all([
+        // update sender(proposer) account
+        statedb.account.update(
+          senderState.address,
+          account.update(senderState, Object.assign({ nonce: tx.nonce }), context),
+          context
+        ),
+
+        // update stake states
+        Promise.all(
+          stakeStates.map((x) =>
+            context.stakeUpdates[x.address]
+              ? statedb.stake.update(
+                  x.address,
+                  stake.update(x, applyTokenChange(x, context.stakeUpdates[x.address]), context),
+                  context
+                )
+              : Promise.resolve(x)
+          )
+        ),
+
+        // update tx owner states: those may get refund
+        Promise.all(
+          senderStates.map((x) =>
+            statedb.account.update(
+              x.address,
+              account.update(x, applyTokenChange(x, context.accountUpdates[x.address]), context),
+              context
+            )
+          )
+        ),
+
+        // Update rollup state
+        statedb.rollup.update(
+          rollupState.address,
+          rollup.update(rollupState, { blockHeight: itx.height, blockHash: itx.hash }, context),
+          context
+        ),
+
+        // Create rollup block
+        statedb.rollupBlock.create(
+          itx.hash,
+          rollupBlock.create(
+            {
+              ...formattedItx,
+              ...['rewardAmount', 'mintedAmount', 'burnedAmount'].reduce((acc, x) => {
+                acc[x] = context[x].toString(10);
+                return acc;
+              }, {}),
+            },
+            context
+          ),
+          context
+        ),
+
+        // Update tx states: mark as finalized
+        Promise.all(
+          txStates.map((x) => statedb.tx.update(x.hash, Tx.update(x, { finalized: true, tx: x.tx }), context))
+        ),
+      ]);
+
+    context.senderState = newSenderState;
+    context.stakeStates = newStakeStates.filter((x) => context.stakeUpdates[x.address]);
+    context.newSenderStates = newSenderStates;
+    context.rollupState = newRollupState;
+    context.rollupBlockState = rollupBlockState;
+    context.txStates = newTxStates;
+
+    context.updatedAccounts = [...Object.values(context.stakeUpdates), ...Object.values(context.accountUpdates)];
+
+    debug('create-rollup-block', { itx, updatedAccounts: context.updatedAccounts });
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/rollup/create.js

@@ -0,0 +1,169 @@
+/* eslint-disable indent */
+const isEmpty = require('empty-value');
+const cloneDeep = require('lodash/cloneDeep');
+const Error = require('@ocap/util/lib/error');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, rollup } = require('@ocap/state');
+const { formatMessage } = require('@ocap/message');
+const { isFromPublicKey, isEthereumDid } = require('@arcblock/did');
+const { toRollupAddress } = require('@arcblock/did-util');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:create-rollup`);
+
+const { decodeAnySafe } = require('../../util');
+const ensureServiceFee = require('./pipes/ensure-service-fee');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+// 0. verify itx
+runner.use((context, next) => {
+  const { itx } = context;
+  context.formattedItx = formatMessage('CreateRollupTx', itx);
+
+  try {
+    rollup.create(context.formattedItx, context);
+  } catch (err) {
+    return next(new Error('INVALID_TX', err.message));
+  }
+
+  return next();
+});
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TX',
+      message: 'Sum of itx.proposerFeeShare and itx.publisherFeeShare must be less than 10000',
+      fn: ({ itx }) => itx.proposerFeeShare + itx.publisherFeeShare < 10000,
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Seed validator pk and address not match',
+      fn: ({ formattedItx }) => formattedItx.seedValidators.every(({ pk, address }) => isFromPublicKey(address, pk)),
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Seed validator must use ethereum compatible address',
+      fn: ({ formattedItx }) => formattedItx.seedValidators.every(({ address }) => isEthereumDid(address)),
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Rollup address is not valid',
+      fn: (context) => {
+        const itx = cloneDeep(context.itx);
+        itx.data = decodeAnySafe(itx.data);
+        itx.address = '';
+
+        // Save for later use
+        context.rollupData = itx.data;
+        context.seedValidators = itx.seedValidatorsList.map((x) => x.address);
+
+        return toRollupAddress(itx) === context.itx.address;
+      },
+    },
+  ])
+);
+
+// 1. ensure sender, validators, delegation
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'seedValidators', to: 'validatorStates', status: 'INVALID_VALIDATOR_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'validatorStates', senderKey: 'senderState' }));
+runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK', table: 'account' }));
+runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
+
+// 2. ensure token exist and match
+runner.use(pipes.ExtractState({ from: 'itx.tokenAddress', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TOKEN',
+      message: 'Token does not have foreignToken attached',
+      fn: ({ tokenState }) => isEmpty(tokenState.foreignToken) === false,
+    },
+  ])
+);
+
+// 3. ensure only 1 rollup for a token
+runner.use(async (context, next) => {
+  const { statedb, itx } = context;
+  const exist = await statedb.rollup.existByToken(itx.tokenAddress, context);
+  if (exist) {
+    return next(new Error('DUPLICATE_ROLLUP', 'Only 1 rollup can be created for the token'));
+  }
+
+  return next();
+});
+
+// 4. ensure rollup not exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'rollupState', status: 'OK', table: 'rollup' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'DUPLICATE_ROLLUP',
+      message: 'This rollup already exist on chain',
+      fn: (context) => isEmpty(context.rollupState),
+    },
+  ])
+);
+
+runner.use(ensureServiceFee);
+
+// 5. create rollup state
+runner.use(
+  async (context, next) => {
+    const {
+      tx,
+      formattedItx,
+      rollupData,
+      statedb,
+      senderState,
+      delegatorState,
+      senderUpdates,
+      vaultState,
+      vaultUpdates,
+    } = context;
+
+    const issuer = delegatorState ? delegatorState.address : senderState.address;
+    const [newSenderState, rollupState, newVaultState] = await Promise.all([
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, ...senderUpdates }, context),
+        context
+      ),
+
+      statedb.rollup.create(
+        formattedItx.address,
+        rollup.create(
+          {
+            ...formattedItx,
+            issuer,
+            validators: formattedItx.seedValidators,
+            data: rollupData,
+          },
+          context
+        ),
+        context
+      ),
+
+      isEmpty(vaultUpdates)
+        ? vaultState
+        : statedb.account.update(vaultState.address, account.update(vaultState, vaultUpdates, context), context),
+    ]);
+
+    // FIXME: create-rollup 的时候不能校验 stake，还是在这里创建 stake？如果在这里创建 stake，是否需要多签？
+    // FIXME: seed validator 无法离开， account migration 也需要测试下
+
+    context.senderState = newSenderState;
+    context.rollupState = rollupState;
+    context.vaultState = newVaultState;
+
+    debug('create-rollup', rollupState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/rollup/join.js

@@ -0,0 +1,156 @@
+/* eslint-disable indent */
+const MerkleTree = require('@ocap/merkle-tree');
+const joinUrl = require('url-join');
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+const { BN, toHex } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, rollup, stake, evidence } = require('@ocap/state');
+const { toStakeAddress } = require('@arcblock/did-util');
+const { isEthereumDid } = require('@arcblock/did');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:join-rollup`);
+
+const VerifySigners = require('./pipes/verify-signers');
+const VerifyEvidence = require('./pipes/verify-evidence');
+const VerifyPaused = require('./pipes/verify-paused');
+
+const runner = new Runner();
+
+// 1. verify itx
+const schema = Joi.object({
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  endpoint: Joi.string()
+    .uri({ scheme: [/https?/] })
+    .required(),
+  evidence: Joi.object({
+    hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  }).required(),
+  signaturesList: Joi.schemas.multiSig.min(1).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+runner.use(({ itx }, next) => {
+  const { error } = schema.validate(itx);
+  return next(error ? new Error('INVALID_TX', `Invalid itx: ${error.message}`) : null);
+});
+
+// 2. verify rollup
+runner.use(pipes.ExtractState({ from: 'itx.rollup', to: 'rollupState', status: 'INVALID_ROLLUP', table: 'rollup' }));
+runner.use(VerifyPaused());
+
+// 3. verify new validator
+runner.use((context, next) => {
+  const { tx, itx, rollupState } = context;
+  const validator = { pk: toHex(tx.pk), address: tx.from, endpoint: itx.endpoint };
+  if (isEthereumDid(tx.from) === false) {
+    return next(new Error('INVALID_TX', 'Invalid tx.from: only ethereum compatible address can join rollup'));
+  }
+
+  if (rollupState.validators.some((x) => x.address === validator.address)) {
+    return next(new Error('INVALID_TX', `Address ${validator.address} already exist in validators`));
+  }
+
+  // The endpoint should not contain any pathname
+  if (rollupState.validators.some((x) => joinUrl(x.endpoint, '/') === joinUrl(validator.endpoint, '/'))) {
+    return next(new Error('INVALID_TX', `Endpoint ${validator.endpoint} already exist in validators`));
+  }
+
+  context.newValidator = validator;
+  context.validatorsHash = MerkleTree.getListHash([validator.address]);
+
+  return next();
+});
+
+// 4. verify evidence signers, signatures, state
+runner.use(VerifySigners({ signersKey: 'itx.signaturesList', allowSender: false }));
+runner.use(
+  VerifyEvidence({ evidenceKey: 'validatorsHash', signaturesKey: 'itx.signaturesList', verifyMethod: 'ethVerify' })
+);
+runner.use(pipes.ExtractState({ from: 'itx.evidence.hash', to: 'evidenceState', status: 'OK', table: 'evidence' }));
+runner.use(({ evidenceState }, next) => {
+  if (evidenceState) return next(new Error('INVALID_TX', 'Join evidence already seen on this chain'));
+  return next();
+});
+
+// 5. verify tx signers and signatures
+runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: false }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
+
+// 6. verify staking: get address, extract state, verify amount
+runner.use((context, next) => {
+  const { tx, itx } = context;
+  context.stakeAddress = toStakeAddress(tx.from, itx.rollup);
+  return next();
+});
+runner.use(
+  pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })
+);
+runner.use((context, next) => {
+  const { stakeState, rollupState } = context;
+  if (stakeState.revocable === false) {
+    return next(new Error('INVALID_STAKE_STATE', `Staking already locked: ${stakeState.address}`));
+  }
+
+  const actualStake = new BN(stakeState.tokens[rollupState.tokenAddress] || 0);
+  const requiredStake = new BN(rollupState.minStakeAmount);
+  if (actualStake.lt(requiredStake)) {
+    return next(new Error('INVALID_STAKE_STATE', `Staking does not match min stake amount: ${requiredStake}`));
+  }
+
+  return next();
+});
+
+// 7. verify sender and signer states
+runner.use(
+  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
+);
+runner.use(
+  pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })
+);
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 8. update state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, rollupState, statedb, senderState, stakeState, newValidator, stakeAddress } = context;
+    const newValidators = rollupState.validators.concat([newValidator]);
+
+    const [newSenderState, newRollupState, newStakeState, evidenceState] = await Promise.all([
+      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+
+      // persist new validators list
+      statedb.rollup.update(
+        rollupState.address,
+        rollup.update(rollupState, { validators: newValidators }, context),
+        context
+      ),
+
+      // lock the stake from the new validator for defined period
+      statedb.stake.update(
+        stakeAddress,
+        stake.update(stakeState, { revocable: false, revokeWaitingPeriod: rollupState.leaveWaitingPeriod }, context),
+        context
+      ),
+
+      // Create evidence state
+      statedb.evidence.create(
+        itx.evidence.hash,
+        evidence.create({ hash: itx.evidence.hash, data: 'rollup-join' }, context),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.rollupState = newRollupState;
+    context.stakeState = newStakeState;
+    context.evidenceState = evidenceState;
+
+    debug('join-rollup', newValidators);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;