refactor for new pb structure

packages/node/src/handlers.ts

@@ -1,6 +1,6 @@
 import type { Stream } from "@libp2p/interface";
 import { Message, Message_MessageType } from "@topology-foundation/network";
-import { TopologyObject } from "@topology-foundation/object";
+import { TopologyObjectBase } from "@topology-foundation/object";
 import * as lp from "it-length-prefixed";
 import type { TopologyNode } from "./index.js";
 
@@ -60,15 +60,14 @@ export async function topologyMessagesHandler(
   operations array doesn't contain the full remote operations array
 */
 function updateHandler(node: TopologyNode, data: Uint8Array) {
-	const object_operations = TopologyObject.decode(data);
+	const object_operations = TopologyObjectBase.decode(data);
 	let object = node.objectStore.get(object_operations.id);
 	if (!object) {
-		object = TopologyObject.create({
+		object = TopologyObjectBase.create({
 			id: object_operations.id,
-			operations: [],
 		});
 	}
-	object.operations.push(...object_operations.operations);
+	object.vertices.push(...object_operations.vertices);
 	node.objectStore.put(object.id, object);
 }
 
@@ -103,22 +102,23 @@ function syncHandler(
 function syncAcceptHandler(node: TopologyNode, data: Uint8Array) {
 	// don't blindly accept, validate the operations
 	// might have have appeared in the meantime
-	const object_operations = TopologyObject.decode(data);
-	let object = node.objectStore.get(object_operations.id);
+	const object_operations = TopologyObjectBase.decode(data);
+	let object: TopologyObjectBase | undefined = node.objectStore.get(
+		object_operations.id,
+	);
 	if (!object) {
-		object = TopologyObject.create({
+		object = TopologyObjectBase.create({
 			id: object_operations.id,
-			operations: [],
 		});
 	}
 
-	object_operations.operations.filter((op) => {
-		if (object?.operations.find((op2) => op.nonce === op2.nonce)) {
+	object_operations.vertices.filter((v1) => {
+		if (object?.vertices.find((v2) => v1.hash === v2.hash)) {
 			return false;
 		}
 		return true;
 	});
-	object.operations.push(...object_operations.operations);
+	object.vertices.push(...object_operations.vertices);
 	node.objectStore.put(object.id, object);
 
 	// TODO missing sending back the diff

packages/node/src/index.ts

@@ -6,7 +6,11 @@ import {
 	TopologyNetworkNode,
 	type TopologyNetworkNodeConfig,
 } from "@topology-foundation/network";
-import { TopologyObject, newTopologyObject } from "@topology-foundation/object";
+import {
+	type CRO,
+	TopologyObjectBase,
+	newTopologyObject,
+} from "@topology-foundation/object";
 import { topologyMessagesHandler } from "./handlers.js";
 import { OPERATIONS, executeObjectOperation } from "./operations.js";
 import { TopologyObjectStore } from "./store/index.js";
@@ -71,17 +75,18 @@ export class TopologyNode {
 		this.networkNode.sendMessage(peerId, [protocol], message);
 	}
 
-	async createObject(id?: string, path?: string, abi?: string) {
+	async createObject<T>(cro: CRO<T>, id?: string, path?: string, abi?: string) {
 		const object = await newTopologyObject(
 			this.networkNode.peerId,
+			cro,
 			path,
 			id,
 			abi,
 		);
 		executeObjectOperation(
 			this,
 			OPERATIONS.CREATE,
-			TopologyObject.encode(object).finish(),
+			TopologyObjectBase.encode(object).finish(),
 		);
 		this.networkNode.addGroupMessageHandler(object.id, async (e) =>
 			topologyMessagesHandler(this, undefined, e.detail.msg.data),
@@ -90,31 +95,25 @@ export class TopologyNode {
 	}
 
 	updateObject(id: string, operations: { fn: string; args: string[] }[]) {
-		const object = TopologyObject.create({
+		// TODO: needs refactor for working with hash graph
+		const object = TopologyObjectBase.create({
 			id,
-			operations: operations.map((op) => {
-				return {
-					nonce: generateNonce(op.fn, op.args),
-					fn: op.fn,
-					args: op.args,
-				};
-			}),
 		});
 		executeObjectOperation(
 			this,
 			OPERATIONS.UPDATE,
-			TopologyObject.encode(object).finish(),
+			TopologyObjectBase.encode(object).finish(),
 		);
 	}
 
 	async subscribeObject(id: string, fetch?: boolean, peerId?: string) {
-		const object = TopologyObject.create({
+		const object = TopologyObjectBase.create({
 			id,
 		});
 		executeObjectOperation(
 			this,
 			OPERATIONS.SUBSCRIBE,
-			TopologyObject.encode(object).finish(),
+			TopologyObjectBase.encode(object).finish(),
 			fetch,
 			peerId,
 		);
@@ -125,13 +124,13 @@ export class TopologyNode {
 	}
 
 	unsubscribeObject(id: string, purge?: boolean) {
-		const object = TopologyObject.create({
+		const object = TopologyObjectBase.create({
 			id,
 		});
 		executeObjectOperation(
 			this,
 			OPERATIONS.UNSUBSCRIBE,
-			TopologyObject.encode(object).finish(),
+			TopologyObjectBase.encode(object).finish(),
 			purge,
 		);
 	}
@@ -141,14 +140,13 @@ export class TopologyNode {
 		operations: { nonce: string; fn: string; args: string[] }[],
 		peerId?: string,
 	) {
-		const object = TopologyObject.create({
+		const object = TopologyObjectBase.create({
 			id,
-			operations,
 		});
 		executeObjectOperation(
 			this,
 			OPERATIONS.SYNC,
-			TopologyObject.encode(object).finish(),
+			TopologyObjectBase.encode(object).finish(),
 			peerId,
 		);
 	}

packages/node/src/operations.ts

@@ -67,13 +67,12 @@ function updateObject(node: TopologyNode, data: Uint8Array) {
 	if (!object) {
 		object = TopologyObjectBase.create({
 			id: object_operations.id,
-			operations: [],
 		});
 	}
 
-	for (const op of object_operations.operations) {
-		if (object.operations.some((o) => o.nonce === op.nonce)) continue;
-		object.operations.push(op);
+	for (const v1 of object_operations.vertices) {
+		if (object.vertices.some((v2) => v1.hash === v2.hash)) continue;
+		object.vertices.push(v1);
 	}
 	node.objectStore.put(object.id, object);
 

packages/node/src/store/index.ts

@@ -1,25 +1,25 @@
-import type { TopologyObject } from "@topology-foundation/object";
+import type { TopologyObjectBase } from "@topology-foundation/object";
 
 export type TopologyObjectStoreCallback = (
 	objectId: string,
-	object: TopologyObject,
+	object: TopologyObjectBase,
 ) => void;
 
 export class TopologyObjectStore {
 	// TODO: should be abstracted in handling multiple types of storage
-	private _store: Map<string, TopologyObject>;
+	private _store: Map<string, TopologyObjectBase>;
 	private _subscriptions: Map<string, TopologyObjectStoreCallback[]>;
 
 	constructor() {
-		this._store = new Map<string, TopologyObject>();
+		this._store = new Map<string, TopologyObjectBase>();
 		this._subscriptions = new Map<string, TopologyObjectStoreCallback[]>();
 	}
 
-	get(objectId: string): TopologyObject | undefined {
+	get(objectId: string): TopologyObjectBase | undefined {
 		return this._store.get(objectId);
 	}
 
-	put(objectId: string, object: TopologyObject) {
+	put(objectId: string, object: TopologyObjectBase) {
 		this._store.set(objectId, object);
 		this._notifySubscribers(objectId, object);
 	}
@@ -31,7 +31,10 @@ export class TopologyObjectStore {
 		this._subscriptions.get(objectId)?.push(callback);
 	}
 
-	private _notifySubscribers(objectId: string, object: TopologyObject): void {
+	private _notifySubscribers(
+		objectId: string,
+		object: TopologyObjectBase,
+	): void {
 		const callbacks = this._subscriptions.get(objectId);
 		if (callbacks) {
 			for (const callback of callbacks) {

packages/object/tests/hashgraph.test.ts

@@ -7,30 +7,22 @@ import {
 } from "../src/index.js";
 
 describe("HashGraph for AddWinSet tests", () => {
-	let cro1: AddWinsSet<number>;
 	let obj1: TopologyObject<number>;
 	let obj2: TopologyObject<number>;
 	let obj3: TopologyObject<number>;
 
 	beforeEach(async () => {
-		cro1 = new AddWinsSet<number>();
-		const cro2 = new AddWinsSet<number>();
-		const cro3 = new AddWinsSet<number>();
-
-		obj1 = await newTopologyObject("peer1", cro1);
-		obj2 = await newTopologyObject("peer2", cro2);
-		obj3 = await newTopologyObject("peer3", cro3);
+		obj1 = await newTopologyObject("peer1", new AddWinsSet<number>());
+		obj2 = await newTopologyObject("peer2", new AddWinsSet<number>());
+		obj3 = await newTopologyObject("peer3", new AddWinsSet<number>());
 	});
 
 	test("Test: Add Two Vertices", () => {
 		/*
       V1:NOP <- V2:ADD(1) <- V2:REMOVE(1)
     */
-		// callFn(obj1, "add", ["1"]);
-		//cro1.add(1);
-		cro1 = obj1.cro as AddWinsSet<number>;
+		const cro1 = obj1.cro as AddWinsSet<number>;
 		cro1.add(1);
-
 		console.log(obj1);
 	});
 });