@peerbit/stream-interface 1.0.11 → 2.0.1

package/src/messages.ts

@@ -15,15 +15,23 @@ import {
 	verify,
 	randomBytes,
 	sha256Base64,
-	sha256
+	getPublicKeyFromPeerId
 } from "@peerbit/crypto";
 
+import type { PeerId } from "@libp2p/interface/peer-id";
+
+export const ID_LENGTH = 32;
+
+const WEEK_MS = 7 * 24 * 60 * 60 + 1000;
+
+const SIGNATURES_SIZE_ENCODING = "u8"; // with 7 steps you know everyone in the world?, so u8 *should* suffice
+
 /**
  * The default msgID implementation
  * Child class can override this.
  */
 export const getMsgId = async (msg: Uint8ArrayList | Uint8Array) => {
-	// first bytes is discriminator,
+	// first bytes fis discriminator,
 	// next 32 bytes should be an id
 	//return  Buffer.from(msg.slice(0, 33)).toString('base64');
 
@@ -51,57 +59,107 @@ if ((globalThis as any).Buffer) {
 	};
 }
 
-export const ID_LENGTH = 32;
+const coerceTo = (tos: (string | PublicSignKey | PeerId)[] | Set<string>) => {
+	const toHashes: string[] = [];
+	let i = 0;
 
-const WEEK_MS = 7 * 24 * 60 * 60 + 1000;
+	for (const to of tos) {
+		const hash =
+			to instanceof PublicSignKey
+				? to.hashcode()
+				: typeof to === "string"
+					? to
+					: getPublicKeyFromPeerId(to).hashcode();
 
-@variant(0)
-export class MessageHeader {
-	@field({ type: fixedArray("u8", ID_LENGTH) })
-	private _id: Uint8Array;
+		toHashes[i++] = hash;
+	}
+	return toHashes;
+};
 
-	@field({ type: "u64" })
-	private _timestamp: bigint;
+export abstract class DeliveryMode {}
 
-	@field({ type: "u64" })
-	private _expires: bigint;
+/**
+ * when you just want to deliver at paths, but does not expect acknowledgement
+ */
+@variant(0)
+export class SilentDelivery extends DeliveryMode {
+	@field({ type: vec("string") })
+	to: string[];
 
-	constructor(properties?: { expires?: bigint; id?: Uint8Array }) {
-		this._id = properties?.id || randomBytes(ID_LENGTH);
-		this._expires = properties?.expires || BigInt(+new Date() + WEEK_MS);
-		this._timestamp = BigInt(+new Date());
-	}
+	@field({ type: "u8" })
+	redundancy: number;
 
-	get id() {
-		return this._id;
+	constructor(properties: {
+		to: (string | PublicSignKey | PeerId)[] | Set<string>;
+		redundancy: number;
+	}) {
+		super();
+		this.to = coerceTo(properties.to);
+		this.redundancy = properties.redundancy;
 	}
+}
 
-	get expires() {
-		return this._expires;
-	}
+/**
+ * Deliver and expect acknowledgement
+ */
+@variant(1)
+export class AcknowledgeDelivery extends DeliveryMode {
+	@field({ type: vec("string") })
+	to: string[];
 
-	get timetamp() {
-		return this._timestamp;
+	@field({ type: "u8" })
+	redundancy: number;
+
+	constructor(properties: {
+		to: (string | PublicSignKey | PeerId)[] | Set<string>;
+		redundancy: number;
+	}) {
+		super();
+		this.to = coerceTo(properties.to);
+		this.redundancy = properties.redundancy;
 	}
+}
 
-	equals(other: MessageHeader) {
-		return this._expires === other.expires && equals(this._id, other.id);
+/**
+ * Deliver but with greedy fanout so that we eventually reach our target
+ * Expect acknowledgement
+ */
+@variant(2)
+export class SeekDelivery extends DeliveryMode {
+	@field({ type: option(vec("string")) })
+	to?: string[];
+
+	@field({ type: "u8" })
+	redundancy: number;
+
+	constructor(properties: {
+		to?: (string | PublicSignKey | PeerId)[] | Set<string>;
+		redundancy: number;
+	}) {
+		super();
+		this.to = properties.to ? coerceTo(properties.to) : undefined;
+		this.redundancy = properties.redundancy;
 	}
+}
 
-	verify() {
-		return this.expires >= +new Date();
+@variant(3)
+export class TracedDelivery extends DeliveryMode {
+	@field({ type: vec("string") })
+	trace: string[];
+
+	constructor(trace: string[]) {
+		super();
+		this.trace = trace;
 	}
 }
 
-class PublicKeys {
-	@field({ type: vec(PublicSignKey) })
-	keys: PublicSignKey[];
-	constructor(keys: PublicSignKey[]) {
-		this.keys = keys;
+@variant(4)
+export class AnyWhere extends DeliveryMode {
+	constructor() {
+		super();
 	}
 }
 
-const SIGNATURES_SIZE_ENCODING = "u8"; // with 7 steps you know everyone in the world?, so u8 *should* suffice
 @variant(0)
 export class Signatures {
 	@field({ type: vec(SignatureWithKey, SIGNATURES_SIZE_ENCODING) })
@@ -121,220 +179,202 @@ export class Signatures {
 	get publicKeys(): PublicSignKey[] {
 		return this.signatures.map((x) => x.publicKey);
 	}
+}
+
+abstract class PeerInfo {}
+
+@variant(0)
+export class MultiAddrinfo extends PeerInfo {
+	@field({ type: vec("string") })
+	multiaddrs: string[];
 
-	hashPublicKeys(): Promise<string> {
-		return sha256Base64(serialize(new PublicKeys(this.publicKeys)));
+	constructor(multiaddrs: string[]) {
+		super();
+		this.multiaddrs = multiaddrs;
 	}
 }
 
-const keyMap: Map<string, PublicSignKey> = new Map();
-interface Signed {
-	get signatures(): Signatures;
+@variant(0)
+export class MessageHeader<T extends DeliveryMode = DeliveryMode> {
+	@field({ type: fixedArray("u8", ID_LENGTH) })
+	private _id: Uint8Array;
+
+	@field({ type: "u64" })
+	private _timestamp: bigint;
+
+	@field({ type: "u64" })
+	private _expires: bigint;
+
+	@field({ type: option(PeerInfo) })
+	private _origin?: MultiAddrinfo;
+
+	// Not signed, since we might want to modify it during transit
+	@field({ type: option(DeliveryMode) })
+	mode: T;
+
+	// Not signed, since we might want to modify it during transit
+	@field({ type: option(Signatures) })
+	signatures: Signatures | undefined;
+
+	constructor(properties: {
+		origin?: MultiAddrinfo;
+		expires?: bigint;
+		id?: Uint8Array;
+		mode: T;
+	}) {
+		this._id = properties?.id || randomBytes(ID_LENGTH);
+		this._expires = properties?.expires || BigInt(+new Date() + WEEK_MS);
+		this._timestamp = BigInt(+new Date());
+		this.signatures = new Signatures();
+		this._origin = properties?.origin;
+		this.mode = properties.mode;
+	}
+
+	get id() {
+		return this._id;
+	}
+
+	get expires() {
+		return this._expires;
+	}
+
+	get timetamp() {
+		return this._timestamp;
+	}
+
+	get origin(): MultiAddrinfo | undefined {
+		return this._origin;
+	}
+
+	equals(other: MessageHeader) {
+		return this._expires === other.expires && equals(this._id, other.id);
+	}
+
+	verify() {
+		return this.expires >= +new Date();
+	}
 }
-interface Suffix {
-	getSuffix(iteration: number): Uint8Array | Uint8Array[];
+
+interface WithHeader {
+	header: MessageHeader;
 }
 
+const sign = async <T extends WithHeader>(
+	obj: T,
+	signer: (bytes: Uint8Array) => Promise<SignatureWithKey>
+): Promise<T> => {
+	const mode = obj.header.mode;
+	obj.header.mode = undefined as any;
+	const signatures = obj.header.signatures;
+	obj.header.signatures = undefined;
+	const bytes = serialize(obj);
+	// reassign properties if some other process expects them
+	obj.header.signatures = signatures;
+	obj.header.mode = mode;
+
+	const signature = await signer(bytes);
+	obj.header.signatures = new Signatures(
+		signatures ? [...signatures.signatures, signature] : [signature]
+	);
+	obj.header.mode = mode;
+	return obj;
+};
+
 const verifyMultiSig = async (
-	message: Suffix & Prefixed & Signed,
+	message: WithHeader,
 	expectSignatures: boolean
 ) => {
-	const signatures = message.signatures.signatures;
-	if (signatures.length === 0) {
+	const signatures = message.header.signatures;
+	if (!signatures || signatures.signatures.length === 0) {
 		return !expectSignatures;
 	}
+	const to = message.header.mode;
+	message.header.mode = undefined as any;
+	message.header.signatures = undefined;
+	const bytes = serialize(message);
+	message.header.mode = to;
+	message.header.signatures = signatures;
 
-	await message.createPrefix();
-
-	const dataGenerator = getMultiSigDataToSignHistory(message, 0);
-	let done: boolean | undefined = false;
-	for (const signature of signatures) {
-		if (done) {
-			throw new Error(
-				"Unexpected, the amount of signatures does not match the amount of data verify"
-			);
-		}
-		const data = dataGenerator.next();
-		done = data.done;
-		if (!(await verify(signature, data.value!))) {
+	for (const signature of signatures.signatures) {
+		if (!(await verify(signature, bytes))) {
 			return false;
 		}
 	}
 	return true;
 };
-interface Prefixed {
-	prefix: Uint8Array;
-	createPrefix: () => Promise<Uint8Array>;
-}
-
-const emptySignatures = serialize(new Signatures());
-function* getMultiSigDataToSignHistory(
-	message: Suffix & Prefixed & Signed,
-	from = 0
-): Generator<Uint8Array, undefined, void> {
-	if (from === 0) {
-		yield concatBytes(
-			[message.prefix, emptySignatures],
-			message.prefix.length + emptySignatures.length
-		);
-	}
 
-	for (
-		let i = Math.max(from - 1, 0);
-		i < message.signatures.signatures.length;
-		i++
-	) {
-		const bytes = message.getSuffix(i); // TODO make more performant
-		const concat = [message.prefix];
-		let len = message.prefix.length;
-		if (bytes instanceof Uint8Array) {
-			concat.push(bytes);
-			len += bytes.byteLength;
-		} else {
-			for (const arr of bytes) {
-				concat.push(arr);
-				len += arr.byteLength;
-			}
-		}
-		yield concatBytes(concat, len);
-	}
-	return;
-}
-
-export abstract class Message {
+export abstract class Message<T extends DeliveryMode = DeliveryMode> {
 	static from(bytes: Uint8ArrayList) {
 		if (bytes.get(0) === DATA_VARIANT) {
 			// Data
 			return DataMessage.from(bytes);
+		} else if (bytes.get(0) === ACKNOWLEDGE_VARIANT) {
+			return ACK.from(bytes);
 		} else if (bytes.get(0) === HELLO_VARIANT) {
-			// heartbeat
 			return Hello.from(bytes);
 		} else if (bytes.get(0) === GOODBYE_VARIANT) {
-			// heartbeat
 			return Goodbye.from(bytes);
-		} else if (bytes.get(0) === PING_VARIANT) {
-			return PingPong.from(bytes);
 		}
-
 		throw new Error("Unsupported");
 	}
 
+	abstract get header(): MessageHeader<T>;
+
+	async sign(
+		signer: (bytes: Uint8Array) => Promise<SignatureWithKey>
+	): Promise<this> {
+		return sign(this, signer);
+	}
 	abstract bytes(): Uint8ArrayList | Uint8Array;
-	abstract equals(other: Message): boolean;
-	abstract verify(expectSignatures: boolean): Promise<boolean>;
+	/* abstract equals(other: Message): boolean; */
+	_verified: boolean;
+
+	async verify(expectSignatures: boolean): Promise<boolean> {
+		return this._verified != null
+			? this._verified
+			: (this._verified =
+					(await this.header.verify()) &&
+					(await verifyMultiSig(this, expectSignatures)));
+	}
 }
 
 // I pack data with this message
 const DATA_VARIANT = 0;
+
 @variant(DATA_VARIANT)
-export class DataMessage extends Message {
+export class DataMessage<
+	T extends SilentDelivery | SeekDelivery | AcknowledgeDelivery | AnyWhere =
+		| SilentDelivery
+		| SeekDelivery
+		| AcknowledgeDelivery
+		| AnyWhere
+> extends Message<T> {
 	@field({ type: MessageHeader })
-	private _header: MessageHeader;
-
-	@field({ type: vec("string") })
-	private _to: string[]; // not signed! TODO should we sign this?
+	private _header: MessageHeader<T>;
 
-	@field({ type: Signatures })
-	private _signatures: Signatures;
-
-	@field({ type: Uint8Array })
-	private _data: Uint8Array;
+	@field({ type: option(Uint8Array) })
+	private _data?: Uint8Array;
 
-	constructor(properties: {
-		header?: MessageHeader;
-		to?: string[];
-		data: Uint8Array;
-		signatures?: Signatures;
-	}) {
+	constructor(properties: { header: MessageHeader<T>; data?: Uint8Array }) {
 		super();
 		this._data = properties.data;
-		this._header = properties.header || new MessageHeader();
-		this._to = properties.to || [];
-		this._signatures = properties.signatures || new Signatures();
+		this._header = properties.header;
 	}
 
 	get id(): Uint8Array {
 		return this._header.id;
 	}
 
-	get signatures(): Signatures {
-		return this._signatures;
-	}
-
-	get header(): MessageHeader {
+	get header(): MessageHeader<T> {
 		return this._header;
 	}
 
-	get to(): string[] {
-		return this._to;
-	}
-	set to(to: string[]) {
-		this._serialized = undefined;
-		this._to = to;
-	}
-
-	get sender(): PublicSignKey {
-		return this.signatures.signatures[0].publicKey;
-	}
-
-	get data(): Uint8Array {
+	get data(): Uint8Array | undefined {
 		return this._data;
 	}
 
-	_serialized: Uint8Array | undefined;
-	get serialized(): Uint8Array | undefined {
-		return this.serialized;
-	}
-
-	_prefix: Uint8Array | undefined;
-	get prefix(): Uint8Array {
-		if (!this._prefix) {
-			throw new Error("Prefix not created");
-		}
-		return this._prefix;
-	}
-	async createPrefix(): Promise<Uint8Array> {
-		if (this._prefix) {
-			return this._prefix;
-		}
-		const headerSer = serialize(this._header);
-		const hashBytes = await sha256(this.data);
-		this._prefix = concatBytes(
-			[new Uint8Array([DATA_VARIANT]), headerSer, hashBytes],
-			1 + headerSer.length + hashBytes.length
-		);
-		return this._prefix;
-	}
-
-	getSuffix(iteration: number): Uint8Array {
-		return serialize(
-			new Signatures(this.signatures.signatures.slice(0, iteration + 1))
-		);
-	}
-
-	async sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>) {
-		this._serialized = undefined; // because we will change this object, so the serialized version will not be applicable anymore
-		await this.createPrefix();
-		this.signatures.signatures.push(
-			await sign(
-				getMultiSigDataToSignHistory(
-					this,
-					this.signatures.signatures.length
-				).next().value!
-			)
-		);
-		return this;
-	}
-
-	async verify(expectSignatures: boolean): Promise<boolean> {
-		return this._header.verify() && verifyMultiSig(this, expectSignatures);
-	}
-
 	/** Manually ser/der for performance gains */
 	bytes() {
-		if (this._serialized) {
-			return this._serialized;
-		}
 		return serialize(this);
 	}
 
@@ -344,415 +384,123 @@ export class DataMessage extends Message {
 		}
 		const arr = bytes.subarray();
 		const ret = deserialize(arr, DataMessage);
-		ret._serialized = arr;
 		return ret;
 	}
-
-	equals(other: Message) {
-		if (other instanceof DataMessage) {
-			const a =
-				equals(this.data, other.data) &&
-				equals(this.id, other.id) &&
-				this.to.length === other.to.length;
-			if (!a) {
-				return false;
-			}
-			for (let i = 0; i < this.to.length; i++) {
-				if (this.to[i] !== other.to[i]) {
-					return false;
-				}
-			}
-			return this.signatures.equals(other.signatures);
-		}
-		return false;
-	}
 }
-@variant(0)
-export class NetworkInfo {
-	@field({ type: vec("u32", SIGNATURES_SIZE_ENCODING) })
-	pingLatencies: number[];
 
-	constructor(pingLatencies: number[]) {
-		this.pingLatencies = pingLatencies;
-	}
-}
+const ACKNOWLEDGE_VARIANT = 1;
 
-// I send this too all my peers
-const HELLO_VARIANT = 1;
-@variant(HELLO_VARIANT)
-export class Hello extends Message {
+@variant(ACKNOWLEDGE_VARIANT)
+export class ACK extends Message {
 	@field({ type: MessageHeader })
-	header: MessageHeader;
-
-	@field({ type: vec("string") })
-	multiaddrs: string[];
+	header: MessageHeader<TracedDelivery>;
 
-	@field({ type: option(Uint8Array) })
-	data?: Uint8Array;
-
-	@field({ type: NetworkInfo })
-	networkInfo: NetworkInfo;
+	@field({ type: fixedArray("u8", 32) })
+	messageIdToAcknowledge: Uint8Array;
 
-	@field({ type: Signatures })
-	signatures: Signatures;
+	@field({ type: "u8" })
+	seenCounter: number; // Number of times a peer has received the messageIdToAcknowledge before
 
-	constructor(options?: { multiaddrs?: string[]; data?: Uint8Array }) {
+	constructor(properties: {
+		messageIdToAcknowledge: Uint8Array;
+		seenCounter: number;
+		header: MessageHeader<TracedDelivery>;
+	}) {
 		super();
-		this.header = new MessageHeader();
-		this.data = options?.data;
-		this.multiaddrs =
-			options?.multiaddrs?.filter((x) => !x.includes("/p2p-circuit/")) || []; // don't forward relay addresess (TODO ?)
-		this.signatures = new Signatures();
-		this.networkInfo = new NetworkInfo([]);
+		this.header = properties.header;
+		this.messageIdToAcknowledge = properties.messageIdToAcknowledge;
+		this.seenCounter = Math.min(255, properties.seenCounter);
 	}
 
-	get sender(): PublicSignKey {
-		return this.signatures.signatures[0].publicKey;
+	get id() {
+		return this.header.id;
 	}
 
 	bytes() {
 		return serialize(this);
 	}
-	static from(bytes: Uint8ArrayList): Hello {
-		const result = deserialize(bytes.subarray(), Hello);
-		if (result.signatures.signatures.length === 0) {
-			throw new Error("Missing sender on Hello");
-		}
-		return result;
-	}
-
-	_prefix: Uint8Array | undefined;
-	get prefix(): Uint8Array {
-		if (!this._prefix) {
-			throw new Error("Prefix not created");
-		}
-		return this._prefix;
-	}
-	async createPrefix(): Promise<Uint8Array> {
-		if (this._prefix) {
-			return this._prefix;
-		}
-		const headerSer = serialize(this.header);
-		const hashBytes = this.data ? await sha256(this.data) : new Uint8Array();
-		this._prefix = concatBytes(
-			[new Uint8Array([HELLO_VARIANT]), headerSer, hashBytes],
-			1 + headerSer.length + hashBytes.length
-		);
-		return this._prefix;
-	}
-
-	getSuffix(iteration: number): Uint8Array[] {
-		return [
-			serialize(
-				new NetworkInfo(this.networkInfo.pingLatencies.slice(0, iteration + 1))
-			),
-			serialize(
-				new Signatures(this.signatures.signatures.slice(0, iteration + 1))
-			)
-		];
-	}
-
-	async sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>) {
-		await this.createPrefix();
-		const toSign = getMultiSigDataToSignHistory(
-			this,
-			this.signatures.signatures.length
-		).next().value!;
-		this.signatures.signatures.push(await sign(toSign));
-		return this;
-	}
-
-	async verify(expectSignatures: boolean): Promise<boolean> {
-		return (
-			this.header.verify() &&
-			this.networkInfo.pingLatencies.length ===
-				this.signatures.signatures.length - 1 &&
-			verifyMultiSig(this, expectSignatures)
-		);
-	}
 
-	equals(other: Message) {
-		if (other instanceof Hello) {
-			const dataEquals =
-				(!!this.data && !!other.data && equals(this.data, other.data)) ||
-				!this.data === !other.data;
-			if (!dataEquals) {
-				return false;
-			}
-
-			return (
-				this.header.equals(other.header) &&
-				this.signatures.equals(other.signatures)
-			);
+	static from(bytes: Uint8ArrayList): ACK {
+		const result = deserialize(bytes.subarray(), ACK);
+		if (
+			!result.header.signatures ||
+			result.header.signatures.signatures.length === 0
+		) {
+			throw new Error("Missing sender on ACK");
 		}
-		return false;
+		return result;
 	}
 }
 
-// Me or some my peer disconnected
-const GOODBYE_VARIANT = 2;
-@variant(GOODBYE_VARIANT)
-export class Goodbye extends Message {
+const HELLO_VARIANT = 2;
+
+@variant(HELLO_VARIANT)
+export class Hello extends Message {
 	@field({ type: MessageHeader })
 	header: MessageHeader;
 
-	@field({ type: "bool" })
-	early?: boolean; // is early goodbye, I send this to my peers so when I disconnect, they can relay the message for me
-
-	@field({ type: option(Uint8Array) })
-	data?: Uint8Array; // not signed
-
-	@field({ type: Signatures })
-	signatures: Signatures;
+	@field({ type: vec("string") })
+	joined: string[];
 
-	constructor(properties?: {
-		header?: MessageHeader;
-		data?: Uint8Array;
-		early?: boolean;
-	}) {
-		// disconnected: PeerId | string,
+	constructor(properties: { joined: string[] }) {
 		super();
-		this.header = properties?.header || new MessageHeader();
-		this.data = properties?.data;
-		this.early = properties?.early;
-		this.signatures = new Signatures();
+		this.joined = properties.joined;
 	}
 
-	get sender(): PublicSignKey {
-		return this.signatures.signatures[0]!.publicKey;
+	get id() {
+		return this.header.id;
 	}
 
 	bytes() {
 		return serialize(this);
 	}
-	static from(bytes: Uint8ArrayList): Goodbye {
-		const result = deserialize(bytes.subarray(), Goodbye);
-		if (result.signatures.signatures.length === 0) {
-			throw new Error("Missing sender on Goodbye");
-		}
-		return result;
-	}
-
-	_prefix: Uint8Array | undefined;
-	get prefix(): Uint8Array {
-		if (!this._prefix) {
-			throw new Error("Prefix not created");
-		}
-		return this._prefix;
-	}
-
-	async createPrefix(): Promise<Uint8Array> {
-		if (this._prefix) {
-			return this._prefix;
-		}
-		const headerSer = serialize(this.header);
-		const hashBytes = this.data ? await sha256(this.data) : new Uint8Array();
-		this._prefix = concatBytes(
-			[new Uint8Array([GOODBYE_VARIANT]), headerSer, hashBytes],
-			1 + headerSer.length + 1 + hashBytes.length
-		);
-		return this._prefix;
-	}
-
-	getSuffix(iteration: number): Uint8Array {
-		return serialize(
-			new Signatures(this.signatures.signatures.slice(0, iteration + 1))
-		);
-	}
-
-	async sign(sign: (bytes: Uint8Array) => Promise<SignatureWithKey>) {
-		await this.createPrefix();
-		this.signatures.signatures.push(
-			await sign(
-				getMultiSigDataToSignHistory(
-					this,
-					this.signatures.signatures.length
-				).next().value!
-			)
-		);
-		return this;
-	}
-
-	async verify(expectSignatures: boolean): Promise<boolean> {
-		return this.header.verify() && verifyMultiSig(this, expectSignatures);
-	}
-
-	equals(other: Message) {
-		if (other instanceof Goodbye) {
-			if (this.early !== other.early) {
-				return false;
-			}
-
-			const dataEquals =
-				(!!this.data && !!other.data && equals(this.data, other.data)) ||
-				!this.data === !other.data;
-			if (!dataEquals) {
-				return false;
-			}
-			return (
-				this.header.equals(other.header) &&
-				this.signatures.equals(other.signatures)
-			);
-		}
-		return false;
-	}
-}
-
-const PING_VARIANT = 3;
-
-@variant(PING_VARIANT)
-export abstract class PingPong extends Message {
-	static from(bytes: Uint8ArrayList) {
-		return deserialize(bytes.subarray(), PingPong);
-	}
-
-	bytes(): Uint8ArrayList | Uint8Array {
-		return serialize(this);
-	}
-
-	verify(_expectSignatures: boolean): Promise<boolean> {
-		return Promise.resolve(true);
-	}
-
-	abstract get pingBytes(): Uint8Array;
-}
-
-@variant(0)
-export class Ping extends PingPong {
-	@field({ type: fixedArray("u8", 32) })
-	pingBytes: Uint8Array;
-
-	constructor() {
-		super();
-		this.pingBytes = randomBytes(32);
-	}
-	equals(other: Message) {
-		if (other instanceof Ping) {
-			return equals(this.pingBytes, other.pingBytes);
-		}
-		return false;
-	}
-}
-
-@variant(1)
-export class Pong extends PingPong {
-	@field({ type: fixedArray("u8", 32) })
-	pingBytes: Uint8Array;
-
-	constructor(pingBytes: Uint8Array) {
-		super();
-		this.pingBytes = pingBytes;
-	}
-
-	equals(other: Message) {
-		if (other instanceof Pong) {
-			return equals(this.pingBytes, other.pingBytes);
-		}
-		return false;
-	}
-}
-
-@variant(0)
-export class Connections {
-	@field({ type: vec(fixedArray("string", 2)) })
-	connections: [string, string][];
-
-	constructor(connections: [string, string][]) {
-		this.connections = connections;
-	}
 
-	equals(other: Connections) {
-		if (this.connections.length !== other.connections.length) {
-			return false;
-		}
-		for (let i = 0; i < this.connections.length; i++) {
-			if (this.connections[i].length !== other.connections[i].length) {
-				return false;
-			}
-			const a1 = this.connections[i][0];
-			const a2 = this.connections[i][1];
-			const b1 = other.connections[i][0];
-			const b2 = other.connections[i][1];
-
-			if (a1 === b1 && a2 === b2) {
-				continue;
-			}
-			if (a1 === b2 && a2 === b1) {
-				continue;
-			}
-			return false;
+	static from(bytes: Uint8ArrayList): Hello {
+		const result = deserialize(bytes.subarray(), Hello);
+		if (
+			!result.header.signatures ||
+			result.header.signatures.signatures.length === 0
+		) {
+			throw new Error("Missing sender on Hello");
 		}
-		return true;
+		return result;
 	}
 }
 
-// Share connections
-/* const NETWORK_INFO_VARIANT = 3;
-@variant(NETWORK_INFO_VARIANT)
-export class NetworkInfo extends Message {
+const GOODBYE_VARIANT = 3;
 
+@variant(GOODBYE_VARIANT)
+export class Goodbye extends Message {
 	@field({ type: MessageHeader })
-	header: MessageHeader;
-
-	@field({ type: Connections })
-	connections: Connections;
-
-
-	@field({ type: Signatures })
-	signatures: Signatures
+	header: MessageHeader<SilentDelivery>;
 
+	@field({ type: vec("string") })
+	leaving: string[];
 
-	constructor(connections: [string, string][]) {
+	constructor(properties: {
+		leaving: string[];
+		header: MessageHeader<SilentDelivery>;
+	}) {
 		super();
-		this.header = new MessageHeader();
-		this.connections = new Connections(connections);
-		this.signatures = new Signatures()
+		this.header = properties.header;
+		this.leaving = properties.leaving;
 	}
-
-	getDataToSign(): Uint8Array {
-		return this.serialize()
-	}
-
-	_prefix: Uint8Array | undefined
-	get prefix(): Uint8Array {
-		if (this._prefix)
-			return this._prefix
-		const header = serialize(this.header);
-		const connections = serialize(this.connections);
-		this._prefix = concatBytes([new Uint8Array([NETWORK_INFO_VARIANT]), header, connections], 1 + header.length + connections.length);
-		return this._prefix;
-	}
-
-	sign(sign: (bytes: Uint8Array) => SignatureWithKey) {
-		this.signatures.signatures.push(sign(getMultiSigDataToSignHistory(this, this.signatures.signatures.length).next().value!));
-		return this;
-	}
-
-	verify(): boolean {
-		return this.header.verify() && verifyMultiSig(this)
+	get id() {
+		return this.header.id;
 	}
 
-
-	serialize() {
-		return serialize(this)
-	}
-	static from(bytes: Uint8ArrayList): NetworkInfo {
-		return deserialize(bytes.subarray(), NetworkInfo)
+	bytes() {
+		return serialize(this);
 	}
 
-	equals(other: Message) {
-		if (other instanceof NetworkInfo) {
-			if (!equals(this.header.id, other.header.id) || !this.header.equals(other.header)) { // TODO fix uneccessary copy
-				return false;
-			}
-
-			if (!this.connections.equals(other.connections)) {
-				return false;
-			}
-			return this.signatures.equals(other.signatures)
+	static from(bytes: Uint8ArrayList): Goodbye {
+		const result = deserialize(bytes.subarray(), Goodbye);
+		if (
+			!result.header.signatures ||
+			result.header.signatures.signatures.length === 0
+		) {
+			throw new Error("Missing sender on Goodbye");
 		}
-		return false;
+		return result;
 	}
 }
-
- */