add throw on add vertex, change return type to detect if it was merge…

…d/missing, do sync on missing deps

packages/node/src/handlers.ts

@@ -74,7 +74,7 @@ export async function topologyMessagesHandler(
 async function updateHandler(
 	node: TopologyNode,
 	data: Uint8Array,
-	senderPeerId: string,
+	sender: string,
 ) {
 	const updateMessage = NetworkPb.Update.decode(data);
 	const object = node.objectStore.get(updateMessage.objectId);
@@ -83,9 +83,7 @@ async function updateHandler(
 		return false;
 	}
 
-	await node.syncObject(updateMessage.objectId, senderPeerId);
-
-	object.merge(
+	const [merged, _] = object.merge(
 		updateMessage.vertices.map((v) => {
 			return {
 				hash: v.hash,
@@ -99,6 +97,10 @@ async function updateHandler(
 		}),
 	);
 
+	if (!merged) {
+		await node.syncObject(updateMessage.objectId, sender);
+	}
+
 	node.objectStore.put(object.id, object);
 
 	return true;
@@ -180,7 +182,6 @@ async function syncAcceptHandler(
 	});
 
 	if (vertices.length !== 0) {
-		await node.syncObject(object.id, sender);
 		object.merge(vertices);
 		node.objectStore.put(object.id, object);
 	}

packages/object/src/hashgraph/index.ts

@@ -118,6 +118,10 @@ 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)) {
@@ -128,8 +132,7 @@ export class HashGraph {
 		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,37 @@ 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) {