Using callback

packages/node/src/handlers.ts

@@ -78,39 +78,57 @@ function updateHandler(node: TopologyNode, data: Uint8Array) {
 		console.error("topology::node::updateHandler", "Object not found");
 		return false;
 	}
-	const _merge = () => {
-		object.merge(
-			updateMessage.vertices.map((v) => {
-				return {
-					hash: v.hash,
-					nodeId: v.nodeId,
-					operation: {
-						type: v.operation?.type ?? "",
-						value: v.operation?.value,
-					},
-					dependencies: v.dependencies,
-				};
-			}),
-		);
-	};
-
-	try {
-		_merge();
-	} catch (err) {
-		if ((err as Error).name === "InvalidDependencyError") {
-			if (updateMessage.vertices.length === 0) return false;
-			const peerId = updateMessage.vertices[0].nodeId;
-			node.syncObject(object.id, peerId);
-			_merge();
-		} else {
-			console.error(
-				"topology::node::updateHandler",
-				"Error merging vertices",
-				err,
-			);
-			return false;
+	object.merge(
+		updateMessage.vertices.map((v) => {
+			return {
+				hash: v.hash,
+				nodeId: v.nodeId,
+				operation: {
+					type: v.operation?.type ?? "",
+					value: v.operation?.value,
+				},
+				dependencies: v.dependencies,
+			};
+		}),
+		async (croId: string, nodeId: string) => {
+			await node.syncObject(croId, nodeId);
 		}
-	}
+	);
+
+	// const _merge = () => {
+	// 	object.merge(
+	// 		updateMessage.vertices.map((v) => {
+	// 			return {
+	// 				hash: v.hash,
+	// 				nodeId: v.nodeId,
+	// 				operation: {
+	// 					type: v.operation?.type ?? "",
+	// 					value: v.operation?.value,
+	// 				},
+	// 				dependencies: v.dependencies,
+	// 			};
+	// 		}),
+	// 	);
+	// };
+
+	// try {
+	// 	_merge();
+	// } catch (err) {
+	// 	if ((err as Error).name === "InvalidDependencyError") {
+	// 		if (updateMessage.vertices.length === 0) return false;
+	// 		const peerId = updateMessage.vertices[0].nodeId;
+	// 		node.syncObject(object.id, peerId).then(() => {
+	// 			_merge();
+	// 		});
+	// 	} else {
+	// 		console.error(
+	// 			"topology::node::updateHandler",
+	// 			"Error merging vertices",
+	// 			err,
+	// 		);
+	// 		return false;
+	// 	}
+	// }
 
 	node.objectStore.put(object.id, object);
 
@@ -193,21 +211,9 @@ function syncAcceptHandler(
 	});
 
 	if (vertices.length !== 0) {
-		try {
-			object.merge(vertices);
-		} catch (err) {
-			if ((err as Error).name === "InvalidDependencyError") {
-				node.syncObject(object.id, sender);
-				object.merge(vertices);
-			} else {
-				console.error(
-					"topology::node::syncAcceptHandler",
-					"Error merging vertices",
-					err,
-				);
-				return;
-			}
-		}
+		object.merge(vertices, async (croId: string, nodeId: string) => {
+			await node.syncObject(croId, nodeId);
+		});
 		node.objectStore.put(object.id, object);
 	}
 

packages/object/src/hashgraph/index.ts

@@ -118,7 +118,25 @@ export class HashGraph {
 		return vertex;
 	}
 
-	addVertex(operation: Operation, deps: Hash[], nodeId: string): Hash {
+	checkVertexDependency(operation: Operation, deps: Hash[], nodeId: string): boolean {
+		const hash = computeHash(nodeId, operation, deps);
+		if (this.vertices.has(hash)) {
+			return true;
+		}
+
+		// 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.log("THE DEPENDENCIES ARE NOT OKAY");
+			return false;
+		}
+
+		return true;
+
+	}
+
+	addVertex(operation: Operation, deps: Hash[], nodeId: string): Hash | boolean {
 		const hash = computeHash(nodeId, operation, deps);
 		if (this.vertices.has(hash)) {
 			return hash; // Vertex already exists

packages/object/src/index.ts

@@ -97,12 +97,24 @@ export class TopologyObject implements ITopologyObject {
 		this._notify("callFn", [serializedVertex]);
 	}
 
-	merge(vertices: Vertex[]) {
+	async merge(
+		vertices: Vertex[],
+		synchronizeVertices: (croId: string, nodeId: string) => void,
+	) {
 		for (const vertex of vertices) {
 			// Check to avoid manually crafted `undefined` operations
 			if (!vertex.operation) {
 				continue;
 			}
+			if (
+				this.hashGraph.checkVertexDependency(
+					vertex.operation,
+					vertex.dependencies,
+					vertex.nodeId,
+				)
+			) {
+				await synchronizeVertices(this.id, vertex.nodeId);
+			}
 
 			this.hashGraph.addVertex(
 				vertex.operation,