Add an option to decide whether Miner allows CreateShard transaction

Author: Seulgi Kim

codechain/codechain.yml

@@ -168,6 +168,10 @@ args:
         value_name: LIMIT
         help: Maximum amount of transactions in the queue (waiting to be included in next block).
         takes_value: true
+    - allow-create-shard:
+        long: allow-create-shard
+        help: Make the miner allow CreateShard transactions
+        takes_value: false
     - notify-work:
         long: notify-work
         value_name: URLS

codechain/config/mod.rs

@@ -79,6 +79,7 @@ impl Config {
                 mem_size => Some(mem_size * 1024 * 1024),
             },
             mem_pool_fee_bump_shift: self.mining.mem_pool_fee_bump_shift.unwrap(),
+            allow_create_shard: self.mining.allow_create_shard.unwrap_or(false),
             new_work_notify: self.mining.notify_work.clone().unwrap(),
             force_sealing: self.mining.force_sealing.unwrap(),
             reseal_on_own_transaction,
@@ -216,6 +217,7 @@ pub struct Mining {
     pub mem_pool_size: Option<usize>,
     pub mem_pool_mem_limit: Option<usize>,
     pub mem_pool_fee_bump_shift: Option<usize>,
+    pub allow_create_shard: Option<bool>,
     pub notify_work: Option<Vec<String>>,
     pub force_sealing: Option<bool>,
     pub reseal_on_txs: Option<String>,
@@ -366,6 +368,9 @@ impl Mining {
         if other.mem_pool_mem_limit.is_some() {
             self.mem_pool_mem_limit = other.mem_pool_mem_limit;
         }
+        if other.allow_create_shard.is_some() {
+            self.allow_create_shard = other.allow_create_shard;
+        }
         if other.notify_work.is_some() {
             self.notify_work = other.notify_work.clone();
         }
@@ -410,6 +415,9 @@ impl Mining {
         if let Some(mem_pool_size) = matches.value_of("mem-pool-size") {
             self.mem_pool_size = Some(mem_pool_size.parse().map_err(|_| "Invalid size")?);
         }
+        if matches.is_present("allow-create-shard") {
+            self.allow_create_shard = Some(true)
+        }
         if let Some(notify_work) = matches.values_of("notify-work") {
             self.notify_work = Some(notify_work.map(|a| a.into()).collect());
         }

codechain/config/presets/config.dev.toml

@@ -9,6 +9,7 @@ disable = false
 mem_pool_mem_limit = 4 # MB
 mem_pool_size = 32768
 mem_pool_fee_bump_shift = 3 # 12.5%
+allow_create_shard = false
 notify_work = []
 force_sealing = false
 reseal_on_txs = "all"

codechain/config/presets/config.prod.toml

@@ -8,6 +8,7 @@ disable = false
 mem_pool_mem_limit = 512 # MB
 mem_pool_size = 524288
 mem_pool_fee_bump_shift = 3 # 12.5%
+allow_create_shard = false
 notify_work = []
 force_sealing = true
 reseal_on_txs = "all"

core/src/miner/miner.rs

@@ -75,6 +75,7 @@ pub struct MinerOptions {
     /// then `new_fee > old_fee + old_fee >> mem_pool_fee_bump_shift` should be satisfied to replace.
     /// Local transactions ignore this option.
     pub mem_pool_fee_bump_shift: usize,
+    pub allow_create_shard: bool,
     /// How many historical work packages can we store before running out?
     pub work_queue_size: usize,
 }
@@ -92,6 +93,7 @@ impl Default for MinerOptions {
             mem_pool_size: 8192,
             mem_pool_memory_limit: Some(2 * 1024 * 1024),
             mem_pool_fee_bump_shift: 3,
+            allow_create_shard: false,
             work_queue_size: 20,
         }
     }
@@ -270,6 +272,9 @@ impl Miner {
                     cdebug!(MINER, "Rejected transaction {:?}: already in the blockchain", hash);
                     return Err(HistoryError::TransactionAlreadyImported.into())
                 }
+                if !self.is_allowed_transaction(&tx.action) {
+                    cdebug!(MINER, "Rejected transaction {:?}: {:?} is not allowed transaction", hash, tx.action);
+                }
                 match self
                     .engine
                     .verify_transaction_basic(&tx, &best_block_header)
@@ -471,6 +476,12 @@ impl Miner {
                 // The previous transaction has failed
                 continue
             }
+            if !self.is_allowed_transaction(&tx.action) {
+                invald_tx_users.insert(signer_public);
+                invalid_transactions.push(tx.hash());
+                continue
+            }
+
             let hash = tx.hash();
             let start = Instant::now();
             // Check whether transaction type is allowed for sender
@@ -597,6 +608,18 @@ impl Miner {
             }
         })
     }
+
+    fn is_allowed_transaction(&self, action: &Action) -> bool {
+        if let Action::CreateShard {
+            ..
+        } = action
+        {
+            if !self.options.allow_create_shard {
+                return false
+            }
+        }
+        true
+    }
 }
 
 const SEALING_TIMEOUT_IN_BLOCKS: u64 = 5;

test/src/e2e/shard.test.ts

@@ -14,7 +14,9 @@
 // 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 * as chai from "chai";
+import * as chaiAsPromised from "chai-as-promised";
+chai.use(chaiAsPromised);
 import "mocha";
 import {
     aliceAddress,
@@ -26,10 +28,12 @@ import {
 } from "../helper/constants";
 import CodeChain from "../helper/spawn";
 
+const expect = chai.expect;
+
 describe("CreateShard", function() {
     let node: CodeChain;
     before(async function() {
-        node = new CodeChain();
+        node = new CodeChain({ argv: ["--allow-create-shard"] });
         await node.start();
     });
 
@@ -413,3 +417,43 @@ describe("CreateShard", function() {
         await node.clean();
     });
 });
+
+describe("Cannot create shard without allow-create-shard flag", function() {
+    let node: CodeChain;
+    before(async function() {
+        node = new CodeChain();
+        await node.start();
+    });
+
+    it("Create 1 shard", async function() {
+        const seq: number = (await node.sdk.rpc.chain.getSeq(faucetAddress))!;
+
+        await node.sdk.rpc.chain.sendSignedTransaction(
+            node.sdk.core
+                .createPayTransaction({ recipient: aliceAddress, quantity: 1 })
+                .sign({ secret: faucetSecret, seq, fee: 10 })
+        );
+
+        const tx = node.sdk.core
+            .createCreateShardTransaction({ users: [aliceAddress] })
+            .sign({ secret: faucetSecret, seq: seq + 1, fee: 10 });
+        expect(
+            await node.sdk.rpc.sendRpcRequest("chain_getShardIdByHash", [
+                tx.hash(),
+                null
+            ])
+        ).be.null;
+        expect(node.sdk.rpc.chain.sendSignedTransaction(tx)).be.rejected;
+        expect(await node.sdk.rpc.chain.containTransaction(tx.hash())).be.false;
+        expect(await node.sdk.rpc.chain.getTransaction(tx.hash())).be.null;
+        const afterShardId = await node.sdk.rpc.sendRpcRequest(
+            "chain_getShardIdByHash",
+            [tx.hash(), null]
+        );
+        expect(afterShardId).be.null;
+    });
+
+    after(async function() {
+        await node.clean();
+    });
+});