@peerbit/stream-interface 1.0.10 → 2.0.0

package/lib/esm/messages.js

@@ -7,16 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var DataMessage_1, Hello_1, Goodbye_1, PingPong_1, Ping_1, Pong_1;
+var DataMessage_1, ACK_1, Hello_1, Goodbye_1;
 import { variant, vec, field, serialize, deserialize, fixedArray, option } from "@dao-xyz/borsh";
 import { equals } from "uint8arrays";
-import { PublicSignKey, SignatureWithKey, verify, randomBytes, sha256Base64, sha256 } from "@peerbit/crypto";
+import { PublicSignKey, SignatureWithKey, verify, randomBytes, sha256Base64, getPublicKeyFromPeerId } from "@peerbit/crypto";
+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) => {
-    // first bytes is discriminator,
+    // first bytes fis discriminator,
     // next 32 bytes should be an id
     //return  Buffer.from(msg.slice(0, 33)).toString('base64');
     return sha256Base64(msg.subarray(0, 33)); // base64EncArr(msg, 0, ID_LENGTH + 1);
@@ -42,16 +45,179 @@ else {
         return output;
     };
 }
-export const ID_LENGTH = 32;
-const WEEK_MS = 7 * 24 * 60 * 60 + 1000;
+const coerceTo = (tos) => {
+    const toHashes = [];
+    let i = 0;
+    for (const to of tos) {
+        const hash = to instanceof PublicSignKey
+            ? to.hashcode()
+            : typeof to === "string"
+                ? to
+                : getPublicKeyFromPeerId(to).hashcode();
+        toHashes[i++] = hash;
+    }
+    return toHashes;
+};
+export class DeliveryMode {
+}
+/**
+ * when you just want to deliver at paths, but does not expect acknowledgement
+ */
+let SilentDelivery = class SilentDelivery extends DeliveryMode {
+    to;
+    redundancy;
+    constructor(properties) {
+        super();
+        this.to = coerceTo(properties.to);
+        this.redundancy = properties.redundancy;
+    }
+};
+__decorate([
+    field({ type: vec("string") }),
+    __metadata("design:type", Array)
+], SilentDelivery.prototype, "to", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], SilentDelivery.prototype, "redundancy", void 0);
+SilentDelivery = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], SilentDelivery);
+export { SilentDelivery };
+/**
+ * Deliver and expect acknowledgement
+ */
+let AcknowledgeDelivery = class AcknowledgeDelivery extends DeliveryMode {
+    to;
+    redundancy;
+    constructor(properties) {
+        super();
+        this.to = coerceTo(properties.to);
+        this.redundancy = properties.redundancy;
+    }
+};
+__decorate([
+    field({ type: vec("string") }),
+    __metadata("design:type", Array)
+], AcknowledgeDelivery.prototype, "to", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], AcknowledgeDelivery.prototype, "redundancy", void 0);
+AcknowledgeDelivery = __decorate([
+    variant(1),
+    __metadata("design:paramtypes", [Object])
+], AcknowledgeDelivery);
+export { AcknowledgeDelivery };
+/**
+ * Deliver but with greedy fanout so that we eventually reach our target
+ * Expect acknowledgement
+ */
+let SeekDelivery = class SeekDelivery extends DeliveryMode {
+    to;
+    redundancy;
+    constructor(properties) {
+        super();
+        this.to = properties.to ? coerceTo(properties.to) : undefined;
+        this.redundancy = properties.redundancy;
+    }
+};
+__decorate([
+    field({ type: option(vec("string")) }),
+    __metadata("design:type", Array)
+], SeekDelivery.prototype, "to", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], SeekDelivery.prototype, "redundancy", void 0);
+SeekDelivery = __decorate([
+    variant(2),
+    __metadata("design:paramtypes", [Object])
+], SeekDelivery);
+export { SeekDelivery };
+let TracedDelivery = class TracedDelivery extends DeliveryMode {
+    trace;
+    constructor(trace) {
+        super();
+        this.trace = trace;
+    }
+};
+__decorate([
+    field({ type: vec("string") }),
+    __metadata("design:type", Array)
+], TracedDelivery.prototype, "trace", void 0);
+TracedDelivery = __decorate([
+    variant(3),
+    __metadata("design:paramtypes", [Array])
+], TracedDelivery);
+export { TracedDelivery };
+let AnyWhere = class AnyWhere extends DeliveryMode {
+    constructor() {
+        super();
+    }
+};
+AnyWhere = __decorate([
+    variant(4),
+    __metadata("design:paramtypes", [])
+], AnyWhere);
+export { AnyWhere };
+let Signatures = class Signatures {
+    signatures;
+    constructor(signatures = []) {
+        this.signatures = signatures;
+    }
+    equals(other) {
+        return (this.signatures.length === other.signatures.length &&
+            this.signatures.every((value, i) => other.signatures[i].equals(value)));
+    }
+    get publicKeys() {
+        return this.signatures.map((x) => x.publicKey);
+    }
+};
+__decorate([
+    field({ type: vec(SignatureWithKey, SIGNATURES_SIZE_ENCODING) }),
+    __metadata("design:type", Array)
+], Signatures.prototype, "signatures", void 0);
+Signatures = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Array])
+], Signatures);
+export { Signatures };
+class PeerInfo {
+}
+let MultiAddrinfo = class MultiAddrinfo extends PeerInfo {
+    multiaddrs;
+    constructor(multiaddrs) {
+        super();
+        this.multiaddrs = multiaddrs;
+    }
+};
+__decorate([
+    field({ type: vec("string") }),
+    __metadata("design:type", Array)
+], MultiAddrinfo.prototype, "multiaddrs", void 0);
+MultiAddrinfo = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Array])
+], MultiAddrinfo);
+export { MultiAddrinfo };
 let MessageHeader = class MessageHeader {
     _id;
     _timestamp;
     _expires;
+    _origin;
+    // Not signed, since we might want to modify it during transit
+    mode;
+    // Not signed, since we might want to modify it during transit
+    signatures;
     constructor(properties) {
         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;
@@ -62,6 +228,9 @@ let MessageHeader = class MessageHeader {
     get timetamp() {
         return this._timestamp;
     }
+    get origin() {
+        return this._origin;
+    }
     equals(other) {
         return this._expires === other.expires && equals(this._id, other.id);
     }
@@ -81,184 +250,106 @@ __decorate([
     field({ type: "u64" }),
     __metadata("design:type", BigInt)
 ], MessageHeader.prototype, "_expires", void 0);
+__decorate([
+    field({ type: option(PeerInfo) }),
+    __metadata("design:type", MultiAddrinfo)
+], MessageHeader.prototype, "_origin", void 0);
+__decorate([
+    field({ type: option(DeliveryMode) }),
+    __metadata("design:type", Object)
+], MessageHeader.prototype, "mode", void 0);
+__decorate([
+    field({ type: option(Signatures) }),
+    __metadata("design:type", Object)
+], MessageHeader.prototype, "signatures", void 0);
 MessageHeader = __decorate([
     variant(0),
     __metadata("design:paramtypes", [Object])
 ], MessageHeader);
 export { MessageHeader };
-class PublicKeys {
-    keys;
-    constructor(keys) {
-        this.keys = keys;
-    }
-}
-__decorate([
-    field({ type: vec(PublicSignKey) }),
-    __metadata("design:type", Array)
-], PublicKeys.prototype, "keys", void 0);
-const SIGNATURES_SIZE_ENCODING = "u8"; // with 7 steps you know everyone in the world?, so u8 *should* suffice
-let Signatures = class Signatures {
-    signatures;
-    constructor(signatures = []) {
-        this.signatures = signatures;
-    }
-    equals(other) {
-        return (this.signatures.length === other.signatures.length &&
-            this.signatures.every((value, i) => other.signatures[i].equals(value)));
-    }
-    get publicKeys() {
-        return this.signatures.map((x) => x.publicKey);
-    }
-    hashPublicKeys() {
-        return sha256Base64(serialize(new PublicKeys(this.publicKeys)));
-    }
+const sign = async (obj, signer) => {
+    const mode = obj.header.mode;
+    obj.header.mode = undefined;
+    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;
 };
-__decorate([
-    field({ type: vec(SignatureWithKey, SIGNATURES_SIZE_ENCODING) }),
-    __metadata("design:type", Array)
-], Signatures.prototype, "signatures", void 0);
-Signatures = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Array])
-], Signatures);
-export { Signatures };
-const keyMap = new Map();
 const verifyMultiSig = async (message, expectSignatures) => {
-    const signatures = message.signatures.signatures;
-    if (signatures.length === 0) {
+    const signatures = message.header.signatures;
+    if (!signatures || signatures.signatures.length === 0) {
         return !expectSignatures;
     }
-    await message.createPrefix();
-    const dataGenerator = getMultiSigDataToSignHistory(message, 0);
-    let done = 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))) {
+    const to = message.header.mode;
+    message.header.mode = undefined;
+    message.header.signatures = undefined;
+    const bytes = serialize(message);
+    message.header.mode = to;
+    message.header.signatures = signatures;
+    for (const signature of signatures.signatures) {
+        if (!(await verify(signature, bytes))) {
             return false;
         }
     }
     return true;
 };
-const emptySignatures = serialize(new Signatures());
-function* getMultiSigDataToSignHistory(message, from = 0) {
-    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 class Message {
     static from(bytes) {
         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");
     }
+    async sign(signer) {
+        return sign(this, signer);
+    }
+    /* abstract equals(other: Message): boolean; */
+    _verified;
+    async verify(expectSignatures) {
+        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;
 let DataMessage = DataMessage_1 = class DataMessage extends Message {
     _header;
-    _to; // not signed! TODO should we sign this?
-    _signatures;
     _data;
     constructor(properties) {
         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() {
         return this._header.id;
     }
-    get signatures() {
-        return this._signatures;
-    }
     get header() {
         return this._header;
     }
-    get to() {
-        return this._to;
-    }
-    set to(to) {
-        this._serialized = undefined;
-        this._to = to;
-    }
-    get sender() {
-        return this.signatures.signatures[0].publicKey;
-    }
     get data() {
         return this._data;
     }
-    _serialized;
-    get serialized() {
-        return this.serialized;
-    }
-    _prefix;
-    get prefix() {
-        if (!this._prefix) {
-            throw new Error("Prefix not created");
-        }
-        return this._prefix;
-    }
-    async createPrefix() {
-        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) {
-        return serialize(new Signatures(this.signatures.signatures.slice(0, iteration + 1)));
-    }
-    async sign(sign) {
-        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) {
-        return this._header.verify() && verifyMultiSig(this, expectSignatures);
-    }
     /** Manually ser/der for performance gains */
     bytes() {
-        if (this._serialized) {
-            return this._serialized;
-        }
         return serialize(this);
     }
     static from(bytes) {
@@ -267,41 +358,15 @@ let DataMessage = DataMessage_1 = class DataMessage extends Message {
         }
         const arr = bytes.subarray();
         const ret = deserialize(arr, DataMessage_1);
-        ret._serialized = arr;
         return ret;
     }
-    equals(other) {
-        if (other instanceof DataMessage_1) {
-            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;
-    }
 };
 __decorate([
     field({ type: MessageHeader }),
     __metadata("design:type", MessageHeader)
 ], DataMessage.prototype, "_header", void 0);
 __decorate([
-    field({ type: vec("string") }),
-    __metadata("design:type", Array)
-], DataMessage.prototype, "_to", void 0);
-__decorate([
-    field({ type: Signatures }),
-    __metadata("design:type", Signatures)
-], DataMessage.prototype, "_signatures", void 0);
-__decorate([
-    field({ type: Uint8Array }),
+    field({ type: option(Uint8Array) }),
     __metadata("design:type", Uint8Array)
 ], DataMessage.prototype, "_data", void 0);
 DataMessage = DataMessage_1 = __decorate([
@@ -309,97 +374,71 @@ DataMessage = DataMessage_1 = __decorate([
     __metadata("design:paramtypes", [Object])
 ], DataMessage);
 export { DataMessage };
-let NetworkInfo = class NetworkInfo {
-    pingLatencies;
-    constructor(pingLatencies) {
-        this.pingLatencies = pingLatencies;
+const ACKNOWLEDGE_VARIANT = 1;
+let ACK = ACK_1 = class ACK extends Message {
+    header;
+    messageIdToAcknowledge;
+    seenCounter; // Number of times a peer has received the messageIdToAcknowledge before
+    constructor(properties) {
+        super();
+        this.header = properties.header;
+        this.messageIdToAcknowledge = properties.messageIdToAcknowledge;
+        this.seenCounter = Math.min(255, properties.seenCounter);
+    }
+    get id() {
+        return this.header.id;
+    }
+    bytes() {
+        return serialize(this);
+    }
+    static from(bytes) {
+        const result = deserialize(bytes.subarray(), ACK_1);
+        if (!result.header.signatures ||
+            result.header.signatures.signatures.length === 0) {
+            throw new Error("Missing sender on ACK");
+        }
+        return result;
     }
 };
 __decorate([
-    field({ type: vec("u32", SIGNATURES_SIZE_ENCODING) }),
-    __metadata("design:type", Array)
-], NetworkInfo.prototype, "pingLatencies", void 0);
-NetworkInfo = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Array])
-], NetworkInfo);
-export { NetworkInfo };
-// I send this too all my peers
-const HELLO_VARIANT = 1;
+    field({ type: MessageHeader }),
+    __metadata("design:type", MessageHeader)
+], ACK.prototype, "header", void 0);
+__decorate([
+    field({ type: fixedArray("u8", 32) }),
+    __metadata("design:type", Uint8Array)
+], ACK.prototype, "messageIdToAcknowledge", void 0);
+__decorate([
+    field({ type: "u8" }),
+    __metadata("design:type", Number)
+], ACK.prototype, "seenCounter", void 0);
+ACK = ACK_1 = __decorate([
+    variant(ACKNOWLEDGE_VARIANT),
+    __metadata("design:paramtypes", [Object])
+], ACK);
+export { ACK };
+const HELLO_VARIANT = 2;
 let Hello = Hello_1 = class Hello extends Message {
     header;
-    multiaddrs;
-    data;
-    networkInfo;
-    signatures;
-    constructor(options) {
+    joined;
+    constructor(properties) {
         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.joined = properties.joined;
     }
-    get sender() {
-        return this.signatures.signatures[0].publicKey;
+    get id() {
+        return this.header.id;
     }
     bytes() {
         return serialize(this);
     }
     static from(bytes) {
         const result = deserialize(bytes.subarray(), Hello_1);
-        if (result.signatures.signatures.length === 0) {
+        if (!result.header.signatures ||
+            result.header.signatures.signatures.length === 0) {
             throw new Error("Missing sender on Hello");
         }
         return result;
     }
-    _prefix;
-    get prefix() {
-        if (!this._prefix) {
-            throw new Error("Prefix not created");
-        }
-        return this._prefix;
-    }
-    async createPrefix() {
-        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) {
-        return [
-            serialize(new NetworkInfo(this.networkInfo.pingLatencies.slice(0, iteration + 1))),
-            serialize(new Signatures(this.signatures.signatures.slice(0, iteration + 1)))
-        ];
-    }
-    async sign(sign) {
-        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) {
-        return (this.header.verify() &&
-            this.networkInfo.pingLatencies.length ===
-                this.signatures.signatures.length - 1 &&
-            verifyMultiSig(this, expectSignatures));
-    }
-    equals(other) {
-        if (other instanceof Hello_1) {
-            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;
-    }
 };
 __decorate([
     field({ type: MessageHeader }),
@@ -408,281 +447,47 @@ __decorate([
 __decorate([
     field({ type: vec("string") }),
     __metadata("design:type", Array)
-], Hello.prototype, "multiaddrs", void 0);
-__decorate([
-    field({ type: option(Uint8Array) }),
-    __metadata("design:type", Uint8Array)
-], Hello.prototype, "data", void 0);
-__decorate([
-    field({ type: NetworkInfo }),
-    __metadata("design:type", NetworkInfo)
-], Hello.prototype, "networkInfo", void 0);
-__decorate([
-    field({ type: Signatures }),
-    __metadata("design:type", Signatures)
-], Hello.prototype, "signatures", void 0);
+], Hello.prototype, "joined", void 0);
 Hello = Hello_1 = __decorate([
     variant(HELLO_VARIANT),
     __metadata("design:paramtypes", [Object])
 ], Hello);
 export { Hello };
-// Me or some my peer disconnected
-const GOODBYE_VARIANT = 2;
+const GOODBYE_VARIANT = 3;
 let Goodbye = Goodbye_1 = class Goodbye extends Message {
     header;
-    early; // is early goodbye, I send this to my peers so when I disconnect, they can relay the message for me
-    data; // not signed
-    signatures;
+    leaving;
     constructor(properties) {
-        // disconnected: PeerId | string,
         super();
-        this.header = properties?.header || new MessageHeader();
-        this.data = properties?.data;
-        this.early = properties?.early;
-        this.signatures = new Signatures();
+        this.header = properties.header;
+        this.leaving = properties.leaving;
     }
-    get sender() {
-        return this.signatures.signatures[0].publicKey;
+    get id() {
+        return this.header.id;
     }
     bytes() {
         return serialize(this);
     }
     static from(bytes) {
         const result = deserialize(bytes.subarray(), Goodbye_1);
-        if (result.signatures.signatures.length === 0) {
+        if (!result.header.signatures ||
+            result.header.signatures.signatures.length === 0) {
             throw new Error("Missing sender on Goodbye");
         }
         return result;
     }
-    _prefix;
-    get prefix() {
-        if (!this._prefix) {
-            throw new Error("Prefix not created");
-        }
-        return this._prefix;
-    }
-    async createPrefix() {
-        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) {
-        return serialize(new Signatures(this.signatures.signatures.slice(0, iteration + 1)));
-    }
-    async sign(sign) {
-        await this.createPrefix();
-        this.signatures.signatures.push(await sign(getMultiSigDataToSignHistory(this, this.signatures.signatures.length).next().value));
-        return this;
-    }
-    async verify(expectSignatures) {
-        return this.header.verify() && verifyMultiSig(this, expectSignatures);
-    }
-    equals(other) {
-        if (other instanceof Goodbye_1) {
-            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;
-    }
 };
 __decorate([
     field({ type: MessageHeader }),
     __metadata("design:type", MessageHeader)
 ], Goodbye.prototype, "header", void 0);
 __decorate([
-    field({ type: "bool" }),
-    __metadata("design:type", Boolean)
-], Goodbye.prototype, "early", void 0);
-__decorate([
-    field({ type: option(Uint8Array) }),
-    __metadata("design:type", Uint8Array)
-], Goodbye.prototype, "data", void 0);
-__decorate([
-    field({ type: Signatures }),
-    __metadata("design:type", Signatures)
-], Goodbye.prototype, "signatures", void 0);
+    field({ type: vec("string") }),
+    __metadata("design:type", Array)
+], Goodbye.prototype, "leaving", void 0);
 Goodbye = Goodbye_1 = __decorate([
     variant(GOODBYE_VARIANT),
     __metadata("design:paramtypes", [Object])
 ], Goodbye);
 export { Goodbye };
-const PING_VARIANT = 3;
-let PingPong = PingPong_1 = class PingPong extends Message {
-    static from(bytes) {
-        return deserialize(bytes.subarray(), PingPong_1);
-    }
-    bytes() {
-        return serialize(this);
-    }
-    verify(_expectSignatures) {
-        return Promise.resolve(true);
-    }
-};
-PingPong = PingPong_1 = __decorate([
-    variant(PING_VARIANT)
-], PingPong);
-export { PingPong };
-let Ping = Ping_1 = class Ping extends PingPong {
-    pingBytes;
-    constructor() {
-        super();
-        this.pingBytes = randomBytes(32);
-    }
-    equals(other) {
-        if (other instanceof Ping_1) {
-            return equals(this.pingBytes, other.pingBytes);
-        }
-        return false;
-    }
-};
-__decorate([
-    field({ type: fixedArray("u8", 32) }),
-    __metadata("design:type", Uint8Array)
-], Ping.prototype, "pingBytes", void 0);
-Ping = Ping_1 = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [])
-], Ping);
-export { Ping };
-let Pong = Pong_1 = class Pong extends PingPong {
-    pingBytes;
-    constructor(pingBytes) {
-        super();
-        this.pingBytes = pingBytes;
-    }
-    equals(other) {
-        if (other instanceof Pong_1) {
-            return equals(this.pingBytes, other.pingBytes);
-        }
-        return false;
-    }
-};
-__decorate([
-    field({ type: fixedArray("u8", 32) }),
-    __metadata("design:type", Uint8Array)
-], Pong.prototype, "pingBytes", void 0);
-Pong = Pong_1 = __decorate([
-    variant(1),
-    __metadata("design:paramtypes", [Uint8Array])
-], Pong);
-export { Pong };
-let Connections = class Connections {
-    connections;
-    constructor(connections) {
-        this.connections = connections;
-    }
-    equals(other) {
-        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;
-        }
-        return true;
-    }
-};
-__decorate([
-    field({ type: vec(fixedArray("string", 2)) }),
-    __metadata("design:type", Array)
-], Connections.prototype, "connections", void 0);
-Connections = __decorate([
-    variant(0),
-    __metadata("design:paramtypes", [Array])
-], Connections);
-export { Connections };
-// Share connections
-/* const NETWORK_INFO_VARIANT = 3;
-@variant(NETWORK_INFO_VARIANT)
-export class NetworkInfo extends Message {
-
-    @field({ type: MessageHeader })
-    header: MessageHeader;
-
-    @field({ type: Connections })
-    connections: Connections;
-
-
-    @field({ type: Signatures })
-    signatures: Signatures
-
-
-    constructor(connections: [string, string][]) {
-        super();
-        this.header = new MessageHeader();
-        this.connections = new Connections(connections);
-        this.signatures = new Signatures()
-    }
-
-    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)
-    }
-
-
-    serialize() {
-        return serialize(this)
-    }
-    static from(bytes: Uint8ArrayList): NetworkInfo {
-        return deserialize(bytes.subarray(), NetworkInfo)
-    }
-
-    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)
-        }
-        return false;
-    }
-}
-
- */
 //# sourceMappingURL=messages.js.map