From bffcbc786aa596a393b7cb9523c158e08a87e60f Mon Sep 17 00:00:00 2001
From: dcorral <hi@dcorral.com>
Date: Thu, 17 Sep 2026 11:55:26 +0200
Subject: [PATCH 1/2] test a contract with a signed precision

---
 src/parse.rs | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/src/parse.rs b/src/parse.rs
index ef8055f..4ccfe00 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -347,3 +347,55 @@ fn fungible_entry<Seal: ExposedSeal>(a: &Assign<rgbstd::RevealedValue, Seal>) ->
 
     FungibleEntry { amount, seal }
 }
+
+#[cfg(test)]
+mod tests {
+    use amplify::confinement::{Confined, SmallBlob};
+    use rgbstd::RevealedData;
+    use rgbstd::containers::{Contract, FileContent};
+    use rgbstd::schema::{GlobalDetails, GlobalStateSchema};
+    use strict_types::encoding::StrictDumb;
+
+    use super::*;
+
+    // Make a contract file. Its precision is a signed byte, and 0xff is the value -1.
+    fn contract_with_signed_precision() -> Vec<u8> {
+        let sem_id = Ty::<SemId>::I8.sem_id_unnamed();
+        let state_type = GlobalStateType::with(GS_PRECISION);
+
+        let mut contract = Contract::strict_dumb();
+        contract.types = TypeSystem::from_inner(Confined::from_checked([(sem_id, Ty::I8)].into()));
+        contract
+            .schema
+            .global_types
+            .insert(
+                state_type,
+                GlobalDetails {
+                    global_state_schema: GlobalStateSchema::once(sem_id),
+                    name: FieldName::from("precision"),
+                },
+            )
+            .unwrap();
+        contract
+            .genesis
+            .globals
+            .add_state(
+                state_type,
+                RevealedData::new(SmallBlob::from_checked(vec![0xff])),
+            )
+            .unwrap();
+
+        let mut bytes = Vec::new();
+        contract.save(&mut bytes).unwrap();
+        bytes
+    }
+
+    #[test]
+    fn signed_precision_does_not_crash_the_parser() {
+        let info = parse(&contract_with_signed_precision()).unwrap();
+        let ConsignmentInfo::Contract(contract) = info else {
+            panic!("the file is a contract");
+        };
+        assert_eq!(contract.genesis.precision, None);
+    }
+}

From b131147652ba8b65de4bcf117bdebf5cdc096357 Mon Sep 17 00:00:00 2001
From: dcorral <hi@dcorral.com>
Date: Thu, 17 Sep 2026 11:55:26 +0200
Subject: [PATCH 2/2] ignore signed numbers when reading precision

---
 src/parse.rs | 50 +++++---------------------------------------------
 1 file changed, 5 insertions(+), 45 deletions(-)

diff --git a/src/parse.rs b/src/parse.rs
index 4ccfe00..03b5972 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -2,7 +2,7 @@ use amplify::Wrapper;
 use rgbstd::containers::{Consignment, ConsignmentExt, Kit, UniversalFile};
 use rgbstd::schema::GlobalStateType;
 use rgbstd::{Assign, Assignments, ExposedSeal, KnownTransition, Transition, TypedAssigns};
-use strict_types::value::{EnumTag, StrictVal};
+use strict_types::value::{EnumTag, StrictNum, StrictVal};
 use strict_types::{FieldName, SemId, Ty, TypeSystem, VariantName};
 
 use crate::info::{
@@ -290,7 +290,7 @@ fn enum_val_to_ord(types: &TypeSystem, v: &StrictVal, sem_id: SemId) -> Option<u
             Ty::Enum(variants) => variants.tag_by_name(name),
             _ => resolve_variant_name(types, sem_id, name),
         },
-        StrictVal::Number(n) => u8::try_from(n.unwrap_uint::<u64>()).ok(),
+        StrictVal::Number(StrictNum::Uint(n)) => u8::try_from(*n).ok(),
         _ => None,
     }
 }
@@ -350,52 +350,12 @@ fn fungible_entry<Seal: ExposedSeal>(a: &Assign<rgbstd::RevealedValue, Seal>) ->
 
 #[cfg(test)]
 mod tests {
-    use amplify::confinement::{Confined, SmallBlob};
-    use rgbstd::RevealedData;
-    use rgbstd::containers::{Contract, FileContent};
-    use rgbstd::schema::{GlobalDetails, GlobalStateSchema};
-    use strict_types::encoding::StrictDumb;
-
     use super::*;
 
-    // Make a contract file. Its precision is a signed byte, and 0xff is the value -1.
-    fn contract_with_signed_precision() -> Vec<u8> {
-        let sem_id = Ty::<SemId>::I8.sem_id_unnamed();
-        let state_type = GlobalStateType::with(GS_PRECISION);
-
-        let mut contract = Contract::strict_dumb();
-        contract.types = TypeSystem::from_inner(Confined::from_checked([(sem_id, Ty::I8)].into()));
-        contract
-            .schema
-            .global_types
-            .insert(
-                state_type,
-                GlobalDetails {
-                    global_state_schema: GlobalStateSchema::once(sem_id),
-                    name: FieldName::from("precision"),
-                },
-            )
-            .unwrap();
-        contract
-            .genesis
-            .globals
-            .add_state(
-                state_type,
-                RevealedData::new(SmallBlob::from_checked(vec![0xff])),
-            )
-            .unwrap();
-
-        let mut bytes = Vec::new();
-        contract.save(&mut bytes).unwrap();
-        bytes
-    }
-
     #[test]
     fn signed_precision_does_not_crash_the_parser() {
-        let info = parse(&contract_with_signed_precision()).unwrap();
-        let ConsignmentInfo::Contract(contract) = info else {
-            panic!("the file is a contract");
-        };
-        assert_eq!(contract.genesis.precision, None);
+        let types = TypeSystem::default();
+        let v = StrictVal::num(-1i8);
+        assert_eq!(enum_val_to_ord(&types, &v, SemId::default()), None);
     }
 }