feat(template): Add template for singleton protocols.

Separate templates and add one for protocols with only a single contract.

substreams/ethereum-template-singleton/src/abi/mod.rs

@@ -0,0 +1,2 @@
+#![allow(clippy::all)]
+pub mod erc20;

substreams/ethereum-template-singleton/src/lib.rs

@@ -0,0 +1,4 @@
+mod abi;
+mod pool_factories;
+mod modules;
+

substreams/ethereum-template-singleton/src/modules.rs

@@ -0,0 +1,246 @@
+//! Template for Protocols with singleton contract
+//!
+//!
+use std::collections::HashMap;
+use anyhow::Result;
+use substreams::pb::substreams::StoreDeltas;
+use substreams::prelude::*;
+use substreams_ethereum::Event;
+use substreams_ethereum::pb::eth;
+use tycho_substreams::balances::aggregate_balances_changes;
+use tycho_substreams::contract::extract_contract_changes_builder;
+use tycho_substreams::prelude::*;
+use itertools::Itertools;
+use prost::Message;
+use substreams_ethereum::block_view::CallView;
+use crate::pool_factories;
+use crate::pool_factories::DeploymentConfig;
+
+/// Find and create all relevant protocol components
+///
+/// This method maps over blocks and instantiates ProtocolComponents with a unique ids
+/// as well as all necessary metadata for routing and encoding.
+#[substreams::handlers::map]
+fn map_protocol_components(
+    params: String,
+    block: eth::v2::Block,
+) -> Result<BlockTransactionProtocolComponents> {
+    let config = serde_qs::from_str(params.as_str())?;
+    Ok(BlockTransactionProtocolComponents {
+        tx_components: block
+            .transactions()
+            .filter_map(|tx| {
+                let components = tx
+                    .logs_with_calls()
+                    .filter_map(|(log, call)| {
+                        // TODO: ensure this method is implemented correctly
+                        pool_factories::maybe_create_component(
+                            call.call,
+                            log,
+                            tx,
+                            &config,
+                        )
+                    })
+                    .collect::<Vec<_>>();
+
+                if !components.is_empty() {
+                    Some(TransactionProtocolComponents { tx: Some(tx.into()), components })
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>(),
+    })
+}
+
+#[substreams::handlers::store]
+fn store_protocol_tokens(map_protocol_components: BlockTransactionProtocolComponents, store: StoreSetInt64) {
+    map_protocol_components.tx_components
+        .into_iter()
+        .for_each(|tx_pc| {
+            tx_pc
+                .components
+                .into_iter()
+                .for_each(|pc| {
+                    pc.tokens.iter().for_each(|token| {
+                        let token_addr_hex = hex::encode(token);
+                        store.set(0, &token_addr_hex, &1);
+                    })
+                })
+        });
+}
+
+/// Extracts balance changes per component
+///
+/// This template function inspects ERC20 transfer events to/from the singleton contract
+/// to extract balance changes.  If a transfer to the component is detected, it's
+/// balanced is increased and if a balance from the component is detected its balance
+/// is decreased.
+///
+/// ## Note:
+/// Changes are necessary if your protocol uses native ETH or your component burns or
+/// mints tokens without emitting transfer events.
+///
+/// You may want to ignore LP tokens if your protocol emits transfer events for these
+/// here.
+#[substreams::handlers::map]
+fn map_relative_component_balance(params: String, block: eth::v2::Block, store: StoreGetInt64) -> Result<BlockBalanceDeltas> {
+    let config: DeploymentConfig = serde_qs::from_str(params.as_str())?;
+    let res = block
+        .transactions()
+        .flat_map(|tx| {
+            tx
+                .logs_with_calls()
+                .filter_map(|(log, call)| {
+                    let token_addr_hex = hex::encode(&log.address);
+                    if !store.has_last(&token_addr_hex) {
+                        return None;
+                    }
+
+                    crate::abi::erc20::events::Transfer::match_and_decode(log).map(|transfer| {
+                        let to_addr = transfer.to.as_slice();
+                        let from_addr = transfer.from.as_slice();
+                        if let Some(component_id) = extract_component_id_from_call(call) {
+                            if to_addr == config.vault_address {
+                                return Some(BalanceDelta {
+                                    ord: log.ordinal,
+                                    tx: Some(tx.into()),
+                                    token: log.address.to_vec(),
+                                    delta: transfer.value.to_signed_bytes_be(),
+                                    component_id: component_id.encode_to_vec(),
+                                });
+                            } else if from_addr == config.vault_address {
+                                return Some(BalanceDelta {
+                                    ord: log.ordinal,
+                                    tx: Some(tx.into()),
+                                    token: log.address.to_vec(),
+                                    delta: (transfer.value.neg()).to_signed_bytes_be(),
+                                    component_id: component_id.encode_to_vec(),
+                                });
+                            }
+                        }
+                        None
+                    })
+                })
+                .flatten()
+        })
+        .collect::<Vec<_>>();
+
+    Ok(BlockBalanceDeltas { balance_deltas: res })
+}
+
+// TODO: given a relevant balance changing call associate it with the respective
+//  component
+fn extract_component_id_from_call(_call: CallView) -> Option<String> {
+    todo!()
+}
+
+/// Aggregates relative balances values into absolute values
+///
+/// Aggregate the relative balances in an additive store since tycho-indexer expects
+/// absolute balance inputs.
+///
+/// ## Note:
+/// This method should usually not require any changes.
+#[substreams::handlers::store]
+pub fn store_component_balances(deltas: BlockBalanceDeltas, store: StoreAddBigInt) {
+    tycho_substreams::balances::store_balance_changes(deltas, store);
+}
+
+/// Aggregates protocol components and balance changes by transaction.
+///
+/// This is the main method that will aggregate all changes as well as extract all
+/// relevant contract storage deltas.
+///
+/// ## Note:
+/// You may have to change this method if your components have any default dynamic
+/// attributes, or if you need any additional static contracts indexed.
+#[substreams::handlers::map]
+fn map_protocol_changes(
+    params: String,
+    block: eth::v2::Block,
+    new_components: BlockTransactionProtocolComponents,
+    balance_store: StoreDeltas,
+    deltas: BlockBalanceDeltas,
+) -> Result<BlockChanges, substreams::errors::Error> {
+    let config: DeploymentConfig = serde_qs::from_str(params.as_str())?;
+    // We merge contract changes by transaction (identified by transaction index)
+    // making it easy to sort them at the very end.
+    let mut transaction_changes: HashMap<_, TransactionChangesBuilder> = HashMap::new();
+
+    // Aggregate newly created components per tx
+    new_components
+        .tx_components
+        .iter()
+        .for_each(|tx_component| {
+            // initialise builder if not yet present for this tx
+            let tx = tx_component.tx.as_ref().unwrap();
+            let builder = transaction_changes
+                .entry(tx.index)
+                .or_insert_with(|| TransactionChangesBuilder::new(tx));
+
+            // iterate over individual components created within this tx
+            tx_component
+                .components
+                .iter()
+                .for_each(|component| {
+                    builder.add_protocol_component(component);
+                    // TODO: In case you require to add any dynamic attributes to the
+                    //  component you can do so here:
+                    /*
+                        builder.add_entity_change(&EntityChanges {
+                            component_id: component.id.clone(),
+                            attributes: default_attributes.clone(),
+                        });
+                    */
+                });
+        });
+
+    // Aggregate absolute balances per transaction.
+    aggregate_balances_changes(balance_store, deltas)
+        .into_iter()
+        .for_each(|(_, (tx, balances))| {
+            let builder = transaction_changes
+                .entry(tx.index)
+                .or_insert_with(|| TransactionChangesBuilder::new(&tx));
+            let mut contract_changes = InterimContractChange::new(&config.vault_address, false);
+            balances
+                .values()
+                .for_each(|token_bc_map| {
+                    token_bc_map
+                        .values()
+                        .for_each(|bc| {
+                            // track component balance
+                            builder.add_balance_change(bc);
+                            // track vault contract balance
+                            contract_changes.upsert_token_balance(bc.token.as_slice(), bc.balance.as_slice())
+                        })
+                });
+            builder.add_contract_changes(&contract_changes);
+        });
+
+
+    // Extract and insert any storage changes that happened for any of the components.
+    extract_contract_changes_builder(
+        &block,
+        |addr| {
+            // we assume that the store holds contract addresses as keys and if it
+            // contains a value, that contract is of relevance.
+            // TODO: if you have any additional static contracts that need to be indexed,
+            //  please add them here.
+            addr == config.vault_address
+        },
+        &mut transaction_changes,
+    );
+
+    // Process all `transaction_changes` for final output in the `BlockChanges`,
+    //  sorted by transaction index (the key).
+    Ok(BlockChanges {
+        block: Some((&block).into()),
+        changes: transaction_changes
+            .drain()
+            .sorted_unstable_by_key(|(index, _)| *index)
+            .filter_map(|(_, builder)| builder.build())
+            .collect::<Vec<_>>(),
+    })
+}

substreams/ethereum-template-singleton/src/pool_factories.rs

@@ -0,0 +1,61 @@
+use serde::Deserialize;
+use substreams_ethereum::pb::eth::v2::{Call, Log, TransactionTrace};
+use tycho_substreams::models::{ChangeType, FinancialType, ImplementationType, ProtocolComponent, ProtocolType};
+
+
+#[derive(Deserialize)]
+pub struct DeploymentConfig {
+    #[serde(with = "hex::serde")]
+    pub vault_address: Vec<u8>,
+}
+
+/// Potentially constructs a new ProtocolComponent given a call
+///
+/// This method is given each individual call within a transaction, the corresponding
+/// logs emitted during that call as well as the full transaction trace.
+///
+/// If this call creates a component in your protocol please contstruct and return it
+/// here. Otherwise, simply return None.
+pub fn maybe_create_component(
+    call: &Call,
+    _log: &Log,
+    _tx: &TransactionTrace,
+    config: &DeploymentConfig,
+) -> Option<ProtocolComponent> {
+    if call.address == config.vault_address {
+        // TODO: replace with your logic
+        Some(ProtocolComponent {
+            id: "".to_string(),
+            tokens: vec![
+                // TODO: add the components tokens
+            ],
+            contracts: vec![
+                // TODO: any contracts required during swapping
+            ],
+            static_att: vec![
+                // TODO: any additional metadata required, e.g. for swap encoding
+            ],
+            change: ChangeType::Creation.into(),
+            protocol_type: Some(ProtocolType {
+                name: "template".to_string(),
+                financial_type: FinancialType::Swap.into(),
+                attribute_schema: vec![],
+                implementation_type: ImplementationType::Vm.into(),
+            }),
+        })
+    } else {
+        None
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn test_decode_config() {
+        let config: DeploymentConfig = serde_qs::from_str("vault_address=0001").unwrap();
+
+        assert_eq!(config.vault_address, [0u8, 1u8]);
+    }
+}