20546506344

Committed 28 Dec 2025 12:42AM UTC coverage: 96.121% (-0.1%) from 96.237%

Build # 20546506344

Build Type

push

github

Committed by

LukaJCB

Commit Message

Deprecate json codec for group state

Run Details

1239 of 1388 branches covered (89.27%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

16 existing lines in 5 files now uncovered.

7162 of 7352 relevant lines covered (97.42%)

44152.98 hits per line

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

79.57

/src/codec/json.ts

import { ClientConfig } from "../clientConfig.js"
import { ClientState } from "../clientState.js"
import { EpochReceiverData } from "../epochReceiverData.js"

/**
 * @deprecated Use encodeGroupState instead for binary serialization
 */
export function toJsonString(clientState: ClientState): string {
  const { clientConfig, ...state } = clientState

  const stateWithSerializableMap = {
    ...state,
    historicalReceiverData: Array.from(state.historicalReceiverData.entries()).map(([epoch, data]) => [
      {
        epoch: epoch.toString(),
      },
      data,
    ]),
  }
  return JSON.stringify(stateWithSerializableMap, (_key, value: unknown) => {
    // Mark BigInt values with a special wrapper
    if (typeof value === "bigint") {
      return { "@@bigint": value.toString() }
    }
    // Mark empty Uint8Arrays with a special marker
    if (value instanceof Uint8Array) {
      if (value.length === 0) {
        return { "@@uint8array": true, length: 0, data: [] }
      }
    }
    return value
  })
}

function isValidGroupActiveState(state: unknown): boolean {
  if (typeof state !== "object" || state === null) return false
  const s = state as Record<string, unknown>
  if (typeof s.kind !== "string") return false
  if (s.kind === "active") return true
  if (s.kind === "suspendedPendingReinit") return "reinit" in s && typeof s.reinit === "object"
  if (s.kind === "removedFromGroup") return true
  return false
}

function isValidRatchetTree(tree: unknown): boolean {
  if (!Array.isArray(tree)) return false
  return tree.every((node) => node === null || (typeof node === "object" && node !== null))
}

function isValidGroupContext(ctx: unknown): boolean {
  if (typeof ctx !== "object" || ctx === null) return false
  const c = ctx as Record<string, unknown>
  return (
    "version" in c &&
    "cipherSuite" in c &&
    "groupId" in c &&
    "epoch" in c &&
    "treeHash" in c &&
    "confirmedTranscriptHash" in c &&
    "extensions" in c
  )
}

function isValidKeySchedule(ks: unknown): boolean {
  if (typeof ks !== "object" || ks === null) return false
  const k = ks as Record<string, unknown>
  return "epochAuthenticator" in k && typeof k.epochAuthenticator === "object"
}

function isValidPrivateKeyPath(pkp: unknown): boolean {
  if (typeof pkp !== "object" || pkp === null) return false
  const p = pkp as Record<string, unknown>
  return "leafIndex" in p && typeof p.leafIndex === "number"
}

function isValidUnappliedProposals(uap: unknown): boolean {
  return uap !== null && typeof uap === "object"
}

function isValidHistoricalReceiverData(hrd: unknown): boolean {
  if (!Array.isArray(hrd)) return false
  return hrd.every(
    (item: unknown) => Array.isArray(item) && item.length === 2 && typeof item[0] === "object" && "epoch" in item[0],
  )
}

function deepConvertUint8Arrays(obj: unknown, depth = 0, maxDepth = 20): unknown {
  if (depth > maxDepth) return obj
  if (obj === null || obj === undefined) return obj
  if (obj instanceof Uint8Array) return obj

  // Check for the special BigInt marker
  if (obj && typeof obj === "object" && "@@bigint" in obj) {
    const objRecord = obj as Record<string, unknown>
    if (typeof objRecord["@@bigint"] === "string") {
      return BigInt(objRecord["@@bigint"])
    }
  }

  // Check for the special empty Uint8Array marker
  if (obj && typeof obj === "object" && "@@uint8array" in obj) {
    const objRecord = obj as Record<string, unknown>
    if (objRecord["@@uint8array"] === true) {
      return new Uint8Array()
    }
  }

  // Handle non-empty Uint8Array-like objects
  if (obj && typeof obj === "object" && !Array.isArray(obj)) {
    const objRecord = obj as Record<string, unknown>
    const keys = Object.keys(objRecord)
    if (keys.length > 0 && !("@@uint8array" in objRecord) && !("@@bigint" in objRecord)) {
      // Check if all keys are numeric strings and all values are 0-255 numbers
      const allNumericKeys = keys.every((k) => /^\d+$/.test(k))
      if (allNumericKeys) {
        const allValidValues = keys.every(
          (k) =>
            Object.prototype.hasOwnProperty.call(objRecord, k) &&
            typeof objRecord[k] === "number" &&
            objRecord[k] >= 0 &&
            objRecord[k] <= 255,
        )
        if (allValidValues) {
          const numKeys = keys.map((k) => parseInt(k, 10))
          const values = numKeys.sort((a, b) => a - b).map((n) => objRecord[String(n)] as number)
          return new Uint8Array(values)
        }
      }
    }
  }

  if (Array.isArray(obj)) {
    return obj.map((item) => deepConvertUint8Arrays(item, depth + 1, maxDepth))
  }

  if (typeof obj === "object") {
    const objRecord = obj as Record<string, unknown>
    const result: Record<string, unknown> = {}
    for (const key in objRecord) {
      if (Object.prototype.hasOwnProperty.call(objRecord, key)) {
        result[key] = deepConvertUint8Arrays(objRecord[key], depth + 1, maxDepth)
      }
    }
    return result
  }

  return obj
}

/**
 * @deprecated Use decodeGroupState instead for binary deserialization
 */
export function fromJsonString(s: string, config: ClientConfig): ClientState | undefined {
  try {
    const parsed = JSON.parse(s) as unknown

    if (typeof parsed !== "object" || parsed === null) return undefined

    const parsedRecord = parsed as Record<string, unknown>
    if (
      !("groupActiveState" in parsedRecord) ||
      !("privatePath" in parsedRecord) ||
      !("ratchetTree" in parsedRecord) ||
      !("keySchedule" in parsedRecord) ||
      !("groupContext" in parsedRecord) ||
      !("unappliedProposals" in parsedRecord) ||
      !("signaturePrivateKey" in parsedRecord) ||
      !("confirmationTag" in parsedRecord) ||
      !("historicalReceiverData" in parsedRecord) ||
      !("secretTree" in parsedRecord)
    ) {
      return undefined
    }

    const converted = deepConvertUint8Arrays(parsedRecord) as Record<string, unknown>

    if (!isValidGroupActiveState(converted.groupActiveState)) return undefined
    if (!isValidPrivateKeyPath(converted.privatePath)) return undefined
    if (!isValidRatchetTree(converted.ratchetTree)) return undefined
    if (!isValidKeySchedule(converted.keySchedule)) return undefined
    if (!isValidGroupContext(converted.groupContext)) return undefined
    if (!isValidUnappliedProposals(converted.unappliedProposals)) return undefined
    if (!isValidHistoricalReceiverData(converted.historicalReceiverData)) return undefined

    if (!(converted.signaturePrivateKey instanceof Uint8Array || typeof converted.signaturePrivateKey === "object")) {
      return undefined
    }
    if (!(converted.confirmationTag instanceof Uint8Array || typeof converted.confirmationTag === "object")) {
      return undefined
    }

    // Reconstruct Map<bigint, EpochReceiverData>
    const historicalReceiverData = new Map<bigint, EpochReceiverData>()
    if (Array.isArray(converted.historicalReceiverData)) {
      for (const [keyObj, data] of converted.historicalReceiverData as [unknown, unknown][]) {
        if (keyObj && typeof keyObj === "object" && "epoch" in keyObj) {
          const keyObjRecord = keyObj as Record<string, unknown>
          if (typeof keyObjRecord.epoch === "bigint") {
            historicalReceiverData.set(keyObjRecord.epoch, data as EpochReceiverData)
          }
        }
      }
    }

    return { clientConfig: config, ...converted, historicalReceiverData } as unknown as ClientState
  } catch {
    return undefined
  }
}

1	import { ClientConfig } from "../clientConfig.js"
2	import { ClientState } from "../clientState.js"
3	import { EpochReceiverData } from "../epochReceiverData.js"
4
5	/**
6	* @deprecated Use encodeGroupState instead for binary serialization
7	*/
8	export function toJsonString(clientState: ClientState): string {	1✔
9	const { clientConfig, ...state } = clientState	19✔
10
11	const stateWithSerializableMap = {	19✔
12	...state,	19✔
13	historicalReceiverData: Array.from(state.historicalReceiverData.entries()).map(([epoch, data]) => [	19✔
14	{	×
15	epoch: epoch.toString(),	×
16	},	×
UNCOV 17	data,	×
18	]),	19✔
19	}	19✔
20	return JSON.stringify(stateWithSerializableMap, (_key, value: unknown) => {	19✔
21	// Mark BigInt values with a special wrapper
22	if (typeof value === "bigint") {	84,689✔
23	return { "@@bigint": value.toString() }	57✔
24	}	57✔
25	// Mark empty Uint8Arrays with a special marker
26	if (value instanceof Uint8Array) {	84,689✔
27	if (value.length === 0) {	418✔
28	return { "@@uint8array": true, length: 0, data: [] }	19✔
29	}	19✔
30	}	418✔
31	return value	84,613✔
32	})	19✔
33	}	19✔
34
35	function isValidGroupActiveState(state: unknown): boolean {	19✔
36	if (typeof state !== "object" \|\| state === null) return false	19!
37	const s = state as Record<string, unknown>	19✔
38	if (typeof s.kind !== "string") return false	19!
39	if (s.kind === "active") return true	19!
40	if (s.kind === "suspendedPendingReinit") return "reinit" in s && typeof s.reinit === "object"	×
41	if (s.kind === "removedFromGroup") return true	×
42	return false	×
UNCOV 43	}	×
44
45	function isValidRatchetTree(tree: unknown): boolean {	19✔
46	if (!Array.isArray(tree)) return false	19!
47	return tree.every((node) => node === null \|\| (typeof node === "object" && node !== null))	19✔
48	}	19✔
49
50	function isValidGroupContext(ctx: unknown): boolean {	19✔
51	if (typeof ctx !== "object" \|\| ctx === null) return false	19!
52	const c = ctx as Record<string, unknown>	19✔
53	return (	19✔
54	"version" in c &&	19✔
55	"cipherSuite" in c &&	19✔
56	"groupId" in c &&	19✔
57	"epoch" in c &&	19✔
58	"treeHash" in c &&	19✔
59	"confirmedTranscriptHash" in c &&	19✔
60	"extensions" in c	19✔
61	)
62	}	19✔
63
64	function isValidKeySchedule(ks: unknown): boolean {	19✔
65	if (typeof ks !== "object" \|\| ks === null) return false	19!
66	const k = ks as Record<string, unknown>	19✔
67	return "epochAuthenticator" in k && typeof k.epochAuthenticator === "object"	19✔
68	}	19✔
69
70	function isValidPrivateKeyPath(pkp: unknown): boolean {	19✔
71	if (typeof pkp !== "object" \|\| pkp === null) return false	19!
72	const p = pkp as Record<string, unknown>	19✔
73	return "leafIndex" in p && typeof p.leafIndex === "number"	19✔
74	}	19✔
75
76	function isValidUnappliedProposals(uap: unknown): boolean {	19✔
77	return uap !== null && typeof uap === "object"	19✔
78	}	19✔
79
80	function isValidHistoricalReceiverData(hrd: unknown): boolean {	19✔
81	if (!Array.isArray(hrd)) return false	19!
82	return hrd.every(	19✔
83	(item: unknown) => Array.isArray(item) && item.length === 2 && typeof item[0] === "object" && "epoch" in item[0],	19✔
84	)	19✔
85	}	19✔
86
87	function deepConvertUint8Arrays(obj: unknown, depth = 0, maxDepth = 20): unknown {	1,684✔
88	if (depth > maxDepth) return obj	1,684!
89	if (obj === null \|\| obj === undefined) return obj	1,684!
90	if (obj instanceof Uint8Array) return obj	1,684!
91
92	// Check for the special BigInt marker
93	if (obj && typeof obj === "object" && "@@bigint" in obj) {	1,684✔
94	const objRecord = obj as Record<string, unknown>	57✔
95	if (typeof objRecord["@@bigint"] === "string") {	57✔
96	return BigInt(objRecord["@@bigint"])	57✔
97	}	57✔
98	}	57✔
99
100	// Check for the special empty Uint8Array marker
101	if (obj && typeof obj === "object" && "@@uint8array" in obj) {	1,684✔
102	const objRecord = obj as Record<string, unknown>	19✔
103	if (objRecord["@@uint8array"] === true) {	19✔
104	return new Uint8Array()	19✔
105	}	19✔
106	}	19✔
107
108	// Handle non-empty Uint8Array-like objects
109	if (obj && typeof obj === "object" && !Array.isArray(obj)) {	1,684✔
110	const objRecord = obj as Record<string, unknown>	722✔
111	const keys = Object.keys(objRecord)	722✔
112	if (keys.length > 0 && !("@@uint8array" in objRecord) && !("@@bigint" in objRecord)) {	722✔
113	// Check if all keys are numeric strings and all values are 0-255 numbers
114	const allNumericKeys = keys.every((k) => /^\d+$/.test(k))	665✔
115	if (allNumericKeys) {	665✔
116	const allValidValues = keys.every(	418✔
117	(k) =>	418✔
118	Object.prototype.hasOwnProperty.call(objRecord, k) &&	82,910✔
119	typeof objRecord[k] === "number" &&	82,910✔
120	objRecord[k] >= 0 &&	82,891✔
121	objRecord[k] <= 255,	82,891✔
122	)	418✔
123	if (allValidValues) {	418✔
124	const numKeys = keys.map((k) => parseInt(k, 10))	399✔
125	const values = numKeys.sort((a, b) => a - b).map((n) => objRecord[String(n)] as number)	399✔
126	return new Uint8Array(values)	399✔
127	}	399✔
128	}	418✔
129	}	665✔
130	}	722✔
131
132	if (Array.isArray(obj)) {	1,684✔
133	return obj.map((item) => deepConvertUint8Arrays(item, depth + 1, maxDepth))	190✔
134	}	190✔
135
136	if (typeof obj === "object") {	1,684✔
137	const objRecord = obj as Record<string, unknown>	323✔
138	const result: Record<string, unknown> = {}	323✔
139	for (const key in objRecord) {	323✔
140	if (Object.prototype.hasOwnProperty.call(objRecord, key)) {	1,102✔
141	result[key] = deepConvertUint8Arrays(objRecord[key], depth + 1, maxDepth)	1,102✔
142	}	1,102✔
143	}	1,102✔
144	return result	323✔
145	}	323✔
146
147	return obj	696✔
148	}	696✔
149
150	/**
151	* @deprecated Use decodeGroupState instead for binary deserialization
152	*/
153	export function fromJsonString(s: string, config: ClientConfig): ClientState \| undefined {	1✔
154	try {	19✔
155	const parsed = JSON.parse(s) as unknown	19✔
156
157	if (typeof parsed !== "object" \|\| parsed === null) return undefined	19!
158
159	const parsedRecord = parsed as Record<string, unknown>	19✔
160	if (	19✔
161	!("groupActiveState" in parsedRecord) \|\|	19✔
162	!("privatePath" in parsedRecord) \|\|	19✔
163	!("ratchetTree" in parsedRecord) \|\|	19✔
164	!("keySchedule" in parsedRecord) \|\|	19✔
165	!("groupContext" in parsedRecord) \|\|	19✔
166	!("unappliedProposals" in parsedRecord) \|\|	19✔
167	!("signaturePrivateKey" in parsedRecord) \|\|	19✔
168	!("confirmationTag" in parsedRecord) \|\|	19✔
169	!("historicalReceiverData" in parsedRecord) \|\|	19✔
170	!("secretTree" in parsedRecord)	19✔
171	) {	19!
172	return undefined	×
UNCOV 173	}	×
174
175	const converted = deepConvertUint8Arrays(parsedRecord) as Record<string, unknown>	19✔
176
177	if (!isValidGroupActiveState(converted.groupActiveState)) return undefined	19!
178	if (!isValidPrivateKeyPath(converted.privatePath)) return undefined	19!
179	if (!isValidRatchetTree(converted.ratchetTree)) return undefined	19!
180	if (!isValidKeySchedule(converted.keySchedule)) return undefined	19!
181	if (!isValidGroupContext(converted.groupContext)) return undefined	19!
182	if (!isValidUnappliedProposals(converted.unappliedProposals)) return undefined	19!
183	if (!isValidHistoricalReceiverData(converted.historicalReceiverData)) return undefined	19!
184
185	if (!(converted.signaturePrivateKey instanceof Uint8Array \|\| typeof converted.signaturePrivateKey === "object")) {	19!
186	return undefined	×
UNCOV 187	}	×
188	if (!(converted.confirmationTag instanceof Uint8Array \|\| typeof converted.confirmationTag === "object")) {	19!
189	return undefined	×
UNCOV 190	}	×
191
192	// Reconstruct Map<bigint, EpochReceiverData>
193	const historicalReceiverData = new Map<bigint, EpochReceiverData>()	19✔
194	if (Array.isArray(converted.historicalReceiverData)) {	19✔
195	for (const [keyObj, data] of converted.historicalReceiverData as [unknown, unknown][]) {	19!
196	if (keyObj && typeof keyObj === "object" && "epoch" in keyObj) {	×
197	const keyObjRecord = keyObj as Record<string, unknown>	×
198	if (typeof keyObjRecord.epoch === "bigint") {	×
199	historicalReceiverData.set(keyObjRecord.epoch, data as EpochReceiverData)	×
200	}	×
201	}	×
UNCOV 202	}	×
203	}	19✔
204
205	return { clientConfig: config, ...converted, historicalReceiverData } as unknown as ClientState	19✔
206	} catch {	19!
207	return undefined	×
UNCOV 208	}	×
209	}	19✔

LukaJCB / ts-mls / 20546506344

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