implement bls12-381 functions

Cargo.toml

@@ -26,27 +26,27 @@ soroban-token-sdk = { version = "22.0.0-rc.1", path = "soroban-token-sdk" }
 [workspace.dependencies.soroban-env-common]
 version = "=22.0.0"
 git = "https://github.com/stellar/rs-soroban-env"
-rev = "75b782119942a4c8be8003f2901db38b30b6db2d"
+rev = "0497816694bef2b103494c8c61b7c8a06a72c7d3"
 
 [workspace.dependencies.soroban-env-guest]
 version = "=22.0.0"
 git = "https://github.com/stellar/rs-soroban-env"
-rev = "75b782119942a4c8be8003f2901db38b30b6db2d"
+rev = "0497816694bef2b103494c8c61b7c8a06a72c7d3"
 
 [workspace.dependencies.soroban-env-host]
 version = "=22.0.0"
 git = "https://github.com/stellar/rs-soroban-env"
-rev = "75b782119942a4c8be8003f2901db38b30b6db2d"
+rev = "0497816694bef2b103494c8c61b7c8a06a72c7d3"
 
 [workspace.dependencies.stellar-strkey]
-version = "=0.0.8"
+version = "=0.0.9"
 
 [workspace.dependencies.stellar-xdr]
 version = "=22.0.0"
 default-features = false
 features = ["curr"]
 git = "https://github.com/stellar/rs-stellar-xdr"
-rev = "39d7dbb0c12bd422ee43a6e2e3277789da4eaac8"
+rev = "b5516843b6379e4e29520bf2ba156484f62edc46"
 
 #[patch."https://github.com/stellar/rs-soroban-env"]
 #soroban-env-common = { path = "../rs-soroban-env/soroban-env-common" }

deny.toml

@@ -244,6 +244,8 @@ deny = [
 # Certain crates/versions that will be skipped when doing duplicate detection.
 skip = [
     #{ name = "ansi_term", version = "=0.11.0" },
+    { name = "hashbrown", version = "=0.14.5" },
+    { name = "syn", version = "=2.0.77" },
 ]
 # Similarly to `skip` allows you to skip certain crates during duplicate
 # detection. Unlike skip, it also includes the entire tree of transitive

soroban-sdk-macros/Cargo.toml

@@ -26,7 +26,7 @@ stellar-xdr = { workspace = true, features = ["curr", "std"] }
 syn = {version="2.0",features=["full"]}
 quote = "1.0"
 proc-macro2 = "1.0"
-itertools = "0.11.0"
+itertools = "0.10.5"
 darling = "0.20.0"
 sha2 = "0.10.7"
 

soroban-sdk/src/bytes.rs

@@ -102,6 +102,102 @@ macro_rules! bytesn {
     };
 }
 
+#[macro_export]
+macro_rules! impl_bytesn_repr {
+    ($elem: ident, $size: literal) => {
+        impl $elem {
+            pub fn from_bytes(bytes: BytesN<$size>) -> Self {
+                Self(bytes)
+            }
+
+            pub fn to_bytes(&self) -> BytesN<$size> {
+                self.0.clone()
+            }
+
+            pub fn as_bytes(&self) -> &BytesN<$size> {
+                &self.0
+            }
+
+            pub fn to_array(&self) -> [u8; $size] {
+                self.0.to_array()
+            }
+
+            pub fn from_array(&self, env: &Env, array: &[u8; $size]) -> Self {
+                Self(<BytesN<$size>>::from_array(env, array))
+            }
+
+            pub fn as_val(&self) -> &Val {
+                self.0.as_val()
+            }
+
+            pub fn to_val(&self) -> Val {
+                self.0.to_val()
+            }
+
+            pub fn as_object(&self) -> &BytesObject {
+                self.0.as_object()
+            }
+
+            pub fn to_object(&self) -> BytesObject {
+                self.0.to_object()
+            }
+        }
+
+        impl IntoVal<Env, Val> for $elem {
+            fn into_val(&self, e: &Env) -> Val {
+                self.0.into_val(e)
+            }
+        }
+
+        impl TryFromVal<Env, Val> for $elem {
+            type Error = ConversionError;
+
+            fn try_from_val(env: &Env, val: &Val) -> Result<Self, Self::Error> {
+                let bytes = <BytesN<$size>>::try_from_val(env, val)?;
+                Ok($elem(bytes))
+            }
+        }
+
+        impl IntoVal<Env, BytesN<$size>> for $elem {
+            fn into_val(&self, _e: &Env) -> BytesN<$size> {
+                self.0.clone()
+            }
+        }
+
+        impl From<$elem> for Bytes {
+            fn from(v: $elem) -> Self {
+                v.0.into()
+            }
+        }
+
+        impl From<$elem> for BytesN<$size> {
+            fn from(v: $elem) -> Self {
+                v.0
+            }
+        }
+
+        impl Into<[u8; $size]> for $elem {
+            fn into(self) -> [u8; $size] {
+                self.0.into()
+            }
+        }
+
+        impl Eq for $elem {}
+
+        impl PartialEq for $elem {
+            fn eq(&self, other: &Self) -> bool {
+                self.0.partial_cmp(other.as_bytes()) == Some(Ordering::Equal)
+            }
+        }
+
+        impl Debug for $elem {
+            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                write!(f, "{}({:?})", stringify!($elem), self.to_array())
+            }
+        }
+    };
+}
+
 /// Bytes is a contiguous growable array type containing `u8`s.
 ///
 /// The array is stored in the Host and available to the Guest through the

soroban-sdk/src/crypto.rs

@@ -1,10 +1,12 @@
 //! Crypto contains functions for cryptographic functions.
 
 use crate::{
-    env::internal, env::internal::BytesObject, unwrap::UnwrapInfallible, Bytes, BytesN,
-    ConversionError, Env, IntoVal, TryFromVal, Val,
+    env::internal::{self, BytesObject},
+    unwrap::UnwrapInfallible,
+    Bytes, BytesN, ConversionError, Env, IntoVal, TryFromVal, Val,
 };
 
+pub mod bls12_381;
 /// A BytesN<N> generated by a cryptographic hash function.
 ///
 /// The `Hash<N>` type contains a `BytesN<N>` and can only be constructed in
@@ -174,6 +176,11 @@ impl Crypto {
         let env = self.env();
         CryptoHazmat::new(env).secp256r1_verify(public_key, &message_digest.0, signature)
     }
+
+    /// Get a [Bls12_381] for accessing the bls12-381 functions.
+    pub fn bls12_381(&self) -> bls12_381::Bls12_381 {
+        bls12_381::Bls12_381::new(self.env())
+    }
 }
 
 /// # ⚠️ Hazardous Materials