Check blocked accounts #181

evm_loader/program/src/entrypoint.rs

@@ -214,6 +214,7 @@ fn process_instruction<'a>(
             do_finalize(program_id, accounts)
         },
         EvmInstruction::Call {bytes} => {
+            StorageAccount::check_for_blocked_accounts(program_id, accounts)?;
             let mut account_storage = ProgramAccountStorage::new(program_id, accounts)?;
             if let Sender::Solana(_addr) = account_storage.get_sender() {
                 // Success execution
@@ -235,6 +236,7 @@ fn process_instruction<'a>(
 
             let trx: UnsignedTransaction = rlp::decode(unsigned_msg).map_err(|e| E!(ProgramError::InvalidInstructionData; "DecoderError={:?}", e))?;
 
+            StorageAccount::check_for_blocked_accounts(program_id, &accounts[1..])?;
             let account_storage = ProgramAccountStorage::new(program_id, &accounts[1..])?;
             let from_addr = verify_tx_signature(signature, unsigned_msg).map_err(|e| E!(ProgramError::MissingRequiredSignature; "Error={:?}", e))?;
             check_ethereum_authority(
@@ -258,6 +260,7 @@ fn process_instruction<'a>(
             let sysvar_info = find_sysvar_info(accounts)?;
 
             let trx: UnsignedTransaction = rlp::decode(unsigned_msg).map_err(|e| E!(ProgramError::InvalidInstructionData; "DecoderError={:?}", e))?;
+            StorageAccount::check_for_blocked_accounts(program_id, accounts)?;
             let mut account_storage = ProgramAccountStorage::new(program_id, accounts)?;
 
             check_secp256k1_instruction(sysvar_info, unsigned_msg.len(), 1_u16)?;
@@ -282,6 +285,7 @@ fn process_instruction<'a>(
             let trx: UnsignedTransaction = rlp::decode(unsigned_msg).map_err(|e| E!(ProgramError::InvalidInstructionData; "DecoderError={:?}", e))?;
 
             let mut storage = StorageAccount::new(storage_info, accounts, caller, trx.nonce)?;
+            StorageAccount::check_for_blocked_accounts(program_id, &accounts[1..])?;
             let account_storage = ProgramAccountStorage::new(program_id, &accounts[1..])?;
 
             check_secp256k1_instruction(sysvar_info, unsigned_msg.len(), 9_u16)?;

evm_loader/program/src/storage_account.rs

@@ -40,6 +40,19 @@ impl<'a> StorageAccount<'a> {
         }
     }
 
+    pub fn check_for_blocked_accounts(program_id: &Pubkey, accounts: &[AccountInfo]) -> Result<(), ProgramError> {
+        for account_info in accounts.iter().filter(|a| a.owner == program_id) {
+            let data = account_info.try_borrow_data()?;
+            if let AccountData::Account(account) = AccountData::unpack(&data)? {
+                if account.blocked.is_some() {
+                    return Err!(ProgramError::InvalidAccountData; "trying to execute transaction on blocked account {}", account_info.key);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn unblock_accounts_and_destroy(self, program_id: &Pubkey, accounts: &[AccountInfo]) -> Result<(), ProgramError> {
         for account_info in accounts.iter().filter(|a| a.owner == program_id) {
             let mut data = account_info.try_borrow_mut_data()?;

evm_loader/test_event.py

@@ -337,7 +337,7 @@ def test_caseFailAfterCancel(self):
         result = self.call_begin(storage, 10, msg, instruction)
         result = self.call_continue(storage, 10)
         result = self.call_cancel(storage)
-            
+
         err = "custom program error: 0x1"
         with self.assertRaisesRegex(Exception,err):
             result = self.call_continue(storage, 10)
@@ -360,5 +360,45 @@ def test_caseSuccessRunOtherTransactionAfterCancel(self):
         self.call_partial_signed(input)
 
 
+    def test_caseFailOnBlockedWithOtherStorageIterative(self):
+        func_name = abi.function_signature_to_4byte_selector('addReturn(uint8,uint8)')
+        input = (func_name + bytes.fromhex("%064x" % 0x1) + bytes.fromhex("%064x" % 0x1))
+
+        (from_addr, sign,  msg) = self.get_call_parameters(input)
+        instruction = from_addr + sign + msg
+
+        storage = self.create_storage_account(sign[-8:].hex())
+
+        result = self.call_begin(storage, 10, msg, instruction)
+        result = self.call_continue(storage, 10)
+
+        err = "invalid account data for instruction"
+        with self.assertRaisesRegex(Exception,err):
+            result = self.call_partial_signed(input)
+            print(result)
+
+        result = self.call_cancel(storage)
+
+
+    def test_caseFailOnBlockedWithOtherStorageNonIterative(self):
+        func_name = abi.function_signature_to_4byte_selector('addReturn(uint8,uint8)')
+        input = (func_name + bytes.fromhex("%064x" % 0x1) + bytes.fromhex("%064x" % 0x1))
+
+        (from_addr, sign,  msg) = self.get_call_parameters(input)
+        instruction = from_addr + sign + msg
+
+        storage = self.create_storage_account(sign[-8:].hex())
+
+        result = self.call_begin(storage, 10, msg, instruction)
+        result = self.call_continue(storage, 10)
+
+        err = "invalid account data for instruction"
+        with self.assertRaisesRegex(Exception,err):
+            result = self.call_signed(input)
+            print(result)
+
+        result = self.call_cancel(storage)
+
+
 if __name__ == '__main__':
     unittest.main()