diff --git a/saved_graphs/baby.json b/saved_graphs/baby.json
index 0991b427..f76ae5c6 100644
--- a/saved_graphs/baby.json
+++ b/saved_graphs/baby.json
@@ -58,7 +58,10 @@
     },
     {
       "data": {
-        "label": "Neutron source"
+        "label": "Neutron source",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "dragging": false,
       "id": "5",
@@ -75,7 +78,10 @@
     },
     {
       "data": {
-        "label": "Neutron rate"
+        "label": "Neutron rate",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "dragging": false,
       "id": "6",
@@ -130,7 +136,10 @@
     },
     {
       "data": {
-        "label": "IV vial activity"
+        "label": "IV vial activity",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "dragging": false,
       "id": "21",
@@ -269,7 +278,10 @@
         "y": 1097.1334152526842
       },
       "data": {
-        "label": "OV vial activity"
+        "label": "OV vial activity",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "measured": {
         "width": 120,
@@ -286,7 +298,10 @@
         "y": 786
       },
       "data": {
-        "label": "BABY inventory"
+        "label": "BABY inventory",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "measured": {
         "width": 120,
diff --git a/src/App.jsx b/src/App.jsx
index 0b05e2a6..0e80367f 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -93,6 +93,24 @@ export default function App() {
 
   // Global variables state
   const [globalVariables, setGlobalVariables] = useState([]);
+  const [defaultValues, setDefaultValues] = useState({});
+
+  // Function to fetch default values for a node type
+  const fetchDefaultValues = async (nodeType) => {
+    try {
+      const response = await fetch(`http://localhost:8000/default-values/${nodeType}`);
+      if (response.ok) {
+        const defaults = await response.json();
+        return defaults;
+      } else {
+        console.error('Failed to fetch default values');
+        return {};
+      }
+    } catch (error) {
+      console.error('Error fetching default values:', error);
+      return {};
+    }
+  };
 
   // Function to save a graph to computer with "Save As" dialog
   const saveGraph = async () => {
@@ -584,7 +602,7 @@ export default function App() {
     );
   };
   // Function to add a new node to the graph
-  const addNode = () => {
+  const addNode = async () => {
     // Get available node types from nodeTypes object
     const availableTypes = Object.keys(nodeTypes);
 
@@ -611,78 +629,24 @@ export default function App() {
 
     const selectedType = availableTypes[choiceIndex];
     const newNodeId = nodeCounter.toString();
-
-    // Create appropriate data based on node type
+    
+    // Fetch default values for this node type
+    const defaults = await fetchDefaultValues(selectedType);
+    
+    // Store default values for this node type
+    setDefaultValues(prev => ({
+      ...prev,
+      [selectedType]: defaults
+    }));
+    
+    // Create node data with label and initialize all expected fields as empty strings
     let nodeData = { label: `${selectedType} ${newNodeId}` };
-
-    // Add type-specific default parameters
-    switch (selectedType) {
-      case 'process':
-        nodeData = { ...nodeData, residence_time: '', source_term: '', initial_value: '' };
-        break;
-      case 'process_horizontal':
-        nodeData = { ...nodeData, residence_time: '', source_term: '', initial_value: '' };
-        break;
-      case 'constant':
-        nodeData = { ...nodeData, value: '' };
-        break;
-      case 'stepsource':
-        nodeData = { ...nodeData, amplitude: '1', delay: '1' };
-        break;
-      case 'pulsesource':
-        nodeData = { ...nodeData, amplitude: '1', T: '1', t_rise: '0.0', t_fall: '0.0', tau: '0.0', duty: '0.5' };
-        break;
-      case 'amplifier':
-        nodeData = { ...nodeData, gain: '' };
-        break;
-      case 'amplifier_reverse':
-        nodeData = { ...nodeData, gain: '' };
-        break;
-      case 'multiplier':
-        break;
-      case 'integrator':
-        nodeData = { ...nodeData, initial_value: '', reset_times: '' };
-        break;
-      case 'adder':
-        break;
-      case 'scope':
-        nodeData = { ...nodeData };
-        break;
-      case 'function':
-        nodeData = { ...nodeData, expression: '' };
-        break;
-      case 'delay':
-        nodeData = { ...nodeData, tau: '' };
-        break;
-      case 'rng':
-        nodeData = { ...nodeData, sampling_rate: '' };
-        break;
-      case 'pid':
-        nodeData = { ...nodeData, Kp: '', Ki: '', Kd: '', f_max: '' };
-        break;
-      case 'splitter2':
-        nodeData = { ...nodeData, f1: '0.5', f2: '0.5' };
-        break;
-      case 'splitter3':
-        nodeData = { ...nodeData, f1: '1/3', f2: '1/3', f3: '1/3' };
-        break;
-      case 'wall':
-        nodeData = { ...nodeData, thickness: '', surface_area: '1', temperature: '', D_0: '1', E_D: '0', n_vertices: '100' };
-        break;
-      case 'bubbler':
-        nodeData = { ...nodeData, conversion_efficiency: '0.95', vial_efficiency: '0.9', replacement_times: '' };
-        break;
-      case 'white_noise':
-        nodeData = { ...nodeData, spectral_density: '1', sampling_rate: '' };
-        break;
-      case 'pink_noise':
-        nodeData = { ...nodeData, spectral_density: '1', num_octaves: '16', sampling_rate: '' };
-        break;
-      default:
-        // For any other types, just use basic data
-        break;
-    }
-
+    
+    // Initialize all expected parameters as empty strings
+    Object.keys(defaults).forEach(key => {
+      nodeData[key] = '';
+    });
+    
     const newNode = {
       id: newNodeId,
       type: selectedType,
@@ -1132,37 +1096,78 @@ export default function App() {
               }}
             >
               <h3>{selectedNode.data.label}</h3>
-              {Object.entries(selectedNode.data)
-                .map(([key, value]) => (
-                  <div key={key} style={{ marginBottom: '10px' }}>
-                    <label>{key}:</label>
-                    <input
-                      type="text"
-                      value={value}
-                      onChange={(e) => {
-                        const newValue = e.target.value;
-                        const updatedNode = {
-                          ...selectedNode,
-                          data: { ...selectedNode.data, [key]: newValue },
-                        };
-
-                        setNodes((nds) =>
-                          nds.map((node) =>
-                            node.id === selectedNode.id ? updatedNode : node
-                          )
-                        );
-                        setSelectedNode(updatedNode);
-
-                      }}
-
-                      style={{ width: '100%', marginTop: 4 }}
-                    />
-                  </div>
-                ))}
+              {(() => {
+                // Get default values for this node type
+                const nodeDefaults = defaultValues[selectedNode.type] || {};
+                
+                // Create a list of all possible parameters (both current data and defaults)
+                const allParams = new Set([
+                  ...Object.keys(selectedNode.data),
+                  ...Object.keys(nodeDefaults)
+                ]);
+                
+                return Array.from(allParams)
+                  .map(key => {
+                    const currentValue = selectedNode.data[key] || '';
+                    const defaultValue = nodeDefaults[key];
+                    const placeholder = defaultValue !== undefined && defaultValue !== null ? 
+                      String(defaultValue) : '';
+                    
+                    return (
+                      <div key={key} style={{ marginBottom: '10px' }}>
+                        <label style={{ 
+                          color: '#ffffff', 
+                          display: 'block', 
+                          marginBottom: '4px',
+                          fontSize: '14px'
+                        }}>
+                          {key}:
+                        </label>
+                        <input
+                          type="text"
+                          value={currentValue}
+                          placeholder={placeholder}
+                          onChange={(e) => {
+                            const newValue = e.target.value;
+                            const updatedNode = {
+                              ...selectedNode,
+                              data: { ...selectedNode.data, [key]: newValue },
+                            };
+
+                            setNodes((nds) =>
+                              nds.map((node) =>
+                                node.id === selectedNode.id ? updatedNode : node
+                              )
+                            );
+                            setSelectedNode(updatedNode);
+                          }}
+                          style={{ 
+                            width: '100%', 
+                            marginTop: 4,
+                            padding: '8px',
+                            borderRadius: '4px',
+                            border: '1px solid #555',
+                            backgroundColor: '#2a2a3e',
+                            color: '#ffffff',
+                            fontSize: '14px'
+                          }}
+                        />
+                      </div>
+                    );
+                  });
+              })()}
 
               <br />
               <button
-                style={{ marginTop: 10 }}
+                style={{ 
+                  marginTop: 10,
+                  padding: '8px 16px',
+                  backgroundColor: '#666',
+                  color: 'white',
+                  border: 'none',
+                  borderRadius: '4px',
+                  cursor: 'pointer'
+                }}
                 onClick={() => setSelectedNode(null)}
               >
                 Close
diff --git a/src/backend.py b/src/backend.py
index 18fb37fd..a620d903 100644
--- a/src/backend.py
+++ b/src/backend.py
@@ -7,9 +7,10 @@
 from plotly.subplots import make_subplots
 import plotly
 import json as plotly_json
+import inspect
 
 from .convert_to_python import convert_graph_to_python
-from .pathsim_utils import make_pathsim_model
+from .pathsim_utils import make_pathsim_model, map_str_to_object
 from pathsim.blocks import Scope
 
 # Configure Flask app for Cloud Run
@@ -62,6 +63,30 @@ def health_check():
     ), 200
 
 
+# returns default values for parameters of a node
+@app.route("/default-values/<string:node_type>", methods=["GET"])
+def get_default_values(node_type):
+    try:
+        if node_type not in map_str_to_object:
+            return jsonify({"error": f"Unknown node type: {node_type}"}), 400
+
+        block_class = map_str_to_object[node_type]
+        parameters_for_class = inspect.signature(block_class.__init__).parameters
+        default_values = {}
+        for param in parameters_for_class:
+            if param != "self":  # Skip 'self' parameter
+                default_value = parameters_for_class[param].default
+                if default_value is inspect._empty:
+                    default_values[param] = None  # Handle empty defaults
+                else:
+                    default_values[param] = default_value
+        return jsonify(default_values)
+    except Exception as e:
+        return jsonify(
+            {"error": f"Could not get default values for {node_type}: {str(e)}"}
+        ), 400
+
+
 # Function to save graphs
 @app.route("/save", methods=["POST"])
 def save_graph():
diff --git a/src/custom_pathsim_blocks.py b/src/custom_pathsim_blocks.py
index a9bdf5fc..f9a51f3c 100644
--- a/src/custom_pathsim_blocks.py
+++ b/src/custom_pathsim_blocks.py
@@ -56,6 +56,44 @@ def __init__(self, f1, f2, f3):
         super().__init__(n=3, fractions=[f1, f2, f3])
 
 
+class Integrator(pathsim.blocks.Integrator):
+    """Integrator block with a reset method."""
+
+    def __init__(self, initial_value=0.0, reset_times=None):
+        """
+        Args:
+            initial_value: Initial value of the integrator.
+            reset_times: List of times at which the integrator is reset. If None, no reset events are created.
+        """
+        super().__init__(initial_value=initial_value)
+        self.reset_times = reset_times
+
+    def create_reset_events(self):
+        """Create reset events for the integrator based on the reset times.
+
+        Raises:
+            ValueError: If reset_times is not valid.
+
+        Returns:
+            list of reset events.
+        """
+        if self.reset_times is None:
+            return []
+        if isinstance(self.reset_times, (int, float)):
+            reset_times = [self.reset_times]
+        elif isinstance(self.reset_times, list) and all(
+            isinstance(t, (int, float)) for t in self.reset_times
+        ):
+            reset_times = self.reset_times
+        else:
+            raise ValueError("reset_times must be a single value or a list of times")
+
+        return [
+            pathsim.blocks.Schedule(t_start=t, t_end=t, func_act=self.reset)
+            for t in reset_times
+        ]
+
+
 # BUBBLER SYSTEM
 
 
diff --git a/src/pathsim_utils.py b/src/pathsim_utils.py
index c1554525..0eebbc74 100644
--- a/src/pathsim_utils.py
+++ b/src/pathsim_utils.py
@@ -12,7 +12,6 @@
     Amplifier,
     Adder,
     Multiplier,
-    Integrator,
     Function,
     Delay,
     RNG,
@@ -27,6 +26,7 @@
     Splitter3,
     Bubbler,
     FestimWall,
+    Integrator,
 )
 from flask import jsonify
 import inspect
@@ -82,24 +82,13 @@ def create_integrator(
     if eval_namespace is None:
         eval_namespace = globals()
 
-    block = Integrator(
-        initial_value=eval(node["data"]["initial_value"], eval_namespace)
-        if node["data"].get("initial_value") and node["data"]["initial_value"] != ""
-        else 0.0,
+    parameters = get_parameters_for_block_class(
+        Integrator, node, eval_namespace=eval_namespace
     )
+
+    block = Integrator(**parameters)
     # add events to reset integrator if needed
-    events = []
-    if node["data"]["reset_times"] != "":
-
-        def reset_itg(_):
-            block.reset()
-
-        reset_times = eval(node["data"]["reset_times"], eval_namespace)
-        if isinstance(reset_times, (int, float)):
-            # If it's a single number, convert it to a list
-            reset_times = [reset_times]
-        for t in reset_times:
-            events.append(Schedule(t_start=t, t_end=t, func_act=reset_itg))
+    events = block.create_reset_events()
     return block, events
 
 
@@ -153,20 +142,15 @@ def create_bubbler(node: dict) -> Bubbler:
     Create a Bubbler block based on the node data.
     """
     # Extract parameters from node data
-    block = Bubbler(
-        conversion_efficiency=eval(node["data"]["conversion_efficiency"]),
-        vial_efficiency=eval(node["data"]["vial_efficiency"]),
-        replacement_times=eval(node["data"]["replacement_times"])
-        if node["data"].get("replacement_times") != ""
-        else None,
-    )
+    parameters = get_parameters_for_block_class(Bubbler, node, eval_namespace=globals())
+    block = Bubbler(**parameters)
 
     events = block.create_reset_events()
 
     return block, events
 
 
-def create_scope(node: dict, edges, nodes) -> Scope:
+def make_labels_for_scope(node: dict, edges: list, nodes: list) -> list[str]:
     # Find all incoming edges to this node and sort by source id for consistent ordering
     incoming_edges = [edge for edge in edges if edge["target"] == node["id"]]
     incoming_edges.sort(key=lambda x: x["source"])
@@ -193,8 +177,17 @@ def create_scope(node: dict, edges, nodes) -> Scope:
             if edge["sourceHandle"]:
                 labels[i] += f" ({edge['sourceHandle']})"
 
-    block = Scope(labels=labels)
+    return labels, connections_order
+
+
+def create_scope(node: dict, edges, nodes) -> Scope:
+    block = auto_block_construction(node, eval_namespace=globals())
+
+    # override labels + add connections order
+    # TODO this should be done in "make connections"
+    labels, connections_order = make_labels_for_scope(node, edges, nodes)
     block._connections_order = connections_order
+    block.labels = labels
 
     return block
 
@@ -297,17 +290,19 @@ def auto_block_construction(node: dict, eval_namespace: dict = None) -> Block:
     if eval_namespace is None:
         eval_namespace = globals()
 
-    block_type = node["type"]
+    if node["type"] not in map_str_to_object:
+        raise ValueError(f"Unknown block type: {node['type']}")
 
-    if eval_namespace is None:
-        eval_namespace = globals()
+    block_class = map_str_to_object[node["type"]]
+
+    parameters = get_parameters_for_block_class(
+        block_class, node, eval_namespace=eval_namespace
+    )
 
-    block_type = node["type"]
-    if block_type not in map_str_to_object:
-        raise ValueError(f"Unknown block type: {block_type}")
+    return block_class(**parameters)
 
-    block_class = map_str_to_object[block_type]
 
+def get_parameters_for_block_class(block_class, node, eval_namespace):
     parameters_for_class = inspect.signature(block_class.__init__).parameters
     parameters = {}
     for k, value in parameters_for_class.items():
@@ -321,13 +316,12 @@ def auto_block_construction(node: dict, eval_namespace: dict = None) -> Block:
         if user_input == "":
             if value.default is inspect._empty:
                 raise ValueError(
-                    f"expected parameter for {k} in {block_type} ({node['label']})"
+                    f"expected parameter for {k} in {node['type']} ({node['label']})"
                 )
             parameters[k] = value.default
         else:
             parameters[k] = eval(user_input, eval_namespace)
-
-    return block_class(**parameters)
+    return parameters
 
 
 def make_blocks(
diff --git a/src/templates/block_macros.py b/src/templates/block_macros.py
index de677dab..7137ce5c 100644
--- a/src/templates/block_macros.py
+++ b/src/templates/block_macros.py
@@ -13,18 +13,9 @@
 {% macro create_integrator_block(node) -%}
 {{ create_block(node) }}
 
-{%- if node["data"].get("reset_times") %}
-def reset_{{ node["var_name"] }}(_):
-    {{ node["var_name"] }}.reset()
-
-for t in {{ node["data"].get("reset_times", "[]") }}:
-    events.append(
-        pathsim.events.Schedule(
-            t_start=t,
-            t_end=t,
-            func_act=reset_{{ node["var_name"] }},
-        )
-    )
+{%- if node["data"].get("replacement_times") %}
+events_{{ node["var_name"] }} = {{ node["var_name"] }}.create_reset_events()
+events += events_{{ node["var_name"] }}
 {%- endif %}
 
 {%- endmacro -%}
diff --git a/test/test_backend.py b/test/test_backend.py
index 2c46174a..0937dcda 100644
--- a/test/test_backend.py
+++ b/test/test_backend.py
@@ -2,8 +2,10 @@
     create_integrator,
     auto_block_construction,
     create_function,
+    create_bubbler,
+    create_scope,
 )
-from src.custom_pathsim_blocks import Process, Splitter2, Splitter3
+from src.custom_pathsim_blocks import Process, Splitter2, Splitter3, Bubbler, Integrator
 
 import pathsim.blocks
 
@@ -28,6 +30,14 @@
         "type": "integrator",
         "data": {"initial_value": "0.0", "label": "Integrator", "reset_times": ""},
     },
+    "bubbler": {
+        "type": "bubbler",
+        "data": {
+            "conversion_efficiency": "",
+            "replacement_times": "",
+            "vial_efficiency": "",
+        },
+    },
     "function": {
         "type": "function",
         "data": {"expression": "3*x**2", "label": "Function"},
@@ -55,7 +65,10 @@
         "type": "splitter3",
         "data": {"f1": "1/3", "f2": "1/3", "f3": "1/3", "label": "Splitter 3"},
     },
-    "scope": {"type": "scope", "data": {"label": "Scope"}},
+    "scope": {
+        "type": "scope",
+        "data": {"label": "Scope", "sampling_rate": "", "labels": ""},
+    },
     "white_noise": {
         "type": "white_noise",
         "data": {
@@ -118,7 +131,7 @@ def test_create_integrator():
     }
     integrator, events = create_integrator(node)
 
-    assert isinstance(integrator, pathsim.blocks.Integrator)
+    assert isinstance(integrator, Integrator)
     assert integrator.initial_value == 0
     for event in events:
         assert isinstance(event, pathsim.blocks.Schedule)
@@ -186,3 +199,34 @@ def test_create_function():
     block = create_function(node, eval_namespace={"b": 2.5})
     assert isinstance(block, pathsim.blocks.Function)
     assert block.func(2) == 3 * 2**2 + 2.5
+
+
+def test_create_bubbler():
+    node = {
+        "id": "6",
+        "type": "bubbler",
+        "position": {"x": 627, "y": 357},
+        "data": {
+            "label": "bubbler 6",
+            "conversion_efficiency": "",
+            "replacement_times": "[1, 2, 3]",
+            "vial_efficiency": "",
+        },
+        "measured": {"width": 230, "height": 160},
+        "selected": False,
+        "dragging": False,
+    }
+    block, events = create_bubbler(node)
+    assert isinstance(block, Bubbler)
+
+
+def test_make_scope():
+    node = {
+        "id": "7",
+        "type": "scope",
+        "data": {"label": "scope 7", "sampling_rate": "", "labels": "", "t_wait": ""},
+    }
+    block = create_scope(node, edges=[], nodes=[node])
+    assert isinstance(block, pathsim.blocks.Scope)
+    assert block.labels == []
+    assert block.sampling_rate is None
diff --git a/test/test_convert_python.py b/test/test_convert_python.py
index 38dfc6ea..fc87013e 100644
--- a/test/test_convert_python.py
+++ b/test/test_convert_python.py
@@ -37,6 +37,9 @@
             "type": "scope",
             "data": {
                 "label": "scope_1",
+                "labels": "",
+                "sampling_rate": "",
+                "t_wait": "",
             },
         },
     ],
@@ -102,6 +105,7 @@
         "test_files/constant_delay_scope.json",
         "test_files/custom_nodes.json",
         "test_files/same_label.json",
+        "test_files/bubbler.json",
     ],
 )
 def test_nested_templates(data):
diff --git a/test/test_files/bubbler.json b/test/test_files/bubbler.json
new file mode 100644
index 00000000..8acba0c0
--- /dev/null
+++ b/test/test_files/bubbler.json
@@ -0,0 +1,189 @@
+{
+  "nodes": [
+    {
+      "id": "1",
+      "type": "bubbler",
+      "position": {
+        "x": 644,
+        "y": 335
+      },
+      "data": {
+        "label": "bubbler 1",
+        "conversion_efficiency": "",
+        "replacement_times": "",
+        "vial_efficiency": ""
+      },
+      "measured": {
+        "width": 230,
+        "height": 160
+      },
+      "selected": true,
+      "dragging": false
+    },
+    {
+      "id": "2",
+      "type": "constant",
+      "position": {
+        "x": 250,
+        "y": 200
+      },
+      "data": {
+        "label": "constant 2",
+        "value": ""
+      },
+      "measured": {
+        "width": 205,
+        "height": 53
+      }
+    },
+    {
+      "id": "3",
+      "type": "scope",
+      "position": {
+        "x": 1165,
+        "y": 314
+      },
+      "data": {
+        "label": "scope 3",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
+      },
+      "measured": {
+        "width": 120,
+        "height": 140
+      },
+      "selected": false,
+      "dragging": false
+    }
+  ],
+  "edges": [
+    {
+      "id": "e2-1-to_sample_in_soluble",
+      "source": "2",
+      "target": "1",
+      "sourceHandle": null,
+      "targetHandle": "sample_in_soluble",
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e2-1-to_sample_in_insoluble",
+      "source": "2",
+      "target": "1",
+      "sourceHandle": null,
+      "targetHandle": "sample_in_insoluble",
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e1-3-from_vial1",
+      "source": "1",
+      "target": "3",
+      "sourceHandle": "vial1",
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e1-3-from_vial2",
+      "source": "1",
+      "target": "3",
+      "sourceHandle": "vial2",
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e1-3-from_vial3",
+      "source": "1",
+      "target": "3",
+      "sourceHandle": "vial3",
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    },
+    {
+      "id": "e1-3-from_vial4",
+      "source": "1",
+      "target": "3",
+      "sourceHandle": "vial4",
+      "targetHandle": null,
+      "type": "smoothstep",
+      "data": {},
+      "style": {
+        "strokeWidth": 2,
+        "stroke": "#ECDFCC"
+      },
+      "markerEnd": {
+        "type": "arrowclosed",
+        "width": 20,
+        "height": 20,
+        "color": "#ECDFCC"
+      }
+    }
+  ],
+  "nodeCounter": 4,
+  "solverParams": {
+    "dt": "0.01",
+    "dt_min": "1e-6",
+    "dt_max": "1.0",
+    "Solver": "SSPRK22",
+    "tolerance_fpi": "1e-6",
+    "iterations_max": "100",
+    "log": "true",
+    "simulation_duration": "50.0",
+    "extra_params": "{}"
+  },
+  "globalVariables": []
+}
\ No newline at end of file
diff --git a/test/test_files/constant_delay_scope.json b/test/test_files/constant_delay_scope.json
index f43feabc..98623d3f 100644
--- a/test/test_files/constant_delay_scope.json
+++ b/test/test_files/constant_delay_scope.json
@@ -42,7 +42,10 @@
         "y": 220
       },
       "data": {
-        "label": "scope 2"
+        "label": "scope 2",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "measured": {
         "width": 120,
diff --git a/test/test_files/same_label.json b/test/test_files/same_label.json
index 8e048c9d..dc23833c 100644
--- a/test/test_files/same_label.json
+++ b/test/test_files/same_label.json
@@ -26,7 +26,10 @@
         "y": 400.9936264496624
       },
       "data": {
-        "label": "scope 2"
+        "label": "scope 2",
+        "labels": "",
+        "sampling_rate": "",
+        "t_wait": ""
       },
       "measured": {
         "width": 120,