test: add version detection and CIP68 user token metadata resolution tests

Signed-off-by: William Hankins <[email protected]>

Author: whankinsiv

modules/assets_state/src/state.rs

@@ -145,8 +145,6 @@ impl State {
             if let Some(info_mut) = info.as_mut() {
                 info_mut.metadata.cip68_metadata = ref_info.metadata.cip68_metadata;
                 info_mut.metadata.cip68_version = ref_info.metadata.cip68_version;
-            } else {
-                info = Some(ref_info);
             }
         }
 
@@ -596,7 +594,7 @@ impl State {
                     continue;
                 };
 
-                let mut cip68_version = None;
+                let mut cip68_version = Some(AssetMetadataStandard::CIP68v1);
 
                 if let Ok(serde_cbor::Value::Map(m)) =
                     serde_cbor::from_slice::<serde_cbor::Value>(blob)
@@ -619,7 +617,6 @@ impl State {
                             continue;
                         }
 
-                        // NOTE: CIP68 metadata version is included in the blob and is decoded in REST handler
                         match registry.lookup_id(policy_id, name) {
                             Some(asset_id) => {
                                 if let Some(record) =
@@ -689,13 +686,14 @@ mod tests {
 
     use crate::{
         asset_registry::{AssetId, AssetRegistry},
-        state::{AssetsStorageConfig, State, StoreTransactions},
+        state::{AssetsStorageConfig, State, StoreTransactions, CIP67_LABEL_222, CIP68_LABEL_100},
     };
     use acropolis_common::{
-        Address, AddressDelta, AssetInfoRecord, AssetMetadataStandard, AssetName, Datum,
-        NativeAsset, NativeAssetDelta, PolicyId, ShelleyAddress, TxIdentifier, TxOutput,
+        Address, AddressDelta, AssetInfoRecord, AssetMetadata, AssetMetadataStandard, AssetName,
+        Datum, NativeAsset, NativeAssetDelta, PolicyId, ShelleyAddress, TxIdentifier, TxOutput,
         TxUTxODeltas, UTxOIdentifier, Value,
     };
+    use serde_cbor::Value as CborValue;
 
     fn dummy_policy(byte: u8) -> PolicyId {
         [byte; 28]
@@ -1286,6 +1284,46 @@ mod tests {
         );
     }
 
+    #[test]
+    fn handle_cip68_version_detection() {
+        let mut registry = AssetRegistry::new();
+        let policy_id: PolicyId = [7u8; 28];
+
+        let (state, asset_id, name) = setup_state_with_asset(
+            &mut registry,
+            policy_id,
+            &[0x00, 0x06, 0x43, 0xb0, 0xAA],
+            true,
+            false,
+            StoreTransactions::None,
+        );
+
+        let mut map = BTreeMap::new();
+        map.insert(
+            CborValue::Text("version".to_string()),
+            CborValue::Text("2.0".to_string()),
+        );
+
+        let datum = serde_cbor::to_vec(&CborValue::Map(map)).unwrap();
+
+        let output = make_output(policy_id, name, Some(datum.clone()));
+
+        let tx = TxUTxODeltas {
+            tx_identifier: TxIdentifier::new(0, 0),
+            inputs: vec![],
+            outputs: vec![output],
+        };
+        let new_state = state.handle_cip68_metadata(&[tx], &registry).unwrap();
+        let record = new_state.info.as_ref().unwrap().get(&asset_id).unwrap();
+
+        // CIP68 version should be v2
+        assert_eq!(
+            record.metadata.cip68_version,
+            Some(AssetMetadataStandard::CIP68v2),
+            "CIP68 version should be set as CIP68v2"
+        );
+    }
+
     #[test]
     fn get_asset_info_reference_nft_strips_metadata() {
         let mut registry = AssetRegistry::new();
@@ -1320,6 +1358,54 @@ mod tests {
         assert!(rec.metadata.cip68_version.is_none());
     }
 
+    #[test]
+    fn get_asset_info_resolves_user_token_metadata_from_reference_nft() {
+        let mut registry = AssetRegistry::new();
+        let policy_id: PolicyId = [5u8; 28];
+        let asset_name = [0x53, 0x4E, 0x45, 0x4B];
+
+        let mut user_name = CIP67_LABEL_222.to_vec();
+        user_name.extend_from_slice(&asset_name);
+        let user_token_name = AssetName::new(&user_name).unwrap();
+        let user_token_id = registry.get_or_insert(policy_id, user_token_name);
+
+        let mut reference_name = CIP68_LABEL_100.to_vec();
+        reference_name.extend_from_slice(&asset_name);
+        let reference_nft_name = AssetName::new(&reference_name).unwrap();
+        let reference_id = registry.get_or_insert(policy_id, reference_nft_name);
+
+        let mut state = State::new(full_config());
+        state.info.as_mut().unwrap().insert(
+            reference_id,
+            AssetInfoRecord {
+                initial_mint_tx: dummy_tx_identifier(0),
+                mint_or_burn_count: 0,
+                metadata: AssetMetadata {
+                    cip25_metadata: None,
+                    cip25_version: None,
+                    cip68_metadata: Some(vec![1, 2, 3]),
+                    cip68_version: Some(AssetMetadataStandard::CIP68v1),
+                },
+            },
+        );
+
+        let resolved = state.resolve_cip68_metadata(&user_token_id, &registry);
+
+        let record = resolved.expect("User token should resolve to reference NFT metadata");
+
+        assert_eq!(
+            record.metadata.cip68_metadata,
+            Some(vec![1, 2, 3]),
+            "User token should inherit CIP68 metadata from reference NFT"
+        );
+
+        assert_eq!(
+            record.metadata.cip68_version,
+            Some(AssetMetadataStandard::CIP68v1),
+            "User token should inherit CIP68 version from reference NFT"
+        );
+    }
+
     #[test]
     fn handle_transactions_duplicate_tx_ignored() {
         let mut registry = AssetRegistry::new();

modules/rest_blockfrost/src/handlers/addresses.rs

@@ -349,9 +349,18 @@ impl AmountListExtended {
                 let meta = &metadata[idx];
                 idx += 1;
 
-                let decimals = if let Some(raw) = meta.cip68_metadata.as_ref() {
+                // Blockfrost priority
+                // 1. Set decimals to null if CIP25 metadata exists (This is an NFT)
+                // 2. Set decimals based on CIP68 metadata if exists
+                // 3. Set decimals based on off-chain registry
+                // 4. Set decimals to null if no CIP68 metadata or off-chain registry entry
+
+                let decimals = if meta.cip25_metadata.is_some() {
+                    None
+                } else if let Some(raw) = meta.cip68_metadata.as_ref() {
                     extract_cip68_decimals(raw)
                 } else {
+                    // TODO: off-chain registry lookup once caching exists
                     None
                 };
 
@@ -407,3 +416,82 @@ pub fn extract_cip68_decimals(raw: &[u8]) -> Option<u64> {
 
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use acropolis_common::{AssetName, NativeAsset, NativeAssets, Value};
+
+    fn make_value(policy_id: [u8; 28], name: Vec<u8>, amount: u64) -> Value {
+        let assets: NativeAssets = vec![(
+            policy_id,
+            vec![NativeAsset {
+                name: AssetName::new(&name).expect("Invalid asset name"),
+                amount,
+            }],
+        )];
+
+        Value::new(0, assets)
+    }
+
+    fn make_metadata(cip25: Option<Vec<u8>>, cip68: Option<Vec<u8>>) -> AssetMetadata {
+        AssetMetadata {
+            cip25_metadata: cip25,
+            cip68_metadata: cip68,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn cip25_existance_overrides_decimals() {
+        use serde_cbor::Value as CborValue;
+        use std::collections::BTreeMap;
+
+        let mut map = BTreeMap::new();
+        map.insert(
+            CborValue::Text("decimals".to_string()),
+            CborValue::Integer(18),
+        );
+
+        let cbor = serde_cbor::to_vec(&vec![CborValue::Map(map), CborValue::Null]).unwrap();
+
+        let policy_id = [1u8; 28];
+        let value = make_value(policy_id, vec![0x41, 0x42], 100);
+
+        let metadata = vec![make_metadata(Some(vec![1, 2, 3]), Some(cbor))];
+
+        let list = AmountListExtended::from_value_and_metadata(value, &metadata);
+        let asset = &list.0[1];
+
+        // Decimals set to none when CIP25 present
+        assert!(asset.decimals.is_none());
+
+        // Onchain metadata flag is set
+        assert!(asset.has_nft_onchain_metadata);
+    }
+
+    #[test]
+    fn cip68_decimals_are_extracted_when_no_cip25() {
+        use serde_cbor::Value as CborValue;
+        use std::collections::BTreeMap;
+
+        let mut map = BTreeMap::new();
+        map.insert(CborValue::Text("decimals".into()), CborValue::Integer(18));
+
+        let cbor = serde_cbor::to_vec(&vec![CborValue::Map(map), CborValue::Null]).unwrap();
+
+        let policy_id = [3u8; 28];
+        let value = make_value(policy_id, b"\x99".to_vec(), 999);
+
+        let metadata = vec![make_metadata(None, Some(cbor))];
+
+        let list = AmountListExtended::from_value_and_metadata(value, &metadata);
+        let asset = &list.0[1];
+
+        // Decimals set to value in CIP68 metadata
+        assert_eq!(asset.decimals, Some(18));
+
+        // Onchain metadata is false
+        assert!(!asset.has_nft_onchain_metadata);
+    }
+}