def deanonymize_c(G, target, path, amt, fuzz):
pq = PriorityQueue()
cost_function = pf.c_cost_fun(fuzz)
delays = {}
costs = {}
paths = nd.nested_dict()
paths1 = nd.nested_dict()
dists = {}
visited = set()
previous = {}
done = {}
# prob = {}
sources = []
pre = path[0]
adv = path[1]
nxt = path[2]
for node in G.nodes():
previous[node] = -1
delays[node] = -1
costs[node] = max
paths[node] = []
dists[node] = max
done[node] = 0
paths1[node] = []
# prob[node] = 1
dists[target] = 0
paths[target] = [target]
costs[target] = amt
delays[target] = 0
pq.put((dists[target], target))
flag1 = 0
flag2 = 0
while (0 != pq.qsize()):
curr_cost, curr = pq.get()
if curr_cost > dists[curr]:
continue
visited.add(curr)
for [v, curr] in G.in_edges(curr):
if (G.edges[v, curr]["Balance"] + G.edges[curr, v]["Balance"] >=
costs[curr]) and v not in visited:
if done[v] == 0 and G.nodes[v]["Tech"] == 1:
paths1[v] = [v] + paths[curr]
done[v] = 1
cost = dists[curr] + cost_function(G, costs[curr], curr, v)
if cost < dists[v]:
paths[v] = [v] + paths[curr]
dists[v] = cost
delays[v] = delays[curr] + G.edges[v, curr]["Delay"]
costs[v] = costs[curr] + G.edges[v, curr][
"BaseFee"] + costs[curr] * G.edges[v, curr]["FeeRate"]
# prob[v] = pf.edge_prob(G.edges[v,curr]["LastFailure"])*prob[curr]
pq.put((dists[v], v))
if (curr in path[1:]):
ind = path.index(curr)
if (paths[curr] != path[ind:]):
return []
if curr == adv:
flag1 = 1
# if flag1 == 1:
# print("path", paths[adv])
if (curr == pre):
if paths[pre] != path:
return [pre]
else:
sources.append(pre)
flag2 = 1
if flag1 == 1 and flag2 == 1:
if pre in paths[curr]:
for [v, curr] in G.in_edges(curr):
if v not in paths[curr]:
sources.append(v)
sources = list(set(sources))
return sources
if (i % 5 == 1):
amt = rn.randint(1, 10)
elif (i % 5 == 2):
amt = rn.randint(10, 100)
elif (i % 5 == 3):
amt = rn.randint(100, 1000)
elif (i % 5 == 4):
amt = rn.randint(1000, 10000)
else:
amt = rn.randint(10000, 100000)
#print(u, v, amt,G1.nodes[u]["Tech"])
if (G1.nodes[u]["Tech"] == 0):
path, delay, amount, dist = pf.Dijkstra(G1, u, v, amt, pf.lnd_cost_fun)
elif (G1.nodes[u]["Tech"] == 1):
fuzz = rn.uniform(-1, 1)
path, delay, amount, dist = pf.Dijkstra(G1, u, v, amt, pf.c_cost_fun(fuzz))
else:
paths = pf.Dijkstra_general(G1, u, v, amt, pf.eclair_cost_fun)
if (paths[0] == []):
continue
if len(paths[0]) == 2:
path = paths[0]
r = 0
else:
r = rn.randint(0, 2)
path = paths[r]
delay = 0
amount = amt
#print(path, r)
if (len(path) > 2):
for m in range(len(path) - 2, 0, -1):
def deanonymize_c(G, target, path, amt, fuzz):
pq = PriorityQueue()
cost_function = pf.c_cost_fun(fuzz)
delays = {}
costs = {}
paths = nd.nested_dict()
paths1 = nd.nested_dict()
dists = {}
visited = set()
previous = {}
done = {}
# prob = {}
sources = []
pre = path[0]
adv = path[1]
nxt = path[2]
for node in G.nodes():
previous[node] = -1
delays[node] = -1
costs[node] = max
paths[node] = []
dists[node] = max
done[node] = 0
paths1[node] = []
# prob[node] = 1
dists[target] = 0
paths[target] = [target]
costs[target] = amt
delays[target] = 0
pq.put((dists[target], target))
flag1 = 0
flag2 = 0
while (0 != pq.qsize()):
curr_cost, curr = pq.get()
if curr_cost > dists[curr]:
continue
visited.add(curr)
for [v, curr] in G.in_edges(curr):
if (G.edges[v, curr]["Balance"] + G.edges[curr, v]["Balance"] >=
costs[curr]) and v not in visited:
if done[v] == 0 and G.nodes[v]["Tech"] == 1:
paths1[v] = [v] + paths[curr]
done[v] = 1
cost = dists[curr] + cost_function(G, costs[curr], curr, v)
if cost < dists[v]:
paths[v] = [v] + paths[curr]
dists[v] = cost
delays[v] = delays[curr] + G.edges[v, curr]["Delay"]
costs[v] = costs[curr] + G.edges[v, curr][
"BaseFee"] + costs[curr] * G.edges[v, curr]["FeeRate"]
# prob[v] = pf.edge_prob(G.edges[v,curr]["LastFailure"])*prob[curr]
pq.put((dists[v], v))
# If at any point the sub-path found is not found to be optimal, this is definetely not the destination if using lnd since the sub-path from an intermediary to
# the destination has to be the cheapest path from the intermediary to the destination.
if (curr in path[1:]):
ind = path.index(curr)
if (paths[curr] != path[ind:]):
return []
if curr == adv:
flag1 = 1
if (curr == pre):
# If pre is the source, the path from pre need to not match the path found since, the cost from the source to the second node is computed differently.
# Moreover, the source would not choose the absolute cheapest path since the first hop may not have sufficient forward balance.
# Thus, pre has to be the source if the paths dont match, since the paths would only match if pre is an intermediary.
if paths[pre] != path:
return [pre]
else:
# if the paths do match, pre is just one possible source
sources.append(pre)
flag2 = 1
if flag1 == 1 and flag2 == 1:
# since if pre is in the path from curr, the path from pre has to match the path we had found as it is the cheapest path from pre. This measns that curr
# is a valid second node. So, all neighbors of curr that have not occured in the path are potential sources.
if pre in paths[curr]:
for [v, curr] in G.in_edges(curr):
if v not in paths[curr] and G.nodes[v]["Tech"] == 1:
sources.append(v)
sources = list(set(sources))
return sources