ts-mls/dist/leafNode.js

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

import { decodeCapabilities, encodeCapabilities } from "./capabilities.js";
import { encodeUint32 } from "./codec/number.js";
import { mapDecoders, mapDecoder, flatMapDecoder, succeedDecoder, mapDecoderOption, } from "./codec/tlsDecoder.js";
import { contramapEncoders, contramapEncoder } from "./codec/tlsEncoder.js";
import { encodeVarLenData, decodeVarLenData, encodeVarLenType, decodeVarLenType } from "./codec/variableLength.js";
import { encodeCredential, decodeCredential } from "./credential.js";
import { signWithLabel, verifyWithLabel } from "./crypto/signature.js";
import { encodeExtension, decodeExtension } from "./extension.js";
import { encodeLeafNodeSource, decodeLeafNodeSource } from "./leafNodeSource.js";
import { encodeLifetime, decodeLifetime } from "./lifetime.js";
export const encodeLeafNodeData = contramapEncoders([encodeVarLenData, encodeVarLenData, encodeCredential, encodeCapabilities], (data) => [data.hpkePublicKey, data.signaturePublicKey, data.credential, data.capabilities]);
export const decodeLeafNodeData = mapDecoders([decodeVarLenData, decodeVarLenData, decodeCredential, decodeCapabilities], (hpkePublicKey, signaturePublicKey, credential, capabilities) => ({
    hpkePublicKey,
    signaturePublicKey,
    credential,
    capabilities,
}));
export const encodeLeafNodeInfoLifetime = contramapEncoders([encodeLeafNodeSource, encodeLifetime], (info) => ["key_package", info.lifetime]);
export const encodeLeafNodeInfoUpdate = contramapEncoder(encodeLeafNodeSource, (i) => i.leafNodeSource);
export const encodeLeafNodeInfoCommit = contramapEncoders([encodeLeafNodeSource, encodeVarLenData], (info) => ["commit", info.parentHash]);
export const encodeLeafNodeInfo = (info) => {
    switch (info.leafNodeSource) {
        case "key_package":
            return encodeLeafNodeInfoLifetime(info);
        case "update":
            return encodeLeafNodeInfoUpdate(info);
        case "commit":
            return encodeLeafNodeInfoCommit(info);
    }
};
export const decodeLeafNodeInfoLifetime = mapDecoder(decodeLifetime, (lifetime) => ({
    leafNodeSource: "key_package",
    lifetime,
}));
export const decodeLeafNodeInfoCommit = mapDecoders([decodeVarLenData], (parentHash) => ({
    leafNodeSource: "commit",
    parentHash,
}));
export const decodeLeafNodeInfo = flatMapDecoder(decodeLeafNodeSource, (leafNodeSource) => {
    switch (leafNodeSource) {
        case "key_package":
            return decodeLeafNodeInfoLifetime;
        case "update":
            return succeedDecoder({ leafNodeSource });
        case "commit":
            return decodeLeafNodeInfoCommit;
    }
});
export const encodeLeafNodeExtensions = contramapEncoder(encodeVarLenType(encodeExtension), (ext) => ext.extensions);
export const decodeLeafNodeExtensions = mapDecoder(decodeVarLenType(decodeExtension), (extensions) => ({ extensions }));
export const encodeGroupIdLeafIndex = contramapEncoders([encodeVarLenData, encodeUint32], (g) => [g.groupId, g.leafIndex]);
export const encodeLeafNodeGroupInfo = (info) => {
    switch (info.leafNodeSource) {
        case "key_package":
            return new Uint8Array();
        case "update":
        case "commit":
            return encodeGroupIdLeafIndex(info);
    }
};
export const encodeLeafNodeTBS = contramapEncoders([encodeLeafNodeData, encodeLeafNodeInfo, encodeLeafNodeExtensions, encodeLeafNodeGroupInfo], (tbs) => [tbs, tbs, tbs, tbs.info]);
export const encodeLeafNode = contramapEncoders([encodeLeafNodeData, encodeLeafNodeInfo, encodeLeafNodeExtensions, encodeVarLenData], (leafNode) => [leafNode, leafNode, leafNode, leafNode.signature]);
export const decodeLeafNode = mapDecoders([decodeLeafNodeData, decodeLeafNodeInfo, decodeLeafNodeExtensions, decodeVarLenData], (data, info, extensions, signature) => ({
    ...data,
    ...info,
    ...extensions,
    signature,
}));
export const decodeLeafNodeKeyPackage = mapDecoderOption(decodeLeafNode, (ln) => ln.leafNodeSource === "key_package" ? ln : undefined);
export const decodeLeafNodeCommit = mapDecoderOption(decodeLeafNode, (ln) => ln.leafNodeSource === "commit" ? ln : undefined);
export const decodeLeafNodeUpdate = mapDecoderOption(decodeLeafNode, (ln) => ln.leafNodeSource === "update" ? ln : undefined);
function toTbs(leafNode, groupId, leafIndex) {
    return { ...leafNode, info: { leafNodeSource: leafNode.leafNodeSource, groupId, leafIndex } };
}
export async function signLeafNodeCommit(tbs, signaturePrivateKey, sig) {
    return { ...tbs, signature: await signWithLabel(signaturePrivateKey, "LeafNodeTBS", encodeLeafNodeTBS(tbs), sig) };
}
export async function signLeafNodeKeyPackage(tbs, signaturePrivateKey, sig) {
    return { ...tbs, signature: await signWithLabel(signaturePrivateKey, "LeafNodeTBS", encodeLeafNodeTBS(tbs), sig) };
}
export function verifyLeafNodeSignature(leaf, groupId, leafIndex, sig) {
    return verifyWithLabel(leaf.signaturePublicKey, "LeafNodeTBS", encodeLeafNodeTBS(toTbs(leaf, groupId, leafIndex)), leaf.signature, sig);
}
export function verifyLeafNodeSignatureKeyPackage(leaf, sig) {
    return verifyWithLabel(leaf.signaturePublicKey, "LeafNodeTBS", encodeLeafNodeTBS({ ...leaf, info: { leafNodeSource: leaf.leafNodeSource } }), leaf.signature, sig);
}
//# sourceMappingURL=leafNode.js.map