@ocap/tx-protocols 1.13.61 → 1.13.65

package/lib/protocols/account/delegate.js

@@ -61,9 +61,9 @@ runner.use(
 );
 
 // Ensure sender/receiver exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
 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.to', to: 'receiverState', status: 'OK', table: 'account' }));
 
 // Extract delegation
 runner.use(pipes.ExtractState({ from: 'itx.address', to: 'delegationState', table: 'delegation', status: 'OK' }));
@@ -71,7 +71,7 @@ runner.use(pipes.ExtractState({ from: 'itx.address', to: 'delegationState', tabl
 // Create delegation state
 runner.use(
   async (context, next) => {
-    const { tx, itx, ops, statedb, senderState, delegationState } = context;
+    const { tx, itx, ops, statedb, senderState, receiverState, delegationState } = context;
 
     const opsObj = ops.reduce(
       (acc, x) => {
@@ -86,8 +86,23 @@ runner.use(
       delegationState ? delegationState.ops : {}
     );
 
-    const [newSenderState, newDelegationState] = await Promise.all([
-      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+    const sender = senderState ? senderState.address : tx.from;
+    const receiver = receiverState ? receiverState.address : itx.to;
+
+    const [newSenderState, newReceiverState, newDelegationState] = await Promise.all([
+      // update sender
+      statedb.account.updateOrCreate(
+        senderState,
+        account.updateOrCreate(senderState, { address: sender, nonce: tx.nonce, pk: tx.pk }, context),
+        context
+      ),
+
+      // update receiver
+      receiverState
+        ? Promise.resolve(receiverState)
+        : statedb.account.create(receiver, account.create({ address: receiver }, context), context),
+
+      // update delegation
       delegationState
         ? statedb.delegation.update(itx.address, delegation.update(delegationState, { ...itx, ops: opsObj }, context), context) // prettier-ignore
         : statedb.delegation.create(itx.address, delegation.create({ ...itx, ops: opsObj }, context), context),
@@ -97,6 +112,7 @@ runner.use(
 
     // Update context
     context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
     context.delegationState = newDelegationState;
 
     return next();

package/lib/protocols/account/migrate.js

@@ -35,7 +35,7 @@ runner.use(
 );
 
 // Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
 
 // Create account state, and update old accounts
@@ -48,7 +48,7 @@ runner.use(
 
     // Ensure receiver does not exist
     if (receiver) {
-      return next(new Error('INVALID_SENDER_STATE', 'Can not migrate to an existing account'));
+      return next(new Error('INVALID_RECEIVER_STATE', 'Can not migrate to an existing account'));
     }
 
     // Create new account

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

@@ -53,10 +53,9 @@ 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' }));
 
 // Update delegation state
 runner.use(

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

@@ -24,7 +24,7 @@ const runner = new Runner();
 runner.use(pipes.VerifyMultiSig(0));
 runner.use(verifyAcquireParams('acquire-v2'));
 
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+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' }));
@@ -43,7 +43,7 @@ runner.use(
 
 // 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' }));
+runner.use(pipes.ExtractState({ from: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
 
 // Verify itx
 runner.use(verifyMintLimit);
@@ -86,6 +86,7 @@ runner.use(
     // Sender updates
     const senderUpdates = {
       nonce: tx.nonce,
+      pk: tx.pk,
       ...applyTokenUpdates(factoryTokens, senderState, 'sub'),
     };
 

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

@@ -82,9 +82,9 @@ runner.use(
 );
 
 // 5. verify sender & signer & owner
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'itx.owner', to: 'ownerState', status: 'INVALID_RECEIVER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', 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
@@ -153,6 +153,7 @@ runner.use(
     });
 
     const isAlsoSigner = !!signerUpdates[senderState.address];
+    const owner = ownerState ? ownerState.address : itx.owner;
 
     // Factory updates
     const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
@@ -163,44 +164,53 @@ runner.use(
       context.tokenUpdates = applyTokenUpdates(factoryTokens, { tokens: {} }, 'add');
     }
 
-    const [newSenderState, assetState, newSignerStates, newFactoryState, newAssetStates] = await Promise.all([
-      // Update sender state
-      statedb.account.update(
-        senderState.address,
-        account.update(
-          senderState,
-          Object.assign({ nonce: tx.nonce }, signerUpdates[senderState.address] || {}),
+    const [newSenderState, newReceiverState, assetState, newSignerStates, newFactoryState, newAssetStates] =
+      await Promise.all([
+        // Update sender state
+        statedb.account.update(
+          senderState.address,
+          account.update(
+            senderState,
+            Object.assign({ nonce: tx.nonce, pk: tx.pk }, signerUpdates[senderState.address] || {}),
+            context
+          ),
           context
         ),
-        context
-      ),
-
-      // Create asset
-      statedb.asset.create(
-        itx.address,
-        asset.create({ ...mintedAsset, owner: ownerState.address, address: mintedAddress }, context),
-        context
-      ),
-
-      // Update signer state
-      Promise.all(
-        signerStates
-          .filter((x) => x.address !== senderState.address)
-          .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)
-        )
-      ),
-    ]);
+
+        // 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 !== senderState.address)
+            .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;

package/lib/protocols/asset/create.js

@@ -64,7 +64,7 @@ runner.use(
 );
 
 // Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
 
 // Check if parent is a factory
@@ -83,7 +83,7 @@ runner.use(
 );
 
 // Ensure parent exist
-runner.use(pipes.ExtractState({ from: 'itx.parent', to: 'parentAsset', status: 'INVALID_ASSET' }));
+runner.use(pipes.ExtractState({ from: 'itx.parent', to: 'parentAsset', status: 'INVALID_ASSET', table: 'asset' }));
 
 // Update asset state
 runner.use(
@@ -92,7 +92,11 @@ runner.use(
 
     const [newSenderState, assetState] = await Promise.all([
       // Update owner state
-      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk }, context),
+        context
+      ),
       // Create asset state
       statedb.asset.create(
         itx.address,

package/lib/protocols/asset/mint.js

@@ -17,17 +17,17 @@ runner.use(pipes.VerifyMultiSig(0));
 runner.use(verifyAcquireParams('mint'));
 
 // Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+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' }));
+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: 'INVALID_OWNER' }));
+runner.use(pipes.ExtractState({ from: 'itx.owner', to: 'ownerState', status: 'OK', table: 'account' }));
 runner.use(
   pipes.VerifyInfo([
     {
@@ -72,20 +72,30 @@ runner.use(
       assetStates = [],
     } = context;
 
-    // account updates
-    const senderUpdates = { nonce: tx.nonce };
+    const owner = ownerState ? ownerState.address : itx.owner;
 
-    // Factory updates
+    const senderUpdates = { nonce: tx.nonce, pk: tx.pk };
     const factoryUpdates = { numMinted: factoryState.numMinted + 1 };
 
-    const [newSenderState, assetState, newFactoryState, newAssetStates] = await Promise.all([
+    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: ownerState.address, address: mintedAddress }, context),
+        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) =>
@@ -95,6 +105,7 @@ runner.use(
     ]);
 
     context.senderState = newSenderState;
+    context.receiverState = newReceiverState;
     context.assetState = assetState;
     context.factoryState = newFactoryState;
     context.assetStates = newAssetStates;

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

@@ -10,11 +10,12 @@ module.exports = (mode) => (context, next) => {
   if (mode === 'acquire-v2') {
     owner = delegatorState || senderState;
     issuer = itx.issuer;
+    context.assetOwner = owner;
   } else if (mode === 'acquire-v3') {
-    owner = ownerState;
+    owner = ownerState || { address: itx.owner };
     issuer = itx.issuer;
   } else if (mode === 'mint') {
-    owner = ownerState;
+    owner = ownerState || { address: itx.owner };
     issuer = {
       id: factoryOwnerState.address,
       pk: factoryOwnerState.pk,
@@ -33,7 +34,6 @@ module.exports = (mode) => (context, next) => {
     return next(new Error('INVALID_ASSET', 'Invalid itx.address: does not match with minted asset address'));
   }
 
-  context.assetOwner = owner;
   context.mintedAsset = minted.asset;
   context.mintedAddress = minted.address;
 

package/lib/protocols/asset/update.js

@@ -52,7 +52,11 @@ runner.use(
 
     const [newSenderState, newAssetState] = await Promise.all([
       // update owner state
-      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk }, context),
+        context
+      ),
 
       // update asset state
       statedb.asset.update(

package/lib/protocols/factory/create.js

@@ -79,23 +79,15 @@ runner.use(
 );
 
 // Ensure sender exist
-runner.use(
-  pipes.ExtractState({ from: 'tx.from', to: 'senderState', table: 'account', status: 'INVALID_SENDER_STATE' })
-);
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', table: 'account', status: 'INVALID_SENDER_STATE' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
 
 // Ensure tokens exist if we are creating an factory that consume tokens
-runner.use(
-  pipes.ExtractState({ from: 'factoryTokens', to: 'tokenStates', table: 'token', status: 'INVALID_FACTORY_INPUT' })
-);
+runner.use(pipes.ExtractState({ from: 'factoryTokens', to: 'tokenStates', table: 'token', status: 'INVALID_FACTORY_INPUT' })); // prettier-ignore
 
 // ensure input.assets all exist on chain
-runner.use(
-  pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputAssetStates', table: 'asset', status: 'OK' })
-);
-runner.use(
-  pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputFactoryStates', table: 'factory', status: 'OK' })
-);
+runner.use(pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputAssetStates', table: 'asset', status: 'OK' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'factoryProps.input.assets', to: 'inputFactoryStates', table: 'factory', status: 'OK' })); // prettier-ignore
 runner.use((context, next) => {
   const { inputAssetStates = [], inputFactoryStates = [], factoryProps } = context;
   if (inputAssetStates.some((x) => !!x.consumedTime)) {
@@ -118,7 +110,12 @@ runner.use(
 
     const [newSenderState, factoryState] = await Promise.all([
       // Update owner state
-      statedb.account.update(senderState.address, account.update(senderState, { nonce: tx.nonce }, context), context),
+      statedb.account.update(
+        senderState.address,
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk }, context),
+        context
+      ),
+
       // Create factory state
       statedb.factory.create(
         itx.address,

package/lib/protocols/governance/stake.js

@@ -122,7 +122,7 @@ runner.use(
         senderState.address,
         account.update(
           senderState,
-          Object.assign({ nonce: tx.nonce }, signerUpdates[senderState.address] || {}),
+          Object.assign({ nonce: tx.nonce, pk: tx.pk }, signerUpdates[senderState.address] || {}),
           context
         ),
         context

package/lib/protocols/rollup/create-block.js

@@ -235,7 +235,7 @@ runner.use(pipes.ExtractState({ from: 'stakeAddress', to: 'stakeStates', status:
 runner.use((context, next) => {
   const { itx, txStates, rollupState } = context;
   try {
-    const result = ensureBlockReward(rollupState.address, rollupState.tokenAddress, itx.minReward, txStates);
+    const result = ensureBlockReward(rollupState, itx.minReward, txStates);
     context.senders = Object.keys(result.accountUpdates);
     Object.assign(context, result);
     return next();

package/lib/protocols/token/create.js

@@ -56,7 +56,7 @@ runner.use(
 );
 
 // Ensure sender exist
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState' }));
 
 // Ensure token not exist
@@ -98,7 +98,7 @@ runner.use(
     const [newSenderState, tokenState] = await Promise.all([
       statedb.account.update(
         senderState.address,
-        account.update(senderState, { tokens: senderTokens, nonce: tx.nonce }, context),
+        account.update(senderState, { tokens: senderTokens, nonce: tx.nonce, pk: tx.pk }, context),
         context
       ),
       statedb.token.create(itx.address, token.create({ ...itx, data, issuer: senderState.address }, context), context),

package/lib/protocols/token/deposit-v2.js

@@ -11,7 +11,7 @@ const debug = require('debug')(`${require('../../../package.json').name}:deposit
 
 const VerifySigners = require('../rollup/pipes/verify-signers');
 const VerifyPaused = require('../rollup/pipes/verify-paused');
-const { applyTokenUpdates, getTxFee, getRewardLocker } = require('../../util');
+const { applyTokenUpdates, getTxFee, getBNSum, getRewardLocker } = require('../../util');
 
 const schema = Joi.object({
   token: Joi.tokenInputSchema.required(),
@@ -138,15 +138,15 @@ runner.use((context, next) => {
   const { itx, rollupState, tokenState } = context;
   const { depositFeeRate, maxDepositFee, minDepositFee } = rollupState;
 
-  context.txFee = getTxFee({
+  const { reward } = getTxFee({
     amount: itx.token.value,
     feeRate: depositFeeRate,
     maxFee: maxDepositFee,
     minFee: minDepositFee,
   });
 
-  if (new BN(itx.actualFee).lt(new BN(context.txFee.reward))) {
-    const expected = fromUnitToToken(context.txFee.reward, tokenState.decimal);
+  if (new BN(itx.actualFee).lt(new BN(reward))) {
+    const expected = fromUnitToToken(reward, tokenState.decimal);
     const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
     return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
   }
@@ -155,28 +155,33 @@ runner.use((context, next) => {
 });
 
 // 7. verify sender and signer states
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'OK', table: 'account' }));
 runner.use(pipes.ExtractState({ from: 'signers', to: 'signerStates', status: 'INVALID_SIGNER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
 
 // 8. update state: the token minting is done when deposit finalized in rollup-block
 runner.use(
   async (context, next) => {
-    const { tx, itx, txFee, statedb, senderState, stakeState, stakeAddress, lockerState, lockerAddress } = context;
+    const { tx, itx, statedb, senderState, stakeState, stakeAddress, lockerState, lockerAddress } = context;
 
-    const stakeUpdates = applyTokenUpdates([{ address: itx.token.address, value: txFee.total }], stakeState, 'sub');
-    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: txFee.user }], senderState, 'add');
+    const user = itx.token.value;
+    const fee = itx.actualFee;
+    const total = getBNSum(user, fee);
+
+    const stakeUpdates = applyTokenUpdates([{ address: itx.token.address, value: total }], stakeState, 'sub');
+    const senderUpdates = applyTokenUpdates([{ address: itx.token.address, value: user }], senderState || {}, 'add');
     const lockerUpdates = applyTokenUpdates(
-      [{ address: itx.token.address, value: txFee.reward }],
+      [{ address: itx.token.address, value: fee }],
       lockerState || { tokens: {} },
       'add'
     );
 
+    const sender = senderState ? senderState.address : tx.from;
     const [newSenderState, newStakeState, newLockerState, evidenceState] = await Promise.all([
-      // update user account
-      statedb.account.update(
-        senderState.address,
-        account.update(senderState, { nonce: tx.nonce, ...senderUpdates }, context),
+      // updateOrCreate user account
+      statedb.account.updateOrCreate(
+        senderState,
+        account.updateOrCreate(senderState, { address: sender, nonce: tx.nonce, pk: tx.pk, ...senderUpdates }, context),
         context
       ),
 
@@ -218,11 +223,11 @@ runner.use(
 
     context.updatedAccounts = [
       // stake for tx proposer is decreased
-      { address: stakeAddress, token: itx.token.address, delta: `-${txFee.total}`, action: 'unlock' },
+      { address: stakeAddress, token: itx.token.address, delta: `-${total}`, action: 'unlock' },
       // mint to depositor from stake
-      { address: senderState.address, token: itx.token.address, delta: txFee.user, action: 'unlock' },
-      // block reward is locked for later claiming
-      { address: lockerAddress, token: itx.token.address, delta: txFee.reward, action: 'pending' },
+      { address: sender, token: itx.token.address, delta: user, action: 'unlock' },
+      // tx fee is locked for later claiming
+      { address: lockerAddress, token: itx.token.address, delta: fee, action: 'pending' },
     ];
 
     debug('deposit-token-v2', itx);

package/lib/protocols/token/withdraw-v2.js

@@ -99,15 +99,15 @@ runner.use((context, next) => {
 
   const isFixedFee = new BN(itx.maxFee).isZero();
   if (isFixedFee) {
-    context.txFee = getTxFee({
+    const { reward } = getTxFee({
       amount: itx.token.value,
       feeRate: withdrawFeeRate,
       maxFee: maxWithdrawFee,
       minFee: minWithdrawFee,
     });
 
-    if (new BN(itx.actualFee).lt(new BN(context.txFee.reward))) {
-      const expected = fromUnitToToken(context.txFee.reward, tokenState.decimal);
+    if (new BN(itx.actualFee).lt(new BN(reward))) {
+      const expected = fromUnitToToken(reward, tokenState.decimal);
       const actual = fromUnitToToken(itx.actualFee, tokenState.decimal);
       return next(new Error('INVALID_TX', `itx.actualFee too low, expect at least ${expected}, got ${actual}`));
     }

package/lib/protocols/trade/exchange-v2.js

@@ -81,8 +81,8 @@ runner.use(pipes.VerifyListSize({ listKey: ['senderTokens', 'receiverTokens'] })
 
 // TODO: anti-replay-exchange-attack
 
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', table: 'account' })); // prettier-ignore
+runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK', table: 'account' }));
 runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
 runner.use(pipes.ExtractSigner({ signerKey: 'signerStates', delegatorKey: 'delegatorStates' }));
 runner.use(
@@ -94,9 +94,9 @@ runner.use(
   })
 );
 
-runner.use(pipes.ExtractState({ from: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN' }));
+runner.use(pipes.ExtractState({ from: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
 
-runner.use(pipes.ExtractState({ from: 'receiver', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'receiver', to: 'receiverState', status: 'INVALID_RECEIVER_STATE', table: 'account' })); // prettier-ignore
 runner.use(pipes.VerifyAccountMigration({ senderKey: 'senderState', signerKey: 'signerStates' }));
 runner.use((context, next) => {
   context.senderTokenConditions = {
@@ -114,11 +114,11 @@ runner.use(pipes.VerifyTokenBalance({ ownerKey: 'receiverState', conditionKey: '
 
 runner.use(pipes.AntiLandAttack({ senderState: 'senderState', receiverState: 'receiverState' }));
 
-runner.use(pipes.ExtractState({ from: 'senderAssets', to: 'priv.senderAssets', status: 'INVALID_ASSET' }));
+runner.use(pipes.ExtractState({ from: 'senderAssets', to: 'priv.senderAssets', status: 'INVALID_ASSET', table: 'asset' })); // prettier-ignore
 runner.use(pipes.VerifyTransferrable({ assets: 'priv.senderAssets' }));
 runner.use(pipes.VerifyUpdater({ assetKey: 'priv.senderAssets', ownerKey: 'senderState' }));
 
-runner.use(pipes.ExtractState({ from: 'receiverAssets', to: 'priv.receiverAssets', status: 'INVALID_ASSET' }));
+runner.use(pipes.ExtractState({ from: 'receiverAssets', to: 'priv.receiverAssets', status: 'INVALID_ASSET', table: 'asset' })); // prettier-ignore
 runner.use(pipes.VerifyTransferrable({ assets: 'priv.receiverAssets' }));
 runner.use(pipes.VerifyUpdater({ assetKey: 'priv.receiverAssets', ownerKey: 'receiverState' }));
 

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

@@ -62,10 +62,10 @@ runner.use((context, next) => {
   next();
 });
 
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
+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: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN' }));
+runner.use(pipes.ExtractState({ from: 'tokenAddress', to: 'tokenStates', status: 'INVALID_TOKEN', table: 'token' }));
 runner.use((context, next) => {
   context.tokenConditions = {
     owner: context.senderState.address,
@@ -75,24 +75,32 @@ runner.use((context, next) => {
 });
 runner.use(pipes.VerifyTokenBalance({ ownerKey: 'senderState', conditionKey: 'tokenConditions' }));
 
-runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK' }));
+runner.use(pipes.ExtractState({ from: 'tx.delegator', to: 'delegatorState', status: 'OK', table: 'account' }));
 runner.use(pipes.VerifyDelegation({ type: 'signature', signerKey: 'senderState', delegatorKey: 'delegatorState' }));
 
-runner.use(pipes.ExtractReceiver({ from: 'itx.to' }));
-runner.use(pipes.ExtractState({ from: 'receiver', to: 'receiverState', status: 'INVALID_RECEIVER_STATE' }));
+runner.use(pipes.ExtractReceiver({ from: 'itx.to', to: 'receiver' }));
+runner.use(pipes.ExtractState({ from: 'receiver', to: 'receiverState', status: 'OK', table: 'account' }));
 runner.use(pipes.AntiLandAttack({ senderState: 'senderState', receiverState: 'receiverState' }));
 
-runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'INVALID_ASSET' }));
+runner.use(pipes.ExtractState({ from: 'assets', to: 'assetStates', status: 'INVALID_ASSET', table: 'asset' }));
 runner.use(pipes.VerifyTransferrable({ assets: 'assetStates' }));
 runner.use(pipes.VerifyUpdater({ assetKey: 'assetStates', ownerKey: 'senderState' }));
 
-runner.use(pipes.UpdateOwner({ assets: 'assetStates', owner: 'receiverState' }));
+// transfer assets to new owner
+runner.use((context, next) => {
+  const { itx, receiverState } = context;
+  context.receiverAddr = receiverState ? receiverState.address : itx.to;
+  return next();
+});
+runner.use(pipes.UpdateOwner({ assets: 'assetStates', owner: 'receiverAddr' }));
+
+// update statedb: transfer tokens to new owner
 runner.use(
   async (context, next) => {
-    const { tx, itx, tokens, senderState, receiverState, statedb } = context;
+    const { tx, itx, tokens, senderState, receiverAddr, receiverState, statedb } = context;
 
     const { tokens: senderTokens = {} } = senderState;
-    const { tokens: receiverTokens = {} } = receiverState;
+    const { tokens: receiverTokens = {} } = receiverState || {};
     for (const token of tokens) {
       const delta = new BN(token.value);
       senderTokens[token.address] = new BN(senderTokens[token.address]).sub(delta).toString();
@@ -103,14 +111,14 @@ runner.use(
       // Update sender state
       statedb.account.update(
         senderState.address,
-        account.update(senderState, { nonce: tx.nonce, tokens: senderTokens }, context),
+        account.update(senderState, { nonce: tx.nonce, pk: tx.pk, tokens: senderTokens }, context),
         context
       ),
 
       // Update receiver state
-      statedb.account.update(
-        receiverState.address,
-        account.update(receiverState, { tokens: receiverTokens }, context),
+      statedb.account.updateOrCreate(
+        receiverState,
+        account.updateOrCreate(receiverState, { address: receiverAddr, tokens: receiverTokens }, context),
         context
       ),
     ]);

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

@@ -108,9 +108,9 @@ runner.use(
 runner.use(pipes.VerifyMultiSigV2({ signersKey: 'senders' }));
 
 // 4. verify sender & signer & receiver
-runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'senders', to: 'signerStates', status: 'INVALID_SIGNER_STATE' }));
-runner.use(pipes.ExtractState({ from: 'receivers', to: 'receiverStates', status: 'INVALID_RECEIVER_STATE' }));
+runner.use(pipes.ExtractState({ from: 'tx.from', to: 'senderState', status: 'INVALID_SENDER_STATE', 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: 'receivers', to: 'receiverStates', status: 'OK', table: 'account' }));
 runner.use(pipes.VerifyAccountMigration({ signerKey: 'signerStates', senderKey: 'senderState' }));
 
 // 5. verify token state and balance
@@ -140,7 +140,17 @@ runner.use(async (context, next) => {
 
 runner.use(
   async (context, next) => {
-    const { tx, inputs, outputs, senderState, signerStates, receiverStates, assetStates = [], statedb } = context;
+    const {
+      tx,
+      inputs,
+      outputs,
+      receivers,
+      senderState,
+      signerStates,
+      receiverStates = [],
+      assetStates = [],
+      statedb,
+    } = context;
 
     const signerUpdates = {};
     inputs.forEach((x) => {
@@ -157,7 +167,7 @@ runner.use(
       const { owner, tokensList } = x;
       receiverUpdates[owner] = applyTokenUpdates(
         tokensList,
-        receiverStates.find((s) => s.address === owner),
+        receiverStates.find((s) => s.address === owner) || {},
         'add'
       );
     });
@@ -175,7 +185,6 @@ runner.use(
 
     debug('transfer-v3', { signerUpdates, receiverUpdates, assetUpdates, isAlsoSigner, isAlsoReceiver });
 
-    // FIXME: skip statedb update if account not changed at all
     const [newSenderState, newSignerStates, newReceiverStates, newAssetStates] = await Promise.all([
       // Update sender state
       statedb.account.update(
@@ -183,7 +192,7 @@ runner.use(
         account.update(
           senderState,
           Object.assign(
-            { nonce: tx.nonce },
+            { nonce: tx.nonce, pk: tx.pk },
             signerUpdates[senderState.address] || {},
             receiverUpdates[senderState.address] || {}
           ),
@@ -199,13 +208,18 @@ runner.use(
           .map((x) => statedb.account.update(x.address, account.update(x, signerUpdates[x.address], context), context))
       ),
 
-      // Update receiver state
+      // UpdateOrCreate receiver state
       Promise.all(
-        receiverStates
-          .filter((x) => x.address !== senderState.address)
-          .map((x) =>
-            statedb.account.update(x.address, account.update(x, receiverUpdates[x.address], context), context)
-          )
+        receivers
+          .filter((x) => x !== senderState.address)
+          .map((x) => {
+            const receiverState = receiverStates.find((s) => s.address === x);
+            return statedb.account.updateOrCreate(
+              receiverState,
+              account.updateOrCreate(receiverState, { ...receiverUpdates[x], address: x }, context),
+              context
+            );
+          })
       ),
 
       // Update asset state

package/lib/util.js

@@ -7,6 +7,7 @@ const { toStakeAddress } = require('@arcblock/did-util');
 const cloneDeep = require('lodash/cloneDeep');
 
 const ZERO = new BN(0);
+const RATE_BASE = new BN(10000);
 
 const decodeAnyNested = (encoded) => {
   if (!encoded) {
@@ -95,12 +96,24 @@ const fixTokenInput = (input, config) => {
   return input;
 };
 
-const RATE_BASE = new BN(10000);
 const getTxFee = ({ amount, feeRate, maxFee, minFee, stringify = true }) => {
   const userAmount = new BN(amount);
   const maxFeeAmount = new BN(maxFee);
   const minFeeAmount = new BN(minFee);
 
+  if (feeRate < 0) {
+    throw new Error('FORBIDDEN', 'Unexpected negative feeRate when getTxFee, abort!');
+  }
+  if (userAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative amount when getTxFee, abort!');
+  }
+  if (maxFeeAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative maxFee when getTxFee, abort!');
+  }
+  if (minFeeAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative minFee when getTxFee, abort!');
+  }
+
   // total fee
   let rewardAmount = userAmount.mul(new BN(feeRate)).div(RATE_BASE);
   if (rewardAmount.lt(minFeeAmount)) {
@@ -130,6 +143,15 @@ const getTxFee = ({ amount, feeRate, maxFee, minFee, stringify = true }) => {
 
 const splitTxFee = ({ total, shares = {}, stringify = true }) => {
   const totalAmount = new BN(total);
+  if (totalAmount.lt(ZERO)) {
+    throw new Error('FORBIDDEN', 'Unexpected negative total when splitTxFee, abort!');
+  }
+  Object.keys(shares).forEach((key) => {
+    if (shares[key] < 0) {
+      throw new Error('FORBIDDEN', `Unexpected negative shares[${key}] when splitTxFee, abort!`);
+    }
+  });
+
   const rewardShares = Object.keys(shares).reduce((acc, x) => {
     acc[x] = totalAmount.mul(new BN(shares[x])).div(RATE_BASE);
     return acc;
@@ -143,10 +165,11 @@ const splitTxFee = ({ total, shares = {}, stringify = true }) => {
 
 const getRewardLocker = (rollupAddress) => toStakeAddress(rollupAddress, rollupAddress);
 const getBNSum = (...args) => flattenDeep(args).reduce((sum, x) => sum.add(new BN(x)), new BN(0)).toString(10); // prettier-ignore
-const isFixedFee = (x) => new BN(x.tx.itxJson.maxFee).isZero();
+const isFixedFee = (x) => !x.tx.itxJson.maxFee || new BN(x.tx.itxJson.maxFee).isZero();
 
-const ensureBlockReward = (rollupAddress, tokenAddress, minReward, txStates) => {
-  const locker = toStakeAddress(rollupAddress, rollupAddress);
+const ensureBlockReward = (rollupState, minReward, txStates) => {
+  const { address, withdrawFeeRate, minWithdrawFee, maxWithdrawFee, tokenAddress } = rollupState;
+  const locker = getRewardLocker(address);
 
   const result = {
     mintedAmount: new BN(0),
@@ -177,7 +200,25 @@ const ensureBlockReward = (rollupAddress, tokenAddress, minReward, txStates) =>
   const changes = { stake: [], account: [] };
   dynamicFeeTxs.forEach((x) => {
     const maxFee = new BN(x.tx.itxJson.maxFee);
-    const actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
+    let actualFee = new BN(0);
+    // If totalMissingFee is less than 0, then the tx will be charged for fixedFee
+    if (totalMissingFee.lt(ZERO)) {
+      const fee = getTxFee({
+        amount: x.tx.itxJson.token.value,
+        feeRate: withdrawFeeRate,
+        maxFee: maxWithdrawFee,
+        minFee: minWithdrawFee,
+        stringify: false,
+      });
+      actualFee = fee.reward;
+    } else {
+      // Else the tx is charged for a portion of totalMissingFee
+      actualFee = totalMissingFee.mul(maxFee).div(totalDynamicFee);
+    }
+
+    if (actualFee.lt(ZERO)) {
+      throw new Error('FORBIDDEN', 'Got negative actualFee for tx, abort!');
+    }
 
     // If the actualFee is less than the maxFee, user will have a refund
     if (actualFee.lt(maxFee)) {
@@ -209,7 +250,7 @@ const ensureBlockReward = (rollupAddress, tokenAddress, minReward, txStates) =>
 
       // mint tokens for deposit proposer
       changes.stake.push({
-        address: toStakeAddress(x.tx.itxJson.proposer, rollupAddress),
+        address: toStakeAddress(x.tx.itxJson.proposer, address),
         delta: total,
         action: 'mint',
       });
@@ -219,7 +260,7 @@ const ensureBlockReward = (rollupAddress, tokenAddress, minReward, txStates) =>
 
       // burn tokens from locked withdraws: user amount
       changes.stake.push({
-        address: toStakeAddress(x.tx.from, rollupAddress),
+        address: toStakeAddress(x.tx.from, address),
         delta: `-${user}`,
         action: 'burn',
       });

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.13.61",
+  "version": "1.13.65",
   "description": "Predefined tx pipeline sets to execute certain type of transactions",
   "main": "lib/index.js",
   "files": [
@@ -19,16 +19,16 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@arcblock/did": "1.13.61",
-    "@arcblock/did-util": "1.13.61",
-    "@ocap/asset": "1.13.61",
-    "@ocap/mcrypto": "1.13.61",
-    "@ocap/merkle-tree": "1.13.61",
-    "@ocap/message": "1.13.61",
-    "@ocap/state": "1.13.61",
-    "@ocap/tx-pipeline": "1.13.61",
-    "@ocap/util": "1.13.61",
-    "@ocap/wallet": "1.13.61",
+    "@arcblock/did": "1.13.65",
+    "@arcblock/did-util": "1.13.65",
+    "@ocap/asset": "1.13.65",
+    "@ocap/mcrypto": "1.13.65",
+    "@ocap/merkle-tree": "1.13.65",
+    "@ocap/message": "1.13.65",
+    "@ocap/state": "1.13.65",
+    "@ocap/tx-pipeline": "1.13.65",
+    "@ocap/util": "1.13.65",
+    "@ocap/wallet": "1.13.65",
     "debug": "^4.3.2",
     "empty-value": "^1.0.1",
     "lodash": "^4.17.21",
@@ -41,5 +41,5 @@
   "devDependencies": {
     "jest": "^27.3.1"
   },
-  "gitHead": "79d07bbde4df1d0d37afe76aaa1eaa2f30cc55a7"
+  "gitHead": "4011996e1800845142aa5c889b58726129a99ec3"
 }