ts-mls/dist/test/test-vectors/messages.test.js

[](https://github.com/LukaJCB/ts-mls/actions/workflows/ci.yml) [](https://badge.fury.io/js/ts-mls) [![Coverage Status](https://co

import json from "../../test_vectors/messages.json";
import { hexToBytes } from "@noble/ciphers/utils";
import { decodeMlsMessage, encodeMlsMessage } from "../../src/message";
import { decodeCommit, encodeCommit } from "../../src/commit";
import { decodeAdd, decodeExternalInit, decodeGroupContextExtensions, decodePSK, decodeReinit, decodeRemove, decodeUpdate, encodeAdd, encodeExternalInit, encodeGroupContextExtensions, encodePSK, encodeReinit, encodeRemove, encodeUpdate, } from "../../src/proposal";
import { decodeRatchetTree, encodeRatchetTree } from "../../src/ratchetTree";
import { decodeGroupSecrets, encodeGroupSecrets } from "../../src/groupSecrets";
for (const [index, x] of json.entries()) {
    test(`messages test vectors ${index}`, () => {
        codecRoundtrip(x);
    });
}
function codecRoundtrip(msgs) {
    welcome(msgs.mls_welcome);
    groupInfo(msgs.mls_group_info);
    keyPackage(msgs.mls_key_package);
    ratchetTree(msgs.ratchet_tree);
    groupSecrets(msgs.group_secrets);
    addProposal(msgs.add_proposal);
    updateProposal(msgs.update_proposal);
    removeProposal(msgs.remove_proposal);
    pskProposal(msgs.pre_shared_key_proposal);
    reinitProposal(msgs.re_init_proposal);
    externalInitProposal(msgs.external_init_proposal);
    groupContextExtension(msgs.group_context_extensions_proposal);
    commit(msgs.commit);
    publicMessageApplication(msgs.public_message_application);
    publicMessageCommit(msgs.public_message_commit);
    publicMessageProposal(msgs.public_message_proposal);
    privateMessage(msgs.private_message);
}
function welcome(s) {
    const inputBytes = hexToBytes(s);
    const mlsWelcome = decodeMlsMessage(inputBytes, 0);
    if (mlsWelcome === undefined || mlsWelcome[0].wireformat !== "mls_welcome") {
        throw new Error("could not decode mls welcome");
    }
    else {
        const reEncoded = encodeMlsMessage(mlsWelcome[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function privateMessage(s) {
    const inputBytes = hexToBytes(s);
    const p = decodeMlsMessage(inputBytes, 0);
    if (p === undefined || p[0].wireformat !== "mls_private_message") {
        throw new Error("could not decode mls private message");
    }
    else {
        const reEncoded = encodeMlsMessage(p?.[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function groupInfo(s) {
    const inputBytes = hexToBytes(s);
    const gi = decodeMlsMessage(inputBytes, 0);
    if (gi === undefined || gi[0].wireformat !== "mls_group_info") {
        throw new Error("could not decode mls_group_info");
    }
    else {
        const reEncoded = encodeMlsMessage(gi[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function keyPackage(s) {
    const inputBytes = hexToBytes(s);
    const kp = decodeMlsMessage(inputBytes, 0);
    if (kp === undefined || kp[0].wireformat !== "mls_key_package") {
        throw new Error("could not decode mls_key_package");
    }
    else {
        const reEncoded = encodeMlsMessage(kp[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function publicMessageApplication(s) {
    const inputBytes = hexToBytes(s);
    const p = decodeMlsMessage(inputBytes, 0);
    if (p === undefined || p[0].wireformat !== "mls_public_message") {
        throw new Error("could not decode mls_public_message");
    }
    else {
        expect(p[0].publicMessage.content.contentType).toBe("application");
        const reEncoded = encodeMlsMessage(p[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function publicMessageProposal(s) {
    const inputBytes = hexToBytes(s);
    const p = decodeMlsMessage(inputBytes, 0);
    if (p === undefined || p[0].wireformat !== "mls_public_message") {
        throw new Error("could not decode mls_public_message");
    }
    else {
        expect(p[0].publicMessage.content.contentType).toBe("proposal");
        const reEncoded = encodeMlsMessage(p[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
function publicMessageCommit(s) {
    const inputBytes = hexToBytes(s);
    const p = decodeMlsMessage(inputBytes, 0);
    if (p === undefined || p[0].wireformat !== "mls_public_message") {
        throw new Error("could not decode mls_public_message");
    }
    else {
        expect(p[0].publicMessage.content.contentType).toBe("commit");
        const reEncoded = encodeMlsMessage(p[0]);
        expect(reEncoded).toStrictEqual(inputBytes);
    }
}
//const keyPackage = createTest(encodeKeyPackage, decodeKeyPackage, '')
const commit = createTest(encodeCommit, decodeCommit, "commit");
const groupSecrets = createTest(encodeGroupSecrets, decodeGroupSecrets, "group_secrets");
const ratchetTree = createTest(encodeRatchetTree, decodeRatchetTree, "ratchet_tree");
const updateProposal = createTest(encodeUpdate, decodeUpdate, "update_proposal");
const addProposal = createTest(encodeAdd, decodeAdd, "add_proposal");
const pskProposal = createTest(encodePSK, decodePSK, "pre_shared_key_proposal");
const removeProposal = createTest(encodeRemove, decodeRemove, "remove_proposal");
const reinitProposal = createTest(encodeReinit, decodeReinit, "re_init_proposal");
const externalInitProposal = createTest(encodeExternalInit, decodeExternalInit, "external_init_proposal");
const groupContextExtension = createTest(encodeGroupContextExtensions, decodeGroupContextExtensions, "group_context_extensions_proposal");
function createTest(enc, dec, typeName) {
    return (s) => {
        const inputBytes = hexToBytes(s);
        const decoded = dec(inputBytes, 0);
        if (decoded === undefined) {
            throw new Error(`could not decode ${typeName}`);
        }
        else {
            const reEncoded = enc(decoded[0]);
            expect(reEncoded).toStrictEqual(inputBytes);
        }
    };
}
//# sourceMappingURL=messages.test.js.map