Make chain ID available to contracts

contracts/host_fn/src/lib.rs

@@ -64,6 +64,10 @@ impl HostFnTest {
         rusk_abi::verify_bls(msg, pk, sig)
     }
 
+    pub fn chain_id(&self) -> u8 {
+        rusk_abi::chain_id()
+    }
+
     pub fn block_height(&self) -> u64 {
         rusk_abi::block_height()
     }
@@ -108,6 +112,11 @@ unsafe fn verify_bls(arg_len: u32) -> u32 {
     })
 }
 
+#[no_mangle]
+unsafe fn chain_id(arg_len: u32) -> u32 {
+    rusk_abi::wrap_call(arg_len, |_: ()| STATE.chain_id())
+}
+
 #[no_mangle]
 unsafe fn block_height(arg_len: u32) -> u32 {
     rusk_abi::wrap_call(arg_len, |_: ()| STATE.block_height())

contracts/license/tests/license.rs

@@ -41,6 +41,7 @@ const LICENSE_CONTRACT_ID: ContractId = {
 
 const POINT_LIMIT: u64 = 0x10000000;
 const TEST_OWNER: [u8; 32] = [0; 32];
+const CHAIN_ID: u8 = 0xFA;
 const USER_ATTRIBUTES: u64 = 545072475273;
 
 static LABEL: &[u8] = b"dusk-network";
@@ -66,7 +67,7 @@ fn initialize() -> Session {
         "../../../target/dusk/wasm32-unknown-unknown/release/license_contract.wasm"
     );
 
-    let mut session = rusk_abi::new_genesis_session(&vm);
+    let mut session = rusk_abi::new_genesis_session(&vm, CHAIN_ID);
 
     session
         .deploy(

contracts/stake/src/state.rs

@@ -72,6 +72,10 @@ impl StakeState {
         let nonce = stake.nonce();
         let signature = *stake.signature();
 
+        if stake.chain_id() != self.chain_id() {
+            panic!("The stake must target the correct chain");
+        }
+
         let loaded_stake = self.load_or_create_stake_mut(&account);
 
         // ensure the stake is at least the minimum and that there isn't an
@@ -456,6 +460,10 @@ impl StakeState {
         }
     }
 
+    fn chain_id(&self) -> u8 {
+        rusk_abi::chain_id()
+    }
+
     fn deduct_contract_balance(amount: u64) {
         // Update the module balance to reflect the change in the amount
         // withdrawable from the contract

contracts/stake/tests/common/init.rs

@@ -20,6 +20,7 @@ use rusk_abi::{ContractData, Session, VM};
 use crate::common::utils::update_root;
 
 const OWNER: [u8; 32] = [0; 32];
+pub const CHAIN_ID: u8 = 0xFA;
 const POINT_LIMIT: u64 = 0x100_000_000;
 
 /// Instantiate the virtual machine with the transfer contract deployed, with a
@@ -37,7 +38,7 @@ pub fn instantiate<Rng: RngCore + CryptoRng>(
         "../../../../target/dusk/wasm32-unknown-unknown/release/stake_contract.wasm"
     );
 
-    let mut session = rusk_abi::new_genesis_session(vm);
+    let mut session = rusk_abi::new_genesis_session(vm, CHAIN_ID);
 
     session
         .deploy(
@@ -81,6 +82,6 @@ pub fn instantiate<Rng: RngCore + CryptoRng>(
     // sets the block height for all subsequent operations to 1
     let base = session.commit().expect("Committing should succeed");
 
-    rusk_abi::new_session(vm, base, 1)
+    rusk_abi::new_session(vm, base, CHAIN_ID, 1)
         .expect("Instantiating new session should succeed")
 }

contracts/stake/tests/common/utils.rs

@@ -87,6 +87,12 @@ pub fn opening(
         .map(|r| r.data)
 }
 
+pub fn chain_id(session: &mut Session) -> Result<u8, PiecrustError> {
+    session
+        .call(TRANSFER_CONTRACT, "chain_id", &(), POINT_LIMIT)
+        .map(|r| r.data)
+}
+
 pub fn filter_notes_owned_by<I: IntoIterator<Item = Note>>(
     vk: PhoenixViewKey,
     iter: I,
@@ -179,6 +185,9 @@ pub fn create_transaction<const I: usize>(
         inputs.push((note.clone(), opening));
     }
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     PhoenixTransaction::new::<StdRng, LocalProver>(
         rng,
         sender_sk,
@@ -191,6 +200,7 @@ pub fn create_transaction<const I: usize>(
         deposit,
         gas_limit,
         gas_price,
+        chain_id,
         exec.map(Into::into),
     )
     .expect("creating the creation shouldn't fail")

contracts/stake/tests/stake.rs

@@ -26,7 +26,7 @@ use execution_core::{
 };
 
 use crate::common::assert::assert_event;
-use crate::common::init::instantiate;
+use crate::common::init::{instantiate, CHAIN_ID};
 use crate::common::utils::*;
 
 const GENESIS_VALUE: u64 = dusk(1_000_000.0);
@@ -71,8 +71,11 @@ fn stake_withdraw_unstake() {
     let input_note_pos = 0;
     let deposit = INITIAL_STAKE;
 
+    let chain_id =
+        chain_id(&mut session).expect("Getting the chain ID should succeed");
+
     // Fashion a Stake struct
-    let stake = Stake::new(&stake_sk, deposit, 1);
+    let stake = Stake::new(&stake_sk, deposit, 1, chain_id);
     let stake_bytes = rkyv::to_bytes::<_, 1024>(&stake)
         .expect("Should serialize Stake correctly")
         .to_vec();
@@ -230,7 +233,7 @@ fn stake_withdraw_unstake() {
     // set different block height so that the new notes are easily located and
     // filtered
     let base = session.commit().expect("Committing should succeed");
-    let mut session = rusk_abi::new_session(vm, base, 2)
+    let mut session = rusk_abi::new_session(vm, base, CHAIN_ID, 2)
         .expect("Instantiating new session should succeed");
 
     let receipt =
@@ -344,7 +347,7 @@ fn stake_withdraw_unstake() {
     // filtered
     // sets the block height for all subsequent operations to 1
     let base = session.commit().expect("Committing should succeed");
-    let mut session = rusk_abi::new_session(vm, base, 3)
+    let mut session = rusk_abi::new_session(vm, base, CHAIN_ID, 3)
         .expect("Instantiating new session should succeed");
 
     let receipt =

contracts/transfer/src/lib.rs

@@ -77,6 +77,11 @@ unsafe fn num_notes(arg_len: u32) -> u32 {
     rusk_abi::wrap_call(arg_len, |_: ()| STATE.num_notes())
 }
 
+#[no_mangle]
+unsafe fn chain_id(arg_len: u32) -> u32 {
+    rusk_abi::wrap_call(arg_len, |_: ()| STATE.chain_id())
+}
+
 // "Feeder" queries
 
 #[no_mangle]

contracts/transfer/src/state.rs

@@ -342,6 +342,10 @@ impl TransferState {
         transitory::put_transaction(tx);
         let phoenix_tx = transitory::unwrap_phoenix_tx();
 
+        if phoenix_tx.chain_id() != self.chain_id() {
+            panic!("The tx must target the correct chain");
+        }
+
         // panic if the root is invalid
         if !self.root_exists(phoenix_tx.root()) {
             panic!("Root not found in the state!");
@@ -398,6 +402,10 @@ impl TransferState {
         transitory::put_transaction(tx);
         let moonlight_tx = transitory::unwrap_moonlight_tx();
 
+        if moonlight_tx.chain_id() != self.chain_id() {
+            panic!("The tx must target the correct chain");
+        }
+
         // check the signature is valid and made by `from`
         if !rusk_abi::verify_bls(
             moonlight_tx.signature_message(),
@@ -676,6 +684,10 @@ impl TransferState {
         let block_height = rusk_abi::block_height();
         self.push_note(block_height, note)
     }
+
+    pub fn chain_id(&self) -> u8 {
+        rusk_abi::chain_id()
+    }
 }
 
 fn verify_tx_proof(tx: &PhoenixTransaction) -> bool {

contracts/transfer/tests/common/utils.rs

@@ -112,6 +112,12 @@ pub fn opening(
         .map(|r| r.data)
 }
 
+pub fn chain_id(session: &mut Session) -> Result<u8, PiecrustError> {
+    session
+        .call(TRANSFER_CONTRACT, "chain_id", &(), GAS_LIMIT)
+        .map(|r| r.data)
+}
+
 /// Executes a transaction.
 /// Returns result containing gas spent.
 pub fn execute(
@@ -214,6 +220,9 @@ pub fn create_phoenix_transaction<const I: usize>(
         inputs.push((note.clone(), opening));
     }
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     PhoenixTransaction::new::<StdRng, LocalProver>(
         rng,
         sender_sk,
@@ -226,6 +235,7 @@ pub fn create_phoenix_transaction<const I: usize>(
         deposit,
         gas_limit,
         gas_price,
+        chain_id,
         exec.map(Into::into),
     )
     .expect("creating the creation shouldn't fail")

contracts/transfer/tests/transfer.rs

@@ -7,7 +7,7 @@
 pub mod common;
 
 use crate::common::utils::{
-    account, contract_balance, create_phoenix_transaction, execute,
+    account, chain_id, contract_balance, create_phoenix_transaction, execute,
     filter_notes_owned_by, leaves_from_height, leaves_from_pos, num_notes,
     owned_notes_value, update_root,
 };
@@ -53,6 +53,7 @@ const BOB_ID: ContractId = {
 };
 
 const OWNER: [u8; 32] = [0; 32];
+const CHAIN_ID: u8 = 0xFA;
 
 /// Instantiate the virtual machine with the transfer contract deployed, with a
 /// single note carrying the `GENESIS_VALUE` owned by the given public key.
@@ -72,7 +73,7 @@ fn instantiate<Rng: RngCore + CryptoRng>(
         "../../../target/dusk/wasm32-unknown-unknown/release/alice.wasm"
     );
 
-    let mut session = rusk_abi::new_genesis_session(vm);
+    let mut session = rusk_abi::new_genesis_session(vm, CHAIN_ID);
 
     session
         .deploy(
@@ -137,7 +138,7 @@ fn instantiate<Rng: RngCore + CryptoRng>(
     // sets the block height for all subsequent operations to 1
     let base = session.commit().expect("Committing should succeed");
 
-    rusk_abi::new_session(vm, base, 1)
+    rusk_abi::new_session(vm, base, CHAIN_ID, 1)
         .expect("Instantiating new session should succeed")
 }
 
@@ -265,6 +266,9 @@ fn moonlight_transfer() {
         "The receiver account should be empty"
     );
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     let transaction = MoonlightTransaction::new(
         &moonlight_sender_sk,
         Some(moonlight_receiver_pk),
@@ -273,6 +277,7 @@ fn moonlight_transfer() {
         GAS_LIMIT,
         LUX,
         sender_account.nonce + 1,
+        chain_id,
         None::<ContractExec>,
     );
 
@@ -396,6 +401,9 @@ fn moonlight_alice_ping() {
         "The account should have the genesis value"
     );
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     let transaction = MoonlightTransaction::new(
         &moonlight_sk,
         None,
@@ -404,6 +412,7 @@ fn moonlight_alice_ping() {
         GAS_LIMIT,
         LUX,
         acc.nonce + 1,
+        chain_id,
         contract_call,
     );
 
@@ -750,6 +759,9 @@ fn moonlight_to_phoenix_swap() {
             .to_vec(),
     };
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     let tx = MoonlightTransaction::new(
         &moonlight_sk,
         None,
@@ -758,6 +770,7 @@ fn moonlight_to_phoenix_swap() {
         GAS_LIMIT,
         LUX,
         nonce,
+        chain_id,
         Some(contract_call),
     );
 
@@ -849,6 +862,9 @@ fn swap_wrong_contract_targeted() {
             .to_vec(),
     };
 
+    let chain_id =
+        chain_id(session).expect("Getting the chain ID should succeed");
+
     let tx = MoonlightTransaction::new(
         &moonlight_sk,
         None,
@@ -857,6 +873,7 @@ fn swap_wrong_contract_targeted() {
         GAS_LIMIT,
         LUX,
         nonce,
+        chain_id,
         Some(contract_call),
     );
 

execution-core/src/stake.rs

@@ -43,19 +43,26 @@ pub const fn next_epoch(block_height: u64) -> u64 {
 #[derive(Debug, Clone, PartialEq, Eq, Archive, Serialize, Deserialize)]
 #[archive_attr(derive(CheckBytes))]
 pub struct Stake {
+    chain_id: u8,
     account: BlsPublicKey,
     value: u64,
     nonce: u64,
     signature: BlsSignature,
 }
 
 impl Stake {
-    const MESSAGE_SIZE: usize = BlsPublicKey::SIZE + u64::SIZE + u64::SIZE;
+    const MESSAGE_SIZE: usize = 1 + BlsPublicKey::SIZE + u64::SIZE + u64::SIZE;
 
     /// Create a new stake.
     #[must_use]
-    pub fn new(sk: &BlsSecretKey, value: u64, nonce: u64) -> Self {
+    pub fn new(
+        sk: &BlsSecretKey,
+        value: u64,
+        nonce: u64,
+        chain_id: u8,
+    ) -> Self {
         let mut stake = Stake {
+            chain_id,
             account: BlsPublicKey::from(sk),
             value,
             nonce,
@@ -91,6 +98,12 @@ impl Stake {
         self.nonce
     }
 
+    /// Returns the chain ID of the stake.
+    #[must_use]
+    pub fn chain_id(&self) -> u8 {
+        self.chain_id
+    }
+
     /// Signature of the stake.
     #[must_use]
     pub fn signature(&self) -> &BlsSignature {
@@ -102,7 +115,8 @@ impl Stake {
     pub fn signature_message(&self) -> [u8; Self::MESSAGE_SIZE] {
         let mut bytes = [0u8; Self::MESSAGE_SIZE];
 
-        let mut offset = 0;
+        bytes[0] = self.chain_id;
+        let mut offset = 1;
 
         bytes[offset..offset + BlsPublicKey::SIZE]
             .copy_from_slice(&self.account.to_bytes());