@ocap/tx-protocols 1.28.9 → 1.29.0

package/lib/protocols/trade/transfer-v3.js

@@ -1,333 +0,0 @@
-const { promisify } = require('node:util');
-const isEqual = require('lodash/isEqual');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Joi, schemas } = require('@arcblock/validator');
-const { BN } = require('@ocap/util');
-const { Runner, pipes } = require('@ocap/tx-pipeline');
-const { account, asset } = require('@ocap/state');
-const { getRelatedAddresses } = require('@ocap/util/lib/get-related-addr');
-
-const debug = require('debug')(`${require('../../../package.json').name}:transfer-v2`);
-
-const EnsureTxGas = require('../../pipes/ensure-gas');
-const EnsureTxCost = require('../../pipes/ensure-cost');
-const { applyTokenUpdates, applyTokenChange } = require('../../util');
-
-const runner = new Runner();
-
-const verifyAssetOwner = promisify(pipes.VerifyUpdater({ assetKey: 'assets', ownerKey: 'owner' }));
-
-// 0. verify itx
-const schema = Joi.object({
-  inputsList: schemas.multiInput.min(1).required(),
-  outputsList: schemas.multiInput.min(1).required(),
-  data: Joi.any().optional().allow(null),
-}).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);
-});
-
-// 0. extract itx
-runner.use(
-  pipes.VerifyTxInput({
-    fieldKey: 'itx.inputs',
-    inputsKey: 'inputs',
-    sendersKey: 'senders',
-    tokensKey: 'inputTokens',
-    assetsKey: 'inputAssets',
-  })
-);
-runner.use(
-  pipes.VerifyTxInput({
-    fieldKey: 'itx.outputs',
-    inputsKey: 'outputs',
-    sendersKey: 'receivers',
-    tokensKey: 'outputTokens',
-    assetsKey: 'outputAssets',
-  })
-);
-
-// 1. verify itx size: set hard limit here because more inputs leads to longer tx execute time
-runner.use(
-  pipes.VerifyListSize({
-    listKey: [
-      'inputs',
-      'outputs',
-      'senders',
-      'receivers',
-      'inputTokens',
-      'inputAssets',
-      'outputTokens',
-      'outputAssets',
-    ],
-  })
-);
-
-// 2. verify itx payload
-runner.use(
-  pipes.VerifyInfo([
-    {
-      error: 'INVALID_TX',
-      message: 'An owner can not exist in tx input and output at the same time',
-      fn: ({ senders, receivers }) => senders.every((x) => receivers.includes(x) === false),
-    },
-    {
-      error: 'INVALID_TX',
-      message: 'Input and output token address does not match',
-      fn: ({ inputTokens, outputTokens }) => isEqual(inputTokens, outputTokens),
-    },
-    {
-      error: 'INVALID_TX',
-      message: 'Input and output asset address does not match',
-      fn: ({ inputAssets, outputAssets }) => isEqual(inputAssets, outputAssets),
-    },
-
-    // If we made this far, token address must match with input and output
-    // Then we can safely sum all inputs and outputs and ensure that they match in amount
-    {
-      error: 'INVALID_TX',
-      message: 'Input and output token amount does not match',
-      fn: ({ inputs, outputs, inputTokens }) => {
-        const inputMap = {};
-        const outputMap = {};
-
-        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));
-          });
-        });
-
-        outputs.forEach(({ tokensList }) => {
-          tokensList.forEach(({ address, value }) => {
-            if (typeof outputMap[address] === 'undefined') {
-              outputMap[address] = new BN(0);
-            }
-            outputMap[address] = outputMap[address].add(new BN(value));
-          });
-        });
-
-        return inputTokens.every((address) => inputMap[address].eq(outputMap[address]));
-      },
-    },
-  ])
-);
-
-// 3. Extract token states FIRST to check token type and ownership
-runner.use(pipes.ExtractState({ from: 'inputTokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
-
-// 3.5. Conditionally verify multi sig - skip for token owner transferring credit tokens
-runner.use((context, next) => {
-  const { tx, inputTokens = [], tokenStates = [] } = context;
-
-  // Check if all input tokens are credit tokens and issuer is owner
-  const isCreditTokenFromIssuer = inputTokens.every((tokenAddress) => {
-    const tokenState = tokenStates.find((t) => t.address === tokenAddress);
-    return tokenState && tokenState.type === 'CreditToken' && tokenState.issuer === tx.from;
-  });
-
-  // Token owner transferring credit tokens from users
-  // Skip multi-sig verification for signers
-  if (isCreditTokenFromIssuer) {
-    return next();
-  }
-
-  // Normal transfer: verify all senders' signatures
-  const verifyMultiSig = pipes.VerifyMultiSigV2({ signersKey: 'senders' });
-  return verifyMultiSig(context, next);
-});
-
-// 4. verify sender & signer & receiver
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
-runner.use(
-  pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })
-);
-runner.use(pipes.ExtractState({ from: 'receivers', to: 'receiverStates', status: 'OK', table: 'account' }));
-runner.use(pipes.VerifyBlocked({ stateKeys: ['signerStates', 'receiverStates'] }));
-runner.use(pipes.AntiLandAttack({ senderState: 'signerStates', receiverState: 'receiverStates' }));
-runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', stateKey: 'senderState', addressKey: 'tx.from' }));
-
-// 5. verify token state and balance
-runner.use(pipes.VerifyTokenBalance({ ownerKey: 'signerStates', conditionKey: 'inputs' }));
-runner.use(
-  pipes.verifyTokenAccess({
-    statesKey: 'tokenStates',
-    listFieldKey: 'spenders',
-    accountKeys: ['senderState'],
-    errorMessage: 'Account {address} is not allowed to transfer token {tokenAddress}',
-  })
-);
-
-// 6. verify asset state and transferrable, ownership
-runner.use(pipes.ExtractState({ from: 'inputAssets', to: 'assetStates', status: 'INVALID_ASSET', table: 'asset' }));
-runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
-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 {
-      await verifyAssetOwner({ assets: states, owner: signer });
-    } catch (err) {
-      return next(err);
-    }
-  }
-
-  return next();
-});
-
-// Ensure tx fee and gas
-runner.use(
-  EnsureTxGas((context) => {
-    // FIXME: payment check
-    const ops = { create: 0, update: 0, payment: 0 };
-    ops.update += context.signerStates.length;
-    ops.update += context.inputAssets.length;
-
-    context.receivers.forEach((x) => {
-      if (context.receiverStates.find((r) => r.address === x)) {
-        ops.update += 1;
-      } else {
-        ops.create += 1;
-      }
-    });
-
-    if (context.senderState) {
-      ops.update += 1;
-    } else {
-      ops.create += 1;
-    }
-
-    return ops;
-  })
-);
-runner.use(EnsureTxCost({ attachSenderChanges: true }));
-
-// Save context snapshot before updating states
-runner.use(pipes.TakeStateSnapshot());
-
-// Update statedb
-runner.use(
-  async (context, next) => {
-    const {
-      tx,
-      inputs,
-      outputs,
-      receivers,
-      senderState,
-      signerStates,
-      senderChange,
-      updateVaults,
-      receiverStates = [],
-      assetStates = [],
-      statedb,
-    } = context;
-
-    const signerUpdates = {};
-    inputs.forEach((x) => {
-      const { owner, tokensList } = x;
-      signerUpdates[owner] = applyTokenUpdates(
-        tokensList,
-        signerStates.find((s) => s.address === owner),
-        'sub'
-      );
-      if (senderChange && owner === senderChange.address) {
-        signerUpdates[owner] = applyTokenChange(signerUpdates[owner], senderChange);
-      }
-    });
-
-    const receiverUpdates = {};
-    const assetUpdates = {};
-    outputs.forEach((x) => {
-      const { owner, tokensList, assetsList } = x;
-      const ownerState = receiverStates.find((s) => getRelatedAddresses(s).includes(owner)) || { address: owner };
-      receiverUpdates[ownerState.address] = applyTokenUpdates(tokensList, ownerState, 'add');
-      if (senderChange && ownerState.address === senderChange.address) {
-        receiverUpdates[ownerState.address] = applyTokenChange(receiverUpdates[ownerState.address], senderChange);
-      }
-      assetsList.forEach((address) => {
-        assetUpdates[address] = { owner: ownerState.address };
-      });
-    });
-
-    const sender = senderState ? senderState.address : tx.from;
-    const isAlsoSigner = !!signerUpdates[sender];
-    const isAlsoReceiver = !!receiverUpdates[sender];
-
-    // When the sender is not in the inputs and outputs, we need to handle the gas fee update separately
-    const senderUpdates = {};
-    if (!isAlsoSigner && !isAlsoReceiver && senderState && senderChange) {
-      senderUpdates[sender] = applyTokenChange(senderState, senderChange);
-    }
-
-    debug('transfer-v3', { signerUpdates, receiverUpdates, assetUpdates, isAlsoSigner, isAlsoReceiver });
-
-    const [newSenderState, newSignerStates, newReceiverStates, newAssetStates] = await Promise.all([
-      // Update sender state
-      statedb.account.updateOrCreate(
-        senderState,
-        account.updateOrCreate(
-          senderState,
-          Object.assign(
-            { address: sender, nonce: tx.nonce, pk: tx.pk },
-            signerUpdates[sender] || {},
-            receiverUpdates[sender] || {},
-            senderUpdates[sender] || {}
-          ),
-          context
-        ),
-        context
-      ),
-
-      // Update signer state
-      Promise.all(
-        signerStates
-          .filter((x) => x.address !== sender)
-          .map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context))
-      ),
-
-      // UpdateOrCreate receiver state
-      Promise.all(
-        receivers
-          .filter((x) => x !== sender)
-          .map((x) => {
-            const receiverState = receiverStates.find((s) => getRelatedAddresses(s).includes(x));
-            const owner = receiverState ? receiverState.address : x;
-            return statedb.account.updateOrCreate(
-              receiverState,
-              account.updateOrCreate(receiverState, { ...receiverUpdates[owner], address: owner }, context),
-              context
-            );
-          })
-      ),
-
-      // Update asset state
-      Promise.all(
-        assetStates.map((x) =>
-          statedb.asset.update(x.address, asset.update(x, assetUpdates[x.address], context), context)
-        )
-      ),
-    ]);
-
-    await updateVaults();
-
-    context.senderState = newSenderState;
-    context.signerStates = isAlsoSigner ? newSignerStates.concat(newSenderState) : newSignerStates;
-    context.receiverStates = isAlsoReceiver ? newReceiverStates.concat(newSenderState) : newReceiverStates;
-    context.assetStates = newAssetStates;
-
-    debug('transfer-v3', { inputs, outputs });
-
-    next();
-  },
-  { persistError: true }
-);
-
-runner.use(pipes.VerifyStateDiff());
-
-module.exports = runner;