Pause Contract and Resume Contract

engine-standalone-storage/src/relayer_db/mod.rs

@@ -219,6 +219,7 @@ mod test {
             chain_id: aurora_engine_types::types::u256_to_arr(&1_313_161_555.into()),
             owner_id: "aurora".parse().unwrap(),
             upgrade_delay_blocks: 0,
+            is_paused: false,
         };
 
         // Initialize engine and connector states in storage.

engine-tests/src/tests/mod.rs

@@ -13,6 +13,7 @@ pub mod modexp;
 mod multisender;
 mod one_inch;
 mod pausable_precompiles;
+mod pause_contract;
 mod prepaid_gas_precompile;
 mod promise_results_precompile;
 mod random;

engine-tests/src/tests/pause_contract.rs

@@ -0,0 +1,161 @@
+use crate::test_utils;
+use aurora_engine::parameters::SetUpgradeDelayBlocksArgs;
+use borsh::BorshSerialize;
+
+#[test]
+fn test_pause_contract_require_owner() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("pause_contract", "new_owner.near", vec![]);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resume_contract_require_owner() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("resume_contract", "new_owner.near", vec![]);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_pause_contract_require_running() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resume_contract_require_paused() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_err());
+
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_pause_contract_get_method() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    // contract is running by default, gets should work
+    let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // pause contract
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is paused, gets should still work
+    let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_pause_contract_set_method() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+    let set = (SetUpgradeDelayBlocksArgs {
+        upgrade_delay_blocks: 2,
+    })
+    .try_to_vec()
+    .unwrap();
+
+    // contract is running by default, sets should work
+    let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set.clone());
+    assert!(result.is_ok());
+
+    // pause contract
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is paused, sets should NOT work
+    let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_resume_contract_get_method() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+
+    // contract is running by default, gets should work
+    let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // pause contract
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is paused, gets should still work
+    let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // resume contract
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is running again, gets should work
+    let result = runner.call("get_upgrade_delay_blocks", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_resume_contract_set_method() {
+    let mut runner = test_utils::deploy_evm();
+    let aurora_account_id = runner.aurora_account_id.clone();
+    let set = (SetUpgradeDelayBlocksArgs {
+        upgrade_delay_blocks: 2,
+    })
+    .try_to_vec()
+    .unwrap();
+
+    // contract is running by default, sets should work
+    let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set.clone());
+    assert!(result.is_ok());
+
+    // pause contract
+    let result = runner.call("pause_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is paused, sets should NOT work
+    let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set.clone());
+    assert!(result.is_err());
+
+    // resume contract
+    let result = runner.call("resume_contract", &aurora_account_id, vec![]);
+    assert!(result.is_ok());
+
+    // contract is running again, sets should work
+    let result = runner.call("set_upgrade_delay_blocks", &aurora_account_id, set);
+    assert!(result.is_ok());
+}

engine-tests/src/tests/sanity.rs

@@ -147,9 +147,9 @@ fn test_state_format() {
     };
     let state: aurora_engine::state::EngineState = args.into();
     let expected_hex: String = [
-        "01000000000000000000000000000000000000000000000000000000000000029a",
+        "02000000000000000000000000000000000000000000000000000000000000029a",
         "04000000626f7373",
-        "0300000000000000",
+        "030000000000000000",
     ]
     .concat();
     assert_eq!(hex::encode(state.borsh_serialize().unwrap()), expected_hex);

engine-tests/src/tests/standalone/sanity.rs

@@ -19,6 +19,7 @@ fn test_deploy_code() {
         chain_id,
         owner_id: owner_id.clone(),
         upgrade_delay_blocks: 0,
+        is_paused: false,
     };
     let origin = Address::new(H160([0u8; 20]));
     let storage = RefCell::new(Storage::default());

engine/src/errors.rs

@@ -22,6 +22,8 @@ pub const ERR_VERIFY_PROOF: &[u8; 16] = b"ERR_VERIFY_PROOF";
 pub const ERR_INVALID_UPGRADE: &[u8; 19] = b"ERR_INVALID_UPGRADE";
 pub const ERR_NO_UPGRADE: &[u8; 14] = b"ERR_NO_UPGRADE";
 pub const ERR_NOT_ALLOWED: &[u8; 15] = b"ERR_NOT_ALLOWED";
+pub const ERR_PAUSED: &[u8; 10] = b"ERR_PAUSED";
+pub const ERR_RUNNING: &[u8; 11] = b"ERR_RUNNING";
 
 pub const ERR_SERIALIZE: &str = "ERR_SERIALIZE";
 pub const ERR_PROMISE_ENCODING: &str = "ERR_PROMISE_ENCODING";