@tinycloud/sdk-core 3.2.1 → 3.2.3-beta.0

package/dist/index.cjs

@@ -408,6 +408,7 @@ __export(index_exports, {
   parseShareArtifact: () => parseShareArtifact,
   parseShareUrl: () => parseShareUrl,
   parseSignedCompactUcanAttenuation: () => parseSignedCompactUcanAttenuation,
+  parseSignedSiweCacao: () => parseSignedSiweCacao,
   parseSpaceUri: () => parseSpaceUri,
   parseStorageRejection: () => import_sdk_services9.parseStorageRejection,
   parseStorageStatus: () => import_sdk_services9.parseStorageStatus,
@@ -1545,12 +1546,12 @@ var Decoder = class {
     this.prefixCodePoint = prefixCodePoint;
     this.baseDecode = baseDecode;
   }
-  decode(text2) {
-    if (typeof text2 === "string") {
-      if (text2.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text2)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+  decode(text3) {
+    if (typeof text3 === "string") {
+      if (text3.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text3)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
       }
-      return this.baseDecode(text2.slice(this.prefix.length));
+      return this.baseDecode(text3.slice(this.prefix.length));
     } else {
       throw Error("Can only multibase decode strings");
     }
@@ -1614,7 +1615,7 @@ function baseX({ name: name2, prefix, alphabet: alphabet2 }) {
     prefix,
     name: name2,
     encode: encode5,
-    decode: (text2) => coerce(decode7(text2))
+    decode: (text3) => coerce(decode7(text3))
   });
 }
 function decode(string2, alphabetIdx, bitsPerChar, name2) {
@@ -4719,7 +4720,7 @@ function parseSignedCompactUcanAttenuation(input, expectedCid) {
     throw new Error("compact UCAN signed audience is missing");
   const cid2 = CID.createV1(85, create(30, (0, import_blake3.blake3)(new TextEncoder().encode(input)))).toString();
   if (expectedCid !== void 0 && cid2 !== expectedCid) throw new Error("compact UCAN CID does not match exact Authorization bytes");
-  return { cid: cid2, payload: { att, aud: payloadValue.aud } };
+  return { cid: cid2, payload: { att, aud: payloadValue.aud, iss: payloadValue.iss } };
 }
 function parsePolicySessionUcan(authorization, expectedProofs) {
   const parsed = parseCompactUcanAuthorization(authorization);
@@ -4888,9 +4889,9 @@ function policyV2DigestHex(input) {
   );
 }
 function date(value, label) {
-  const text2 = nonEmpty(value, label);
-  if (!Number.isFinite(Date.parse(text2))) throw new Error(`${label} is invalid`);
-  return text2;
+  const text3 = nonEmpty(value, label);
+  if (!Number.isFinite(Date.parse(text3))) throw new Error(`${label} is invalid`);
+  return text3;
 }
 function rfc3339Seconds2(value) {
   return new Date(Math.floor(value.getTime() / 1e3) * 1e3).toISOString().replace(/\.000Z$/, "Z");
@@ -8843,64 +8844,64 @@ function canonicalJson(value) {
   }
   throw new ShareEnvelopeError("invalid-envelope", "unsupported JSON value");
 }
-function skipWhitespace(text2, start) {
+function skipWhitespace(text3, start) {
   let index = start;
-  while (/\s/.test(text2[index] ?? "")) index += 1;
+  while (/\s/.test(text3[index] ?? "")) index += 1;
   return index;
 }
-function scanJsonValue(text2, start) {
-  let index = skipWhitespace(text2, start);
-  const first = text2[index];
+function scanJsonValue(text3, start) {
+  let index = skipWhitespace(text3, start);
+  const first = text3[index];
   if (first === '"') {
     index += 1;
-    while (index < text2.length) {
-      if (text2[index] === "\\") index += 2;
-      else if (text2[index++] === '"') return index;
+    while (index < text3.length) {
+      if (text3[index] === "\\") index += 2;
+      else if (text3[index++] === '"') return index;
     }
     throw new ShareEnvelopeError("invalid-envelope", "unterminated JSON string");
   }
   if (first === "{") {
     const keys = /* @__PURE__ */ new Set();
-    index = skipWhitespace(text2, index + 1);
-    if (text2[index] === "}") return index + 1;
-    while (index < text2.length) {
-      index = skipWhitespace(text2, index);
-      if (text2[index] !== '"') throw new ShareEnvelopeError("invalid-envelope", "object key must be a string");
+    index = skipWhitespace(text3, index + 1);
+    if (text3[index] === "}") return index + 1;
+    while (index < text3.length) {
+      index = skipWhitespace(text3, index);
+      if (text3[index] !== '"') throw new ShareEnvelopeError("invalid-envelope", "object key must be a string");
       const keyStart = index;
-      index = scanJsonValue(text2, index);
-      const key = JSON.parse(text2.slice(keyStart, index));
+      index = scanJsonValue(text3, index);
+      const key = JSON.parse(text3.slice(keyStart, index));
       if (keys.has(key)) throw new ShareEnvelopeError("invalid-envelope", `duplicate JSON key ${key}`);
       keys.add(key);
-      index = skipWhitespace(text2, index);
-      if (text2[index++] !== ":") throw new ShareEnvelopeError("invalid-envelope", "missing object colon");
-      index = scanJsonValue(text2, index);
-      index = skipWhitespace(text2, index);
-      if (text2[index] === "}") return index + 1;
-      if (text2[index++] !== ",") throw new ShareEnvelopeError("invalid-envelope", "invalid object separator");
+      index = skipWhitespace(text3, index);
+      if (text3[index++] !== ":") throw new ShareEnvelopeError("invalid-envelope", "missing object colon");
+      index = scanJsonValue(text3, index);
+      index = skipWhitespace(text3, index);
+      if (text3[index] === "}") return index + 1;
+      if (text3[index++] !== ",") throw new ShareEnvelopeError("invalid-envelope", "invalid object separator");
     }
     throw new ShareEnvelopeError("invalid-envelope", "unterminated JSON object");
   }
   if (first === "[") {
-    index = skipWhitespace(text2, index + 1);
-    if (text2[index] === "]") return index + 1;
-    while (index < text2.length) {
-      index = scanJsonValue(text2, index);
-      index = skipWhitespace(text2, index);
-      if (text2[index] === "]") return index + 1;
-      if (text2[index++] !== ",") throw new ShareEnvelopeError("invalid-envelope", "invalid array separator");
+    index = skipWhitespace(text3, index + 1);
+    if (text3[index] === "]") return index + 1;
+    while (index < text3.length) {
+      index = scanJsonValue(text3, index);
+      index = skipWhitespace(text3, index);
+      if (text3[index] === "]") return index + 1;
+      if (text3[index++] !== ",") throw new ShareEnvelopeError("invalid-envelope", "invalid array separator");
     }
     throw new ShareEnvelopeError("invalid-envelope", "unterminated JSON array");
   }
-  const match = text2.slice(index).match(/^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/);
+  const match = text3.slice(index).match(/^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/);
   if (!match) throw new ShareEnvelopeError("invalid-envelope", "invalid JSON value");
   return index + match[0].length;
 }
-function parseCanonicalJson(text2) {
+function parseCanonicalJson(text3) {
   try {
-    const end = scanJsonValue(text2, 0);
-    if (skipWhitespace(text2, end) !== text2.length) throw new Error("trailing JSON");
-    const parsed = JSON.parse(text2);
-    if (canonicalJson(parsed) !== text2) throw new Error("non-canonical JSON");
+    const end = scanJsonValue(text3, 0);
+    if (skipWhitespace(text3, end) !== text3.length) throw new Error("trailing JSON");
+    const parsed = JSON.parse(text3);
+    if (canonicalJson(parsed) !== text3) throw new Error("non-canonical JSON");
     return parsed;
   } catch (error) {
     if (error instanceof ShareEnvelopeError) throw error;
@@ -12329,8 +12330,8 @@ async function createPolicyEnforcementDelegation(input) {
   return { cid: cid(dagCborBytes), dagCbor: b64(dagCborBytes), issuerDid: input.shareKey.did, audienceDid: input.enforcerDid, facts, signature };
 }
 async function canonicalOwnerSharePolicy(policy) {
-  const text2 = canonicalizeSignedObjectUnsigned({ domain: POLICY_DOMAIN, policy });
-  const policyBytes = new TextEncoder().encode(text2);
+  const text3 = canonicalizeSignedObjectUnsigned({ domain: POLICY_DOMAIN, policy });
+  const policyBytes = new TextEncoder().encode(text3);
   return { bytes: policyBytes, cid: cid(policyBytes), digest: digest3(policyBytes) };
 }
 function computeOwnerShareRegistrationCid(registration) {
@@ -12562,6 +12563,222 @@ var SenderShareStore = class {
 var import_share_sdk = require("@tinycloud/share-sdk");
 var import_share_sdk2 = require("@tinycloud/share-sdk");
 
+// src/delegations/cacao.ts
+var import_blake34 = require("@noble/hashes/blake3");
+var import_siwe2 = require("siwe");
+var import_viem5 = require("viem");
+var MAX_CACAO_BYTES = 64 * 1024;
+var MAX_CBOR_DEPTH = 64;
+var RECAP_PREFIX = "urn:recap:";
+var RECAP_STATEMENT = "I further authorize the stated URI to perform the following actions on my behalf:";
+function compareKeys(left, right) {
+  if (left.length !== right.length) return left.length - right.length;
+  for (let index = 0; index < left.length; index++) {
+    if (left[index] !== right[index]) return left[index] - right[index];
+  }
+  return 0;
+}
+function decodeDagCbor(bytes2) {
+  let offset = 0;
+  const view = new DataView(bytes2.buffer, bytes2.byteOffset, bytes2.byteLength);
+  const take = (length2) => {
+    if (length2 > bytes2.length - offset) throw new Error("CBOR input ended early");
+    return bytes2.subarray(offset, offset += length2);
+  };
+  const read2 = (depth) => {
+    if (depth > MAX_CBOR_DEPTH) throw new Error(`CBOR nesting exceeds ${MAX_CBOR_DEPTH} levels`);
+    const [initial] = take(1);
+    const major = initial >> 5;
+    const info = initial & 31;
+    if (major === 7) {
+      if (info === 20) return false;
+      if (info === 21) return true;
+      if (info === 22) return null;
+      throw new Error("CBOR floats and other simple values are not part of a CACAO");
+    }
+    if (major === 6) throw new Error("CBOR tags are not part of a CACAO");
+    let argument;
+    if (info < 24) argument = info;
+    else if (info === 24) argument = take(1)[0];
+    else if (info === 25) argument = view.getUint16(take(2).byteOffset - bytes2.byteOffset);
+    else if (info === 26) argument = view.getUint32(take(4).byteOffset - bytes2.byteOffset);
+    else if (info === 27) {
+      const value2 = view.getBigUint64(take(8).byteOffset - bytes2.byteOffset);
+      if (value2 > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("CBOR integer is too large");
+      argument = Number(value2);
+    } else throw new Error("CBOR indefinite lengths are not DAG-CBOR");
+    switch (major) {
+      case 0:
+        return argument;
+      case 1:
+        return -1 - argument;
+      case 2:
+        return take(argument).slice();
+      case 3:
+        return new TextDecoder("utf-8", { fatal: true }).decode(take(argument));
+      case 4: {
+        if (argument > bytes2.length - offset) throw new Error("CBOR input ended early");
+        const items = [];
+        for (let index = 0; index < argument; index++) items.push(read2(depth + 1));
+        return items;
+      }
+      default: {
+        if (argument > bytes2.length - offset) throw new Error("CBOR input ended early");
+        const map2 = /* @__PURE__ */ Object.create(null);
+        for (let index = 0; index < argument; index++) {
+          const key = read2(depth + 1);
+          if (typeof key !== "string") throw new Error("CBOR map keys must be strings");
+          if (key === "__proto__") throw new Error("CBOR map key __proto__ is not allowed");
+          if (Object.prototype.hasOwnProperty.call(map2, key)) throw new Error(`CBOR map has a duplicate key ${JSON.stringify(key)}`);
+          map2[key] = read2(depth + 1);
+        }
+        return map2;
+      }
+    }
+  };
+  const value = read2(0);
+  if (offset !== bytes2.length) throw new Error("CBOR input has trailing bytes");
+  return value;
+}
+function encodeDagCbor(value) {
+  const output = [];
+  const head = (major, argument) => {
+    if (argument < 24) output.push(major << 5 | argument);
+    else if (argument < 256) output.push(major << 5 | 24, argument);
+    else if (argument < 65536) output.push(major << 5 | 25, argument >> 8, argument & 255);
+    else if (argument < 4294967296) output.push(major << 5 | 26, ...[24, 16, 8, 0].map((shift) => argument >>> shift & 255));
+    else output.push(major << 5 | 27, ...[56n, 48n, 40n, 32n, 24n, 16n, 8n, 0n].map((shift) => Number(BigInt(argument) >> shift & 0xffn)));
+  };
+  const write = (item) => {
+    if (item === null) output.push(246);
+    else if (item === false) output.push(244);
+    else if (item === true) output.push(245);
+    else if (typeof item === "number" && Number.isSafeInteger(item)) {
+      if (item >= 0) head(0, item);
+      else head(1, -1 - item);
+    } else if (typeof item === "string") {
+      const encoded = new TextEncoder().encode(item);
+      head(3, encoded.length);
+      output.push(...encoded);
+    } else if (item instanceof Uint8Array) {
+      head(2, item.length);
+      output.push(...item);
+    } else if (Array.isArray(item)) {
+      head(4, item.length);
+      item.forEach(write);
+    } else if (typeof item === "object") {
+      const entries = Object.keys(item).map((key) => [new TextEncoder().encode(key), item[key]]);
+      entries.sort(([left], [right]) => compareKeys(left, right));
+      head(5, entries.length);
+      for (const [key, entry] of entries) {
+        head(3, key.length);
+        output.push(...key);
+        write(entry);
+      }
+    } else throw new Error("value is not DAG-CBOR encodable");
+  };
+  write(value);
+  return Uint8Array.from(output);
+}
+function map(value, label, keys, optional = []) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Uint8Array) throw new Error(`CACAO ${label} must be a map`);
+  const entries = value;
+  for (const key of Object.keys(entries)) {
+    if (!keys.includes(key) && !optional.includes(key)) throw new Error(`CACAO ${label} has unknown field ${JSON.stringify(key)}`);
+  }
+  for (const key of keys) if (!(key in entries)) throw new Error(`CACAO ${label} is missing ${key}`);
+  return entries;
+}
+function text2(value, label) {
+  if (typeof value !== "string" || value.length === 0) throw new Error(`CACAO ${label} must be a non-empty string`);
+  return value;
+}
+function reCapStatement(attenuation) {
+  var _a3;
+  let index = 0;
+  let lines = "";
+  for (const resource of Object.keys(attenuation).sort()) {
+    const namespaces = /* @__PURE__ */ Object.create(null);
+    for (const ability of Object.keys(attenuation[resource]).sort()) {
+      const slash = ability.indexOf("/");
+      if (slash <= 0) throw new Error("ReCap ability must be namespace/name");
+      (namespaces[_a3 = ability.slice(0, slash)] ?? (namespaces[_a3] = [])).push(ability.slice(slash + 1));
+    }
+    for (const namespace of Object.keys(namespaces).sort()) {
+      lines += ` (${++index}) '${namespace}': ${namespaces[namespace].map((name2) => `'${name2}'`).join(", ")} for '${resource}'.`;
+    }
+  }
+  return `${RECAP_STATEMENT}${lines}`;
+}
+function reCapAttenuation(resource) {
+  const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(decodeBase64Url(resource.slice(RECAP_PREFIX.length))));
+  if (!isObject(parsed) || !("att" in parsed) || !isObject(parsed.att)) throw new Error("ReCap attenuation must be an object");
+  const attenuation = /* @__PURE__ */ Object.create(null);
+  for (const [target, abilities] of Object.entries(parsed.att)) {
+    if (target === "__proto__" || !isObject(abilities) || Object.keys(abilities).length === 0) throw new Error("ReCap resource must map to abilities");
+    const copy = /* @__PURE__ */ Object.create(null);
+    for (const [ability, caveats] of Object.entries(abilities)) {
+      if (ability === "__proto__" || !/^[^/]+\/[^/]/.test(ability)) throw new Error("ReCap ability must be namespace/name");
+      if (!Array.isArray(caveats) || caveats.length === 0 || !caveats.every(isObject)) throw new Error("ReCap caveats must be a non-empty array of objects");
+      copy[ability] = caveats;
+    }
+    attenuation[target] = copy;
+  }
+  return attenuation;
+}
+async function parseSignedSiweCacao(authorization, expectedCid) {
+  if (authorization.length > Math.ceil(MAX_CACAO_BYTES / 3) * 4 + 2) throw new Error(`CACAO exceeds ${MAX_CACAO_BYTES} bytes`);
+  if (!/^[A-Za-z0-9_-]+={0,2}$/.test(authorization)) throw new Error("CACAO must be base64url DAG-CBOR");
+  const bytes2 = decodeBase64Url(authorization.replace(/=+$/, ""));
+  if (bytes2.length > MAX_CACAO_BYTES) throw new Error(`CACAO exceeds ${MAX_CACAO_BYTES} bytes`);
+  const cid2 = CID.createV1(85, create(30, (0, import_blake34.blake3)(bytes2))).toString();
+  if (expectedCid !== void 0 && cid2 !== expectedCid) throw new Error("CACAO CID does not match exact Authorization bytes");
+  const decoded = decodeDagCbor(bytes2);
+  const canonical = encodeDagCbor(decoded);
+  if (canonical.length !== bytes2.length || canonical.some((byte, index) => byte !== bytes2[index])) throw new Error("CACAO is not canonical DAG-CBOR");
+  const cacao = map(decoded, "envelope", ["h", "p", "s"]);
+  if (map(cacao.h, "header", ["t"]).t !== "eip4361") throw new Error("CACAO header must be eip4361");
+  const signature = map(cacao.s, "signature", ["t", "s"]);
+  if (signature.t !== "eip191" || !(signature.s instanceof Uint8Array) || signature.s.length !== 65) throw new Error("CACAO signature must be a 65-byte eip191 signature");
+  const payload = map(cacao.p, "payload", ["domain", "iss", "aud", "version", "nonce", "iat"], ["exp", "nbf", "statement", "requestId", "resources"]);
+  if (payload.version !== 1) throw new Error("CACAO SIWE version must be the integer 1");
+  const issuer = text2(payload.iss, "iss");
+  const pkh = /^did:pkh:eip155:([1-9]\d*):(0x[0-9a-fA-F]{40})$/.exec(issuer);
+  const chainId = Number(pkh?.[1]);
+  if (pkh === null || !Number.isSafeInteger(chainId) || String(chainId) !== pkh[1]) throw new Error("CACAO issuer must be did:pkh:eip155 with a safe-integer chain ID");
+  const audience = text2(payload.aud, "aud");
+  const optional = (key) => payload[key] === void 0 ? void 0 : text2(payload[key], key);
+  const statement = optional("statement");
+  const expiresAt = optional("exp");
+  const notBefore = optional("nbf");
+  const requestId = optional("requestId");
+  let resources = [];
+  if ("resources" in payload) {
+    if (!Array.isArray(payload.resources) || payload.resources.length === 0) throw new Error("CACAO resources must be a non-empty array when present");
+    resources = payload.resources.map((resource, index) => text2(resource, `resources[${index}]`));
+  }
+  const last = resources.at(-1);
+  const attenuation = last?.startsWith(RECAP_PREFIX) ? reCapAttenuation(last) : /* @__PURE__ */ Object.create(null);
+  if (last?.startsWith(RECAP_PREFIX) && !statement?.endsWith(reCapStatement(attenuation))) throw new Error("CACAO statement does not match its ReCap");
+  const message = new import_siwe2.SiweMessage({
+    domain: text2(payload.domain, "domain"),
+    address: pkh[2],
+    uri: audience,
+    version: "1",
+    chainId,
+    nonce: text2(payload.nonce, "nonce"),
+    issuedAt: text2(payload.iat, "iat"),
+    ...statement === void 0 ? {} : { statement },
+    ...expiresAt === void 0 ? {} : { expirationTime: expiresAt },
+    ...notBefore === void 0 ? {} : { notBefore },
+    ...requestId === void 0 ? {} : { requestId },
+    ...resources.length === 0 ? {} : { resources }
+  }).prepareMessage();
+  if (!await verifyEip191MessageSignature(message, (0, import_viem5.bytesToHex)(signature.s), pkh[2])) throw new Error("CACAO signature is invalid");
+  return { cid: cid2, issuer, audience, attenuation, ...expiresAt === void 0 ? {} : { expiresAt } };
+}
+
 // src/networkId.ts
 var import_sdk_services4 = require("@tinycloud/sdk-services");
 function canonicalizeNetworkId(networkId) {
@@ -14221,11 +14438,11 @@ var TinyCloud = class _TinyCloud {
       if (contentType?.includes("application/json")) {
         data = await response.json();
       } else {
-        const text2 = await response.text();
+        const text3 = await response.text();
         try {
-          data = JSON.parse(text2);
+          data = JSON.parse(text3);
         } catch {
-          data = text2;
+          data = text3;
         }
       }
       return (0, import_sdk_services6.ok)(data);
@@ -18141,7 +18358,7 @@ function portForProtocol(protocol) {
 
 // src/location.ts
 var import_ed2551910 = require("@noble/curves/ed25519");
-var import_viem5 = require("viem");
+var import_viem6 = require("viem");
 var DEFAULT_TINYCLOUD_LOCATION_REGISTRY_URL = "https://registry.tinycloud.xyz";
 var DEFAULT_TINYCLOUD_FALLBACK_HOST = "https://node.tinycloud.xyz";
 var DEFAULT_LOCAL_NODE_URL = "http://127.0.0.1:8000";
@@ -18311,10 +18528,10 @@ async function fetchLocationRecord(registryUrl, subject, fetchFn = globalThis.fe
   if (!response.ok) {
     throw new LocationRegistryHttpError(`location registry returned HTTP ${response.status}`, response.status);
   }
-  const text2 = await boundedResponseText(response, "location registry", 64 * 1024);
+  const text3 = await boundedResponseText(response, "location registry", 64 * 1024);
   let body;
   try {
-    body = JSON.parse(text2);
+    body = JSON.parse(text3);
   } catch {
     throw new LocationRecordValidationError("registry response is not JSON");
   }
@@ -18356,10 +18573,10 @@ async function publishLocationRecord(options2) {
   if (!response.ok) {
     throw new LocationRegistryHttpError(`location registry publish returned HTTP ${response.status}`, response.status);
   }
-  const text2 = await boundedResponseText(response, "location registry", 64 * 1024);
+  const text3 = await boundedResponseText(response, "location registry", 64 * 1024);
   let body;
   try {
-    body = JSON.parse(text2);
+    body = JSON.parse(text3);
   } catch {
     throw new LocationRecordValidationError("registry publish response is not JSON");
   }
@@ -18726,10 +18943,10 @@ async function verifyOwnerNodeBinding(options2) {
       Object.assign(failure, { status: response.status });
       throw failure;
     }
-    const text2 = await boundedResponseText(response, "target node /info", 16 * 1024);
+    const text3 = await boundedResponseText(response, "target node /info", 16 * 1024);
     let body;
     try {
-      body = JSON.parse(text2);
+      body = JSON.parse(text3);
     } catch {
       throw new LocationRecordValidationError("target node /info response is not JSON");
     }
@@ -18894,7 +19111,7 @@ async function verifyPkhSignature(did, payload, signature) {
   if (!/^0x[0-9a-fA-F]+$/.test(signature)) {
     throw new LocationRecordValidationError("did:pkh signature must be hex");
   }
-  return (0, import_viem5.verifyMessage)({
+  return (0, import_viem6.verifyMessage)({
     address,
     message: payload,
     signature