@ocap/tx-protocols 1.21.3 → 1.22.0

package/lib/index.js

@@ -31,6 +31,10 @@ const resumeRollup = require('./protocols/rollup/resume');
 const createRollupBlock = require('./protocols/rollup/create-block');
 const claimBlockReward = require('./protocols/rollup/claim-reward');
 const migrateRollup = require('./protocols/rollup/migrate');
+const createTokenFactory = require('./protocols/token-factory/create');
+const updateTokenFactory = require('./protocols/token-factory/update');
+const mintToken = require('./protocols/token-factory/mint');
+const burnToken = require('./protocols/token-factory/burn');
 
 const executor = require('./execute');
 
@@ -62,6 +66,10 @@ const createExecutor = ({ filter, runAsLambda }) => {
     createToken,
     depositTokenV2,
     withdrawTokenV2,
+    createTokenFactory,
+    updateTokenFactory,
+    mintToken,
+    burnToken,
 
     // governance
     stake,

package/lib/protocols/token/create.js

@@ -31,6 +31,7 @@ const schema = Joi.object({
   totalSupply: Joi.BN().greater(0).max(MAX_TOTAL_SUPPLY).required(),
   initialSupply: Joi.BN().greater(0).max(Joi.ref('totalSupply')).required(),
   foreignToken: schemas.foreignToken.optional().allow(null).default(null),
+  tokenFactoryAddress: Joi.forbidden(),
   data: Joi.any().optional().allow(null),
 }).options({ stripUnknown: true, noDefaults: false });
 

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

@@ -0,0 +1,255 @@
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const { Joi, schemas } = require('@arcblock/validator');
+const { BN, isSameDid, fromUnitToToken } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, tokenFactory, token } = require('@ocap/state');
+
+const EnsureTxGas = require('../../pipes/ensure-gas');
+const EnsureTxCost = require('../../pipes/ensure-cost');
+const CalcReserveAmount = require('./pipes/calc-reserve');
+const { applyTokenChange } = require('../../util');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+const schema = Joi.object({
+  tokenFactory: Joi.DID().prefix().role('ROLE_TOKEN_FACTORY').required(),
+  receiver: schemas.tokenHolder.required(),
+  amount: Joi.BN().greater(0).required(),
+  minReserve: Joi.alternatives().try(Joi.BN().greater(0), Joi.equal('')).optional(),
+  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 sender
+runner.use(
+  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
+);
+runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
+
+// ensure receiver
+runner.use(pipes.ExtractState({ from: 'itx.receiver', to: 'receiverState', status: 'OK', table: 'account' }));
+
+// ensure owner
+runner.use(
+  pipes.ExtractState({
+    from: 'tokenFactoryState.owner',
+    to: 'ownerState',
+    status: 'INVALID_OWNER_STATE',
+    table: 'account',
+  })
+);
+
+// verify blocked
+runner.use(pipes.VerifyBlocked({ stateKeys: ['senderState', 'receiverState'] }));
+
+// ensure token state
+runner.use(
+  pipes.ExtractState({
+    from: 'tokenFactoryState.tokenAddress',
+    to: 'tokenState',
+    status: 'INVALID_TOKEN',
+    table: 'token',
+  })
+);
+
+// calculate reserve amount
+runner.use(
+  CalcReserveAmount({
+    tokenFactoryKey: 'tokenFactoryState',
+    tokenStateKey: 'tokenState',
+    reserveKey: 'reserveAmount',
+    feeKey: 'reserveFee',
+    direction: 'burn',
+  })
+);
+
+// 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)))) {
+    return next(
+      new Error(
+        'SLIPPAGE_EXCEEDED',
+        `Burn token failed due to price movement. Expected minimum: ${fromUnitToToken(minReserve)}, actual: ${fromUnitToToken(reserveAmount)}. Try reducing your minReserve.`
+      )
+    );
+  }
+
+  next();
+});
+
+// verify sender tokens
+runner.use((context, next) => {
+  const { tokenFactoryState, itx, reserveFee } = context;
+
+  context.tokenConditions = {
+    owner: context.senderState.address,
+    tokens: [{ address: tokenFactoryState.tokenAddress, value: itx.amount }],
+  };
+
+  if (reserveFee) {
+    context.tokenConditions.tokens.push({ address: tokenFactoryState.reserveAddress, value: reserveFee });
+  }
+
+  next();
+});
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'senderState', conditionKey: 'tokenConditions' }));
+
+// Ensure tx fee and gas
+runner.use(
+  EnsureTxGas((context) => {
+    const result = { create: 0, update: 3, payment: 0 };
+
+    if (context.receiverState) {
+      result.update += 1;
+    }
+    if (context.reserveFee) {
+      result.update += 1;
+    }
+
+    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,
+    } = context;
+    const { amount, receiver } = itx;
+    const { reserveAddress, tokenAddress } = tokenFactoryState;
+
+    const { tokens: senderTokens = {} } = senderState;
+    const { tokens: receiverTokens = {} } = receiverState || {};
+    const { tokens: ownerTokens = {} } = ownerState;
+
+    senderTokens[tokenAddress] = new BN(senderTokens[tokenAddress]).sub(new BN(amount)).toString();
+    receiverTokens[reserveAddress] = new BN(receiverTokens[reserveAddress] || '0')
+      .add(new BN(reserveAmount))
+      .toString();
+
+    if (isSameDid(senderState.address, receiver)) {
+      senderTokens[reserveAddress] = receiverTokens[reserveAddress];
+    }
+    if (reserveFee) {
+      const fee = new BN(reserveFee);
+      senderTokens[reserveAddress] = new BN(senderTokens[reserveAddress]).sub(fee).toString();
+
+      if (isSameDid(receiver, ownerState.address)) {
+        receiverTokens[reserveAddress] = new BN(receiverTokens[reserveAddress] || '0').add(fee).toString();
+      } else {
+        ownerTokens[reserveAddress] = new BN(ownerTokens[reserveAddress] || '0').add(fee).toString();
+      }
+    }
+
+    const senderUpdates = senderChange
+      ? applyTokenChange({ tokens: senderTokens }, senderChange)
+      : { tokens: senderTokens };
+
+    const [newSenderState, newReceiverState, newOwnerState, newTokenFactoryState, newTokenState] = await Promise.all([
+      // Update sender state
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      // Update receiver state
+      !isSameDid(senderState.address, receiver)
+        ? statedb.account.updateOrCreate(
+            receiverState,
+            account.updateOrCreate(receiverState, { address: receiver, tokens: receiverTokens }, context),
+            context
+          )
+        : null,
+
+      // Update owner state
+      !isSameDid(senderState.address, ownerState.address) && !isSameDid(receiver, ownerState.address)
+        ? statedb.account.update(
+            ownerState.address,
+            account.update(ownerState, { tokens: ownerTokens }, context),
+            context
+          )
+        : null,
+
+      // Update token factory state
+      statedb.tokenFactory.update(
+        tokenFactoryState.address,
+        tokenFactory.update(
+          tokenFactoryState,
+          {
+            currentSupply: new BN(tokenFactoryState.currentSupply).sub(new BN(amount)).toString(),
+            reserveBalance: new BN(tokenFactoryState.reserveBalance).sub(new BN(reserveAmount)).toString(),
+          },
+          context
+        ),
+        context
+      ),
+
+      statedb.token.update(
+        tokenAddress,
+        token.update(
+          tokenState,
+          {
+            totalSupply: new BN(tokenState.totalSupply).sub(new BN(amount)).toString(),
+          },
+          context
+        ),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
+    context.ownerState = newOwnerState;
+    context.tokenFactoryState = newTokenFactoryState;
+    context.tokenState = newTokenState;
+
+    await updateVaults();
+
+    next();
+  },
+  { persistError: true }
+);
+
+runner.use(pipes.VerifyStateDiff());
+
+module.exports = runner;

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

@@ -0,0 +1,205 @@
+const isEmpty = require('empty-value');
+const cloneDeep = require('lodash/cloneDeep');
+const { Joi } = require('@arcblock/validator');
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, token, tokenFactory } = require('@ocap/state');
+const { toTokenFactoryAddress, toTokenAddress } = require('@arcblock/did-util');
+const { applyTokenChange } = require('../../util');
+
+// eslint-disable-next-line global-require, import/order
+const debug = require('debug')(`${require('../../../package.json').name}:create-token-factory`);
+
+const { decodeAnySafe } = require('../../util');
+
+const EnsureTxGas = require('../../pipes/ensure-gas');
+const EnsureTxCost = require('../../pipes/ensure-cost');
+
+const runner = new Runner();
+
+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: 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(1).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(6).max(18).required(),
+    icon: Joi.string().optional().allow(null).valid(''),
+  }).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;
+
+  return next();
+});
+
+// Ensure factory and token address is valid
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_TOKEN',
+      message: 'Token address is not valid',
+      fn: (context) => {
+        return toTokenAddress({ ...context.itx.token, address: '' }) === context.itx.token.address;
+      },
+    },
+    {
+      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;
+      },
+    },
+  ])
+);
+
+// Ensure reserve address is config.token.address
+runner.use(
+  pipes.VerifyInfo([
+    {
+      error: 'INVALID_RESERVE_ADDRESS',
+      message: 'Reserve address is not valid',
+      fn: (context) => context.itx.reserveAddress === context.config.token.address,
+    },
+  ])
+);
+
+// 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' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
+
+runner.use(pipes.VerifyBlocked({ stateKeys: ['senderState'] }));
+
+// Ensure uniqueness of token symbol
+runner.use(
+  async function EnsureTokenSymbol(context, next) {
+    const { symbol } = context.config.token;
+    const itxToken = context.itx.token;
+    if (symbol.toLowerCase() === itxToken.symbol.toLowerCase()) {
+      return next(new Error('DUPLICATE_SYMBOL', `Token symbol can not be ${symbol}`));
+    }
+
+    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(() => {
+    return { create: 1, update: 2, payment: 0 };
+  })
+);
+runner.use(EnsureTxCost({ attachSenderChanges: true }));
+
+// Save context snapshot before updating states
+runner.use(pipes.TakeStateSnapshot());
+
+// Update sender state, token factory state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, senderState, senderChange, updateVaults } = context;
+    const data = decodeAnySafe(itx.data);
+    const owner = senderState.address;
+
+    const itxToken = itx.token;
+
+    const { tokens: senderTokens = {} } = senderState;
+
+    const senderUpdates = senderChange
+      ? applyTokenChange({ tokens: senderTokens }, senderChange)
+      : { tokens: senderTokens };
+
+    const [newSenderState, newTokenState, newTokenFactoryState] = 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
+      ),
+    ]);
+
+    await updateVaults();
+
+    context.senderState = newSenderState;
+    context.tokenState = newTokenState;
+    context.tokenFactoryState = newTokenFactoryState;
+
+    debug('create token factory', newTokenFactoryState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+runner.use(pipes.VerifyStateDiff());
+
+module.exports = runner;

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

@@ -0,0 +1,248 @@
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const { Joi, schemas } = require('@arcblock/validator');
+const { BN, isSameDid, fromUnitToToken } = require('@ocap/util');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, tokenFactory, token } = require('@ocap/state');
+
+const EnsureTxGas = require('../../pipes/ensure-gas');
+const EnsureTxCost = require('../../pipes/ensure-cost');
+const CalcReserve = require('./pipes/calc-reserve');
+const { applyTokenChange } = require('../../util');
+
+const runner = new Runner();
+
+runner.use(pipes.VerifyMultiSig(0));
+
+const schema = Joi.object({
+  tokenFactory: Joi.DID().prefix().role('ROLE_TOKEN_FACTORY').required(),
+  receiver: schemas.tokenHolder.required(),
+  amount: Joi.BN().greater(0).required(),
+  maxReserve: Joi.alternatives().try(Joi.BN().greater(0), Joi.equal('')).optional(),
+  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 sender
+runner.use(
+  pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })
+);
+runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
+
+// ensure receiver
+runner.use(pipes.ExtractState({ from: 'itx.receiver', to: 'receiverState', status: 'OK', table: 'account' }));
+
+// ensure owner
+runner.use(
+  pipes.ExtractState({
+    from: 'tokenFactoryState.owner',
+    to: 'ownerState',
+    status: 'INVALID_OWNER_STATE',
+    table: 'account',
+  })
+);
+
+// verify blocked
+runner.use(pipes.VerifyBlocked({ stateKeys: ['senderState', 'receiverState'] }));
+
+// ensure token state
+runner.use(
+  pipes.ExtractState({
+    from: 'tokenFactoryState.tokenAddress',
+    to: 'tokenState',
+    status: 'INVALID_TOKEN',
+    table: 'token',
+  })
+);
+
+// calculate reserve amount
+runner.use(
+  CalcReserve({ tokenFactoryKey: 'tokenFactoryState', tokenStateKey: 'tokenState', reserveKey: 'reserveAmount' })
+);
+
+// verify slippage
+runner.use((context, next) => {
+  const { reserveAmount, reserveFee } = context;
+  const { maxReserve } = context.itx;
+
+  const actual = new BN(reserveAmount).add(new BN(reserveFee || '0'));
+  if (maxReserve && actual.gt(new BN(maxReserve))) {
+    return next(
+      new Error(
+        'SLIPPAGE_EXCEEDED',
+        `Mint token failed due to price movement. Expected maximum: ${fromUnitToToken(maxReserve)}, actual: ${fromUnitToToken(actual)}. Try increasing your maxReserve.`
+      )
+    );
+  }
+
+  next();
+});
+
+// verify sender balance
+runner.use((context, next) => {
+  const { tokenFactoryState } = context;
+  context.tokenConditions = {
+    owner: context.senderState.address,
+    tokens: [
+      {
+        address: tokenFactoryState.reserveAddress,
+        value: new BN(context.reserveAmount).add(new BN(context.reserveFee || '0')).toString(),
+      },
+    ],
+  };
+  next();
+});
+runner.use(pipes.VerifyTokenBalance({ ownerKey: 'senderState', conditionKey: 'tokenConditions' }));
+
+// Ensure tx fee and gas
+runner.use(
+  EnsureTxGas((context) => {
+    const result = { create: 0, update: 3, payment: 0 };
+
+    if (context.receiverState) {
+      result.update += 1;
+    }
+    if (context.reserveFee) {
+      result.update += 1;
+    }
+
+    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,
+    } = context;
+    const { amount, receiver } = itx;
+    const { reserveAddress, tokenAddress } = tokenFactoryState;
+
+    const { tokens: senderTokens = {} } = senderState;
+    const { tokens: receiverTokens = {} } = receiverState || {};
+    const { tokens: ownerTokens = {} } = ownerState;
+
+    senderTokens[reserveAddress] = new BN(senderTokens[reserveAddress]).sub(new BN(reserveAmount)).toString();
+    receiverTokens[tokenAddress] = new BN(receiverTokens[tokenAddress] || '0').add(new BN(amount)).toString();
+
+    // merge receiver tokens to sender tokens
+    if (isSameDid(senderState.address, receiver)) {
+      senderTokens[tokenAddress] = receiverTokens[tokenAddress];
+    }
+    if (reserveFee) {
+      const fee = new BN(reserveFee);
+      senderTokens[reserveAddress] = new BN(senderTokens[reserveAddress]).sub(fee).toString();
+
+      if (isSameDid(receiver, ownerState.address)) {
+        receiverTokens[reserveAddress] = new BN(receiverTokens[reserveAddress] || '0').add(fee).toString();
+      } else {
+        ownerTokens[reserveAddress] = new BN(ownerTokens[reserveAddress] || '0').add(fee).toString();
+      }
+    }
+
+    const senderUpdates = senderChange
+      ? applyTokenChange({ tokens: senderTokens }, senderChange)
+      : { tokens: senderTokens };
+
+    const [newSenderState, newReceiverState, newOwnerState, newTokenFactoryState, newTokenState] = await Promise.all([
+      // Update sender state
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      // Update receiver state
+      !isSameDid(senderState.address, receiver)
+        ? statedb.account.updateOrCreate(
+            receiverState,
+            account.updateOrCreate(receiverState, { address: receiver, tokens: receiverTokens }, context),
+            context
+          )
+        : null,
+
+      // Update owner state
+      !isSameDid(senderState.address, ownerState.address) && !isSameDid(receiver, ownerState.address)
+        ? statedb.account.update(
+            ownerState.address,
+            account.update(ownerState, { tokens: ownerTokens }, context),
+            context
+          )
+        : null,
+
+      // Update token factory state
+      statedb.tokenFactory.update(
+        tokenFactoryState.address,
+        tokenFactory.update(
+          tokenFactoryState,
+          {
+            currentSupply: new BN(tokenFactoryState.currentSupply).add(new BN(amount)).toString(),
+            reserveBalance: new BN(tokenFactoryState.reserveBalance).add(new BN(reserveAmount)).toString(),
+          },
+          context
+        ),
+        context
+      ),
+
+      statedb.token.update(
+        tokenAddress,
+        token.update(
+          tokenState,
+          {
+            totalSupply: new BN(tokenState.totalSupply).add(new BN(amount)).toString(),
+          },
+          context
+        ),
+        context
+      ),
+    ]);
+
+    context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
+    context.ownerState = newOwnerState;
+    context.tokenFactoryState = newTokenFactoryState;
+    context.tokenState = newTokenState;
+
+    await updateVaults();
+
+    next();
+  },
+  { persistError: true }
+);
+
+runner.use(pipes.VerifyStateDiff());
+
+module.exports = runner;

package/lib/protocols/token-factory/pipes/calc-reserve.js

@@ -0,0 +1,40 @@
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const get = require('lodash/get');
+const set = require('lodash/set');
+const { calcCost, calcFee } = require('@ocap/util/lib/curve');
+
+module.exports =
+  ({
+    tokenFactoryKey = 'tokenFactoryState',
+    tokenStateKey = 'tokenState',
+    senderStateKey = 'senderState',
+    reserveKey = 'reserveAmount',
+    feeKey = 'reserveFee',
+    direction = 'mint',
+  } = {}) =>
+  (context, next) => {
+    const tokenFactoryState = get(context, tokenFactoryKey);
+    const tokenState = get(context, tokenStateKey);
+    const senderState = get(context, senderStateKey);
+
+    if (!tokenFactoryState) {
+      return next(new Error('INVALID_TOKEN_FACTORY', 'Token factory state not found'));
+    }
+    if (!tokenState) {
+      return next(new Error('INVALID_TOKEN', 'Token state not found'));
+    }
+
+    const { curve, currentSupply, feeRate } = tokenFactoryState;
+    const { decimal } = tokenState;
+    const { amount } = context.itx;
+
+    const reserveAmount = calcCost({ amount, decimal, currentSupply, direction, curve });
+    set(context, reserveKey, reserveAmount.toString());
+
+    if (senderState.address !== tokenFactoryState.owner) {
+      const reserveFee = calcFee({ reserveAmount, feeRate });
+      set(context, feeKey, reserveFee.toString());
+    }
+
+    next();
+  };

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

@@ -0,0 +1,108 @@
+const { Joi } = require('@arcblock/validator');
+const { CustomError: Error } = require('@ocap/util/lib/error');
+const { Runner, pipes } = require('@ocap/tx-pipeline');
+const { account, tokenFactory } = require('@ocap/state');
+const { applyTokenChange } = require('../../util');
+
+// eslint-disable-next-line global-require, import/order
+const debug = require('debug')(`${require('../../../package.json').name}:update-token-factory`);
+
+const EnsureTxGas = require('../../pipes/ensure-gas');
+const EnsureTxCost = require('../../pipes/ensure-cost');
+
+const runner = new Runner();
+
+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(),
+  data: Joi.any().optional().allow(null),
+}).options({ stripUnknown: true, noDefaults: false });
+
+// 1. verify itx
+runner.use((context, next) => {
+  const { error } = schema.validate(context.itx);
+  if (error) {
+    return next(new Error('INVALID_TX', `Invalid itx: ${error.message}`));
+  }
+
+  return next();
+});
+
+// ensure token factory exists
+runner.use(
+  pipes.ExtractState({
+    from: 'itx.address',
+    to: 'tokenFactoryState',
+    table: 'tokenFactory',
+    status: 'INVALID_TOKEN_FACTORY',
+  })
+);
+
+// verify owner
+runner.use((context, next) => {
+  const { tx, tokenFactoryState } = context;
+  if (tx.from !== tokenFactoryState.owner) {
+    return next(new Error('FORBIDDEN', 'Token factory can only be updated by owner'));
+  }
+
+  return next();
+});
+
+// Ensure sender
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.VerifyAccountMigration({ stateKey: 'senderState', addressKey: 'tx.from' }));
+runner.use(pipes.VerifyBlocked({ stateKeys: ['senderState'] }));
+
+// Ensure tx fee and gas
+runner.use(
+  EnsureTxGas(() => {
+    return { create: 0, update: 2, payment: 0 };
+  })
+);
+runner.use(EnsureTxCost({ attachSenderChanges: true }));
+
+// Save context snapshot before updating states
+runner.use(pipes.TakeStateSnapshot());
+
+// Update sender state, token factory state
+runner.use(
+  async (context, next) => {
+    const { tx, itx, statedb, senderState, tokenFactoryState, senderChange, updateVaults } = context;
+
+    const { tokens: senderTokens = {} } = senderState;
+
+    const senderUpdates = senderChange
+      ? applyTokenChange({ tokens: senderTokens }, senderChange)
+      : { tokens: senderTokens };
+
+    const [newSenderState, newTokenFactoryState] = await Promise.all([
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
+        context
+      ),
+
+      statedb.tokenFactory.update(
+        tokenFactoryState.address,
+        tokenFactory.update(tokenFactoryState, { feeRate: itx.feeRate }, context),
+        context
+      ),
+    ]);
+
+    await updateVaults();
+
+    context.senderState = newSenderState;
+    context.tokenFactoryState = newTokenFactoryState;
+
+    debug('update token factory', newTokenFactoryState);
+
+    next();
+  },
+  { persistError: true }
+);
+
+runner.use(pipes.VerifyStateDiff());
+
+module.exports = runner;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.21.3",
+  "version": "1.22.0",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -18,19 +18,19 @@
     "empty-value": "^1.0.1",
     "lodash": "^4.17.21",
     "url-join": "^4.0.1",
-    "@arcblock/did": "1.21.3",
-    "@arcblock/did-util": "1.21.3",
-    "@arcblock/jwt": "1.21.3",
-    "@arcblock/validator": "1.21.3",
-    "@ocap/asset": "1.21.3",
-    "@ocap/client": "1.21.3",
-    "@ocap/mcrypto": "1.21.3",
-    "@ocap/merkle-tree": "1.21.3",
-    "@ocap/message": "1.21.3",
-    "@ocap/state": "1.21.3",
-    "@ocap/tx-pipeline": "1.21.3",
-    "@ocap/util": "1.21.3",
-    "@ocap/wallet": "1.21.3"
+    "@arcblock/did": "1.22.0",
+    "@arcblock/did-util": "1.22.0",
+    "@arcblock/jwt": "1.22.0",
+    "@arcblock/validator": "1.22.0",
+    "@ocap/asset": "1.22.0",
+    "@ocap/client": "1.22.0",
+    "@ocap/mcrypto": "1.22.0",
+    "@ocap/state": "1.22.0",
+    "@ocap/merkle-tree": "1.22.0",
+    "@ocap/message": "1.22.0",
+    "@ocap/tx-pipeline": "1.22.0",
+    "@ocap/util": "1.22.0",
+    "@ocap/wallet": "1.22.0"
   },
   "resolutions": {
     "bn.js": "5.2.1",
@@ -39,8 +39,8 @@
   "devDependencies": {
     "jest": "^29.7.0",
     "start-server-and-test": "^1.14.0",
-    "@ocap/e2e-test": "1.21.3",
-    "@ocap/statedb-memory": "1.21.3"
+    "@ocap/e2e-test": "1.22.0",
+    "@ocap/statedb-memory": "1.22.0"
   },
   "scripts": {
     "lint": "eslint tests lib",