[protocol 3.6] Remove short storageID uses (#1727)

* [protocol 3.6] Remove short storageID uses

* [protocol3.6] Formatting

Author: Brechtpd

packages/loopring_v3.js/src/exchange_v3.ts

@@ -703,7 +703,9 @@ export class ExchangeV3 {
             }
           }
         ],
-        "0x" + data/*transaction.input*/.slice(2 + 4 * 2)
+        "0x" +
+          data /*transaction.input*/
+            .slice(2 + 4 * 2)
       );
       //console.log(decodedInputs);
       const numBlocks = decodedInputs[0].length;
@@ -889,8 +891,13 @@ export class ExchangeV3 {
     };
 
     for (let i = 0; i < block.blockSize; i++) {
-      const txData1 = data.extractData(offset + i * 25, 25);
-      const txData2 = data.extractData(offset + block.blockSize * 25 + i * 43, 43);
+      const size1 = 29;
+      const size2 = 39;
+      const txData1 = data.extractData(offset + i * size1, size1);
+      const txData2 = data.extractData(
+        offset + block.blockSize * size1 + i * size2,
+        size2
+      );
       const txData = new Bitstream(txData1 + txData2);
 
       const txType = txData.extractUint8(0);

packages/loopring_v3.js/src/request_processors/spot_trade_processor.ts

@@ -2,7 +2,13 @@ import BN from "bn.js";
 import { Bitstream } from "../bitstream";
 import { Constants } from "../constants";
 import { fromFloat } from "../float";
-import { AccountLeaf, BalanceLeaf, BlockContext, ExchangeState, SpotTrade } from "../types";
+import {
+  AccountLeaf,
+  BalanceLeaf,
+  BlockContext,
+  ExchangeState,
+  SpotTrade
+} from "../types";
 
 interface SettlementValues {
   fillSA: BN;
@@ -20,14 +26,18 @@ interface SettlementValues {
  * Processes ring settlement requests.
  */
 export class SpotTradeProcessor {
-  public static process(state: ExchangeState, block: BlockContext, data: Bitstream) {
+  public static process(
+    state: ExchangeState,
+    block: BlockContext,
+    data: Bitstream
+  ) {
     let offset = 1;
 
     // Storage IDs
-    const tradeHistoryDataA = data.extractUint16(offset);
-    offset += 2;
-    const tradeHistoryDataB = data.extractUint16(offset);
-    offset += 2;
+    const storageIdA = data.extractUint32(offset);
+    offset += 4;
+    const storageIdB = data.extractUint32(offset);
+    offset += 4;
 
     // Accounts
     const accountIdA = data.extractUint32(offset);
@@ -54,16 +64,10 @@ export class SpotTradeProcessor {
     offset += 1;
 
     // Further extraction of packed data
-    const tradeHistorySlotA = tradeHistoryDataA & 0b0011111111111111;
-    const overwriteTradeHistorySlotA =
-      (tradeHistoryDataA & 0b0100000000000000) !== 0;
     const limitMaskA = orderDataA & 0b10000000;
     const feeBipsA = orderDataA & 0b00111111;
     const fillAmountBorSA = limitMaskA > 0;
 
-    const tradeHistorySlotB = tradeHistoryDataB & 0b0011111111111111;
-    const overwriteTradeHistorySlotB =
-      (tradeHistoryDataB & 0b0100000000000000) !== 0;
     const limitMaskB = orderDataB & 0b10000000;
     const feeBipsB = orderDataB & 0b00111111;
     const fillAmountBorSB = limitMaskB > 0;
@@ -72,9 +76,6 @@ export class SpotTradeProcessor {
     const fillSA = fromFloat(fFillSA, Constants.Float24Encoding);
     const fillSB = fromFloat(fFillSB, Constants.Float24Encoding);
 
-    let orderIdA: number = undefined;
-    let orderIdB: number = undefined;
-
     const s = this.calculateSettlementValues(
       block.protocolFeeTakerBips,
       block.protocolFeeMakerBips,
@@ -88,35 +89,33 @@ export class SpotTradeProcessor {
     {
       const accountA = state.getAccount(accountIdA);
       accountA.getBalance(tokenA).balance.isub(s.fillSA);
-      accountA.getBalance(tokenB).balance.iadd(s.fillBA).isub(s.feeA);
+      accountA
+        .getBalance(tokenB)
+        .balance.iadd(s.fillBA)
+        .isub(s.feeA);
 
-      const tradeHistoryA = accountA.getBalance(tokenA).getStorage(tradeHistorySlotA);
-      if (tradeHistoryA.storageID === 0) {
-        tradeHistoryA.storageID = tradeHistorySlotA;
-      }
-      if (overwriteTradeHistorySlotA) {
-        tradeHistoryA.storageID += Constants.NUM_STORAGE_SLOTS;
+      const tradeHistoryA = accountA.getBalance(tokenA).getStorage(storageIdA);
+      if (tradeHistoryA.storageID !== storageIdA) {
         tradeHistoryA.data = new BN(0);
       }
+      tradeHistoryA.storageID = storageIdA;
       tradeHistoryA.data.iadd(fillAmountBorSA ? s.fillBA : s.fillSA);
-      orderIdA = tradeHistoryA.storageID;
     }
     // Update accountB
     {
       const accountB = state.getAccount(accountIdB);
       accountB.getBalance(tokenB).balance.isub(s.fillSB);
-      accountB.getBalance(tokenA).balance.iadd(s.fillBB).isub(s.feeB);
+      accountB
+        .getBalance(tokenA)
+        .balance.iadd(s.fillBB)
+        .isub(s.feeB);
 
-      const tradeHistoryB = accountB.getBalance(tokenB).getStorage(tradeHistorySlotB);
-      if (tradeHistoryB.storageID === 0) {
-        tradeHistoryB.storageID = tradeHistorySlotB;
-      }
-      if (overwriteTradeHistorySlotB) {
-        tradeHistoryB.storageID += Constants.NUM_STORAGE_SLOTS;
+      const tradeHistoryB = accountB.getBalance(tokenB).getStorage(storageIdB);
+      if (tradeHistoryB.storageID !== storageIdB) {
         tradeHistoryB.data = new BN(0);
       }
+      tradeHistoryB.storageID = storageIdB;
       tradeHistoryB.data.iadd(fillAmountBorSB ? s.fillBB : s.fillSB);
-      orderIdB = tradeHistoryB.storageID;
     }
 
     // Update protocol fee
@@ -126,26 +125,31 @@ export class SpotTradeProcessor {
 
     // Update operator
     const operator = state.getAccount(block.operatorAccountID);
-    operator.getBalance(tokenA).balance.iadd(s.feeB).isub(s.protocolFeeB);
-    operator.getBalance(tokenB).balance.iadd(s.feeA).isub(s.protocolFeeA);
-
+    operator
+      .getBalance(tokenA)
+      .balance.iadd(s.feeB)
+      .isub(s.protocolFeeB);
+    operator
+      .getBalance(tokenB)
+      .balance.iadd(s.feeA)
+      .isub(s.protocolFeeA);
 
     // Create struct
     const trade: SpotTrade = {
       exchangeId: state.exchangeId,
       requestIdx: state.processedRequests.length,
-      blockIdx: /*block.blockIdx*/0,
+      blockIdx: /*block.blockIdx*/ 0,
 
       accountIdA,
-      orderIdA,
+      orderIdA: storageIdA,
       fillAmountBorSA,
       tokenA,
       fillSA: s.fillSA,
       feeA: s.feeA,
       protocolFeeA: s.protocolFeeA,
 
       accountIdB,
-      orderIdB,
+      orderIdB: storageIdB,
       fillAmountBorSB,
       tokenB,
       fillSB: s.fillSB,

packages/loopring_v3.js/src/request_processors/transfer_processor.ts

@@ -11,7 +11,6 @@ interface Transfer {
   amount?: BN;
   feeTokenID?: number;
   fee?: BN;
-  shortStorageID?: number;
   validUntil?: number;
   storageID?: number;
   from?: string;
@@ -23,7 +22,11 @@ interface Transfer {
  * Processes internal transfer requests.
  */
 export class TransferProcessor {
-  public static process(state: ExchangeState, block: BlockContext, txData: Bitstream) {
+  public static process(
+    state: ExchangeState,
+    block: BlockContext,
+    txData: Bitstream
+  ) {
     const transfer = this.extractData(txData);
 
     const from = state.getAccount(transfer.accountFromID);
@@ -38,16 +41,10 @@ export class TransferProcessor {
     from.getBalance(transfer.feeTokenID).balance.isub(transfer.fee);
 
     // Nonce
-    const storageSlot = transfer.shortStorageID & 0b0011111111111111;
-    const overwriteSlot = (transfer.shortStorageID & 0b0100000000000000) !== 0;
-    const storage = from.getBalance(transfer.tokenID).getStorage(storageSlot);
-    if (storage.storageID === 0) {
-      storage.storageID = storageSlot;
-    }
-    if (overwriteSlot) {
-      storage.storageID += Constants.NUM_STORAGE_SLOTS;
-      storage.data = new BN(0);
-    }
+    const storage = from
+      .getBalance(transfer.tokenID)
+      .getStorage(transfer.storageID);
+    storage.storageID = transfer.storageID;
     storage.data = new BN(1);
 
     const operator = state.getAccount(block.operatorAccountID);
@@ -70,18 +67,22 @@ export class TransferProcessor {
     offset += 4;
     transfer.tokenID = data.extractUint16(offset);
     offset += 2;
-    transfer.amount = fromFloat(data.extractUint24(offset), Constants.Float24Encoding);
+    transfer.amount = fromFloat(
+      data.extractUint24(offset),
+      Constants.Float24Encoding
+    );
     offset += 3;
     transfer.feeTokenID = data.extractUint16(offset);
     offset += 2;
-    transfer.fee = fromFloat(data.extractUint16(offset), Constants.Float16Encoding);
+    transfer.fee = fromFloat(
+      data.extractUint16(offset),
+      Constants.Float16Encoding
+    );
     offset += 2;
-    transfer.shortStorageID = data.extractUint16(offset);
-    offset += 2;
-    transfer.to = data.extractAddress(offset);
-    offset += 20;
     transfer.storageID = data.extractUint32(offset);
     offset += 4;
+    transfer.to = data.extractAddress(offset);
+    offset += 20;
     transfer.from = data.extractAddress(offset);
     offset += 20;
 

packages/loopring_v3.js/src/request_processors/withdrawal_processor.ts

@@ -23,7 +23,11 @@ interface Withdrawal {
  * Processes internal transfer requests.
  */
 export class WithdrawalProcessor {
-  public static process(state: ExchangeState, block: BlockContext, txData: Bitstream) {
+  public static process(
+    state: ExchangeState,
+    block: BlockContext,
+    txData: Bitstream
+  ) {
     const withdrawal = this.extractData(txData);
 
     const account = state.getAccount(withdrawal.accountID);
@@ -42,8 +46,9 @@ export class WithdrawalProcessor {
 
     if (withdrawal.type === 0 || withdrawal.type === 1) {
       // Nonce
-      const storageSlot = withdrawal.storageID % Constants.NUM_STORAGE_SLOTS;
-      const storage = account.getBalance(withdrawal.tokenID).getStorage(storageSlot);
+      const storage = account
+        .getBalance(withdrawal.tokenID)
+        .getStorage(withdrawal.storageID);
       storage.storageID = withdrawal.storageID;
       storage.data = new BN(1);
     }
@@ -67,7 +72,10 @@ export class WithdrawalProcessor {
     offset += 12;
     withdrawal.feeTokenID = data.extractUint16(offset);
     offset += 2;
-    withdrawal.fee = fromFloat(data.extractUint16(offset), Constants.Float16Encoding);
+    withdrawal.fee = fromFloat(
+      data.extractUint16(offset),
+      Constants.Float16Encoding
+    );
     offset += 2;
     withdrawal.storageID = data.extractUint32(offset);
     offset += 4;

packages/loopring_v3/DESIGN.md

@@ -228,14 +228,14 @@ The `fillAmountBorS` parameter can be used to decide which amount is the limitin
 ```
 - For both Orders:
     - Account ID: 4 bytes
-    - Short StorageID: 2 bytes
+    - Storage ID: 4 bytes
     - TokenS: 2 bytes
     - FillS: 3 bytes （24 bits, 19 bits for the mantissa part and 5 for the exponent part)
     - Order data (fillAmountBorS,feeBips): 1 byte
 ```
 
-- => **24 bytes/ring**
-- => Calldata cost: 24 \* 16 = **384 gas/ring**
+- => **28 bytes/ring**
+- => Calldata cost: 28 \* 16 = **448 gas/ring**
 
 ### Fee Model
 
@@ -321,7 +321,7 @@ If the order never left the DEX and the user trusts the DEX, the order can simpl
 
 ### Storage
 
-Every account has a storage tree with 2^14 leaves **for every token**. Which leaf is used for storing e.g., the trading history for an order is completely left up to the user, and we call this the **storageID**. The storageID is stored in a 32-bit value and works as a 2D nonce. We allow the user to overwrite the existing storage stored at `storageID % 2^14` if `order.storageID == storage.storageID + 2^14`. If `order.storageID < storage.storageID` the order is automatically canceled. If `order.storageID == storage.storageID` we use the data stored in the leaf. If `order.storageID > storage.storageID + 2^14`, the order cannot be used yet as the storageID can only be incremented by `2^14`. This allows the account to create 2^32 unique orders for every token, and the only limitation is that only 2^14 of these orders selling a certain token can be active at the same time.
+Every account has a storage tree with 2^14 leaves **for every token**. Which leaf is used for storing e.g., the trading history for an order is completely left up to the user, and we call this the **storageID**. The storageID is stored in a 32-bit value and works as a 2D nonce. We allow the user to overwrite the existing storage stored at `storageID % 2^14` if `order.storageID > storage.storageID`. If `order.storageID < storage.storageID` the order is automatically canceled. If `order.storageID == storage.storageID` we use the data stored in the leaf. This allows the account to create 2^32 unique orders for every token, and the only limitation is that only 2^14 of these orders selling a certain token can be active at the same time.
 
 While this was done for performance reasons (so we do not have to have a storage tree with a large depth using the order hash as an address), this does open up some interesting possibilities.
 
@@ -390,14 +390,13 @@ Not all features available for transfers using EdDSA signatures are available us
 - Amount: 3 bytes （24 bits, 19 bits for the mantissa part and 5 for the exponent part)
 - Fee token ID: 2 bytes
 - Fee amount: 2 bytes （16 bits, 11 bits for the mantissa part and 5 for the exponent part)
-- Short storageID: 2 bytes
+- StorageID: 4 bytes
 - To: 20 bytes （only set when transferring to a new account)
-- storageID: 4 bytes （only set for conditional transfers)
 - From: 20 bytes （only set for conditional transfers)
 ```
 
-- => **20 bytes/transfer** (in the most common case)
-- => Calldata cost: 20 \* 16 = **320 gas/transfer**
+- => **22 bytes/transfer** (in the most common case)
+- => Calldata cost: 22 \* 16 = **352 gas/transfer**
 
 ## Deposit
 

packages/loopring_v3/circuit/Circuits/SpotTradeCircuit.h

@@ -333,12 +333,8 @@ class SpotTradeCircuit : public BaseTransactionCircuit
     const VariableArrayT getPublicData() const
     {
         return flattenReverse({
-          VariableArrayT(1, state.constants._0),
-          VariableArrayT(1, tradeHistory_A.getOverwrite()),
-          subArray(orderA.storageID.bits, 0, NUM_BITS_STORAGE_ADDRESS),
-          VariableArrayT(1, state.constants._0),
-          VariableArrayT(1, tradeHistory_B.getOverwrite()),
-          subArray(orderB.storageID.bits, 0, NUM_BITS_STORAGE_ADDRESS),
+          orderA.storageID.bits,
+          orderB.storageID.bits,
 
           orderA.accountID.bits,
           orderB.accountID.bits,

packages/loopring_v3/circuit/Circuits/TransferCircuit.h

@@ -95,7 +95,6 @@ class TransferCircuit : public BaseTransactionCircuit
     OrGadget da_NeedsToAddress;
     ArrayTernaryGadget da_To;
     ArrayTernaryGadget da_From;
-    ArrayTernaryGadget da_StorageID;
 
     // Fee as float
     FloatGadget fFee;
@@ -271,12 +270,6 @@ class TransferCircuit : public BaseTransactionCircuit
             from.bits,
             VariableArrayT(NUM_BITS_ADDRESS, state.constants._0),
             FMT(prefix, ".da_From")),
-          da_StorageID(
-            pb,
-            isConditional.result(),
-            storageID.bits,
-            VariableArrayT(NUM_BITS_STORAGEID, state.constants._0),
-            FMT(prefix, ".da_StorageID")),
 
           // Fee as float
           fFee(pb, state.constants, Float16Encoding, FMT(prefix, ".fFee")),
@@ -409,7 +402,6 @@ class TransferCircuit : public BaseTransactionCircuit
         da_NeedsToAddress.generate_r1cs_witness();
         da_To.generate_r1cs_witness();
         da_From.generate_r1cs_witness();
-        da_StorageID.generate_r1cs_witness();
 
         // Fee as float
         fFee.generate_r1cs_witness(toFloat(transfer.fee, Float16Encoding));
@@ -487,7 +479,6 @@ class TransferCircuit : public BaseTransactionCircuit
         da_NeedsToAddress.generate_r1cs_constraints();
         da_To.generate_r1cs_constraints();
         da_From.generate_r1cs_constraints();
-        da_StorageID.generate_r1cs_constraints();
 
         // Fee as float
         fFee.generate_r1cs_constraints();
@@ -516,9 +507,8 @@ class TransferCircuit : public BaseTransactionCircuit
            fAmount.bits(),
            feeTokenID.bits,
            fFee.bits(),
-           nonce.getShortStorageID(),
+           storageID.bits,
            da_To.result(),
-           da_StorageID.result(),
            da_From.result()});
     }
 };