@peerbit/stream-interface 1.0.1

package/lib/esm/messages.js

@@ -0,0 +1,678 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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;
+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";
+/**
+ * The default msgID implementation
+ * Child class can override this.
+ */
+export const getMsgId = async (msg) => {
+    // first bytes is 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);
+};
+let concatBytes;
+if (globalThis.Buffer) {
+    concatBytes = globalThis.Buffer.concat;
+}
+else {
+    concatBytes = (arrays, length) => {
+        if (length == null) {
+            let length = 0;
+            for (const element of arrays) {
+                length += element.length;
+            }
+        }
+        const output = new Uint8Array(length);
+        let offset = 0;
+        for (const arr of arrays) {
+            output.set(arr, offset);
+            offset += arr.length;
+        }
+        return output;
+    };
+}
+export const ID_LENGTH = 32;
+const WEEK_MS = 7 * 24 * 60 * 60 + 1000;
+export let MessageHeader = class MessageHeader {
+    _id;
+    _timestamp;
+    _expires;
+    constructor(properties) {
+        this._id = properties?.id || randomBytes(ID_LENGTH);
+        this._expires = properties?.expires || BigInt(+new Date() + WEEK_MS);
+        this._timestamp = BigInt(+new Date());
+    }
+    get id() {
+        return this._id;
+    }
+    get expires() {
+        return this._expires;
+    }
+    get timetamp() {
+        return this._timestamp;
+    }
+    equals(other) {
+        return this._expires === other.expires && equals(this._id, other.id);
+    }
+    verify() {
+        return this.expires >= +new Date();
+    }
+};
+__decorate([
+    field({ type: fixedArray("u8", ID_LENGTH) }),
+    __metadata("design:type", Uint8Array)
+], MessageHeader.prototype, "_id", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], MessageHeader.prototype, "_timestamp", void 0);
+__decorate([
+    field({ type: "u64" }),
+    __metadata("design:type", BigInt)
+], MessageHeader.prototype, "_expires", void 0);
+MessageHeader = __decorate([
+    variant(0),
+    __metadata("design:paramtypes", [Object])
+], 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
+export 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)));
+    }
+};
+__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);
+const keyMap = new Map();
+const verifyMultiSig = async (message, expectSignatures) => {
+    const signatures = message.signatures.signatures;
+    if (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))) {
+            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 deserialize(bytes) {
+        if (bytes.get(0) === DATA_VARIANT) {
+            // Data
+            return DataMessage.deserialize(bytes);
+        }
+        else if (bytes.get(0) === HELLO_VARIANT) {
+            // heartbeat
+            return Hello.deserialize(bytes);
+        }
+        else if (bytes.get(0) === GOODBYE_VARIANT) {
+            // heartbeat
+            return Goodbye.deserialize(bytes);
+        }
+        else if (bytes.get(0) === PING_VARIANT) {
+            return PingPong.deserialize(bytes);
+        }
+        throw new Error("Unsupported");
+    }
+}
+// I pack data with this message
+const DATA_VARIANT = 0;
+export 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();
+    }
+    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 */
+    serialize() {
+        if (this._serialized) {
+            return this._serialized;
+        }
+        return serialize(this);
+    }
+    static deserialize(bytes) {
+        if (bytes.get(0) !== 0) {
+            throw new Error("Unsupported");
+        }
+        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 }),
+    __metadata("design:type", Uint8Array)
+], DataMessage.prototype, "_data", void 0);
+DataMessage = DataMessage_1 = __decorate([
+    variant(DATA_VARIANT),
+    __metadata("design:paramtypes", [Object])
+], DataMessage);
+export let NetworkInfo = class NetworkInfo {
+    pingLatencies;
+    constructor(pingLatencies) {
+        this.pingLatencies = pingLatencies;
+    }
+};
+__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);
+// I send this too all my peers
+const HELLO_VARIANT = 1;
+export let Hello = Hello_1 = class Hello extends Message {
+    header;
+    multiaddrs;
+    data;
+    networkInfo;
+    signatures;
+    constructor(options) {
+        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([]);
+    }
+    get sender() {
+        return this.signatures.signatures[0].publicKey;
+    }
+    serialize() {
+        return serialize(this);
+    }
+    static deserialize(bytes) {
+        const result = deserialize(bytes.subarray(), Hello_1);
+        if (result.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 }),
+    __metadata("design:type", MessageHeader)
+], Hello.prototype, "header", void 0);
+__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 = Hello_1 = __decorate([
+    variant(HELLO_VARIANT),
+    __metadata("design:paramtypes", [Object])
+], Hello);
+// Me or some my peer disconnected
+const GOODBYE_VARIANT = 2;
+export 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;
+    constructor(properties) {
+        // disconnected: PeerId | string,
+        super();
+        this.header = properties?.header || new MessageHeader();
+        this.data = properties?.data;
+        this.early = properties?.early;
+        this.signatures = new Signatures();
+    }
+    get sender() {
+        return this.signatures.signatures[0].publicKey;
+    }
+    serialize() {
+        return serialize(this);
+    }
+    static deserialize(bytes) {
+        const result = deserialize(bytes.subarray(), Goodbye_1);
+        if (result.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);
+Goodbye = Goodbye_1 = __decorate([
+    variant(GOODBYE_VARIANT),
+    __metadata("design:paramtypes", [Object])
+], Goodbye);
+const PING_VARIANT = 3;
+export let PingPong = PingPong_1 = class PingPong extends Message {
+    static deserialize(bytes) {
+        return deserialize(bytes.subarray(), PingPong_1);
+    }
+    serialize() {
+        return serialize(this);
+    }
+    verify(_expectSignatures) {
+        return Promise.resolve(true);
+    }
+};
+PingPong = PingPong_1 = __decorate([
+    variant(PING_VARIANT)
+], PingPong);
+export 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 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 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);
+// 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 deserialize(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