Implement rpc chain_getTermMetadata

Author: foriequal0

core/src/lib.rs

@@ -84,7 +84,7 @@ pub use crate::block::Block;
 pub use crate::client::Error::Database;
 pub use crate::client::{
     AccountData, AssetClient, BlockChainClient, BlockChainTrait, ChainNotify, Client, ClientConfig, DatabaseClient,
-    EngineClient, EngineInfo, ExecuteClient, ImportBlock, MiningBlockChainClient, Shard, StateInfo,
+    EngineClient, EngineInfo, ExecuteClient, ImportBlock, MetadataInfo, MiningBlockChainClient, Shard, StateInfo,
     TestBlockChainClient, TextClient,
 };
 pub use crate::consensus::{EngineType, TimeGapParams};

rpc/src/v1/impls/chain.rs

@@ -17,7 +17,10 @@
 use std::convert::{TryFrom, TryInto};
 use std::sync::Arc;
 
-use ccore::{AccountData, AssetClient, BlockId, EngineInfo, ExecuteClient, MiningBlockChainClient, Shard, TextClient};
+use ccore::{
+    AccountData, AssetClient, BlockId, EngineInfo, ExecuteClient, MetadataInfo, MiningBlockChainClient, Shard,
+    TextClient,
+};
 use ccrypto::Blake;
 use cjson::scheme::Params;
 use cjson::uint::Uint;
@@ -60,6 +63,7 @@ where
         + EngineInfo
         + FindActionHandler
         + TextClient
+        + MetadataInfo
         + 'static,
 {
     fn get_transaction(&self, transaction_hash: H256) -> Result<Option<Transaction>> {
@@ -300,6 +304,11 @@ where
         Ok(self.client.common_params(block_id).map(Into::<Params>::into))
     }
 
+    fn get_term_metadata(&self, block_number: Option<u64>) -> Result<Option<(u64, u64)>> {
+        let block_id = block_number.map(BlockId::Number).unwrap_or(BlockId::Latest);
+        Ok(self.client.metadata(block_id).map(|m| (m.last_term_finished_block_num(), m.current_term_id())))
+    }
+
     fn execute_transaction(&self, tx: UnsignedTransaction, sender: PlatformAddress) -> Result<Option<String>> {
         let sender_address = sender.try_address().map_err(errors::core)?;
         let action = Action::try_from(tx.action).map_err(errors::conversion)?;

rpc/src/v1/traits/chain.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use cjson::scheme::Params;
 use cjson::uint::Uint;
 use ckey::{NetworkId, PlatformAddress, Public};
 use ctypes::{BlockNumber, ShardId};
@@ -140,6 +141,10 @@ build_rpc_trait! {
         #[rpc(name = "chain_getCommonParams")]
         fn get_common_params(&self, Option<u64>) -> Result<Option<Params>>;
 
+        /// Return the current term id at given block number
+        #[rpc(name = "chain_getTermMetadata")]
+        fn get_term_metadata(&self, Option<u64>) -> Result<Option<(u64, u64)>>;
+
         /// Execute Transactions
         # [rpc(name = "chain_executeTransaction")]
         fn execute_transaction(&self, UnsignedTransaction, PlatformAddress) -> Result<Option<String>>;

state/src/item/metadata.rs

@@ -102,6 +102,10 @@ impl Metadata {
     pub fn last_term_finished_block_num(&self) -> u64 {
         self.term.last_term_finished_block_num
     }
+
+    pub fn current_term_id(&self) -> u64 {
+        self.term.current_term_id
+    }
 }
 
 impl Default for Metadata {

test/src/e2e/termChange.test.ts

@@ -0,0 +1,170 @@
+// Copyright 2019 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import { expect } from "chai";
+import { blake256 } from "codechain-sdk/lib/utils";
+import "mocha";
+import {
+    aliceAddress,
+    aliceSecret,
+    carolSecret,
+    faucetAddress,
+    faucetSecret,
+    stakeActionHandlerId,
+    validator0Address
+} from "../helper/constants";
+import CodeChain from "../helper/spawn";
+
+const RLP = require("rlp");
+
+describe("ChangeParams", function() {
+    const chain = `${__dirname}/../scheme/solo-block-reward-50.json`;
+    let node: CodeChain;
+
+    beforeEach(async function() {
+        node = new CodeChain({
+            chain,
+            argv: ["--author", validator0Address.toString(), "--force-sealing"]
+        });
+        await node.start();
+
+        const tx = await node.sendPayTx({
+            fee: 10,
+            quantity: 100_000,
+            recipient: aliceAddress
+        });
+        expect(await node.sdk.rpc.chain.containsTransaction(tx.hash())).be.true;
+    });
+
+    async function changeTermSeconds(metadataSeq: number, termSeconds: number) {
+        const newParams = [
+            0x20, // maxExtraDataSize
+            0x0400, // maxAssetSchemeMetadataSize
+            0x0100, // maxTransferMetadataSize
+            0x0200, // maxTextContentSize
+            "tc", // networkID
+            10, // minPayCost
+            10, // minSetRegularKeyCost
+            10, // minCreateShardCost
+            10, // minSetShardOwnersCost
+            10, // minSetShardUsersCost
+            10, // minWrapCccCost
+            10, // minCustomCost
+            10, // minStoreCost
+            10, // minRemoveCost
+            10, // minMintAssetCost
+            10, // minTransferAssetCost
+            10, // minChangeAssetSchemeCost
+            10, // minIncreaseAssetSupplyCost
+            10, // minComposeAssetCost
+            10, // minDecomposeAssetCost
+            10, // minUnwrapCccCost
+            4194304, // maxBodySize
+            16384, // snapshotPeriod
+            termSeconds, // termSeconds
+            0, // nominationExpiration
+            0, // custodyPeriod
+            0, // releasePeriod
+            0, // maxNumOfValidators
+            0, // minNumOfValidators
+            0, // delegationThreshold
+            0 // minDeposit
+        ];
+        const changeParams: (number | string | (number | string)[])[] = [
+            0xff,
+            metadataSeq,
+            newParams
+        ];
+        const message = blake256(RLP.encode(changeParams).toString("hex"));
+        changeParams.push(`0x${node.sdk.util.signEcdsa(message, aliceSecret)}`);
+        changeParams.push(`0x${node.sdk.util.signEcdsa(message, carolSecret)}`);
+
+        {
+            const hash = await node.sdk.rpc.chain.sendSignedTransaction(
+                node.sdk.core
+                    .createCustomTransaction({
+                        handlerId: stakeActionHandlerId,
+                        bytes: RLP.encode(changeParams)
+                    })
+                    .sign({
+                        secret: faucetSecret,
+                        seq: await node.sdk.rpc.chain.getSeq(faucetAddress),
+                        fee: 10
+                    })
+            );
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
+        }
+    }
+
+    it("initial term metadata", async function() {
+        const params = await node.sdk.rpc.sendRpcRequest(
+            "chain_getTermMetadata",
+            [null]
+        );
+        expect(params).to.be.deep.equals([0, 0]);
+    });
+
+    async function waitForTermPeriodChange(termSeconds: number) {
+        const lastBlockNumber = await node.sdk.rpc.chain.getBestBlockNumber();
+        const lastBlock = (await node.sdk.rpc.chain.getBlock(lastBlockNumber))!;
+
+        let previousTs = lastBlock.timestamp;
+        for (let count = 0; count < 20; count++) {
+            await node.sdk.rpc.devel.startSealing();
+            const blockNumber = await node.sdk.rpc.chain.getBestBlockNumber();
+            const block = (await node.sdk.rpc.chain.getBlock(blockNumber))!;
+
+            const currentTs = block.timestamp;
+            const previousTermPeriod = Math.floor(previousTs / termSeconds);
+            const currentTermPeriod = Math.floor(currentTs / termSeconds);
+            if (previousTermPeriod !== currentTermPeriod) {
+                return blockNumber;
+            }
+            previousTs = currentTs;
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+        throw new Error("Timeout on waiting term period change");
+    }
+
+    it("can turn on term change", async function() {
+        const TERM_SECONDS = 3;
+        await changeTermSeconds(0, TERM_SECONDS);
+
+        const blockNumber1 = await waitForTermPeriodChange(TERM_SECONDS);
+
+        const params1 = await node.sdk.rpc.sendRpcRequest(
+            "chain_getTermMetadata",
+            [blockNumber1]
+        );
+        expect(params1).to.be.deep.equals([blockNumber1, 1]);
+
+        const blockNumber2 = await waitForTermPeriodChange(TERM_SECONDS);
+
+        const params2 = await node.sdk.rpc.sendRpcRequest(
+            "chain_getTermMetadata",
+            [blockNumber2]
+        );
+        expect(params2).to.be.deep.equals([blockNumber2, 2]);
+    });
+
+    afterEach(async function() {
+        if (this.currentTest!.state === "failed") {
+            node.testFailed(this.currentTest!.fullTitle());
+        }
+        await node.clean();
+    });
+});