@ocap/tx-protocols 1.18.17 → 1.18.19

package/lib/execute.js

@@ -62,11 +62,13 @@ module.exports = ({ filter, runAsLambda }) => {
           // we should only flush events when retry is not supported
           // otherwise the outer caller should handle these 2
           if (shouldPersistTx(err) && isRetrySupported === false) {
-            const txState = context.states.tx.create(context, err ? err.code || 'INTERNAL' : 'OK');
+            let txState;
             try {
+              txState = context.states.tx.create(context, err ? err.code || 'INTERNAL' : 'OK');
               await context.statedb.tx.create(txState.hash, txState, context);
             } catch (e) {
               console.error('Failed to save transaction to statedb', e);
+              return reject(e);
             }
 
             flushEvents(context, { txState });

package/lib/index.js

@@ -17,6 +17,7 @@ const createToken = require('./protocols/token/create');
 const stake = require('./protocols/governance/stake');
 const revokeStake = require('./protocols/governance/revoke-stake');
 const claimStake = require('./protocols/governance/claim-stake');
+const slashStake = require('./protocols/governance/slash-stake');
 const depositTokenV2 = require('./protocols/token/deposit-v2');
 const withdrawTokenV2 = require('./protocols/token/withdraw-v2');
 const createRollup = require('./protocols/rollup/create');
@@ -65,6 +66,7 @@ const createExecutor = ({ filter, runAsLambda }) => {
     stake,
     revokeStake,
     claimStake,
+    slashStake,
 
     // rollup
     createRollup,

package/lib/pipes/ensure-cost.js

@@ -43,7 +43,11 @@ module.exports = function CreateEnsureTxCostPipe({ attachSenderChanges = true }
     const gasStake = {};
     if (token && pk && JWT.verify(token, pk, { enforceTimestamp: true, tolerance: 5 })) {
       const decoded = JWT.decode(token);
-      if (decoded.txHash === txHash) {
+      const txHashes = (decoded.txHash || '')
+        .split(',')
+        .map((x) => x.trim())
+        .filter(Boolean);
+      if (txHashes.includes(txHash)) {
         gasStake.owner = toAddress(decoded.iss);
         gasStake.stakeId = toStakeAddress(gasStake.owner, gasStake.owner);
       } else {

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

@@ -1,5 +1,7 @@
 const isEmpty = require('empty-value');
 const { BN } = require('@ocap/util');
+const { Joi, schemas } = require('@arcblock/validator');
+const { CustomError: Error } = require('@ocap/util/lib/error');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
 const { account, stake } = require('@ocap/state');
 const { getRelatedAddresses } = require('@ocap/util/lib/get-related-addr');
@@ -15,6 +17,17 @@ const runner = new Runner();
 
 runner.use(pipes.VerifyMultiSig(0));
 
+// 0. verify itx
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_STAKE').required(),
+  outputsList: schemas.multiInput.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);
+});
+
 // 1. verify itx output
 runner.use(
   pipes.VerifyTxInput({
@@ -29,11 +42,6 @@ runner.use(
 // 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',
@@ -64,6 +72,11 @@ runner.use(
       message: 'This stake address is not revocable',
       fn: ({ stakeState }) => stakeState.revocable,
     },
+    {
+      error: 'INVALID_TX',
+      message: 'Can not revoke assets that are not locked in the stake',
+      fn: ({ assets, stakeState }) => assets.every((x) => stakeState.assets.includes(x)),
+    },
   ])
 );
 

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

@@ -0,0 +1,249 @@
+const isEmpty = require('empty-value');
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const { BN } = require('@ocap/util');
+const { Joi, schemas } = require('@arcblock/validator');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, stake, asset } = 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}:slash-stake`);
+
+const { applyTokenUpdates, applyTokenChange } = require('../../util');
+const EnsureTxGas = require('../../pipes/ensure-gas');
+const EnsureTxCost = require('../../pipes/ensure-cost');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+// 0. verify itx
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_STAKE').required(),
+  message: Joi.string().trim().min(1).max(256).required(),
+  outputsList: schemas.multiInput.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);
+});
+
+// 1. verify itx.outputs
+runner.use(
+  pipes.VerifyTxInput({
+    fieldKey: 'itx.outputs',
+    inputsKey: 'outputs',
+    sendersKey: 'receivers',
+    tokensKey: 'tokens',
+    assetsKey: 'assets',
+  })
+);
+
+// 2. verify output
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INSUFFICIENT_DATA',
+      message: 'Can not slash stake without any output',
+      fn: ({ assets, tokens }) => !(isEmpty(tokens) && isEmpty(assets)),
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Can only send slashed token/assets to specified vault',
+      fn: ({ config, receivers }) => receivers.every((x) => x === config.vaults.slashedStake),
+    },
+  ])
+);
+
+// 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: 'INVALID_TX',
+      message: 'You are not allowed to slash from this stake',
+      fn: ({ tx, stakeState }) =>
+        (isEmpty(stakeState.slashers) ? [stakeState.receiver] : stakeState.slashers).includes(tx.from),
+    },
+  ])
+);
+
+// 6. verify token state and balance from both staked and revoked
+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));
+    });
+  });
+
+  // merge both staked and revoked as locked
+  const lockedState = {
+    address: stakeState.address,
+    tokens: { ...stakeState.tokens },
+    assets: [...stakeState.assets, ...stakeState.revokedAssets],
+  };
+  Object.keys(stakeState.revokedTokens).forEach((address) => {
+    lockedState.tokens[address] = new BN(stakeState.revokedTokens[address])
+      .add(new BN(stakeState.tokens[address]))
+      .toString(10);
+  });
+
+  context.lockedState = lockedState;
+  context.tokenCondition = {
+    owner: stakeState.address,
+    tokens: Object.keys(tokens).map((address) => ({ address, value: tokens[address] })),
+  };
+
+  next();
+});
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'lockedState', conditionKey: 'tokenCondition' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TX',
+      message: 'Can not slash assets that are not locked in the stake',
+      fn: ({ assets, lockedState }) => assets.every((x) => lockedState.assets.includes(x)),
+    },
+  ])
+);
+
+// 7. verify asset state and ownership
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'INVALID_ASSET_STATE', table: 'asset' }));
+runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
+runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'stakeState' }));
+
+// ensure tx cost and gas
+runner.use(
+  EnsureTxGas((context) => {
+    const result = { create: 0, update: 2, payment: 0 };
+    if (context.receiverStates) {
+      result.update += context.receiverStates.length;
+    }
+    if (context.assetStates) {
+      result.update += context.assetStates.length;
+    }
+
+    return result;
+  })
+);
+runner.use(EnsureTxCost({ attachSenderChanges: true }));
+
+// 8. update statedb
+runner.use(
+  async (context, next) => {
+    const {
+      tx,
+      itx,
+      outputs,
+      statedb,
+      senderState,
+      receiverStates = [],
+      assetStates = [],
+      stakeState,
+      updateVaults,
+      senderChange,
+    } = context;
+
+    const receiverUpdates = {};
+    const assetUpdates = {};
+    const stakeUpdates = {
+      tokens: stakeState.tokens || {},
+      assets: stakeState.assets || [],
+      revokedTokens: stakeState.revokedTokens || {},
+      revokedAssets: stakeState.revokedAssets || [],
+    };
+
+    outputs.forEach((x) => {
+      const { owner, tokensList, assetsList } = x;
+
+      // move assets to output
+      stakeUpdates.assets = stakeUpdates.assets.filter((a) => assetsList.includes(a) === false);
+      stakeUpdates.revokedAssets = stakeUpdates.revokedAssets.filter((a) => assetsList.includes(a) === false);
+
+      // move tokens and assets from staked or revoked to output
+      const [newTokens, newRevoked] = applyTokenUpdates(
+        tokensList,
+        [{ tokens: stakeUpdates.tokens }, { tokens: stakeUpdates.revokedTokens }],
+        'sub'
+      );
+      stakeUpdates.tokens = newTokens.tokens;
+      stakeUpdates.revokedTokens = newRevoked.tokens;
+
+      // Update receiver balance
+      const ownerState = receiverStates.find((s) => getRelatedAddresses(s).includes(owner));
+      receiverUpdates[ownerState.address] = applyTokenUpdates(tokensList, ownerState, 'add');
+      if (senderChange && ownerState.address === senderChange.address) {
+        receiverUpdates[ownerState.address] = applyTokenChange(receiverUpdates[ownerState.address], senderChange);
+      }
+
+      // Update asset owner
+      assetsList.forEach((a) => {
+        assetUpdates[a] = { owner: ownerState.address };
+      });
+    });
+
+    const [newSenderState, newReceiverStates, newStakeState, newAssetStates] = await Promise.all([
+      // Update sender state
+      statedb.account.update(
+        senderState.address,
+        account.update(
+          senderState,
+          Object.assign(
+            { nonce: tx.nonce },
+            receiverUpdates[senderState.address] || (senderChange ? applyTokenChange(senderState, senderChange) : {})
+          ),
+          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)
+        )
+      ),
+
+      updateVaults(),
+    ]);
+
+    context.senderState = newSenderState;
+    context.receiverStates = newReceiverStates;
+    context.stakeState = newStakeState;
+    context.assetStates = newAssetStates;
+
+    debug('slash-stake', { address: itx.address, stakeUpdates });
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/governance/stake.js

@@ -1,7 +1,7 @@
 const pick = require('lodash/pick');
 const { promisify } = require('util');
 const isEmpty = require('empty-value');
-const { Joi } = require('@arcblock/validator');
+const { Joi, schemas } = require('@arcblock/validator');
 const { CustomError: Error } = require('@ocap/util/lib/error');
 const { BN, fromTokenToUnit } = require('@ocap/util');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
@@ -24,7 +24,9 @@ const runner = new Runner();
 const schema = Joi.object({
   address: Joi.DID().role('ROLE_STAKE').required(),
   receiver: Joi.DID().required(),
+  slashersList: Joi.array().items(Joi.DID()).default([]),
   locked: Joi.boolean().default(false),
+  inputsList: schemas.multiInput.min(1).required(),
   message: Joi.string().trim().min(1).max(256).required(),
   revokeWaitingPeriod: Joi.number().integer().min(0).default(0),
 }).options({ stripUnknown: true, noDefaults: false });
@@ -50,6 +52,11 @@ runner.use(
       message: 'Invalid staking address',
       fn: ({ tx, itx }) => toStakeAddress(tx.from, itx.receiver) === itx.address,
     },
+    {
+      error: 'INVALID_TX',
+      message: 'Tx sender can not be slasher',
+      fn: ({ tx, itx }) => itx.slashersList.includes(tx.from) === false,
+    },
     {
       error: 'INSUFFICIENT_DATA',
       message: 'Can not stake without any token or asset',
@@ -104,9 +111,7 @@ runner.use(async (context, next) => {
   const { token, transaction } = config;
   const { minStake, maxStake } = transaction.txGas;
 
-  // FIXME: delegation not supported here
   context.isGasStake = isGasStakeAddress(tx.from, itx.address) && isGasStakeInput(inputs, token.address);
-
   if (context.isGasStake) {
     const [tokenInput] = inputs[0].tokensList;
     const actualStake = new BN(tokenInput.value);
@@ -122,8 +127,10 @@ runner.use(async (context, next) => {
 
   if (context.isGasStake) {
     context.revokeWaitingPeriod = transaction.txGas.stakeLockPeriod;
+    context.slashers = [config.moderator.address];
   } else {
     context.revokeWaitingPeriod = itx.revokeWaitingPeriod;
+    context.slashers = itx.slashersList;
   }
 
   return next();
@@ -224,6 +231,7 @@ runner.use(
               {
                 sender: tx.from,
                 revocable: !itx.locked,
+                slashers: context.slashers,
                 revokeWaitingPeriod: context.revokeWaitingPeriod,
                 ...pick(itx, ['address', 'receiver', 'message', 'data']),
                 ...stakeUpdates,

package/lib/util.js

@@ -52,6 +52,8 @@ const decodeAnySafe = (encoded) => {
   }
 };
 
+// If we are adding tokens to multiple states, same updates applied to all
+// If we are removing tokens from multiple states, applied sequentially
 const applyTokenUpdates = (tokens, state, operator) => {
   if (['add', 'sub'].includes(operator) === false) {
     throw new Error('UNEXPECTED_OPERATOR', `Invalid operator when applyTokenUpdates: ${operator}`);
@@ -61,23 +63,40 @@ const applyTokenUpdates = (tokens, state, operator) => {
     return {};
   }
 
-  const oldTokens = state.tokens || {};
-  const newTokens = cloneDeep(oldTokens);
+  const states = cloneDeep((Array.isArray(state) ? state : [state]).map((x) => ({ tokens: x.tokens || {} })));
   for (let i = 0; i < tokens.length; i++) {
     const { address, value } = tokens[i];
-    const requirement = new BN(value);
-    const balance = new BN(oldTokens[address] || 0);
-    const newBalance = balance[operator](requirement);
-    if (newBalance.isNeg()) {
+    const expectedDelta = new BN(value);
+
+    let fulfilled = new BN(0);
+    for (let j = 0; j < states.length; j++) {
+      const origin = states[j].tokens;
+      const updated = cloneDeep(origin);
+      const balance = new BN(origin[address] || 0);
+
+      let newBalance;
+      if (operator === 'add') {
+        fulfilled = fulfilled.add(expectedDelta);
+        newBalance = balance.add(expectedDelta);
+      } else {
+        const unfulfilledDelta = expectedDelta.sub(fulfilled);
+        const actualDelta = balance.lt(unfulfilledDelta) ? balance : unfulfilledDelta;
+        fulfilled = fulfilled.add(actualDelta);
+        newBalance = balance.sub(actualDelta);
+      }
+
+      updated[address] = newBalance.toString(10);
+      states[j].tokens = updated;
+    }
+
+    if (fulfilled.lt(expectedDelta)) {
       throw new Error('NEGATIVE_TOKEN_BALANCE', `Negative token balance when applyTokenUpdates for ${address}`);
     }
-    newTokens[address] = newBalance.toString(10);
   }
 
-  return {
-    tokens: newTokens,
-  };
+  return Array.isArray(state) ? states : states[0];
 };
+
 const applyTokenChange = (state, change) => {
   const delta = typeof change.delta === 'string' ? new BN(change.delta) : change.delta;
   if (delta.gt(ZERO)) {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.18.17",
+  "version": "1.18.19",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -21,18 +21,18 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "1.18.17",
-    "@arcblock/did-util": "1.18.17",
-    "@arcblock/jwt": "1.18.17",
-    "@arcblock/validator": "1.18.17",
-    "@ocap/asset": "1.18.17",
-    "@ocap/mcrypto": "1.18.17",
-    "@ocap/merkle-tree": "1.18.17",
-    "@ocap/message": "1.18.17",
-    "@ocap/state": "1.18.17",
-    "@ocap/tx-pipeline": "1.18.17",
-    "@ocap/util": "1.18.17",
-    "@ocap/wallet": "1.18.17",
+    "@arcblock/did": "1.18.19",
+    "@arcblock/did-util": "1.18.19",
+    "@arcblock/jwt": "1.18.19",
+    "@arcblock/validator": "1.18.19",
+    "@ocap/asset": "1.18.19",
+    "@ocap/mcrypto": "1.18.19",
+    "@ocap/merkle-tree": "1.18.19",
+    "@ocap/message": "1.18.19",
+    "@ocap/state": "1.18.19",
+    "@ocap/tx-pipeline": "1.18.19",
+    "@ocap/util": "1.18.19",
+    "@ocap/wallet": "1.18.19",
     "debug": "^4.3.4",
     "deep-diff": "^1.0.2",
     "empty-value": "^1.0.1",
@@ -47,5 +47,5 @@
     "jest": "^27.5.1",
     "start-server-and-test": "^1.14.0"
   },
-  "gitHead": "be4f07d40599521e3b5364dd7d0ace22ad5f58d6"
+  "gitHead": "d13bcea225809e0c0a926cfc246c7a46bd4185f3"
 }