Contract deployment via transaction

contracts/bob/src/lib.rs

@@ -22,11 +22,26 @@ mod wasm {
     #[no_mangle]
     static mut STATE: Bob = Bob::new();
 
+    #[no_mangle]
+    unsafe fn init(arg_len: u32) -> u32 {
+        rusk_abi::wrap_call(arg_len, |n| STATE.init(n))
+    }
+
     #[no_mangle]
     unsafe fn ping(arg_len: u32) -> u32 {
         rusk_abi::wrap_call(arg_len, |()| STATE.ping())
     }
 
+    #[no_mangle]
+    unsafe fn echo(arg_len: u32) -> u32 {
+        rusk_abi::wrap_call(arg_len, |n| STATE.echo(n))
+    }
+
+    #[no_mangle]
+    unsafe fn value(arg_len: u32) -> u32 {
+        rusk_abi::wrap_call(arg_len, |()| STATE.value())
+    }
+
     const PAYMENT_INFO: PaymentInfo = PaymentInfo::Transparent(None);
 
     #[no_mangle]

contracts/bob/src/state.rs

@@ -6,11 +6,13 @@
 
 /// Bob contract.
 #[derive(Debug, Clone)]
-pub struct Bob;
+pub struct Bob {
+    value: u8,
+}
 
 impl Bob {
     pub const fn new() -> Self {
-        Self
+        Self { value: 0 }
     }
 
     #[allow(dead_code)]
@@ -20,7 +22,17 @@ impl Bob {
 }
 
 impl Bob {
-    pub fn ping(&mut self) {
-        rusk_abi::debug!("Bob ping");
+    pub fn init(&mut self, n: u8) {
+        self.value = n;
+    }
+
+    pub fn ping(&mut self) {}
+
+    pub fn echo(&mut self, n: u64) -> u64 {
+        n
+    }
+
+    pub fn value(&mut self) -> u8 {
+        self.value
     }
 }

contracts/stake/tests/common/utils.rs

@@ -16,7 +16,8 @@ use rand::SeedableRng;
 
 use execution_core::{
     transfer::{
-        ContractCall, Fee, Payload, Transaction, TreeLeaf, TRANSFER_TREE_DEPTH,
+        ContractCall, ContractExec, Fee, Payload, Transaction, TreeLeaf,
+        TRANSFER_TREE_DEPTH,
     },
     value_commitment, JubJubScalar, Note, PublicKey, SchnorrSecretKey,
     SecretKey, Sender, TxSkeleton, ViewKey,
@@ -272,7 +273,7 @@ pub fn create_transaction<const I: usize>(
     let tx_payload = Payload {
         tx_skeleton,
         fee,
-        contract_call,
+        contract_exec: (contract_call.map(|c| ContractExec::Call(c))),
     };
 
     let payload_hash = tx_payload.hash();

contracts/transfer/src/state.rs

@@ -191,7 +191,7 @@ impl TransferState {
 
         // if present, place the contract deposit on the state
         if tx.payload().tx_skeleton.deposit > 0 {
-            let contract = match &tx.payload().contract_call {
+            let contract = match &tx.payload().contract_call() {
                 Some(call) => ContractId::from_bytes(call.contract),
                 None => {
                     panic!("There needs to be a contract call when depositing funds");
@@ -202,7 +202,7 @@ impl TransferState {
 
         // perform contract call if present
         let mut result = Ok(Vec::new());
-        if let Some(call) = &tx.payload().contract_call {
+        if let Some(call) = &tx.payload().contract_call() {
             result = rusk_abi::call_raw(
                 ContractId::from_bytes(call.contract),
                 &call.fn_name,

contracts/transfer/tests/common.rs

@@ -17,10 +17,10 @@ use rusk_abi::{ContractError, ContractId, Error, Session, TRANSFER_CONTRACT};
 
 use dusk_bytes::Serializable;
 use dusk_plonk::prelude::*;
+use execution_core::transfer::ContractExec;
 use ff::Field;
 use phoenix_circuits::transaction::{TxCircuit, TxInputNote, TxOutputNote};
 use poseidon_merkle::Opening as PoseidonOpening;
-
 use rand::rngs::StdRng;
 use rand::SeedableRng;
 
@@ -287,7 +287,7 @@ pub fn create_transaction<const I: usize>(
     let tx_payload = Payload {
         tx_skeleton,
         fee,
-        contract_call,
+        contract_exec: (contract_call.map(|c| ContractExec::Call(c))),
     };
 
     let payload_hash = tx_payload.hash();

execution-core/CHANGELOG.md

@@ -7,7 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Added
+### Changed
+
+- Improved deserialization [#1963]
+- Change payload to support contract deployment [#1882]
+
 
 - Re-export
   - `dusk-bls12_381::BlsScalar`
@@ -75,6 +79,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
       StakeData,
   }`
 
+[#1963]: https://github.com/dusk-network/rusk/issues/1963
+[#1882]: https://github.com/dusk-network/rusk/issues/1882
 
 [Unreleased]: https://github.com/dusk-network/rusk/compare/execution-core-0.1.0...HEAD
 [0.1.0]: https://github.com/dusk-network/dusk-abi/releases/tag/execution-core-0.1.0

execution-core/Cargo.toml

@@ -17,7 +17,7 @@ rand = { version = "0.8", default-features = false }
 ff = { version = "0.13", default-features = false }
 
 [dev-dependencies]
-rand = { version = "0.8", default-features = false, features = ["std_rng"] }
+rand = "0.8"
 
 [features]
 # It enables parallel thread aggregation of BlsPublicKey

execution-core/src/bytecode.rs

@@ -0,0 +1,53 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+//! Wrapper for a strip-able bytecode that we want to keep the integrity of.
+
+extern crate alloc;
+use crate::reader::{read_arr, read_vec};
+use alloc::vec::Vec;
+use bytecheck::CheckBytes;
+use dusk_bytes::{Error as BytesError, Serializable};
+use rkyv::{Archive, Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Archive, Serialize, Deserialize)]
+#[archive_attr(derive(CheckBytes))]
+/// Holds bytes of bytecode and its hash.
+pub struct Bytecode {
+    /// Hash of the bytecode bytes.
+    pub hash: [u8; 32],
+    /// Bytecode bytes.
+    pub bytes: Vec<u8>,
+}
+
+impl Bytecode {
+    /// Provides contribution bytes for an external hash.
+    #[must_use]
+    pub fn to_hash_input_bytes(&self) -> Vec<u8> {
+        self.hash.to_vec()
+    }
+
+    /// Serializes this object into a variable length buffer
+    #[must_use]
+    pub fn to_var_bytes(&self) -> Vec<u8> {
+        let mut bytes = Vec::new();
+        bytes.extend(self.hash);
+        bytes.extend((self.bytes.len() as u64).to_bytes());
+        bytes.extend(&self.bytes);
+        bytes
+    }
+
+    /// Deserialize from a bytes buffer.
+    /// Resets buffer to a position after the bytes read.
+    ///
+    /// # Errors
+    /// Errors when the bytes are not available.
+    pub fn from_buf(buf: &mut &[u8]) -> Result<Self, BytesError> {
+        let hash = read_arr::<32>(buf)?;
+        let bytes = read_vec(buf)?;
+        Ok(Self { hash, bytes })
+    }
+}

execution-core/src/lib.rs

@@ -13,6 +13,8 @@
 /// Block height type alias
 pub type BlockHeight = u64;
 
+pub mod bytecode;
+pub mod reader;
 pub mod stake;
 pub mod transfer;
 

execution-core/src/reader.rs

@@ -0,0 +1,64 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Copyright (c) DUSK NETWORK. All rights reserved.
+
+//! Functions for reading variable length elements from bytes.
+
+extern crate alloc;
+use alloc::string::String;
+use alloc::vec::Vec;
+
+use dusk_bytes::Error::InvalidData;
+use dusk_bytes::{DeserializableSlice, Error as BytesError};
+
+/// Reads vector from a buffer.
+/// Resets buffer to a position after the bytes read.
+///
+/// # Errors
+/// When length or data could not be read.
+pub fn read_vec(buf: &mut &[u8]) -> Result<Vec<u8>, BytesError> {
+    let len = usize::try_from(u64::from_reader(buf)?)
+        .map_err(|_| BytesError::InvalidData)?;
+    if buf.len() < len {
+        return Err(InvalidData);
+    }
+    let bytes = buf[..len].into();
+    *buf = &buf[len..];
+    Ok(bytes)
+}
+
+/// Reads string from a buffer.
+/// Resets buffer to a position after the bytes read.
+///
+/// # Errors
+/// When length or data could not be read.
+pub fn read_str(buf: &mut &[u8]) -> Result<String, BytesError> {
+    let len = usize::try_from(u64::from_reader(buf)?)
+        .map_err(|_| BytesError::InvalidData)?;
+    if buf.len() < len {
+        return Err(InvalidData);
+    }
+    let str = String::from_utf8(buf[..len].into())
+        .map_err(|_| BytesError::InvalidData)?;
+    *buf = &buf[len..];
+    Ok(str)
+}
+
+/// Reads array from a buffer.
+/// Resets buffer to a position after the bytes read.
+///
+/// # Errors
+/// When length or data could not be read.
+pub fn read_arr<const N: usize>(
+    buf: &mut &[u8],
+) -> Result<[u8; N], BytesError> {
+    if buf.len() < N {
+        return Err(InvalidData);
+    }
+    let mut a = [0u8; N];
+    a.copy_from_slice(&buf[..N]);
+    *buf = &buf[N..];
+    Ok(a)
+}