Make CreateWorld fail on invalid nonce

Author: Seulgi Kim

state/src/impls/shard_level.rs

@@ -137,10 +137,18 @@ impl<B: Backend + ShardBackend> ShardLevelState<B> {
         }
     }
 
-    fn create_world(&mut self, shard_id: ShardId, _nonce: &u64, owners: &Vec<Address>) -> StateResult<()> {
+    fn create_world(&mut self, shard_id: ShardId, nonce: &u64, owners: &Vec<Address>) -> StateResult<()> {
         let metadata_address = ShardMetadataAddress::new(shard_id);
         let mut metadata = self.require_metadata(&metadata_address, || unreachable!("Shard must have metadata"))?;
 
+        let current_nonce = *metadata.nonce();
+        if *nonce != current_nonce {
+            return Err(TransactionError::InvalidShardNonce(Mismatch {
+                expected: current_nonce,
+                found: *nonce,
+            }).into())
+        }
+
         let world_id = *metadata.number_of_worlds();
         let world_address = WorldAddress::new(shard_id, world_id);
 
@@ -569,6 +577,40 @@ mod tests {
         assert_eq!(Ok(Some(World::new(owners))), world);
     }
 
+    #[test]
+    fn create_world_fail_if_nonce_is_not_matched() {
+        let network_id = 0xDEADBEEF;
+        let shard_id = 0xCAFE;
+        let mut state = get_temp_shard_state(shard_id);
+
+        let nonce = 1;
+        let owners = vec![];
+
+        let transaction = Transaction::CreateWorld {
+            network_id,
+            shard_id,
+            nonce,
+            owners: owners.clone(),
+        };
+
+        let sender = address();
+        let shard_owner = address();
+        assert_eq!(
+            Ok(TransactionInvoice::Fail(TransactionError::InvalidShardNonce(Mismatch {
+                expected: 0,
+                found: 1
+            }))),
+            state.apply(shard_id, &transaction, &sender, &shard_owner)
+        );
+
+        let metadata = state.metadata();
+        assert_eq!(Ok(Some(ShardMetadata::new_with_nonce(0, 0))), metadata);
+
+        let world_id = 0;
+        let world = state.world(world_id);
+        assert_eq!(Ok(None), world);
+    }
+
     #[test]
     fn mint_permissioned_asset() {
         let shard_id = 0;

types/src/transaction/error.rs

@@ -49,6 +49,7 @@ pub enum Error {
     FailedToUnlock(H256),
     /// Returned when the sum of the transaction's inputs is different from the sum of outputs.
     InconsistentTransactionInOut,
+    InvalidShardNonce(Mismatch<u64>),
 }
 
 const ERROR_ID_INVALID_PAYMENT_SENDER: u8 = 1u8;
@@ -62,6 +63,7 @@ const ERROR_ID_SCRIPT_HASH_MISMATCH: u8 = 8u8;
 const ERROR_ID_INVALID_SCRIPT: u8 = 9u8;
 const ERROR_ID_FAILED_TO_UNLOCK: u8 = 10u8;
 const ERROR_ID_INCONSISTENT_TRANSACTION_IN_OUT: u8 = 11u8;
+const ERROR_ID_INVALID_SHARD_NONCE: u8 = 12u8;
 
 impl Encodable for Error {
     fn rlp_append(&self, s: &mut RlpStream) {
@@ -91,6 +93,9 @@ impl Encodable for Error {
             Error::InvalidScript => s.begin_list(1).append(&ERROR_ID_INVALID_SCRIPT),
             Error::FailedToUnlock(hash) => s.begin_list(1).append(&ERROR_ID_FAILED_TO_UNLOCK).append(hash),
             Error::InconsistentTransactionInOut => s.begin_list(1).append(&ERROR_ID_INCONSISTENT_TRANSACTION_IN_OUT),
+            Error::InvalidShardNonce(mismatch) => {
+                s.begin_list(2).append(&ERROR_ID_INVALID_SHARD_NONCE).append(mismatch)
+            }
         };
     }
 }
@@ -118,6 +123,12 @@ impl Decodable for Error {
             ERROR_ID_INVALID_SCRIPT => Error::InvalidScript,
             ERROR_ID_FAILED_TO_UNLOCK => Error::FailedToUnlock(rlp.val_at(1)?),
             ERROR_ID_INCONSISTENT_TRANSACTION_IN_OUT => Error::InconsistentTransactionInOut,
+            ERROR_ID_INVALID_SHARD_NONCE => {
+                if rlp.item_count()? != 2 {
+                    return Err(DecoderError::RlpInvalidLength)
+                }
+                Error::InvalidShardNonce(rlp.val_at(1)?)
+            }
             _ => return Err(DecoderError::Custom("Invalid transaction error")),
         })
     }
@@ -153,6 +164,7 @@ impl Display for Error {
             Error::InconsistentTransactionInOut => {
                 write!(f, "The sum of the transaction's inputs is different from the sum of the transaction's outputs")
             }
+            Error::InvalidShardNonce(mismatch) => write!(f, "The shard nonce {}", mismatch),
         }
     }
 }