feat: Context and Proxy Starknet contract integration into Calimero

Cargo.toml

@@ -105,7 +105,7 @@ semver = "1.0.22"
 serde = "1.0.196"
 serde_json = "1.0.113"
 serde_with = "3.9.0"
-starknet = "0.12.0"
+starknet = { git = "https://github.com/xJonathanLEI/starknet-rs" }
 starknet-crypto = "0.7.1"
 starknet-types-core = "0.1.7"
 strum = "0.26.2"

crates/context/Cargo.toml

@@ -10,13 +10,17 @@ license.workspace = true
 camino = { workspace = true, features = ["serde1"] }
 eyre.workspace = true
 futures-util.workspace = true
+hex.workspace = true
 rand.workspace = true
 reqwest = { workspace = true, features = ["stream"] }
 serde.workspace = true
 tokio = { workspace = true, features = ["sync", "macros"] }
 tokio-util.workspace = true
 tracing.workspace = true
 
+starknet-crypto = { workspace = true }
+starknet = { workspace = true }
+
 calimero-context-config = { path = "./config", features = ["client"] }
 calimero-blobstore = { path = "../store/blobs" }
 calimero-primitives = { path = "../primitives", features = ["borsh", "rand"] }

crates/context/config/Cargo.toml

@@ -12,6 +12,7 @@ borsh = { workspace = true, features = ["derive"] }
 ed25519-dalek.workspace = true
 either = { workspace = true, optional = true }
 eyre = { workspace = true, optional = true }
+hex.workspace = true
 near-crypto = { workspace = true, optional = true }
 near-jsonrpc-client = { workspace = true, optional = true }
 near-jsonrpc-primitives = { workspace = true, optional = true }

crates/context/config/src/client/env/config.rs

@@ -2,7 +2,7 @@ use crate::client::{CallClient, Environment};
 
 mod mutate;
 mod query;
-
+mod types;
 use mutate::ContextConfigMutate;
 use query::ContextConfigQuery;
 

crates/context/config/src/client/env/config/mutate.rs

@@ -1,14 +1,19 @@
+use std::fmt::Debug;
+
 use ed25519_dalek::{Signer, SigningKey};
+use starknet::core::codec::Encode;
+use starknet::signers::SigningKey as StarknetSigningKey;
+use starknet_crypto::{poseidon_hash_many, Felt};
 
+use super::types::starknet::{Request as StarknetRequest, Signed as StarknetSigned};
 use crate::client::env::{utils, Method};
 use crate::client::protocol::near::Near;
 use crate::client::protocol::starknet::Starknet;
 use crate::client::transport::Transport;
 use crate::client::{CallClient, ClientError, Operation};
-use crate::repr::ReprTransmute;
+use crate::repr::{Repr, ReprBytes, ReprTransmute};
 use crate::types::Signed;
-use crate::{Request, RequestKind};
-
+use crate::{ContextIdentity, Request, RequestKind};
 pub mod methods;
 
 #[derive(Debug)]
@@ -25,6 +30,7 @@ pub struct ContextConfigMutateRequest<'a, T> {
 #[derive(Debug)]
 struct Mutate<'a> {
     pub(crate) signing_key: [u8; 32],
+    pub(crate) nonce: u64,
     pub(crate) kind: RequestKind<'a>,
 }
 
@@ -56,28 +62,76 @@ impl<'a> Method<Near> for Mutate<'a> {
 
 impl<'a> Method<Starknet> for Mutate<'a> {
     type Returns = ();
-
     const METHOD: &'static str = "mutate";
 
     fn encode(self) -> eyre::Result<Vec<u8>> {
-        // sign the params, encode it and return
-        // since you will have a `Vec<Felt>` here, you can
-        // `Vec::with_capacity(32 * calldata.len())` and then
-        // extend the `Vec` with each `Felt::to_bytes_le()`
-        // when this `Vec<u8>` makes it to `StarknetTransport`,
-        // reconstruct the `Vec<Felt>` from it
-        todo!()
+        // Derive ecdsa key from private key
+        let secret_scalar = Felt::from_bytes_be(&self.signing_key);
+        let signing_key = StarknetSigningKey::from_secret_scalar(secret_scalar);
+        let verifying_key = signing_key.verifying_key().scalar();
+        let verifying_key_bytes = verifying_key.to_bytes_be();
+
+        // Derive ed25519 key from private key
+        let user_key = SigningKey::from_bytes(&self.signing_key).verifying_key();
+        let user_key_bytes = user_key.to_bytes();
+
+        // Create Repr wrapped ContextIdentity instances
+        let signer_id = Repr::new(ContextIdentity::from_bytes(|bytes| {
+            bytes.copy_from_slice(&verifying_key_bytes);
+            Ok(32)
+        })?);
+
+        let user_id = Repr::new(ContextIdentity::from_bytes(|bytes| {
+            bytes.copy_from_slice(&user_key_bytes);
+            Ok(32)
+        })?);
+
+        // Create the Request structure using into() conversions
+        let request = StarknetRequest {
+            signer_id: signer_id.into(),
+            user_id: user_id.into(),
+            nonce: 0,
+            kind: self.kind.into(),
+        };
+
+        // Serialize the request
+        let mut serialized_request = vec![];
+        request.encode(&mut serialized_request)?;
+
+        // Hash the serialized request
+        let hash = poseidon_hash_many(&serialized_request);
+
+        // Sign the hash with the signing key
+        let signature = signing_key.sign(&hash)?;
+
+        let signed_request = StarknetSigned {
+            payload: serialized_request,
+            signature_r: signature.r,
+            signature_s: signature.s,
+        };
+
+        let mut signed_request_serialized = vec![];
+        signed_request.encode(&mut signed_request_serialized)?;
+
+        let bytes: Vec<u8> = signed_request_serialized
+            .iter()
+            .flat_map(|felt| felt.to_bytes_be())
+            .collect();
+
+        Ok(bytes)
     }
 
-    fn decode(_response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        todo!()
+    fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
+        println!("decode {:?}", response);
+        Ok(())
     }
 }
 
-impl<'a, T: Transport> ContextConfigMutateRequest<'a, T> {
+impl<'a, T: Transport + Debug> ContextConfigMutateRequest<'a, T> {
     pub async fn send(self, signing_key: [u8; 32]) -> Result<(), ClientError<T>> {
         let request = Mutate {
             signing_key,
+            nonce: 0,
             // todo! when nonces are implemented in context
             // todo! config contract, we fetch it here first
             // nonce: _,

crates/context/config/src/client/env/config/query/application.rs

@@ -1,9 +1,10 @@
 use serde::Serialize;
+use starknet_crypto::Felt;
 
 use crate::client::env::Method;
 use crate::client::protocol::near::Near;
 use crate::client::protocol::starknet::Starknet;
-use crate::repr::Repr;
+use crate::repr::{Repr, ReprBytes, ReprTransmute};
 use crate::types::{Application, ApplicationMetadata, ApplicationSource, ContextId};
 
 #[derive(Copy, Clone, Debug, Serialize)]
@@ -41,10 +42,69 @@ impl Method<Starknet> for ApplicationRequest {
     const METHOD: &'static str = "application";
 
     fn encode(self) -> eyre::Result<Vec<u8>> {
-        todo!()
+        // Split context_id into high/low parts
+        let bytes = self.context_id.as_bytes();
+        let (high_bytes, low_bytes) = bytes.split_at(bytes.len() / 2);
+
+        // Convert to Felts
+        let high_felt = Felt::from_bytes_be_slice(high_bytes);
+        let low_felt = Felt::from_bytes_be_slice(low_bytes);
+
+        // Convert both Felts to bytes and concatenate
+        let mut result = Vec::new();
+        result.extend_from_slice(&high_felt.to_bytes_be());
+        result.extend_from_slice(&low_felt.to_bytes_be());
+        Ok(result)
     }
 
-    fn decode(_response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        todo!()
+    fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
+        if response.is_empty() {
+            return Err(eyre::eyre!("No application found"));
+        }
+
+        // Check if it's a None response (single zero Felt)
+        if response.len() == 32 && response.iter().all(|&x| x == 0) {
+            return Err(eyre::eyre!("No application found"));
+        }
+
+        // First 32 bytes is the flag/version (0x0), skip it
+        let response = &response[32..];
+
+        // Next two Felts are application id (high/low)
+        let mut id_bytes = [0u8; 32];
+        id_bytes[..16].copy_from_slice(&response[16..32]); // high part
+        id_bytes[16..].copy_from_slice(&response[48..64]); // low part
+        let id = Repr::new(id_bytes.rt()?);
+
+        // Next two Felts are blob id (high/low)
+        let mut blob_bytes = [0u8; 32];
+        blob_bytes[..16].copy_from_slice(&response[80..96]); // high part
+        blob_bytes[16..].copy_from_slice(&response[112..128]); // low part
+        let blob = Repr::new(blob_bytes.rt()?);
+
+        // Next Felt is size (0x1af25)
+        let size = u64::from_be_bytes(response[152..160].try_into()?);
+
+        // Source string starts after the length Felt (0x2)
+        let mut source_bytes = Vec::new();
+        let mut i = 192; // Start after length Felt
+        while i < response.len() {
+            let chunk = &response[i..];
+            if chunk.iter().take(32).all(|&b| b == 0) {
+                break;
+            }
+            source_bytes.extend(chunk.iter().take(32).filter(|&&b| b != 0));
+            i += 32;
+        }
+        let source = ApplicationSource(String::from_utf8(source_bytes)?.into());
+
+        // Find metadata after source string (look for 0.0.1)
+        let metadata_bytes: Vec<u8> = response
+            .windows(5)
+            .find(|window| window == b"0.0.1")
+            .map(|_| b"0.0.1".to_vec())
+            .unwrap_or_default();
+        let metadata = ApplicationMetadata(Repr::new(metadata_bytes.into()));
+        Ok(Application::new(id, blob, size, source, metadata))
     }
 }

crates/context/config/src/client/env/config/query/application_revision.rs

@@ -1,14 +1,15 @@
 use serde::Serialize;
+use starknet_crypto::Felt;
 
 use crate::client::env::Method;
 use crate::client::protocol::near::Near;
 use crate::client::protocol::starknet::Starknet;
-use crate::repr::Repr;
+use crate::repr::{Repr, ReprBytes};
 use crate::types::{ContextId, Revision};
 
 #[derive(Copy, Clone, Debug, Serialize)]
-pub(super) struct ApplicationRevisionRequest {
-    pub(super) context_id: Repr<ContextId>,
+pub struct ApplicationRevisionRequest {
+    pub context_id: Repr<ContextId>,
 }
 
 impl Method<Near> for ApplicationRevisionRequest {
@@ -31,10 +32,30 @@ impl Method<Starknet> for ApplicationRevisionRequest {
     const METHOD: &'static str = "application_revision";
 
     fn encode(self) -> eyre::Result<Vec<u8>> {
-        todo!()
+        // Split context_id into high/low parts
+        let bytes = self.context_id.as_bytes();
+        let (high_bytes, low_bytes) = bytes.split_at(bytes.len() / 2);
+
+        // Convert to Felts
+        let high_felt = Felt::from_bytes_be_slice(high_bytes);
+        let low_felt = Felt::from_bytes_be_slice(low_bytes);
+
+        // Convert both Felts to bytes and concatenate
+        let mut result = Vec::new();
+        result.extend_from_slice(&high_felt.to_bytes_be());
+        result.extend_from_slice(&low_felt.to_bytes_be());
+        Ok(result)
     }
 
-    fn decode(_response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        todo!()
+    fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
+        if response.is_empty() {
+            return Err(eyre::eyre!("Empty response"));
+        }
+
+        // Response should be a single u64 in the last 8 bytes of a felt
+        let revision_bytes = &response[24..32]; // Take last 8 bytes
+        let revision = u64::from_be_bytes(revision_bytes.try_into()?);
+
+        Ok(revision)
     }
 }

crates/context/config/src/client/env/config/query/has_member.rs

@@ -1,9 +1,11 @@
 use serde::Serialize;
+use starknet_crypto::Felt;
 
 use crate::client::env::Method;
 use crate::client::protocol::near::Near;
 use crate::client::protocol::starknet::Starknet;
 use crate::repr::Repr;
+use crate::repr::ReprBytes;
 use crate::types::{ContextId, ContextIdentity};
 
 #[derive(Copy, Clone, Debug, Serialize)]
@@ -32,10 +34,42 @@ impl Method<Starknet> for HasMemberRequest {
     const METHOD: &'static str = "has_member";
 
     fn encode(self) -> eyre::Result<Vec<u8>> {
-        todo!()
+        let mut result = Vec::new();
+
+        // Encode context_id (2 felts)
+        let context_bytes = self.context_id.as_bytes();
+        let (context_high, context_low) = context_bytes.split_at(context_bytes.len() / 2);
+
+        // Convert to Felts and add to result
+        let context_high_felt = Felt::from_bytes_be_slice(context_high);
+        let context_low_felt = Felt::from_bytes_be_slice(context_low);
+        result.extend_from_slice(&context_high_felt.to_bytes_be());
+        result.extend_from_slice(&context_low_felt.to_bytes_be());
+
+        // Encode member identity (2 felts)
+        let identity_bytes = self.identity.as_bytes();
+        let (identity_high, identity_low) = identity_bytes.split_at(identity_bytes.len() / 2);
+
+        // Convert to Felts and add to result
+        let identity_high_felt = Felt::from_bytes_be_slice(identity_high);
+        let identity_low_felt = Felt::from_bytes_be_slice(identity_low);
+        result.extend_from_slice(&identity_high_felt.to_bytes_be());
+        result.extend_from_slice(&identity_low_felt.to_bytes_be());
+
+        Ok(result)
     }
 
-    fn decode(_response: Vec<u8>) -> eyre::Result<Self::Returns> {
-        todo!()
+    fn decode(response: Vec<u8>) -> eyre::Result<Self::Returns> {
+        if response.is_empty() {
+            return Err(eyre::eyre!("Empty response"));
+        }
+
+        // Response should be a single felt (32 bytes) representing 0 or 1
+        if response.len() != 32 {
+            return Err(eyre::eyre!("Invalid response length"));
+        }
+
+        // Check the last byte for 0 or 1
+        Ok(response[31] == 1)
     }
 }