fix: validate dips pricing

Author: mangas

Cargo.lock

@@ -4,7 +4,7 @@ members = [
     "crates/attestation",
     "crates/config",
     "crates/dips",
-    "crates/indexer-receipt", 
+    "crates/indexer-receipt",
     "crates/monitor",
     "crates/query",
     "crates/service",
@@ -82,6 +82,7 @@ tonic-build = "0.12.3"
 serde_yaml = "0.9.21"
 bon = "3.3"
 test-log = { version = "0.2.12", features = ["trace"] }
+graph-networks-registry = "0.6.1"
 
 [patch.crates-io.tap_core]
 git = "https://github.com/semiotic-ai/timeline-aggregation-protocol"

Cargo.toml

@@ -18,18 +18,23 @@ uuid.workspace = true
 tokio.workspace = true
 indexer-monitor = { path = "../monitor" }
 tracing.workspace = true
+graph-networks-registry.workspace = true
 
 bytes = { version = "1.10.0", optional = true }
 derivative = "2.2.0"
 
 futures = "0.3"
 http = "0.2"
 prost = { workspace = true, optional = true }
-ipfs-api-backend-hyper = { version = "0.6.0", features = ["with-send-sync", "with-hyper-tls"] }
+ipfs-api-backend-hyper = { version = "0.6.0", features = [
+    "with-send-sync",
+    "with-hyper-tls",
+] }
 serde_yaml.workspace = true
 serde.workspace = true
 sqlx = { workspace = true, optional = true }
 tonic = { workspace = true, optional = true }
+serde_json.workspace = true
 
 [dev-dependencies]
 rand = "0.9.0"

crates/dips/Cargo.toml

@@ -6,7 +6,9 @@ use std::{str::FromStr, sync::Arc};
 use server::DipsServerContext;
 use thegraph_core::alloy::{
     core::primitives::Address,
-    primitives::{b256, ChainId, PrimitiveSignature as Signature, Uint, B256},
+    primitives::{
+        b256, ruint::aliases::U256, ChainId, PrimitiveSignature as Signature, Uint, B256,
+    },
     signers::SignerSync,
     sol,
     sol_types::{eip712_domain, Eip712Domain, SolStruct, SolValue},
@@ -18,6 +20,7 @@ pub mod ipfs;
 pub mod price;
 #[cfg(feature = "rpc")]
 pub mod proto;
+pub mod registry;
 #[cfg(feature = "rpc")]
 pub mod server;
 pub mod signers;
@@ -145,8 +148,12 @@ pub enum DipsError {
     InvalidSubgraphManifest(String),
     #[error("chainId {0} is not supported")]
     UnsupportedChainId(String),
-    #[error("price per block is below configured price for chain {0}, minimum: {1}, offered: {2}")]
-    PricePerBlockTooLow(String, u64, String),
+    #[error("price per epoch is below configured price for chain {0}, minimum: {1}, offered: {2}")]
+    PricePerEpochTooLow(String, u64, String),
+    #[error(
+        "price per entity is below configured price for chain {0}, minimum: {1}, offered: {2}"
+    )]
+    PricePerEntityTooLow(String, u64, String),
     // cancellation
     #[error("cancelled_by is expected to match the signer")]
     UnexpectedSigner,
@@ -304,6 +311,7 @@ pub async fn validate_and_create_agreement(
         ipfs_fetcher,
         price_calculator,
         signer_validator,
+        registry,
     } = ctx.as_ref();
     let decoded_voucher = SignedIndexingAgreementVoucher::abi_decode(voucher.as_ref(), true)
         .map_err(|e| DipsError::AbiDecoding(e.to_string()))?;
@@ -330,19 +338,33 @@ pub async fn validate_and_create_agreement(
         }
     }
 
-    let offered_price = metadata.pricePerEntity;
+    let network = match registry.get_network_by_id(&metadata.chainId) {
+        Some(network) => network.id.clone(),
+        None => return Err(DipsError::UnsupportedChainId(metadata.chainId)),
+    };
+
+    let offered_epoch_price = metadata.basePricePerEpoch;
     match price_calculator.get_minimum_price(&metadata.chainId) {
-        Some(price) if offered_price.lt(&Uint::from(price)) => {
-            return Err(DipsError::PricePerBlockTooLow(
-                metadata.chainId,
+        Some(price) if offered_epoch_price.lt(&Uint::from(price)) => {
+            return Err(DipsError::PricePerEpochTooLow(
+                network,
                 price,
-                offered_price.to_string(),
+                offered_epoch_price.to_string(),
             ))
         }
         Some(_) => {}
         None => return Err(DipsError::UnsupportedChainId(metadata.chainId)),
     }
 
+    let offered_entity_price = metadata.pricePerEntity;
+    if offered_entity_price < U256::from(price_calculator.entity_price()) {
+        return Err(DipsError::PricePerEntityTooLow(
+            network,
+            price_calculator.entity_price(),
+            offered_entity_price.to_string(),
+        ));
+    }
+
     store
         .create_agreement(decoded_voucher.clone(), metadata)
         .await?;
@@ -754,7 +776,17 @@ mod test {
             subgraphDeploymentId: voucher_ctx.deployment_id.clone(),
         };
 
-        let low_price_voucher = voucher_ctx.test_voucher(metadata);
+        let low_entity_price_voucher = voucher_ctx.test_voucher(metadata);
+
+        let metadata = SubgraphIndexingVoucherMetadata {
+            basePricePerEpoch: U256::from(10_u64),
+            pricePerEntity: U256::from(10000_u64),
+            protocolNetwork: "eip155:42161".to_string(),
+            chainId: "mainnet".to_string(),
+            subgraphDeploymentId: voucher_ctx.deployment_id.clone(),
+        };
+
+        let low_epoch_price_voucher = voucher_ctx.test_voucher(metadata);
 
         let metadata = SubgraphIndexingVoucherMetadata {
             basePricePerEpoch: U256::from(10000_u64),
@@ -775,11 +807,16 @@ mod test {
             Err(DipsError::InvalidSubgraphManifest(
                 voucher_ctx.deployment_id.clone(),
             )),
-            Err(DipsError::PricePerBlockTooLow(
+            Err(DipsError::PricePerEntityTooLow(
                 "mainnet".to_string(),
                 100,
                 "10".to_string(),
             )),
+            Err(DipsError::PricePerEpochTooLow(
+                "mainnet".to_string(),
+                200,
+                "10".to_string(),
+            )),
             Err(DipsError::SignerNotAuthorised(signer.address())),
             Ok(valid_voucher
                 .voucher
@@ -790,7 +827,8 @@ mod test {
         ];
         let cases = vec![
             no_network_voucher,
-            low_price_voucher,
+            low_entity_price_voucher,
+            low_epoch_price_voucher,
             valid_voucher_invalid_signer,
             valid_voucher,
         ];

crates/dips/src/lib.rs

@@ -5,25 +5,27 @@ use std::collections::HashMap;
 
 #[derive(Debug, Default)]
 pub struct PriceCalculator {
-    prices_per_chain: HashMap<String, u64>,
-    default_price: Option<u64>,
+    base_price_per_epoch: HashMap<String, u64>,
+    price_per_entity: u64,
 }
 
 impl PriceCalculator {
     #[cfg(test)]
     pub fn for_testing() -> Self {
         Self {
-            prices_per_chain: HashMap::default(),
-            default_price: Some(100),
+            base_price_per_epoch: HashMap::from_iter(vec![("mainnet".to_string(), 200)]),
+            price_per_entity: 100,
         }
     }
 
     pub fn is_supported(&self, chain_id: &str) -> bool {
         self.get_minimum_price(chain_id).is_some()
     }
     pub fn get_minimum_price(&self, chain_id: &str) -> Option<u64> {
-        let chain_price = self.prices_per_chain.get(chain_id).copied();
+        self.base_price_per_epoch.get(chain_id).copied()
+    }
 
-        chain_price.or(self.default_price)
+    pub fn entity_price(&self) -> u64 {
+        self.price_per_entity
     }
 }

crates/dips/src/price.rs

@@ -0,0 +1,74 @@
+// Copyright 2023-, Edge & Node, GraphOps, and Semiotic Labs.
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(test)]
+use graph_networks_registry::NetworksRegistry;
+
+#[cfg(test)]
+pub fn test_registry() -> NetworksRegistry {
+    use graph_networks_registry::{Network, NetworkType, Services};
+
+    NetworksRegistry {
+        schema: "".to_string(),
+        description: "".to_string(),
+        networks: vec![
+            Network {
+                aliases: None,
+                api_urls: None,
+                caip2_id: "eip155:1".to_string(),
+                docs_url: None,
+                explorer_urls: None,
+                firehose: None,
+                full_name: "".to_string(),
+                genesis: None,
+                graph_node: None,
+                icon: None,
+                id: "mainnet".to_string(),
+                indexer_docs_urls: None,
+                issuance_rewards: false,
+                native_token: None,
+                network_type: NetworkType::Mainnet,
+                relations: None,
+                rpc_urls: None,
+                second_name: None,
+                services: Services {
+                    firehose: None,
+                    sps: None,
+                    subgraphs: None,
+                    substreams: None,
+                },
+                short_name: "mainnet".to_string(),
+            },
+            Network {
+                aliases: None,
+                api_urls: None,
+                caip2_id: "eip155:1337".to_string(),
+                docs_url: None,
+                explorer_urls: None,
+                firehose: None,
+                full_name: "".to_string(),
+                genesis: None,
+                graph_node: None,
+                icon: None,
+                id: "hardhat".to_string(),
+                indexer_docs_urls: None,
+                issuance_rewards: false,
+                native_token: None,
+                network_type: NetworkType::Mainnet,
+                relations: None,
+                rpc_urls: None,
+                second_name: None,
+                services: Services {
+                    firehose: None,
+                    sps: None,
+                    subgraphs: None,
+                    substreams: None,
+                },
+                short_name: "hardhat".to_string(),
+            },
+        ],
+        title: "".to_string(),
+        updated_at: "".to_string(),
+        version: "".to_string(),
+    }
+}