Eliminate contract index duplication between commit objects

contracts/Cargo.toml

@@ -3,8 +3,10 @@ members = [
     "box",
     "c-example",
     "callcenter",
+    "callstack",
     "initializer",
     "counter",
+    "counter_float",
     "debugger",
     "double_counter",
     "empty_initializer",

contracts/callcenter/src/lib.rs

@@ -80,6 +80,11 @@ impl Callcenter {
         uplink::caller()
     }
 
+    /// Return the entire call stack of this contract
+    pub fn return_callstack(&self) -> Vec<ContractId> {
+        uplink::callstack()
+    }
+
     /// Make sure that the caller of this contract is the contract itself
     pub fn call_self(&self) -> Result<bool, ContractError> {
         let self_id = uplink::self_id();
@@ -90,6 +95,16 @@ impl Callcenter {
         }
     }
 
+    /// Return a call stack after calling itself n times
+    pub fn call_self_n_times(&self, n: u32) -> Vec<ContractId> {
+        let self_id = uplink::self_id();
+        match n {
+            0 => uplink::callstack(),
+            _ => uplink::call(self_id, "call_self_n_times", &(n - 1))
+                .expect("calling self should succeed")
+        }
+    }
+
     /// Calls the `spend` function of the `contract` with no arguments, and the
     /// given `gas_limit`, assuming the called function returns `()`. It will
     /// then return the call's result itself.
@@ -133,6 +148,12 @@ unsafe fn call_self(arg_len: u32) -> u32 {
     wrap_call(arg_len, |_: ()| STATE.call_self())
 }
 
+/// Expose `Callcenter::call_self_n_times()` to the host
+#[no_mangle]
+unsafe fn call_self_n_times(arg_len: u32) -> u32 {
+    wrap_call(arg_len, |n: u32| STATE.call_self_n_times(n))
+}
+
 /// Expose `Callcenter::call_spend_with_limit` to the host
 #[no_mangle]
 unsafe fn call_spend_with_limit(arg_len: u32) -> u32 {
@@ -153,6 +174,12 @@ unsafe fn return_caller(arg_len: u32) -> u32 {
     wrap_call(arg_len, |_: ()| STATE.return_caller())
 }
 
+/// Expose `Callcenter::return_callstack()` to the host
+#[no_mangle]
+unsafe fn return_callstack(arg_len: u32) -> u32 {
+    wrap_call(arg_len, |_: ()| STATE.return_callstack())
+}
+
 /// Expose `Callcenter::delegate_query()` to the host
 #[no_mangle]
 unsafe fn delegate_query(arg_len: u32) -> u32 {

contracts/callstack/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "callstack"
+version = "0.1.0"
+authors = [
+    "Milosz Muszynski <[email protected]>",
+]
+edition = "2021"
+
+license = "MPL-2.0"
+
+[dependencies]
+piecrust-uplink = { path = "../../piecrust-uplink", features = ["abi", "dlmalloc"] }
+
+[lib]
+crate-type = ["cdylib", "rlib"]

contracts/callstack/src/lib.rs

@@ -0,0 +1,34 @@
+// 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.
+
+//! Contract which exposes the call stack
+
+#![no_std]
+
+extern crate alloc;
+
+use piecrust_uplink as uplink;
+use alloc::vec::Vec;
+use uplink::ContractId;
+
+/// Struct that describes the state of the contract
+pub struct CallStack;
+
+/// State of the Counter contract
+static mut STATE: CallStack = CallStack;
+
+impl CallStack {
+    /// Return the call stack
+    pub fn return_callstack(&self) -> Vec<ContractId> {
+        uplink::callstack()
+    }
+}
+
+/// Expose `CallStack::read_callstack()` to the host
+#[no_mangle]
+unsafe fn return_callstack(arg_len: u32) -> u32 {
+    uplink::wrap_call_unchecked(arg_len, |_: ()| STATE.return_callstack())
+}

contracts/counter_float/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "counter_float"
+version = "0.1.0"
+authors = [
+    "Kristoffer Ström <[email protected]>",
+    "Milosz Muszynski <[email protected]>",
+]
+edition = "2021"
+
+license = "MPL-2.0"
+
+[dependencies]
+piecrust-uplink = { path = "../../piecrust-uplink", features = ["abi", "dlmalloc"] }
+
+[lib]
+crate-type = ["cdylib", "rlib"]

contracts/counter_float/src/lib.rs

@@ -0,0 +1,45 @@
+// 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.
+
+//! Contract to implement a simple counter that can be read and incremented by
+//! one count.
+
+#![no_std]
+
+use piecrust_uplink as uplink;
+
+/// Struct that describes the state of the Counter contract
+pub struct Counter {
+    value: f64,
+}
+
+/// State of the Counter contract
+static mut STATE: Counter = Counter { value: 0xfc as f64 };
+
+impl Counter {
+    /// Read the value of the counter
+    pub fn read_value(&self) -> f64 {
+        self.value
+    }
+
+    /// Increment the value of the counter by 1
+    pub fn increment(&mut self) {
+        let value = self.value + 1.0;
+        self.value = value;
+    }
+}
+
+/// Expose `Counter::read_value()` to the host
+#[no_mangle]
+unsafe fn read_value(arg_len: u32) -> u32 {
+    uplink::wrap_call_unchecked(arg_len, |_: ()| STATE.read_value())
+}
+
+/// Expose `Counter::increment()` to the host
+#[no_mangle]
+unsafe fn increment(arg_len: u32) -> u32 {
+    uplink::wrap_call_unchecked(arg_len, |_: ()| STATE.increment())
+}

contracts/crossover/src/lib.rs

@@ -67,6 +67,27 @@ impl Crossover {
         self.set_crossover(value_to_set);
     }
 
+    // Chain of ICC is not being rolled back when a callee panics and its panic
+    // is not propagated up the call chain.
+    pub fn check_iccs_dont_rollback(
+        &mut self,
+        contract: ContractId,
+        value_to_set: i32,
+    ) {
+        self.set_crossover(value_to_set);
+
+        const ANY_VALUE_1: i32 = 5;
+        const ANY_VALUE_2: i32 = 6;
+
+        uplink::debug!("calling panicking contract {contract:?}");
+        uplink::call::<_, ()>(
+            contract,
+            "set_back_and_panic",
+            &(ANY_VALUE_1, ANY_VALUE_2),
+        )
+        .expect_err("should give an error on a panic");
+    }
+
     // Sets the contract's value and then calls its caller's [`set_crossover`]
     // call to set their value. The caller is assumed to be another crossover
     // contract.
@@ -125,6 +146,14 @@ unsafe fn check_consistent_state_on_errors(arg_len: u32) -> u32 {
     })
 }
 
+/// Expose `Crossover::check_iccs_dont_rollback()` to the host
+#[no_mangle]
+unsafe fn check_iccs_dont_rollback(arg_len: u32) -> u32 {
+    uplink::wrap_call(arg_len, |(contract, s)| {
+        STATE.check_iccs_dont_rollback(contract, s)
+    })
+}
+
 /// Expose `Crossover::set_back_and_panic()` to the host
 #[no_mangle]
 unsafe fn set_back_and_panic(arg_len: u32) -> u32 {

piecrust-uplink/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.17.3] - 2024-12-19
+
+## [0.17.2] - 2024-12-17
+
+### Added
+
+- Add serde `Serialize` and `Deserialize` implementations for `ContractId` and `Event` [#414]
+- Add `serde`, `hex`, `base64` and `serde_json` optional dependencies [#414]
+- Add `serde` feature [#414]
+
 ## [0.17.1] - 2024-09-24
 
 ### Changed
@@ -216,6 +226,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - First `piecrust-uplink` release
 
 <!-- ISSUES -->
+[#414]: https://github.com/dusk-network/piecrust/issues/414
 [#375]: https://github.com/dusk-network/piecrust/issues/375
 [#365]: https://github.com/dusk-network/piecrust/issues/365
 [#357]: https://github.com/dusk-network/piecrust/issues/357
@@ -241,7 +252,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#136]: https://github.com/dusk-network/piecrust/issues/136
 
 <!-- VERSIONS -->
-[Unreleased]: https://github.com/dusk-network/piecrust/compare/uplink-0.17.1...HEAD
+[Unreleased]: https://github.com/dusk-network/piecrust/compare/uplink-0.17.3...HEAD
+[0.17.3]: https://github.com/dusk-network/piecrust/compare/uplink-0.17.2...uplink-0.17.3
+[0.17.2]: https://github.com/dusk-network/piecrust/compare/uplink-0.17.1...uplink-0.17.2
 [0.17.1]: https://github.com/dusk-network/piecrust/compare/uplink-0.17.0...uplink-0.17.1
 [0.17.0]: https://github.com/dusk-network/piecrust/compare/uplink-0.16.0...uplink-0.17.0
 [0.16.0]: https://github.com/dusk-network/piecrust/compare/uplink-0.15.0...uplink-0.16.0

piecrust-uplink/Cargo.toml

@@ -7,7 +7,7 @@ categories = ["wasm", "no-std", "cryptography::cryptocurrencies"]
 keywords = ["virtual", "machine", "smart", "contract", "wasm"]
 
 repository = "https://github.com/dusk-network/piecrust"
-version = "0.17.1"
+version = "0.17.3"
 
 edition = "2021"
 license = "MPL-2.0"
@@ -16,10 +16,18 @@ license = "MPL-2.0"
 rkyv = { version = "0.7", default-features = false, features = ["size_32", "alloc", "validation"] }
 bytecheck = { version = "0.6", default-features = false }
 dlmalloc = { version = "0.2", optional = true, features = ["global"] }
+serde = { version = "1.0", optional = true }
+hex = { version = "0.4" , optional = true }
+base64 = { version = "0.22", optional = true }
+serde_json = { version = "1.0", optional = true }
+
+[dev-dependencies]
+rand = "0.8"
 
 [features]
 abi = []
 debug = []
+serde = ["dep:serde", "serde_json", "hex", "base64"]
 
 [package.metadata.docs.rs]
 all-features = true

piecrust-uplink/src/abi/state.rs

@@ -58,6 +58,7 @@ mod ext {
         pub fn feed(arg_len: u32);
 
         pub fn caller() -> i32;
+        pub fn callstack() -> i32;
         pub fn limit() -> u64;
         pub fn spent() -> u64;
         pub fn owner(contract_id: *const u8) -> i32;
@@ -289,6 +290,22 @@ pub fn caller() -> Option<ContractId> {
     }
 }
 
+/// Returns IDs of all calling contracts present in the calling stack
+pub fn callstack() -> Vec<ContractId> {
+    let n = unsafe { ext::callstack() };
+    with_arg_buf(|buf| {
+        let mut v = Vec::new();
+        for i in 0..n as usize {
+            let mut bytes = [0; CONTRACT_ID_BYTES];
+            bytes.copy_from_slice(
+                &buf[i * CONTRACT_ID_BYTES..(i + 1) * CONTRACT_ID_BYTES],
+            );
+            v.push(ContractId::from_bytes(bytes));
+        }
+        v
+    })
+}
+
 /// Returns the gas limit with which the contact was called.
 pub fn limit() -> u64 {
     unsafe { ext::limit() }

piecrust-uplink/src/lib.rs

@@ -78,6 +78,9 @@ pub use types::*;
 mod error;
 pub use error::*;
 
+#[cfg(feature = "serde")]
+mod serde_support;
+
 /// How many bytes to use for scratch space when serializing
 pub const SCRATCH_BUF_BYTES: usize = 1024;