diff --git a/rpc/src/v1/types/action.rs b/rpc/src/v1/types/action.rs
index 71635e3fef..62055f0f43 100644
--- a/rpc/src/v1/types/action.rs
+++ b/rpc/src/v1/types/action.rs
@@ -59,6 +59,7 @@ pub enum Action {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: u64,
         metadata: String,
         approver: Option<PlatformAddress>,
         registrar: Option<PlatformAddress>,
@@ -71,6 +72,7 @@ pub enum Action {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: u64,
         output: Box<AssetMintOutput>,
 
         approvals: Vec<Signature>,
@@ -183,6 +185,7 @@ pub enum ActionWithTracker {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: u64,
         metadata: String,
         approver: Option<PlatformAddress>,
         registrar: Option<PlatformAddress>,
@@ -197,6 +200,7 @@ pub enum ActionWithTracker {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: u64,
         output: Box<AssetMintOutput>,
 
         approvals: Vec<Signature>,
@@ -329,6 +333,7 @@ impl ActionWithTracker {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
@@ -338,6 +343,7 @@ impl ActionWithTracker {
                 network_id,
                 shard_id,
                 asset_type,
+                seq: seq as u64,
                 metadata,
                 approver: approver.map(|approver| PlatformAddress::new_v1(network_id, approver)),
                 registrar: registrar.map(|registrar| PlatformAddress::new_v1(network_id, registrar)),
@@ -349,12 +355,14 @@ impl ActionWithTracker {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output,
                 approvals,
             } => ActionWithTracker::IncreaseAssetSupply {
                 network_id,
                 shard_id,
                 asset_type,
+                seq: seq as u64,
                 output: Box::new((*output).into()),
                 approvals,
                 tracker: tracker.unwrap(),
@@ -543,6 +551,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
@@ -562,6 +571,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                     network_id,
                     shard_id,
                     asset_type,
+                    seq: seq as usize,
                     metadata,
                     approver,
                     registrar,
@@ -573,6 +583,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output,
                 approvals,
             } => {
@@ -580,6 +591,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                 ActionType::IncreaseAssetSupply {
                     network_id,
                     shard_id,
+                    seq: seq as usize,
                     asset_type,
                     output: Box::new(output_content),
                     approvals,
diff --git a/rpc/src/v1/types/asset_scheme.rs b/rpc/src/v1/types/asset_scheme.rs
index be4febde5f..aa4d23b3d4 100644
--- a/rpc/src/v1/types/asset_scheme.rs
+++ b/rpc/src/v1/types/asset_scheme.rs
@@ -30,6 +30,7 @@ pub struct AssetScheme {
     registrar: Option<PlatformAddress>,
     allowed_script_hashes: Vec<H160>,
     pool: Vec<Asset>,
+    seq: u64,
 }
 
 impl AssetScheme {
@@ -44,6 +45,7 @@ impl AssetScheme {
                 .map(|registrar| PlatformAddress::new_v1(network_id, *registrar)),
             allowed_script_hashes: asset_scheme.allowed_script_hashes().to_owned(),
             pool: asset_scheme.pool().iter().map(|asset| asset.clone().into()).collect(),
+            seq: asset_scheme.seq() as u64,
         }
     }
 }
diff --git a/state/src/impls/shard_level.rs b/state/src/impls/shard_level.rs
index da6cc8da5a..ec9cf6a53c 100644
--- a/state/src/impls/shard_level.rs
+++ b/state/src/impls/shard_level.rs
@@ -157,6 +157,7 @@ impl<'db> ShardLevelState<'db> {
             ShardTransaction::ChangeAssetScheme {
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
@@ -168,6 +169,7 @@ impl<'db> ShardLevelState<'db> {
                     sender,
                     approvers,
                     asset_type,
+                    *seq,
                     metadata,
                     approver,
                     registrar,
@@ -178,10 +180,11 @@ impl<'db> ShardLevelState<'db> {
                 shard_id,
                 asset_type,
                 output,
+                seq,
                 ..
             } => {
                 assert_eq!(*shard_id, self.shard_id);
-                self.increase_asset_supply(transaction.tracker(), sender, approvers, asset_type, output)
+                self.increase_asset_supply(transaction.tracker(), *seq, sender, approvers, asset_type, output)
             }
             ShardTransaction::ComposeAsset {
                 metadata,
@@ -456,6 +459,7 @@ impl<'db> ShardLevelState<'db> {
         sender: &Address,
         approvers: &[Address],
         asset_type: &H160,
+        seq: usize,
         metadata: &str,
         approver: &Option<Address>,
         registrar: &Option<Address>,
@@ -466,12 +470,23 @@ impl<'db> ShardLevelState<'db> {
         }
 
         let mut asset_scheme = self.get_asset_scheme_mut(self.shard_id, *asset_type)?;
+        if asset_scheme.seq() != seq {
+            return Err(RuntimeError::InvalidSeqOfAssetScheme {
+                asset_type: *asset_type,
+                shard_id: self.shard_id,
+                expected: asset_scheme.seq(),
+                actual: seq,
+            }
+            .into())
+        }
+
         asset_scheme.change_data(
             metadata.to_string(),
             approver.clone(),
             registrar.clone(),
             allowed_script_hashes.to_vec(),
         );
+        asset_scheme.increase_seq();
 
         Ok(())
     }
@@ -479,6 +494,7 @@ impl<'db> ShardLevelState<'db> {
     fn increase_asset_supply(
         &mut self,
         transaction_tracker: H256,
+        seq: usize,
         sender: &Address,
         approvers: &[Address],
         asset_type: &H160,
@@ -492,7 +508,17 @@ impl<'db> ShardLevelState<'db> {
         assert!(output.supply > 0, "Supply increasing quantity must be specified and greater than 0");
 
         let mut asset_scheme = self.get_asset_scheme_mut(self.shard_id, *asset_type)?;
+        if seq != asset_scheme.seq() {
+            return Err(RuntimeError::InvalidSeqOfAssetScheme {
+                asset_type: *asset_type,
+                shard_id: self.shard_id,
+                expected: asset_scheme.seq(),
+                actual: seq,
+            }
+            .into())
+        }
         let previous_supply = asset_scheme.increase_supply(output.supply)?;
+        asset_scheme.increase_seq();
         self.create_asset(
             transaction_tracker,
             0,
@@ -502,7 +528,7 @@ impl<'db> ShardLevelState<'db> {
             output.supply,
             None,
         )?;
-        ctrace!(TX, "Increased asset supply {:?} {:?} {:?}", asset_type, previous_supply, output.supply);
+        ctrace!(TX, "Increased asset supply {:?} {:?} => {:?}", asset_type, previous_supply, output.supply);
         ctrace!(TX, "Created asset on {}:{}", self.shard_id, transaction_tracker);
 
         Ok(())
@@ -2439,6 +2465,7 @@ mod tests {
             network_id: "tc".into(),
             shard_id: SHARD_ID,
             asset_type,
+            seq: 0,
             metadata: "New metadata".to_string(),
             approver: Some(approver),
             registrar: None,
@@ -2485,6 +2512,7 @@ mod tests {
             network_id: "tc".into(),
             shard_id: SHARD_ID,
             asset_type,
+            seq: 0,
             output: AssetMintOutput {
                 lock_script_hash: H160::random(),
                 parameters: vec![],
diff --git a/state/src/item/asset_scheme.rs b/state/src/item/asset_scheme.rs
index 5b50013451..80fdb7972d 100644
--- a/state/src/item/asset_scheme.rs
+++ b/state/src/item/asset_scheme.rs
@@ -32,6 +32,7 @@ pub struct AssetScheme {
     registrar: Option<Address>,
     allowed_script_hashes: Vec<H160>,
     pool: Vec<Asset>,
+    seq: usize,
 }
 
 impl AssetScheme {
@@ -49,6 +50,7 @@ impl AssetScheme {
             registrar,
             allowed_script_hashes,
             pool: Vec::new(),
+            seq: 0,
         }
     }
 
@@ -67,6 +69,7 @@ impl AssetScheme {
             registrar,
             allowed_script_hashes,
             pool,
+            seq: 0,
         }
     }
 
@@ -90,6 +93,10 @@ impl AssetScheme {
         &self.allowed_script_hashes
     }
 
+    pub fn seq(&self) -> usize {
+        self.seq
+    }
+
     pub fn is_permissioned(&self) -> bool {
         self.approver.is_some()
     }
@@ -130,6 +137,10 @@ impl AssetScheme {
         Ok(previous)
     }
 
+    pub fn increase_seq(&mut self) {
+        self.seq += 1;
+    }
+
     pub fn reduce_supply(&mut self, quantity: u64) -> u64 {
         assert!(self.supply >= quantity, "AssetScheme supply shouldn't be depleted");
         let previous = self.supply;
@@ -148,26 +159,36 @@ impl Default for AssetScheme {
 
 impl Encodable for AssetScheme {
     fn rlp_append(&self, s: &mut RlpStream) {
-        s.begin_list(7)
-            .append(&PREFIX)
+        if self.seq == 0 {
+            s.begin_list(7);
+        } else {
+            s.begin_list(8);
+        }
+        s.append(&PREFIX)
             .append(&self.metadata)
             .append(&self.supply)
             .append(&self.approver)
             .append(&self.registrar)
             .append_list(&self.allowed_script_hashes)
             .append_list(&self.pool);
+        if self.seq != 0 {
+            s.append(&self.seq);
+        }
     }
 }
 
 impl Decodable for AssetScheme {
     fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
-        let item_count = rlp.item_count()?;
-        if item_count != 7 {
-            return Err(DecoderError::RlpInvalidLength {
-                got: item_count,
-                expected: 7,
-            })
-        }
+        let seq = match rlp.item_count()? {
+            7 => 0,
+            8 => rlp.val_at(7)?,
+            item_count => {
+                return Err(DecoderError::RlpInvalidLength {
+                    got: item_count,
+                    expected: 7,
+                })
+            }
+        };
 
         let prefix = rlp.val_at::<u8>(0)?;
         if PREFIX != prefix {
@@ -181,6 +202,7 @@ impl Decodable for AssetScheme {
             registrar: rlp.val_at(4)?,
             allowed_script_hashes: rlp.list_at(5)?,
             pool: rlp.list_at(6)?,
+            seq,
         })
     }
 }
diff --git a/test/package.json b/test/package.json
index cb2b81dd51..0a1588959f 100644
--- a/test/package.json
+++ b/test/package.json
@@ -43,8 +43,8 @@
     "blakejs": "^1.1.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "codechain-primitives": "^0.4.8",
-    "codechain-sdk": "https://github.com/sgkim126/codechain-sdk-js.git#result-lib",
+    "codechain-primitives": "^0.5.0",
+    "codechain-sdk": "https://github.com/sgkim126/codechain-sdk-js.git#seq-lib",
     "crypto": "^1.0.1",
     "dgram": "^1.0.1",
     "elliptic": "^6.4.1",
diff --git a/test/src/e2e.long/orders.test.ts b/test/src/e2e.long/orders.test.ts
index 685acd63c2..94d6c17d65 100644
--- a/test/src/e2e.long/orders.test.ts
+++ b/test/src/e2e.long/orders.test.ts
@@ -19,12 +19,7 @@ import { $anything } from "../helper/chai-similar";
 import * as chaiAsPromised from "chai-as-promised";
 chai.use(chaiAsPromised);
 const expect = chai.expect;
-import {
-    Asset,
-    AssetTransferAddress,
-    H160,
-    U64
-} from "codechain-sdk/lib/core/classes";
+import { Asset, AssetAddress, H160, U64 } from "codechain-sdk/lib/core/classes";
 import * as _ from "lodash";
 import "mocha";
 import { faucetAddress, faucetSecret } from "../helper/constants";
@@ -42,7 +37,7 @@ describe("orders", function() {
 
     describe("AssetTransfer with orders", function() {
         describe("Mint one asset", function() {
-            let aliceAddress: AssetTransferAddress;
+            let aliceAddress: AssetAddress;
 
             let gold: Asset;
 
@@ -69,7 +64,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -135,8 +130,8 @@ describe("orders", function() {
         });
 
         describe("Mint two assets", function() {
-            let aliceAddress: AssetTransferAddress;
-            let bobAddress: AssetTransferAddress;
+            let aliceAddress: AssetAddress;
+            let bobAddress: AssetAddress;
 
             let gold: Asset;
             let silver: Asset;
@@ -209,7 +204,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 1);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -230,7 +225,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -297,7 +292,7 @@ describe("orders", function() {
                 );
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             }).timeout(10_000);
@@ -351,7 +346,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 1);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -417,7 +412,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 1);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -496,7 +491,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 1);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -577,7 +572,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 1);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -599,7 +594,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -664,7 +659,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 3);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -1402,7 +1397,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -1470,9 +1465,9 @@ describe("orders", function() {
                 });
                 await node.sdk.rpc.devel.startSealing();
                 await node.waitBlockNumber(blockNumber + 1);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .false;
-                expect(await node.sdk.rpc.chain.containTransaction(pay.hash()))
+                expect(await node.sdk.rpc.chain.containsTransaction(pay.hash()))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                     .null;
@@ -1495,7 +1490,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -1576,9 +1571,9 @@ describe("orders", function() {
                 });
                 await node.sdk.rpc.devel.startSealing();
                 await node.waitBlockNumber(blockNumber + 1);
-                expect(await node.sdk.rpc.chain.containTransaction(pay.hash()))
+                expect(await node.sdk.rpc.chain.containsTransaction(pay.hash()))
                     .be.true;
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .false;
                 expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                     .null;
@@ -1601,7 +1596,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -1680,7 +1675,7 @@ describe("orders", function() {
                 });
                 await node.sdk.rpc.devel.startSealing();
                 await node.waitBlockNumber(blockNumber + 1);
-                expect(await node.sdk.rpc.chain.containTransaction(pay.hash()))
+                expect(await node.sdk.rpc.chain.containsTransaction(pay.hash()))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                     .null;
@@ -1955,7 +1950,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx1, 1);
 
                 const hash1 = await node.sendAssetTransaction(transferTx1);
-                expect(await node.sdk.rpc.chain.containTransaction(hash1)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
 
@@ -2002,7 +1997,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx2, 1);
 
                 const hash2 = await node.sendAssetTransaction(transferTx2);
-                expect(await node.sdk.rpc.chain.containTransaction(hash2)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
             }).timeout(10_000);
@@ -2080,7 +2075,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx1, 1);
 
                 const hash1 = await node.sendAssetTransaction(transferTx1);
-                expect(await node.sdk.rpc.chain.containTransaction(hash1)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
 
@@ -2133,7 +2128,7 @@ describe("orders", function() {
                 // Sign on both inputs 0, 1 are not needed
 
                 const hash2 = await node.sendAssetTransaction(transferTx2);
-                expect(await node.sdk.rpc.chain.containTransaction(hash2)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
             }).timeout(10_000);
@@ -2193,7 +2188,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx1, 1);
 
                 const hash1 = await node.sendAssetTransaction(transferTx1);
-                expect(await node.sdk.rpc.chain.containTransaction(hash1)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
 
@@ -2221,16 +2216,16 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx2, 1);
 
                 const hash2 = await node.sendAssetTransaction(transferTx2);
-                expect(await node.sdk.rpc.chain.containTransaction(hash2)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
             });
         }).timeout(10_000);
 
         describe("Mint three assets ", function() {
-            let aliceAddress: AssetTransferAddress;
-            let bobAddress: AssetTransferAddress;
-            let charlieAddress: AssetTransferAddress;
+            let aliceAddress: AssetAddress;
+            let bobAddress: AssetAddress;
+            let charlieAddress: AssetAddress;
 
             let gold: Asset;
             let silver: Asset;
@@ -2290,7 +2285,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -2371,7 +2366,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 2);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -2449,7 +2444,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 2);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -2479,7 +2474,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -2596,7 +2591,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 3);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -2626,7 +2621,7 @@ describe("orders", function() {
                 await node.signTransactionInput(splitTx, 0);
 
                 const splitHash = await node.sendAssetTransaction(splitTx);
-                expect(await node.sdk.rpc.chain.containTransaction(splitHash))
+                expect(await node.sdk.rpc.chain.containsTransaction(splitHash))
                     .be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(splitHash)).not
                     .null;
@@ -2749,7 +2744,7 @@ describe("orders", function() {
                 await node.signTransactionInput(transferTx, 3);
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -2839,9 +2834,9 @@ describe("orders", function() {
                 });
                 await node.sdk.rpc.devel.startSealing();
                 await node.waitBlockNumber(blockNumber + 1);
-                expect(await node.sdk.rpc.chain.containTransaction(pay.hash()))
+                expect(await node.sdk.rpc.chain.containsTransaction(pay.hash()))
                     .be.true;
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .false;
                 expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                     .null;
@@ -2850,7 +2845,7 @@ describe("orders", function() {
         });
 
         describe("Mint five assets", function() {
-            let addresses: AssetTransferAddress[];
+            let addresses: AssetAddress[];
             let assets: Asset[];
 
             beforeEach(async function() {
@@ -2915,7 +2910,7 @@ describe("orders", function() {
                 );
 
                 const hash = await node.sendAssetTransaction(transferTx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             }).timeout(10_000);
diff --git a/test/src/e2e.long/staking.test.ts b/test/src/e2e.long/staking.test.ts
index 441c2a56fa..b0cd055564 100644
--- a/test/src/e2e.long/staking.test.ts
+++ b/test/src/e2e.long/staking.test.ts
@@ -252,7 +252,7 @@ describe("Staking", function() {
             receiverAddress: validator0Address,
             quantity: 100
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash))) {
             await wait(500);
         }
 
@@ -289,7 +289,7 @@ describe("Staking", function() {
             receiverAddress: validator0Address,
             quantity: 70000
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash))) {
             await wait(500);
         }
 
@@ -325,7 +325,7 @@ describe("Staking", function() {
             receiverAddress: validator0Address,
             quantity: 100
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash))) {
             await wait(500);
         }
 
@@ -365,7 +365,7 @@ describe("Staking", function() {
             receiverAddress: validator0Address,
             quantity: 70000
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash))) {
             await wait(500);
         }
 
@@ -405,7 +405,7 @@ describe("Staking", function() {
         });
 
         while (
-            !(await nodes[0].sdk.rpc.chain.containTransaction(pay1.hash()))
+            !(await nodes[0].sdk.rpc.chain.containsTransaction(pay1.hash()))
         ) {
             await wait(500);
         }
@@ -417,7 +417,7 @@ describe("Staking", function() {
             receiverAddress: validator0Address,
             quantity: 200
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash1))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash1))) {
             await wait(500);
         }
 
@@ -440,7 +440,9 @@ describe("Staking", function() {
         });
         await nodes[0].waitBlockNumber(blockNumber + 1);
 
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(pay.hash()))) {
+        while (
+            !(await nodes[0].sdk.rpc.chain.containsTransaction(pay.hash()))
+        ) {
             await wait(500);
         }
         const err0 = await nodes[0].sdk.rpc.chain.getErrorHint(hash);
@@ -462,7 +464,7 @@ describe("Staking", function() {
             quantity: 50000,
             fee
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash))) {
             await wait(500);
         }
         // faucet: 20000, alice: 20000, bob: 10000, val0: 50000,
@@ -558,7 +560,7 @@ describe("Staking", function() {
             quantity: 50000,
             fee: 1000
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash1))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash1))) {
             await wait(500);
         }
 
@@ -567,7 +569,7 @@ describe("Staking", function() {
             recipient: validator0Address,
             quantity: fee
         })).hash();
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(payHash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(payHash))) {
             await wait(500);
         }
 
@@ -580,7 +582,7 @@ describe("Staking", function() {
             fee
         });
 
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash2))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash2))) {
             await wait(500);
         }
         // faucet: 20000, alice: 20000, bob: 10000, val0: 0 (delegated 50000 to val1), val1: 0
@@ -698,7 +700,7 @@ describe("Staking", function() {
             quantity: 30000,
             fee: 1000
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash1))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash1))) {
             await wait(500);
         }
 
@@ -710,7 +712,7 @@ describe("Staking", function() {
             quantity: 30000,
             fee: 1000
         });
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash2))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash2))) {
             await wait(500);
         }
 
@@ -720,7 +722,7 @@ describe("Staking", function() {
             quantity: fee,
             fee
         })).hash();
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(payHash))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(payHash))) {
             await wait(500);
         }
 
@@ -733,7 +735,7 @@ describe("Staking", function() {
             fee
         });
 
-        while (!(await nodes[0].sdk.rpc.chain.containTransaction(hash3))) {
+        while (!(await nodes[0].sdk.rpc.chain.containsTransaction(hash3))) {
             await wait(500);
         }
         // faucet: 20000, alice: 20000, bob: 10000, val0: 0 (delegated 30000 to val1), val1: 30000
diff --git a/test/src/e2e.long/sync3.test.ts b/test/src/e2e.long/sync3.test.ts
index 2ac2d77171..2a84c88113 100644
--- a/test/src/e2e.long/sync3.test.ts
+++ b/test/src/e2e.long/sync3.test.ts
@@ -51,7 +51,7 @@ describe("sync 3 nodes", function() {
                 const blockNumber = await nodes[0].getBestBlockNumber();
                 const payTx = await nodes[0].sendPayTx();
                 expect(
-                    await nodes[0].sdk.rpc.chain.containTransaction(
+                    await nodes[0].sdk.rpc.chain.containsTransaction(
                         payTx.hash()
                     )
                 ).be.true;
@@ -135,7 +135,7 @@ describe("sync 3 nodes", function() {
         it("It should be synced when the first node created a block", async function() {
             const payTx = await nodes[0].sendPayTx();
             expect(
-                await nodes[0].sdk.rpc.chain.containTransaction(payTx.hash())
+                await nodes[0].sdk.rpc.chain.containsTransaction(payTx.hash())
             ).be.true;
             const transaction = (await nodes[0].sdk.rpc.chain.getTransaction(
                 payTx.hash()
diff --git a/test/src/e2e.long/timelock.test.ts b/test/src/e2e.long/timelock.test.ts
index e41ec99fbb..2e55147d27 100644
--- a/test/src/e2e.long/timelock.test.ts
+++ b/test/src/e2e.long/timelock.test.ts
@@ -16,11 +16,7 @@
 
 import { expect } from "chai";
 import { H256 } from "codechain-primitives/lib";
-import {
-    Asset,
-    AssetTransferAddress,
-    Timelock
-} from "codechain-sdk/lib/core/classes";
+import { Asset, AssetAddress, Timelock } from "codechain-sdk/lib/core/classes";
 import "mocha";
 import { wait } from "../helper/promise";
 import CodeChain from "../helper/spawn";
@@ -239,7 +235,7 @@ describe("Timelock", function() {
     });
 
     describe("Multiple timelocks", async function() {
-        let recipient: AssetTransferAddress;
+        let recipient: AssetAddress;
 
         beforeEach(async function() {
             recipient = await node.createP2PKHAddress();
diff --git a/test/src/e2e.long/transactions.test.ts b/test/src/e2e.long/transactions.test.ts
index 743e3b9bb3..64ba0e9002 100644
--- a/test/src/e2e.long/transactions.test.ts
+++ b/test/src/e2e.long/transactions.test.ts
@@ -21,7 +21,7 @@ chai.use(chaiAsPromised);
 const expect = chai.expect;
 import {
     Asset,
-    AssetTransferAddress,
+    AssetAddress,
     H160,
     H256,
     MintAsset,
@@ -66,7 +66,7 @@ describe("transactions", function() {
                 });
                 const hash = await node.sendAssetTransaction(tx);
                 expect(
-                    await node.sdk.rpc.chain.containTransaction(hash)
+                    await node.sdk.rpc.chain.containsTransaction(hash)
                 ).be.true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -140,7 +140,7 @@ describe("transactions", function() {
             });
 
             const hash = await node.sendAssetTransaction(tx);
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
 
             const assetScheme = await node.sdk.rpc.chain.getAssetSchemeByType(
@@ -161,6 +161,224 @@ describe("transactions", function() {
             );
         });
 
+        it("cannot increase supply with the same transaction", async function() {
+            const amount = 100;
+            const increasedAmount = 300;
+            const asset = await node.mintAsset({
+                supply: amount,
+                registrar: faucetAddress
+            });
+            const recipient = await node.createP2PKHAddress();
+            const tx1 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            const tx2 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            expect(tx1.tracker().value).equal(tx2.tracker().value);
+
+            const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
+
+            const hash1 = await node.sendAssetTransaction(tx1, { seq });
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
+
+            await node.sdk.rpc.devel.stopSealing();
+            const blockNumber = await node.getBestBlockNumber();
+
+            const pay = await node.sendPayTx({ seq: seq + 1, quantity: 1 });
+            const hash2 = await node.sendAssetTransaction(tx2, {
+                seq: seq + 2
+            });
+
+            await node.sdk.rpc.devel.startSealing();
+            await node.waitBlockNumber(blockNumber + 1);
+
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
+                .true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
+                .false;
+            expect(await node.sdk.rpc.chain.getTransaction(hash2)).be.null;
+            expect(await node.sdk.rpc.chain.getErrorHint(hash2)).be.not.null;
+        });
+
+        it("cannot increase supply with the same transaction even the asset is moved", async function() {
+            const amount = 100;
+            const increasedAmount = 300;
+            const asset = await node.mintAsset({
+                supply: amount,
+                registrar: faucetAddress
+            });
+            const recipient = await node.createP2PKHAddress();
+            const tx1 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            const tx2 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            expect(tx1.tracker().value).equal(tx2.tracker().value);
+
+            const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
+
+            const hash1 = await node.sendAssetTransaction(tx1, { seq });
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
+
+            const input = tx1.getMintedAsset().createTransferInput();
+            const transfer = await node.sdk.core.createTransferAssetTransaction(
+                {
+                    inputs: [input],
+                    outputs: [
+                        node.sdk.core.createAssetTransferOutput({
+                            assetType: input.prevOut.assetType,
+                            shardId: input.prevOut.shardId,
+                            quantity: input.prevOut.quantity,
+                            recipient
+                        })
+                    ]
+                }
+            );
+            await node.signTransactionInput(transfer, 0);
+            const transferHash = await node.sdk.rpc.chain.sendSignedTransaction(
+                transfer.sign({
+                    secret: faucetSecret,
+                    fee: 100,
+                    seq: seq + 1
+                })
+            );
+            expect(await node.sdk.rpc.chain.containsTransaction(transferHash))
+                .be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(transferHash)).be.not
+                .null;
+
+            await node.sdk.rpc.devel.stopSealing();
+            const blockNumber = await node.getBestBlockNumber();
+
+            const pay = await node.sendPayTx({ seq: seq + 2, quantity: 1 });
+            const hash2 = await node.sendAssetTransaction(tx2, {
+                seq: seq + 3
+            });
+
+            await node.sdk.rpc.devel.startSealing();
+            await node.waitBlockNumber(blockNumber + 1);
+
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
+                .true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
+                .false;
+            expect(await node.sdk.rpc.chain.getTransaction(hash2)).be.null;
+            expect(await node.sdk.rpc.chain.getErrorHint(hash2)).be.not.null;
+        });
+
+        it("can increase supply again", async function() {
+            const amount = 100;
+            const increasedAmount = 300;
+            const asset = await node.mintAsset({
+                supply: amount,
+                registrar: faucetAddress
+            });
+            const recipient = await node.createP2PKHAddress();
+            const tx1 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            const tx2 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                seq: 1,
+                supply: increasedAmount
+            });
+            expect(tx1.tracker().value).not.equal(tx2.tracker().value);
+
+            const hash1 = await node.sendAssetTransaction(tx1);
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
+
+            const hash2 = await node.sendAssetTransaction(tx2);
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
+        });
+
+        it("can increase supply again after move", async function() {
+            const amount = 100;
+            const increasedAmount = 300;
+            const asset = await node.mintAsset({
+                supply: amount,
+                registrar: faucetAddress
+            });
+            const recipient = await node.createP2PKHAddress();
+            const tx1 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                supply: increasedAmount
+            });
+            const tx2 = node.sdk.core.createIncreaseAssetSupplyTransaction({
+                shardId: asset.shardId,
+                assetType: asset.assetType,
+                recipient,
+                seq: 1,
+                supply: increasedAmount
+            });
+            expect(tx1.tracker().value).not.equal(tx2.tracker().value);
+
+            const hash1 = await node.sendAssetTransaction(tx1);
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
+
+            const input = tx1.getMintedAsset().createTransferInput();
+            const transfer = await node.sdk.core.createTransferAssetTransaction(
+                {
+                    inputs: [input],
+                    outputs: [
+                        node.sdk.core.createAssetTransferOutput({
+                            assetType: input.prevOut.assetType,
+                            shardId: input.prevOut.shardId,
+                            quantity: input.prevOut.quantity,
+                            recipient
+                        })
+                    ]
+                }
+            );
+
+            const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
+
+            await node.signTransactionInput(transfer, 0);
+            const transferHash = await node.sdk.rpc.chain.sendSignedTransaction(
+                transfer.sign({
+                    secret: faucetSecret,
+                    fee: 100,
+                    seq
+                })
+            );
+            expect(await node.sdk.rpc.chain.containsTransaction(transferHash))
+                .be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(transferHash)).be.not
+                .null;
+
+            const blockNumber = await node.getBestBlockNumber();
+            const hash2 = await node.sendAssetTransaction(tx2);
+            await node.waitBlockNumber(blockNumber + 1);
+
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash2)).be.not.null;
+        });
+
         it("cannot increase without registrar", async function() {
             const amount = 100;
             const increasedAmount = 300;
@@ -181,8 +399,8 @@ describe("transactions", function() {
             const hash = await node.sendAssetTransaction(tx, { seq: seq + 1 });
             await node.sdk.rpc.devel.startSealing();
             await node.waitBlockNumber(blockNumber + 1);
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
@@ -216,8 +434,8 @@ describe("transactions", function() {
             const hash = await node.sendTransaction(tx, { account: outsider });
             await node.sdk.rpc.devel.startSealing();
             await node.waitBlockNumber(blockNumber + 1);
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
@@ -257,8 +475,8 @@ describe("transactions", function() {
             const hash = await node.sendAssetTransaction(tx, { seq: seq + 1 });
             await node.sdk.rpc.devel.startSealing();
             await node.waitBlockNumber(blockNumber + 1);
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
@@ -301,7 +519,7 @@ describe("transactions", function() {
 
                 const hash = await node.sendAssetTransaction(tx);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
             });
         });
@@ -441,7 +659,7 @@ describe("transactions", function() {
                 await node.signTransactionInput(tx, 0);
                 await node.signTransactionInput(tx, 1);
                 const hash = await node.sendAssetTransaction(tx);
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
             });
@@ -464,7 +682,7 @@ describe("transactions", function() {
             }
         });
         transferAsset.addInputs(input);
-        const recipient = await node.sdk.key.createAssetTransferAddress();
+        const recipient = await node.sdk.key.createAssetAddress();
         transferAsset.addOutputs({
             quantity: asset.quantity,
             assetType,
@@ -485,8 +703,9 @@ describe("transactions", function() {
         });
         await node.sdk.rpc.devel.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
-        expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
+        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
+            .true;
         expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
         expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
     });
@@ -504,7 +723,7 @@ describe("transactions", function() {
         await node.signTransactionInput(tx1, 0);
         const hash1 = await node.sendAssetTransaction(tx1);
         expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
-        expect(await node.sdk.rpc.chain.containTransaction(hash1)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
 
         const transferredAsset = tx1.getTransferredAsset(0);
         const tx2 = node.sdk.core.createTransferAssetTransaction();
@@ -512,7 +731,7 @@ describe("transactions", function() {
         await node.signTransactionBurn(tx2, 0);
         const hash2 = await node.sendAssetTransaction(tx2);
         expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
-        expect(await node.sdk.rpc.chain.containTransaction(hash2)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.true;
 
         expect(
             await node.sdk.rpc.chain.getAsset(tx2.tracker(), 0, asset.shardId)
@@ -532,7 +751,7 @@ describe("transactions", function() {
         await node.signTransactionInput(tx1, 0);
         const hash = await node.sendAssetTransaction(tx1);
         expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
 
         const tx2 = node.sdk.core.createTransferAssetTransaction();
         const {
@@ -576,7 +795,7 @@ describe("transactions", function() {
         await node.signTransactionInput(tx1, 0);
         const hash1 = await node.sendAssetTransaction(tx1);
         expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
-        expect(await node.sdk.rpc.chain.containTransaction(hash1)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
 
         const transferredAsset = tx1.getTransferredAsset(0);
         const tx2 = node.sdk.core.createTransferAssetTransaction();
@@ -602,8 +821,9 @@ describe("transactions", function() {
         const hash2 = await node.sendAssetTransaction(tx2, { seq: seq + 1 });
         await node.sdk.rpc.devel.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
-        expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be.true;
-        expect(await node.sdk.rpc.chain.containTransaction(hash2)).be.false;
+        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
+            .true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.false;
         expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
         expect(await node.sdk.rpc.chain.getErrorHint(hash2)).not.null;
         expect(
@@ -627,8 +847,9 @@ describe("transactions", function() {
         const hash = await node.sendAssetTransaction(tx, { seq: seq + 1 });
         await node.sdk.rpc.devel.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
-        expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
+        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
+            .true;
         expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
         expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
     });
@@ -656,9 +877,9 @@ describe("transactions", function() {
             const hash = await node.sendAssetTransaction(tx, { seq: seq + 1 });
             await node.sdk.rpc.devel.startSealing();
             await node.waitBlockNumber(blockNumber + 1);
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
@@ -668,7 +889,7 @@ describe("transactions", function() {
             const triviallyFail = Buffer.from([0x03]); // Opcode.FAIL
             const asset = await node.mintAsset({
                 supply: 1,
-                recipient: AssetTransferAddress.fromTypeAndPayload(
+                recipient: AssetAddress.fromTypeAndPayload(
                     0,
                     blake160(triviallyFail),
                     {
@@ -695,9 +916,9 @@ describe("transactions", function() {
             const hash = await node.sendAssetTransaction(tx, { seq: seq + 1 });
             await node.sdk.rpc.devel.startSealing();
             await node.waitBlockNumber(blockNumber + 1);
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
@@ -708,7 +929,7 @@ describe("transactions", function() {
             const triviallySuccess = Buffer.from([Opcode.PUSH, 1]);
             const asset = await node.mintAsset({
                 supply: 1,
-                recipient: AssetTransferAddress.fromTypeAndPayload(
+                recipient: AssetAddress.fromTypeAndPayload(
                     0,
                     blake160(triviallySuccess),
                     {
@@ -730,7 +951,7 @@ describe("transactions", function() {
 
             const hash = await node.sendAssetTransaction(tx);
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         });
 
         it("Cannot transfer when lock script left multiple values in stack", async function() {
@@ -742,7 +963,7 @@ describe("transactions", function() {
             ]);
             const asset = await node.mintAsset({
                 supply: 1,
-                recipient: AssetTransferAddress.fromTypeAndPayload(
+                recipient: AssetAddress.fromTypeAndPayload(
                     0,
                     blake160(leaveMultipleValue),
                     {
@@ -772,9 +993,9 @@ describe("transactions", function() {
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
         });
     });
 
@@ -821,7 +1042,7 @@ describe("transactions", function() {
                 account: approver
             });
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         });
 
         it("nonApprover cannot send a transaction", async function() {
@@ -843,21 +1064,21 @@ describe("transactions", function() {
     describe("Partial signature", function() {
         let assets: Asset[];
         let assetType: H256;
-        let address1: AssetTransferAddress;
-        let address2: AssetTransferAddress;
-        let burnAddress1: AssetTransferAddress;
-        let burnAddress2: AssetTransferAddress;
+        let address1: AssetAddress;
+        let address2: AssetAddress;
+        let burnAddress1: AssetAddress;
+        let burnAddress2: AssetAddress;
         beforeEach(async function() {
-            address1 = await node.sdk.key.createAssetTransferAddress({
+            address1 = await node.sdk.key.createAssetAddress({
                 type: "P2PKH"
             });
-            address2 = await node.sdk.key.createAssetTransferAddress({
+            address2 = await node.sdk.key.createAssetAddress({
                 type: "P2PKH"
             });
-            burnAddress1 = await node.sdk.key.createAssetTransferAddress({
+            burnAddress1 = await node.sdk.key.createAssetAddress({
                 type: "P2PKHBurn"
             });
-            burnAddress2 = await node.sdk.key.createAssetTransferAddress({
+            burnAddress2 = await node.sdk.key.createAssetAddress({
                 type: "P2PKHBurn"
             });
             const mintTx = node.sdk.core.createMintAssetTransaction({
@@ -929,9 +1150,9 @@ describe("transactions", function() {
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
         });
 
         it("Can add burns after signing with the signature tag of single input", async function() {
@@ -951,7 +1172,7 @@ describe("transactions", function() {
             await node.sdk.key.signTransactionBurn(tx, 0);
             const hash = await node.sendAssetTransaction(tx);
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         });
 
         // FIXME: (WIP) It fails
@@ -979,9 +1200,9 @@ describe("transactions", function() {
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
         });
 
         it("Can add inputs after signing with the signature tag of single input", async function() {
@@ -1001,7 +1222,7 @@ describe("transactions", function() {
             await node.sdk.key.signTransactionInput(tx, 1);
             const hash = await node.sendAssetTransaction(tx);
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         });
 
         it("Can't add outputs after signing the signature tag of all outputs", async function() {
@@ -1032,9 +1253,9 @@ describe("transactions", function() {
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.false;
         });
 
         it("Can add outputs after signing the signature tag of some outputs", async function() {
@@ -1064,7 +1285,7 @@ describe("transactions", function() {
             const hash = await node.sendAssetTransaction(tx);
             await node.waitBlockNumber(blockNumber + 1);
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         });
 
         it("Can only change the output protected by signature", async function() {
@@ -1108,9 +1329,10 @@ describe("transactions", function() {
             expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not
                 .null;
             expect(await node.sdk.rpc.chain.getErrorHint(hash1)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(pay.hash())).be
+            expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
                 .true;
-            expect(await node.sdk.rpc.chain.containTransaction(hash1)).be.false;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be
+                .false;
 
             ((tx as any)._transaction.outputs[0]
                 .parameters as any) = address1Param;
@@ -1128,7 +1350,7 @@ describe("transactions", function() {
                 .parameters as any) = address1Param;
             const hash2 = await node.sendAssetTransaction(tx);
             expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
-            expect(await node.sdk.rpc.chain.containTransaction(hash2)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.true;
         });
 
         describe("many outputs", function() {
@@ -1161,8 +1383,8 @@ describe("transactions", function() {
                     const hash = await node.sendAssetTransaction(tx);
                     expect(await node.sdk.rpc.chain.getTransaction(hash)).not
                         .null;
-                    expect(await node.sdk.rpc.chain.containTransaction(hash)).be
-                        .true;
+                    expect(await node.sdk.rpc.chain.containsTransaction(hash))
+                        .be.true;
                 }).timeout(length * 10 + 5_000);
             });
         });
@@ -1194,7 +1416,7 @@ describe("transactions", function() {
                 await node.waitBlockNumber(blockNumber + 1);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
                 expect(
-                    await node.sdk.rpc.chain.containTransaction(hash)
+                    await node.sdk.rpc.chain.containsTransaction(hash)
                 ).be.true;
             });
         });
@@ -1227,7 +1449,7 @@ describe("transactions", function() {
 
     describe("Unwrap CCC", function() {
         describe("Wrap CCC with P2PKHBurnAddress", function() {
-            let recipient: AssetTransferAddress;
+            let recipient: AssetAddress;
             let wrapTransaction: SignedTransaction;
             let quantity: number = 100;
             beforeEach(async function() {
@@ -1254,7 +1476,7 @@ describe("transactions", function() {
                 await node.waitBlockNumber(blockNumber + 1);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
                 expect(
-                    await node.sdk.rpc.chain.containTransaction(hash)
+                    await node.sdk.rpc.chain.containsTransaction(hash)
                 ).be.true;
             });
 
@@ -1269,7 +1491,7 @@ describe("transactions", function() {
                 await node.signTransactionBurn(tx, 0);
                 const hash = await node.sendAssetTransaction(tx);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
-                expect(await node.sdk.rpc.chain.containTransaction(hash)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
                     .true;
                 expect(
                     (await node.sdk.rpc.chain.getBalance(
@@ -1285,7 +1507,7 @@ describe("transactions", function() {
         });
 
         describe("Wrap CCC with P2PKHAddress", function() {
-            let recipient: AssetTransferAddress;
+            let recipient: AssetAddress;
             let wrapTransaction: SignedTransaction;
             let quantity: number = 100;
             beforeEach(async function() {
@@ -1312,7 +1534,7 @@ describe("transactions", function() {
                 await node.waitBlockNumber(blockNumber + 1);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
                 expect(
-                    await node.sdk.rpc.chain.containTransaction(hash)
+                    await node.sdk.rpc.chain.containsTransaction(hash)
                 ).be.true;
             });
 
@@ -1331,7 +1553,7 @@ describe("transactions", function() {
                 await node.signTransactionInput(transferTx, 0);
                 const hash1 = await node.sendAssetTransaction(transferTx);
                 expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
-                expect(await node.sdk.rpc.chain.containTransaction(hash1)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be
                     .true;
 
                 const asset2 = await node.sdk.rpc.chain.getAsset(
@@ -1350,7 +1572,7 @@ describe("transactions", function() {
                 await node.signTransactionBurn(unwrapTx, 0);
                 const hash2 = await node.sendAssetTransaction(unwrapTx);
                 expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
-                expect(await node.sdk.rpc.chain.containTransaction(hash2)).be
+                expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be
                     .true;
 
                 expect(
@@ -1367,7 +1589,7 @@ describe("transactions", function() {
         });
 
         describe("With minted asset (not wrapped CCC)", function() {
-            let recipient: AssetTransferAddress;
+            let recipient: AssetAddress;
             let mintTx: MintAsset;
             const supply: number = 100;
             beforeEach(async function() {
@@ -1384,7 +1606,7 @@ describe("transactions", function() {
                 const hash = await node.sendAssetTransaction(mintTx);
                 expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
                 expect(
-                    await node.sdk.rpc.chain.containTransaction(hash)
+                    await node.sdk.rpc.chain.containsTransaction(hash)
                 ).be.true;
             });
 
@@ -1412,6 +1634,125 @@ describe("transactions", function() {
         });
     });
 
+    describe("ChangeAssetScheme", function() {
+        let mint: MintAsset;
+        beforeEach(async function() {
+            const recipient = await node.createP2PKHAddress();
+            const scheme = node.sdk.core.createAssetScheme({
+                registrar: faucetAddress,
+                shardId: 0,
+                metadata: "",
+                supply: 10
+            });
+            mint = node.sdk.core.createMintAssetTransaction({
+                scheme,
+                recipient
+            });
+            const hash = await node.sendAssetTransaction(mint);
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+        });
+
+        it("Changing asset scheme", async function() {
+            const seq = (await node.sdk.rpc.chain.getSeq(faucetAddress))!;
+            const changeAssetScheme = node.sdk.core.createChangeAssetSchemeTransaction(
+                {
+                    shardId: 0,
+                    assetType: mint.getAssetType(),
+                    scheme: {
+                        metadata: "A",
+                        allowedScriptHashes: []
+                    },
+                    approvals: []
+                }
+            );
+            const signedChangeAssetScheme = changeAssetScheme.sign({
+                secret: faucetSecret,
+                seq,
+                fee: 10
+            });
+            const hash = await node.sdk.rpc.chain.sendSignedTransaction(
+                signedChangeAssetScheme
+            );
+            expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
+        });
+
+        it("Changing asset scheme back to original", async function() {
+            const seq = (await node.sdk.rpc.chain.getSeq(faucetAddress))!;
+            const changeAssetScheme0 = node.sdk.core.createChangeAssetSchemeTransaction(
+                {
+                    shardId: 0,
+                    assetType: mint.getAssetType(),
+                    scheme: {
+                        metadata: "A",
+                        registrar: faucetAddress,
+                        allowedScriptHashes: []
+                    },
+                    approvals: []
+                }
+            );
+            const signedChangeAssetScheme0 = changeAssetScheme0.sign({
+                secret: faucetSecret,
+                seq,
+                fee: 10
+            });
+            const hash0 = await node.sdk.rpc.chain.sendSignedTransaction(
+                signedChangeAssetScheme0
+            );
+            expect(await node.sdk.rpc.chain.getTransaction(hash0)).not.null;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash0)).be.true;
+
+            const changeAssetScheme1 = node.sdk.core.createChangeAssetSchemeTransaction(
+                {
+                    shardId: 0,
+                    assetType: mint.getAssetType(),
+                    scheme: {
+                        metadata: "B",
+                        registrar: faucetAddress,
+                        allowedScriptHashes: []
+                    },
+                    seq: 1,
+                    approvals: []
+                }
+            );
+            const signedChangeAssetScheme1 = changeAssetScheme1.sign({
+                secret: faucetSecret,
+                seq: seq + 1,
+                fee: 10
+            });
+            const hash1 = await node.sdk.rpc.chain.sendSignedTransaction(
+                signedChangeAssetScheme1
+            );
+            expect(await node.sdk.rpc.chain.getTransaction(hash1)).not.null;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash1)).be.true;
+
+            const changeAssetScheme2 = node.sdk.core.createChangeAssetSchemeTransaction(
+                {
+                    shardId: 0,
+                    assetType: mint.getAssetType(),
+                    seq: 2,
+                    scheme: {
+                        metadata: "A",
+                        registrar: faucetAddress,
+                        allowedScriptHashes: []
+                    },
+                    approvals: []
+                }
+            );
+            const signedChangeAssetScheme2 = changeAssetScheme2.sign({
+                secret: faucetSecret,
+                seq: seq + 2,
+                fee: 10
+            });
+            const hash2 = await node.sdk.rpc.chain.sendSignedTransaction(
+                signedChangeAssetScheme2
+            );
+            expect(await node.sdk.rpc.chain.getTransaction(hash2)).not.null;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash2)).be.true;
+        });
+    });
+
     afterEach(function() {
         if (this.currentTest!.state === "failed") {
             node.testFailed(this.currentTest!.fullTitle());
diff --git a/test/src/e2e/chain.test.ts b/test/src/e2e/chain.test.ts
index 93f8c361ba..82ae1eb8ec 100644
--- a/test/src/e2e/chain.test.ts
+++ b/test/src/e2e/chain.test.ts
@@ -153,7 +153,7 @@ describe("chain", function() {
                 seq
             })
         );
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         const signed = await node.sdk.rpc.chain.getTransaction(hash);
         expect(signed).not.null;
         expect(signed!.unsigned).to.deep.equal(tx);
@@ -383,7 +383,7 @@ describe("chain", function() {
         });
         await node.signTransactionInput(tx, 0);
         const hash = await node.sendAssetTransaction(tx);
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
         expect(
             await node.sdk.rpc.chain.isAssetSpent(
diff --git a/test/src/e2e/customAction.test.ts b/test/src/e2e/customAction.test.ts
index 5795fdb6e3..e6e6b396df 100644
--- a/test/src/e2e/customAction.test.ts
+++ b/test/src/e2e/customAction.test.ts
@@ -64,7 +64,7 @@ describe("customAction", function() {
                     })
             );
 
-            expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+            expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
             expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
 
             const actionData = await node.sdk.rpc.engine.getCustomActionData(
diff --git a/test/src/e2e/mempool.test.ts b/test/src/e2e/mempool.test.ts
index 7c04cf7fa9..3f99bef1cc 100644
--- a/test/src/e2e/mempool.test.ts
+++ b/test/src/e2e/mempool.test.ts
@@ -16,11 +16,7 @@
 
 import { expect } from "chai";
 import { H256 } from "codechain-primitives/lib";
-import {
-    Asset,
-    AssetTransferAddress,
-    Timelock
-} from "codechain-sdk/lib/core/classes";
+import { Asset, Timelock } from "codechain-sdk/lib/core/classes";
 import "mocha";
 import { faucetAddress } from "../helper/constants";
 import CodeChain from "../helper/spawn";
diff --git a/test/src/e2e/shard.test.ts b/test/src/e2e/shard.test.ts
index 822491aee0..fcd8e235ab 100644
--- a/test/src/e2e/shard.test.ts
+++ b/test/src/e2e/shard.test.ts
@@ -30,7 +30,7 @@ import CodeChain from "../helper/spawn";
 
 const expect = chai.expect;
 
-describe("CreateShard", function() {
+describe.skip("CreateShard", function() {
     let node: CodeChain;
     before(async function() {
         node = new CodeChain({ argv: ["--allow-create-shard"] });
@@ -57,7 +57,7 @@ describe("CreateShard", function() {
             ])
         ).to.be.null;
         await node.sdk.rpc.chain.sendSignedTransaction(tx);
-        expect(await node.sdk.rpc.chain.containTransaction(tx.hash())).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(tx.hash())).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(tx.hash())).not.null;
         const afterShardId = await node.sdk.rpc.sendRpcRequest(
             "chain_getShardIdByHash",
@@ -179,7 +179,8 @@ describe("CreateShard", function() {
             ])
         ).to.be.null;
         await node.sdk.rpc.chain.sendSignedTransaction(tx1);
-        expect(await node.sdk.rpc.chain.containTransaction(tx1.hash())).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(tx1.hash())).be
+            .true;
         expect(await node.sdk.rpc.chain.getTransaction(tx1.hash())).not.null;
         expect(
             await node.sdk.rpc.sendRpcRequest("chain_getShardIdByHash", [
@@ -198,7 +199,8 @@ describe("CreateShard", function() {
             ])
         ).to.be.null;
         await node.sdk.rpc.chain.sendSignedTransaction(tx2);
-        expect(await node.sdk.rpc.chain.containTransaction(tx2.hash())).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(tx2.hash())).be
+            .true;
         expect(await node.sdk.rpc.chain.getTransaction(tx2.hash())).not.null;
         expect(
             await node.sdk.rpc.sendRpcRequest("chain_getShardIdByHash", [
@@ -304,7 +306,7 @@ describe("CreateShard", function() {
             .sign({ secret: aliceSecret, seq: aliceSeq, fee: 10 });
         await node.sdk.rpc.chain.sendSignedTransaction(mint);
 
-        expect(await node.sdk.rpc.chain.containTransaction(mint.hash())).be
+        expect(await node.sdk.rpc.chain.containsTransaction(mint.hash())).be
             .true;
         expect(await node.sdk.rpc.chain.getTransaction(mint.hash())).not.null;
         const hint = await node.sdk.rpc.chain.getErrorHint(mint.hash());
@@ -400,7 +402,7 @@ describe("CreateShard", function() {
         });
         await node.sdk.rpc.chain.sendSignedTransaction(signedMint2);
 
-        expect(await node.sdk.rpc.chain.containTransaction(signedMint2.hash()))
+        expect(await node.sdk.rpc.chain.containsTransaction(signedMint2.hash()))
             .be.true;
         expect(await node.sdk.rpc.chain.getTransaction(signedMint2.hash())).not
             .null;
@@ -418,7 +420,7 @@ describe("CreateShard", function() {
     });
 });
 
-describe("Cannot create shard without allow-create-shard flag", function() {
+describe.skip("Cannot create shard without allow-create-shard flag", function() {
     let node: CodeChain;
     before(async function() {
         node = new CodeChain();
@@ -444,7 +446,8 @@ describe("Cannot create shard without allow-create-shard flag", function() {
             ])
         ).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.containsTransaction(tx.hash())).be
+            .false;
         expect(await node.sdk.rpc.chain.getTransaction(tx.hash())).be.null;
         const afterShardId = await node.sdk.rpc.sendRpcRequest(
             "chain_getShardIdByHash",
diff --git a/test/src/e2e/storeRemove.test.ts b/test/src/e2e/storeRemove.test.ts
index e1b941155b..58450882c5 100644
--- a/test/src/e2e/storeRemove.test.ts
+++ b/test/src/e2e/storeRemove.test.ts
@@ -55,7 +55,7 @@ describe("store & remove", function() {
             });
 
         const storeHash = await node.sdk.rpc.chain.sendSignedTransaction(store);
-        expect(await node.sdk.rpc.chain.containTransaction(storeHash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(storeHash)).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(storeHash)).not.null;
 
         const text = await node.sdk.rpc.chain.getText(storeHash);
@@ -79,7 +79,8 @@ describe("store & remove", function() {
             remove
         );
         await node.waitBlockNumber(blockNumber + 1);
-        expect(await node.sdk.rpc.chain.containTransaction(removeHash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(removeHash)).be
+            .true;
         expect(await node.sdk.rpc.chain.getTransaction(removeHash)).not.null;
     });
 
diff --git a/test/src/e2e/transactionResult.test.ts b/test/src/e2e/transactionResult.test.ts
index f1988243f5..c9f459b470 100644
--- a/test/src/e2e/transactionResult.test.ts
+++ b/test/src/e2e/transactionResult.test.ts
@@ -53,7 +53,7 @@ describe("transaction result", function() {
                 mint.tracker()
             )
         ).deep.equal([true]);
-        expect(await node.sdk.rpc.chain.containTransaction(signedMint.hash()))
+        expect(await node.sdk.rpc.chain.containsTransaction(signedMint.hash()))
             .be.true;
         expect(await node.sdk.rpc.chain.getTransaction(signedMint.hash())).not
             .null;
@@ -145,18 +145,18 @@ describe("transaction result", function() {
         ).deep.equal([false, true]);
 
         expect(
-            await node.sdk.rpc.chain.containTransaction(signedTransfer1.hash())
+            await node.sdk.rpc.chain.containsTransaction(signedTransfer1.hash())
         ).be.false;
         expect(await node.sdk.rpc.chain.getErrorHint(signedTransfer1.hash()))
             .not.null;
 
-        expect(await node.sdk.rpc.chain.containTransaction(signedMint.hash()))
+        expect(await node.sdk.rpc.chain.containsTransaction(signedMint.hash()))
             .be.true;
         expect(await node.sdk.rpc.chain.getTransaction(signedMint.hash())).not
             .null;
 
         expect(
-            await node.sdk.rpc.chain.containTransaction(signedTransfer2.hash())
+            await node.sdk.rpc.chain.containsTransaction(signedTransfer2.hash())
         ).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(signedTransfer2.hash()))
             .not.null;
diff --git a/test/src/e2e/verification.test.ts b/test/src/e2e/verification.test.ts
index 24a056b854..aa215b3825 100644
--- a/test/src/e2e/verification.test.ts
+++ b/test/src/e2e/verification.test.ts
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 import { expect } from "chai";
-import { AssetTransferAddress, PlatformAddress } from "codechain-primitives";
+import { AssetAddress, PlatformAddress } from "codechain-primitives";
 import {
     AssetScheme,
     AssetTransferInput,
@@ -148,12 +148,14 @@ describe("solo - 1 node", function() {
             { actionType: 0x13, actionLength: 12 },
             { actionType: 0x14, actionLength: 8 }, // TransferAsset
             { actionType: 0x14, actionLength: 10 },
-            { actionType: 0x15, actionLength: 8 }, // ChangeAssetScheme
-            { actionType: 0x15, actionLength: 10 },
+            { actionType: 0x15, actionLength: 9 }, // ChangeAssetScheme
+            { actionType: 0x15, actionLength: 11 },
             { actionType: 0x16, actionLength: 11 }, // ComposeAsset
             { actionType: 0x16, actionLength: 13 },
             { actionType: 0x17, actionLength: 4 }, // DecomposeAsset
-            { actionType: 0x17, actionLength: 6 }
+            { actionType: 0x17, actionLength: 6 },
+            { actionType: 0x18, actionLength: 8 }, // IncreaseAssetSupply
+            { actionType: 0x18, actionLength: 10 }
         ].forEach(function(params: {
             actionType: number;
             actionLength: number;
@@ -200,7 +202,7 @@ describe("solo - 1 node", function() {
         let scheme: AssetScheme;
         let input: AssetTransferInput;
         let output: AssetTransferOutput;
-        let recipient: AssetTransferAddress;
+        let recipient: AssetAddress;
 
         before(async function() {
             recipient = await node.createP2PKHAddress();
diff --git a/test/src/e2e/wrap.test.ts b/test/src/e2e/wrap.test.ts
index 7e7757a0c0..c89ef70cc5 100644
--- a/test/src/e2e/wrap.test.ts
+++ b/test/src/e2e/wrap.test.ts
@@ -55,7 +55,7 @@ describe("WrapCCC", function() {
 
         await node.sdk.rpc.chain.sendSignedTransaction(signedWrapCCC);
         expect(
-            await node.sdk.rpc.chain.containTransaction(signedWrapCCC.hash())
+            await node.sdk.rpc.chain.containsTransaction(signedWrapCCC.hash())
         ).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(signedWrapCCC.hash()))
             .not.null;
@@ -83,7 +83,7 @@ describe("WrapCCC", function() {
             fee: 10
         });
         const hash = await node.sdk.rpc.chain.sendSignedTransaction(signedBurn);
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
 
         const schemeAfterBurn = (await node.sdk.rpc.chain.getAssetSchemeByType(
@@ -120,7 +120,7 @@ describe("WrapCCC", function() {
         const hash = await node.sdk.rpc.chain.sendSignedTransaction(
             signedWrapCCC
         );
-        expect(await node.sdk.rpc.chain.containTransaction(hash)).be.true;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
         expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
 
         const changeAssetScheme = node.sdk.core.createChangeAssetSchemeTransaction(
diff --git a/test/src/helper/spawn.ts b/test/src/helper/spawn.ts
index 1f72a36c10..a97aa17e7c 100644
--- a/test/src/helper/spawn.ts
+++ b/test/src/helper/spawn.ts
@@ -18,7 +18,7 @@ import { ChildProcess, spawn } from "child_process";
 import { SDK } from "codechain-sdk";
 import {
     Asset,
-    AssetTransferAddress,
+    AssetAddress,
     AssetTransferInput,
     ComposeAsset,
     DecomposeAsset,
@@ -422,7 +422,7 @@ export default class CodeChain {
 
     public async mintAsset(params: {
         supply: U64 | number;
-        recipient?: string | AssetTransferAddress;
+        recipient?: string | AssetAddress;
         secret?: string;
         seq?: number;
         metadata?: string;
diff --git a/test/src/tendermint.test/local.ts b/test/src/tendermint.test/local.ts
index fd452c6b2c..a2afb874aa 100644
--- a/test/src/tendermint.test/local.ts
+++ b/test/src/tendermint.test/local.ts
@@ -102,7 +102,7 @@ import CodeChain from "../helper/spawn";
         let flag = true;
         for (let i = 0; i < 4; i++) {
             const hash = transactions[numTransactions - 1].hash();
-            const result = await nodes[i].sdk.rpc.chain.containTransaction(
+            const result = await nodes[i].sdk.rpc.chain.containsTransaction(
                 hash
             );
 
diff --git a/test/src/tendermint.test/remote.ts b/test/src/tendermint.test/remote.ts
index d508cd5899..52244adc1a 100644
--- a/test/src/tendermint.test/remote.ts
+++ b/test/src/tendermint.test/remote.ts
@@ -60,7 +60,7 @@ import CodeChain from "../helper/spawn";
 
     while (true) {
         const hash = transactions[numTransactions - 1].hash();
-        const result = await node.sdk.rpc.chain.containTransaction(hash);
+        const result = await node.sdk.rpc.chain.containsTransaction(hash);
         console.log(`Node result: ${result}`);
         if (result) {
             break;
diff --git a/test/yarn.lock b/test/yarn.lock
index 2e3ab216c6..fd96a7b7b2 100644
--- a/test/yarn.lock
+++ b/test/yarn.lock
@@ -522,10 +522,10 @@ codechain-keystore@^0.6.0:
     lowdb-session-storage-adapter "^1.0.0"
     uuid "^3.3.2"
 
-codechain-primitives@^0.3.0:
-  version "0.3.5"
-  resolved "https://registry.yarnpkg.com/codechain-primitives/-/codechain-primitives-0.3.5.tgz#13bb72c341ea27a4640baee791609c28db18c29e"
-  integrity sha512-/S3QPobB5xLEKQsFu+uYiUofl5oIAQA0/BQsBiGwtzrrNsjD93QMLWQntysaaEF72gTBMsqEFDTjGP0u8hDviA==
+codechain-primitives@0.5.0, codechain-primitives@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/codechain-primitives/-/codechain-primitives-0.5.0.tgz#dd8fe3bfe4a9972300e6972a06d6aee594b38732"
+  integrity sha512-wN3uwZ9Bb5XNF5po2YVMtfJ2DJ7ds6dllq2IZpkjqSoXADvDG5qU9nxTocueo7m1l7IMkq4F510F9ViKaTbkKA==
   dependencies:
     bignumber.js "^7.2.1"
     blakejs "^1.1.0"
@@ -538,10 +538,10 @@ codechain-primitives@^0.3.0:
     ripemd160 "^2.0.2"
     rlp "^2.1.0"
 
-codechain-primitives@^0.4.6, codechain-primitives@^0.4.8:
-  version "0.4.8"
-  resolved "https://registry.yarnpkg.com/codechain-primitives/-/codechain-primitives-0.4.8.tgz#5206ebcf92c0d225924931493b05c384d48fc63e"
-  integrity sha512-yEPinaK3y0pdMgmp7EjYkru2FL0XjXZ6sjdT4KmlGchqEuLUJsZ3V+MOyGlumdW7TSR7gpHl5+szyRPxUndMrQ==
+codechain-primitives@^0.3.0:
+  version "0.3.5"
+  resolved "https://registry.yarnpkg.com/codechain-primitives/-/codechain-primitives-0.3.5.tgz#13bb72c341ea27a4640baee791609c28db18c29e"
+  integrity sha512-/S3QPobB5xLEKQsFu+uYiUofl5oIAQA0/BQsBiGwtzrrNsjD93QMLWQntysaaEF72gTBMsqEFDTjGP0u8hDviA==
   dependencies:
     bignumber.js "^7.2.1"
     blakejs "^1.1.0"
@@ -554,13 +554,13 @@ codechain-primitives@^0.4.6, codechain-primitives@^0.4.8:
     ripemd160 "^2.0.2"
     rlp "^2.1.0"
 
-"codechain-sdk@https://github.com/sgkim126/codechain-sdk-js.git#result-lib":
-  version "0.5.1"
-  resolved "https://github.com/sgkim126/codechain-sdk-js.git#4ed32333c517d656b41b1bb904690d7b27a2aa84"
+"codechain-sdk@https://github.com/sgkim126/codechain-sdk-js.git#seq-lib":
+  version "1.0.1"
+  resolved "https://github.com/sgkim126/codechain-sdk-js.git#6228c69f9fabaab2cf1041be53ab565076773d05"
   dependencies:
     buffer "5.1.0"
     codechain-keystore "^0.6.0"
-    codechain-primitives "^0.4.6"
+    codechain-primitives "0.5.0"
     jayson "^2.0.6"
     lodash "^4.17.10"
     node-fetch "^2.1.2"
diff --git a/types/src/errors/runtime_error.rs b/types/src/errors/runtime_error.rs
index 0315a2cdfa..c4c1423f10 100644
--- a/types/src/errors/runtime_error.rs
+++ b/types/src/errors/runtime_error.rs
@@ -42,6 +42,12 @@ pub enum Error {
         asset_type: H160,
         shard_id: ShardId,
     },
+    InvalidSeqOfAssetScheme {
+        asset_type: H160,
+        shard_id: ShardId,
+        expected: usize,
+        actual: usize,
+    },
     AssetSupplyOverflow,
     CannotBurnRegulatedAsset,
     CannotComposeRegulatedAsset,
@@ -117,6 +123,7 @@ const ERROR_ID_ASSET_SCHEME_NOT_FOUND: u8 = 3;
 const ERROR_ID_CANNOT_BURN_REGULATED_ASSET: u8 = 4;
 const ERROR_ID_CANNOT_COMPOSE_REGULATED_ASSET: u8 = 5;
 const ERROR_ID_FAILED_TO_UNLOCK: u8 = 6;
+const ERROR_ID_INVALID_SEQ_OF_ASSET_SCHEME: u8 = 7;
 const ERROR_ID_INSUFFICIENT_BALANCE: u8 = 8;
 const ERROR_ID_INSUFFICIENT_PERMISSION: u8 = 9;
 const ERROR_ID_INVALID_ASSET_QUANTITY: u8 = 10;
@@ -150,6 +157,7 @@ impl TaggedRlp for RlpHelper {
             ERROR_ID_ASSET_NOT_FOUND => 4,
             ERROR_ID_ASSET_SCHEME_DUPLICATED => 3,
             ERROR_ID_ASSET_SCHEME_NOT_FOUND => 3,
+            ERROR_ID_INVALID_SEQ_OF_ASSET_SCHEME => 5,
             ERROR_ID_ASSET_SUPPLY_OVERFLOW => 1,
             ERROR_ID_CANNOT_BURN_REGULATED_ASSET => 1,
             ERROR_ID_CANNOT_COMPOSE_REGULATED_ASSET => 1,
@@ -197,6 +205,16 @@ impl Encodable for Error {
                 asset_type,
                 shard_id,
             } => RlpHelper::new_tagged_list(s, ERROR_ID_ASSET_SCHEME_NOT_FOUND).append(asset_type).append(shard_id),
+            Error::InvalidSeqOfAssetScheme {
+                asset_type,
+                shard_id,
+                expected,
+                actual,
+            } => RlpHelper::new_tagged_list(s, ERROR_ID_INVALID_SEQ_OF_ASSET_SCHEME)
+                .append(asset_type)
+                .append(shard_id)
+                .append(expected)
+                .append(actual),
             Error::AssetSupplyOverflow => RlpHelper::new_tagged_list(s, ERROR_ID_ASSET_SUPPLY_OVERFLOW),
             Error::CannotBurnRegulatedAsset => RlpHelper::new_tagged_list(s, ERROR_ID_CANNOT_BURN_REGULATED_ASSET),
             Error::CannotComposeRegulatedAsset => {
@@ -307,6 +325,12 @@ impl Decodable for Error {
                 asset_type: rlp.val_at(1)?,
                 shard_id: rlp.val_at(2)?,
             },
+            ERROR_ID_INVALID_SEQ_OF_ASSET_SCHEME => Error::InvalidSeqOfAssetScheme {
+                asset_type: rlp.val_at(1)?,
+                shard_id: rlp.val_at(2)?,
+                expected: rlp.val_at(3)?,
+                actual: rlp.val_at(4)?,
+            },
             ERROR_ID_ASSET_SUPPLY_OVERFLOW => Error::AssetSupplyOverflow,
             ERROR_ID_CANNOT_BURN_REGULATED_ASSET => Error::CannotBurnRegulatedAsset,
             ERROR_ID_CANNOT_COMPOSE_REGULATED_ASSET => Error::CannotComposeRegulatedAsset,
@@ -379,6 +403,12 @@ impl Display for Error {
                 asset_type,
                 shard_id,
             } => write!(f, "Asset scheme not found: {}:{}", asset_type, shard_id),
+            Error::InvalidSeqOfAssetScheme {
+                asset_type,
+                shard_id,
+                expected,
+                actual,
+            } => write!(f, "Already used seq of asset scheme {}:{}. expected: {}, actual: {}", asset_type, shard_id, expected, actual),
             Error::AssetSupplyOverflow => write!(f, "Asset supply should not be overflowed"),
             Error::CannotBurnRegulatedAsset => write!(f, "Cannot burn the regulated asset"),
             Error::CannotComposeRegulatedAsset => write!(f, "Cannot compose the regulated asset"),
diff --git a/types/src/transaction/action.rs b/types/src/transaction/action.rs
index a4c7915885..8211419d97 100644
--- a/types/src/transaction/action.rs
+++ b/types/src/transaction/action.rs
@@ -69,6 +69,7 @@ pub enum Action {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: usize,
         metadata: String,
         approver: Option<Address>,
         registrar: Option<Address>,
@@ -79,6 +80,7 @@ pub enum Action {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: usize,
         output: Box<AssetMintOutput>,
         approvals: Vec<Signature>,
     },
@@ -470,6 +472,7 @@ impl From<Action> for Option<ShardTransaction> {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
@@ -479,6 +482,7 @@ impl From<Action> for Option<ShardTransaction> {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
@@ -488,12 +492,14 @@ impl From<Action> for Option<ShardTransaction> {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output,
                 ..
             } => Some(ShardTransaction::IncreaseAssetSupply {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output: *output,
             }),
             Action::ComposeAsset {
@@ -591,17 +597,19 @@ impl Encodable for Action {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
                 allowed_script_hashes,
                 approvals,
             } => {
-                s.begin_list(9)
+                s.begin_list(10)
                     .append(&CHANGE_ASSET_SCHEME)
                     .append(network_id)
                     .append(shard_id)
                     .append(asset_type)
+                    .append(seq)
                     .append(metadata)
                     .append(approver)
                     .append(registrar)
@@ -612,14 +620,16 @@ impl Encodable for Action {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output,
                 approvals,
             } => {
-                s.begin_list(8)
+                s.begin_list(9)
                     .append(&INCREASE_ASSET_SUPPLY)
                     .append(network_id)
                     .append(shard_id)
                     .append(asset_type)
+                    .append(seq)
                     .append(&output.lock_script_hash)
                     .append(&output.parameters)
                     .append(&output.supply)
@@ -806,41 +816,43 @@ impl Decodable for Action {
             }
             CHANGE_ASSET_SCHEME => {
                 let item_count = rlp.item_count()?;
-                if item_count != 9 {
+                if item_count != 10 {
                     return Err(DecoderError::RlpIncorrectListLen {
                         got: item_count,
-                        expected: 9,
+                        expected: 10,
                     })
                 }
                 Ok(Action::ChangeAssetScheme {
                     network_id: rlp.val_at(1)?,
                     shard_id: rlp.val_at(2)?,
                     asset_type: rlp.val_at(3)?,
-                    metadata: rlp.val_at(4)?,
-                    approver: rlp.val_at(5)?,
-                    registrar: rlp.val_at(6)?,
-                    allowed_script_hashes: rlp.list_at(7)?,
-                    approvals: rlp.list_at(8)?,
+                    seq: rlp.val_at(4)?,
+                    metadata: rlp.val_at(5)?,
+                    approver: rlp.val_at(6)?,
+                    registrar: rlp.val_at(7)?,
+                    allowed_script_hashes: rlp.list_at(8)?,
+                    approvals: rlp.list_at(9)?,
                 })
             }
             INCREASE_ASSET_SUPPLY => {
                 let item_count = rlp.item_count()?;
-                if item_count != 8 {
+                if item_count != 9 {
                     return Err(DecoderError::RlpIncorrectListLen {
                         got: item_count,
-                        expected: 8,
+                        expected: 9,
                     })
                 }
                 Ok(Action::IncreaseAssetSupply {
                     network_id: rlp.val_at(1)?,
                     shard_id: rlp.val_at(2)?,
                     asset_type: rlp.val_at(3)?,
+                    seq: rlp.val_at(4)?,
                     output: Box::new(AssetMintOutput {
-                        lock_script_hash: rlp.val_at(4)?,
-                        parameters: rlp.val_at(5)?,
-                        supply: rlp.val_at(6)?,
+                        lock_script_hash: rlp.val_at(5)?,
+                        parameters: rlp.val_at(6)?,
+                        supply: rlp.val_at(7)?,
                     }),
-                    approvals: rlp.list_at(7)?,
+                    approvals: rlp.list_at(8)?,
                 })
             }
             COMPOSE_ASSET => {
@@ -1336,6 +1348,7 @@ mod tests {
             network_id: "ab".into(),
             shard_id: 1,
             asset_type: H160::random(),
+            seq: 0,
             metadata: "some asset scheme metadata".to_string(),
             approver: Some(Address::random()),
             registrar: Some(Address::random()),
diff --git a/types/src/transaction/shard.rs b/types/src/transaction/shard.rs
index 22a6fa64b5..7e7b52bedd 100644
--- a/types/src/transaction/shard.rs
+++ b/types/src/transaction/shard.rs
@@ -49,6 +49,7 @@ pub enum ShardTransaction {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: usize,
         metadata: String,
         approver: Option<Address>,
         registrar: Option<Address>,
@@ -58,6 +59,7 @@ pub enum ShardTransaction {
         network_id: NetworkId,
         shard_id: ShardId,
         asset_type: H160,
+        seq: usize,
         output: AssetMintOutput,
     },
     ComposeAsset {
@@ -523,38 +525,40 @@ impl Decodable for ShardTransaction {
             }
             ASSET_SCHEME_CHANGE_ID => {
                 let item_count = d.item_count()?;
-                if item_count != 8 {
+                if item_count != 9 {
                     return Err(DecoderError::RlpIncorrectListLen {
                         got: item_count,
-                        expected: 8,
+                        expected: 9,
                     })
                 }
                 Ok(ShardTransaction::ChangeAssetScheme {
                     network_id: d.val_at(1)?,
                     shard_id: d.val_at(2)?,
                     asset_type: d.val_at(3)?,
-                    metadata: d.val_at(4)?,
-                    approver: d.val_at(5)?,
-                    registrar: d.val_at(6)?,
-                    allowed_script_hashes: d.list_at(7)?,
+                    seq: d.val_at(4)?,
+                    metadata: d.val_at(5)?,
+                    approver: d.val_at(6)?,
+                    registrar: d.val_at(7)?,
+                    allowed_script_hashes: d.list_at(8)?,
                 })
             }
             ASSET_INCREASE_SUPPLY_ID => {
                 let item_count = d.item_count()?;
-                if item_count != 7 {
+                if item_count != 8 {
                     return Err(DecoderError::RlpIncorrectListLen {
                         got: item_count,
-                        expected: 7,
+                        expected: 8,
                     })
                 }
                 Ok(ShardTransaction::IncreaseAssetSupply {
                     network_id: d.val_at(1)?,
                     shard_id: d.val_at(2)?,
                     asset_type: d.val_at(3)?,
+                    seq: d.val_at(4)?,
                     output: AssetMintOutput {
-                        lock_script_hash: d.val_at(4)?,
-                        parameters: d.val_at(5)?,
-                        supply: d.val_at(6)?,
+                        lock_script_hash: d.val_at(5)?,
+                        parameters: d.val_at(6)?,
+                        supply: d.val_at(7)?,
                     },
                 })
             }
@@ -662,16 +666,18 @@ impl Encodable for ShardTransaction {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 metadata,
                 approver,
                 registrar,
                 allowed_script_hashes,
             } => {
-                s.begin_list(8)
+                s.begin_list(9)
                     .append(&ASSET_SCHEME_CHANGE_ID)
                     .append(network_id)
                     .append(shard_id)
                     .append(asset_type)
+                    .append(seq)
                     .append(metadata)
                     .append(approver)
                     .append(registrar)
@@ -681,6 +687,7 @@ impl Encodable for ShardTransaction {
                 network_id,
                 shard_id,
                 asset_type,
+                seq,
                 output:
                     AssetMintOutput {
                         lock_script_hash,
@@ -688,11 +695,12 @@ impl Encodable for ShardTransaction {
                         supply,
                     },
             } => {
-                s.begin_list(7)
+                s.begin_list(8)
                     .append(&ASSET_INCREASE_SUPPLY_ID)
                     .append(network_id)
                     .append(shard_id)
                     .append(asset_type)
+                    .append(seq)
                     .append(lock_script_hash)
                     .append(parameters)
                     .append(supply);