Server only api

.github/workflows/container-image.yml

@@ -4,9 +4,6 @@ on:
   push:
     tags:
     - v[0-9]+.[0-9]+.[0-9]+*
-    branches:
-    - dev
-    - feature/server_only
   workflow_dispatch:
 
 jobs:

README.md

@@ -95,3 +95,46 @@ Example:
 `cargo run --bin convert --safes-json safes.json --edges-bin edges.dat`
 
 Converts a safe json file called `safes.json` into a binary edge database file called `edges.dat`.
+
+
+```shell
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -d '{
+    "id": "1",
+    "method": "load_safes_binary",
+    "params": {
+        "file": "/home/daniel/src/CirclesUBI/pathfinder2/graph_at_20230523_15_00.db"
+    }
+}' \
+  "http://localhost:1234"
+
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -d '{
+    "id": "1",
+    "method": "load_safes_binary",
+    "params": {
+        "file": "/var/pathfinder2/data/graph_at_20230523_15_00.db"
+    }
+}' \
+  "http://65.109.109.165:54390"
+
+
+
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -d '{
+    "id": "1",
+    "method": "compute_transfer",
+    "params": {
+        "from": "0xde374ece6fa50e781e81aac78e811b33d16912c7",
+        "to": "0x6de572faa138048ce8142c4a206eb09a8ec39e45",
+        "value": "9999999999999999999999999",
+        "iterative": false,
+        "prune": true
+    }
+}' \
+  "http://localhost:1234"
+
+```

src/graph/adjacencies.rs

@@ -10,10 +10,6 @@ pub struct Adjacencies<'a> {
     capacity_adjustments: HashMap<Node, HashMap<Node, U256>>,
 }
 
-// fn pseudo_node(edge: Edge) -> Node {
-//     Node::TokenEdge(edge.from, edge.token)
-// }
-
 fn balance_node(edge: &Edge) -> Node {
     Node::BalanceNode(edge.from, edge.token)
 }
@@ -22,13 +18,6 @@ fn trust_node(edge: &Edge) -> Node {
     Node::TrustNode(edge.to, edge.token)
 }
 
-// fn source_address_of(node: &Node) -> &Address {
-//     match node {
-//         Node::Node(addr) => addr,
-//         Node::TokenEdge(from, _) => from,
-//     }
-// }
-
 impl<'a> Adjacencies<'a> {
     pub fn new(edges: &'a EdgeDB) -> Self {
         Adjacencies {

src/graph/augmenting_path.rs

@@ -0,0 +1,54 @@
+use crate::graph::adjacencies::Adjacencies;
+use crate::graph::Node;
+use crate::types::{Address, U256};
+use std::cmp::min;
+use std::collections::{HashMap, VecDeque};
+
+pub fn augmenting_path(
+    source: &Address,
+    sink: &Address,
+    adjacencies: &mut Adjacencies,
+    max_distance: Option<u64>,
+) -> (U256, Vec<Node>) {
+    let mut parent = HashMap::new();
+    if *source == *sink {
+        return (U256::default(), vec![]);
+    }
+    let mut queue = VecDeque::<(Node, (u64, U256))>::new();
+    queue.push_back((Node::Node(*source), (0, U256::default() - U256::from(1))));
+    while let Some((node, (depth, flow))) = queue.pop_front() {
+        if let Some(max) = max_distance {
+            // * 3 because we have three edges per trust connection (two intermediate nodes).
+            if depth >= max * 3 {
+                continue;
+            }
+        }
+        for (target, capacity) in adjacencies.outgoing_edges_sorted_by_capacity(&node) {
+            if !parent.contains_key(&target) && capacity > U256::default() {
+                parent.insert(target.clone(), node.clone());
+                let new_flow = min(flow, capacity);
+                if target == Node::Node(*sink) {
+                    return (
+                        new_flow,
+                        trace(parent, &Node::Node(*source), &Node::Node(*sink)),
+                    );
+                }
+                queue.push_back((target, (depth + 1, new_flow)));
+            }
+        }
+    }
+    (U256::default(), vec![])
+}
+
+fn trace(parent: HashMap<Node, Node>, source: &Node, sink: &Node) -> Vec<Node> {
+    let mut t = vec![sink.clone()];
+    let mut node = sink;
+    loop {
+        node = parent.get(node).unwrap();
+        t.push(node.clone());
+        if *node == *source {
+            break;
+        }
+    }
+    t
+}