@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/account/revoke-delegate.js

@@ -1,5 +1,6 @@
 const get = require('lodash/get');
-const isEmpty = require('empty-value');
+const cloneDeep = require('lodash/cloneDeep');
+const Joi = require('@arcblock/validator');
 const getListField = require('@ocap/util/lib/get-list-field');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
 const { delegation, account } = require('@ocap/state');
@@ -13,6 +14,19 @@ const runner = new Runner();
 runner.use(pipes.VerifyMultiSig(0));
 
 // Verify itx
+const schema = Joi.object({
+  address: Joi.DID().role('ROLE_DELEGATION').required(),
+  to: Joi.DID().required(),
+  typeUrlsList: Joi.array().items(Joi.string().required()).min(1).required(),
+  data: Joi.any().optional(),
+}).options({ stripUnknown: true, noDefaults: false });
+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([
     {
@@ -22,11 +36,6 @@ runner.use(
         return true;
       },
     },
-    {
-      error: 'INSUFFICIENT_DATA',
-      message: 'itx.address, itx.to and itx.typeUrls should not be empty',
-      fn: ({ itx, typeUrls }) => !isEmpty(itx.address) && !isEmpty(itx.to) && typeUrls.length > 0,
-    },
     {
       error: 'INVALID_TX',
       message: 'Delegation address does not match',
@@ -45,29 +54,36 @@ runner.use(
 );
 
 // Ensure sender/receiver/delegation exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'delegationState', status: 'INVALID_DELEGATION', table: 'delegation' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
-runner.use(pipes.ExtractState({ from: 'itx.to', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'itx.address', to: 'delegationState', status: 'INVALID_DELEGATION' }));
 
-// Create account state, and update old accounts
-runner.use(async (context, next) => {
-  const { itx, typeUrls, statedb, senderState } = context;
+// Update delegation state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, typeUrls, statedb, senderState, delegationState } = context;
 
-  debug('update', { address: itx.address, typeUrls });
+    debug('update', { address: itx.address, typeUrls });
 
-  typeUrls.forEach((x) => delete context.delegationState.ops[x]);
-  const state = delegation.update(context.delegationState, { ops: context.delegationState.ops }, context);
-  await statedb.delegation.update(itx.address, state, context);
+    const newOps = cloneDeep(delegationState.ops);
+    typeUrls.forEach((x) => delete newOps[x]);
 
-  const newSenderState = account.update(senderState, {}, context);
-  await statedb.account.update(senderState.address, newSenderState, context);
+    const [newSenderState, newDelegationState] = await Promise.all([
+      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+      statedb.delegation.update(
+        itx.address,
+        delegation.update(context.delegationState, { ops: newOps }, context),
+        context
+      ),
+    ]);
 
-  // Update context
-  context.delegationState = state;
-  context.senderState = newSenderState;
+    // Update context
+    context.senderState = newSenderState;
+    context.delegationState = newDelegationState;
 
-  return next();
-});
+    return next();
+  },
+  { persistError: true }
+);
 
 module.exports = runner;

package/lib/protocols/asset/acquire-v2.js

@@ -0,0 +1,159 @@
+/* eslint-disable function-paren-newline */
+const { promisify } = require('util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, asset, factory } = require('@ocap/state');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:acquire-asset-v2`);
+
+// custom pipes
+const verifyAcquireParams = require('./pipes/verify-acquire-params');
+const verifyMintLimit = require('./pipes/verify-mint-limit');
+const verifyItxVariables = require('./pipes/verify-itx-variables');
+const verifyItxAssets = require('./pipes/verify-itx-assets');
+const verifyItxAddress = require('./pipes/verify-itx-address');
+const execMintHook = require('./pipes/exec-mint-hook');
+const extractFactoryTokens = require('./pipes/extract-factory-tokens');
+
+const { applyTokenUpdates } = require('../../util');
+
+const verifyTokenBalance = promisify(pipes.VerifyTokenBalance({ ownerKey: 'senders', conditionKey: 'conditions' }));
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+runner.use(verifyAcquireParams('acquire-v2'));
+
+// ensure asset not exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'duplicateAsset', status: 'OK', table: 'asset' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'FORBIDDEN',
+      message: 'Asset with same address already exists',
+      fn: ({ duplicateAsset }) => !duplicateAsset,
+      persist: true,
+    },
+  ])
+);
+
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
+
+runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK' }));
+runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
+
+runner.use(pipes.ExtractState({ from: 'itx.factory', to: 'factoryState', status: 'INVALID_FACTORY_STATE', table: 'factory' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'itx.assetsList', to: 'assetStates', status: 'OK', table: 'asset' }));
+runner.use(
+  pipes.ExtractState({
+    from: 'factoryState.input.assets',
+    to: 'expectedFactoryStates',
+    status: 'OK',
+    table: 'factory',
+  })
+);
+
+// Though tokens are verified on factory creating phase, we need them here to construct tokenSymbols
+runner.use(extractFactoryTokens);
+runner.use(pipes.ExtractState({ from: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
+
+// Verify itx
+runner.use(verifyMintLimit);
+runner.use(verifyItxVariables);
+runner.use(verifyItxAddress('acquire-v2'));
+runner.use(async (context, next) => {
+  const { factoryTokens, senderState } = context;
+  const condition = {
+    owner: senderState.address,
+    tokens: [...factoryTokens],
+  };
+
+  try {
+    await verifyTokenBalance({ senders: [senderState], conditions: [condition] });
+    return next();
+  } catch (err) {
+    return next(err);
+  }
+});
+runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'assetOwner' }));
+runner.use(verifyItxAssets);
+
+// update statedb
+runner.use(
+  async (context, next) => {
+    const {
+      tx,
+      itx,
+      txTime,
+      statedb,
+      senderState,
+      assetOwner,
+      factoryState,
+      factoryTokens,
+      mintedAsset,
+      mintedAddress,
+      assetStates = [],
+    } = context;
+
+    // Sender updates
+    const senderUpdates = {
+      nonce: tx.nonce,
+      pk: tx.pk,
+      ...applyTokenUpdates(factoryTokens, senderState, 'sub'),
+    };
+
+    // Owner updates
+    const ownerUpdates = {};
+
+    // Factory updates
+    const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+    if (factoryState.settlement !== 'instant') {
+      // Move primary/secondary tokens to factory if we are not doing instant settlement
+      Object.assign(factoryUpdates, applyTokenUpdates(factoryTokens, factoryState, 'add'));
+      context.tokenUpdates = applyTokenUpdates(factoryTokens, { tokens: {} }, 'add');
+    }
+
+    const [newSenderState, assetState, newFactoryState, newAssetStates] = await Promise.all([
+      // Update sender state
+      statedb.account.update(senderState.address, account.update(senderState, senderUpdates, context), context),
+
+      // Create new asset
+      statedb.asset.create(
+        itx.address,
+        asset.create({ ...mintedAsset, owner: assetOwner.address, address: mintedAddress }, context),
+        context
+      ),
+
+      // Update factory state
+      statedb.factory.update(factoryState.address, factory.update(factoryState, factoryUpdates, context), context),
+
+      // Mark input assets as consumed
+      Promise.all(
+        assetStates.map((x) =>
+          statedb.asset.update(x.address, asset.update(x, { consumedTime: txTime }, context), context)
+        )
+      ),
+
+      // Update delegator state
+      context.delegatorState
+        ? statedb.account.update(assetOwner.address, account.update(assetOwner, ownerUpdates, context), context)
+        : null,
+    ]);
+
+    context.senderState = newSenderState;
+    context.assetState = assetState;
+    context.factoryState = newFactoryState;
+    context.assetStates = newAssetStates;
+
+    debug('acquire-v2', assetState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+// run minting hooks for instant settlement
+runner.use(execMintHook, { persistError: true });
+
+module.exports = runner;

package/lib/protocols/asset/acquire-v3.js

@@ -0,0 +1,242 @@
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable prefer-object-spread */
+/* eslint-disable function-paren-newline */
+const { promisify } = require('util');
+const isEqual = require('lodash/isEqual');
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, asset, factory } = require('@ocap/state');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../package.json').name}:acquire-asset-v2`);
+
+const { applyTokenUpdates } = require('../../util');
+
+// custom pipes
+const verifyAcquireParams = require('./pipes/verify-acquire-params');
+const verifyMintLimit = require('./pipes/verify-mint-limit');
+const verifyItxVariables = require('./pipes/verify-itx-variables');
+const verifyItxAssets = require('./pipes/verify-itx-assets');
+const verifyItxAddress = require('./pipes/verify-itx-address');
+const execMintHook = require('./pipes/exec-mint-hook');
+const extractFactoryTokens = require('./pipes/extract-factory-tokens');
+
+const verifyAssetOwner = promisify(pipes.VerifyUpdater({ assetKey: 'assets', ownerKey: 'owner' }));
+
+const runner = new Runner();
+
+// 1. extract & verify itx input
+runner.use(verifyAcquireParams('acquire-v3'));
+
+// ensure asset not exist
+runner.use(pipes.ExtractState({ from: 'itx.address', to: 'duplicateAsset', status: 'OK', table: 'asset' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'FORBIDDEN',
+      message: 'Asset with same address already exists',
+      fn: ({ duplicateAsset }) => !duplicateAsset,
+      persist: true,
+    },
+  ])
+);
+runner.use(
+  pipes.VerifyTxInput({
+    fieldKey: 'itx.inputs',
+    inputsKey: 'inputs',
+    sendersKey: 'senders',
+    tokensKey: 'tokens',
+    assetsKey: 'assets',
+  })
+);
+
+// 2. verify itx size: set hard limit here because more inputs leads to longer tx execute time
+runner.use(pipes.VerifyListSize({ listKey: ['inputs', 'senders', 'tokens', 'assets'] }));
+
+// 3. verify multi sig
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'senders' }));
+
+// 4. verify against factory state
+runner.use(pipes.ExtractState({ from: 'itx.factory', to: 'factoryState', status: 'INVALID_FACTORY_STATE', table: 'factory' })); // prettier-ignore
+runner.use(extractFactoryTokens);
+runner.use(verifyMintLimit);
+runner.use(verifyItxVariables);
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TX',
+      message: 'Input token address does not match with factory input requirement',
+      fn: (ctx) => isEqual(ctx.tokens, ctx.tokenAddress),
+    },
+    {
+      error: 'INVALID_TX',
+      message: 'Input token amount does not match with factory input requirement',
+      fn: ({ inputs, factoryTokens }) => {
+        const inputMap = {};
+
+        inputs.forEach(({ tokensList }) => {
+          tokensList.forEach(({ address, value }) => {
+            if (typeof inputMap[address] === 'undefined') {
+              inputMap[address] = new BN(0);
+            }
+            inputMap[address] = inputMap[address].add(new BN(value));
+          });
+        });
+
+        const expectedTokens = factoryTokens.reduce((acc, x) => {
+          acc[x.address] = new BN(x.value);
+          return acc;
+        }, {});
+
+        return Object.keys(expectedTokens).every((address) => inputMap[address].eq(expectedTokens[address]));
+      },
+    },
+  ])
+);
+
+// 5. verify sender & signer & owner
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'itx.owner', to: 'ownerState', status: 'OK', table: 'account' }));
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
+
+// 6. verify token state and balance
+runner.use(pipes.ExtractState({ from: 'tokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'signerStates', conditionKey: 'inputs' }));
+
+// 7. verify asset state and ownership
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'OK', table: 'asset' }));
+runner.use(async (context, next) => {
+  const { inputs, assetStates = [], signerStates } = context;
+  for (const input of inputs) {
+    const { owner, assetsList } = input;
+    const states = assetStates.filter((x) => assetsList.includes(x.address));
+    const signer = signerStates.find((x) => x.address === owner);
+
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      await verifyAssetOwner({ assets: states, owner: signer });
+    } catch (err) {
+      return next(err);
+    }
+  }
+
+  return next();
+});
+runner.use(
+  pipes.ExtractState({
+    from: 'factoryState.input.assets',
+    to: 'expectedFactoryStates',
+    status: 'OK',
+    table: 'factory',
+  })
+);
+
+// Verify itx
+runner.use(verifyItxAddress('acquire-v3'));
+runner.use(verifyItxAssets);
+
+// update statedb
+runner.use(
+  async (context, next) => {
+    const {
+      tx,
+      itx,
+      txTime,
+      inputs,
+      statedb,
+      senderState,
+      ownerState,
+      factoryState,
+      factoryTokens,
+      mintedAsset,
+      mintedAddress,
+      signerStates,
+      assetStates = [],
+    } = context;
+
+    const signerUpdates = {};
+    inputs.forEach((x) => {
+      const { owner, tokensList } = x;
+      signerUpdates[owner] = applyTokenUpdates(
+        tokensList,
+        signerStates.find((s) => s.address === owner),
+        'sub'
+      );
+    });
+
+    const isAlsoSigner = !!signerUpdates[tx.from];
+    const owner = ownerState ? ownerState.address : itx.owner;
+
+    // Factory updates
+    const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+
+    // Move primary/secondary tokens to factory if we are not doing instant settlement
+    if (factoryState.settlement !== 'instant') {
+      Object.assign(factoryUpdates, applyTokenUpdates(factoryTokens, factoryState, 'add'));
+      context.tokenUpdates = applyTokenUpdates(factoryTokens, { tokens: {} }, 'add');
+    }
+
+    const [newSenderState, newReceiverState, assetState, newSignerStates, newFactoryState, newAssetStates] =
+      await Promise.all([
+        // update sender
+        statedb.account.updateOrCreate(
+          senderState,
+          account.updateOrCreate(
+            senderState,
+            Object.assign({ address: tx.from, nonce: tx.nonce, pk: tx.pk }, signerUpdates[tx.from] || {}),
+            context
+          ),
+          context
+        ),
+
+        // create receiver if not exist: asset owner
+        ownerState
+          ? Promise.resolve(ownerState)
+          : statedb.account.create(owner, account.create({ address: owner }, context), context),
+
+        // Create asset
+        statedb.asset.create(
+          itx.address,
+          asset.create({ ...mintedAsset, owner, address: mintedAddress }, context),
+          context
+        ),
+
+        // Update signer state
+        Promise.all(
+          signerStates
+            .filter((x) => x.address !== tx.from)
+            .map((x) =>
+              statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context)
+            )
+        ),
+
+        // Update factory state
+        statedb.factory.update(factoryState.address, factory.update(factoryState, factoryUpdates, context), context),
+
+        // Mark asset as consumed
+        Promise.all(
+          assetStates.map((x) =>
+            statedb.asset.update(x.address, asset.update(x, { consumedTime: txTime }, context), context)
+          )
+        ),
+      ]);
+
+    context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
+    context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
+    context.assetState = assetState;
+    context.factoryState = newFactoryState;
+    context.assetStates = newAssetStates;
+
+    debug('acquire-v3', assetState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+// run minting hooks for instant settlement
+runner.use(execMintHook, { persistError: true });
+
+module.exports = runner;

package/lib/protocols/asset/calls/README.md

@@ -0,0 +1,5 @@
+# ABOUT
+
+This folder contains reusable pipelines for contract calls.
+
+These pipelines does not actually update the statedb, it just return an `updateSet` for the caller to execute.

package/lib/protocols/asset/calls/transfer-token.js

@@ -0,0 +1,37 @@
+const cloneDeep = require('lodash/cloneDeep');
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../../package.json').name}:acquire-asset:transfer-token`);
+
+const runner = new Runner();
+
+runner.use(pipes.ExtractState({ from: 'args.to', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
+
+runner.use(async (context, next) => {
+  const { states, receiverState, args } = context;
+  const { tokenAddress, amount } = args;
+
+  const delta = new BN(amount);
+  const newTokens = cloneDeep(receiverState.tokens || {});
+  if (newTokens[tokenAddress]) {
+    const old = new BN(newTokens[tokenAddress]);
+    newTokens[tokenAddress] = old.add(delta).toString();
+  } else {
+    newTokens[tokenAddress] = delta.toString();
+  }
+
+  context.updateSet = {
+    address: receiverState.address,
+    updates: states.account.update(receiverState, { tokens: newTokens }, context),
+    delta: amount,
+    token: tokenAddress,
+  };
+
+  debug('contract.transfer-token', context.updateSet);
+
+  next();
+});
+
+module.exports = runner;

package/lib/protocols/asset/calls/transfer.js

@@ -0,0 +1,29 @@
+const { BN } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+
+// eslint-disable-next-line global-require
+const debug = require('debug')(`${require('../../../../package.json').name}:acquire-asset:transfer`);
+
+const runner = new Runner();
+
+runner.use(pipes.ExtractState({ from: 'args.to', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
+
+runner.use(async (context, next) => {
+  const { states, receiverState, args } = context;
+
+  const old = new BN(receiverState.balance);
+  const delta = new BN(args.amount);
+
+  context.updateSet = {
+    address: receiverState.address,
+    updates: states.account.update(receiverState, { balance: old.add(delta).toString() }, context),
+    delta: args.amount,
+    token: '',
+  };
+
+  debug('contract.transfer', context.updateSet);
+
+  next();
+});
+
+module.exports = runner;