@ocap/tx-protocols 1.6.3 → 1.6.10

package/lib/protocols/asset/create.js

@@ -1,44 +1,49 @@
+/* eslint-disable indent */
+const Error = require('@ocap/util/lib/error');
+const isEmpty = require('lodash/isEmpty');
 const cloneDeep = require('lodash/cloneDeep');
-const isEmpty = require('empty-value');
-const { toAssetAddress } = require('@arcblock/did-util');
 const { Runner, pipes } = require('@ocap/tx-pipeline');
 const { account, asset } = require('@ocap/state');
+const { toAssetAddress } = require('@arcblock/did-util');
 
 // eslint-disable-next-line global-require
 const debug = require('debug')(`${require('../../../package.json').name}:create-asset`);
 
-const { decodeItxData } = require('../../util');
+const { decodeAnySafe } = require('../../util');
+const ensureServiceFee = require('../rollup/pipes/ensure-service-fee');
 
 const runner = new Runner();
 
-runner.use(pipes.VerifyMultiSig(0));
-
+// Verify itx
+runner.use(({ itx }, next) => {
+  const { error } = asset.schema.validate(itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+  return next();
+});
 runner.use(
   pipes.VerifyInfo([
-    {
-      error: 'INSUFFICIENT_DATA',
-      message: 'itx.data or itx.address must not be empty',
-      fn: ({ itx }) => itx.address && itx.data,
-    },
     {
       error: 'INVALID_ASSET',
       message: 'Asset address is not valid',
       fn: (context) => {
         const itx = cloneDeep(context.itx);
-        itx.data = decodeItxData(itx.data);
-        delete itx.address;
+        itx.data = decodeAnySafe(itx.data);
+        itx.address = '';
+
+        // Save for later use
+        context.assetData = itx.data;
+        context.signers = [itx.issuer].filter(Boolean);
+
         return toAssetAddress(itx) === context.itx.address;
       },
     },
   ])
 );
 
-// Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
-runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
-
-// Ensure parent exist
-runner.use(pipes.ExtractState({ from: 'itx.parent', to: 'parentAsset', status: 'INVALID_ASSET' }));
+// Ensure issuer signed
+runner.use(pipes.VerifyMultiSigV2({ signersKey: 'signers' }));
 
 // Ensure asset not exist
 runner.use(pipes.ExtractState({ from: 'itx.address', to: 'assetState', status: 'OK' }));
@@ -47,33 +52,77 @@ runner.use(
     {
       error: 'INVALID_ASSET',
       message: 'This asset already exist on chain',
-      fn: (context) => isEmpty(context.assetState),
+      fn: (context) => !context.assetState,
     },
   ])
 );
 
+// Ensure issuer exist
+runner.use(pipes.ExtractState({ from: 'itx.issuer', to: 'issuerState', status: 'INVALID_ISSUER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ signerKey: 'issuerState' }));
+
+// 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' }));
+
+// Check if parent is a factory
+runner.use(pipes.ExtractState({ from: 'itx.parent', to: 'factoryState', status: 'OK', table: 'factory' }));
+runner.use(
+  pipes.VerifyInfo([
+    // For security consideration, user can not create fake assets from a factory
+    // https://github.com/ArcBlock/asset-chain/issues/97
+    {
+      error: 'CREATE_FROM_FACTORY',
+      message: 'You can only get asset from factory from acquire or mint',
+      fn: ({ itx, factoryState }) => !(itx.parent && factoryState),
+      persist: true,
+    },
+  ])
+);
+
+// Ensure parent exist
+runner.use(pipes.ExtractState({ from: 'itx.parent', to: 'parentAsset', status: 'INVALID_ASSET', table: 'asset' }));
+
+runner.use(ensureServiceFee);
+
 // Update asset state
-runner.use(async (context, next) => {
-  const { itx, statedb, senderState } = context;
-  const data = decodeItxData(itx.data);
+runner.use(
+  async (context, next) => {
+    const { tx, itx, assetData, statedb, senderState, delegatorState, senderUpdates, vaultState, vaultUpdates } =
+      context;
+    const owner = delegatorState ? delegatorState.address : senderState.address;
 
-  // Update owner state
-  const ownerState = await statedb.account.update(
-    senderState.address,
-    account.update(senderState, { numAssets: senderState.numAssets + 1 }, context),
-    context
-  );
+    const [newSenderState, assetState, newVaultState] = await Promise.all([
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
 
-  // Create asset state
-  const attrs = asset.create({ ...itx, data, owner: ownerState.address, issuer: ownerState.address }, context);
-  const assetState = await statedb.asset.create(itx.address, attrs, context);
+      statedb.asset.create(
+        itx.address,
+        asset.create({ ...itx, tags: itx.tagsList, data: assetData, owner }, context),
+        context
+      ),
 
-  context.senderState = ownerState;
-  context.assetState = assetState;
+      isEmpty(vaultUpdates)
+        ? vaultState
+        : statedb.account.update(vaultState.address, account.update(vaultState, vaultUpdates, context), context),
+    ]);
 
-  debug('create', assetState);
+    context.senderState = newSenderState;
+    context.assetState = assetState;
+    context.vaultState = newVaultState;
 
-  next();
-});
+    debug('createAsset', assetState);
+
+    next();
+  },
+  { persistError: true }
+);
 
 module.exports = runner;

package/lib/protocols/asset/mint.js

@@ -0,0 +1,133 @@
+/* eslint-disable function-paren-newline */
+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`);
+
+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 runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+runner.use(verifyAcquireParams('mint'));
+
+// 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,
+    },
+  ])
+);
+
+// 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 factory exist
+runner.use(pipes.ExtractState({ from: 'itx.factory', to: 'factoryState', status: 'INVALID_FACTORY_STATE', table: 'factory' })); // prettier-ignore
+
+// Used to assemble issuer object
+runner.use(pipes.ExtractState({ from: 'factoryState.owner', to: 'factoryOwnerState', status: 'INVALID_OWNER', table: 'account' })); // prettier-ignore
+
+// Ensure factory owner exist and equal to sender
+runner.use(pipes.ExtractState({ from: 'itx.owner', to: 'ownerState', status: 'OK', table: 'account' }));
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'OWNER_ONLY_OPERATION',
+      message: 'Only factory owner is allowed to mint',
+      fn: ({ factoryState, senderState }) => factoryState.owner === senderState.address,
+      persist: true,
+    },
+  ])
+);
+
+// Prepare for itx.assets verify
+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',
+  })
+);
+
+runner.use(verifyMintLimit);
+runner.use(verifyItxVariables);
+runner.use(verifyItxAddress('mint'));
+runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'ownerState' }));
+runner.use(verifyItxAssets);
+
+// update statedb
+runner.use(
+  async (context, next) => {
+    const {
+      tx,
+      itx,
+      txTime,
+      statedb,
+      senderState,
+      factoryState,
+      mintedAsset,
+      mintedAddress,
+      ownerState,
+      assetStates = [],
+    } = context;
+
+    const owner = ownerState ? ownerState.address : itx.owner;
+
+    const senderUpdates = { nonce: tx.nonce, pk: tx.pk };
+    const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
+
+    const [newSenderState, newReceiverState, assetState, newFactoryState, newAssetStates] = await Promise.all([
+      // update sender
+      statedb.account.update(senderState.address, account.update(senderState, senderUpdates, 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 factory
+      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)
+        )
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
+    context.assetState = assetState;
+    context.factoryState = newFactoryState;
+    context.assetStates = newAssetStates;
+
+    debug('mint', assetState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+module.exports = runner;

package/lib/protocols/asset/pipes/exec-mint-hook.js

@@ -0,0 +1,59 @@
+/* eslint-disable no-await-in-loop */
+// contract calls
+const cloneDeep = require('lodash/cloneDeep');
+const transferCall = require('../calls/transfer');
+const transferTokenCall = require('../calls/transfer-token');
+
+const contractCalls = {
+  transfer: transferCall,
+  transferToken: transferTokenCall,
+};
+
+module.exports = async (context, next) => {
+  const { statedb, factoryState, tokenUpdates, config } = context;
+
+  if (factoryState.settlement === 'instant') {
+    const mintHook = factoryState.hooks.find((x) => x.name === 'mint');
+    if (mintHook && mintHook.type === 'contract') {
+      context.updatedAccounts = [];
+
+      // These calls must be run sequentially, because different calls may update same account
+      const clone = cloneDeep(mintHook.compiled);
+      for (const x of clone) {
+        // Convert transfer to transferToken call for backwards compatibility
+        if (x.call === 'transfer') {
+          x.call = 'transferToken';
+          x.args.tokenAddress = config.token.address;
+        }
+
+        const pipeline = contractCalls[x.call];
+        const { updateSet } = await pipeline.runAsync({
+          states: context.states,
+          statedb,
+          txn: context.txn,
+          txTime: context.txTime,
+          txHash: context.txHash,
+          args: x.args,
+        });
+
+        await statedb.account.update(updateSet.address, updateSet.updates, context);
+        context.updatedAccounts.push(updateSet);
+      }
+    }
+  } else {
+    context.receipts = [
+      {
+        address: factoryState.address,
+        changes: Object.keys(tokenUpdates.tokens)
+          .map((x) => ({
+            target: x,
+            action: 'transfer',
+            value: tokenUpdates.tokens[x],
+          }))
+          .filter((x) => x.value > 0),
+      },
+    ];
+  }
+
+  next();
+};

package/lib/protocols/asset/pipes/extract-factory-tokens.js

@@ -0,0 +1,18 @@
+const uniqBy = require('lodash/uniqBy');
+const { BN } = require('@ocap/util');
+const createSortedList = require('@ocap/util/lib/create-sorted-list');
+
+// Create token requirements from factoryState
+module.exports = (context, next) => {
+  const { factoryState, config } = context;
+  context.factoryTokens = [...factoryState.input.tokens];
+
+  const exist = context.factoryTokens.find((x) => x.address === config.token.address);
+  if (!exist && new BN(factoryState.input.value).gt(new BN(0))) {
+    context.factoryTokens.push({ address: config.token.address, value: factoryState.input.value });
+  }
+
+  context.factoryTokens = uniqBy(context.factoryTokens, 'address');
+  context.tokenAddress = createSortedList(context.factoryTokens.map((x) => x.address));
+  next();
+};

package/lib/protocols/asset/pipes/verify-acquire-params.js

@@ -0,0 +1,30 @@
+const Error = require('@ocap/util/lib/error');
+const getListField = require('@ocap/util/lib/get-list-field');
+
+module.exports =
+  (mode) =>
+  ({ itx }, next) => {
+    if (!itx.factory) {
+      return next(new Error('INSUFFICIENT_DATA', 'itx.factory must not be empty'));
+    }
+    if (!itx.address) {
+      return next(new Error('INSUFFICIENT_DATA', 'itx.address must not be empty'));
+    }
+    if (mode === 'acquire-v2') {
+      if (!itx.issuer) {
+        return next(new Error('INSUFFICIENT_DATA', 'itx.issuer must not be empty'));
+      }
+    }
+    if (['mint', 'acquire-v3'].includes(mode)) {
+      if (!itx.owner) {
+        return next(new Error('INSUFFICIENT_DATA', 'itx.owner must not be empty'));
+      }
+    }
+
+    const variables = getListField(itx, 'variables');
+    if (!Array.isArray(variables) && !variables.length) {
+      return next(new Error('INSUFFICIENT_DATA', 'itx.variables must not be empty'));
+    }
+
+    return next();
+  };

package/lib/protocols/asset/pipes/verify-itx-address.js

@@ -0,0 +1,41 @@
+const Error = require('@ocap/util/lib/error');
+const { mintFromFactory } = require('@ocap/asset');
+
+module.exports = (mode) => (context, next) => {
+  const { itx, senderState, ownerState, factoryState, delegatorState, factoryOwnerState, factoryInputs } = context;
+
+  let issuer = null;
+  let owner = null;
+
+  if (mode === 'acquire-v2') {
+    owner = delegatorState || senderState;
+    issuer = itx.issuer;
+    context.assetOwner = owner;
+  } else if (mode === 'acquire-v3') {
+    owner = ownerState || { address: itx.owner };
+    issuer = itx.issuer;
+  } else if (mode === 'mint') {
+    owner = ownerState || { address: itx.owner };
+    issuer = {
+      id: factoryOwnerState.address,
+      pk: factoryOwnerState.pk,
+      name: factoryOwnerState.moniker,
+    };
+  }
+
+  const minted = mintFromFactory({
+    factory: factoryState,
+    inputs: factoryInputs,
+    owner: owner.address,
+    issuer,
+  });
+
+  if (minted.address !== itx.address) {
+    return next(new Error('INVALID_ASSET', 'Invalid itx.address: does not match with minted asset address'));
+  }
+
+  context.mintedAsset = minted.asset;
+  context.mintedAddress = minted.address;
+
+  return next();
+};

package/lib/protocols/asset/pipes/verify-itx-assets.js

@@ -0,0 +1,49 @@
+const Error = require('@ocap/util/lib/error');
+const getListField = require('@ocap/util/lib/get-list-field');
+
+module.exports = (context, next) => {
+  const { factoryState, expectedFactoryStates = [], assetStates: actualAssetStates = [], itx } = context;
+  const { assets: expectedAssets } = factoryState.input;
+
+  if (expectedAssets.length === 0) {
+    return next();
+  }
+
+  const inputAssets = getListField(itx, 'assets');
+
+  // Are all input assets found on chain?
+  if (inputAssets.length > actualAssetStates.length) {
+    return next(new Error('INVALID_ASSET', 'Input asset does not exist on chain'));
+  }
+
+  // https://github.com/ArcBlock/asset-chain/issues/96
+  // If factory.input.assets are all factory
+  if (expectedFactoryStates.length === expectedAssets.length) {
+    // Just ensure that input assets are minted from any of the factory
+    // They do not need to match on number
+    if (actualAssetStates.every((x) => x.parent && expectedAssets.includes(x.parent) && !x.consumedTime)) {
+      return next();
+    }
+
+    return next(new Error('INVALID_ASSET', 'Input asset not minted from any of factory.input.assets'));
+  }
+
+  // For specific assets, they must not be consumed
+  // For factory, they must exist on chain
+  // eslint-disable-next-line no-restricted-syntax
+  for (const address of expectedAssets) {
+    const plainAsset = actualAssetStates.find((x) => x.address === address);
+    if (plainAsset) {
+      if (plainAsset.consumedTime) {
+        return next(new Error('INVALID_ASSET', `Input asset ${address} already consumed`));
+      }
+    } else {
+      const childAsset = actualAssetStates.find((x) => x.parent === address);
+      if (!childAsset) {
+        return next(new Error('INVALID_ASSET', `Input asset not found ${address}`));
+      }
+    }
+  }
+
+  return next();
+};

package/lib/protocols/asset/pipes/verify-itx-variables.js

@@ -0,0 +1,26 @@
+const Error = require('@ocap/util/lib/error');
+const getListField = require('@ocap/util/lib/get-list-field');
+
+module.exports = (context, next) => {
+  const { factoryState, itx } = context;
+  const { variables } = factoryState.input;
+
+  // validate input variables
+  const factoryInputs = getListField(itx, 'variables').reduce((acc, x) => {
+    acc[x.name] = x.value;
+    return acc;
+  }, {});
+  const missingVariables = variables.filter((x) => x.required && !factoryInputs[x.name]);
+  if (missingVariables.length) {
+    return next(
+      new Error(
+        'INVALID_FACTORY_INPUT',
+        `Invalid itx.variables: missing required input variable: ${missingVariables.map((x) => x.name).join(', ')}`
+      )
+    );
+  }
+
+  context.factoryInputs = factoryInputs;
+
+  return next();
+};

package/lib/protocols/asset/pipes/verify-mint-limit.js

@@ -0,0 +1,13 @@
+const Error = require('@ocap/util/lib/error');
+
+module.exports = ({ factoryState }, next) => {
+  if (factoryState.limit === 0) {
+    return next();
+  }
+
+  if (factoryState.numMinted < factoryState.limit) {
+    return next();
+  }
+
+  return next(new Error('EXCEED_MINT_LIMIT', 'This request will exceed factory mint limit'));
+};