Experiment with Rustler Serde feature.

Author: murisi

Cargo.lock

@@ -3,16 +3,9 @@ defmodule AnomaSDK.Arm do
   I define a few functions to test the ARM repo NIF interface.
   """
 
-  mix_config = Mix.Project.config()
-  version = mix_config[:version]
-  github_url = mix_config[:package][:links]["GitHub"]
-
-  use RustlerPrecompiled,
+  use Rustler,
     otp_app: :anoma_sdk,
-    crate: :arm_bindings,
-    base_url: "#{github_url}/releases/download/v#{version}",
-    version: version,
-    force_build: System.get_env("BUILD_NATIVE") in ["1", "true"]
+    crate: :arm_bindings
 
   alias AnomaSDK.Arm.ComplianceInstance
   alias AnomaSDK.Arm.ComplianceUnit

lib/arm/arm.ex

@@ -9,8 +9,8 @@ name = "arm_bindings"
 crate-type = ["cdylib"]
 
 [dependencies]
-evm_protocol_adapter_bindings = { git = "https://github.com/anoma/evm-protocol-adapter", branch = "feature/sepolia-demo" }
-arm = { git = "https://github.com/anoma/arm-risc0", branch = "m1dnight/sdk-integration", default-features = true, features = [
+evm_protocol_adapter_bindings = { git = "https://github.com/anoma/evm-protocol-adapter", branch = "murisi/sepolia-demo" }
+arm = { git = "https://github.com/anoma/arm-risc0", branch = "murisi/sdk-integration", default-features = true, features = [
     "nif",
     "transaction",
     "groth16_prover",
@@ -23,7 +23,7 @@ risc0-zkvm = { version = "3.0.3", features = [
     "unstable",
 ], default-features = false }
 
-rustler = "0.36.2"
+rustler = { version = "0.36.2", features = ["serde"] }
 serde = { version = "1.0.197", default-features = false }
 serde_json = "1.0"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }

native/arm_bindings/Cargo.toml

@@ -6,113 +6,80 @@ use arm::delta_proof::DeltaWitness;
 use arm::encryption::{random_keypair, Ciphertext, SecretKey};
 use arm::logic_proof::LogicVerifier;
 use arm::logic_proof::LogicVerifierInputs;
-use arm::rustler_util::{at_struct, RustlerDecoder, RustlerEncoder};
 use arm::transaction::Transaction;
 use k256::AffinePoint;
-use rustler::types::map::map_new;
-use rustler::{atoms, nif, Decoder, Encoder, Env, NifResult, Term};
+use rustler::{nif, SerdeTerm};
+use serde::{Deserialize, Serialize};
 
 /// A Keypair is a struct that holds a SecretKey and Affinepoint.
 /// It is used here to implement the Encoder and RusterEncoder trait.
 /// The encoded value is a tuple.
+#[derive(Deserialize, Serialize)]
 pub struct Keypair {
     pub secret: SecretKey,
     pub public: AffinePoint,
 }
 
-atoms! {
-    at_secret_key = "secret_key",
-    at_public_key = "public_key",
-    at_keypair_key = "Elixir.AnomaSDK.Arm.Keypair"
-}
-
-impl Encoder for Keypair {
-    fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let secret_key = self.secret.rustler_encode(env).unwrap();
-        let public_key = self.public.rustler_encode(env).unwrap();
-
-        let map = map_new(env)
-            .map_put(at_struct().encode(env), at_keypair_key())
-            .unwrap()
-            .map_put(at_secret_key(), secret_key)
-            .unwrap()
-            .map_put(at_public_key(), public_key);
-
-        map.expect("failed to encode Keypair")
-    }
-}
-
-impl<'a> Decoder<'a> for Keypair {
-    fn decode(term: Term<'a>) -> NifResult<Self> {
-        let secret_term = term.map_get(at_secret_key().encode(term.get_env()))?;
-        let secret: SecretKey = RustlerDecoder::rustler_decode(secret_term)?;
-
-        let public_term = term.map_get(at_public_key().encode(term.get_env()))?;
-        let public: AffinePoint = RustlerDecoder::rustler_decode(public_term)?;
-        Ok(Keypair { secret, public })
-    }
-}
-
 #[nif]
 /// Generates a random pair of SecretKey and AffinePoint.
-pub fn random_key_pair() -> Keypair {
+pub fn random_key_pair() -> SerdeTerm<Keypair> {
     let (secret, public) = random_keypair();
-    Keypair { secret, public }
+    SerdeTerm(Keypair { secret, public })
 }
 
 /// Returns the ComplianceInstance from within a ComplianceUnit
 #[nif]
-fn compliance_unit_instance(unit: ComplianceUnit) -> ComplianceInstance {
-    unit.get_instance()
+fn compliance_unit_instance(SerdeTerm(unit): SerdeTerm<ComplianceUnit>) -> SerdeTerm<ComplianceInstance> {
+    SerdeTerm(unit.get_instance())
 }
 
 #[nif]
-fn encrypt_cipher(cipher: Vec<u8>, keypair: Keypair, nonce: Vec<u8>) -> Ciphertext {
-    Ciphertext::encrypt(
+fn encrypt_cipher(cipher: Vec<u8>, SerdeTerm(keypair): SerdeTerm<Keypair>, nonce: Vec<u8>) -> SerdeTerm<Ciphertext> {
+    SerdeTerm(Ciphertext::encrypt(
         cipher.as_ref(),
         &keypair.public,
         &keypair.secret,
         nonce.try_into().expect("REASON"),
-    )
+    ))
 }
 
 #[nif]
-pub fn decrypt_cipher(cipher_bytes: Vec<u8>, keypair: Keypair) -> Option<Vec<u8>> {
+pub fn decrypt_cipher(cipher_bytes: Vec<u8>, SerdeTerm(keypair): SerdeTerm<Keypair>) -> Option<Vec<u8>> {
     let cipher_text = Ciphertext::from_bytes(cipher_bytes);
     let decipher_result = cipher_text.decrypt(&keypair.secret);
     decipher_result.ok()
 }
 
 #[nif]
 /// Generate a compliance unit from a compliance witness.
-fn prove_compliance_witness(compliance_witness: ComplianceWitness) -> ComplianceUnit {
-    ComplianceUnit::create(&compliance_witness)
+fn prove_compliance_witness(SerdeTerm(compliance_witness): SerdeTerm<ComplianceWitness>) -> SerdeTerm<ComplianceUnit> {
+    SerdeTerm(ComplianceUnit::create(&compliance_witness))
 }
 
 #[nif]
 /// Converts a logic verifier to a logic verifier inputs.
 /// this nif is here because this conversion relies on the Journal
 /// implementation of Risc0 ZKVM.
-fn convert(logic_verifier: LogicVerifier) -> LogicVerifierInputs {
-    logic_verifier.into()
+fn convert(SerdeTerm(logic_verifier): SerdeTerm<LogicVerifier>) -> SerdeTerm<LogicVerifierInputs> {
+    SerdeTerm(logic_verifier.into())
 }
 
 #[nif]
 /// Generate a proof for a delta witness.
-fn prove_delta_witness(witness: DeltaWitness, message: Vec<u8>) -> DeltaProof {
-    DeltaProof::prove(&message, &witness)
+fn prove_delta_witness(SerdeTerm(witness): SerdeTerm<DeltaWitness>, message: Vec<u8>) -> SerdeTerm<DeltaProof> {
+    SerdeTerm(DeltaProof::prove(&message, &witness))
 }
 
 #[nif]
 /// Given a transaction, puts in the delta proof.
-pub fn generate_delta_proof(transaction: Transaction) -> Transaction {
+pub fn generate_delta_proof(SerdeTerm(transaction): SerdeTerm<Transaction>) -> SerdeTerm<Transaction> {
     let mut tx = transaction.clone();
     tx.generate_delta_proof();
-    tx
+    SerdeTerm(tx)
 }
 
 #[nif]
-pub fn verify_transaction(transaction: Transaction) -> bool {
+pub fn verify_transaction(SerdeTerm(transaction): SerdeTerm<Transaction>) -> bool {
     transaction.verify()
 }
 

native/arm_bindings/src/lib.rs

@@ -9,7 +9,7 @@ name = "arm_bindings_test"
 crate-type = ["cdylib"]
 
 [dependencies]
-arm = { git = "https://github.com/anoma/arm-risc0", branch = "m1dnight/sdk-integration", default-features = true, features = ["nif"] }
+arm = { git = "https://github.com/anoma/arm-risc0", branch = "murisi/sdk-integration", default-features = true, features = ["nif"] }
 
 
 
@@ -18,7 +18,7 @@ risc0-zkvm = { version = "3.0.3", features = [
     "unstable",
 ], default-features = false }
 
-rustler = "0.36.2"
+rustler = { version = "0.36.2", features = ["serde"] }
 serde = { version = "1.0.197", default-features = false }
 serde_json = "1.0"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }