Merge pull request #382 from dusk-network/additional-raws

Add additional "raw" calls

contracts/eventer/src/lib.rs

@@ -27,6 +27,13 @@ impl Eventer {
  }
  }
 
+ /// Emits an event with the given number, using `emit_raw`
+ pub fn emit_num_raw(&mut self, num: u32) {
+ for i in 0..num {
+ uplink::emit_raw("number", i.to_le_bytes());
+ }
+ }
+
  pub fn emit_input(&mut self, input: Vec<u8>) -> (u64, u64) {
  let spent_before = uplink::spent();
  uplink::emit("input", input);
@@ -41,6 +48,12 @@ unsafe fn emit_events(arg_len: u32) -> u32 {
  uplink::wrap_call(arg_len, |num| STATE.emit_num(num))
 }
 
+/// Expose `Eventer::emit_num_raw()` to the host
+#[no_mangle]
+unsafe fn emit_events_raw(arg_len: u32) -> u32 {
+ uplink::wrap_call(arg_len, |num| STATE.emit_num_raw(num))
+}
+
 /// Expose `Eventer::emit_input()` to the host
 #[no_mangle]
 unsafe fn emit_input(arg_len: u32) -> u32 {

contracts/feeder/src/lib.rs

@@ -25,10 +25,23 @@ impl Feeder {
  uplink::feed(i);
  }
  }
+
+ /// Feed the host with 32-bit integers sequentially in the `0..num` range.
+ pub fn feed_num_raw(&self, num: u32) {
+ for i in 0..num {
+ uplink::feed_raw(i.to_le_bytes());
+ }
+ }
 }
 
 /// Expose `Feeder::feed_num()` to the host
 #[no_mangle]
 unsafe fn feed_num(arg_len: u32) -> u32 {
  uplink::wrap_call(arg_len, |num| STATE.feed_num(num))
 }
+
+/// Expose `Feeder::feed_num_raw()` to the host
+#[no_mangle]
+unsafe fn feed_num_raw(arg_len: u32) -> u32 {
+ uplink::wrap_call(arg_len, |num| STATE.feed_num_raw(num))
+}

piecrust-uplink/CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Add `emit_raw` and `feed_raw` functions
 - Add `ContractError::DoesNotExist` variant
 
 ## [0.16.0] - 2024-08-01

piecrust-uplink/src/abi/state.rs

@@ -299,7 +299,7 @@ pub fn spent() -> u64 {
  unsafe { ext::spent() }
 }
 
-/// Emits an event with the given data.
+/// Emits an event with the given data, serializing it using [`rkyv`].
 pub fn emit<D>(topic: &'static str, data: D)
 where
  for<'a> D: Serialize<StandardBufSerializer<'a>>,
@@ -321,7 +321,24 @@ where
  });
 }
 
-/// Feeds the host with data.
+/// Emits an event with the given data.
+pub fn emit_raw(topic: &'static str, data: impl AsRef<[u8]>) {
+ with_arg_buf(|buf| {
+ let data = data.as_ref();
+
+ let arg_len = data.len();
+ buf[..arg_len].copy_from_slice(&data);
+
+ let arg_len = arg_len as u32;
+
+ let topic_ptr = topic.as_ptr();
+ let topic_len = topic.len() as u32;
+
+ unsafe { ext::emit(topic_ptr, topic_len, arg_len) }
+ });
+}
+
+/// Feeds the host with data, serializing it using [`rkyv`].
 ///
 /// This is only allowed to be called in the context of a `feed_call`, and
 /// will error out otherwise. It is meant for contracts to be able to report
@@ -343,3 +360,21 @@ where
  unsafe { ext::feed(arg_len) }
  });
 }
+
+/// Feeds the host with data.
+///
+/// This is only allowed to be called in the context of a `feed_call`, and
+/// will error out otherwise. It is meant for contracts to be able to report
+/// large amounts of data to the host, in the span of a single call.
+pub fn feed_raw(data: impl AsRef<[u8]>) {
+ with_arg_buf(|buf| {
+ let data = data.as_ref();
+
+ let arg_len = data.len();
+ buf[..arg_len].copy_from_slice(&data);
+
+ let arg_len = arg_len as u32;
+
+ unsafe { ext::feed(arg_len) }
+ });
+}

piecrust/tests/eventer.rs

@@ -36,6 +36,23 @@ pub fn vm_center_events() -> Result<(), Error> {
  assert_eq!(events[index].data, i.to_le_bytes());
  }
 
+ let receipt = session.call::<_, ()>(
+ eventer_id,
+ "emit_events_raw",
+ &EVENT_NUM,
+ LIMIT,
+ )?;
+
+ let events = receipt.events;
+ assert_eq!(events.len() as u32, EVENT_NUM);
+
+ for i in 0..EVENT_NUM {
+ let index = i as usize;
+ assert_eq!(events[index].source, eventer_id);
+ assert_eq!(events[index].topic, "number");
+ assert_eq!(events[index].data, i.to_le_bytes());
+ }
+
  Ok(())
 }
 

piecrust/tests/feeder.rs

@@ -26,10 +26,42 @@ fn feed() -> Result<(), Error> {
  const FEED_NUM: u32 = 10;
  const GAS_LIMIT: u64 = 1_000_000;
 
- let (sender, receiver) = mpsc::channel();
+ let (first_sender, receiver) = mpsc::channel();
+
+ session.feeder_call::<_, ()>(
+ id,
+ "feed_num",
+ &FEED_NUM,
+ GAS_LIMIT,
+ first_sender,
+ )?;
 
- session
- .feeder_call::<_, ()>(id, "feed_num", &FEED_NUM, GAS_LIMIT, sender)?;
+ let numbers = receiver
+ .into_iter()
+ .map(|data| {
+ rkyv::from_bytes(&data).expect("Fed data should be a number")
+ })
+ .collect::<Vec<u32>>();
+
+ assert_eq!(
+ numbers.len(),
+ FEED_NUM as usize,
+ "The correct number of numbers should be fed"
+ );
+
+ for (i, n) in numbers.into_iter().enumerate() {
+ assert_eq!(i as u32, n, "Numbers should be fed in order");
+ }
+
+ let (second_sender, receiver) = mpsc::channel();
+
+ session.feeder_call::<_, ()>(
+ id,
+ "feed_num_raw",
+ &FEED_NUM,
+ GAS_LIMIT,
+ second_sender,
+ )?;
 
  let numbers = receiver
  .into_iter()