@metamynd/agentsafe-guard 0.3.0 → 0.4.0

package/cli.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// cli.mjs — the package's only executable. Its whole job is to make the offline
+// demo reachable without cloning anything:
+//
+//   npx @metamynd/agentsafe-guard demo
+//
+// Kept deliberately thin: no argument parser, no dependencies, no network.
+const [, , cmd] = process.argv;
+
+if (cmd === 'demo') {
+  await import('./demo.mjs');
+} else if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(`
+  @metamynd/agentsafe-guard — runtime governance for Node AI agents
+
+  Usage
+    npx @metamynd/agentsafe-guard demo     Run the offline policy demo
+                                           (no account, no API key, no network)
+
+  In your agent
+    import { createGuard } from '@metamynd/agentsafe-guard';
+
+  Docs   https://www.npmjs.com/package/@metamynd/agentsafe-guard
+  Hosted https://metamynd.ai
+`);
+} else {
+  console.error(`Unknown command: ${cmd}\nTry: npx @metamynd/agentsafe-guard demo`);
+  process.exit(1);
+}

package/demo.mjs

@@ -0,0 +1,161 @@
+// demo.mjs — the no-account, no-network tour of the guard.
+//
+//   npx @metamynd/agentsafe-guard demo
+//
+// Everything here runs locally: an ephemeral Ed25519 key, an inline policy bundle,
+// and `policy-core` — the same evaluator bytes the hosted gate runs. No MetaMynd
+// account, no API key, no Hedera, no outbound request (the `api` URL below is
+// deliberately unroutable, and nothing ever calls it).
+//
+// Exits 0 when every verdict matches what the policy says it should be, 1 otherwise —
+// so this doubles as a smoke test of the shipped package.
+import crypto from 'node:crypto';
+import { createGuard } from './agentsafe-guard.mjs';
+
+const c = (code, s) => (process.stdout.isTTY ? `\u001b[${code}m${s}\u001b[0m` : s);
+const bold = (s) => c('1', s);
+const dim = (s) => c('2', s);
+const head = (s) => console.log(`\n${bold(s)}\n${dim('─'.repeat(s.length))}`);
+
+// Colour per decision — but never colour ALONE: the verdict is always spelled out.
+const paint = { allow: '32', observe: '36', escalate: '33', block: '31', quarantine: '35' };
+const verdict = (d) => c(paint[d] ?? '0', d.toUpperCase().padEnd(10));
+
+const { privateKey } = crypto.generateKeyPairSync('ed25519');
+const guard = createGuard({
+  api: 'http://unused.local/api/v1', // never contacted — this demo is entirely local
+  agentDid: 'did:hedera:testnet:z6MkDemo_0.0.1',
+  agentKey: privateKey.export({ format: 'der', type: 'pkcs8' }).toString('hex'),
+});
+
+// The policy an owner would author in the dashboard, as the agent receives it:
+// one enforced Standard, one SOP, and an ODRL mandate.
+const bundle = {
+  standards: [
+    {
+      standardKey: 'eu-ai-act',
+      document: {
+        molecules: [
+          {
+            id: 'risk',
+            combinator: 'any',
+            atoms: [{ id: 'r', predicate: 'risk-at-or-above', config: { level: 'high' } }],
+            decision: 'escalate',
+            reasonCode: 'RISK_REVIEW',
+          },
+        ],
+      },
+    },
+  ],
+  sops: [
+    {
+      standardKey: 'sop:travel',
+      document: {
+        molecules: [
+          {
+            id: 'watch',
+            combinator: 'any',
+            atoms: [{ id: 'w', predicate: 'amount-over', config: { limit: 200 } }],
+            decision: 'observe',
+            reasonCode: 'WATCH_LARGE',
+          },
+          {
+            id: 'cap',
+            combinator: 'any',
+            atoms: [{ id: 'a', predicate: 'amount-over', config: { limit: 500 } }],
+            decision: 'block',
+            reasonCode: 'SOP_SPEND_CAP',
+          },
+          {
+            id: 'contain',
+            combinator: 'any',
+            atoms: [{ id: 'q', predicate: 'amount-over', config: { limit: 5000 } }],
+            decision: 'quarantine',
+            reasonCode: 'GROSS_OVERSPEND',
+          },
+        ],
+      },
+    },
+  ],
+  mandate: {
+    permission: [
+      {
+        target: 'flight-purchase',
+        constraint: [
+          { leftOperand: 'mm:payAmount', operator: 'lteq', rightOperand: 1000 },
+          { leftOperand: 'mm:cumulativeSpend', operator: 'lteq', rightOperand: 1000 },
+          { leftOperand: 'mm:merchant', operator: 'isAnyOf', rightOperand: ['amadeus'] },
+        ],
+      },
+    ],
+  },
+};
+
+let failed = 0;
+const check = (ok) => { if (!ok) failed++; return ok ? dim('ok') : c('31', 'FAIL'); };
+
+const run = (label, request, expect, extra = {}) => {
+  const v = guard.evaluateLocally({ ...bundle, ...extra, request });
+  const ok = v.decision === expect[0] && v.reasonCode === expect[1];
+  console.log(`  ${verdict(v.decision)} ${String(v.reasonCode).padEnd(22)} ${label}  ${check(ok)}`);
+};
+
+console.log(bold('\nAgentSafe Guard — local policy evaluation'));
+console.log(dim('No account, no API key, no network. Same policy-core the hosted gate runs.'));
+
+head('The policy this agent is under');
+console.log(`  Standard ${dim('eu-ai-act')}    risk ≥ high                 → escalate`);
+console.log(`  SOP      ${dim('sop:travel')}   amount > 200                → observe   ${dim('(permit, but flag)')}`);
+console.log(`                        amount > 500                → block`);
+console.log(`                        amount > 5000               → quarantine ${dim('(contain the agent)')}`);
+console.log(`  Mandate  ${dim('ODRL')}         merchant ∈ [amadeus], ≤ 1000 per action and in total`);
+
+head('A tool call, evaluated against it');
+run('$100 to amadeus, low risk', { action: 'flight-purchase', amount: 100, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['allow', 'AUTHORIZED']);
+run('$300 — over the watch line', { action: 'flight-purchase', amount: 300, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['observe', 'WATCH_LARGE']);
+run('$600 — over the SOP cap', { action: 'flight-purchase', amount: 600, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['block', 'SOP_SPEND_CAP']);
+run('$100 but flagged high risk', { action: 'flight-purchase', amount: 100, merchant: 'amadeus', context: { riskLevel: 'high' } }, ['escalate', 'RISK_REVIEW']);
+run('$100 to a merchant off the mandate', { action: 'flight-purchase', amount: 100, merchant: 'sabre', context: { riskLevel: 'low' } }, ['block', 'MERCHANT_NOT_ALLOWED']);
+run('$6000 — gross overspend', { action: 'flight-purchase', amount: 6000, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['quarantine', 'GROSS_OVERSPEND']);
+
+head('The agent cannot argue its way out');
+console.log(dim('  Unsigned context is untrusted input — it never shadows the signed amount.'));
+run('$600 claiming "payAmount: 1"', { action: 'flight-purchase', amount: 600, merchant: 'amadeus', context: { 'mm:payAmount': 1, riskLevel: 'low' } }, ['block', 'SOP_SPEND_CAP']);
+console.log(dim('  A quarantined agent is refused at the edge, before any rule is read.'));
+run('$1 while quarantined', { action: 'flight-purchase', amount: 1, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['quarantine', 'AGENT_QUARANTINED'], { contained: { status: 'quarantined', reason: 'GROSS_OVERSPEND' } });
+
+head('Operating mode narrows the ladder further');
+const mode = (m) => ({ operatingMode: { mode: m } });
+run('read_only — value action refused', { action: 'flight-purchase', amount: 100, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['block', 'MODE_READ_ONLY'], mode('read_only'));
+run('read_only — a $0 read still passes', { action: 'flight-purchase', amount: 0, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['allow', 'AUTHORIZED'], mode('read_only'));
+run('restricted — spend needs a human', { action: 'flight-purchase', amount: 100, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['escalate', 'MODE_RESTRICTED_REVIEW'], mode('restricted'));
+run('restricted — but a block stays a block', { action: 'flight-purchase', amount: 600, merchant: 'amadeus', context: { riskLevel: 'low' } }, ['block', 'SOP_SPEND_CAP'], mode('restricted'));
+
+head('What that means for your tool');
+{
+  let ran = false;
+  const book = guard.guardToolLocal('flight-purchase', async () => { ran = true; return 'booked'; }, (a) => a, bundle);
+  const out = await book({ amount: 300, merchant: 'amadeus', context: { riskLevel: 'low' } });
+  console.log(`  observe   → handler RAN, returned ${JSON.stringify(out)}  ${check(ran === true && out === 'booked')}`);
+}
+{
+  let ran = false;
+  const book = guard.guardToolLocal('flight-purchase', async () => { ran = true; return 'booked'; }, (a) => a, bundle);
+  let name = null;
+  try { await book({ amount: 600, merchant: 'amadeus', context: { riskLevel: 'low' } }); } catch (e) { name = e?.name; }
+  console.log(`  block     → threw ${name}, handler never ran  ${check(name === 'GovernanceBlocked' && ran === false)}`);
+}
+
+if (failed) {
+  console.error(c('31', `\n${failed} case(s) FAILED — that is a bug, please report it.`));
+  console.error(dim('Please report it — https://metamynd.ai\n'));
+  process.exit(1);
+}
+
+console.log(bold('\nPASS') + dim(' — every verdict matched the policy, decided locally in-process.\n'));
+console.log('Wire it into your own agent:');
+console.log(dim("  import { createGuard } from '@metamynd/agentsafe-guard';"));
+console.log(dim('  const safeBooking = guard.guardToolLocal(\'flight-purchase\', bookFlight, mapArgs, bundle);'));
+console.log(`\n${dim('Local evaluation needs nothing from us. The hosted platform adds live policy')}`);
+console.log(`${dim('editing, cumulative spend caps, human escalation, and anchored evidence:')}`);
+console.log(`${dim('https://metamynd.ai')}\n`);

package/example-openclaw-agent.mjs

@@ -1,47 +1,47 @@
-// example-openclaw-agent.mjs — a runnable demo of the guard against a seeded bound agent.
-//
-// Simulates how an OpenClaw agent's TOOL is wrapped: the raw tool only runs if the
-// AgentSafe gate returns `allow`. Run it after seeding an agent with
-// backend/scripts/demo-seed-governance.ts:
-//
-//   $env:AGENTSAFE_API="http://localhost:9926/api/v1"
-//   $env:AGENT_DID="did:hedera:testnet:..."
-//   $env:AGENT_KEY="302e0201..."
-//   node example-openclaw-agent.mjs
-import { createGuard } from './agentsafe-guard.mjs';
-
-const guard = createGuard({
-  api: process.env.AGENTSAFE_API ?? 'http://localhost:9926/api/v1',
-  agentDid: process.env.AGENT_DID,
-  agentKey: process.env.AGENT_KEY,
-});
-
-// --- The agent's tool. In OpenClaw you register this handler for the tool; here we
-//     wrap it with guard.guardTool so every call is gated first. ---
-const bookFlight = guard.guardTool(
-  'flight-purchase', // the governed action (matches the mandate scope)
-  async (args, decision) => {
-    // Only reached when the gate ALLOWED. Real booking would go here.
-    return { booked: true, pnr: 'PNR-DEMO', remaining: decision.remaining, ...args };
-  },
-  // Map the tool args → gate inputs. `context` carries what the Standard/SOP rules need.
-  (a) => ({ amount: a.amount, currency: 'USD', merchant: a.merchant, context: { tool: a.tool ?? 'book-flight', riskLevel: a.riskLevel ?? 'low' } }),
-);
-
-async function ask(label, args) {
-  try {
-    const r = await bookFlight(args);
-    console.log(`  \x1b[32m✅ ALLOW\x1b[0m   ${label.padEnd(30)} → booked ${r.pnr} (remaining $${r.remaining})`);
-  } catch (e) {
-    const g = e.governance ?? {};
-    const tag = g.decision === 'escalate' ? '\x1b[33m⚠ ESCALATE\x1b[0m' : '\x1b[31m⛔ BLOCK\x1b[0m';
-    console.log(`  ${tag} ${label.padEnd(30)} → ${g.reasonCode ?? e.message}`);
-  }
-}
-
-console.log(`\n  OpenClaw agent — every booking passes through the AgentSafe gate\n  ${'─'.repeat(60)}`);
-await ask('$150 book-flight, low risk', { amount: 150, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'low' });
-await ask('$600 book-flight', { amount: 600, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'low' });
-await ask('$100 wire-transfer tool', { amount: 100, merchant: 'skyward-air', tool: 'wire-transfer', riskLevel: 'low' });
-await ask('$100 high-risk decision', { amount: 100, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'high' });
-console.log(`\n  The agent refuses blocked/escalated actions itself — governance decided, not the LLM.\n`);
+// example-openclaw-agent.mjs — a runnable demo of the guard against a seeded bound agent.
+//
+// Simulates how an OpenClaw agent's TOOL is wrapped: the raw tool only runs if the
+// AgentSafe gate returns `allow`. Run it after seeding an agent with
+// backend/scripts/demo-seed-governance.ts:
+//
+//   $env:AGENTSAFE_API="http://localhost:9926/api/v1"
+//   $env:AGENT_DID="did:hedera:testnet:..."
+//   $env:AGENT_KEY="302e0201..."
+//   node example-openclaw-agent.mjs
+import { createGuard } from './agentsafe-guard.mjs';
+
+const guard = createGuard({
+  api: process.env.AGENTSAFE_API ?? 'http://localhost:9926/api/v1',
+  agentDid: process.env.AGENT_DID,
+  agentKey: process.env.AGENT_KEY,
+});
+
+// --- The agent's tool. In OpenClaw you register this handler for the tool; here we
+//     wrap it with guard.guardTool so every call is gated first. ---
+const bookFlight = guard.guardTool(
+  'flight-purchase', // the governed action (matches the mandate scope)
+  async (args, decision) => {
+    // Only reached when the gate ALLOWED. Real booking would go here.
+    return { booked: true, pnr: 'PNR-DEMO', remaining: decision.remaining, ...args };
+  },
+  // Map the tool args → gate inputs. `context` carries what the Standard/SOP rules need.
+  (a) => ({ amount: a.amount, currency: 'USD', merchant: a.merchant, context: { tool: a.tool ?? 'book-flight', riskLevel: a.riskLevel ?? 'low' } }),
+);
+
+async function ask(label, args) {
+  try {
+    const r = await bookFlight(args);
+    console.log(`  \x1b[32m✅ ALLOW\x1b[0m   ${label.padEnd(30)} → booked ${r.pnr} (remaining $${r.remaining})`);
+  } catch (e) {
+    const g = e.governance ?? {};
+    const tag = g.decision === 'escalate' ? '\x1b[33m⚠ ESCALATE\x1b[0m' : '\x1b[31m⛔ BLOCK\x1b[0m';
+    console.log(`  ${tag} ${label.padEnd(30)} → ${g.reasonCode ?? e.message}`);
+  }
+}
+
+console.log(`\n  OpenClaw agent — every booking passes through the AgentSafe gate\n  ${'─'.repeat(60)}`);
+await ask('$150 book-flight, low risk', { amount: 150, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'low' });
+await ask('$600 book-flight', { amount: 600, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'low' });
+await ask('$100 wire-transfer tool', { amount: 100, merchant: 'skyward-air', tool: 'wire-transfer', riskLevel: 'low' });
+await ask('$100 high-risk decision', { amount: 100, merchant: 'skyward-air', tool: 'book-flight', riskLevel: 'high' });
+console.log(`\n  The agent refuses blocked/escalated actions itself — governance decided, not the LLM.\n`);

package/magp-did.mjs

@@ -1,157 +1,157 @@
-// GENERATED from backend/src/features/magp/did.ts — do not edit. Regenerate: npm run build:guard-core
-
-// src/features/magp/did.ts
-import crypto from "node:crypto";
-
-// src/features/agent-identity/did.util.ts
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function base58(bytes) {
-  let zeros = 0;
-  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
-  const digits = [];
-  for (let i = zeros; i < bytes.length; i++) {
-    let carry = bytes[i];
-    for (let j = 0; j < digits.length; j++) {
-      carry += digits[j] << 8;
-      digits[j] = carry % 58;
-      carry = carry / 58 | 0;
-    }
-    while (carry > 0) {
-      digits.push(carry % 58);
-      carry = carry / 58 | 0;
-    }
-  }
-  let out = "";
-  for (let k = 0; k < zeros; k++) out += BASE58_ALPHABET[0];
-  for (let q = digits.length - 1; q >= 0; q--) out += BASE58_ALPHABET[digits[q]];
-  return out;
-}
-function multibaseBase58btc(bytes) {
-  return "z" + base58(bytes);
-}
-function buildHederaDid(network, publicKeyBytes, topicId) {
-  return `did:hedera:${network}:${multibaseBase58btc(publicKeyBytes)}_${topicId}`;
-}
-function base58Decode(str) {
-  const bytes = [0];
-  for (const ch of str) {
-    const value = BASE58_ALPHABET.indexOf(ch);
-    if (value === -1) throw new Error(`invalid base58 character '${ch}'`);
-    let carry = value;
-    for (let j = 0; j < bytes.length; j++) {
-      carry += bytes[j] * 58;
-      bytes[j] = carry & 255;
-      carry >>= 8;
-    }
-    while (carry > 0) {
-      bytes.push(carry & 255);
-      carry >>= 8;
-    }
-  }
-  let zeros = 0;
-  for (let k = 0; k < str.length && str[k] === BASE58_ALPHABET[0]; k++) zeros++;
-  const out = new Uint8Array(zeros + bytes.length);
-  for (let i = 0; i < bytes.length; i++) out[zeros + i] = bytes[bytes.length - 1 - i];
-  return out;
-}
-function parseHederaDid(did) {
-  const m = /^did:hedera:(mainnet|testnet|previewnet|devnet):(z[1-9A-HJ-NP-Za-km-z]+)_(\d+\.\d+\.\d+)$/.exec(did ?? "");
-  if (!m) return null;
-  const [, network, publicKeyMultibase, topicId] = m;
-  let publicKeyBytes;
-  try {
-    publicKeyBytes = base58Decode(publicKeyMultibase.slice(1));
-  } catch {
-    return null;
-  }
-  if (publicKeyBytes.length !== 32) return null;
-  return { network, publicKeyMultibase, publicKeyBytes, topicId };
-}
-var ED25519_MULTICODEC = Uint8Array.of(237, 1);
-function buildDidKey(publicKeyBytes) {
-  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKeyBytes.length);
-  prefixed.set(ED25519_MULTICODEC, 0);
-  prefixed.set(publicKeyBytes, ED25519_MULTICODEC.length);
-  return `did:key:${multibaseBase58btc(prefixed)}`;
-}
-function parseDidKey(did) {
-  const m = /^did:key:(z[1-9A-HJ-NP-Za-km-z]+)$/.exec(did ?? "");
-  if (!m) return null;
-  const multibase = m[1];
-  let decoded;
-  try {
-    decoded = base58Decode(multibase.slice(1));
-  } catch {
-    return null;
-  }
-  if (decoded.length !== ED25519_MULTICODEC.length + 32) return null;
-  if (decoded[0] !== ED25519_MULTICODEC[0] || decoded[1] !== ED25519_MULTICODEC[1]) return null;
-  return { method: "key", publicKeyMultibase: multibase, publicKeyBytes: decoded.slice(ED25519_MULTICODEC.length) };
-}
-function didPublicKeyBytes(did) {
-  return parseHederaDid(did)?.publicKeyBytes ?? parseDidKey(did)?.publicKeyBytes ?? null;
-}
-
-// src/features/magp/did.ts
-var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
-function ed25519KeyFromRaw(raw) {
-  const der = Buffer.concat([ED25519_SPKI_PREFIX, Buffer.from(raw)]);
-  return crypto.createPublicKey({ key: der, format: "der", type: "spki" });
-}
-function verifyDidSignature(did, message, signatureHex) {
-  const publicKeyBytes = didPublicKeyBytes(did);
-  if (!publicKeyBytes) return false;
-  try {
-    const key = ed25519KeyFromRaw(publicKeyBytes);
-    return crypto.verify(null, Buffer.from(message, "utf8"), key, Buffer.from(signatureHex, "hex"));
-  } catch {
-    return false;
-  }
-}
-function buildDidDocument(did, service) {
-  const hedera = parseHederaDid(did);
-  const key = hedera ? null : parseDidKey(did);
-  if (!hedera && !key) return null;
-  const publicKeyMultibase = hedera ? hedera.publicKeyMultibase : key.publicKeyMultibase;
-  const fragment = hedera ? "#did-root-key" : `#${key.publicKeyMultibase}`;
-  const vmId = `${did}${fragment}`;
-  const doc = {
-    "@context": ["https://www.w3.org/ns/did/v1"],
-    id: did,
-    controller: did,
-    verificationMethod: [
-      {
-        id: vmId,
-        type: "Ed25519VerificationKey2020",
-        controller: did,
-        publicKeyMultibase
-      }
-    ],
-    authentication: [vmId]
-  };
-  if (service) {
-    doc.service = [
-      {
-        id: `${did}#magp`,
-        type: "MAGPEndpoint",
-        serviceEndpoint: service.serviceEndpoint,
-        channels: service.channels,
-        protoVersions: service.protoVersions
-      }
-    ];
-  }
-  return doc;
-}
-export {
-  base58,
-  base58Decode,
-  buildDidDocument,
-  buildDidKey,
-  buildHederaDid,
-  didPublicKeyBytes,
-  ed25519KeyFromRaw,
-  multibaseBase58btc,
-  parseDidKey,
-  parseHederaDid,
-  verifyDidSignature
-};
+// GENERATED from backend/src/features/magp/did.ts — do not edit. Regenerate: npm run build:guard-core
+
+// src/features/magp/did.ts
+import crypto from "node:crypto";
+
+// src/features/agent-identity/did.util.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) zeros++;
+  const digits = [];
+  for (let i = zeros; i < bytes.length; i++) {
+    let carry = bytes[i];
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = carry / 58 | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = carry / 58 | 0;
+    }
+  }
+  let out = "";
+  for (let k = 0; k < zeros; k++) out += BASE58_ALPHABET[0];
+  for (let q = digits.length - 1; q >= 0; q--) out += BASE58_ALPHABET[digits[q]];
+  return out;
+}
+function multibaseBase58btc(bytes) {
+  return "z" + base58(bytes);
+}
+function buildHederaDid(network, publicKeyBytes, topicId) {
+  return `did:hedera:${network}:${multibaseBase58btc(publicKeyBytes)}_${topicId}`;
+}
+function base58Decode(str) {
+  const bytes = [0];
+  for (const ch of str) {
+    const value = BASE58_ALPHABET.indexOf(ch);
+    if (value === -1) throw new Error(`invalid base58 character '${ch}'`);
+    let carry = value;
+    for (let j = 0; j < bytes.length; j++) {
+      carry += bytes[j] * 58;
+      bytes[j] = carry & 255;
+      carry >>= 8;
+    }
+    while (carry > 0) {
+      bytes.push(carry & 255);
+      carry >>= 8;
+    }
+  }
+  let zeros = 0;
+  for (let k = 0; k < str.length && str[k] === BASE58_ALPHABET[0]; k++) zeros++;
+  const out = new Uint8Array(zeros + bytes.length);
+  for (let i = 0; i < bytes.length; i++) out[zeros + i] = bytes[bytes.length - 1 - i];
+  return out;
+}
+function parseHederaDid(did) {
+  const m = /^did:hedera:(mainnet|testnet|previewnet|devnet):(z[1-9A-HJ-NP-Za-km-z]+)_(\d+\.\d+\.\d+)$/.exec(did ?? "");
+  if (!m) return null;
+  const [, network, publicKeyMultibase, topicId] = m;
+  let publicKeyBytes;
+  try {
+    publicKeyBytes = base58Decode(publicKeyMultibase.slice(1));
+  } catch {
+    return null;
+  }
+  if (publicKeyBytes.length !== 32) return null;
+  return { network, publicKeyMultibase, publicKeyBytes, topicId };
+}
+var ED25519_MULTICODEC = Uint8Array.of(237, 1);
+function buildDidKey(publicKeyBytes) {
+  const prefixed = new Uint8Array(ED25519_MULTICODEC.length + publicKeyBytes.length);
+  prefixed.set(ED25519_MULTICODEC, 0);
+  prefixed.set(publicKeyBytes, ED25519_MULTICODEC.length);
+  return `did:key:${multibaseBase58btc(prefixed)}`;
+}
+function parseDidKey(did) {
+  const m = /^did:key:(z[1-9A-HJ-NP-Za-km-z]+)$/.exec(did ?? "");
+  if (!m) return null;
+  const multibase = m[1];
+  let decoded;
+  try {
+    decoded = base58Decode(multibase.slice(1));
+  } catch {
+    return null;
+  }
+  if (decoded.length !== ED25519_MULTICODEC.length + 32) return null;
+  if (decoded[0] !== ED25519_MULTICODEC[0] || decoded[1] !== ED25519_MULTICODEC[1]) return null;
+  return { method: "key", publicKeyMultibase: multibase, publicKeyBytes: decoded.slice(ED25519_MULTICODEC.length) };
+}
+function didPublicKeyBytes(did) {
+  return parseHederaDid(did)?.publicKeyBytes ?? parseDidKey(did)?.publicKeyBytes ?? null;
+}
+
+// src/features/magp/did.ts
+var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
+function ed25519KeyFromRaw(raw) {
+  const der = Buffer.concat([ED25519_SPKI_PREFIX, Buffer.from(raw)]);
+  return crypto.createPublicKey({ key: der, format: "der", type: "spki" });
+}
+function verifyDidSignature(did, message, signatureHex) {
+  const publicKeyBytes = didPublicKeyBytes(did);
+  if (!publicKeyBytes) return false;
+  try {
+    const key = ed25519KeyFromRaw(publicKeyBytes);
+    return crypto.verify(null, Buffer.from(message, "utf8"), key, Buffer.from(signatureHex, "hex"));
+  } catch {
+    return false;
+  }
+}
+function buildDidDocument(did, service) {
+  const hedera = parseHederaDid(did);
+  const key = hedera ? null : parseDidKey(did);
+  if (!hedera && !key) return null;
+  const publicKeyMultibase = hedera ? hedera.publicKeyMultibase : key.publicKeyMultibase;
+  const fragment = hedera ? "#did-root-key" : `#${key.publicKeyMultibase}`;
+  const vmId = `${did}${fragment}`;
+  const doc = {
+    "@context": ["https://www.w3.org/ns/did/v1"],
+    id: did,
+    controller: did,
+    verificationMethod: [
+      {
+        id: vmId,
+        type: "Ed25519VerificationKey2020",
+        controller: did,
+        publicKeyMultibase
+      }
+    ],
+    authentication: [vmId]
+  };
+  if (service) {
+    doc.service = [
+      {
+        id: `${did}#magp`,
+        type: "MAGPEndpoint",
+        serviceEndpoint: service.serviceEndpoint,
+        channels: service.channels,
+        protoVersions: service.protoVersions
+      }
+    ];
+  }
+  return doc;
+}
+export {
+  base58,
+  base58Decode,
+  buildDidDocument,
+  buildDidKey,
+  buildHederaDid,
+  didPublicKeyBytes,
+  ed25519KeyFromRaw,
+  multibaseBase58btc,
+  parseDidKey,
+  parseHederaDid,
+  verifyDidSignature
+};