@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/token/create.js

@@ -0,0 +1,150 @@
+const isEmpty = require('empty-value');
+const cloneDeep = require('lodash/cloneDeep');
+const Joi = require('@arcblock/validator');
+const Error = require('@ocap/util/lib/error');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, token } = require('@ocap/state');
+const { toTokenAddress } = require('@arcblock/did-util');
+const { fromTokenToUnit } = require('@ocap/util');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:create-token`);
+const { decodeAnySafe } = require('../../util');
+const ensureServiceFee = require('../rollup/pipes/ensure-service-fee');
+
+const MAX_TOTAL_SUPPLY = fromTokenToUnit(10000 * 100000000, 18); // 32
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_TOKEN').required(),
+  name: Joi.string().min(1).max(32).required(),
+  description: Joi.string().min(1).max(128).required(),
+  symbol: Joi.string().min(2).max(6).uppercase().required(),
+  unit: Joi.string().min(1).max(6).lowercase().required(),
+  decimal: Joi.number().min(6).max(18).required(),
+  icon: Joi.string().optional().valid(''),
+  totalSupply: Joi.BN().greater(0).max(MAX_TOTAL_SUPPLY).required(),
+  initialSupply: Joi.BN().greater(0).max(Joi.ref('totalSupply')).required(),
+  foreignToken: Joi.schemas.foreignToken.optional().default(null),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+// 1. verify itx
+runner.use(({ itx }, next) => {
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+  return next();
+});
+
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TOKEN',
+      message: 'Token address is not valid',
+      fn: (context) => {
+        const itx = cloneDeep(context.itx);
+        itx.data = decodeAnySafe(itx.data);
+        itx.address = '';
+
+        return toTokenAddress(itx) === context.itx.address;
+      },
+    },
+  ])
+);
+
+// Ensure sender exist
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // 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 token not exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'tokenState', table: 'token', status: 'OK' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'DUPLICATE_TOKEN',
+      message: 'Token address already exists on chain',
+      fn: (context) => isEmpty(context.tokenState),
+    },
+  ])
+);
+
+// Ensure uniq ness of token symbol
+runner.use(async (context, next) => {
+  const { symbol } = context.config.token;
+  if (symbol.toLowerCase() === context.itx.symbol.toLowerCase()) {
+    return next(new Error('DUPLICATE_SYMBOL', `Token symbol can not be ${symbol}`));
+  }
+
+  const exist = await context.statedb.token.existBySymbol(context.itx.symbol, context);
+  if (exist) {
+    return next(new Error('DUPLICATE_SYMBOL', 'Token symbol already exists'));
+  }
+
+  return next();
+});
+
+runner.use(ensureServiceFee);
+
+// Update sender state, token state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, senderState, delegatorState, senderUpdates, vaultState, vaultUpdates } = context;
+    const data = decodeAnySafe(itx.data);
+    const owner = delegatorState ? delegatorState.address : senderState.address;
+
+    const delegatorUpdates = {};
+    senderUpdates.tokens = senderUpdates.tokens || {};
+
+    // We are definitely creating a different token, so it is safe to set tokens to initial supply
+    // For delegated create-token, the delegator is the actual token-holder
+    if (delegatorState) {
+      delegatorUpdates.tokens = delegatorState.tokens || {};
+      delegatorUpdates.tokens[itx.address] = itx.initialSupply;
+    } else {
+      senderUpdates.tokens[itx.address] = itx.initialSupply;
+    }
+
+    const [newSenderState, tokenState, newVaultState, newDelegatorState] = await Promise.all([
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      statedb.token.create(itx.address, token.create({ ...cloneDeep(itx), data, issuer: owner }, context), context),
+
+      isEmpty(vaultUpdates)
+        ? vaultState
+        : statedb.account.update(vaultState.address, account.update(vaultState, vaultUpdates, context), context),
+
+      delegatorState
+        ? statedb.account.update(
+            delegatorState.address,
+            account.update(delegatorState, delegatorUpdates, context),
+            context
+          )
+        : null,
+    ]);
+
+    context.senderState = newSenderState;
+    context.tokenState = tokenState;
+    context.vaultState = newVaultState;
+    context.delegatorState = newDelegatorState;
+
+    debug('create token v2', tokenState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/token/deposit-v2.js

@@ -0,0 +1,241 @@
+/* eslint-disable indent */
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+const getListField = require('@ocap/util/lib/get-list-field');
+const { BN, fromUnitToToken } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake, evidence } = require('@ocap/state');
+const { toStakeAddress } = require('@arcblock/did-util');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:deposit-token`);
+
+const VerifySigners = require('../rollup/pipes/verify-signers');
+const VerifyPaused = require('../rollup/pipes/verify-paused');
+const { applyTokenUpdates, getTxFee, getBNSum, getRewardLocker } = require('../../util');
+
+const schema = Joi.object({
+  token: Joi.schemas.tokenInput.required(),
+  to: Joi.DID().wallet('ethereum').required(),
+  proposer: Joi.DID().wallet('ethereum').required(),
+  evidence: Joi.object({
+    hash: Joi.string().regex(Joi.patterns.txHash).required(),
+  }).required(),
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  actualFee: Joi.BN().min(0).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+const runner = new Runner();
+
+// 1. verify itx
+runner.use(({ tx, itx }, next) => {
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+
+  if (itx.to !== tx.from) {
+    return next(new Error('INVALID_TX', 'You can only deposit to tx sender account'));
+  }
+
+  // ensure proposer in signer list
+  const signatures = getListField(tx, 'signatures');
+  if (signatures.some((x) => x.signer === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer must exist in signatures'));
+  }
+
+  // ensure tx.from not in validator list
+  if (signatures.some((x) => x.signer === tx.from)) {
+    return next(new Error('INVALID_TX', 'tx.from should not exist in signatures'));
+  }
+
+  return next();
+});
+
+// 2. verify rollup against itx
+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 (rollupState.tokenAddress !== itx.token.address) {
+    return next(new Error('INVALID_TX', 'Deposit token address does not match with rollup state'));
+  }
+
+  if (rollupState.validators.some((x) => x.address === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer does not exist in validators'));
+  }
+
+  return next();
+});
+
+// 3. verify evidence
+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', 'Deposit evidence already seen on this chain'));
+  }
+
+  return next();
+});
+
+// 4. verify signers & signatures
+runner.use(VerifySigners({ signersKey: 'tx.signaturesList', allowSender: true }));
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
+
+// 5. verify token state
+runner.use(pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })); // prettier-ignore
+
+// 6. verify staking: get address, extract state, verify amount
+runner.use((context, next) => {
+  const { itx } = context;
+  context.stakeAddress = toStakeAddress(itx.proposer, itx.rollup);
+  context.lockerAddress = getRewardLocker(itx.rollup);
+  return next();
+});
+runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'OK', table: 'stake' }));
+runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })); // prettier-ignore
+runner.use((context, next) => {
+  const { itx, stakeState, tokenState, rollupState } = context;
+  if (stakeState.revocable === true) {
+    return next(new Error('INVALID_STAKE_STATE', `Staking not locked for deposit: ${stakeState.address}`));
+  }
+
+  const depositAmount = new BN(itx.token.value).add(new BN(itx.actualFee));
+  const minDepositAmount = new BN(rollupState.minDepositAmount);
+  const maxDepositAmount = new BN(rollupState.maxDepositAmount);
+  if (depositAmount.lt(minDepositAmount)) {
+    return next(
+      new Error(
+        'INVALID_TX',
+        `Deposit amount must be greater than minDepositAmount: ${fromUnitToToken(minDepositAmount, tokenState.decimal)}`
+      )
+    );
+  }
+  if (depositAmount.gt(maxDepositAmount)) {
+    return next(
+      new Error(
+        'INVALID_TX',
+        `Deposit amount must be less than maxDepositAmount: ${fromUnitToToken(maxDepositAmount, tokenState.decimal)}`
+      )
+    );
+  }
+
+  const stakedAmount = new BN(stakeState.tokens[rollupState.tokenAddress] || 0);
+  if (depositAmount.gt(stakedAmount)) {
+    return next(
+      new Error(
+        'INSUFFICIENT_STAKE',
+        `Deposit amount must be less than available stake: ${fromUnitToToken(stakedAmount, tokenState.decimal)}`
+      )
+    );
+  }
+
+  return next();
+});
+
+// 7. verify actualFee
+runner.use((context, next) => {
+  const { itx, rollupState, tokenState } = context;
+  const { depositFeeRate, maxDepositFee, minDepositFee } = rollupState;
+
+  const { reward } = getTxFee({
+    amount: itx.token.value,
+    feeRate: depositFeeRate,
+    maxFee: maxDepositFee,
+    minFee: minDepositFee,
+  });
+
+  if (new BN(itx.actualFee).lt(new BN(reward))) {
+    const expected = fromUnitToToken(reward, tokenState.decimal);
+    const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
+    return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
+  }
+
+  return next();
+});
+
+// 7. verify sender and signer states
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
+runner.use(pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 8. update state: the token minting is done when deposit finalized in rollup-block
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, senderState, stakeState, stakeAddress, lockerState, lockerAddress } = context;
+
+    const user = itx.token.value;
+    const fee = itx.actualFee;
+    const total = getBNSum(user, fee);
+
+    const stakeUpdates = applyTokenUpdates([{ address: itx.token.address, value: total }], stakeState, 'sub');
+    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: user }], senderState || {}, 'add');
+    const lockerUpdates = applyTokenUpdates(
+      [{ address: itx.token.address, value: fee }],
+      lockerState || { tokens: {} },
+      'add'
+    );
+
+    const sender = senderState ? senderState.address : tx.from;
+    const [newSenderState, newStakeState, newLockerState, evidenceState] = await Promise.all([
+      // updateOrCreate user account
+      statedb.account.updateOrCreate(
+        senderState,
+        account.updateOrCreate(senderState, { address: sender, nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      // update stake amount from the proposer
+      statedb.stake.update(stakeAddress, stake.update(stakeState, stakeUpdates, context), context),
+
+      // Update pending fee locker state
+      lockerState
+        ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context)
+        : statedb.stake.create(
+            lockerAddress,
+            stake.create(
+              {
+                address: lockerAddress,
+                sender: itx.rollup,
+                receiver: itx.rollup,
+                revocable: false,
+                message: 'pending-block-reward',
+                revokeWaitingPeriod: 0,
+                ...lockerUpdates,
+              },
+              context
+            ),
+            context
+          ),
+
+      // Create evidence state
+      statedb.evidence.create(
+        itx.evidence.hash,
+        evidence.create({ hash: itx.evidence.hash, data: 'rollup-deposit' }, context),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.stakeState = newStakeState;
+    context.evidenceState = evidenceState;
+    context.stakeStates = [newStakeState, newLockerState];
+
+    context.updatedAccounts = [
+      // stake for tx proposer is decreased
+      { address: stakeAddress, token: itx.token.address, delta: `-${total}`, action: 'unlock' },
+      // mint to depositor from stake
+      { address: sender, token: itx.token.address, delta: user, action: 'unlock' },
+      // tx fee is locked for later claiming
+      { address: lockerAddress, token: itx.token.address, delta: fee, action: 'pending' },
+    ];
+
+    debug('deposit-token-v2', itx);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/token/withdraw-v2.js

@@ -0,0 +1,255 @@
+/* eslint-disable indent */
+const Error = require('@ocap/util/lib/error');
+const Joi = require('@arcblock/validator');
+const getListField = require('@ocap/util/lib/get-list-field');
+const { BN, fromUnitToToken } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake } = require('@ocap/state');
+const { toStakeAddress } = require('@arcblock/did-util');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:withdraw-token`);
+
+const VerifyPaused = require('../rollup/pipes/verify-paused');
+const { applyTokenUpdates, getTxFee, getBNSum, getRewardLocker } = require('../../util');
+
+const verifyMultiSigV2 = pipes.VerifyMultiSigV2({ signersKey: 'signers' });
+
+const schema = Joi.object({
+  token: Joi.schemas.tokenInput.required(),
+  to: Joi.DID().wallet('ethereum').required(),
+  rollup: Joi.DID().role('ROLE_ROLLUP').required(),
+  proposer: Joi.DID().wallet('ethereum').optional().allow('').default(''),
+  actualFee: Joi.BN().min(0).required(),
+  maxFee: Joi.BN().min(0).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+
+const runner = new Runner();
+
+// 1. verify itx
+runner.use(({ tx, itx }, next) => {
+  const { error } = schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+
+  if (itx.to !== tx.from) {
+    return next(new Error('INVALID_TX', 'You can only withdraw to tx sender account'));
+  }
+
+  return next();
+});
+
+// 2. verify rollup against itx
+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 (rollupState.tokenAddress !== itx.token.address) {
+    return next(new Error('INVALID_TX', 'Withdraw token address does not match with rollup'));
+  }
+
+  return next();
+});
+
+// 3. verify token state
+runner.use(pipes.ExtractState({ from: 'itx.token.address', to: 'tokenState', status: 'INVALID_TOKEN', table: 'token' })); // prettier-ignore
+
+// 4. verify sender and signer states
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
+
+// 5. verify amount
+runner.use((context, next) => {
+  const { tx, itx, tokenState, rollupState } = context;
+
+  // withdraw amount
+  const withdrawAmount = new BN(itx.token.value);
+  const minWithdrawAmount = new BN(rollupState.minWithdrawAmount);
+  const maxWithdrawAmount = new BN(rollupState.maxWithdrawAmount);
+  if (withdrawAmount.lt(minWithdrawAmount)) {
+    return next(
+      new Error(
+        'INVALID_TX',
+        `Withdraw amount must be greater than: ${fromUnitToToken(minWithdrawAmount, tokenState.decimal)}`
+      )
+    );
+  }
+  if (withdrawAmount.gt(maxWithdrawAmount)) {
+    return next(
+      new Error(
+        'INVALID_TX',
+        `Withdraw amount must be less than maxWithdrawAmount: ${fromUnitToToken(maxWithdrawAmount, tokenState.decimal)}`
+      )
+    );
+  }
+
+  // user balance
+  const maxAmount = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+  context.tokenConditions = { owner: tx.from, tokens: [{ address: itx.token.address, value: maxAmount }] };
+
+  return next();
+});
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'senderState', conditionKey: 'tokenConditions' }));
+
+// 6. verify actualFee
+runner.use((context, next) => {
+  const { itx, rollupState, tokenState } = context;
+  const { withdrawFeeRate, maxWithdrawFee, minWithdrawFee } = rollupState;
+
+  const isFixedFee = new BN(itx.maxFee).isZero();
+  if (isFixedFee) {
+    const { reward } = getTxFee({
+      amount: itx.token.value,
+      feeRate: withdrawFeeRate,
+      maxFee: maxWithdrawFee,
+      minFee: minWithdrawFee,
+    });
+
+    if (new BN(itx.actualFee).lt(new BN(reward))) {
+      const expected = fromUnitToToken(reward, tokenState.decimal);
+      const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
+      return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
+    }
+  }
+
+  return next();
+});
+
+// 7. verify maxFee and conditional multi-sig
+// eslint-disable-next-line consistent-return
+runner.use((context, next) => {
+  const { tx, itx } = context;
+  const isFixedFee = new BN(itx.maxFee).isZero();
+  if (isFixedFee) {
+    return next();
+  }
+
+  const signatures = getListField(tx, 'signatures');
+
+  // ensure signature count
+  if (signatures.length !== 1) {
+    return next(new Error('INVALID_TX', 'Withdraw with maxFee should have one multi-sig'));
+  }
+
+  // ensure proposer in signer list
+  if (signatures.some((x) => x.signer === itx.proposer) === false) {
+    return next(new Error('INVALID_TX', 'itx.proposer must exist in tx.signatures'));
+  }
+
+  // ensure signature is valid
+  context.signers = signatures.map((x) => x.signer);
+  verifyMultiSigV2(context, next);
+});
+
+// 8. verify staking: user withdraw is locked in stake
+runner.use((context, next) => {
+  const { itx, senderState } = context;
+  context.stakeAddress = toStakeAddress(senderState.address, itx.rollup);
+  context.lockerAddress = getRewardLocker(itx.rollup);
+  return next();
+});
+runner.use(pipes.ExtractState({ from: 'lockerAddress', to: 'lockerState', status: 'OK', table: 'stake' }));
+runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'OK', table: 'stake' }));
+runner.use((context, next) => {
+  const { stakeState } = context;
+  if (stakeState && stakeState.revocable === true) {
+    return next(new Error('INVALID_STAKE_STATE', `Staking not locked for withdraw: ${stakeState.address}`));
+  }
+
+  return next();
+});
+
+// 8. update state: the fee splitting and token burning is done when withdraw finalized in rollup-block
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, stakeState, senderState, lockerState, lockerAddress, stakeAddress } = context;
+
+    const total = getBNSum(itx.token.value, itx.actualFee, itx.maxFee);
+    const fee = getBNSum(itx.actualFee, itx.maxFee);
+
+    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: total }], senderState, 'sub');
+
+    // Burned amount should equal to user received amount
+    const stakeUpdates = applyTokenUpdates(
+      [{ address: itx.token.address, value: itx.token.value }],
+      stakeState || {},
+      'add'
+    );
+
+    // Fees are locked to reward locker, and funded later
+    const lockerUpdates = applyTokenUpdates(
+      [{ address: itx.token.address, value: fee }],
+      lockerState || { tokens: {} },
+      'add'
+    );
+
+    const [newSenderState, newStakeState, newLockerState] = await Promise.all([
+      // update user account
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, ...senderUpdates }, context),
+        context
+      ),
+
+      // lock withdraw amount to a not-revocable stake
+      stakeState
+        ? statedb.stake.update(stakeAddress, stake.update(stakeState, stakeUpdates, context), context)
+        : statedb.stake.create(
+            stakeAddress,
+            stake.create(
+              {
+                address: stakeAddress,
+                sender: senderState.address,
+                receiver: itx.rollup,
+                revocable: false,
+                tokens: stakeUpdates.tokens,
+                message: 'withdraw-locker',
+                assets: [],
+              },
+              context
+            ),
+            context
+          ),
+
+      // Update pending fee locker state
+      lockerState
+        ? statedb.stake.update(lockerState.address, stake.update(lockerState, lockerUpdates, context), context)
+        : statedb.stake.create(
+            lockerAddress,
+            stake.create(
+              {
+                address: lockerAddress,
+                sender: itx.rollup,
+                receiver: itx.rollup,
+                revocable: false,
+                message: 'pending-block-reward',
+                revokeWaitingPeriod: 0,
+                ...lockerUpdates,
+              },
+              context
+            ),
+            context
+          ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.stakeState = newStakeState;
+    context.lockerState = newLockerState;
+    context.stakeStates = [newStakeState, newLockerState];
+
+    context.updatedAccounts = [
+      { address: senderState.address, token: itx.token.address, delta: `-${total}`, action: 'lock' },
+      { address: stakeAddress, token: itx.token.address, delta: itx.token.value, action: 'lock' },
+      { address: lockerAddress, token: itx.token.address, delta: fee, action: 'pending' },
+    ];
+
+    debug('withdraw-token-v2', itx);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;