Changes for Economic Protocol scenario 3 - "contract pays for gas"

contracts/c-example/src/lib.rs

@@ -10,6 +10,10 @@ use std::ptr;
 #[no_mangle]
 pub static mut A: [u8; 65536] = [0; 65536];
 
+// Define second argument buffer for the Economic Protocol
+#[no_mangle]
+pub static mut ECO_MODE: [u8; 16] = [0; 16];
+
 // ==== Host functions ====
 //
 // These functions are provided by the host. See `piecrust-uplink` for a full

contracts/callcenter/src/lib.rs

@@ -42,7 +42,7 @@ impl Callcenter {
  fn_arg: Vec<u8>,
  ) -> Result<Vec<u8>, ContractError> {
  uplink::debug!("raw query {fn_name} at {contract_id:?}");
- uplink::call_raw(contract_id, &fn_name, &fn_arg)
+ uplink::call_raw(contract_id, &fn_name, &fn_arg).map(|r|r.data)
  }
 
  /// Pass the current query
@@ -62,7 +62,7 @@ impl Callcenter {
  fn_name: String,
  fn_arg: Vec<u8>,
  ) -> Vec<u8> {
- uplink::call_raw(contract_id, &fn_name, &fn_arg).unwrap()
+ uplink::call_raw(contract_id, &fn_name, &fn_arg).unwrap().data
  }
 
  /// Check whether the current caller is the contract itself

contracts/grower/src/lib.rs

@@ -29,15 +29,15 @@ static mut STATE: Grower = Grower(Vec::new());
 impl Grower {
  /// Appends the bytes sent in the argument buffer to the state vector.
  fn append(&mut self, len: usize) {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  self.0.extend_from_slice(&buf[..len]);
  });
  }
 
  /// Parses offset and length from the argument buffer, and copies the bytes
  /// at said offset and length on the state vector to the argument buffer.
  fn view(&self, arg_len: usize) -> usize {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  if arg_len != 8 {
  panic!("Bad arguments");
  }
@@ -62,7 +62,7 @@ impl Grower {
 
  /// Emplace the length of the state vector into the argument buffer.
  fn len(&self) -> usize {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let len = self.0.len() as u32;
  let len_bytes = len.to_le_bytes();
  buf[..4].copy_from_slice(&len_bytes);

piecrust-uplink/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Add contract charge setting method [#353] 
+- Add contract allowance setting method and a corresponding passing mechanism [#350] 
+
 ## [0.11.0] - 2024-02-14
 
 ### Added
@@ -162,6 +167,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - First `piecrust-uplink` release
 
 <!-- ISSUES -->
+[#353]: https://github.com/dusk-network/piecrust/issues/353
+[#350]: https://github.com/dusk-network/piecrust/issues/350
 [#324]: https://github.com/dusk-network/piecrust/issues/324
 [#301]: https://github.com/dusk-network/piecrust/issues/301
 [#271]: https://github.com/dusk-network/piecrust/issues/271

piecrust-uplink/src/abi.rs

@@ -46,7 +46,7 @@ impl Write for ArgbufWriter {
  return Err(fmt::Error);
  }
 
- state::with_arg_buf(|buf| {
+ state::with_arg_buf(|buf, _| {
  buf[self.0..new_ofs].copy_from_slice(bytes);
  });
 

piecrust-uplink/src/abi/helpers.rs

@@ -31,7 +31,7 @@ where
  R: for<'a> Serialize<StandardBufSerializer<'a>>,
  F: Fn(A) -> R,
 {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let slice = &buf[..arg_len as usize];
 
  let aa: &A::Archived = check_archived_root::<A>(slice)
@@ -60,7 +60,7 @@ where
  R: for<'a> Serialize<StandardBufSerializer<'a>>,
  F: Fn(A) -> R,
 {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let slice = &buf[..arg_len as usize];
 
  let aa: &A::Archived = unsafe { archived_root::<A>(slice) };

piecrust-uplink/src/abi/state.rs

@@ -4,7 +4,6 @@
 //
 // Copyright (c) DUSK NETWORK. All rights reserved.
 
-use alloc::vec::Vec;
 use core::ptr;
 
 use rkyv::{
@@ -15,31 +14,46 @@ use rkyv::{
 };
 
 use crate::{
- ContractError, ContractId, StandardBufSerializer, CONTRACT_ID_BYTES,
- SCRATCH_BUF_BYTES,
+ ContractError, ContractId, EconomicMode, RawResult, StandardBufSerializer,
+ CONTRACT_ID_BYTES, ECO_MODE_BUF_LEN, ECO_MODE_LEN, SCRATCH_BUF_BYTES,
 };
 
 pub mod arg_buf {
- use crate::ARGBUF_LEN;
-
+ use crate::{EconomicMode, ARGBUF_LEN, ECO_MODE_BUF_LEN, ECO_MODE_LEN};
  use core::ptr;
  use core::slice;
 
  #[no_mangle]
  static mut A: [u64; ARGBUF_LEN / 8] = [0; ARGBUF_LEN / 8];
 
+ #[no_mangle]
+ static mut ECO_MODE: [u8; ECO_MODE_BUF_LEN] = [0u8; ECO_MODE_BUF_LEN];
+
  pub fn with_arg_buf<F, R>(f: F) -> R
  where
- F: FnOnce(&mut [u8]) -> R,
+ F: FnOnce(&mut [u8], &mut [u8]) -> R,
  {
  unsafe {
  let addr = ptr::addr_of_mut!(A);
  let slice = slice::from_raw_parts_mut(addr as _, ARGBUF_LEN);
- f(slice)
+ let addr_eco_mode = ptr::addr_of_mut!(ECO_MODE);
+ let slice_eco_mode =
+ slice::from_raw_parts_mut(addr_eco_mode as _, ECO_MODE_BUF_LEN);
+ f(slice, slice_eco_mode)
+ }
+ }
+
+ pub fn set_eco_mode(eco_mode: EconomicMode) {
+ unsafe {
+ let addr_eco_mode = ptr::addr_of_mut!(ECO_MODE);
+ let slice_eco_mode =
+ slice::from_raw_parts_mut(addr_eco_mode as _, ECO_MODE_LEN);
+ eco_mode.write(slice_eco_mode);
  }
  }
 }
 
+pub(crate) use arg_buf::set_eco_mode;
 pub(crate) use arg_buf::with_arg_buf;
 
 mod ext {
@@ -73,7 +87,7 @@ where
  Ret: Archive,
  Ret::Archived: Deserialize<Ret, Infallible>,
 {
- let arg_len = with_arg_buf(|buf| {
+ let arg_len = with_arg_buf(|buf, _| {
  let mut sbuf = [0u8; SCRATCH_BUF_BYTES];
  let scratch = BufferScratch::new(&mut sbuf);
  let ser = BufferSerializer::new(buf);
@@ -88,7 +102,7 @@ where
 
  let ret_len = unsafe { ext::hq(name_ptr, name_len, arg_len) };
 
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let slice = &buf[..ret_len as usize];
  let ret = unsafe { archived_root::<Ret>(slice) };
  ret.deserialize(&mut Infallible).expect("Infallible")
@@ -132,7 +146,7 @@ where
  Ret: Archive,
  Ret::Archived: Deserialize<Ret, Infallible>,
 {
- let arg_len = with_arg_buf(|buf| {
+ let arg_len = with_arg_buf(|buf, _| {
  let mut sbuf = [0u8; SCRATCH_BUF_BYTES];
  let scratch = BufferScratch::new(&mut sbuf);
  let ser = BufferSerializer::new(buf);
@@ -155,7 +169,7 @@ where
  )
  };
 
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  if ret_len < 0 {
  Err(ContractError::from_parts(ret_len, buf))
  } else {
@@ -175,10 +189,26 @@ pub fn call_raw(
  contract: ContractId,
  fn_name: &str,
  fn_arg: &[u8],
-) -> Result<Vec<u8>, ContractError> {
+) -> Result<RawResult, ContractError> {
  call_raw_with_limit(contract, fn_name, fn_arg, 0)
 }
 
+/// Allows the contract to set allowance which will be used
+/// to pay for the current call, under the condition that contract's
+/// current balance is greater or equal to the allowance
+/// and the allowance is sufficient to cover gas cost.
+/// This call is of no consequence if the above conditions are not met.
+pub fn set_allowance(allowance: u64) {
+ set_eco_mode(EconomicMode::Allowance(allowance));
+}
+
+/// Allows the contract to set charge which will be used
+/// as a fee. If charge is greater than gas spent,
+/// the difference will be added to contract's balance.
+pub fn set_charge(charge: u64) {
+ set_eco_mode(EconomicMode::Charge(charge));
+}
+
 /// Calls the function with name `fn_name` of the given `contract` using
 /// `fn_arg` as argument, allowing it to spend the given `gas_limit`.
 ///
@@ -192,8 +222,8 @@ pub fn call_raw_with_limit(
  fn_name: &str,
  fn_arg: &[u8],
  gas_limit: u64,
-) -> Result<Vec<u8>, ContractError> {
- with_arg_buf(|buf| {
+) -> Result<RawResult, ContractError> {
+ with_arg_buf(|buf, _| {
  buf[..fn_arg.len()].copy_from_slice(fn_arg);
  });
 
@@ -210,11 +240,16 @@ pub fn call_raw_with_limit(
  )
  };
 
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, eco_mode_buf| {
  if ret_len < 0 {
  Err(ContractError::from_parts(ret_len, buf))
  } else {
- Ok(buf[..ret_len as usize].to_vec())
+ Ok(RawResult::new(
+ buf[..ret_len as usize].to_vec(),
+ EconomicMode::read(
+ &eco_mode_buf[ECO_MODE_LEN..ECO_MODE_BUF_LEN],
+ ),
+ ))
  }
  })
 }
@@ -234,7 +269,7 @@ where
  unsafe {
  match ext::hd(name, name_len) as usize {
  0 => None,
- arg_pos => Some(with_arg_buf(|buf| {
+ arg_pos => Some(with_arg_buf(|buf, _| {
  let ret = archived_root::<D>(&buf[..arg_pos]);
  ret.deserialize(&mut Infallible).expect("Infallible")
  })),
@@ -249,7 +284,7 @@ pub fn owner<const N: usize>(contract: ContractId) -> Option<[u8; N]> {
  unsafe {
  match ext::owner(contract_id_ptr) {
  0 => None,
- _ => Some(with_arg_buf(|buf| {
+ _ => Some(with_arg_buf(|buf, _| {
  let ret = archived_root::<[u8; N]>(&buf[..N]);
  ret.deserialize(&mut Infallible).expect("Infallible")
  })),
@@ -261,7 +296,7 @@ pub fn owner<const N: usize>(contract: ContractId) -> Option<[u8; N]> {
 pub fn self_owner<const N: usize>() -> [u8; N] {
  unsafe { ext::owner(ptr::null()) };
 
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let ret = unsafe { archived_root::<[u8; N]>(&buf[..N]) };
  ret.deserialize(&mut Infallible).expect("Infallible")
  })
@@ -270,7 +305,7 @@ pub fn self_owner<const N: usize>() -> [u8; N] {
 /// Return the current contract's id.
 pub fn self_id() -> ContractId {
  unsafe { ext::self_id() };
- let id: ContractId = with_arg_buf(|buf| {
+ let id: ContractId = with_arg_buf(|buf, _| {
  let ret =
  unsafe { archived_root::<ContractId>(&buf[..CONTRACT_ID_BYTES]) };
  ret.deserialize(&mut Infallible).expect("Infallible")
@@ -283,7 +318,7 @@ pub fn self_id() -> ContractId {
 /// to be called.
 pub fn caller() -> ContractId {
  unsafe { ext::caller() };
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let ret = unsafe {
  archived_root::<ContractId>(
  &buf[..core::mem::size_of::<Archived<ContractId>>()],
@@ -308,7 +343,7 @@ pub fn emit<D>(topic: &'static str, data: D)
 where
  for<'a> D: Serialize<StandardBufSerializer<'a>>,
 {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let mut sbuf = [0u8; SCRATCH_BUF_BYTES];
  let scratch = BufferScratch::new(&mut sbuf);
  let ser = BufferSerializer::new(buf);
@@ -334,7 +369,7 @@ pub fn feed<D>(data: D)
 where
  for<'a> D: Serialize<StandardBufSerializer<'a>>,
 {
- with_arg_buf(|buf| {
+ with_arg_buf(|buf, _| {
  let mut sbuf = [0u8; SCRATCH_BUF_BYTES];
  let scratch = BufferScratch::new(&mut sbuf);
  let ser = BufferSerializer::new(buf);

piecrust-uplink/src/lib.rs

@@ -83,3 +83,9 @@ pub const SCRATCH_BUF_BYTES: usize = 64;
 
 /// The size of the argument buffer in bytes
 pub const ARGBUF_LEN: usize = 64 * 1024;
+
+/// The size of the economic mode buffer in bytes
+pub const ECO_MODE_BUF_LEN: usize = ECO_MODE_LEN * 2;
+
+/// Size of a single economic mode object
+pub const ECO_MODE_LEN: usize = 9;