runtime: Disable ipfs.cat by default

Author: leoyvens

runtime/wasm/src/host.rs

@@ -30,6 +30,15 @@ use crate::mapping::{MappingContext, MappingRequest, MappingTrigger};
 
 pub(crate) const TIMEOUT_ENV_VAR: &str = "GRAPH_MAPPING_HANDLER_TIMEOUT";
 
+lazy_static! {
+    pub static ref TIMEOUT: Option<Duration> = std::env::var(TIMEOUT_ENV_VAR)
+        .ok()
+        .map(|s| u64::from_str(&s).expect("Invalid value for GRAPH_MAPPING_HANDLER_TIMEOUT"))
+        .map(Duration::from_secs);
+    static ref ALLOW_NON_DETERMINISTIC_IPFS: bool =
+        std::env::var("GRAPH_ALLOW_NON_DETERMINISTIC_IPFS").is_ok();
+}
+
 struct RuntimeHostConfig {
     subgraph_id: SubgraphDeploymentId,
     mapping: Mapping,
@@ -97,18 +106,14 @@ where
         subgraph_id: SubgraphDeploymentId,
         metrics: Arc<HostMetrics>,
     ) -> Result<Sender<Self::Req>, anyhow::Error> {
-        let timeout = std::env::var(TIMEOUT_ENV_VAR)
-            .ok()
-            .and_then(|s| u64::from_str(&s).ok())
-            .map(Duration::from_secs);
-
         crate::mapping::spawn_module(
             raw_module,
             logger,
             subgraph_id,
             metrics,
             tokio::runtime::Handle::current(),
-            timeout,
+            *TIMEOUT,
+            *ALLOW_NON_DETERMINISTIC_IPFS,
         )
     }
 

runtime/wasm/src/host_exports.rs

@@ -413,6 +413,7 @@ impl HostExports {
                     ctx.derive_with_empty_block_state(),
                     host_metrics.clone(),
                     module.timeout,
+                    module.allow_non_determinstic_ipfs,
                 )?;
                 let result = module.handle_json_callback(&callback, &sv.value, &user_data)?;
                 // Log progress every 15s

runtime/wasm/src/mapping.rs

@@ -20,6 +20,7 @@ pub fn spawn_module(
     host_metrics: Arc<HostMetrics>,
     runtime: tokio::runtime::Handle,
     timeout: Option<Duration>,
+    allow_non_deterministic_ipfs: bool,
 ) -> Result<mpsc::Sender<MappingRequest>, anyhow::Error> {
     let valid_module = Arc::new(ValidModule::new(&raw_module)?);
 
@@ -54,6 +55,7 @@ pub fn spawn_module(
                         ctx,
                         host_metrics.clone(),
                         timeout,
+                        allow_non_deterministic_ipfs,
                     )?;
                     section.end();
 

runtime/wasm/src/module/mod.rs

@@ -246,6 +246,8 @@ pub(crate) struct WasmInstanceContext {
 
     // A trap ocurred due to a possible reorg detection.
     possible_reorg: bool,
+
+    pub(crate) allow_non_determinstic_ipfs: bool,
 }
 
 impl WasmInstance {
@@ -255,6 +257,7 @@ impl WasmInstance {
         ctx: MappingContext,
         host_metrics: Arc<HostMetrics>,
         timeout: Option<Duration>,
+        allow_non_determinstic_ipfs: bool,
     ) -> Result<WasmInstance, anyhow::Error> {
         let mut linker = wasmtime::Linker::new(&wasmtime::Store::new(valid_module.module.engine()));
 
@@ -322,6 +325,7 @@ impl WasmInstance {
                                     host_metrics.cheap_clone(),
                                     timeout,
                                     timeout_stopwatch.cheap_clone(),
+                                    allow_non_determinstic_ipfs
                                 ).unwrap())
                             }
 
@@ -366,6 +370,7 @@ impl WasmInstance {
                                 host_metrics.cheap_clone(),
                                 timeout,
                                 timeout_stopwatch.cheap_clone(),
+                                allow_non_determinstic_ipfs,
                             )
                             .unwrap(),
                         )
@@ -482,6 +487,7 @@ impl WasmInstance {
                 host_metrics,
                 timeout,
                 timeout_stopwatch,
+                allow_non_determinstic_ipfs,
             )?);
         }
 
@@ -548,6 +554,7 @@ impl WasmInstanceContext {
         host_metrics: Arc<HostMetrics>,
         timeout: Option<Duration>,
         timeout_stopwatch: Arc<std::sync::Mutex<TimeoutStopwatch>>,
+        allow_non_determinstic_ipfs: bool,
     ) -> Result<Self, anyhow::Error> {
         // Provide access to the WASM runtime linear memory
         let memory = instance
@@ -570,6 +577,7 @@ impl WasmInstanceContext {
             arena_free_size: 0,
             arena_start_ptr: 0,
             possible_reorg: false,
+            allow_non_determinstic_ipfs,
         })
     }
 
@@ -580,6 +588,7 @@ impl WasmInstanceContext {
         host_metrics: Arc<HostMetrics>,
         timeout: Option<Duration>,
         timeout_stopwatch: Arc<std::sync::Mutex<TimeoutStopwatch>>,
+        allow_non_determinstic_ipfs: bool,
     ) -> Result<Self, anyhow::Error> {
         let memory = caller
             .get_export("memory")
@@ -605,6 +614,7 @@ impl WasmInstanceContext {
             arena_free_size: 0,
             arena_start_ptr: 0,
             possible_reorg: false,
+            allow_non_determinstic_ipfs,
         })
     }
 }
@@ -805,6 +815,13 @@ impl WasmInstanceContext {
 
     /// function ipfs.cat(link: String): Bytes
     fn ipfs_cat(&mut self, link_ptr: AscPtr<AscString>) -> Result<AscPtr<Uint8Array>, Trap> {
+        if !self.allow_non_determinstic_ipfs {
+            return Err(anyhow::anyhow!(
+                "`ipfs.cat` is deprecated. Improved support for IPFS will be added in the future"
+            )
+            .into());
+        }
+
         let link = self.asc_get(link_ptr);
         let ipfs_res = self.ctx.host_exports.ipfs_cat(&self.ctx.logger, link);
         match ipfs_res {
@@ -831,6 +848,13 @@ impl WasmInstanceContext {
         user_data: AscPtr<AscEnum<StoreValueKind>>,
         flags: AscPtr<Array<AscPtr<AscString>>>,
     ) -> Result<(), Trap> {
+        if !self.allow_non_determinstic_ipfs {
+            return Err(anyhow::anyhow!(
+                "`ipfs.map` is deprecated. Improved support for IPFS will be added in the future"
+            )
+            .into());
+        }
+
         let link: String = self.asc_get(link_ptr);
         let callback: String = self.asc_get(callback);
         let user_data: store::Value = self.try_asc_get(user_data)?;

runtime/wasm/src/module/test.rs

@@ -59,10 +59,8 @@ fn test_valid_module_and_store(
         Arc::new(ValidModule::new(data_source.mapping.runtime.as_ref()).unwrap()),
         mock_context(deployment_id, data_source, store.clone()),
         host_metrics,
-        std::env::var(crate::host::TIMEOUT_ENV_VAR)
-            .ok()
-            .and_then(|s| u64::from_str(&s).ok())
-            .map(std::time::Duration::from_secs),
+        *crate::host::TIMEOUT,
+        true,
     )
     .unwrap();