feat: Add get_traced_entrypoints endpoint. (#581)

Author: tamaralipows

postgres.Dockerfile

@@ -5,6 +5,7 @@
 FROM ghcr.io/dbsystel/postgresql-partman:15-5
 ARG PGCRON_VERSION="1.6.2"
 USER root
+RUN apt-get update && apt-get install -y wget build-essential
 RUN cd /tmp \
     && wget "https://github.com/citusdata/pg_cron/archive/refs/tags/v${PGCRON_VERSION}.tar.gz" \
     && tar zxf v${PGCRON_VERSION}.tar.gz \

tycho-common/src/dto.rs

@@ -1284,7 +1284,7 @@ impl ProtocolStateRequestResponse {
     }
 }
 
-#[derive(Clone, PartialEq, Hash, Eq)]
+#[derive(Serialize, Clone, PartialEq, Hash, Eq)]
 pub struct ProtocolComponentId {
     pub chain: Chain,
     pub system: String,
@@ -1322,6 +1322,117 @@ impl ProtocolSystemsRequestResponse {
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, ToSchema, Eq, Hash, Clone)]
+pub struct TracedEntryPointRequestBody {
+    #[serde(default)]
+    pub chain: Chain,
+    /// Filters by protocol, required to correctly apply unconfirmed state from
+    /// ReorgBuffers
+    pub protocol_system: String,
+    /// Filter by component ids
+    pub component_ids: Option<Vec<String>>,
+    /// Max page size supported is 100
+    #[serde(default)]
+    pub pagination: PaginationParams,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema, Eq, Hash)]
+pub struct EntryPoint {
+    #[schema(example = "0xEdf63cce4bA70cbE74064b7687882E71ebB0e988:getRate()")]
+    /// Entry point id.
+    pub external_id: String,
+    #[schema(value_type=String, example="0x8f4E8439b970363648421C692dd897Fb9c0Bd1D9")]
+    #[serde(with = "hex_bytes")]
+    /// The address of the contract to trace.
+    pub target: Bytes,
+    #[schema(example = "getRate()")]
+    /// The signature of the function to trace.
+    pub signature: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, ToSchema, Eq, Hash)]
+pub struct RPCTracerParams {
+    /// The caller address of the transaction, if not provided tracing uses the default value
+    /// for an address defined by the VM.
+    #[schema(value_type=Option<String>)]
+    #[serde(with = "hex_bytes_option", default)]
+    pub caller: Option<Bytes>,
+    /// The call data used for the tracing call, this needs to include the function selector
+    #[schema(value_type=String, example="0x679aefce")]
+    #[serde(with = "hex_bytes")]
+    pub calldata: Bytes,
+}
+
+impl From<models::blockchain::RPCTracerParams> for RPCTracerParams {
+    fn from(value: models::blockchain::RPCTracerParams) -> Self {
+        RPCTracerParams { caller: value.caller, calldata: value.calldata }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
+#[serde(tag = "method", rename_all = "lowercase")]
+pub enum TracingParams {
+    /// Uses RPC calls to retrieve the called addresses and retriggers
+    RPCTracer(RPCTracerParams),
+}
+
+impl From<models::blockchain::TracingParams> for TracingParams {
+    fn from(value: models::blockchain::TracingParams) -> Self {
+        match value {
+            models::blockchain::TracingParams::RPCTracer(params) => {
+                TracingParams::RPCTracer(params.into())
+            }
+        }
+    }
+}
+
+impl From<models::blockchain::EntryPoint> for EntryPoint {
+    fn from(value: models::blockchain::EntryPoint) -> Self {
+        Self { external_id: value.external_id, target: value.target, signature: value.signature }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, ToSchema, Eq, Clone)]
+pub struct EntryPointWithTracingParams {
+    /// The entry point object
+    pub entry_point: EntryPoint,
+    /// The parameters used
+    pub params: TracingParams,
+}
+
+impl From<models::blockchain::EntryPointWithTracingParams> for EntryPointWithTracingParams {
+    fn from(value: models::blockchain::EntryPointWithTracingParams) -> Self {
+        Self { entry_point: value.entry_point.into(), params: value.params.into() }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Default, PartialEq, ToSchema, Eq, Clone)]
+pub struct TracingResult {
+    #[schema(value_type=HashSet<(String, String)>)]
+    pub retriggers: HashSet<(Bytes, Bytes)>,
+    #[schema(value_type=HashSet<String>)]
+    pub called_addresses: HashSet<Bytes>,
+}
+
+impl From<models::blockchain::TracingResult> for TracingResult {
+    fn from(value: models::blockchain::TracingResult) -> Self {
+        TracingResult { retriggers: value.retriggers, called_addresses: value.called_addresses }
+    }
+}
+
+#[derive(Serialize, PartialEq, ToSchema, Eq, Clone)]
+pub struct TracedEntryPointRequestResponse {
+    /// Map of protocol component id to a list of a tuple containing each entry point with its
+    /// tracing parameters and its corresponding tracing results.
+    pub traced_entry_points: HashMap<String, Vec<(EntryPointWithTracingParams, TracingResult)>>,
+    pub pagination: PaginationResponse,
+}
+
+pub struct AddEntrypointRequestBody {
+    pub entrypoints_with_tracing_data: Vec<(String, Vec<EntryPointWithTracingParams>)>,
+    pub chain: Chain,
+}
+
 #[cfg(test)]
 mod test {
     use std::str::FromStr;

tycho-common/src/models/blockchain.rs

@@ -369,7 +369,7 @@ pub enum BlockTag {
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EntryPoint {
-    /// The id of the protocol component that the entry point belongs to.
+    /// Entry point id
     pub external_id: String,
     /// The address of the contract to trace.
     pub target: Address,

tycho-common/src/storage.rs

@@ -513,6 +513,7 @@ impl EntryPointFilter {
 pub trait EntryPointGateway {
     /// Inserts a list of entry points into the database.
     ///
+    /// # Arguments
     /// * `entry_points` - The map of component ids to their entry points to insert.
     ///
     /// Note: This function ignores conflicts on inserts.
@@ -523,6 +524,7 @@ pub trait EntryPointGateway {
 
     /// Inserts a list of entry points with their tracing params into the database.
     ///
+    /// # Arguments
     /// * `entry_points_params` - The map of entry points to their tracing params to insert and
     ///   optionally a component id used for debugging only.
     ///
@@ -534,9 +536,13 @@ pub trait EntryPointGateway {
 
     /// Retrieves a map of component ids to a set of entry points from the database.
     ///
+    /// # Arguments
     /// * `filter` - The EntryPointFilter to apply to the query.
     /// * `pagination_params` - The pagination parameters to apply to the query, if None, all
     ///   results are returned.
+    ///
+    /// # Returns
+    /// A map of component ids to a set of entry points.
     async fn get_entry_points(
         &self,
         filter: EntryPointFilter,
@@ -546,9 +552,13 @@ pub trait EntryPointGateway {
     /// Retrieves a map of component ids to a set of entry points with their tracing data from the
     /// database.
     ///
+    /// # Arguments
     /// * `filter` - The EntryPointFilter to apply to the query.
     /// * `pagination_params` - The pagination parameters to apply to the query, if None, all
     ///   results are returned.
+    ///
+    /// # Returns
+    /// A map of component ids to a set of entry points with their tracing data.
     async fn get_entry_points_tracing_params(
         &self,
         filter: EntryPointFilter,
@@ -558,6 +568,7 @@ pub trait EntryPointGateway {
     /// Upserts a list of traced entry points into the database. Updates the result if it already
     /// exists for the same entry point and tracing params.
     ///
+    /// # Arguments
     /// * `traced_entry_points` - The list of traced entry points to upsert.
     async fn upsert_traced_entry_points(
         &self,
@@ -566,11 +577,15 @@ pub trait EntryPointGateway {
 
     /// Retrieves all tracing results for a set of entry points from the database.
     ///
+    /// # Arguments
     /// * `entry_points` - The set of entry points to retrieve tracing results for.
+    ///
+    /// # Returns
+    /// A map of entry point ids to a map of tracing params to tracing results.
     async fn get_traced_entry_points(
         &self,
         entry_points: &HashSet<EntryPointId>,
-    ) -> Result<HashMap<EntryPointId, Vec<TracingResult>>, StorageError>;
+    ) -> Result<HashMap<EntryPointId, HashMap<TracingParams, TracingResult>>, StorageError>;
 }
 
 /// Manage contracts and their state in storage.
@@ -753,6 +768,7 @@ pub trait Gateway:
     + ExtractionStateGateway
     + ProtocolGateway
     + ContractStateGateway
+    + EntryPointGateway
     + Send
     + Sync
 {

tycho-indexer/src/services/mod.rs

@@ -17,7 +17,8 @@ use tycho_common::{
         ProtocolComponentsRequestBody, ProtocolId, ProtocolStateDelta, ProtocolStateRequestBody,
         ProtocolStateRequestResponse, ProtocolSystemsRequestBody, ProtocolSystemsRequestResponse,
         ResponseAccount, ResponseProtocolState, ResponseToken, StateRequestBody,
-        StateRequestResponse, TokensRequestBody, TokensRequestResponse, VersionParam,
+        StateRequestResponse, TokensRequestBody, TokensRequestResponse,
+        TracedEntryPointRequestBody, TracedEntryPointRequestResponse, VersionParam,
     },
     storage::Gateway,
 };
@@ -106,6 +107,7 @@ where
                 rpc::protocol_systems,
                 rpc::tokens,
                 rpc::protocol_components,
+                rpc::traced_entry_points,
                 rpc::protocol_state,
                 rpc::contract_state,
             ),
@@ -126,6 +128,8 @@ where
                 schemas(ProtocolComponentRequestResponse),
                 schemas(ProtocolComponent),
                 schemas(ProtocolStateRequestBody),
+                schemas(TracedEntryPointRequestBody),
+                schemas(TracedEntryPointRequestResponse),
                 schemas(ProtocolStateRequestResponse),
                 schemas(AccountUpdate),
                 schemas(ProtocolId),
@@ -243,6 +247,10 @@ where
                     web::resource(format!("/{}/protocol_components", self.prefix))
                         .route(web::post().to(rpc::protocol_components::<G>)),
                 )
+                .service(
+                    web::resource(format!("/{}/traced_entry_points", self.prefix))
+                        .route(web::post().to(rpc::traced_entry_points::<G>)),
+                )
                 .service(
                     web::resource(format!("/{}/health", self.prefix))
                         .route(web::get().to(rpc::health)),