20945201760

Committed 13 Jan 2026 04:55AM UTC coverage: 95.199% (-0.5%) from 95.727%

Build # 20945201760

Build Type

push

github

Committed by

web-flow

Commit Message

Use CiphersuiteId instead of CiphersuiteName for internal values (#200)

* Use CiphersuiteId instead of CiphersuiteName for internal values

* Use ProtocolVersionValue instead of ProtocolVersionName

* Use CredentialTypeValue instead of CredentialTypeName

* Use DefaultProposalTypeValue instead of DefaultProposalTypeName

* Remove extensionType

* Refactor credential

* Cleanup

* Use LeafNodeSourceValue insteda of Name

* Cleanup

* Update NodeType and LeafNodeSource

* Update contentType

* Update resumptionPskusage & senderTypes

* Update wireformat and pskTypes

* Update ts-mls.api

Coverage Stats

412 of 421 branches covered (97.86%)

Branch coverage included in aggregate %.

193 of 208 new or added lines in 35 files covered. (92.79%)

6 existing lines in 3 files now uncovered.

2364 of 2495 relevant lines covered (94.75%)

75088.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.18

/src/publicMessage.ts

import { Decoder, flatMapDecoder, mapDecoder, mapDecoders, succeedDecoder } from "./codec/tlsDecoder.js"
import { contramapBufferEncoders, BufferEncoder, encode, Encoder, encVoid } from "./codec/tlsEncoder.js"
import { decodeVarLenData, varLenDataEncoder } from "./codec/variableLength.js"
import { Extension } from "./extension.js"
import { decodeExternalSender, ExternalSender } from "./externalSender.js"
import {
  decodeFramedContent,
  decodeFramedContentAuthData,
  framedContentEncoder,
  framedContentAuthDataEncoder,
  FramedContent,
  FramedContentAuthData,
} from "./framedContent.js"
import { GroupContext } from "./groupContext.js"
import { CodecError, ValidationError } from "./mlsError.js"
import { defaultProposalTypes } from "./defaultProposalType.js"
import { defaultExtensionTypes } from "./defaultExtensionType.js"
import { getSignaturePublicKeyFromLeafIndex, RatchetTree } from "./ratchetTree.js"
import { senderTypes, SenderTypeValue } from "./sender.js"
import { toLeafIndex } from "./treemath.js"
import { isDefaultProposal } from "./proposal.js"
import { contentTypes } from "./contentType.js"

/** @public */
export type PublicMessageInfo = PublicMessageInfoMember | PublicMessageInfoMemberOther
/** @public */
export type PublicMessageInfoMember = { senderType: typeof senderTypes.member; membershipTag: Uint8Array }
/** @public */
export type PublicMessageInfoMemberOther = { senderType: Exclude<SenderTypeValue, typeof senderTypes.member> }

export const publicMessageInfoEncoder: BufferEncoder<PublicMessageInfo> = (info) => {
  switch (info.senderType) {
    case senderTypes.member:
      return varLenDataEncoder(info.membershipTag)
    case senderTypes.external:
    case senderTypes.new_member_proposal:
    case senderTypes.new_member_commit:
      return encVoid
  }
}

export const encodePublicMessageInfo: Encoder<PublicMessageInfo> = encode(publicMessageInfoEncoder)

export function decodePublicMessageInfo(senderType: SenderTypeValue): Decoder<PublicMessageInfo> {
  switch (senderType) {
    case senderTypes.member:
      return mapDecoder(decodeVarLenData, (membershipTag) => ({
        senderType,
        membershipTag,
      }))
    case senderTypes.external:
    case senderTypes.new_member_proposal:
    case senderTypes.new_member_commit:
      return succeedDecoder({ senderType })
  }
}

/** @public */
export type PublicMessage = { content: FramedContent; auth: FramedContentAuthData } & PublicMessageInfo
export type MemberPublicMessage = PublicMessage & PublicMessageInfoMember
export type ExternalPublicMessage = PublicMessage & PublicMessageInfoMemberOther

export const publicMessageEncoder: BufferEncoder<PublicMessage> = contramapBufferEncoders(
  [framedContentEncoder, framedContentAuthDataEncoder, publicMessageInfoEncoder],
  (msg) => [msg.content, msg.auth, msg] as const,
)

export const encodePublicMessage: Encoder<PublicMessage> = encode(publicMessageEncoder)

export const decodePublicMessage: Decoder<PublicMessage> = flatMapDecoder(decodeFramedContent, (content) =>
  mapDecoders(
    [decodeFramedContentAuthData(content.contentType), decodePublicMessageInfo(content.sender.senderType)],
    (auth, info) => ({
      ...info,
      content,
      auth,
    }),
  ),
)

export function findSignaturePublicKey(
  ratchetTree: RatchetTree,
  groupContext: GroupContext,
  framedContent: FramedContent,
): Uint8Array {
  switch (framedContent.sender.senderType) {
    case senderTypes.member:
      return getSignaturePublicKeyFromLeafIndex(ratchetTree, toLeafIndex(framedContent.sender.leafIndex))
    case senderTypes.external: {
      const sender = senderFromExtension(groupContext.extensions, framedContent.sender.senderIndex)
      if (sender === undefined) throw new ValidationError("Received external but no external_sender extension")
      return sender.signaturePublicKey
    }
    case senderTypes.new_member_proposal:
      if (framedContent.contentType !== contentTypes.proposal)
        throw new ValidationError("Received new_member_proposal but contentType is not proposal")
      if (
        !isDefaultProposal(framedContent.proposal) ||
        framedContent.proposal.proposalType !== defaultProposalTypes.add
      )
        throw new ValidationError("Received new_member_proposal but proposalType was not add")

      return framedContent.proposal.add.keyPackage.leafNode.signaturePublicKey
    case senderTypes.new_member_commit: {
      if (framedContent.contentType !== contentTypes.commit)
        throw new ValidationError("Received new_member_commit but contentType is not commit")

      if (framedContent.commit.path === undefined) throw new ValidationError("Commit contains no update path")
      return framedContent.commit.path.leafNode.signaturePublicKey
    }
  }
}

export function senderFromExtension(extensions: Extension[], senderIndex: number): ExternalSender | undefined {
  const externalSenderExtensions = extensions.filter(
    (ex) => ex.extensionType === defaultExtensionTypes.external_senders,
  )

  const externalSenderExtension = externalSenderExtensions[senderIndex]

  if (externalSenderExtension !== undefined) {
    const externalSender = decodeExternalSender(externalSenderExtension.extensionData, 0)
    if (externalSender === undefined) throw new CodecError("Could not decode ExternalSender")

    return externalSender[0]
  }
}

1	import { Decoder, flatMapDecoder, mapDecoder, mapDecoders, succeedDecoder } from "./codec/tlsDecoder.js"
2	import { contramapBufferEncoders, BufferEncoder, encode, Encoder, encVoid } from "./codec/tlsEncoder.js"
3	import { decodeVarLenData, varLenDataEncoder } from "./codec/variableLength.js"
4	import { Extension } from "./extension.js"
5	import { decodeExternalSender, ExternalSender } from "./externalSender.js"
6	import {
7	decodeFramedContent,
8	decodeFramedContentAuthData,
9	framedContentEncoder,
10	framedContentAuthDataEncoder,
11	FramedContent,
12	FramedContentAuthData,
13	} from "./framedContent.js"
14	import { GroupContext } from "./groupContext.js"
15	import { CodecError, ValidationError } from "./mlsError.js"
16	import { defaultProposalTypes } from "./defaultProposalType.js"
17	import { defaultExtensionTypes } from "./defaultExtensionType.js"
18	import { getSignaturePublicKeyFromLeafIndex, RatchetTree } from "./ratchetTree.js"
19	import { senderTypes, SenderTypeValue } from "./sender.js"
20	import { toLeafIndex } from "./treemath.js"
21	import { isDefaultProposal } from "./proposal.js"
22	import { contentTypes } from "./contentType.js"
23
24	/** @public */
25	export type PublicMessageInfo = PublicMessageInfoMember \| PublicMessageInfoMemberOther
26	/** @public */
27	export type PublicMessageInfoMember = { senderType: typeof senderTypes.member; membershipTag: Uint8Array }
28	/** @public */
29	export type PublicMessageInfoMemberOther = { senderType: Exclude<SenderTypeValue, typeof senderTypes.member> }
30
31	export const publicMessageInfoEncoder: BufferEncoder<PublicMessageInfo> = (info) => {	3✔
32	switch (info.senderType) {	903✔
33	case senderTypes.member:
34	return varLenDataEncoder(info.membershipTag)	902✔
35	case senderTypes.external:
36	case senderTypes.new_member_proposal:
37	case senderTypes.new_member_commit:
38	return encVoid	1✔
39	}
40	}
41
42	export const encodePublicMessageInfo: Encoder<PublicMessageInfo> = encode(publicMessageInfoEncoder)	3✔
43
44	export function decodePublicMessageInfo(senderType: SenderTypeValue): Decoder<PublicMessageInfo> {
45	switch (senderType) {	2,925✔
46	case senderTypes.member:
47	return mapDecoder(decodeVarLenData, (membershipTag) => ({	2,924✔
48	senderType,
49	membershipTag,
50	}))
51	case senderTypes.external:
52	case senderTypes.new_member_proposal:
53	case senderTypes.new_member_commit:
54	return succeedDecoder({ senderType })	1✔
55	}
56	}
57
58	/** @public */
59	export type PublicMessage = { content: FramedContent; auth: FramedContentAuthData } & PublicMessageInfo
60	export type MemberPublicMessage = PublicMessage & PublicMessageInfoMember
61	export type ExternalPublicMessage = PublicMessage & PublicMessageInfoMemberOther
62
63	export const publicMessageEncoder: BufferEncoder<PublicMessage> = contramapBufferEncoders(	3✔
64	[framedContentEncoder, framedContentAuthDataEncoder, publicMessageInfoEncoder],
65	(msg) => [msg.content, msg.auth, msg] as const,	903✔
66	)
67
68	export const encodePublicMessage: Encoder<PublicMessage> = encode(publicMessageEncoder)	3✔
69
70	export const decodePublicMessage: Decoder<PublicMessage> = flatMapDecoder(decodeFramedContent, (content) =>	2,925✔
71	mapDecoders(
72	[decodeFramedContentAuthData(content.contentType), decodePublicMessageInfo(content.sender.senderType)],
73	(auth, info) => ({	2,925✔
74	...info,
75	content,
76	auth,
77	}),
78	),
79	)
80
81	export function findSignaturePublicKey(
82	ratchetTree: RatchetTree,
83	groupContext: GroupContext,
84	framedContent: FramedContent,
85	): Uint8Array {
86	switch (framedContent.sender.senderType) {	2,274✔
87	case senderTypes.member:
88	return getSignaturePublicKeyFromLeafIndex(ratchetTree, toLeafIndex(framedContent.sender.leafIndex))	2,122✔
89	case senderTypes.external: {
90	const sender = senderFromExtension(groupContext.extensions, framedContent.sender.senderIndex)	38✔
91	if (sender === undefined) throw new ValidationError("Received external but no external_sender extension")	38✔
92	return sender.signaturePublicKey	38✔
93	}
94	case senderTypes.new_member_proposal:
95	if (framedContent.contentType !== contentTypes.proposal)	38✔
UNCOV 96	throw new ValidationError("Received new_member_proposal but contentType is not proposal")	×
97	if (	38✔
98	!isDefaultProposal(framedContent.proposal) \|\|
99	framedContent.proposal.proposalType !== defaultProposalTypes.add
100	)
UNCOV 101	throw new ValidationError("Received new_member_proposal but proposalType was not add")	×
102
103	return framedContent.proposal.add.keyPackage.leafNode.signaturePublicKey	38✔
104	case senderTypes.new_member_commit: {
105	if (framedContent.contentType !== contentTypes.commit)	76✔
UNCOV 106	throw new ValidationError("Received new_member_commit but contentType is not commit")	×
107
108	if (framedContent.commit.path === undefined) throw new ValidationError("Commit contains no update path")	76✔
109	return framedContent.commit.path.leafNode.signaturePublicKey	76✔
110	}
111	}
112	}
113
114	export function senderFromExtension(extensions: Extension[], senderIndex: number): ExternalSender \| undefined {
115	const externalSenderExtensions = extensions.filter(	38✔
116	(ex) => ex.extensionType === defaultExtensionTypes.external_senders,	38✔
117	)
118
119	const externalSenderExtension = externalSenderExtensions[senderIndex]	38✔
120
121	if (externalSenderExtension !== undefined) {	38✔
122	const externalSender = decodeExternalSender(externalSenderExtension.extensionData, 0)	38✔
123	if (externalSender === undefined) throw new CodecError("Could not decode ExternalSender")	38✔
124
125	return externalSender[0]	38✔
126	}
127	}

LukaJCB / ts-mls / 20945201760

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous