@calimero-network/mero-js 21.3.0 → 21.4.1

package/dist/index.cjs

@@ -25,6 +25,7 @@ __export(index_exports, {
   CAPABILITIES: () => CAPABILITIES,
   CloudClient: () => CloudClient,
   DEFAULT_LOCAL_NODE_PORTS: () => DEFAULT_LOCAL_NODE_PORTS,
+  DEFAULT_RELEASE_MIRROR: () => DEFAULT_RELEASE_MIRROR,
   EphemeralClient: () => EphemeralClient,
   HANDSHAKE_PATH: () => HANDSHAKE_PATH,
   HTTPError: () => HTTPError,
@@ -32,6 +33,7 @@ __export(index_exports, {
   LocalStorageTokenStore: () => LocalStorageTokenStore,
   MemoryTokenStore: () => MemoryTokenStore,
   MeroJs: () => MeroJs,
+  NODE_RELEASE_SIGNER: () => NODE_RELEASE_SIGNER,
   RelayClient: () => RelayClient,
   RpcClient: () => RpcClient,
   RpcError: () => RpcError,
@@ -50,6 +52,7 @@ __export(index_exports, {
   buildAuthLoginUrl: () => buildAuthLoginUrl,
   callerProof: () => callerProof,
   classifyError: () => classifyError,
+  cloudNodeReleaseUrl: () => cloudNodeReleaseUrl,
   combineSignals: () => combineSignals,
   compareSemver: () => compareSemver,
   connectCloud: () => connectCloud,
@@ -72,12 +75,16 @@ __export(index_exports, {
   createQuoteVerifier: () => createQuoteVerifier,
   createRetryableMethod: () => createRetryableMethod,
   createSealedFetch: () => createSealedFetch,
+  createSignedReleaseSealedFetch: () => createSignedReleaseSealedFetch,
+  createSignedReleaseVerifier: () => createSignedReleaseVerifier,
   createTimeoutSignal: () => createTimeoutSignal,
   createUniversalHttpClient: () => createUniversalHttpClient,
   deviceCertPayload: () => deviceCertPayload,
   discoverLocalNodes: () => discoverLocalNodes,
   encodeSignedInvitation: () => encodeSignedInvitation,
   fetchAttestedTransportKey: () => fetchAttestedTransportKey,
+  fetchNodeRelease: () => fetchNodeRelease,
+  fetchNodeReleaseVersion: () => fetchNodeReleaseVersion,
   generateAccountRoot: () => generateAccountRoot,
   generateSessionKey: () => generateSessionKey,
   hasCap: () => hasCap,
@@ -89,6 +96,7 @@ __export(index_exports, {
   login: () => login,
   mintDeviceId: () => mintDeviceId,
   nodeEndpoint: () => nodeEndpoint,
+  nodeReleaseVersionFromImage: () => nodeReleaseVersionFromImage,
   parseAuthCallback: () => parseAuthCallback,
   probeNodeHealth: () => probeNodeHealth,
   redeemInvitation: () => redeemInvitation,
@@ -104,7 +112,9 @@ __export(index_exports, {
   signRoutingChallenge: () => signRoutingChallenge,
   signWarrant: () => signWarrant,
   transportKeyBinding: () => transportKeyBinding,
+  trustSignedRelease: () => trustSignedRelease,
   trustedMeasurementsFromReleases: () => trustedMeasurementsFromReleases,
+  verifySignedNodeRelease: () => verifySignedNodeRelease,
   withCap: () => withCap,
   withRetry: () => withRetry,
   withoutCap: () => withoutCap
@@ -7489,8 +7499,525 @@ function tcbStatus(status, release) {
   return known;
 }
 
+// src/sealed/sigstore-trust-root.ts
+var FULCIO_AUTHORITIES = [
+  {
+    uri: "https://fulcio.sigstore.dev",
+    validFor: { start: "2021-03-07T03:20:29Z", end: "2022-12-31T23:59:59.999Z" },
+    certChain: [
+      "MIIB+DCCAX6gAwIBAgITNVkDZoCiofPDsy7dfm6geLbuhzAKBggqhkjOPQQDAzAqMRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxETAPBgNVBAMTCHNpZ3N0b3JlMB4XDTIxMDMwNzAzMjAyOVoXDTMxMDIyMzAzMjAyOVowKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABLSyA7Ii5k+pNO8ZEWY0ylemWDowOkNa3kL+GZE5Z5GWehL9/A9bRNA3RbrsZ5i0JcastaRL7Sp5fp/jD5dxqc/UdTVnlvS16an+2Yfswe/QuLolRUCrcOE2+2iA5+tzd6NmMGQwDgYDVR0PAQH/BAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQEwHQYDVR0OBBYEFMjFHQBBmiQpMlEk6w2uSu1KBtPsMB8GA1UdIwQYMBaAFMjFHQBBmiQpMlEk6w2uSu1KBtPsMAoGCCqGSM49BAMDA2gAMGUCMH8liWJfMui6vXXBhjDgY4MwslmN/TJxVe/83WrFomwmNf056y1X48F9c4m3a3ozXAIxAKjRay5/aj/jsKKGIkmQatjI8uupHr/+CxFvaJWmpYqNkLDGRU+9orzh5hI2RrcuaQ=="
+    ]
+  },
+  {
+    uri: "https://fulcio.sigstore.dev",
+    validFor: { start: "2022-04-13T20:06:15Z" },
+    certChain: [
+      "MIICGjCCAaGgAwIBAgIUALnViVfnU0brJasmRkHrn/UnfaQwCgYIKoZIzj0EAwMwKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTAeFw0yMjA0MTMyMDA2MTVaFw0zMTEwMDUxMzU2NThaMDcxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEeMBwGA1UEAxMVc2lnc3RvcmUtaW50ZXJtZWRpYXRlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE8RVS/ysH+NOvuDZyPIZtilgUF9NlarYpAd9HP1vBBH1U5CV77LSS7s0ZiH4nE7Hv7ptS6LvvR/STk798LVgMzLlJ4HeIfF3tHSaexLcYpSASr1kS0N/RgBJz/9jWCiXno3sweTAOBgNVHQ8BAf8EBAMCAQYwEwYDVR0lBAwwCgYIKwYBBQUHAwMwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU39Ppz1YkEZb5qNjpKFWixi4YZD8wHwYDVR0jBBgwFoAUWMAeX5FFpWapesyQoZMi0CrFxfowCgYIKoZIzj0EAwMDZwAwZAIwPCsQK4DYiZYDPIaDi5HFKnfxXx6ASSVmERfsynYBiX2X6SJRnZU84/9DZdnFvvxmAjBOt6QpBlc4J/0DxvkTCqpclvziL6BCCPnjdlIB3Pu3BxsPmygUY7Ii2zbdCdliiow=",
+      "MIIB9zCCAXygAwIBAgIUALZNAPFdxHPwjeDloDwyYChAO/4wCgYIKoZIzj0EAwMwKjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MREwDwYDVQQDEwhzaWdzdG9yZTAeFw0yMTEwMDcxMzU2NTlaFw0zMTEwMDUxMzU2NThaMCoxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjERMA8GA1UEAxMIc2lnc3RvcmUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAT7XeFT4rb3PQGwS4IajtLk3/OlnpgangaBclYpsYBr5i+4ynB07ceb3LP0OIOZdxexX69c5iVuyJRQ+Hz05yi+UF3uBWAlHpiS5sh0+H2GHE7SXrk1EC5m1Tr19L9gg92jYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRYwB5fkUWlZql6zJChkyLQKsXF+jAfBgNVHSMEGDAWgBRYwB5fkUWlZql6zJChkyLQKsXF+jAKBggqhkjOPQQDAwNpADBmAjEAj1nHeXZp+13NWBNa+EDsDP8G1WWg1tCMWP/WHPqpaVo0jhsweNFZgSs0eE7wYI4qAjEA2WB9ot98sIkoF3vZYdd3/VtWB5b9TNMea7Ix/stJ5TfcLLeABLE4BNJOsQ4vnBHJ"
+    ]
+  }
+];
+var REKOR_LOGS = [
+  {
+    baseUrl: "https://rekor.sigstore.dev",
+    logId: "c0d23d6ad406973f9559f3ba2d1ca01f84147d8ffc5b8445c224f98b9591801d",
+    publicKey: "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE2G2Y+2tabdTV5BcGiBIx0a9fAFwrkBbmLSGtks4L3qX6yYY0zufBnhC8Ur/iy55GhWP/9A/bY2LhC30M9+RYtw==",
+    validFor: { start: "2021-01-12T11:53:27Z" }
+  }
+];
+
+// src/sealed/x509.ts
+var SEQUENCE = 48;
+var OID = 6;
+var INTEGER = 2;
+var BIT_STRING = 3;
+var OCTET_STRING = 4;
+var BOOLEAN = 1;
+var UTC_TIME = 23;
+var GENERALIZED_TIME = 24;
+var CONTEXT_0 = 160;
+var CONTEXT_3 = 163;
+var EC_PUBLIC_KEY = "1.2.840.10045.2.1";
+var CURVES = {
+  "1.2.840.10045.3.1.7": "P-256",
+  "1.3.132.0.34": "P-384"
+};
+var CURVE_SIZE = { "P-256": 32, "P-384": 48 };
+var SIGNATURE_HASHES = {
+  "1.2.840.10045.4.3.2": "SHA-256",
+  "1.2.840.10045.4.3.3": "SHA-384"
+};
+function read(bytes, offset, limit) {
+  if (offset + 2 > limit) throw new Error("it is truncated");
+  const tag = bytes[offset];
+  if ((tag & 31) === 31) throw new Error("it uses a tag this parser does not read");
+  let length = bytes[offset + 1];
+  let start = offset + 2;
+  if (length & 128) {
+    const count = length & 127;
+    if (count === 0 || count > 4 || start + count > limit) throw new Error("it has a length this parser does not read");
+    length = 0;
+    for (let i = 0; i < count; i += 1) length = length * 256 + bytes[start + i];
+    start += count;
+  }
+  const end = start + length;
+  if (end > limit) throw new Error("it is truncated");
+  return { tag, bytes, offset, start, end };
+}
+function parseDer(bytes) {
+  const element = read(bytes, 0, bytes.length);
+  if (element.end !== bytes.length) throw new Error("it has trailing bytes");
+  return element;
+}
+function children(element) {
+  const out = [];
+  for (let offset = element.start; offset < element.end; ) {
+    const child = read(element.bytes, offset, element.end);
+    out.push(child);
+    offset = child.end;
+  }
+  return out;
+}
+function expectTag(element, tag, what) {
+  if (!element || element.tag !== tag) throw new Error(`${what} is not where it should be`);
+  return element;
+}
+function contents(element) {
+  return element.bytes.slice(element.start, element.end);
+}
+function whole(element) {
+  return element.bytes.slice(element.offset, element.end);
+}
+function oid(element) {
+  const value = contents(expectTag(element, OID, "An object identifier"));
+  if (value.length === 0 || value[value.length - 1] & 128) throw new Error("it has a malformed object identifier");
+  const arcs = [];
+  let arc = 0;
+  for (const byte of value) {
+    arc = arc * 128 + (byte & 127);
+    if (!(byte & 128)) {
+      arcs.push(arc);
+      arc = 0;
+    }
+  }
+  const first = arcs.shift();
+  const head = first < 80 ? [Math.floor(first / 40), first % 40] : [2, first - 80];
+  return [...head, ...arcs].join(".");
+}
+function time(element) {
+  const text = new TextDecoder().decode(contents(element));
+  const utc = element.tag === UTC_TIME ? /^(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z$/.exec(text) : null;
+  const generalized = element.tag === GENERALIZED_TIME ? /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})Z$/.exec(text) : null;
+  const parts = utc ?? generalized;
+  if (!parts) throw new Error(`it holds the time ${JSON.stringify(text)}, which is not one a certificate may hold`);
+  let year = Number(parts[1]);
+  if (utc) year += year < 50 ? 2e3 : 1900;
+  const [month, day, hour, minute, second] = parts.slice(2).map(Number);
+  return Date.UTC(year, month - 1, day, hour, minute, second);
+}
+function parseCertificate(der) {
+  try {
+    const [tbsElement, algorithm, signature, ...rest] = children(
+      expectTag(parseDer(der), SEQUENCE, "The certificate")
+    );
+    if (rest.length > 0) throw new Error("it has fields after its signature");
+    const fields = children(expectTag(tbsElement, SEQUENCE, "The signed part"));
+    const first = fields[0]?.tag === CONTEXT_0 ? 1 : 0;
+    const [serial, innerAlgorithm, issuer, validity, subject, spki, ...optional] = fields.slice(first);
+    expectTag(serial, INTEGER, "The serial number");
+    const algorithmId = oid(children(expectTag(algorithm, SEQUENCE, "The signature algorithm"))[0]);
+    const innerId = oid(children(expectTag(innerAlgorithm, SEQUENCE, "The signature algorithm"))[0]);
+    if (innerId !== algorithmId) throw new Error("it names two different signature algorithms");
+    const signatureHash = SIGNATURE_HASHES[algorithmId];
+    if (!signatureHash) throw new Error(`it is signed with ${algorithmId}, not ECDSA with SHA-256 or SHA-384`);
+    const [notBefore, notAfter] = children(expectTag(validity, SEQUENCE, "The validity")).map(time);
+    if (notAfter === void 0) throw new Error("its validity is incomplete");
+    const [keyAlgorithm, keyBits] = children(expectTag(spki, SEQUENCE, "The public key"));
+    expectTag(keyBits, BIT_STRING, "The public key");
+    const [keyType, keyCurve] = children(expectTag(keyAlgorithm, SEQUENCE, "The key algorithm"));
+    if (oid(keyType) !== EC_PUBLIC_KEY) throw new Error("its key is not an elliptic-curve key");
+    const curve = CURVES[oid(keyCurve)];
+    if (!curve) throw new Error("its key is on a curve other than P-256 or P-384");
+    const extensions = /* @__PURE__ */ new Map();
+    const extensionsField = optional.find((field) => field.tag === CONTEXT_3);
+    if (extensionsField) {
+      const [list] = children(extensionsField);
+      for (const extension of children(expectTag(list, SEQUENCE, "The extensions"))) {
+        const parts = children(expectTag(extension, SEQUENCE, "An extension"));
+        if (parts.length === 3) expectTag(parts[1], BOOLEAN, "An extension's critical flag");
+        else if (parts.length !== 2) throw new Error("it has a malformed extension");
+        const id = oid(parts[0]);
+        if (extensions.has(id)) throw new Error(`it has extension ${id} twice`);
+        extensions.set(id, contents(expectTag(parts[parts.length - 1], OCTET_STRING, "An extension value")));
+      }
+    }
+    const signatureBits = contents(expectTag(signature, BIT_STRING, "The signature"));
+    if (signatureBits[0] !== 0) throw new Error("its signature is not a whole number of bytes");
+    return {
+      der,
+      tbs: whole(tbsElement),
+      signatureHash,
+      signature: signatureBits.slice(1),
+      issuer: whole(expectTag(issuer, SEQUENCE, "The issuer")),
+      subject: whole(expectTag(subject, SEQUENCE, "The subject")),
+      notBefore,
+      notAfter,
+      spki: whole(spki),
+      curve,
+      extensions
+    };
+  } catch (error) {
+    throw new Error(`The certificate is malformed: ${error.message}`);
+  }
+}
+function objectIdentifiers(der) {
+  return children(expectTag(parseDer(der), SEQUENCE, "The list")).map(oid);
+}
+function ecdsaSignatureToP1363(der, curve) {
+  const size = CURVE_SIZE[curve];
+  const integers = children(expectTag(parseDer(der), SEQUENCE, "The signature"));
+  if (integers.length !== 2) throw new Error("The signature is not an ECDSA signature");
+  const out = new Uint8Array(size * 2);
+  integers.forEach((integer, index) => {
+    let value = contents(expectTag(integer, INTEGER, "The signature"));
+    if (value.length === 0 || value[0] & 128) throw new Error("The signature is not an ECDSA signature");
+    while (value.length > 1 && value[0] === 0) value = value.subarray(1);
+    if (value.length > size) throw new Error("The signature is not an ECDSA signature");
+    out.set(value, index * size + size - value.length);
+  });
+  return out;
+}
+async function verifyEcdsa(spki, curve, hash, signature, data) {
+  let p1363;
+  try {
+    p1363 = ecdsaSignatureToP1363(signature, curve);
+  } catch {
+    return false;
+  }
+  const key = await crypto.subtle.importKey("spki", spki, { name: "ECDSA", namedCurve: curve }, false, ["verify"]);
+  return crypto.subtle.verify({ name: "ECDSA", hash }, key, p1363, data);
+}
+function fromBase642(value, what) {
+  const clean = value.replace(/\s+/g, "");
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(clean) || clean.length % 4 !== 0) {
+    throw new Error(`${what} is not base64`);
+  }
+  const binary = atob(clean);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function pemCertificate(pem, what) {
+  const blocks = [...pem.matchAll(/-----BEGIN CERTIFICATE-----([^-]*)-----END CERTIFICATE-----/g)];
+  if (blocks.length !== 1 || pem.replace(blocks[0][0], "").trim() !== "") {
+    throw new Error(`${what} is not exactly one PEM certificate`);
+  }
+  return fromBase642(blocks[0][1], what);
+}
+
+// src/sealed/sigstore.ts
+var SUBJECT_ALT_NAME = "2.5.29.17";
+var EXTENDED_KEY_USAGE = "2.5.29.37";
+var CODE_SIGNING = "1.3.6.1.5.5.7.3.3";
+var FULCIO_ISSUER_V2 = "1.3.6.1.4.1.57264.1.8";
+var FULCIO_ISSUER_V1 = "1.3.6.1.4.1.57264.1.1";
+var SAN_URI = 134;
+var UTF8_STRING = 12;
+var SEQUENCE2 = 48;
+var utf82 = new TextEncoder();
+var fromUtf8 = (bytes) => new TextDecoder().decode(bytes);
+async function verifyCosignBundle(body, bundle, signer, signature) {
+  const { base64Signature, cert, rekorBundle } = cosignBundle(bundle);
+  const payload = rekorBundle.Payload;
+  if (signature !== void 0 && signature.trim() !== base64Signature.trim()) {
+    throw new Error("The detached signature is not the one in the bundle");
+  }
+  const sig = fromBase642(base64Signature, "The bundle signature");
+  const leafDer = pemCertificate(fromUtf8(fromBase642(cert, "The bundle certificate")), "The bundle certificate");
+  const leaf = parseCertificate(leafDer);
+  const log = REKOR_LOGS.find((candidate) => candidate.logId === payload.logID.toLowerCase());
+  if (!log) throw new Error(`The bundle names Rekor log ${payload.logID}, which the Sigstore trust root does not know`);
+  const canonical = utf82.encode(
+    `{"body":${JSON.stringify(payload.body)},"integratedTime":${payload.integratedTime},"logID":${JSON.stringify(payload.logID)},"logIndex":${payload.logIndex}}`
+  );
+  const setVerifies = await verifyEcdsa(
+    fromBase642(log.publicKey, "The Rekor key"),
+    "P-256",
+    "SHA-256",
+    fromBase642(rekorBundle.SignedEntryTimestamp, "The signed entry timestamp"),
+    canonical
+  );
+  if (!setVerifies) {
+    throw new Error("Rekor's signed entry timestamp does not verify: the log entry, its time or its index was altered");
+  }
+  const at = payload.integratedTime * 1e3;
+  if (!within(at, log.validFor)) {
+    throw new Error(`Rekor log ${log.baseUrl} was not in use at ${iso(at)}, when the entry says it was logged`);
+  }
+  const entry = hashedRekord(payload.body);
+  const digest = hex(new Uint8Array(await crypto.subtle.digest("SHA-256", body)));
+  if (entry.hash !== digest) throw new Error("The file's SHA-256 is not the one Rekor logged: the file is not the one signed");
+  if (!equal(fromBase642(entry.signature, "The logged signature"), sig)) {
+    throw new Error("The bundle's signature is not the one Rekor logged");
+  }
+  const loggedCert = pemCertificate(fromUtf8(fromBase642(entry.publicKey, "The logged certificate")), "The logged certificate");
+  if (!equal(loggedCert, leafDer)) throw new Error("The bundle's certificate is not the one Rekor logged");
+  if (leaf.curve !== "P-256" || !await verifyEcdsa(leaf.spki, "P-256", "SHA-256", sig, body)) {
+    throw new Error("The signature over the file does not verify with the bundle's certificate");
+  }
+  await chainsToFulcio(leaf, at);
+  checkSigner(leaf, signer);
+  return { integratedTime: payload.integratedTime };
+}
+async function chainsToFulcio(leaf, at) {
+  if (!validAt(leaf, at)) {
+    throw new Error(
+      `The signing certificate was valid ${iso(leaf.notBefore)} to ${iso(leaf.notAfter)}, not at ${iso(at)} when Rekor logged it`
+    );
+  }
+  const reasons = [];
+  for (const authority of FULCIO_AUTHORITIES) {
+    const chain = authority.certChain.map((der) => parseCertificate(fromBase642(der, "A Fulcio certificate")));
+    if (!await issuedBy(leaf, chain[0])) continue;
+    const reason = await authorityRefusal(chain, authority.validFor, at);
+    if (!reason) return;
+    reasons.push(`${authority.uri} (valid from ${authority.validFor.start}): ${reason}`);
+  }
+  throw new Error(
+    reasons.length > 0 ? `The signing certificate's CA is not trusted at ${iso(at)}: ${reasons.join("; ")}` : "The signing certificate was not issued by a Fulcio CA in the Sigstore trust root"
+  );
+}
+async function authorityRefusal(chain, validFor, at) {
+  if (!within(at, validFor)) return "the trust root says it was not issuing certificates then";
+  for (const [index, certificate] of chain.entries()) {
+    if (!validAt(certificate, at)) return `its certificate ${index} was not valid then`;
+    const parent = chain[index + 1] ?? certificate;
+    if (!await issuedBy(certificate, parent)) return `its certificate ${index} is not signed by the next`;
+  }
+  return void 0;
+}
+async function issuedBy(child, parent) {
+  if (!equal(child.issuer, parent.subject)) return false;
+  return verifyEcdsa(parent.spki, parent.curve, child.signatureHash, child.signature, child.tbs);
+}
+function checkSigner(leaf, signer) {
+  const san = leaf.extensions.get(SUBJECT_ALT_NAME);
+  if (!san) throw new Error("The signing certificate names no identity");
+  const names = children(expectTag(parseDer(san), SEQUENCE2, "The subject alternative name"));
+  const uris = names.filter((name) => name.tag === SAN_URI).map((name) => fromUtf8(contents(name)));
+  if (uris.length !== 1 || names.length !== 1 || uris[0] !== signer.identity) {
+    throw new Error(
+      `The release was signed by ${JSON.stringify(uris.length === 1 ? uris[0] : uris)}, not by ${signer.identity}`
+    );
+  }
+  const v2 = leaf.extensions.get(FULCIO_ISSUER_V2);
+  const v1 = leaf.extensions.get(FULCIO_ISSUER_V1);
+  const issuer = v2 ? fromUtf8(contents(expectTag(parseDer(v2), UTF8_STRING, "The OIDC issuer"))) : v1 ? fromUtf8(v1) : void 0;
+  if (issuer !== signer.issuer) {
+    throw new Error(
+      `The signing certificate's OIDC issuer is ${issuer === void 0 ? "missing" : JSON.stringify(issuer)}, not ${signer.issuer}`
+    );
+  }
+  const usage = leaf.extensions.get(EXTENDED_KEY_USAGE);
+  if (!usage || !objectIdentifiers(usage).includes(CODE_SIGNING)) {
+    throw new Error("The signing certificate is not for code signing");
+  }
+}
+function cosignBundle(value) {
+  let bundle = value;
+  if (typeof bundle === "string") {
+    try {
+      bundle = JSON.parse(bundle);
+    } catch {
+      throw new Error("The bundle is not JSON");
+    }
+  }
+  const b = bundle;
+  const p = b?.rekorBundle?.Payload;
+  const ok = typeof b?.base64Signature === "string" && typeof b.cert === "string" && typeof b.rekorBundle?.SignedEntryTimestamp === "string" && typeof p?.body === "string" && typeof p.logID === "string" && /^[0-9a-fA-F]{64}$/.test(p.logID) && Number.isSafeInteger(p.integratedTime) && p.integratedTime >= 0 && Number.isSafeInteger(p.logIndex) && p.logIndex >= 0;
+  if (!ok) throw new Error("The bundle is not a cosign bundle with a Rekor entry");
+  return b;
+}
+function hashedRekord(body) {
+  let entry;
+  try {
+    entry = JSON.parse(fromUtf8(fromBase642(body, "The logged entry")));
+  } catch {
+    throw new Error("The logged entry is not JSON");
+  }
+  const hash = entry?.spec?.data?.hash;
+  const signature = entry?.spec?.signature;
+  if (entry?.kind !== "hashedrekord" || hash?.algorithm !== "sha256" || typeof hash.value !== "string" || typeof signature?.content !== "string" || typeof signature.publicKey?.content !== "string") {
+    throw new Error("The logged entry is not a SHA-256 hashedrekord");
+  }
+  return { hash: hash.value.toLowerCase(), signature: signature.content, publicKey: signature.publicKey.content };
+}
+function validAt(certificate, at) {
+  return certificate.notBefore <= at && at <= certificate.notAfter;
+}
+function within(at, window2) {
+  return Date.parse(window2.start) <= at && (window2.end === void 0 || at <= Date.parse(window2.end));
+}
+function iso(ms) {
+  return new Date(ms).toISOString();
+}
+function equal(a, b) {
+  return a.length === b.length && a.every((byte, index) => byte === b[index]);
+}
+
+// src/sealed/release.ts
+var NODE_RELEASE_SIGNER = Object.freeze({
+  identity: "https://github.com/calimero-network/mero-tee/.github/workflows/release-node-image-gcp.yaml@refs/heads/master",
+  issuer: "https://token.actions.githubusercontent.com"
+});
+var MEASUREMENTS = ["mrtd", "rtmr0", "rtmr1", "rtmr2", "rtmr3"];
+var DEFAULT_RELEASE_MIRROR = "https://cloud.calimero.network";
+async function verifySignedNodeRelease(publishedMrtds, bundle, options = {}) {
+  const body = typeof publishedMrtds === "string" ? new TextEncoder().encode(publishedMrtds) : publishedMrtds;
+  await verifyCosignBundle(
+    body,
+    bundle,
+    {
+      identity: options.identity ?? NODE_RELEASE_SIGNER.identity,
+      issuer: options.issuer ?? NODE_RELEASE_SIGNER.issuer
+    },
+    options.signature
+  );
+  let release;
+  try {
+    release = JSON.parse(new TextDecoder().decode(body));
+  } catch {
+    throw new Error("The signed release is not JSON");
+  }
+  if (release?.role !== "node") {
+    throw new Error(`The signed release is a ${JSON.stringify(release?.role)} release, not a node one`);
+  }
+  const profiles = Object.values(release.profiles ?? {});
+  const measured = (image) => MEASUREMENTS.every((register) => /^[0-9a-f]{96}$/i.test(String(image?.[register])));
+  if (typeof release.tag !== "string" || profiles.length === 0 || !profiles.every(measured)) {
+    throw new Error("The signed file is not a release's published-mrtds.json: it lists no measured profiles");
+  }
+  if (options.expectedVersion !== void 0 && release.tag !== options.expectedVersion) {
+    throw new Error(`The signed release is ${release.tag}, not ${options.expectedVersion}`);
+  }
+  return release;
+}
+async function fetchNodeRelease(url, options = {}) {
+  const response = await (options.fetch ?? fetch)(url, { headers: { accept: "application/json" } });
+  if (!response.ok) throw new Error(`Fetching the node release from ${url} failed: HTTP ${response.status}`);
+  let release;
+  try {
+    release = (await response.json())?.data;
+  } catch {
+    throw new Error(`${url} did not answer with JSON`);
+  }
+  if (typeof release?.version !== "string" || typeof release.publishedMrtds !== "string" || typeof release.bundle !== "string") {
+    throw new Error(`${url} did not answer with a signed node release`);
+  }
+  return { version: release.version, publishedMrtds: release.publishedMrtds, bundle: release.bundle };
+}
+function nodeReleaseVersionFromImage(osImage) {
+  const match = /^merotee-.+-(\d+)-(\d+)-(\d+)$/.exec(osImage);
+  if (!match) throw new Error(`${JSON.stringify(osImage)} is not the image of a mero-tee node release`);
+  return `${Number(match[1])}.${Number(match[2])}.${Number(match[3])}`;
+}
+async function fetchNodeReleaseVersion(baseUrl, options = {}) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/admin-api/tee/info`;
+  const response = await (options.fetch ?? fetch)(url, { headers: { accept: "application/json" } });
+  if (!response.ok) throw new Error(`Fetching ${url} failed: HTTP ${response.status}`);
+  let osImage;
+  try {
+    osImage = (await response.json())?.data?.osImage;
+  } catch {
+    throw new Error(`${url} did not answer with JSON`);
+  }
+  if (typeof osImage !== "string") throw new Error(`${url} did not name the node's image`);
+  return nodeReleaseVersionFromImage(osImage);
+}
+function cloudNodeReleaseUrl(cloudUrl, version) {
+  return `${cloudUrl.replace(/\/+$/, "")}/api/tee/node-releases/${releaseVersion(version, "version")}`;
+}
+async function trustSignedRelease(options) {
+  const minimum = releaseVersion(options.minReleaseVersion, "minReleaseVersion");
+  const version = releaseVersion(options.release?.version, "The release version");
+  const published = await verifySignedNodeRelease(options.release.publishedMrtds, options.release.bundle, {
+    expectedVersion: version,
+    identity: options.identity,
+    issuer: options.issuer
+  });
+  if (compareReleaseVersions(version, minimum) < 0) {
+    throw new Error(`Release ${version} is older than the minimum trusted, ${minimum}`);
+  }
+  return trustedMeasurementsFromReleases([published], { profile: options.profile });
+}
+function createSignedReleaseVerifier(options) {
+  releaseVersion(options.minReleaseVersion, "minReleaseVersion");
+  const verifier = async (args) => {
+    const trusted = await trustSignedRelease({
+      release: await options.release(),
+      profile: options.profile,
+      minReleaseVersion: options.minReleaseVersion,
+      identity: options.identity,
+      issuer: options.issuer
+    });
+    return createQuoteVerifier({
+      dcapVerify: options.dcapVerify,
+      fetchCollateral: options.fetchCollateral,
+      now: options.now,
+      ...trusted
+    })(args);
+  };
+  return Object.assign(verifier, { includeCollateral: true });
+}
+function createSignedReleaseSealedFetch(options) {
+  const { baseUrl, releaseSource, applicationId, applicationHash, fetch: givenFetch, ...verifierOptions } = options;
+  const baseFetch = givenFetch ?? ((input, init) => fetch(input, init));
+  const release = async () => {
+    const version = await fetchNodeReleaseVersion(baseUrl, { fetch: baseFetch });
+    return typeof releaseSource === "function" ? releaseSource({ baseUrl, version, fetch: baseFetch }) : fetchNodeRelease(cloudNodeReleaseUrl(releaseSource ?? DEFAULT_RELEASE_MIRROR, version), { fetch: baseFetch });
+  };
+  return createAttestedSealedFetch({
+    baseUrl,
+    verify: createSignedReleaseVerifier({ ...verifierOptions, release }),
+    applicationId,
+    applicationHash,
+    fetch: baseFetch
+  });
+}
+var RELEASE_VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function releaseVersion(value, what) {
+  const match = typeof value === "string" ? RELEASE_VERSION.exec(value) : null;
+  const pre = match?.[4];
+  if (!match || pre !== void 0 && pre.split(".").some((id) => id === "")) {
+    throw new Error(`${what} is ${JSON.stringify(value)}, not a release version like 2.3.87`);
+  }
+  return value;
+}
+function compareReleaseVersions(a, b) {
+  const [aCore, aPre] = splitVersion2(a);
+  const [bCore, bPre] = splitVersion2(b);
+  for (let i = 0; i < 3; i += 1) {
+    if (aCore[i] !== bCore[i]) return aCore[i] < bCore[i] ? -1 : 1;
+  }
+  if (aPre === void 0 || bPre === void 0) return aPre === bPre ? 0 : aPre === void 0 ? 1 : -1;
+  const aIds = aPre.split(".");
+  const bIds = bPre.split(".");
+  for (let i = 0; i < Math.max(aIds.length, bIds.length); i += 1) {
+    const [x, y] = [aIds[i], bIds[i]];
+    if (x === void 0 || y === void 0) return x === void 0 ? -1 : 1;
+    const [xNum, yNum] = [/^\d+$/.test(x), /^\d+$/.test(y)];
+    const order = xNum && yNum ? Math.sign(Number(x) - Number(y)) : xNum !== yNum ? xNum ? -1 : 1 : x < y ? -1 : x > y ? 1 : 0;
+    if (order !== 0) return order;
+  }
+  return 0;
+}
+function splitVersion2(version) {
+  const match = RELEASE_VERSION.exec(version);
+  return [[Number(match[1]), Number(match[2]), Number(match[3])], match[4]];
+}
+
 // src/namespace-op/namespace-op.ts
-var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 9;
+var SIGNED_NAMESPACE_OP_SCHEMA_VERSION = 11;
 var NAMESPACE_SIGN_DOMAIN = new TextEncoder().encode("calimero.namespace.v1");
 var NAMESPACE_OP_ROOT = 0;
 var ROOT_OP = {
@@ -7503,7 +8030,7 @@ var ROOT_OP = {
   KeyDelivery: 6,
   MemberJoinedOpen: 7,
   MemberJoinedAt: 8,
-  NamespaceCreated: 9,
+  NamespaceCreatedV2: 9,
   MemberJoinedViaTeeAttestation: 10
 };
 function bytes32(value, label) {