From 4f65d8c93496fb9f40cf93ad8774a6cd0d3889c3 Mon Sep 17 00:00:00 2001
From: ra0x3 <spam.rashad@protonmail.com>
Date: Mon, 23 Oct 2023 16:18:11 -0400
Subject: [PATCH] pending manifest

---
 Cargo.lock                                  |  2 ++
 packages/fuel-indexer-macros/src/helpers.rs |  1 +
 packages/fuel-indexer-macros/src/indexer.rs | 34 ++++++++++++++++-----
 packages/fuel-indexer-plugin/Cargo.toml     |  2 ++
 packages/fuel-indexer-plugin/src/wasm.rs    | 23 ++++++++++++++
 5 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2b7a81f9c..b3cfb0d34 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3411,6 +3411,8 @@ dependencies = [
  "futures",
  "getrandom",
  "hex",
+ "proc-macro2",
+ "quote",
  "serde",
  "serde_json",
  "sha2 0.10.8",
diff --git a/packages/fuel-indexer-macros/src/helpers.rs b/packages/fuel-indexer-macros/src/helpers.rs
index cfde62d50..725315a30 100644
--- a/packages/fuel-indexer-macros/src/helpers.rs
+++ b/packages/fuel-indexer-macros/src/helpers.rs
@@ -8,6 +8,7 @@ use fuel_abi_types::abi::program::{
 use fuel_indexer_lib::{
     constants::*,
     graphql::{list_field_type_name, types::IdCol, ParsedGraphQLSchema},
+    manifest::Predicates,
 };
 use fuel_indexer_types::{type_id, FUEL_TYPES_NAMESPACE};
 use fuels_code_gen::utils::Source;
diff --git a/packages/fuel-indexer-macros/src/indexer.rs b/packages/fuel-indexer-macros/src/indexer.rs
index e4b468170..e74a3852e 100644
--- a/packages/fuel-indexer-macros/src/indexer.rs
+++ b/packages/fuel-indexer-macros/src/indexer.rs
@@ -722,9 +722,8 @@ fn process_fn_items(
                                 let _p = PredicateEntity::from(p.to_owned()).get_or_create();
                             });
 
-                            let verifiable_predicates = inputs.iter().filter(|i| {
+                            let verifiable_predicates = inputs.iter().filter_map(|i| {
                                 match i {
-
                                     fuel::Input::Coin(coin) => {
                                         let fuel::InputCoin {
                                             utxo_id,
@@ -738,20 +737,41 @@ fn process_fn_items(
 
                                         // This could potentially be an InputCoin with no predicate data
                                         if predicate.is_empty() || predicate_data.is_empty() {
-                                            return false;
+                                            return None;
                                         }
 
-                                        signaled_predicates.iter().any(|p| {
+                                        let pred = signaled_predicates.iter().find(|p| {
                                             let utxo = p.coin_output();
                                             utxo.to == *owner
-                                        })
+                                        });
+
+                                        if !pred.is_none() {
+                                            return None;
+                                        }
+
+                                        let result = match pred {
+                                            Some(p) => {
+                                                let pid = p.predicate_id();
+                                                let ident = predicate_configurable_ident(pid.to_string(), &manifest.predicates());
+                                                // convert predicate_data into #identConfigurable
+                                                None
+                                            }
+                                            None => None,
+                                        };
+
+                                        result
                                     }
                                     _ => {
                                         warn!("This input type is not handled yet.");
-                                        false
+                                        None
                                     }
                                 }
-                            });
+                            }).collect::<Vec<_>>();
+
+                            // let verifiable_predicate_data = verifiable_predicates.iter().map(|p| {
+
+                            //     let name = manifest.predicates().templates().find(|t| t.id == pid).expect("Could not find predicate in manifest").name.clone();
+                            // });
 
                             // 1. do the verification
 
diff --git a/packages/fuel-indexer-plugin/Cargo.toml b/packages/fuel-indexer-plugin/Cargo.toml
index 35d62d5f8..9ad68dc45 100644
--- a/packages/fuel-indexer-plugin/Cargo.toml
+++ b/packages/fuel-indexer-plugin/Cargo.toml
@@ -25,6 +25,8 @@ fuel-indexer-types = { workspace = true }
 futures = { version = "0.3", optional = true }
 getrandom = { version = "0.2", features = ["js"] }
 hex = "0.4"
+proc-macro2 = "1.0"
+quote = "1.0"
 serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = { version = "0.10" }
diff --git a/packages/fuel-indexer-plugin/src/wasm.rs b/packages/fuel-indexer-plugin/src/wasm.rs
index e8af8578e..16c215958 100644
--- a/packages/fuel-indexer-plugin/src/wasm.rs
+++ b/packages/fuel-indexer-plugin/src/wasm.rs
@@ -3,6 +3,7 @@ extern crate alloc;
 use alloc::vec::Vec;
 use fuel_indexer_lib::{
     graphql::MAX_FOREIGN_KEY_LIST_FIELDS,
+    manifest::Predicates,
     utils::{deserialize, serialize},
     WasmIndexerError,
 };
@@ -11,6 +12,8 @@ use fuel_indexer_schema::{
     FtColumn,
 };
 use fuel_indexer_types::{ffi::*, scalar::UID};
+use proc_macro2::Ident;
+use quote::format_ident;
 
 pub use bincode;
 pub use hex::FromHex;
@@ -163,3 +166,23 @@ pub fn early_exit(err_code: WasmIndexerError) -> ! {
     unsafe { ff_early_exit(err_code as u32) }
     unreachable!("Expected termination of WASM exetution after a call to ff_early_exit.")
 }
+
+pub fn predicate_configurable_ident(
+    predicate_id: String,
+    predicates: &Predicates,
+) -> Ident {
+    match predicates.templates() {
+        Some(templates) => {
+            let name = templates
+                .iter()
+                .find(|t| t.id == predicate_id)
+                .expect("No templates matching ID.")
+                .name
+                .clone();
+            format_ident! { "{}Configurables", name }
+        }
+        None => {
+            panic!("No templates found in predicates.")
+        }
+    }
+}