@orangecheck/agent-core 0.1.0 → 0.2.0

package/dist/index.js

@@ -294,6 +294,19 @@ function revocationCanonicalMessage(input) {
     `signed_at: ${input.signed_at}`
   ].join("\n");
 }
+function subdelegationCanonicalMessage(input) {
+  const scopeField = input.scopes.join(",");
+  return [
+    "oc-agent:subdelegation:v1",
+    `parent_id: ${input.parent_id}`,
+    `principal: ${input.principal}`,
+    `agent: ${input.agent}`,
+    `scopes: ${scopeField}`,
+    `issued_at: ${input.issued_at}`,
+    `expires_at: ${input.expires_at}`,
+    `nonce: ${input.nonce}`
+  ].join("\n");
+}
 function delegationCanonicalBytes(input) {
   return new TextEncoder().encode(delegationCanonicalMessage(input));
 }
@@ -303,6 +316,9 @@ function actionCanonicalBytes(input) {
 function revocationCanonicalBytes(input) {
   return new TextEncoder().encode(revocationCanonicalMessage(input));
 }
+function subdelegationCanonicalBytes(input) {
+  return new TextEncoder().encode(subdelegationCanonicalMessage(input));
+}
 function computeDelegationId(input) {
   return canonical.hexEncode(sha256.sha256(delegationCanonicalBytes(input)));
 }
@@ -312,6 +328,9 @@ function computeActionId(input) {
 function computeRevocationId(input) {
   return canonical.hexEncode(sha256.sha256(revocationCanonicalBytes(input)));
 }
+function computeSubdelegationId(input) {
+  return canonical.hexEncode(sha256.sha256(subdelegationCanonicalBytes(input)));
+}
 function canonicalizeDelegation(env) {
   return canonical.canonicalize(env);
 }
@@ -333,6 +352,7 @@ function canonicalRevocationBytes(env) {
 function sha256Hex(bytes) {
   return canonical.hexEncode(sha256.sha256(bytes));
 }
+var DEFAULT_MAX_CHAIN_DEPTH = 5;
 var AgentError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -406,6 +426,14 @@ async function verifyDelegation(input) {
 async function verifyAction(input) {
   const a = input.action;
   const d = input.delegation;
+  const chain = input.subdelegationChain ?? [];
+  const maxDepth = input.maxChainDepth ?? DEFAULT_MAX_CHAIN_DEPTH;
+  if (chain.length > maxDepth) {
+    return err(
+      "E_SUBDELEGATION_DEPTH_EXCEEDED",
+      `chain depth ${chain.length} exceeds maximum ${maxDepth}`
+    );
+  }
   const dr = await verifyDelegation({
     envelope: d,
     verifyBip322: input.verifyBip322,
@@ -415,6 +443,13 @@ async function verifyAction(input) {
     // action window check dominates
   });
   if (!dr.ok) return dr;
+  let parent = d;
+  for (const sub of chain) {
+    const r = await verifyChainLink(sub, parent, input);
+    if (!r.ok) return r;
+    parent = sub;
+  }
+  const leaf = chain.length > 0 ? chain[chain.length - 1] : d;
   if (a.v !== ENVELOPE_VERSION) {
     return err("E_UNSUPPORTED_VERSION", `action version ${a.v} not supported`);
   }
@@ -439,25 +474,25 @@ async function verifyAction(input) {
     const ok = await input.verifyBip322(a.id, a.sig.value, a.signer.address);
     if (!ok) return err("E_BAD_ACTION_STAMP", "action BIP-322 signature did not verify");
   }
-  if (a.delegation_id !== d.id) {
-    return err("E_DELEGATION_MISMATCH", `action.delegation_id (${a.delegation_id}) != delegation.id (${d.id})`);
+  if (a.delegation_id !== leaf.id) {
+    return err("E_DELEGATION_MISMATCH", `action.delegation_id (${a.delegation_id}) != leaf.id (${leaf.id})`);
   }
-  if (a.signer.address !== d.agent.address) {
-    return err("E_AGENT_MISMATCH", `action signer (${a.signer.address}) != delegation.agent (${d.agent.address})`);
+  if (a.signer.address !== leaf.agent.address) {
+    return err("E_AGENT_MISMATCH", `action signer (${a.signer.address}) != leaf.agent (${leaf.agent.address})`);
   }
-  const issued = new Date(d.issued_at).getTime();
-  const expires = new Date(d.expires_at).getTime();
+  const issued = new Date(leaf.issued_at).getTime();
+  const expires = new Date(leaf.expires_at).getTime();
   const signed = new Date(a.signed_at).getTime();
   if (Number.isNaN(issued) || Number.isNaN(expires) || Number.isNaN(signed)) {
     return err("E_MALFORMED", "unparseable ISO 8601 timestamp");
   }
   if (signed < issued || signed >= expires) {
-    return err("E_OUT_OF_WINDOW", `action.signed_at ${a.signed_at} is outside delegation window [${d.issued_at}, ${d.expires_at})`);
+    return err("E_OUT_OF_WINDOW", `action.signed_at ${a.signed_at} is outside leaf window [${leaf.issued_at}, ${leaf.expires_at})`);
   }
   let exercised, accepted;
   try {
     exercised = canonicalizeScope(parseScope(a.scope_exercised));
-    const granted = d.scopes.map((s) => parseScope(s));
+    const granted = leaf.scopes.map((s) => parseScope(s));
     const exercisedParsed = parseScope(a.scope_exercised);
     validateScope(exercisedParsed, { mode: input.scopeMode ?? "strict" });
     accepted = granted.some((g) => isSubScope(exercisedParsed, g));
@@ -467,19 +502,22 @@ async function verifyAction(input) {
   }
   if (!accepted) return err("E_SCOPE_DENIED", `scope_exercised (${exercised}) not a sub-scope of any granted scope`);
   if (input.revocations && input.revocations.length > 0) {
-    for (const rev of input.revocations) {
-      if (rev.delegation_id !== d.id) continue;
-      const rr = await verifyRevocation({
-        envelope: rev,
-        delegation: d,
-        verifyBip322: input.verifyBip322,
-        skipSignatureVerification: input.skipSignatureVerification
-      });
-      if (!rr.ok) continue;
-      const effective = effectiveRevocationTime(rev, input.resolveAnchorBlockHeight);
-      const actionTime = actionEffectiveTime(a, input.resolveAnchorBlockHeight);
-      if (compareTimes(effective, actionTime) <= 0) {
-        return err("E_REVOKED", `delegation was revoked by ${rev.id} before action was signed`);
+    const allLinks = [d, ...chain];
+    for (const link of allLinks) {
+      for (const rev of input.revocations) {
+        if (rev.delegation_id !== link.id) continue;
+        const rr = await verifyRevocation({
+          envelope: rev,
+          delegation: link,
+          verifyBip322: input.verifyBip322,
+          skipSignatureVerification: input.skipSignatureVerification
+        });
+        if (!rr.ok) continue;
+        const effective = effectiveRevocationTime(rev, input.resolveAnchorBlockHeight);
+        const actionTime = actionEffectiveTime(a, input.resolveAnchorBlockHeight);
+        if (compareTimes(effective, actionTime) <= 0) {
+          return err("E_REVOKED", `chain link ${link.id} was revoked by ${rev.id} before action was signed`);
+        }
       }
     }
   }
@@ -516,6 +554,7 @@ async function verifyAction(input) {
     canonicalMessage: reconstructedMessage,
     id: a.id,
     delegation: d,
+    chain,
     scopeExercised: exercised,
     anchor
   };
@@ -599,6 +638,121 @@ function checkRevocationShape(env) {
   if (env.sig.pubkey !== env.signer.address) return err("E_MALFORMED", "sig.pubkey must equal signer.address");
   return null;
 }
+function checkSubdelegationShape(env) {
+  if (env.kind !== "agent-subdelegation") return err("E_MALFORMED", 'kind must be "agent-subdelegation"');
+  if (!isHex64(env.id)) return err("E_MALFORMED", "id must be 64 lowercase hex chars");
+  if (!isHex64(env.parent_id)) return err("E_MALFORMED", "parent_id must be 64-hex");
+  if (!env.principal?.address || env.principal.alg !== "bip322") return err("E_MALFORMED", "principal invalid");
+  if (!env.agent?.address || env.agent.alg !== "bip322") return err("E_MALFORMED", "agent invalid");
+  if (!Array.isArray(env.scopes) || env.scopes.length === 0) return err("E_MALFORMED", "scopes must be non-empty array");
+  if ("bond" in env && env.bond !== void 0) {
+    return err("E_MALFORMED", "sub-delegation envelopes MUST NOT carry a bond field");
+  }
+  if (!isIsoUtc(env.issued_at)) return err("E_MALFORMED", "issued_at must be ISO 8601 UTC");
+  if (!isIsoUtc(env.expires_at)) return err("E_MALFORMED", "expires_at must be ISO 8601 UTC");
+  if (!/^[0-9a-f]{32}$/.test(env.nonce)) return err("E_MALFORMED", "nonce must be 32 lowercase hex chars");
+  if (env.sig?.alg !== "bip322" || typeof env.sig.value !== "string") return err("E_MALFORMED", "sig invalid");
+  if (env.sig.pubkey !== env.principal.address) return err("E_MALFORMED", "sig.pubkey must equal principal.address");
+  return null;
+}
+async function verifyChainLink(s, parent, input) {
+  if (s.v !== ENVELOPE_VERSION) {
+    return err("E_UNSUPPORTED_VERSION", `subdelegation version ${s.v} not supported`);
+  }
+  const shape = checkSubdelegationShape(s);
+  if (shape) return shape;
+  let canonicalScopesList;
+  try {
+    canonicalScopesList = canonicalizeScopes(s.scopes);
+  } catch (e) {
+    const msg = e instanceof ScopeParseError ? e.message : e.message;
+    return err("E_BAD_SCOPE_GRAMMAR", msg);
+  }
+  const canonInput = {
+    parent_id: s.parent_id,
+    principal: s.principal.address,
+    agent: s.agent.address,
+    scopes: canonicalScopesList,
+    issued_at: s.issued_at,
+    expires_at: s.expires_at,
+    nonce: s.nonce
+  };
+  const reconstructedId = computeSubdelegationId(canonInput);
+  if (reconstructedId !== s.id) {
+    return err("E_BAD_ID", `reconstructed subdelegation id (${reconstructedId}) does not match envelope id (${s.id})`);
+  }
+  let parsedScopes;
+  try {
+    parsedScopes = s.scopes.map((str) => parseScope(str));
+    for (const p of parsedScopes) validateScope(p, { mode: input.scopeMode ?? "strict" });
+  } catch (e) {
+    const msg = e instanceof ScopeParseError ? e.message : e.message;
+    return err("E_BAD_SCOPE_GRAMMAR", msg);
+  }
+  if (!input.skipSignatureVerification) {
+    if (!input.verifyBip322) return err("E_BAD_SIG", "no BIP-322 verifier supplied for subdelegation");
+    const ok = await input.verifyBip322(s.id, s.sig.value, s.principal.address);
+    if (!ok) return err("E_BAD_SIG", "subdelegation BIP-322 signature did not verify");
+  }
+  if (s.parent_id !== parent.id) {
+    return err(
+      "E_SUBDELEGATION_PRINCIPAL_MISMATCH",
+      `subdelegation.parent_id (${s.parent_id}) does not match parent envelope id (${parent.id})`
+    );
+  }
+  if (s.principal.address !== parent.agent.address) {
+    return err(
+      "E_SUBDELEGATION_PRINCIPAL_MISMATCH",
+      `subdelegation.principal (${s.principal.address}) does not match parent.agent (${parent.agent.address})`
+    );
+  }
+  const sIssued = new Date(s.issued_at).getTime();
+  const sExpires = new Date(s.expires_at).getTime();
+  const pIssued = new Date(parent.issued_at).getTime();
+  const pExpires = new Date(parent.expires_at).getTime();
+  if (Number.isNaN(sIssued) || Number.isNaN(sExpires) || Number.isNaN(pIssued) || Number.isNaN(pExpires)) {
+    return err("E_MALFORMED", "unparseable ISO 8601 timestamp in chain");
+  }
+  if (sExpires <= sIssued) {
+    return err("E_MALFORMED", "subdelegation expires_at must be > issued_at");
+  }
+  if (sIssued < pIssued || sExpires > pExpires) {
+    return err(
+      "E_SUBDELEGATION_EXPIRES_EXTENDED",
+      `subdelegation window [${s.issued_at}, ${s.expires_at}) is not contained in parent's [${parent.issued_at}, ${parent.expires_at})`
+    );
+  }
+  const parentScopesParsed = parent.scopes.map((str) => parseScope(str));
+  for (let i = 0; i < parsedScopes.length; i++) {
+    const childScope = parsedScopes[i];
+    const containedBySomeParentScope = parentScopesParsed.some((p) => isSubScope(childScope, p));
+    if (!containedBySomeParentScope) {
+      return err(
+        "E_SUBDELEGATION_SCOPE_ESCALATED",
+        `subdelegation scope ${canonicalizeScope(childScope)} is not a sub-scope of any granted scope on the parent`
+      );
+    }
+  }
+  return {
+    ok: true,
+    envelope: s,
+    canonicalMessage: "",
+    // not populated for chain links; computeSubdelegationId is the binding form
+    id: s.id
+  };
+}
+async function verifySubdelegation(input) {
+  const r = await verifyChainLink(input.envelope, input.parent, input);
+  if (!r.ok) return r;
+  if (!input.skipTemporalCheck) {
+    const now = (input.now ?? /* @__PURE__ */ new Date()).getTime();
+    const issued = new Date(input.envelope.issued_at).getTime();
+    const expires = new Date(input.envelope.expires_at).getTime();
+    if (now < issued) return err("E_NOT_YET_VALID", `subdelegation issued_at ${input.envelope.issued_at} is in the future`);
+    if (now >= expires) return err("E_EXPIRED", `subdelegation expires_at ${input.envelope.expires_at} is past`);
+  }
+  return r;
+}
 function actionEffectiveTime(a, resolve) {
   if (a.ots?.status === "confirmed") {
     const h = resolve ? resolve(a) : a.ots.block_height;
@@ -638,6 +792,7 @@ Object.defineProperty(exports, "hexEncode", {
   get: function () { return canonical.hexEncode; }
 });
 exports.AgentError = AgentError;
+exports.DEFAULT_MAX_CHAIN_DEPTH = DEFAULT_MAX_CHAIN_DEPTH;
 exports.ENVELOPE_VERSION = ENVELOPE_VERSION;
 exports.REGISTERED_SCOPES = REGISTERED_SCOPES;
 exports.ScopeParseError = ScopeParseError;
@@ -655,6 +810,7 @@ exports.canonicalizeScopes = canonicalizeScopes;
 exports.computeActionId = computeActionId;
 exports.computeDelegationId = computeDelegationId;
 exports.computeRevocationId = computeRevocationId;
+exports.computeSubdelegationId = computeSubdelegationId;
 exports.delegationCanonicalBytes = delegationCanonicalBytes;
 exports.delegationCanonicalMessage = delegationCanonicalMessage;
 exports.isSubScope = isSubScope;
@@ -663,9 +819,12 @@ exports.parseScope = parseScope;
 exports.revocationCanonicalBytes = revocationCanonicalBytes;
 exports.revocationCanonicalMessage = revocationCanonicalMessage;
 exports.sha256Hex = sha256Hex;
+exports.subdelegationCanonicalBytes = subdelegationCanonicalBytes;
+exports.subdelegationCanonicalMessage = subdelegationCanonicalMessage;
 exports.validateScope = validateScope;
 exports.verifyAction = verifyAction;
 exports.verifyDelegation = verifyDelegation;
 exports.verifyRevocation = verifyRevocation;
+exports.verifySubdelegation = verifySubdelegation;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map