Fixing vertex dependencies issue (#247)

Co-authored-by: droak <[email protected]>

packages/node/src/handlers.ts

@@ -32,7 +32,7 @@ export async function topologyMessagesHandler(
 
 	switch (message.type) {
 		case NetworkPb.Message_MessageType.UPDATE:
-			updateHandler(node, message.data);
+			updateHandler(node, message.data, message.sender);
 			break;
 		case NetworkPb.Message_MessageType.SYNC:
 			if (!stream) {
@@ -71,15 +71,19 @@ export async function topologyMessagesHandler(
   data: { id: string, operations: {nonce: string, fn: string, args: string[] }[] }
   operations array doesn't contain the full remote operations array
 */
-function updateHandler(node: TopologyNode, data: Uint8Array) {
+async function updateHandler(
+	node: TopologyNode,
+	data: Uint8Array,
+	sender: string,
+) {
 	const updateMessage = NetworkPb.Update.decode(data);
 	const object = node.objectStore.get(updateMessage.objectId);
 	if (!object) {
 		console.error("topology::node::updateHandler", "Object not found");
 		return false;
 	}
 
-	object.merge(
+	const [merged, _] = object.merge(
 		updateMessage.vertices.map((v) => {
 			return {
 				hash: v.hash,
@@ -92,6 +96,11 @@ function updateHandler(node: TopologyNode, data: Uint8Array) {
 			};
 		}),
 	);
+
+	if (!merged) {
+		await node.syncObject(updateMessage.objectId, sender);
+	}
+
 	node.objectStore.put(object.id, object);
 
 	return true;

packages/object/src/hashgraph/index.ts

@@ -118,18 +118,20 @@ export class HashGraph {
 		return vertex;
 	}
 
+	/* Add a vertex to the hashgraph with the given operation and dependencies.
+	 * If the vertex already exists, return the hash of the existing vertex.
+	 * Throws an error if any of the dependencies are not present in the hashgraph.
+	 */
 	addVertex(operation: Operation, deps: Hash[], nodeId: string): Hash {
 		const hash = computeHash(nodeId, operation, deps);
 		if (this.vertices.has(hash)) {
 			return hash; // Vertex already exists
 		}
 
-		// Temporary fix: don't add the vertex if the dependencies are not present in the local HG.
 		if (
 			!deps.every((dep) => this.forwardEdges.has(dep) || this.vertices.has(dep))
 		) {
-			console.error("Invalid dependency detected.");
-			return "";
+			throw new Error("Invalid dependency detected.");
 		}
 
 		const vertex: Vertex = {

packages/object/src/index.ts

@@ -97,25 +97,36 @@ export class TopologyObject implements ITopologyObject {
 		this._notify("callFn", [serializedVertex]);
 	}
 
-	merge(vertices: Vertex[]) {
+	/* Merges the vertices into the hashgraph
+	 * Returns a tuple with a boolean indicating if there were
+	 * missing vertices and an array with the missing vertices
+	 */
+	merge(vertices: Vertex[]): [merged: boolean, missing: string[]] {
+		const missing = [];
 		for (const vertex of vertices) {
 			// Check to avoid manually crafted `undefined` operations
 			if (!vertex.operation) {
 				continue;
 			}
 
-			this.hashGraph.addVertex(
-				vertex.operation,
-				vertex.dependencies,
-				vertex.nodeId,
-			);
+			try {
+				this.hashGraph.addVertex(
+					vertex.operation,
+					vertex.dependencies,
+					vertex.nodeId,
+				);
+			} catch (e) {
+				missing.push(vertex.hash);
+			}
 		}
 
 		const operations = this.hashGraph.linearizeOperations();
 		this.vertices = this.hashGraph.getAllVertices();
 
 		(this.cro as CRO).mergeCallback(operations);
 		this._notify("merge", this.vertices);
+
+		return [missing.length === 0, missing];
 	}
 
 	subscribe(callback: TopologyObjectCallback) {