@ocap/tx-protocols 1.28.8 → 1.29.0

package/lib/protocols/token-factory/burn.js

@@ -1,371 +0,0 @@
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Joi, schemas } = require('@arcblock/validator');
-const { BN, fromUnitToToken } = require('@ocap/util');
-const { Runner, pipes } = require('@ocap/tx-pipeline');
-const { account, tokenFactory, token } = require('@ocap/state');
-const pick = require('lodash/pick');
-
-const EnsureTxGas = require('../../pipes/ensure-gas');
-const EnsureTxCost = require('../../pipes/ensure-cost');
-const CalcReserve = require('./pipes/calc-reserve');
-const { applyTokenChange, applyTokenUpdates } = require('../../util');
-
-const runner = new Runner();
-
-const schema = Joi.object({
-  tokenFactory: Joi.DID().prefix().role('ROLE_TOKEN_FACTORY').required(),
-  receiver: schemas.tokenHolder.required(),
-  minReserve: Joi.alternatives().try(Joi.BN().greater(0), Joi.equal('')).optional(),
-  inputsList: schemas.multiInput.min(1).required(),
-  data: Joi.any().optional().allow(null),
-}).options({ stripUnknown: true, noDefaults: false });
-
-// 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();
-});
-
-// verify token factory
-runner.use(
-  pipes.ExtractState({
-    from: 'itx.tokenFactory',
-    to: 'tokenFactoryState',
-    status: 'INVALID_TOKEN_FACTORY',
-    table: 'tokenFactory',
-  })
-);
-
-// ensure token state
-runner.use(
-  pipes.ExtractState({
-    from: 'tokenFactoryState.tokenAddress',
-    to: 'tokenState',
-    status: 'INVALID_TOKEN',
-    table: 'token',
-  })
-);
-
-// verify inputs
-runner.use(
-  pipes.VerifyTxInput({
-    fieldKey: 'itx.inputs',
-    inputsKey: 'inputs',
-    sendersKey: 'senders',
-    tokensKey: 'tokens',
-    assetsKey: null,
-  })
-);
-
-// 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'] }));
-
-// verify multi sig
-runner.use(pipes.VerifyMultiSigV2({ signersKey: 'senders' }));
-
-// verify inputs token
-runner.use((context, next) => {
-  const { tokenFactoryState, inputs } = context;
-
-  const isAccepted = inputs.every(
-    (input) =>
-      input.tokensList.length &&
-      input.tokensList.every((x) => x.address === tokenFactoryState.tokenAddress) &&
-      !input.assetsList.length
-  );
-
-  if (!isAccepted) {
-    return next(new Error('INVALID_TX', `Inputs only accept ${tokenFactoryState.tokenAddress}`));
-  }
-
-  return next();
-});
-
-// ensure sender
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
-runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
-
-runner.use(
-  pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })
-);
-runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', stateKey: 'senderState', addressKey: 'tx.from' }));
-
-// ensure receiver
-runner.use(pipes.ExtractState({ from: 'itx.receiver', to: 'receiverState', status: 'OK', table: 'account' }));
-runner.use(pipes.VerifyAccountMigration({ stateKey: 'receiverState', addressKey: 'itx.receiver' }));
-
-// verify blocked
-runner.use(pipes.VerifyBlocked({ stateKeys: ['signerStates', 'receiverState'] }));
-
-// ensure owner
-runner.use(
-  pipes.ExtractState({
-    from: 'tokenFactoryState.owner',
-    to: 'ownerState',
-    status: 'INVALID_OWNER_STATE',
-    table: 'account',
-  })
-);
-
-// verify minters restriction
-runner.use(
-  pipes.verifyTokenAccess({
-    statesKey: 'tokenState',
-    listFieldKey: 'minters',
-    accountKeys: ['senderState'],
-    errorMessage: 'Account {address} is not allowed to burn token {tokenAddress}',
-  })
-);
-
-// calculate burn amount
-runner.use((context, next) => {
-  const { inputs, tokenFactoryState } = context;
-  let amount = new BN('0');
-
-  for (const { tokensList } of inputs) {
-    const delta = tokensList.find((x) => x.address === tokenFactoryState.tokenAddress)?.value;
-    if (!delta) {
-      return next(new Error('INVALID_TX', 'Invalid inputs'));
-    }
-    amount = amount.add(new BN(delta));
-  }
-
-  context.burnAmount = amount.toString();
-
-  return next();
-});
-
-// calculate reserve amount / fee
-runner.use(
-  CalcReserve({
-    tokenFactoryKey: 'tokenFactoryState',
-    tokenStateKey: 'tokenState',
-    reserveKey: 'reserveAmount',
-    feeKey: 'reserveFee',
-    amountKey: 'burnAmount',
-    direction: 'burn',
-  }),
-  { shouldSkip: ({ tokenFactoryState }) => !tokenFactoryState.curve }
-);
-
-// verify slippage
-runner.use(
-  (context, next) => {
-    const { reserveAmount, reserveFee } = context;
-    const { minReserve } = context.itx;
-
-    if (minReserve && new BN(reserveAmount).lt(new BN(minReserve).add(new BN(reserveFee || '0')))) {
-      return next(
-        new Error(
-          'SLIPPAGE_EXCEEDED',
-          `Burn token failed due to price movement. Expected minimum: ${fromUnitToToken(minReserve)}, actual: ${fromUnitToToken(reserveAmount)}. Try reducing your minReserve.`
-        )
-      );
-    }
-
-    return next();
-  },
-  { shouldSkip: ({ tokenFactoryState }) => !tokenFactoryState.curve }
-);
-
-// verify balance
-runner.use(pipes.ExtractState({ from: 'tokens', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
-runner.use(pipes.VerifyTokenBalance({ ownerKey: 'signerStates', conditionKey: 'inputs' }));
-
-// verify token factory balance
-runner.use((context, next) => {
-  const { tokenFactoryState } = context;
-  if (new BN(tokenFactoryState.currentSupply).lt(new BN(context.burnAmount))) {
-    return next(new Error('INSUFFICIENT_FUND', 'Token factory supply is not enough'));
-  }
-  if (new BN(tokenFactoryState.reserveBalance).lt(new BN(context.reserveAmount || '0'))) {
-    return next(new Error('INSUFFICIENT_FUND', 'Token factory reserve balance is not enough'));
-  }
-  return next();
-});
-
-// Ensure tx fee and gas
-runner.use(
-  EnsureTxGas((context) => {
-    const result = { create: 0, update: 2, payment: 0 };
-
-    if (context.senderState) {
-      result.update += 1;
-    } else {
-      result.create += 1;
-    }
-
-    if (context.tokenFactoryState.curve) {
-      if (context.receiverState) {
-        result.update += 1;
-      } else {
-        result.create += 1;
-      }
-    }
-
-    if (context.reserveFee) {
-      result.update += 1; // owner
-    }
-
-    if (context.signerStates) {
-      result.update += context.signerStates.length;
-    }
-
-    return result;
-  })
-);
-runner.use(EnsureTxCost({ attachSenderChanges: true }));
-
-// Save context snapshot before updating states
-runner.use(pipes.TakeStateSnapshot());
-
-// update statedb: transfer tokens to new owner
-runner.use(
-  async (context, next) => {
-    const {
-      tx,
-      senderState,
-      receiverState,
-      ownerState,
-      statedb,
-      senderChange,
-      updateVaults,
-      tokenFactoryState,
-      tokenState,
-      reserveAmount,
-      reserveFee,
-      itx,
-      inputs,
-      signerStates,
-      burnAmount,
-    } = context;
-    const { receiver } = itx;
-    const { reserveAddress, tokenAddress } = tokenFactoryState;
-
-    const accountUpdates = {};
-    const inputChanges = [];
-
-    // update signer burns
-    inputs.forEach(({ owner, tokensList }) => {
-      const tokenChange = tokensList.find((item) => item.address === tokenAddress);
-
-      accountUpdates[owner] = applyTokenUpdates(
-        [tokenChange],
-        signerStates.find((s) => s.address === owner),
-        'sub'
-      );
-
-      inputChanges.push({
-        address: owner,
-        token: tokenAddress,
-        delta: new BN(tokenChange.value).neg().toString(),
-      });
-    });
-
-    // Ensure the sender exists in accountUpdates, because even if there is no balance change, we need to update his nonce
-    if (!accountUpdates[tx.from]) {
-      accountUpdates[tx.from] = senderState || {};
-    }
-
-    // update owner
-    if (reserveFee && new BN(reserveFee).gt(0)) {
-      accountUpdates[ownerState.address] = applyTokenChange(accountUpdates[ownerState.address] || ownerState, {
-        address: ownerState.address,
-        token: reserveAddress,
-        delta: reserveFee,
-      });
-    }
-
-    // update receiver
-    // should not update receiver for credit token
-    if (tokenFactoryState.curve) {
-      accountUpdates[receiver] = applyTokenChange(
-        accountUpdates[receiver] || receiverState || { address: receiver, tokens: {} },
-        {
-          address: receiver,
-          token: reserveAddress,
-          delta: new BN(reserveAmount).sub(new BN(reserveFee || '0')).toString(), // reserveAmount - reserveFee
-        }
-      );
-    }
-
-    // update sender
-    if (senderChange) {
-      accountUpdates[senderChange.address] = applyTokenChange(
-        accountUpdates[senderChange.address] || senderState,
-        senderChange
-      );
-    }
-
-    const [newAccountStates, newTokenFactoryState, newTokenState] = await Promise.all([
-      // update accounts
-      Promise.all(
-        Object.entries(accountUpdates).map(([address, updates]) => {
-          // We can use updateOrCreate here because the owner and signer have already been validated to exist earlier,
-          // the sender and receiver are allowed to be created in the transaction.
-          const state = [senderState, receiverState, ownerState, ...signerStates].find((x) => x?.address === address);
-
-          // Should only update nonce and pk for sender and new accounts
-          const actualUpdates = state ? pick(updates, ['tokens']) : { ...updates, address };
-
-          // Should only update nonce and pk for sender
-          if (address === tx.from) {
-            actualUpdates.pk = tx.pk;
-            actualUpdates.nonce = tx.nonce;
-          }
-
-          return statedb.account.updateOrCreate(state, account.updateOrCreate(state, actualUpdates, context), context);
-        })
-      ),
-
-      // Update token factory state
-      statedb.tokenFactory.update(
-        tokenFactoryState.address,
-        tokenFactory.update(
-          tokenFactoryState,
-          {
-            currentSupply: new BN(tokenFactoryState.currentSupply).sub(new BN(burnAmount)).toString(),
-            reserveBalance: new BN(tokenFactoryState.reserveBalance).sub(new BN(reserveAmount || '0')).toString(),
-          },
-          context
-        ),
-        context
-      ),
-
-      statedb.token.update(
-        tokenAddress,
-        token.update(
-          tokenState,
-          {
-            totalSupply: new BN(tokenState.totalSupply).sub(new BN(burnAmount)).toString(),
-          },
-          context
-        ),
-        context
-      ),
-    ]);
-
-    context.senderState = newAccountStates.find((x) => x.address === tx.from);
-    context.receiverState = newAccountStates.find((x) => x.address === receiver);
-    // owner maybe not updated
-    context.ownerState = newAccountStates.find((x) => x.address === ownerState.address) || ownerState;
-    context.signerStates = newAccountStates.filter((x) => signerStates.find((s) => s.address === x.address));
-    context.tokenFactoryState = newTokenFactoryState;
-    context.tokenState = newTokenState;
-
-    // save this for receipt generation
-    context.inputChanges = inputChanges;
-
-    await updateVaults();
-
-    next();
-  },
-  { persistError: true }
-);
-
-runner.use(pipes.VerifyStateDiff());
-
-module.exports = runner;

package/lib/protocols/token-factory/create.js

@@ -1,342 +0,0 @@
-const isEmpty = require('empty-value');
-const cloneDeep = require('lodash/cloneDeep');
-const uniq = require('lodash/uniq');
-const { Joi } = require('@arcblock/validator');
-const { CustomError: Error } = require('@ocap/util/lib/error');
-const { Runner, pipes } = require('@ocap/tx-pipeline');
-const { account, token, tokenFactory, delegation, stake } = require('@ocap/state');
-const { toTokenFactoryAddress, toTokenAddress, toStakeAddress } = require('@arcblock/did-util');
-const { BN, fromTokenToUnit, fromUnitToToken } = require('@ocap/util');
-
-const debug = require('debug')(`${require('../../../package.json').name}:create-token-factory`);
-const { applyTokenChange, decodeAnySafe, getDelegationRequirements } = require('../../util');
-
-const EnsureTxGas = require('../../pipes/ensure-gas');
-const EnsureTxCost = require('../../pipes/ensure-cost');
-const verifyIcon = require('./pipes/verify-icon');
-const verifyUrl = require('./pipes/verify-url');
-const verifyOwnership = require('./pipes/verify-ownership');
-
-const runner = new Runner();
-
-const isTest = process.env.NODE_ENV === 'development' || process.env.NODE_ENV === 'test' || process.env.CI;
-
-runner.use(pipes.VerifyMultiSig(0));
-
-const schema = Joi.object({
-  address: Joi.DID().prefix().role('ROLE_TOKEN_FACTORY').required(),
-  feeRate: Joi.number().min(0).max(2000).required(),
-  curve: Joi.when('token.type', {
-    is: 'CreditToken',
-    then: Joi.valid(null).optional().messages({
-      'any.only': 'Should not provide curve for CreditToken',
-    }),
-    otherwise: tokenFactory.curveSchema.required(),
-  }),
-  reserveAddress: Joi.DID().prefix().role('ROLE_TOKEN').required(),
-  token: Joi.object({
-    name: Joi.string().min(1).max(32).required(),
-    description: Joi.string().min(16).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(2).max(18).required(),
-    icon: Joi.string().optional().allow(null, ''),
-    maxTotalSupply: Joi.alternatives().try(Joi.BN().greater(0), Joi.string().valid('')).optional().allow(null),
-    website: Joi.string()
-      .uri({
-        scheme: isTest ? ['http', 'https'] : ['https'],
-        allowRelative: false,
-      })
-      .max(256)
-      .optional()
-      .allow(null, ''),
-    metadata: Joi.any().required(),
-    spendersList: Joi.array().items(Joi.DID().prefix()).max(30).optional().allow(null).default(null),
-    mintersList: Joi.array().items(Joi.DID().prefix()).max(30).optional().allow(null).default(null),
-    type: Joi.string().valid('CreditToken', 'BondingCurveToken').required(),
-  }).required(),
-  data: Joi.any().optional().allow(null),
-}).options({ stripUnknown: true, noDefaults: false });
-
-// 1. verify itx
-runner.use((context, next) => {
-  const { error, value } = schema.validate(context.itx);
-  if (error) {
-    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
-  }
-
-  // filter by curve type
-  context.itx.curve = value.curve;
-
-  // decode and verify metadata
-  if (context.itx.token.metadata) {
-    const metadata = decodeAnySafe(context.itx.token.metadata);
-    const { error: metadataError, value: metadataValue } = token.metadataSchema.validate(metadata.value);
-    if (metadataError) {
-      return next(new Error('INVALID_TX', `Invalid metadata: ${metadataError.message}`));
-    }
-    context.itx.token.metadata = { ...metadata, value: metadataValue };
-  }
-
-  // convert spendersList to spenders
-  context.itx.token.spenders = value.token.spendersList?.length ? uniq(value.token.spendersList) : null;
-  delete context.itx.token.spendersList;
-
-  // convert mintersList to minters
-  context.itx.token.minters = value.token.mintersList?.length ? uniq(value.token.mintersList) : null;
-  delete context.itx.token.mintersList;
-
-  return next();
-});
-
-runner.use(
-  pipes.VerifyInfo([
-    // verify token address is valid
-    {
-      error: 'INVALID_TOKEN',
-      message: 'Token address is not valid',
-      fn: (context) => {
-        return toTokenAddress({ ...context.itx.token, address: '' }) === context.itx.token.address;
-      },
-    },
-    // verify token factory address is valid
-    {
-      error: 'INVALID_TOKEN_FACTORY',
-      message: 'Token factory address is not valid',
-      fn: (context) => {
-        const itx = cloneDeep(context.itx);
-        itx.data = decodeAnySafe(itx.data);
-        itx.address = '';
-
-        return toTokenFactoryAddress(itx) === context.itx.address;
-      },
-    },
-    // verify reserve address is config.token.address
-    {
-      error: 'INVALID_RESERVE_ADDRESS',
-      message: 'Reserve address is not valid',
-      fn: (context) => context.itx.reserveAddress === context.config.token.address,
-    },
-  ])
-);
-
-runner.use(verifyIcon());
-runner.use(verifyUrl({ urlKeys: ['itx.token.website', 'itx.token.metadata.value.communityUrl'] }));
-runner.use(verifyOwnership({ tokenKey: 'itx.token' }));
-
-// Ensure symbol is not internal
-runner.use((context, next) => {
-  const { reservedSymbols } = context.config;
-  const { symbol } = context.itx.token;
-
-  if (reservedSymbols.includes(symbol.toUpperCase())) {
-    return next(new Error('INVALID_SYMBOL', `Token symbol can not be ${symbol}`));
-  }
-
-  return next();
-});
-
-// Ensure token factory not exist
-runner.use(pipes.ExtractState({ from: 'itx.address', to: 'tokenFactoryState', table: 'tokenFactory', status: 'OK' }));
-runner.use(
-  pipes.VerifyInfo([
-    {
-      error: 'DUPLICATE_TOKEN_FACTORY',
-      message: 'Token factory address already exists on chain',
-      fn: (context) => isEmpty(context.tokenFactoryState),
-    },
-  ])
-);
-
-// Ensure token not exist
-runner.use(pipes.ExtractState({ from: 'itx.token.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 sender exist
-runner.use(
-  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
-);
-runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
-
-runner.use(pipes.VerifyBlocked({ stateKeys: ['senderState'] }));
-
-// verify staking: get address, extract state, verify amount
-runner.use((context, next) => {
-  const { tx, itx } = context;
-  // stake from sender to main token
-  const sender = tx.delegator || tx.from;
-  const receiver = context.config.token.address;
-  context.stakeAddress = toStakeAddress(sender, receiver, itx.token.symbol);
-  return next();
-});
-runner.use(
-  pipes.ExtractState({ from: 'stakeAddress', to: 'stakeState', status: 'INVALID_STAKE_STATE', table: 'stake' })
-);
-runner.use((context, next) => {
-  const { stakeState, config, itx } = context;
-
-  if (stakeState.revocable === false) {
-    return next(new Error('INVALID_STAKE_STATE', `Staking for token creating already locked: ${stakeState.address}`));
-  }
-
-  const actualStake = new BN(stakeState.tokens[config.token.address] || 0);
-  const requiredStake = fromTokenToUnit(
-    itx.token.type === 'CreditToken'
-      ? config.transaction.txStake.createCreditToken
-      : config.transaction.txStake.createToken,
-    config.token.decimal
-  );
-  if (actualStake.lt(requiredStake)) {
-    return next(
-      new Error(
-        'INVALID_STAKE_STATE',
-        `Insufficient stake amount: required ${fromUnitToToken(requiredStake, config.token.decimal)} ${config.token.symbol}`
-      )
-    );
-  }
-
-  return next();
-});
-
-// Ensure delegation
-runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK', table: 'account' }));
-runner.use(pipes.VerifyAccountMigration({ stateKey: 'delegatorState', addressKey: 'tx.delegator' }));
-runner.use(
-  pipes.VerifyDelegation({
-    type: 'signature',
-    signerKey: 'senderState',
-    delegatorKey: 'delegatorState',
-    getRequirements: getDelegationRequirements,
-  })
-);
-
-// Ensure uniqueness of token symbol
-runner.use(
-  async function EnsureTokenSymbol(context, next) {
-    const itxToken = context.itx.token;
-
-    const exist = await context.statedb.token.existBySymbol(itxToken.symbol, context);
-    if (exist) {
-      return next(new Error('DUPLICATE_SYMBOL', 'Token symbol already exists'));
-    }
-
-    return next();
-  },
-  { persistError: true }
-);
-
-// Ensure tx fee and gas
-runner.use(
-  EnsureTxGas((context) => {
-    const result = { create: 2, update: 2, payment: 0 };
-
-    if (context.isDelegationChanged) {
-      result.update += 1;
-    }
-
-    return result;
-  })
-);
-runner.use(EnsureTxCost({ attachSenderChanges: true }));
-
-// Save context snapshot before updating states
-runner.use(pipes.TakeStateSnapshot());
-
-// Update sender state, token factory state, and lock stake
-runner.use(
-  async (context, next) => {
-    const {
-      tx,
-      itx,
-      statedb,
-      senderState,
-      delegatorState,
-      delegationState,
-      senderChange,
-      stakeState,
-      stakeAddress,
-      updateVaults,
-      config,
-    } = context;
-    const data = decodeAnySafe(itx.data);
-    const owner = delegatorState ? delegatorState.address : senderState.address;
-
-    const itxToken = itx.token;
-
-    const { tokens: senderTokens = {} } = senderState;
-
-    const senderUpdates = senderChange
-      ? applyTokenChange({ tokens: senderTokens }, senderChange)
-      : { tokens: senderTokens };
-
-    const [newSenderState, newTokenState, newTokenFactoryState, newDelegationState, newStakeState] = await Promise.all([
-      statedb.account.update(
-        senderState.address,
-        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
-        context
-      ),
-
-      statedb.token.create(
-        itxToken.address,
-        token.create(
-          {
-            ...cloneDeep(itxToken),
-            totalSupply: '0',
-            initialSupply: '0',
-            issuer: owner,
-            tokenFactoryAddress: itx.address,
-          },
-          context
-        ),
-        context
-      ),
-
-      statedb.tokenFactory.create(
-        itx.address,
-        tokenFactory.create({ ...cloneDeep(itx), owner, tokenAddress: itxToken.address, data }, context),
-        context
-      ),
-
-      // Update delegation state
-      context.isDelegationChanged
-        ? statedb.delegation.update(delegationState.address, delegation.update(delegationState, {}, context), context)
-        : delegationState,
-
-      // Lock the stake after successful token creation
-      statedb.stake.update(
-        stakeAddress,
-        stake.update(
-          stakeState,
-          { revocable: false, revokeWaitingPeriod: config.transaction.txStake.createTokenLockPeriod },
-          context
-        ),
-        context
-      ),
-    ]);
-
-    await updateVaults();
-
-    context.senderState = newSenderState;
-    context.tokenState = newTokenState;
-    context.tokenFactoryState = newTokenFactoryState;
-    context.delegationState = newDelegationState;
-    context.stakeState = newStakeState;
-
-    debug('create token factory', newTokenFactoryState);
-
-    next();
-  },
-  { persistError: true }
-);
-
-runner.use(pipes.VerifyStateDiff());
-
-module.exports = runner;