implement rust sdk

Author: mkaput

Cargo.lock

@@ -0,0 +1,3 @@
+[workspace]
+members = ["sdk/rust"]
+resolver = "3"

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "cairo-oracle-server"
+version = "0.1.0"
+rust-version = "1.88.0"
+edition = "2024"
+description = "SDK for writing Cairo oracles in Rust"
+authors = ["Software Mansion <[email protected]>"]
+homepage = "https://docs.swmansion.com/scarb"
+license = "MIT"
+repository = "https://github.com/software-mansion/cairo-oracle"
+
+[dependencies]
+anyhow = "1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+starknet-core = "0.15.0"

sdk/rust/Cargo.toml

@@ -0,0 +1,34 @@
+use crate::handler::{Handler, HandlerMap, box_handler};
+use crate::server::Server;
+use std::mem;
+use std::process::ExitCode;
+
+pub struct Oracle<'a> {
+    handler_map: HandlerMap<'a>,
+}
+
+impl<'a> Oracle<'a> {
+    pub fn new() -> Self {
+        Self {
+            handler_map: Default::default(),
+        }
+    }
+
+    pub fn provide<T>(&mut self, selector: &str, handler: impl Handler<T> + 'a) -> &mut Self {
+        self.handler_map
+            .insert(selector.into(), box_handler(handler));
+        self
+    }
+
+    #[must_use = "the returned exit code must be used to exit the process"]
+    pub fn run(&mut self) -> ExitCode {
+        let handler_map = mem::take(&mut self.handler_map);
+        Server::main(handler_map)
+    }
+}
+
+impl Default for Oracle<'_> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

sdk/rust/src/builder.rs

@@ -0,0 +1,61 @@
+use anyhow::{Result, ensure};
+use starknet_core::codec::{Decode, Encode};
+use starknet_core::types::Felt;
+use std::collections::HashMap;
+
+pub(crate) type HandlerMap<'a> = HashMap<String, BoxedUntypedHandler<'a>>;
+pub(crate) type BoxedUntypedHandler<'a> = Box<dyn (FnMut(Vec<Felt>) -> Result<Vec<Felt>>) + 'a>;
+
+pub(crate) fn box_handler<'a, T>(mut handler: impl Handler<T> + 'a) -> BoxedUntypedHandler<'a> {
+    Box::new(move |calldata| handler.invoke_untyped(calldata))
+}
+
+// NOTE: The T parameter allows us to overcome a lack of specialisation in Rust.
+//   This trick has been stolen from Axum, the clue is using tuples here:
+//   https://docs.rs/axum/latest/src/axum/handler/mod.rs.html#193
+
+pub trait Handler<T> {
+    fn invoke_untyped(&mut self, calldata: Vec<Felt>) -> Result<Vec<Felt>>;
+}
+
+macro_rules! impl_handler {
+    ($($var:ident: $param:ident),*) => {
+        impl<F, $($param,)* R> Handler<(($($param,)*),)> for F
+        where
+            F: FnMut($($param),*) -> Result<R>,
+            $($param: for<'a> Decode<'a>,)*
+            R: Encode,
+        {
+            fn invoke_untyped(&mut self, calldata: Vec<Felt>) -> Result<Vec<Felt>> {
+                let mut calldata = calldata.iter();
+
+                $(
+                    let $var = $param::decode_iter(&mut calldata)?;
+                )*
+
+                ensure!(calldata.next().is_none(), "unexpected parameters");
+
+                let value = self($($var,)*)?;
+
+                let mut encoded = vec![];
+                value.encode(&mut encoded)?;
+                Ok(encoded)
+            }
+        }
+    };
+}
+
+// Generate implementations for up to 12 parameters.
+impl_handler!();
+impl_handler!(a0: A0);
+impl_handler!(a0: A0, a1: A1);
+impl_handler!(a0: A0, a1: A1, a2: A2);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10);
+impl_handler!(a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11);

sdk/rust/src/handler.rs

@@ -0,0 +1,48 @@
+use crate::jsonrpc;
+use anyhow::Context;
+use std::io;
+use std::io::{BufRead, Write};
+
+pub struct Io {
+    stdin: io::BufReader<io::StdinLock<'static>>,
+    stdout: io::StdoutLock<'static>,
+}
+
+impl Io {
+    pub fn lock() -> Self {
+        Self {
+            stdin: io::BufReader::new(io::stdin().lock()),
+            stdout: io::stdout().lock(),
+        }
+    }
+
+    pub fn send(&mut self, message: impl Into<jsonrpc::Message>) {
+        let message = message.into();
+        return inner(self, &message);
+
+        // Minimize monomorphisation effects.
+        fn inner(this: &mut Io, message: &jsonrpc::Message) {
+            // Serialise the message to string as a whole to avoid emitting unterminated messages.
+            let line =
+                serde_json::to_string(&message).expect("failed to serialize message from oracle");
+
+            eprintln!("send: {line}");
+            writeln!(this.stdout, "{line}").expect("failed to write message to oracle stdout");
+            this.stdout.flush().expect("failed to flush oracle stdout");
+        }
+    }
+
+    pub fn recv(&mut self) -> Option<anyhow::Result<jsonrpc::Message>> {
+        let mut buf = String::new();
+        match self.stdin.read_line(&mut buf) {
+            Ok(0) => None,
+            Ok(_n) => {
+                eprintln!("recv: {buf}");
+                Some(
+                    serde_json::from_str(buf.trim()).context("failed to parse message from oracle"),
+                )
+            }
+            Err(err) => Some(Err(err).context("failed to read bytes from oracle")),
+        }
+    }
+}