Skip to content

Commit c1d29a0

Browse files
mariarimariari
committed
Get The nif branch to compile for v0.7.0
V0.7.0 introduces the Digest types and converts Vecs into fixed sized arrays
1 parent c58d57c commit c1d29a0

File tree

2 files changed

+95
-33
lines changed

2 files changed

+95
-33
lines changed

‎arm/src/logic_instance.rs‎

Lines changed: 0 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,7 @@
11
use risc0_zkvm::Digest;
2-
#[cfg(feature = "nif")]
3-
use rustler::NifStruct;
42
use serde::{Deserialize, Serialize};
53

64
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
7-
#[cfg_attr(feature = "nif", derive(NifStruct))]
8-
#[cfg_attr(feature = "nif", module = "Anoma.Arm.LogicInstance")]
95
pub struct LogicInstance {
106
pub tag: Digest,
117
pub is_consumed: bool,

‎arm/src/rustler_util.rs‎

Lines changed: 95 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ use crate::action_tree::MerkleTree;
88
use crate::compliance::{ComplianceInstance, ComplianceWitness};
99
use crate::compliance_unit::ComplianceUnit;
1010
use crate::delta_proof::{DeltaProof, DeltaWitness};
11-
use crate::logic_instance::{AppData, ExpirableBlob};
11+
use crate::logic_instance::{AppData, ExpirableBlob, LogicInstance};
1212
use crate::logic_proof::{LogicVerifier, LogicVerifierInputs};
1313
use crate::merkle_path::MerklePath;
1414
use crate::nullifier_key::{NullifierKey, NullifierKeyCommitment};
@@ -18,6 +18,7 @@ use crate::utils::{bytes_to_words, words_to_bytes};
1818
use bincode;
1919
use k256::ecdsa::{RecoveryId, Signature, SigningKey};
2020
use k256::AffinePoint;
21+
use risc0_zkvm::Digest;
2122
use rustler::types::map::map_new;
2223
use rustler::{atoms, Binary, Decoder, Encoder, NifResult};
2324
use rustler::{Env, Error, OwnedBinary, Term};
@@ -40,6 +41,9 @@ atoms! {
4041
at_discovery_payload = "discovery_payload",
4142
at_external_payload = "external_payload",
4243
at_application_payload = "application_payload",
44+
at_logic_instance = "Anoma.Arm.LogicInstance",
45+
at_is_consumed = "is_consumed",
46+
at_root = "root",
4347
at_logic_verifier_inputs = "Elixir.Anoma.Arm.LogicVerifierInputs",
4448
at_tag = "tag",
4549
at_verifying_key = "verifying_key",
@@ -131,6 +135,19 @@ impl<'a> RustlerDecoder<'a> for Vec<u32> {
131135
}
132136
}
133137

138+
impl RustlerEncoder for Digest {
139+
fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
140+
self.as_words().to_vec().rustler_encode(env)
141+
}
142+
}
143+
144+
impl<'a> RustlerDecoder<'a> for Digest {
145+
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
146+
let binary: Vec<u32> = term.decode()?;
147+
binary.try_into().map_err(|_| Error::BadArg)
148+
}
149+
}
150+
134151
impl RustlerEncoder for AffinePoint {
135152
fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
136153
bincode::serialize(self)
@@ -361,9 +378,9 @@ impl RustlerEncoder for LogicVerifierInputs {
361378
impl<'a> RustlerDecoder<'a> for LogicVerifierInputs {
362379
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
363380
let tag_term = term.map_get(at_tag().encode(term.get_env()))?;
364-
let tag: Vec<u32> = RustlerDecoder::rustler_decode(tag_term)?;
381+
let tag = RustlerDecoder::rustler_decode(tag_term)?;
365382
let verifying_key_term = term.map_get(at_verifying_key().encode(term.get_env()))?;
366-
let verifying_key: Vec<u32> = RustlerDecoder::rustler_decode(verifying_key_term)?;
383+
let verifying_key = RustlerDecoder::rustler_decode(verifying_key_term)?;
367384
let app_data_term = term.map_get(at_app_data_key().encode(term.get_env()))?;
368385
let app_data: AppData = app_data_term.decode()?;
369386
let proof_term = term.map_get(at_proof().encode(term.get_env()))?;
@@ -378,6 +395,45 @@ impl<'a> RustlerDecoder<'a> for LogicVerifierInputs {
378395
}
379396
}
380397

398+
impl RustlerEncoder for LogicInstance {
399+
fn rustler_encode<'a>(&self, env: Env<'a>) -> NifResult<Term<'a>> {
400+
map_new(env)
401+
.map_put(at_struct().encode(env), at_logic_instance().encode(env))?
402+
.map_put(at_tag().encode(env), self.tag.rustler_encode(env)?)?
403+
.map_put(at_is_consumed().encode(env), self.is_consumed.encode(env))?
404+
.map_put(at_root().encode(env), self.root.rustler_encode(env)?)?
405+
.map_put(
406+
at_app_data().encode(env),
407+
self.app_data.rustler_encode(env)?,
408+
)
409+
}
410+
}
411+
412+
impl<'a> RustlerDecoder<'a> for LogicInstance {
413+
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
414+
let env = term.get_env();
415+
416+
let tag_term = term.map_get(at_tag().encode(env))?;
417+
let tag = RustlerDecoder::rustler_decode(tag_term)?;
418+
419+
let is_consumed_term = term.map_get(at_is_consumed().encode(env))?;
420+
let is_consumed: bool = is_consumed_term.decode()?;
421+
422+
let root_term = term.map_get(at_root().encode(env))?;
423+
let root = RustlerDecoder::rustler_decode(root_term)?;
424+
425+
let app_data_term = term.map_get(at_app_data().encode(env))?;
426+
let app_data = RustlerDecoder::rustler_decode(app_data_term)?;
427+
428+
Ok(LogicInstance {
429+
tag,
430+
is_consumed,
431+
root,
432+
app_data,
433+
})
434+
}
435+
}
436+
381437
impl Encoder for LogicVerifierInputs {
382438
fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
383439
let encoded = self.rustler_encode(env);
@@ -450,7 +506,7 @@ impl RustlerEncoder for MerkleTree {
450506
let encoded_vec: Term = self
451507
.leaves
452508
.iter()
453-
.map(|leaf: &Vec<u32>| {
509+
.map(|leaf| {
454510
leaf.rustler_encode(env)
455511
.expect("could not encode MerkleTree leaf")
456512
})
@@ -471,7 +527,7 @@ impl<'a> RustlerDecoder<'a> for MerkleTree {
471527
let leaves_terms =
472528
Vec::<Term>::decode(leaves_term).expect("failed to decode MerkleTree leaves");
473529

474-
let leaves: Vec<Vec<u32>> = leaves_terms
530+
let leaves: Vec<Digest> = leaves_terms
475531
.iter()
476532
.map(|term| RustlerDecoder::rustler_decode(*term).expect("failed to decode leaf"))
477533
.collect();
@@ -518,11 +574,11 @@ impl<'a> RustlerDecoder<'a> for MerklePath {
518574
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
519575
let path_terms = Vec::<Term>::decode(term).expect("failed to decode MerklePath list");
520576

521-
let path: Vec<(Vec<u32>, bool)> = path_terms
577+
let path: Vec<(Digest, bool)> = path_terms
522578
.iter()
523579
.map(|term| {
524580
let tuple: (Term, Term) = term.decode().expect("failed to decode MerklePath tuple");
525-
let hash: Vec<u32> = RustlerDecoder::rustler_decode(tuple.0)
581+
let hash: Digest = RustlerDecoder::rustler_decode(tuple.0)
526582
.expect("failed to decode MerklePath hash");
527583
let is_right: bool = tuple
528584
.1
@@ -579,9 +635,14 @@ impl RustlerEncoder for ComplianceInstance {
579635
at_created_logic_ref().encode(env),
580636
self.created_logic_ref.rustler_encode(env)?,
581637
)?
582-
.map_put(at_delta_x().encode(env), self.delta_x.rustler_encode(env)?)?
583-
.map_put(at_delta_y().encode(env), self.delta_y.rustler_encode(env)?)?;
584-
638+
.map_put(
639+
at_delta_x().encode(env),
640+
self.delta_x.to_vec().rustler_encode(env)?,
641+
)?
642+
.map_put(
643+
at_delta_y().encode(env),
644+
self.delta_y.to_vec().rustler_encode(env)?,
645+
)?;
585646
Ok(map)
586647
}
587648
}
@@ -590,38 +651,37 @@ impl<'a> RustlerDecoder<'a> for ComplianceInstance {
590651
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
591652
let consumed_nullifier_term =
592653
term.map_get(at_consumed_nullifier().encode(term.get_env()))?;
593-
let consumed_nullifier: Vec<u32> = RustlerDecoder::rustler_decode(consumed_nullifier_term)?;
654+
let consumed_nullifier = RustlerDecoder::rustler_decode(consumed_nullifier_term)?;
594655

595656
let consumed_logic_ref_term =
596657
term.map_get(at_consumed_logic_ref().encode(term.get_env()))?;
597-
let consumed_logic_ref: Vec<u32> = RustlerDecoder::rustler_decode(consumed_logic_ref_term)?;
658+
let consumed_logic_ref = RustlerDecoder::rustler_decode(consumed_logic_ref_term)?;
598659

599660
let consumed_commitment_tree_root_term =
600661
term.map_get(at_consumed_commitment_tree_root().encode(term.get_env()))?;
601-
let consumed_commitment_tree_root: Vec<u32> =
662+
let consumed_commitment_tree_root =
602663
RustlerDecoder::rustler_decode(consumed_commitment_tree_root_term)?;
603664

604665
let created_commitment_term =
605666
term.map_get(at_created_commitment().encode(term.get_env()))?;
606-
let created_commitment: Vec<u32> = RustlerDecoder::rustler_decode(created_commitment_term)?;
667+
let created_commitment = RustlerDecoder::rustler_decode(created_commitment_term)?;
607668

608669
let created_logic_ref_term = term.map_get(at_created_logic_ref().encode(term.get_env()))?;
609-
let created_logic_ref: Vec<u32> = RustlerDecoder::rustler_decode(created_logic_ref_term)?;
670+
let created_logic_ref = RustlerDecoder::rustler_decode(created_logic_ref_term)?;
610671

611672
let delta_x_term = term.map_get(at_delta_x().encode(term.get_env()))?;
612673
let delta_x: Vec<u32> = RustlerDecoder::rustler_decode(delta_x_term)?;
613674

614675
let delta_y_term = term.map_get(at_delta_y().encode(term.get_env()))?;
615676
let delta_y: Vec<u32> = RustlerDecoder::rustler_decode(delta_y_term)?;
616-
617677
Ok(ComplianceInstance {
618678
consumed_nullifier,
619679
consumed_logic_ref,
620680
consumed_commitment_tree_root,
621681
created_commitment,
622682
created_logic_ref,
623-
delta_x,
624-
delta_y,
683+
delta_x: <[u32; 8]>::try_from(delta_x).map_err(|_e| Error::BadArg)?,
684+
delta_y: <[u32; 8]>::try_from(delta_y).map_err(|_e| Error::BadArg)?,
625685
})
626686
}
627687
}
@@ -678,7 +738,7 @@ impl<'a> RustlerDecoder<'a> for ComplianceWitness {
678738
let merkle_path: MerklePath = RustlerDecoder::rustler_decode(merkle_path_term)?;
679739

680740
let ephemeral_root_term = term.map_get(at_ephemeral_root().encode(term.get_env()))?;
681-
let ephemeral_root: Vec<u32> = RustlerDecoder::rustler_decode(ephemeral_root_term)?;
741+
let ephemeral_root = RustlerDecoder::rustler_decode(ephemeral_root_term)?;
682742

683743
let nf_key_term = term.map_get(at_nf_key().encode(term.get_env()))?;
684744
let nf_key: NullifierKey = nf_key_term.decode()?;
@@ -718,15 +778,16 @@ impl<'a> Decoder<'a> for ComplianceWitness {
718778

719779
impl RustlerEncoder for NullifierKeyCommitment {
720780
fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
721-
let inner_bytes = self.inner().to_vec();
781+
let inner_bytes = self.inner().as_words().to_vec();
722782
inner_bytes.rustler_encode(env)
723783
}
724784
}
725785

726786
impl<'a> RustlerDecoder<'a> for NullifierKeyCommitment {
727787
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
728788
let bytes: Vec<u8> = RustlerDecoder::rustler_decode(term)?;
729-
Ok(NullifierKeyCommitment::from_bytes(&bytes))
789+
Ok(NullifierKeyCommitment::from_bytes(&bytes)
790+
.map_err(|e| Error::Term(Box::new(e.to_string())))?)
730791
}
731792
}
732793

@@ -794,14 +855,17 @@ impl RustlerEncoder for Resource {
794855
self.value_ref.rustler_encode(env)?,
795856
)?
796857
.map_put(at_is_ephemeral().encode(env), self.is_ephemeral.encode(env))?
797-
.map_put(at_nonce().encode(env), self.nonce.rustler_encode(env)?)?
858+
.map_put(
859+
at_nonce().encode(env),
860+
self.nonce.to_vec().rustler_encode(env)?,
861+
)?
798862
.map_put(
799863
at_nk_commitment().encode(env),
800864
self.nk_commitment.rustler_encode(env)?,
801865
)?
802866
.map_put(
803867
at_rand_seed().encode(env),
804-
self.rand_seed.rustler_encode(env)?,
868+
self.rand_seed.to_vec().rustler_encode(env)?,
805869
)?;
806870

807871
Ok(map)
@@ -811,16 +875,16 @@ impl RustlerEncoder for Resource {
811875
impl<'a> RustlerDecoder<'a> for Resource {
812876
fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
813877
let logic_ref_term = term.map_get(at_logic_ref().encode(term.get_env()))?;
814-
let logic_ref: Vec<u8> = RustlerDecoder::rustler_decode(logic_ref_term)?;
878+
let logic_ref = RustlerDecoder::rustler_decode(logic_ref_term)?;
815879

816880
let label_ref_term = term.map_get(at_label_ref().encode(term.get_env()))?;
817-
let label_ref: Vec<u8> = RustlerDecoder::rustler_decode(label_ref_term)?;
881+
let label_ref = RustlerDecoder::rustler_decode(label_ref_term)?;
818882

819883
let quantity_term = term.map_get(at_quantity().encode(term.get_env()))?;
820884
let quantity: u128 = quantity_term.decode()?;
821885

822886
let value_ref_term = term.map_get(at_value_ref().encode(term.get_env()))?;
823-
let value_ref: Vec<u8> = RustlerDecoder::rustler_decode(value_ref_term)?;
887+
let value_ref = RustlerDecoder::rustler_decode(value_ref_term)?;
824888

825889
let is_ephemeral_term = term.map_get(at_is_ephemeral().encode(term.get_env()))?;
826890
let is_ephemeral: bool = is_ephemeral_term.decode()?;
@@ -841,9 +905,11 @@ impl<'a> RustlerDecoder<'a> for Resource {
841905
quantity,
842906
value_ref,
843907
is_ephemeral,
844-
nonce,
908+
nonce: <[u8; 32]>::try_from(nonce)
909+
.map_err(|_e| Error::Term(Box::new("invalid_nonce")))?,
845910
nk_commitment,
846-
rand_seed,
911+
rand_seed: <[u8; 32]>::try_from(rand_seed)
912+
.map_err(|_e| Error::Term(Box::new("invalid_nonce")))?,
847913
})
848914
}
849915
}
@@ -971,7 +1037,7 @@ impl<'a> RustlerDecoder<'a> for LogicVerifier {
9711037
let instance: Vec<u8> = RustlerDecoder::rustler_decode(instance_term)?;
9721038

9731039
let verifying_key_term = term.map_get(at_verifying_key().encode(term.get_env()))?;
974-
let verifying_key: Vec<u32> = RustlerDecoder::rustler_decode(verifying_key_term)?;
1040+
let verifying_key = RustlerDecoder::rustler_decode(verifying_key_term)?;
9751041

9761042
Ok(LogicVerifier {
9771043
proof,

0 commit comments

Comments
 (0)