feature: merge PlaceOrder and SpotTrade; fix #145 (#152)

Author: lispc

helper.ts/state-utils.ts

@@ -33,16 +33,18 @@ function accountState2Array(st) {
 function hashAccountState(st) {
   return hash(accountState2Array(st));
 }
-
-const emptyOrderHash = hashOrderState({
-  order_id: 0n,
-  tokenbuy: 0n,
-  tokensell: 0n,
-  filled_sell: 0n,
-  filled_buy: 0n,
-  total_sell: 0n,
-  total_buy: 0n,
-});
+function emptyOrder() {
+  return {
+    order_id: 0n,
+    tokenbuy: 0n,
+    tokensell: 0n,
+    filled_sell: 0n,
+    filled_buy: 0n,
+    total_sell: 0n,
+    total_buy: 0n,
+  };
+}
+const emptyOrderHash = hashOrderState(emptyOrder());
 
 function calculateGenesisOrderRoot(orderLevels) {
   return new Tree<bigint>(orderLevels, emptyOrderHash).getRoot();
@@ -72,4 +74,4 @@ function hashOrderState(st) {
   return hash(orderState2Array(st));
 }
 
-export { hashAccountState, hashOrderState, emptyOrderHash, calculateGenesisOrderRoot };
+export { hashAccountState, hashOrderState, emptyOrder, emptyOrderHash, calculateGenesisOrderRoot };

package-lock.json

@@ -24,7 +24,7 @@
     "printf": "^0.6.1",
     "scrypt-js": "^3.0.1",
     "shelljs": "^0.8.4",
-    "snarkit": "git+https://github.com/fluidex/snarkit.git",
+    "snarkit": "github:fluidex/snarkit",
     "snarkjs": "^0.3.55",
     "tmp-promise": "^3.0.2",
     "ts-node": "^9.1.1",

package.json

@@ -38,6 +38,8 @@ template BalanceChecker(balanceLevels, accountLevels) {
     }
 
 
+    
+    
     component balanceTree = CalculateRootFromMerklePath(balanceLevels);
     balanceTree.leaf <== balance;
     for (var i = 0; i < balanceLevels; i++) {
@@ -60,12 +62,10 @@ template BalanceChecker(balanceLevels, accountLevels) {
         accountTree.path_index[i] <== account_path_index[i];
         accountTree.path_elements[i][0] <== account_path_elements[i][0];
     }
+    component checkEq = ForceEqualIfEnabled();
+    checkEq.enabled <== enabled;
+    checkEq.in[0] <== accountTree.root;
+    checkEq.in[1] <== accountRoot;
 
-    component check = ForceEqualIfEnabled();
-    check.enabled <== enabled;
-    check.in[0] <== accountTree.root;
-    check.in[1] <== accountRoot;
-
-    
 
 }

src/base_tx.circom

@@ -6,7 +6,7 @@ include "./deposit_to_new.circom";
 include "./deposit_to_old.circom";
 include "./transfer.circom";
 include "./withdraw.circom";
-include "./place_order.circom";
+//include "./place_order.circom";
 include "./spot_trade.circom";
 include "./base_tx.circom";
 
@@ -28,7 +28,6 @@ template Block(nTxs, balanceLevels, orderLevels, accountLevels) {
     signal input encodedTxs[nTxs][TxLength()];
 
     // State
-
     signal input balance_path_elements[nTxs][4][balanceLevels][1]; // index meanings: [tx idx][sender, receiver, sender, receiver][levels][siblings]
     signal input order_path_elements[nTxs][2][orderLevels][1]; // index meanings: [tx idx][order_account1, order_account2][levels][siblings]
     signal input account_path_elements[nTxs][2][accountLevels][1]; // index meanings: [tx idx][sender, receiver][levels][siblings]
@@ -97,7 +96,7 @@ template Block(nTxs, balanceLevels, orderLevels, accountLevels) {
     component processDepositToOld[nTxs];
     component processTransfer[nTxs];
     component processWithdraw[nTxs];
-    component processPlaceOrder[nTxs];
+    //component processPlaceOrder[nTxs];
     component processSpotTrade[nTxs];
 
     for (var i = 0; i < nTxs; i++) {
@@ -180,9 +179,26 @@ template Block(nTxs, balanceLevels, orderLevels, accountLevels) {
         processTransfer[i] = Transfer(balanceLevels, accountLevels);
         processTransfer[i].enabled <== enableTransfer[i].out;
 
-        for (var j = 0; j < TxLength(); j++) {
-            processTransfer[i].in[j] <== encodedTxs[i][j];
-        }
+        processTransfer[i].fromAccountID <== decodedTx[i].accountID1;
+        processTransfer[i].toAccountID <== decodedTx[i].accountID2;
+        processTransfer[i].tokenID <== decodedTx[i].tokenID1;
+        processTransfer[i].amount <== decodedTx[i].amount;
+        //processTransfer[i].nonce <== decodedTx[i].nonce1;
+        processTransfer[i].nonce1 <== decodedTx[i].nonce1;
+        processTransfer[i].nonce2 <== decodedTx[i].nonce2;
+        processTransfer[i].sign1 <== decodedTx[i].sign1;
+        processTransfer[i].sign2 <== decodedTx[i].sign2;
+        processTransfer[i].ay1 <== decodedTx[i].ay1;
+        processTransfer[i].ay2 <== decodedTx[i].ay2;
+        processTransfer[i].ethAddr1 <== decodedTx[i].ethAddr1;
+        processTransfer[i].ethAddr2 <== decodedTx[i].ethAddr2;
+
+        processTransfer[i].balance1 <== decodedTx[i].balance1;
+        processTransfer[i].balance2 <== decodedTx[i].balance2;
+        processTransfer[i].sigL2Hash <== decodedTx[i].sigL2Hash;
+        processTransfer[i].s <== decodedTx[i].s;
+        processTransfer[i].r8x <== decodedTx[i].r8x;
+        processTransfer[i].r8y <== decodedTx[i].r8y;
 
         processTransfer[i].orderRoot1 <== orderRoots[i][0];
         processTransfer[i].orderRoot2 <== orderRoots[i][1];
@@ -222,63 +238,63 @@ template Block(nTxs, balanceLevels, orderLevels, accountLevels) {
         processWithdraw[i].oldAccountRoot <== oldAccountRoots[i];
         processWithdraw[i].newAccountRoot <== newAccountRoots[i];
 
-        // try place_order
-        
-        processPlaceOrder[i] = PlaceOrder(balanceLevels, orderLevels, accountLevels);
-        processPlaceOrder[i].enabled <== enablePlaceOrder[i].out;
-        for (var j = 0; j < TxLength(); j++) {
-            processPlaceOrder[i].in[j] <== encodedTxs[i][j];
-        }
-        
-        for (var j = 0; j < balanceLevels; j++) {
-            processPlaceOrder[i].balance_path_elements[j][0] <== balance_path_elements[i][0][j][0];
-        }
-        for (var j = 0; j < orderLevels; j++) {
-            processPlaceOrder[i].order_path_elements[j][0] <== order_path_elements[i][0][j][0];
-        }
-        for (var j = 0; j < accountLevels; j++) {
-            processPlaceOrder[i].account_path_elements[j][0] <== account_path_elements[i][0][j][0];
-        }
-        processPlaceOrder[i].oldOrderRoot <== orderRoots[i][0];
-        processPlaceOrder[i].newOrderRoot <== orderRoots[i][1];
-        processPlaceOrder[i].oldAccountRoot <== oldAccountRoots[i];
-        processPlaceOrder[i].newAccountRoot <== newAccountRoots[i];
-
         // try spot_trade
         processSpotTrade[i] = SpotTrade(balanceLevels, orderLevels, accountLevels);
         processSpotTrade[i].enabled <== enableSpotTrade[i].out;
-        processSpotTrade[i].order1_pos <== decodedTx[i].tokenID3;
-        processSpotTrade[i].order1_id <== decodedTx[i].order1_id;
-        processSpotTrade[i].order1_tokensell <== decodedTx[i].tokenID1;
-        processSpotTrade[i].order1_amountsell <== decodedTx[i].order1_amountsell;
-        processSpotTrade[i].order1_tokenbuy <== decodedTx[i].tokenID2;
-        processSpotTrade[i].order1_amountbuy <== decodedTx[i].order1_amountbuy;
-        processSpotTrade[i].order2_pos <== decodedTx[i].tokenID4;
-        processSpotTrade[i].order2_id <== decodedTx[i].order2_id;
-        processSpotTrade[i].order2_tokensell <== decodedTx[i].tokenID2;
-        processSpotTrade[i].order2_amountsell <== decodedTx[i].order2_amountsell;
-        processSpotTrade[i].order2_tokenbuy <== decodedTx[i].tokenID1;
-        processSpotTrade[i].order2_amountbuy <== decodedTx[i].order2_amountbuy;
-        processSpotTrade[i].amount_2to1 <== decodedTx[i].amount2;
+
+        
+        processSpotTrade[i].oldOrder1ID <== decodedTx[i].oldOrder1ID;
+        processSpotTrade[i].oldOrder1TokenSell <== decodedTx[i].oldOrder1TokenSell;
+        processSpotTrade[i].oldOrder1FilledSell <== decodedTx[i].oldOrder1FilledSell;
+        processSpotTrade[i].oldOrder1AmountSell <== decodedTx[i].oldOrder1AmountSell;
+        processSpotTrade[i].oldOrder1TokenBuy <== decodedTx[i].oldOrder1TokenBuy;
+        processSpotTrade[i].oldOrder1FilledBuy <== decodedTx[i].oldOrder1FilledBuy;
+        processSpotTrade[i].oldOrder1AmountBuy <== decodedTx[i].oldOrder1AmountBuy;
+        processSpotTrade[i].newOrder1ID <== decodedTx[i].newOrder1ID;
+        processSpotTrade[i].newOrder1TokenSell <== decodedTx[i].newOrder1TokenSell;
+        processSpotTrade[i].newOrder1FilledSell <== decodedTx[i].newOrder1FilledSell;
+        processSpotTrade[i].newOrder1AmountSell <== decodedTx[i].newOrder1AmountSell;
+        processSpotTrade[i].newOrder1TokenBuy <== decodedTx[i].newOrder1TokenBuy;
+        processSpotTrade[i].newOrder1FilledBuy <== decodedTx[i].newOrder1FilledBuy;
+        processSpotTrade[i].newOrder1AmountBuy <== decodedTx[i].newOrder1AmountBuy;
+        processSpotTrade[i].oldOrder2ID <== decodedTx[i].oldOrder2ID;
+        processSpotTrade[i].oldOrder2TokenSell <== decodedTx[i].oldOrder2TokenSell;
+        processSpotTrade[i].oldOrder2FilledSell <== decodedTx[i].oldOrder2FilledSell;
+        processSpotTrade[i].oldOrder2AmountSell <== decodedTx[i].oldOrder2AmountSell;
+        processSpotTrade[i].oldOrder2TokenBuy <== decodedTx[i].oldOrder2TokenBuy;
+        processSpotTrade[i].oldOrder2FilledBuy <== decodedTx[i].oldOrder2FilledBuy;
+        processSpotTrade[i].oldOrder2AmountBuy <== decodedTx[i].oldOrder2AmountBuy;
+        processSpotTrade[i].newOrder2ID <== decodedTx[i].newOrder2ID;
+        processSpotTrade[i].newOrder2TokenSell <== decodedTx[i].newOrder2TokenSell;
+        processSpotTrade[i].newOrder2FilledSell <== decodedTx[i].newOrder2FilledSell;
+        processSpotTrade[i].newOrder2AmountSell <== decodedTx[i].newOrder2AmountSell;
+        processSpotTrade[i].newOrder2TokenBuy <== decodedTx[i].newOrder2TokenBuy;
+        processSpotTrade[i].newOrder2FilledBuy <== decodedTx[i].newOrder2FilledBuy;
+        processSpotTrade[i].newOrder2AmountBuy <== decodedTx[i].newOrder2AmountBuy;
+   
+
+        processSpotTrade[i].order1Pos <== decodedTx[i].order1Pos;
+        processSpotTrade[i].order1AccountID <== decodedTx[i].accountID1;
+        processSpotTrade[i].order1AccountNonce <== decodedTx[i].nonce1;
+        processSpotTrade[i].order1AccountSign <== decodedTx[i].sign1;
+        processSpotTrade[i].order1AccountAy <== decodedTx[i].ay1;
+        processSpotTrade[i].order1AccountEthAddr <== decodedTx[i].ethAddr1;
+
+        processSpotTrade[i].order2Pos <== decodedTx[i].order2Pos;
+        processSpotTrade[i].order2AccountID <== decodedTx[i].accountID2;
+        processSpotTrade[i].order2AccountNonce <== decodedTx[i].nonce2;
+        processSpotTrade[i].order2AccountSign <== decodedTx[i].sign2;
+        processSpotTrade[i].order2AccountAy <== decodedTx[i].ay2;
+        processSpotTrade[i].order2AccountEthAddr <== decodedTx[i].ethAddr2;
+
         processSpotTrade[i].amount_1to2 <== decodedTx[i].amount;
-        processSpotTrade[i].order1_filledsell <== decodedTx[i].order1_filledsell;
-        processSpotTrade[i].order1_filledbuy <== decodedTx[i].order1_filledbuy;
-        processSpotTrade[i].order2_filledsell <== decodedTx[i].order2_filledsell;
-        processSpotTrade[i].order2_filledbuy <== decodedTx[i].order2_filledbuy;
-        processSpotTrade[i].order1_accountID <== decodedTx[i].accountID1;
-        processSpotTrade[i].order2_accountID <== decodedTx[i].accountID2;
-        processSpotTrade[i].order1_account_nonce <== decodedTx[i].nonce1;
-        processSpotTrade[i].order2_account_nonce <== decodedTx[i].nonce2;
-        processSpotTrade[i].order1_account_sign <== decodedTx[i].sign1;
-        processSpotTrade[i].order2_account_sign <== decodedTx[i].sign2;
-        processSpotTrade[i].order1_account_ay <== decodedTx[i].ay1;
-        processSpotTrade[i].order2_account_ay <== decodedTx[i].ay2;
-        processSpotTrade[i].order1_account_ethAddr <== decodedTx[i].ethAddr1;
-        processSpotTrade[i].order2_account_ethAddr <== decodedTx[i].ethAddr2;
-        processSpotTrade[i].order1_token_sell_balance <== decodedTx[i].balance1;
-        processSpotTrade[i].order1_token_buy_balance <== decodedTx[i].balance4;
-        processSpotTrade[i].order2_token_sell_balance <== decodedTx[i].balance3;
-        processSpotTrade[i].order2_token_buy_balance <== decodedTx[i].balance2;
+        processSpotTrade[i].amount_2to1 <== decodedTx[i].amount2;
+
+        processSpotTrade[i].order1TokenSellBalance <== decodedTx[i].balance1;
+        processSpotTrade[i].order2TokenBuyBalance <== decodedTx[i].balance2;
+        processSpotTrade[i].order2TokenSellBalance <== decodedTx[i].balance3;
+        processSpotTrade[i].order1TokenBuyBalance <== decodedTx[i].balance4;
+
         for (var j = 0; j < orderLevels; j++) {
             processSpotTrade[i].order_path_elements[0][j][0] <== order_path_elements[i][0][j][0];
             processSpotTrade[i].order_path_elements[1][j][0] <== order_path_elements[i][1][j][0];

src/block.circom

@@ -5,5 +5,3 @@ function TxTypeWithdraw() { return 3; }
 function TxTypePlaceOrder() { return 4; }
 function TxTypeSpotTrade() { return 5; }
 function TxTypeNop() { return 6; }
-
-function TxLength() { return 36; }