Cob/sequential trx requests (#278)

* add sorting of trx requests in transaction pool

format

re-remove split_once directive

* fix test

* fix test

Author: coburncoburn

chains/scripts/README.md

@@ -0,0 +1,2 @@
+usage: scripts to be run in the context of the repl
+yarn repl -s path_to_my_script.js

chains/scripts/add_users.js

@@ -0,0 +1,50 @@
+async function loadem(starting_page = 0) {
+    var cash_nonce = await api.query.cash.nonces({eth: saddle.account});
+    await feedAccount(cash_nonce, starting_page);
+}
+
+async function feedAccount(n, r, accounts = [] ) {
+    const user = saddle.account
+    var accounts
+    var cash_nonce = n
+    if (r > 2000) return;
+
+    if (accounts.length == 0 || i == accounts.length) {
+        console.log(r)
+        accounts =  
+            await fetch(`https://api.compound.finance/api/v2/account?page_number=${r}&page_size=200`)
+                .then(r => r.json())
+                .then( b => b.accounts.map( x => x.address))
+        i = 0;
+        r++;
+    }
+
+    console.log(accounts)
+    for (const a of accounts) {
+        // let a = accounts[i]
+        let request = `(Transfer ${1234567 + cash_nonce} Cash Eth:${a})`
+        let req = `${cash_nonce}:${request}`
+        let sig = await saddle.web3.eth.sign(req, user)
+        console.log("🅰️", a)
+        console.log("🎲", req)
+        let tx = api.tx.cash.execTrxRequest(request, {'Eth': [user, sig]}, cash_nonce)
+
+        await tx.send(({ status }) => {
+            if (status.isDropped) {
+                console.log(`dopped ${status.events}`);
+                }
+            if (status.isInvalid) {
+                console.log(`invalid ${status.events}`);
+                }
+            if (status.isInBlock) {
+                console.log(`included in ${status}`);
+            
+            }
+            if (status.isFinalized) {
+                console.log(`${request} finailzied in ${status}`);
+            }
+        })
+        cash_nonce++
+    }
+    feedAccount(cash_nonce, r)
+}

node/Cargo.toml

@@ -98,6 +98,7 @@ default = ['with-parity-db']
 with-parity-db=['sc-client-db/with-parity-db']
 with-rocks-db=['sc-client-db/with-kvdb-rocksdb']
 runtime-benchmarks = [
+	'with-rocks-db',
 	'gateway-runtime/runtime-benchmarks',
 	'frame-benchmarking-cli',
 ]

pallets/cash/src/internal/exec_trx_request.rs

@@ -49,7 +49,7 @@ pub fn is_minimally_valid_trx_request<T: Config>(
     request: Vec<u8>,
     signature: ChainAccountSignature,
     nonce: Nonce,
-) -> Result<ChainAccount, Reason> {
+) -> Result<(ChainAccount, Nonce), Reason> {
     // Basic request validity checks - valid symbols and parsable request
     let request_str: &str = str::from_utf8(&request[..]).map_err(|_| Reason::InvalidUTF8)?;
     trx_request::parse_request(request_str)?;
@@ -59,13 +59,8 @@ pub fn is_minimally_valid_trx_request<T: Config>(
         .recover_account(&prepend_nonce(&request, nonce)[..])
         .map_err(|_| Reason::SignatureAccountMismatch)?;
 
-    // Nonce check
     let current_nonce = Nonces::get(sender);
-    require!(
-        nonce == current_nonce,
-        Reason::IncorrectNonce(nonce, current_nonce)
-    );
-    Ok(sender)
+    Ok((sender, current_nonce))
 }
 
 pub fn exec_trx_request<T: Config>(

pallets/cash/src/internal/validate_trx.rs

@@ -88,14 +88,29 @@ pub fn validate_unsigned<T: Config>(
 
             match (signer_res, nonce) {
                 (Err(e), _) => Err(ValidationError::InvalidTrxRequest(e)),
-                (Ok(sender), nonce) => Ok(ValidTransaction::with_tag_prefix(
-                    "Gateway::exec_trx_request",
-                )
-                .priority(UNSIGNED_TXS_PRIORITY)
-                .longevity(UNSIGNED_TXS_LONGEVITY)
-                .and_provides((sender, nonce))
-                .propagate(true)
-                .build()),
+                (Ok((sender, current_nonce)), nonce) => {
+                    // Nonce check
+                    if current_nonce == 0 || *nonce == current_nonce {
+                        Ok(
+                            ValidTransaction::with_tag_prefix("Gateway::exec_trx_request")
+                                .priority(UNSIGNED_TXS_PRIORITY)
+                                .longevity(UNSIGNED_TXS_LONGEVITY)
+                                .and_provides((sender, nonce))
+                                .propagate(true)
+                                .build(),
+                        )
+                    } else {
+                        Ok(
+                            ValidTransaction::with_tag_prefix("Gateway::exec_trx_request")
+                                .priority(UNSIGNED_TXS_PRIORITY)
+                                .longevity(UNSIGNED_TXS_LONGEVITY)
+                                .and_requires((sender, nonce - 1))
+                                .and_provides((sender, nonce))
+                                .propagate(true)
+                                .build(),
+                        )
+                    }
+                }
             }
         }
         Call::publish_signature(chain_id, notice_id, signature) => {
@@ -414,7 +429,7 @@ mod tests {
     }
 
     #[test]
-    fn test_exec_trx_request_invalid_request_wrong_nonce() {
+    fn test_exec_trx_request_valid_request_wrong_nonce() {
         new_test_ext().execute_with(|| {
             let request: Vec<u8> = String::from(
                 "(Extract 50000000 Cash Eth:0xfc04833Ca66b7D6B4F540d4C2544228f64a25ac2)",
@@ -434,12 +449,21 @@ mod tests {
 
             Nonces::insert(ChainAccount::Eth(eth_address), nonce - 1);
 
+            let exp = ValidTransaction::with_tag_prefix("Gateway::exec_trx_request")
+                .priority(UNSIGNED_TXS_PRIORITY)
+                .longevity(UNSIGNED_TXS_LONGEVITY)
+                .and_requires((ChainAccount::Eth(eth_address), nonce - 1))
+                .and_provides((ChainAccount::Eth(eth_address), nonce))
+                .propagate(true)
+                .build();
+
+
             assert_eq!(
                 validate_unsigned(
                     TransactionSource::InBlock {},
                     &Call::exec_trx_request::<Test>(request, signature, nonce),
                 ),
-                Err(ValidationError::InvalidTrxRequest(Reason::IncorrectNonce(nonce, nonce - 1)))
+                Ok(exp)
             );
         });
     }