@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/asset/update.js

@@ -1,73 +1,105 @@
+const deepDiff = require('deep-diff');
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
 const { account, asset } = require('@ocap/state');
 
 // eslint-disable-next-line global-require
 const debug = require('debug')(`${require('../../../package.json').name}:update-asset`);
 
-const { decodeItxData } = require('../../util');
+const { decodeAnySafe } = require('../../util');
 
 const runner = new Runner();
 
 runner.use(pipes.VerifyMultiSig(0));
 
-runner.use(
-  pipes.VerifyInfo([
-    {
-      error: 'INSUFFICIENT_DATA',
-      message: 'itx.data or itx.address must not be empty',
-      fn: ({ itx }) => itx.address && itx.moniker && itx.data,
-    },
-  ])
-);
+// Verify itx
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_ASSET').required(),
+  moniker: Joi.string().min(2).max(255).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+runner.use((context, next) => {
+  const { itx } = context;
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+
+  context.newData = decodeAnySafe(itx.data);
+  return next();
+});
+
+// Ensure asset exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'assetState', status: 'INVALID_ASSET', table: 'asset' }));
+runner.use(pipes.ExtractState({ from: 'assetState.issuer', to: 'issuerState', status: 'OK', table: 'account' }));
 
 // Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
 
-// Ensure asset exist owned by sender and can be modified
-runner.use(pipes.ExtractState({ from: 'itx.address', to: 'assetState', status: 'INVALID_ASSET' }));
+// Ensure asset owned by sender and can be modified
 runner.use(pipes.VerifyUpdater({ assetKey: 'assetState', ownerKey: 'senderState', updaterKey: ['owner', 'issuer'] }));
 runner.use(
   pipes.VerifyInfo([
     {
       error: 'READONLY_ASSET',
-      message: 'Asset is readonly',
+      message: 'Can not update a readonly asset',
       fn: ({ assetState }) => assetState.readonly === false,
+      persist: true,
     },
   ])
 );
 
-// Update asset state
+// Ensure we are in append-only mode update proposed by issuer
 runner.use(async (context, next) => {
-  const { tx, itx, statedb, senderState, assetState } = context;
-  const data = decodeItxData(itx.data);
-
-  // Update owner state
-  const ownerState = await statedb.account.update(
-    senderState.address,
-    account.update(senderState, { nonce: tx.nonce }, context),
-    context
-  );
-
-  const newAssetState = await statedb.asset.update(
-    itx.address,
-    asset.update(
-      assetState,
-      {
-        moniker: itx.moniker,
-        data,
-      },
-      context
-    ),
-    context
-  );
-
-  context.senderState = ownerState;
-  context.assetState = newAssetState;
-
-  debug('update', newAssetState);
-
-  next();
+  const { itx, newData, senderState, assetState, issuerState } = context;
+  if (issuerState && senderState.address === issuerState.address) {
+    if (itx.moniker !== assetState.moniker) {
+      return next(new Error('FORBIDDEN', 'Asset moniker can only be updated by owner'));
+    }
+    if (newData.type !== assetState.data.type) {
+      return next(new Error('FORBIDDEN', 'Asset data type can only be updated by owner'));
+    }
+    const dataDiff = deepDiff(assetState.data.value, newData.value);
+    const appendOnly = dataDiff.every((x) => x.kind === 'N' || (x.kind === 'A' && x.item.kind === 'N'));
+    if (appendOnly === false) {
+      return next(new Error('APPEND_ONLY', 'Asset data value can only be updated in append only mode'));
+    }
+  }
+
+  return next();
 });
 
+// Update asset state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, newData, statedb, senderState, assetState } = context;
+
+    const [newSenderState, newAssetState] = await Promise.all([
+      // update owner state
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk }, context),
+        context
+      ),
+
+      // update asset state
+      statedb.asset.update(
+        itx.address,
+        asset.update(assetState, { moniker: itx.moniker, data: newData }, context),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.assetState = newAssetState;
+
+    debug('update', newAssetState);
+
+    next();
+  },
+  { persistError: true }
+);
+
 module.exports = runner;

package/lib/protocols/factory/create.js

@@ -0,0 +1,146 @@
+/* eslint-disable indent */
+const get = require('lodash/get');
+const isEmpty = require('empty-value');
+const cloneDeep = require('lodash/cloneDeep');
+const Error = require('@ocap/util/lib/error');
+const { isValidFactory } = require('@ocap/asset');
+const { formatMessage } = require('@ocap/message');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { BN } = require('@ocap/util');
+const { account, factory } = require('@ocap/state');
+const { toFactoryAddress } = require('@arcblock/did-util');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:create-factory`);
+
+const { decodeAnySafe } = require('../../util');
+const ensureServiceFee = require('../rollup/pipes/ensure-service-fee');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+// validate factory props
+runner.use((context, next) => {
+  const factoryProps = formatMessage('CreateFactoryTx', context.itx);
+
+  try {
+    isValidFactory(factoryProps);
+  } catch (err) {
+    return next(new Error('INVALID_FACTORY_PROPS', err.message));
+  }
+
+  if (factoryProps.output.data) {
+    factoryProps.output.data = decodeAnySafe(factoryProps.output.data);
+  }
+
+  if (factoryProps.name.length < 2 || factoryProps.name.length > 255) {
+    return next(new Error('INVALID_FACTORY_PROPS', 'Length of factory name should between 2 and 255 characters'));
+  }
+
+  const props = cloneDeep(factoryProps);
+  props.address = '';
+  if (toFactoryAddress(props) !== factoryProps.address) {
+    return next(new Error('INVALID_FACTORY_PROPS', 'Factory address is not valid'));
+  }
+
+  context.factoryTokens = (factoryProps.input.tokens || []).map((x) => x.address);
+
+  // ensure max tokens length
+  const maxListSize = get(context, 'config.transaction.maxListSize');
+  if (context.factoryTokens.length > maxListSize) {
+    return next(new Error('INVALID_FACTORY_INPUT', `input.tokens exceeded max allowed length: ${maxListSize}`));
+  }
+  if (factoryProps.input.assets.length > maxListSize) {
+    return next(new Error('INVALID_FACTORY_INPUT', `input.assets exceeded max allowed length: ${maxListSize}`));
+  }
+
+  // For backwards compatibility, merge tokens
+  if (new BN(factoryProps.input.value || 0).gt(new BN(0))) {
+    context.factoryTokens.push(context.config.token.address);
+    factoryProps.input.tokens.push({ address: context.config.token.address, value: factoryProps.input.value });
+    factoryProps.input.value = '0';
+  }
+
+  context.factoryProps = factoryProps;
+
+  return next();
+});
+
+// Ensure factory not exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'factoryState', status: 'OK' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'DUPLICATE_FACTORY',
+      message: 'This asset factory already exist on chain',
+      fn: (context) => isEmpty(context.factoryState),
+    },
+  ])
+);
+
+// Ensure sender exist
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', table: 'account', status: 'INVALID_SENDER_STATE' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
+
+// Ensure delegation
+runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK', table: 'account' }));
+runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
+
+// Ensure tokens exist if we are creating an factory that consume tokens
+runner.use(pipes.ExtractState({ from: 'factoryTokens', to: 'tokenStates', table: 'token', status: 'INVALID_FACTORY_INPUT' })); // prettier-ignore
+
+// ensure input.assets all exist on chain
+runner.use(pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputAssetStates', table: 'asset', status: 'OK' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputFactoryStates', table: 'factory', status: 'OK' })); // prettier-ignore
+runner.use((context, next) => {
+  const { inputAssetStates = [], inputFactoryStates = [], factoryProps } = context;
+  if (inputAssetStates.some((x) => !!x.consumedTime)) {
+    return next(new Error('INVALID_FACTORY_INPUT', 'Some of input.assets already consumed'));
+  }
+
+  if (inputAssetStates.length + inputFactoryStates.length === factoryProps.input.assets.length) {
+    return next();
+  }
+
+  return next(new Error('INVALID_FACTORY_INPUT', 'Not all input.assets exist on chain'));
+});
+
+runner.use(ensureServiceFee);
+
+// Create factory state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, senderState, delegatorState, senderUpdates, vaultState, vaultUpdates, factoryProps } =
+      context;
+    const tokens = { [context.config.token.address]: '0' };
+    const owner = delegatorState ? delegatorState.address : senderState.address;
+
+    const [newSenderState, factoryState, newVaultState] = await Promise.all([
+      // Update owner state
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      // Create factory state
+      statedb.factory.create(itx.address, factory.create({ ...factoryProps, tokens, owner }, context), context),
+
+      isEmpty(vaultUpdates)
+        ? vaultState
+        : statedb.account.update(vaultState.address, account.update(vaultState, vaultUpdates, context), context),
+    ]);
+
+    context.senderState = newSenderState;
+    context.factoryState = factoryState;
+    context.vaultState = newVaultState;
+
+    debug('createFactory', factoryState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/governance/claim-stake.js

@@ -0,0 +1,219 @@
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, asset, stake, evidence } = require('@ocap/state');
+const getRelatedAddresses = require('@ocap/util/lib/get-related-addr');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:acquire-asset-v2`);
+
+const { applyTokenUpdates } = require('../../util');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+// 1. verify itx output
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_STAKE').required(),
+  evidence: Joi.object({
+    hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  }).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 stake state & sender state
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'SENDER_NOT_MATCH',
+      message: 'You are not allowed to claim stake from this address',
+      fn: ({ senderState, stakeState }) => getRelatedAddresses(senderState).includes(stakeState.sender),
+    },
+  ])
+);
+
+// 3. verify evidence replay
+runner.use(pipes.ExtractState({ from: 'itx.evidence.hash', to: 'evidenceState', status: 'OK', table: 'evidence' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'ALREADY_CLAIMED',
+      message: 'Revoke evidence already seen on this chain',
+      fn: ({ evidenceState }) => !evidenceState,
+    },
+  ])
+);
+
+// 4. verify evidence tx
+runner.use(pipes.ExtractState({ from: 'itx.evidence.hash', to: 'txState', status: 'INVALID_TX', table: 'tx' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TX',
+      message: 'Evidence tx is not valid',
+      fn: ({ txState }) => txState.code === 'OK',
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Evidence tx type is not valid',
+      fn: ({ txState }) => txState.type === 'revoke_stake',
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Evidence tx does not belong to same stake',
+      fn: ({ txState, itx }) => txState.tx.itxJson.address === itx.address,
+    },
+    {
+      error: 'WITHIN_WAITING_PERIOD',
+      message: 'You can not claim stake before waiting period ends',
+      fn: ({ txState, stakeState, txTime }) => {
+        const end = +new Date(txState.time) + (stakeState.revokeWaitingPeriod || 0) * 1000;
+        const now = +new Date(txTime);
+        return now > end;
+      },
+    },
+  ])
+);
+
+// 5. assemble output
+runner.use(
+  pipes.VerifyTxInput({
+    fieldKey: 'txState.tx.itxJson.outputs',
+    inputsKey: 'outputs',
+    sendersKey: 'receivers',
+    tokensKey: 'tokens',
+    assetsKey: 'assets',
+  })
+);
+
+// 6. verify receiver states
+runner.use(pipes.ExtractState({ from: 'receivers', to: 'receiverStates', status: 'INVALID_RECEIVER_STATE', table: 'account' })); // prettier-ignore
+
+// 7. verify token state and balance
+runner.use(pipes.ExtractState({ from: 'tokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
+runner.use((context, next) => {
+  const { outputs, stakeState } = context;
+  const tokensToClaim = {};
+  outputs.forEach(({ tokens }) => {
+    tokens.forEach(({ address, value }) => {
+      if (typeof tokensToClaim[address] === 'undefined') {
+        tokensToClaim[address] = new BN(0);
+      }
+      tokensToClaim[address] = tokensToClaim[address].add(new BN(value));
+    });
+  });
+
+  context.tokenCondition = {
+    owner: stakeState.address,
+    tokens: Object.keys(tokensToClaim).map((address) => ({ address, value: tokensToClaim[address] })),
+  };
+
+  next();
+});
+runner.use(
+  pipes.VerifyTokenBalance({
+    ownerKey: 'stakeState',
+    conditionKey: 'tokenCondition',
+    tokensKey: 'revokedTokens',
+  })
+);
+
+// 7. verify asset state and ownership
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'OK', table: 'asset' }));
+runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
+runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'stakeState' }));
+
+// 8. update statedb
+runner.use(
+  async (context, next) => {
+    const { tx, itx, outputs, statedb, senderState, stakeState, receiverStates, assetStates = [] } = context;
+
+    const receiverUpdates = {};
+    const assetUpdates = {};
+    const stakeUpdates = {
+      revokedTokens: stakeState.revokedTokens || {},
+      revokedAssets: stakeState.revokedAssets || [],
+    };
+
+    outputs.forEach((x) => {
+      const { owner, tokens, assets } = x;
+
+      // Update receiver balance
+      const ownerState = receiverStates.find((s) => getRelatedAddresses(s).includes(owner));
+      receiverUpdates[ownerState.address] = applyTokenUpdates(tokens, ownerState, 'add');
+
+      // Update asset owner
+      assets.forEach((a) => {
+        assetUpdates[a] = { owner: ownerState.address };
+      });
+
+      // Update Stake Revoked fields
+      const revoked = applyTokenUpdates(tokens, { tokens: stakeUpdates.revokedTokens }, 'sub');
+      stakeUpdates.revokedTokens = revoked.tokens;
+      stakeUpdates.revokedAssets = stakeUpdates.revokedAssets.filter((a) => assets.includes(a) === false);
+    });
+
+    const isAlsoSigner = !!receiverUpdates[senderState.address];
+
+    const [newSenderState, newReceiverStates, newStakeState, newAssetStates, evidenceState] = await Promise.all([
+      // Update sender state
+      statedb.account.update(
+        senderState.address,
+        account.update(
+          senderState,
+          Object.assign({ nonce: tx.nonce }, receiverUpdates[senderState.address] || {}),
+          context
+        ),
+        context
+      ),
+
+      // Update receiver states
+      Promise.all(
+        receiverStates
+          .filter((x) => x.address !== senderState.address)
+          .map((x) =>
+            statedb.account.update(x.address, account.update(x, receiverUpdates[x.address], context), context)
+          )
+      ),
+
+      // Update stake state
+      statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context),
+
+      // Transfer assets to output account
+      Promise.all(
+        assetStates.map((x) =>
+          statedb.asset.update(x.address, asset.update(x, assetUpdates[x.address], context), context)
+        )
+      ),
+
+      // Create evidence state
+      statedb.evidence.create(
+        itx.evidence.hash,
+        evidence.create({ hash: itx.evidence.hash, data: 'claim-stake' }, context),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.receiverStates = isAlsoSigner ? newReceiverStates.concat(newSenderState) : newReceiverStates;
+    context.stakeState = newStakeState;
+    context.assetStates = newAssetStates;
+    context.evidenceState = evidenceState;
+
+    debug('claim-stake', { address: itx.address, stakeUpdates, receiverUpdates, assetUpdates });
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/governance/revoke-stake.js

@@ -0,0 +1,136 @@
+const isEmpty = require('empty-value');
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake } = require('@ocap/state');
+const getRelatedAddresses = require('@ocap/util/lib/get-related-addr');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:acquire-asset-v2`);
+
+const { applyTokenUpdates } = require('../../util');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+// 1. verify itx output
+runner.use(
+  pipes.VerifyTxInput({
+    fieldKey: 'itx.outputs',
+    inputsKey: 'outputs',
+    sendersKey: 'receivers',
+    tokensKey: 'tokens',
+    assetsKey: 'assets',
+  })
+);
+
+// 2. verify itx address
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INSUFFICIENT_DATA',
+      message: 'Can not revoke stake without stake address',
+      fn: ({ itx }) => itx.address,
+    },
+    {
+      error: 'INSUFFICIENT_DATA',
+      message: 'Can not revoke stake without any output',
+      fn: ({ assets, tokens }) => !(isEmpty(tokens) && isEmpty(assets)),
+    },
+  ])
+);
+
+// 3. verify itx size: set hard limit here because more output leads to longer tx execute time
+runner.use(pipes.VerifyListSize({ listKey: ['outputs', 'receivers', 'tokens', 'assets'] }));
+
+// 4. verify sender & receiver
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'receivers', to: 'receiverStates', status: 'INVALID_RECEIVER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
+
+// 5. verify stake state
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'SENDER_NOT_MATCH',
+      message: 'You are not allowed to revoke stake from this address',
+      fn: ({ senderState, stakeState }) => getRelatedAddresses(senderState).includes(stakeState.sender),
+    },
+    {
+      error: 'STAKE_NOT_REVOCABLE',
+      message: 'This stake address is not revocable',
+      fn: ({ stakeState }) => stakeState.revocable,
+    },
+  ])
+);
+
+// 6. verify token state and balance
+runner.use(pipes.ExtractState({ from: 'tokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
+runner.use((context, next) => {
+  const { outputs, stakeState } = context;
+  const tokens = {};
+  outputs.forEach(({ tokensList }) => {
+    tokensList.forEach(({ address, value }) => {
+      if (typeof tokens[address] === 'undefined') {
+        tokens[address] = new BN(0);
+      }
+      tokens[address] = tokens[address].add(new BN(value));
+    });
+  });
+
+  context.tokenCondition = {
+    owner: stakeState.address,
+    tokens: Object.keys(tokens).map((address) => ({ address, value: tokens[address] })),
+  };
+
+  next();
+});
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'stakeState', conditionKey: 'tokenCondition' }));
+
+// 7. verify asset state and ownership
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'OK', table: 'asset' }));
+runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
+runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'stakeState' }));
+
+// 8. update statedb
+runner.use(
+  async (context, next) => {
+    const { tx, itx, outputs, statedb, senderState, stakeState } = context;
+
+    const stakeUpdates = {
+      tokens: stakeState.tokens || {},
+      assets: stakeState.assets || [],
+      revokedTokens: stakeState.revokedTokens || {},
+      revokedAssets: stakeState.revokedAssets || [],
+    };
+
+    outputs.forEach((x) => {
+      const { tokensList, assetsList } = x;
+
+      // Move tokens and assets from staked to revoked
+      const staked = applyTokenUpdates(tokensList, { tokens: stakeUpdates.tokens }, 'sub');
+      stakeUpdates.tokens = staked.tokens;
+      stakeUpdates.assets = stakeUpdates.assets.filter((a) => assetsList.includes(a) === false);
+
+      const revoked = applyTokenUpdates(tokensList, { tokens: stakeUpdates.revokedTokens }, 'add');
+      stakeUpdates.revokedTokens = revoked.tokens;
+      stakeUpdates.revokedAssets = stakeUpdates.revokedAssets.concat(...assetsList);
+    });
+
+    const [newSenderState, newStakeState] = await Promise.all([
+      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+      statedb.stake.update(stakeState.address, stake.update(stakeState, stakeUpdates, context), context),
+    ]);
+
+    context.senderState = newSenderState;
+    context.stakeState = newStakeState;
+
+    debug('revoke-stake', { address: itx.address, stakeUpdates });
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;