Add CIP25 reparse basic

indexer/reparse/Cargo.toml

@@ -18,3 +18,4 @@ entity = { path = "../entity" }
 futures = "0.3.21"
 cardano-multiplatform-lib = { git = "https://github.com/dcSpark/cardano-multiplatform-lib", branch = "metadata-and-addr" }
 hex = "0.4.0"
+cml-cip25 = { "path" = "../../../cardano-multiplatform-lib/cip25/rust" }

indexer/reparse/src/reparse.rs

@@ -1,3 +1,4 @@
+use cml_cip25::serialization::FromBytes;
 use entity::{
     prelude::*,
     sea_orm::{prelude::*, JoinType, QueryOrder, QuerySelect},
@@ -11,11 +12,86 @@ pub async fn start_reparse(conn: DatabaseConnection) -> anyhow::Result<()> {
     reparse_addresses(&conn, 0).await?;
     reparse_tx_out(&conn, 0).await?;
     reparse_txs(&conn, 0).await?;
+    // note: cip25 errors are extremely common from projects accidentally not following it, so we ignore them
+    // reparse_nft(&conn, 0).await?;
     Ok(())
 }
 
 static PAGE_SIZE: usize = 8192 * 4;
 
+async fn reparse_nft(conn: &DatabaseConnection, start_index: u64) -> Result<(), DbErr> {
+    let cip25_count = Cip25Entry::find().count(conn).await?;
+    let mut cip25_stream = Cip25Entry::find()
+        .order_by_asc(Cip25EntryColumn::Id)
+        .filter(Cip25EntryColumn::Id.gt(start_index))
+        .paginate(conn, PAGE_SIZE)
+        .into_stream();
+
+    while let Some(cip25_entries) = &cip25_stream.try_next().await? {
+        println!(
+            "cip25 entries: {} / {} ({:.1}%)",
+            cip25_entries.first().unwrap().id,
+            cip25_count,
+            (100.0 * cip25_entries.first().unwrap().id as f64) / (cip25_count as f64)
+        );
+        for cip25_entry in cip25_entries {
+            // Option 1:
+            // let name = asset...get_str('name').as_text();
+            // let image = asset.get_str('image').as_text();
+            // match cml_cip25::MetadataDetails::from_bytes(cip25_entry.payload.clone()) {
+            //     Err(_) => {}
+            //     Ok(details) => {
+            //         let name = details.name.to_str();
+            //         let image = String::from(&details.image).as_str();
+            //     }
+            // }
+
+            // Option 2:
+            // match cardano_multiplatform_lib::metadata::TransactionMetadatum::from_bytes(
+            //     cip25_entry.payload.clone(),
+            // ) {
+            //     Err(_) => {}
+            //     Ok(metadatum) => {
+            //         let assetMap = metadatum.as_map().unwrap();
+            //         let name = assetMap.get_str("name").and_then(|val| val.as_text());
+            //         let image_base = assetMap.get_str("image");
+            //         match image_base.as_ref() {
+            //             Err(_) => {}
+            //             Ok(base) => match base.as_text() {
+            //                 Ok(_) => {}
+            //                 Err(_) => {
+            //                     let mut result: String = "".to_string();
+            //                     if let Ok(list) = base.as_list().as_ref() {
+            //                         for i in 0..list.len() {
+            //                             result += &list.get(i).as_text().unwrap();
+            //                         }
+            //                     }
+            //                 }
+            //             },
+            //         }
+            //     }
+            // };
+
+            if let Err(e) = &cml_cip25::MetadataDetails::from_bytes(cip25_entry.payload.clone()) {
+                let asset = NativeAsset::find()
+                    .filter(NativeAssetColumn::Id.eq(cip25_entry.asset_id))
+                    .one(conn)
+                    .await?
+                    .unwrap();
+                println!(
+                    "\nFailed cip25 entry {}.{} {:?} {}\n",
+                    hex::encode(&asset.policy_id),
+                    hex::encode(&asset.asset_name),
+                    e,
+                    hex::encode(&cip25_entry.payload)
+                );
+            };
+        }
+    }
+    println!("Done parsing transactions");
+    Ok(())
+}
+
 async fn reparse_txs(conn: &DatabaseConnection, start_index: u64) -> Result<(), DbErr> {
     let tx_count = Transaction::find().count(conn).await?;
     let mut tx_stream = Transaction::find()