Use the parent block's information in the timelock OPcode

Author: majecty

core/src/block.rs

@@ -23,6 +23,7 @@ use cstate::{FindActionHandler, StateDB, StateError, StateWithCache, TopLevelSta
 use ctypes::errors::HistoryError;
 use ctypes::machine::{LiveBlock, Transactions};
 use ctypes::util::unexpected::Mismatch;
+use ctypes::BlockNumber;
 use cvm::ChainTimeInfo;
 use primitives::{Bytes, H256};
 use rlp::{Decodable, DecoderError, Encodable, RlpStream, UntrustedRlp};
@@ -169,14 +170,23 @@ impl<'x> OpenBlock<'x> {
         tx: SignedTransaction,
         h: Option<H256>,
         client: &C,
+        parent_block_number: BlockNumber,
+        parent_block_timestamp: u64,
     ) -> Result<(), Error> {
         if self.block.transactions_set.contains(&tx.hash()) {
             return Err(HistoryError::TransactionAlreadyImported.into())
         }
 
         let hash = tx.hash();
         let tracker = tx.tracker();
-        let error = match self.block.state.apply(&tx, &hash, &tx.signer_public(), client) {
+        let error = match self.block.state.apply(
+            &tx,
+            &hash,
+            &tx.signer_public(),
+            client,
+            parent_block_number,
+            parent_block_timestamp,
+        ) {
             Ok(()) => {
                 self.block.transactions_set.insert(h.unwrap_or(hash));
                 self.block.transactions.push(tx);
@@ -201,9 +211,11 @@ impl<'x> OpenBlock<'x> {
         &mut self,
         transactions: &[SignedTransaction],
         client: &C,
+        parent_block_number: BlockNumber,
+        parent_block_timestamp: u64,
     ) -> Result<(), Error> {
         for tx in transactions {
-            self.push_transaction(tx.clone(), None, client)?;
+            self.push_transaction(tx.clone(), None, client, parent_block_number, parent_block_timestamp)?;
         }
         Ok(())
     }
@@ -443,7 +455,7 @@ pub fn enact<C: ChainTimeInfo + FindActionHandler>(
     let mut b = OpenBlock::try_new(engine, db, parent, Address::default(), vec![], is_epoch_begin)?;
 
     b.populate_from(header);
-    b.push_transactions(transactions, client)?;
+    b.push_transactions(transactions, client, parent.number(), parent.timestamp())?;
 
     b.close_and_lock(*parent.transactions_root())
 }

core/src/client/client.rs

@@ -405,7 +405,14 @@ impl TextClient for Client {
 impl ExecuteClient for Client {
     fn execute_transaction(&self, transaction: &ShardTransaction, sender: &Address) -> StateResult<()> {
         let mut state = Client::state_at(&self, BlockId::Latest).expect("Latest state MUST exist");
-        state.apply_shard_transaction(transaction, sender, &[], self)
+        state.apply_shard_transaction(
+            transaction,
+            sender,
+            &[],
+            self,
+            self.best_block_header().number(),
+            self.best_block_header().timestamp(),
+        )
     }
 
     fn execute_vm(
@@ -434,6 +441,8 @@ impl ExecuteClient for Client {
                                 &input,
                                 false,
                                 self,
+                                self.best_block_header().number(),
+                                self.best_block_header().timestamp(),
                             ) {
                                 Ok(ScriptResult::Burnt) => "burnt".to_string(),
                                 Ok(ScriptResult::Unlocked) => "unlocked".to_string(),
@@ -803,21 +812,12 @@ impl ImportSealedBlock for Client {
 impl MiningBlockChainClient for Client {}
 
 impl ChainTimeInfo for Client {
-    fn best_block_number(&self) -> BlockNumber {
-        self.chain_info().best_block_number
+    fn transaction_block_age(&self, tracker: &H256, parent_block_number: BlockNumber) -> Option<u64> {
+        self.transaction_block_number(tracker).map(|block_number| parent_block_number - block_number)
     }
 
-    fn best_block_timestamp(&self) -> u64 {
-        self.chain_info().best_block_timestamp
-    }
-
-    fn transaction_block_age(&self, tracker: &H256) -> Option<u64> {
-        self.transaction_block_number(tracker).map(|block_number| self.chain_info().best_block_number - block_number)
-    }
-
-    fn transaction_time_age(&self, tracker: &H256) -> Option<u64> {
-        self.transaction_block_timestamp(tracker)
-            .map(|block_timestamp| self.chain_info().best_block_timestamp - block_timestamp)
+    fn transaction_time_age(&self, tracker: &H256, parent_timestamp: u64) -> Option<u64> {
+        self.transaction_block_timestamp(tracker).map(|block_timestamp| parent_timestamp - block_timestamp)
     }
 }
 

core/src/client/test_client.rs

@@ -562,19 +562,11 @@ impl ResealTimer for TestBlockChainClient {
 }
 
 impl ChainTimeInfo for TestBlockChainClient {
-    fn best_block_number(&self) -> u64 {
-        0
-    }
-
-    fn best_block_timestamp(&self) -> u64 {
-        0
-    }
-
-    fn transaction_block_age(&self, _: &H256) -> Option<u64> {
+    fn transaction_block_age(&self, _: &H256, _parent_block_number: BlockNumber) -> Option<u64> {
         Some(0)
     }
 
-    fn transaction_time_age(&self, _: &H256) -> Option<u64> {
+    fn transaction_time_age(&self, _: &H256, _parent_timestamp: u64) -> Option<u64> {
         Some(0)
     }
 }

core/src/miner/miner.rs

@@ -467,6 +467,10 @@ impl Miner {
         let mut invalid_transactions = Vec::new();
         let block_number = open_block.block().header().number();
 
+        let parent_header = {
+            let parent_hash = open_block.header().parent_hash();
+            chain.block_header(&BlockId::Hash(*parent_hash)).expect("Parent header MUST exist")
+        };
         let mut tx_count: usize = 0;
         let tx_total = transactions.len();
         let mut invald_tx_users = HashSet::new();
@@ -485,11 +489,10 @@ impl Miner {
             let hash = tx.hash();
             let start = Instant::now();
             // Check whether transaction type is allowed for sender
-            let result = self
-                .engine
-                .machine()
-                .verify_transaction(&tx, open_block.header(), chain, true)
-                .and_then(|_| open_block.push_transaction(tx, None, chain));
+            let result =
+                self.engine.machine().verify_transaction(&tx, open_block.header(), chain, true).and_then(|_| {
+                    open_block.push_transaction(tx, None, chain, parent_header.number(), parent_header.timestamp())
+                });
 
             match result {
                 // already have transaction - ignore