Remove all instance of .expect with proper error handling

mariari · mariari · commit b4d5b6cd5d1c · 2025-10-02T20:05:15.000+08:00
Doing this improperly can crash the Erlang VM. Every instnace of this
where the end type is a result type or something analygous (like the
Term&lt;'a&gt; type) now is expectless.

More work needs to be done for functions that do not fit this
architype which is 13 methods in arm/src
diff --git a/arm/src/encryption.rs b/arm/src/encryption.rs
@@ -48,16 +48,15 @@ fn do_encode<'a>(secret_key: &SecretKey, env: Env<'a>) -> Result<Term<'a>, Error
 #[cfg(feature = "nif")]
 impl Encoder for SecretKey {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let result = do_encode(self, env).expect("failed to encode SecretKey");
-        result
+        do_encode(self, env).unwrap_or_else(|_| env.error_tuple("failed to encode SecretKey"))
     }
 }
 
 #[cfg(feature = "nif")]
 impl<'a> Decoder<'a> for SecretKey {
     fn decode(term: Term<'a>) -> NifResult<Self> {
         let binary = term.decode_as_binary()?.as_slice();
-        let scalar: Scalar = bincode::deserialize(binary).expect("failed to decode SecretKey");
+        let scalar: Scalar = bincode_deserialize(binary)?;
         Ok(SecretKey(scalar))
     }
 }
diff --git a/arm/src/rustler_util.rs b/arm/src/rustler_util.rs
@@ -126,25 +126,22 @@ impl<'a> RustlerDecoder<'a> for Binary<'a> {
 impl RustlerEncoder for Vec<u8> {
     fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
         let mut erl_bin = OwnedBinary::new(self.len())
-            .ok_or("could not create OwnedBinary")
-            .expect("could not allocate binary");
+            .ok_or_else(|| Error::RaiseTerm(Box::new("could not create OwnedBinary")))?;
         let _ = erl_bin.as_mut_slice().write_all(&self.as_slice());
         Ok(erl_bin.release(env).to_term(env))
     }
 }
 
 impl<'a> RustlerDecoder<'a> for Vec<u8> {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
-        let binary: Binary = term.decode().expect("failed to decode binary");
-        Ok(binary.as_slice().to_vec())
+        term.decode::<Binary>().map(|t| t.to_vec())
     }
 }
 
 impl RustlerEncoder for Vec<u32> {
     fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
         let mut erl_bin: OwnedBinary = OwnedBinary::new(self.len() * 4)
-            .ok_or("could not create OwnedBinary")
-            .expect("could not allocate binary");
+            .ok_or_else(|| Error::RaiseTerm(Box::new("could not create OwnedBinary")))?;
         let bytes: &[u8] = words_to_bytes(self.as_slice());
         let _ = erl_bin.as_mut_slice().write_all(bytes);
         Ok(erl_bin.release(env).to_term(env))
@@ -153,10 +150,8 @@ impl RustlerEncoder for Vec<u32> {
 
 impl<'a> RustlerDecoder<'a> for Vec<u32> {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
-        let binary: Binary = term.decode().expect("failed to decode binary");
-        let bytes: &[u8] = binary.as_slice();
-        let words: Vec<u32> = bytes_to_words(bytes);
-        Ok(words)
+        term.decode::<Binary>()
+            .map(|b| bytes_to_words(b.as_slice()))
     }
 }
 
@@ -175,9 +170,7 @@ impl<'a> RustlerDecoder<'a> for Digest {
 
 impl RustlerEncoder for AffinePoint {
     fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
-        bincode::serialize(self)
-            .expect("failed to encode AffinePoint")
-            .rustler_encode(env)
+        bincode_serialize(self)?.rustler_encode(env)
     }
 }
 
@@ -190,9 +183,7 @@ impl<'a> RustlerDecoder<'a> for AffinePoint {
 
 impl RustlerEncoder for Signature {
     fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {
-        bincode::serialize(self)
-            .expect("failed to encode Signature")
-            .rustler_encode(env)
+        bincode_serialize(self)?.rustler_encode(env)
     }
 }
 
@@ -213,7 +204,7 @@ impl RustlerEncoder for RecoveryId {
 impl<'a> RustlerDecoder<'a> for RecoveryId {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
         let byte: u8 = term.decode()?;
-        Ok(RecoveryId::from_byte(byte).expect("invalid RecoveryId"))
+        RecoveryId::from_byte(byte).ok_or_else(|| Error::Term(Box::new("RecoveryId")))
     }
 }
 
@@ -228,7 +219,7 @@ impl RustlerEncoder for SigningKey {
 impl<'a> RustlerDecoder<'a> for SigningKey {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
         let bytez: Vec<u8> = RustlerDecoder::rustler_decode(term)?;
-        Ok(SigningKey::from_slice(&bytez).expect("invalid SigningKey"))
+        SigningKey::from_slice(&bytez).map_err(|_| Error::Term(Box::new("invalid SigningKey")))
     }
 }
 
@@ -261,8 +252,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceUnit {
 
 impl Encoder for ComplianceUnit {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode ComplianceUnit")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode ComplianceUnit"))
     }
 }
 
@@ -304,8 +295,8 @@ impl<'a> RustlerDecoder<'a> for ExpirableBlob {
 
 impl Encoder for ExpirableBlob {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode ExpirableBlob")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode ExpirableBlob"))
     }
 }
 
@@ -365,8 +356,8 @@ impl<'a> RustlerDecoder<'a> for AppData {
 
 impl Encoder for AppData {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode AppData")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode AppData"))
     }
 }
 
@@ -459,8 +450,8 @@ impl<'a> RustlerDecoder<'a> for LogicInstance {
 
 impl Encoder for LogicVerifierInputs {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode LogicVerifierInputs")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode LogicVerifierInputs"))
     }
 }
 
@@ -508,8 +499,8 @@ impl<'a> RustlerDecoder<'a> for Action {
 
 impl Encoder for Action {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode Action")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode Action"))
     }
 }
 
@@ -529,11 +520,8 @@ impl RustlerEncoder for MerkleTree {
         let encoded_vec: Term = self
             .leaves
             .iter()
-            .map(|leaf| {
-                leaf.rustler_encode(env)
-                    .expect("could not encode MerkleTree leaf")
-            })
-            .collect::<Vec<Term>>()
+            .map(|leaf| leaf.rustler_encode(env))
+            .collect::<NifResult<Vec<Term>>>()?
             .encode(env);
 
         let map = map_new(env)
@@ -547,22 +535,21 @@ impl RustlerEncoder for MerkleTree {
 impl<'a> RustlerDecoder<'a> for MerkleTree {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
         let leaves_term = term.map_get(at_leaves().encode(term.get_env()))?;
-        let leaves_terms =
-            Vec::<Term>::decode(leaves_term).expect("failed to decode MerkleTree leaves");
+        let leaves_terms = Vec::<Term>::decode(leaves_term)?;
 
         let leaves: Vec<Digest> = leaves_terms
             .iter()
-            .map(|term| RustlerDecoder::rustler_decode(*term).expect("failed to decode leaf"))
-            .collect();
+            .map(|term| RustlerDecoder::rustler_decode(*term))
+            .collect::<NifResult<Vec<_>>>()?;
 
         Ok(MerkleTree { leaves })
     }
 }
 
 impl Encoder for MerkleTree {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode MerkleTree")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode MerkleTree"))
     }
 }
 
@@ -581,44 +568,33 @@ impl RustlerEncoder for MerklePath {
             .0
             .iter()
             .map(|(hash, is_right)| {
-                let hash_term = hash
-                    .rustler_encode(env)
-                    .expect("could not encode MerklePath hash");
-                let is_right_term = is_right.encode(env);
-                (hash_term, is_right_term).encode(env)
+                Ok((hash.rustler_encode(env)?, is_right.encode(env)).encode(env))
             })
-            .collect();
+            .collect::<NifResult<Vec<Term>>>()?;
 
         Ok(encoded_vec.encode(env))
     }
 }
 
 impl<'a> RustlerDecoder<'a> for MerklePath {
     fn rustler_decode(term: Term<'a>) -> NifResult<Self> {
-        let path_terms = Vec::<Term>::decode(term).expect("failed to decode MerklePath list");
-
-        let path: Vec<(Digest, bool)> = path_terms
+        Vec::<Term>::decode(term)?
             .iter()
             .map(|term| {
-                let tuple: (Term, Term) = term.decode().expect("failed to decode MerklePath tuple");
-                let hash: Digest = RustlerDecoder::rustler_decode(tuple.0)
-                    .expect("failed to decode MerklePath hash");
-                let is_right: bool = tuple
-                    .1
-                    .decode()
-                    .expect("failed to decode MerklePath boolean");
-                (hash, is_right)
+                let tuple: (Term, Term) = term.decode()?;
+                let hash: Digest = RustlerDecoder::rustler_decode(tuple.0)?;
+                let is_right: bool = tuple.1.decode()?;
+                Ok((hash, is_right))
             })
-            .collect();
-
-        Ok(MerklePath(path))
+            .collect::<NifResult<Vec<(Digest, bool)>>>()
+            .map(MerklePath)
     }
 }
 
 impl Encoder for MerklePath {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode MerklePath")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_e| env.error_tuple("failed to encode MerklePath"))
     }
 }
 
@@ -711,8 +687,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceInstance {
 
 impl Encoder for ComplianceInstance {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode ComplianceInstance")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode compliance instance"))
     }
 }
 
@@ -785,8 +761,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceWitness {
 
 impl Encoder for ComplianceWitness {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode ComplianceWitness")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode compliance witness"))
     }
 }
 
@@ -816,8 +792,8 @@ impl<'a> RustlerDecoder<'a> for NullifierKeyCommitment {
 
 impl Encoder for NullifierKeyCommitment {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode NullifierKeyCommitment")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode nullifier"))
     }
 }
 
@@ -846,8 +822,8 @@ impl<'a> RustlerDecoder<'a> for NullifierKey {
 
 impl Encoder for NullifierKey {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode NullifierKey")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode NullifierKey"))
     }
 }
 
@@ -939,8 +915,8 @@ impl<'a> RustlerDecoder<'a> for Resource {
 
 impl Encoder for Resource {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode Resource")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode Resource"))
     }
 }
 
@@ -981,8 +957,8 @@ impl<'a> RustlerDecoder<'a> for DeltaProof {
 
 impl Encoder for DeltaProof {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode DeltaProof")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode DeltaProof"))
     }
 }
 
@@ -1019,8 +995,8 @@ impl<'a> RustlerDecoder<'a> for DeltaWitness {
 
 impl Encoder for DeltaWitness {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode DeltaWitness")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode DeltaWitness"))
     }
 }
 
@@ -1073,7 +1049,7 @@ impl<'a> RustlerDecoder<'a> for LogicVerifier {
 impl Encoder for LogicVerifier {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
         let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode LogicVerifier")
+        encoded.unwrap_or_else(|_e| env.error_tuple("failed to encode LogicVerifier"))
     }
 }
 
@@ -1131,8 +1107,8 @@ impl<'a> RustlerDecoder<'a> for Transaction {
 
 impl Encoder for Transaction {
     fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-        let encoded = self.rustler_encode(env);
-        encoded.expect("failed to encode Transaction")
+        self.rustler_encode(env)
+            .unwrap_or_else(|_| env.error_tuple("failed to encode Transaction"))
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -48,16 +48,15 @@ fn do_encode<'a>(secret_key: &SecretKey, env: Env<'a>) -> Result<Term<'a>, Error`
`48`	`48`	`#[cfg(feature = "nif")]`
`49`	`49`	`impl Encoder for SecretKey {`
`50`	`50`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`51`		`- let result = do_encode(self, env).expect("failed to encode SecretKey");`
`52`		`- result`
	`51`	`+ do_encode(self, env).unwrap_or_else(\|_\| env.error_tuple("failed to encode SecretKey"))`
`53`	`52`	`}`
`54`	`53`	`}`
`55`	`54`
`56`	`55`	`#[cfg(feature = "nif")]`
`57`	`56`	`impl<'a> Decoder<'a> for SecretKey {`
`58`	`57`	`fn decode(term: Term<'a>) -> NifResult<Self> {`
`59`	`58`	`let binary = term.decode_as_binary()?.as_slice();`
`60`		`- let scalar: Scalar = bincode::deserialize(binary).expect("failed to decode SecretKey");`
	`59`	`+ let scalar: Scalar = bincode_deserialize(binary)?;`
`61`	`60`	`Ok(SecretKey(scalar))`
`62`	`61`	`}`
`63`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -126,25 +126,22 @@ impl<'a> RustlerDecoder<'a> for Binary<'a> {`
`126`	`126`	`impl RustlerEncoder for Vec<u8> {`
`127`	`127`	`fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {`
`128`	`128`	`let mut erl_bin = OwnedBinary::new(self.len())`
`129`		`- .ok_or("could not create OwnedBinary")`
`130`		`- .expect("could not allocate binary");`
	`129`	`+ .ok_or_else(\|\| Error::RaiseTerm(Box::new("could not create OwnedBinary")))?;`
`131`	`130`	`let _ = erl_bin.as_mut_slice().write_all(&self.as_slice());`
`132`	`131`	`Ok(erl_bin.release(env).to_term(env))`
`133`	`132`	`}`
`134`	`133`	`}`
`135`	`134`
`136`	`135`	`impl<'a> RustlerDecoder<'a> for Vec<u8> {`
`137`	`136`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`138`		`- let binary: Binary = term.decode().expect("failed to decode binary");`
`139`		`- Ok(binary.as_slice().to_vec())`
	`137`	`+ term.decode::<Binary>().map(\|t\| t.to_vec())`
`140`	`138`	`}`
`141`	`139`	`}`
`142`	`140`
`143`	`141`	`impl RustlerEncoder for Vec<u32> {`
`144`	`142`	`fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {`
`145`	`143`	`let mut erl_bin: OwnedBinary = OwnedBinary::new(self.len() * 4)`
`146`		`- .ok_or("could not create OwnedBinary")`
`147`		`- .expect("could not allocate binary");`
	`144`	`+ .ok_or_else(\|\| Error::RaiseTerm(Box::new("could not create OwnedBinary")))?;`
`148`	`145`	`let bytes: &[u8] = words_to_bytes(self.as_slice());`
`149`	`146`	`let _ = erl_bin.as_mut_slice().write_all(bytes);`
`150`	`147`	`Ok(erl_bin.release(env).to_term(env))`
`@@ -153,10 +150,8 @@ impl RustlerEncoder for Vec<u32> {`
`153`	`150`
`154`	`151`	`impl<'a> RustlerDecoder<'a> for Vec<u32> {`
`155`	`152`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`156`		`- let binary: Binary = term.decode().expect("failed to decode binary");`
`157`		`- let bytes: &[u8] = binary.as_slice();`
`158`		`- let words: Vec<u32> = bytes_to_words(bytes);`
`159`		`- Ok(words)`
	`153`	`+ term.decode::<Binary>()`
	`154`	`+ .map(\|b\| bytes_to_words(b.as_slice()))`
`160`	`155`	`}`
`161`	`156`	`}`
`162`	`157`
`@@ -175,9 +170,7 @@ impl<'a> RustlerDecoder<'a> for Digest {`
`175`	`170`
`176`	`171`	`impl RustlerEncoder for AffinePoint {`
`177`	`172`	`fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {`
`178`		`- bincode::serialize(self)`
`179`		`- .expect("failed to encode AffinePoint")`
`180`		`- .rustler_encode(env)`
	`173`	`+ bincode_serialize(self)?.rustler_encode(env)`
`181`	`174`	`}`
`182`	`175`	`}`
`183`	`176`
`@@ -190,9 +183,7 @@ impl<'a> RustlerDecoder<'a> for AffinePoint {`
`190`	`183`
`191`	`184`	`impl RustlerEncoder for Signature {`
`192`	`185`	`fn rustler_encode<'a>(&self, env: Env<'a>) -> Result<Term<'a>, Error> {`
`193`		`- bincode::serialize(self)`
`194`		`- .expect("failed to encode Signature")`
`195`		`- .rustler_encode(env)`
	`186`	`+ bincode_serialize(self)?.rustler_encode(env)`
`196`	`187`	`}`
`197`	`188`	`}`
`198`	`189`
`@@ -213,7 +204,7 @@ impl RustlerEncoder for RecoveryId {`
`213`	`204`	`impl<'a> RustlerDecoder<'a> for RecoveryId {`
`214`	`205`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`215`	`206`	`let byte: u8 = term.decode()?;`
`216`		`- Ok(RecoveryId::from_byte(byte).expect("invalid RecoveryId"))`
	`207`	`+ RecoveryId::from_byte(byte).ok_or_else(\|\| Error::Term(Box::new("RecoveryId")))`
`217`	`208`	`}`
`218`	`209`	`}`
`219`	`210`
`@@ -228,7 +219,7 @@ impl RustlerEncoder for SigningKey {`
`228`	`219`	`impl<'a> RustlerDecoder<'a> for SigningKey {`
`229`	`220`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`230`	`221`	`let bytez: Vec<u8> = RustlerDecoder::rustler_decode(term)?;`
`231`		`- Ok(SigningKey::from_slice(&bytez).expect("invalid SigningKey"))`
	`222`	`+ SigningKey::from_slice(&bytez).map_err(\|_\| Error::Term(Box::new("invalid SigningKey")))`
`232`	`223`	`}`
`233`	`224`	`}`
`234`	`225`
`@@ -261,8 +252,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceUnit {`
`261`	`252`
`262`	`253`	`impl Encoder for ComplianceUnit {`
`263`	`254`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`264`		`- let encoded = self.rustler_encode(env);`
`265`		`- encoded.expect("failed to encode ComplianceUnit")`
	`255`	`+ self.rustler_encode(env)`
	`256`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode ComplianceUnit"))`
`266`	`257`	`}`
`267`	`258`	`}`
`268`	`259`
`@@ -304,8 +295,8 @@ impl<'a> RustlerDecoder<'a> for ExpirableBlob {`
`304`	`295`
`305`	`296`	`impl Encoder for ExpirableBlob {`
`306`	`297`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`307`		`- let encoded = self.rustler_encode(env);`
`308`		`- encoded.expect("failed to encode ExpirableBlob")`
	`298`	`+ self.rustler_encode(env)`
	`299`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode ExpirableBlob"))`
`309`	`300`	`}`
`310`	`301`	`}`
`311`	`302`
`@@ -365,8 +356,8 @@ impl<'a> RustlerDecoder<'a> for AppData {`
`365`	`356`
`366`	`357`	`impl Encoder for AppData {`
`367`	`358`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`368`		`- let encoded = self.rustler_encode(env);`
`369`		`- encoded.expect("failed to encode AppData")`
	`359`	`+ self.rustler_encode(env)`
	`360`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode AppData"))`
`370`	`361`	`}`
`371`	`362`	`}`
`372`	`363`
`@@ -459,8 +450,8 @@ impl<'a> RustlerDecoder<'a> for LogicInstance {`
`459`	`450`
`460`	`451`	`impl Encoder for LogicVerifierInputs {`
`461`	`452`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`462`		`- let encoded = self.rustler_encode(env);`
`463`		`- encoded.expect("failed to encode LogicVerifierInputs")`
	`453`	`+ self.rustler_encode(env)`
	`454`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode LogicVerifierInputs"))`
`464`	`455`	`}`
`465`	`456`	`}`
`466`	`457`
`@@ -508,8 +499,8 @@ impl<'a> RustlerDecoder<'a> for Action {`
`508`	`499`
`509`	`500`	`impl Encoder for Action {`
`510`	`501`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`511`		`- let encoded = self.rustler_encode(env);`
`512`		`- encoded.expect("failed to encode Action")`
	`502`	`+ self.rustler_encode(env)`
	`503`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode Action"))`
`513`	`504`	`}`
`514`	`505`	`}`
`515`	`506`
`@@ -529,11 +520,8 @@ impl RustlerEncoder for MerkleTree {`
`529`	`520`	`let encoded_vec: Term = self`
`530`	`521`	`.leaves`
`531`	`522`	`.iter()`
`532`		`- .map(\|leaf\| {`
`533`		`- leaf.rustler_encode(env)`
`534`		`- .expect("could not encode MerkleTree leaf")`
`535`		`- })`
`536`		`- .collect::<Vec<Term>>()`
	`523`	`+ .map(\|leaf\| leaf.rustler_encode(env))`
	`524`	`+ .collect::<NifResult<Vec<Term>>>()?`
`537`	`525`	`.encode(env);`
`538`	`526`
`539`	`527`	`let map = map_new(env)`
`@@ -547,22 +535,21 @@ impl RustlerEncoder for MerkleTree {`
`547`	`535`	`impl<'a> RustlerDecoder<'a> for MerkleTree {`
`548`	`536`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`549`	`537`	`let leaves_term = term.map_get(at_leaves().encode(term.get_env()))?;`
`550`		`- let leaves_terms =`
`551`		`- Vec::<Term>::decode(leaves_term).expect("failed to decode MerkleTree leaves");`
	`538`	`+ let leaves_terms = Vec::<Term>::decode(leaves_term)?;`
`552`	`539`
`553`	`540`	`let leaves: Vec<Digest> = leaves_terms`
`554`	`541`	`.iter()`
`555`		`- .map(\|term\| RustlerDecoder::rustler_decode(*term).expect("failed to decode leaf"))`
`556`		`- .collect();`
	`542`	`+ .map(\|term\| RustlerDecoder::rustler_decode(*term))`
	`543`	`+ .collect::<NifResult<Vec<_>>>()?;`
`557`	`544`
`558`	`545`	`Ok(MerkleTree { leaves })`
`559`	`546`	`}`
`560`	`547`	`}`
`561`	`548`
`562`	`549`	`impl Encoder for MerkleTree {`
`563`	`550`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`564`		`- let encoded = self.rustler_encode(env);`
`565`		`- encoded.expect("failed to encode MerkleTree")`
	`551`	`+ self.rustler_encode(env)`
	`552`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode MerkleTree"))`
`566`	`553`	`}`
`567`	`554`	`}`
`568`	`555`
`@@ -581,44 +568,33 @@ impl RustlerEncoder for MerklePath {`
`581`	`568`	`.0`
`582`	`569`	`.iter()`
`583`	`570`	`.map(\|(hash, is_right)\| {`
`584`		`- let hash_term = hash`
`585`		`- .rustler_encode(env)`
`586`		`- .expect("could not encode MerklePath hash");`
`587`		`- let is_right_term = is_right.encode(env);`
`588`		`- (hash_term, is_right_term).encode(env)`
	`571`	`+ Ok((hash.rustler_encode(env)?, is_right.encode(env)).encode(env))`
`589`	`572`	`})`
`590`		`- .collect();`
	`573`	`+ .collect::<NifResult<Vec<Term>>>()?;`
`591`	`574`
`592`	`575`	`Ok(encoded_vec.encode(env))`
`593`	`576`	`}`
`594`	`577`	`}`
`595`	`578`
`596`	`579`	`impl<'a> RustlerDecoder<'a> for MerklePath {`
`597`	`580`	`fn rustler_decode(term: Term<'a>) -> NifResult<Self> {`
`598`		`- let path_terms = Vec::<Term>::decode(term).expect("failed to decode MerklePath list");`
`599`		`-`
`600`		`- let path: Vec<(Digest, bool)> = path_terms`
	`581`	`+ Vec::<Term>::decode(term)?`
`601`	`582`	`.iter()`
`602`	`583`	`.map(\|term\| {`
`603`		`- let tuple: (Term, Term) = term.decode().expect("failed to decode MerklePath tuple");`
`604`		`- let hash: Digest = RustlerDecoder::rustler_decode(tuple.0)`
`605`		`- .expect("failed to decode MerklePath hash");`
`606`		`- let is_right: bool = tuple`
`607`		`- .1`
`608`		`- .decode()`
`609`		`- .expect("failed to decode MerklePath boolean");`
`610`		`- (hash, is_right)`
	`584`	`+ let tuple: (Term, Term) = term.decode()?;`
	`585`	`+ let hash: Digest = RustlerDecoder::rustler_decode(tuple.0)?;`
	`586`	`+ let is_right: bool = tuple.1.decode()?;`
	`587`	`+ Ok((hash, is_right))`
`611`	`588`	`})`
`612`		`- .collect();`
`613`		`-`
`614`		`- Ok(MerklePath(path))`
	`589`	`+ .collect::<NifResult<Vec<(Digest, bool)>>>()`
	`590`	`+ .map(MerklePath)`
`615`	`591`	`}`
`616`	`592`	`}`
`617`	`593`
`618`	`594`	`impl Encoder for MerklePath {`
`619`	`595`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`620`		`- let encoded = self.rustler_encode(env);`
`621`		`- encoded.expect("failed to encode MerklePath")`
	`596`	`+ self.rustler_encode(env)`
	`597`	`+ .unwrap_or_else(\|_e\| env.error_tuple("failed to encode MerklePath"))`
`622`	`598`	`}`
`623`	`599`	`}`
`624`	`600`
`@@ -711,8 +687,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceInstance {`
`711`	`687`
`712`	`688`	`impl Encoder for ComplianceInstance {`
`713`	`689`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`714`		`- let encoded = self.rustler_encode(env);`
`715`		`- encoded.expect("failed to encode ComplianceInstance")`
	`690`	`+ self.rustler_encode(env)`
	`691`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode compliance instance"))`
`716`	`692`	`}`
`717`	`693`	`}`
`718`	`694`
`@@ -785,8 +761,8 @@ impl<'a> RustlerDecoder<'a> for ComplianceWitness {`
`785`	`761`
`786`	`762`	`impl Encoder for ComplianceWitness {`
`787`	`763`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`788`		`- let encoded = self.rustler_encode(env);`
`789`		`- encoded.expect("failed to encode ComplianceWitness")`
	`764`	`+ self.rustler_encode(env)`
	`765`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode compliance witness"))`
`790`	`766`	`}`
`791`	`767`	`}`
`792`	`768`
`@@ -816,8 +792,8 @@ impl<'a> RustlerDecoder<'a> for NullifierKeyCommitment {`
`816`	`792`
`817`	`793`	`impl Encoder for NullifierKeyCommitment {`
`818`	`794`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`819`		`- let encoded = self.rustler_encode(env);`
`820`		`- encoded.expect("failed to encode NullifierKeyCommitment")`
	`795`	`+ self.rustler_encode(env)`
	`796`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode nullifier"))`
`821`	`797`	`}`
`822`	`798`	`}`
`823`	`799`
`@@ -846,8 +822,8 @@ impl<'a> RustlerDecoder<'a> for NullifierKey {`
`846`	`822`
`847`	`823`	`impl Encoder for NullifierKey {`
`848`	`824`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`849`		`- let encoded = self.rustler_encode(env);`
`850`		`- encoded.expect("failed to encode NullifierKey")`
	`825`	`+ self.rustler_encode(env)`
	`826`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode NullifierKey"))`
`851`	`827`	`}`
`852`	`828`	`}`
`853`	`829`
`@@ -939,8 +915,8 @@ impl<'a> RustlerDecoder<'a> for Resource {`
`939`	`915`
`940`	`916`	`impl Encoder for Resource {`
`941`	`917`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`942`		`- let encoded = self.rustler_encode(env);`
`943`		`- encoded.expect("failed to encode Resource")`
	`918`	`+ self.rustler_encode(env)`
	`919`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode Resource"))`
`944`	`920`	`}`
`945`	`921`	`}`
`946`	`922`
`@@ -981,8 +957,8 @@ impl<'a> RustlerDecoder<'a> for DeltaProof {`
`981`	`957`
`982`	`958`	`impl Encoder for DeltaProof {`
`983`	`959`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`984`		`- let encoded = self.rustler_encode(env);`
`985`		`- encoded.expect("failed to encode DeltaProof")`
	`960`	`+ self.rustler_encode(env)`
	`961`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode DeltaProof"))`
`986`	`962`	`}`
`987`	`963`	`}`
`988`	`964`
`@@ -1019,8 +995,8 @@ impl<'a> RustlerDecoder<'a> for DeltaWitness {`
`1019`	`995`
`1020`	`996`	`impl Encoder for DeltaWitness {`
`1021`	`997`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`1022`		`- let encoded = self.rustler_encode(env);`
`1023`		`- encoded.expect("failed to encode DeltaWitness")`
	`998`	`+ self.rustler_encode(env)`
	`999`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode DeltaWitness"))`
`1024`	`1000`	`}`
`1025`	`1001`	`}`
`1026`	`1002`
`@@ -1073,7 +1049,7 @@ impl<'a> RustlerDecoder<'a> for LogicVerifier {`
`1073`	`1049`	`impl Encoder for LogicVerifier {`
`1074`	`1050`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`1075`	`1051`	`let encoded = self.rustler_encode(env);`
`1076`		`- encoded.expect("failed to encode LogicVerifier")`
	`1052`	`+ encoded.unwrap_or_else(\|_e\| env.error_tuple("failed to encode LogicVerifier"))`
`1077`	`1053`	`}`
`1078`	`1054`	`}`
`1079`	`1055`
`@@ -1131,8 +1107,8 @@ impl<'a> RustlerDecoder<'a> for Transaction {`
`1131`	`1107`
`1132`	`1108`	`impl Encoder for Transaction {`
`1133`	`1109`	`fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {`
`1134`		`- let encoded = self.rustler_encode(env);`
`1135`		`- encoded.expect("failed to encode Transaction")`
	`1110`	`+ self.rustler_encode(env)`
	`1111`	`+ .unwrap_or_else(\|_\| env.error_tuple("failed to encode Transaction"))`
`1136`	`1112`	`}`
`1137`	`1113`	`}`
`1138`	`1114`