@prismer/sdk 2.0.7 → 2.2.55

package/node_modules/@prismer/aip-sdk/dist/index.cjs

@@ -0,0 +1,368 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIPIdentity: () => AIPIdentity,
+  KeyResolver: () => KeyResolver,
+  buildCredential: () => buildCredential,
+  buildDelegation: () => buildDelegation,
+  buildEphemeralDelegation: () => buildEphemeralDelegation,
+  buildPresentation: () => buildPresentation,
+  didKeyToPublicKey: () => didKeyToPublicKey,
+  publicKeyToDIDKey: () => publicKeyToDIDKey,
+  validateDIDKey: () => validateDIDKey,
+  verifyCredential: () => verifyCredential,
+  verifyDelegation: () => verifyDelegation,
+  verifyEphemeralDelegation: () => verifyEphemeralDelegation,
+  verifyPresentation: () => verifyPresentation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/did.ts
+var ED25519_MULTICODEC = new Uint8Array([237, 1]);
+var B58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    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 output = "";
+  for (const byte of bytes) {
+    if (byte === 0) output += "1";
+    else break;
+  }
+  for (let i = digits.length - 1; i >= 0; i--) {
+    output += B58_ALPHABET[digits[i]];
+  }
+  return output;
+}
+function base58Decode(str) {
+  const bytes = [0];
+  for (const char of str) {
+    const index = B58_ALPHABET.indexOf(char);
+    if (index < 0) throw new Error(`Invalid base58 character: ${char}`);
+    let carry = index;
+    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;
+    }
+  }
+  for (const char of str) {
+    if (char === "1") bytes.push(0);
+    else break;
+  }
+  return new Uint8Array(bytes.reverse());
+}
+function publicKeyToDIDKey(pubBytes) {
+  if (pubBytes.length !== 32) throw new Error(`Expected 32 bytes, got ${pubBytes.length}`);
+  const mc = new Uint8Array(34);
+  mc.set(ED25519_MULTICODEC, 0);
+  mc.set(pubBytes, 2);
+  return `did:key:z${base58Encode(mc)}`;
+}
+function didKeyToPublicKey(did) {
+  if (!did.startsWith("did:key:z")) throw new Error("Invalid did:key format");
+  const decoded = base58Decode(did.slice(9));
+  if (decoded.length !== 34 || decoded[0] !== 237 || decoded[1] !== 1) {
+    throw new Error("Invalid did:key: wrong prefix or length");
+  }
+  return decoded.slice(2);
+}
+function validateDIDKey(did) {
+  try {
+    didKeyToPublicKey(did);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/identity.ts
+var _ed25519 = null;
+async function getEd25519() {
+  if (_ed25519) return _ed25519;
+  const mod = await import("@noble/curves/ed25519.js");
+  _ed25519 = mod.ed25519;
+  return _ed25519;
+}
+var AIPIdentity = class _AIPIdentity {
+  constructor(priv, pub, did) {
+    this.privateKey = priv;
+    this.publicKey = pub;
+    this.did = did;
+  }
+  static async create() {
+    const ed = await getEd25519();
+    const priv = ed.utils.randomSecretKey();
+    const pub = ed.getPublicKey(priv);
+    return new _AIPIdentity(priv, pub, publicKeyToDIDKey(pub));
+  }
+  /**
+   * @deprecated Compatibility derivation for existing Prismer Cloud identities.
+   * New applications should create and persist a random identity with create().
+   * The deterministic output remains unchanged throughout the 2.x release line.
+   */
+  static async fromApiKey(apiKey) {
+    const ed = await getEd25519();
+    const keyBytes = new TextEncoder().encode(apiKey);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", keyBytes);
+    const seed = new Uint8Array(hashBuffer);
+    const pub = ed.getPublicKey(seed);
+    return new _AIPIdentity(seed, pub, publicKeyToDIDKey(pub));
+  }
+  static async fromPrivateKey(key) {
+    const ed = await getEd25519();
+    const pub = ed.getPublicKey(key);
+    return new _AIPIdentity(key, pub, publicKeyToDIDKey(pub));
+  }
+  get publicKeyBase64() {
+    return typeof Buffer !== "undefined" ? Buffer.from(this.publicKey).toString("base64") : btoa(String.fromCharCode(...this.publicKey));
+  }
+  async sign(data) {
+    const ed = await getEd25519();
+    const sig = ed.sign(data, this.privateKey);
+    return typeof Buffer !== "undefined" ? Buffer.from(sig).toString("base64") : btoa(String.fromCharCode(...sig));
+  }
+  static async verify(data, sigB64, signerDid) {
+    try {
+      const ed = await getEd25519();
+      const pub = didKeyToPublicKey(signerDid);
+      const sig = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(sigB64, "base64")) : new Uint8Array(
+        atob(sigB64).split("").map((c) => c.charCodeAt(0))
+      );
+      return ed.verify(sig, data, pub);
+    } catch (e) {
+      return false;
+    }
+  }
+  getDIDDocument(params) {
+    var _a, _b;
+    const keyId = `${this.did}#keys-1`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const doc = {
+      "@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/suites/ed25519-2020/v1"],
+      id: this.did,
+      controller: this.did,
+      verificationMethod: [
+        { id: keyId, type: "Ed25519VerificationKey2020", controller: this.did, publicKeyMultibase: this.did.slice(8) }
+      ],
+      authentication: [keyId],
+      assertionMethod: [keyId],
+      capabilityDelegation: [keyId],
+      capabilityInvocation: [keyId],
+      created: now,
+      updated: now
+    };
+    if ((_a = params == null ? void 0 : params.services) == null ? void 0 : _a.length) {
+      doc.service = params.services.map((s, i) => ({
+        id: `${this.did}#service-${i}`,
+        type: s.type,
+        serviceEndpoint: s.endpoint
+      }));
+    }
+    if ((_b = params == null ? void 0 : params.capabilities) == null ? void 0 : _b.length) doc["aip:capabilities"] = params.capabilities;
+    return doc;
+  }
+  exportPrivateKey() {
+    return typeof Buffer !== "undefined" ? Buffer.from(this.privateKey).toString("base64") : btoa(String.fromCharCode(...this.privateKey));
+  }
+};
+
+// src/credentials.ts
+async function buildCredential(params) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const body = {
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiableCredential", params.type],
+    issuer: params.issuer.did,
+    validFrom: now,
+    credentialSubject: __spreadValues({ id: params.holderDid }, params.claims)
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.issuer.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.issuer.did}#keys-1`, proofPurpose: "assertionMethod", created: now, proofValue } });
+}
+async function buildPresentation(params) {
+  const body = {
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiablePresentation"],
+    holder: params.holder.did,
+    verifiableCredential: params.credentials
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body) + params.challenge);
+  const proofValue = await params.holder.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.holder.did}#keys-1`, challenge: params.challenge, proofValue } });
+}
+async function verifyCredential(vc) {
+  const _a = vc, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, vc.issuer);
+}
+async function verifyPresentation(vp, expectedChallenge) {
+  if (vp.proof.challenge !== expectedChallenge) return false;
+  const _a = vp, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body) + expectedChallenge);
+  const holderValid = await AIPIdentity.verify(data, proof.proofValue, vp.holder);
+  if (!holderValid) return false;
+  for (const vc of vp.verifiableCredential) {
+    if (!await verifyCredential(vc)) return false;
+  }
+  return true;
+}
+
+// src/delegation.ts
+async function buildDelegation(params) {
+  const now = /* @__PURE__ */ new Date();
+  const validUntil = params.validDays ? new Date(now.getTime() + params.validDays * 864e5) : void 0;
+  const body = __spreadProps(__spreadValues({
+    "@context": ["https://www.w3.org/ns/credentials/v2"],
+    type: ["VerifiableCredential", "AgentDelegation"],
+    issuer: params.issuer.did,
+    validFrom: now.toISOString()
+  }, validUntil && { validUntil: validUntil.toISOString() }), {
+    credentialSubject: __spreadValues({
+      id: params.subjectDid,
+      "aip:scope": params.scope
+    }, params.role && { "aip:role": params.role })
+  });
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.issuer.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.issuer.did}#keys-1`, proofPurpose: "assertionMethod", created: now.toISOString(), proofValue } });
+}
+async function buildEphemeralDelegation(params) {
+  const now = /* @__PURE__ */ new Date();
+  const validUntil = new Date(now.getTime() + params.ttlSeconds * 1e3);
+  const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), (b) => b.toString(16).padStart(2, "0")).join("");
+  const body = {
+    type: "EphemeralDelegation",
+    parentDid: params.parent.did,
+    sessionId: `sub_${nonce.slice(0, 8)}`,
+    scope: params.scope,
+    validFrom: now.toISOString(),
+    validUntil: validUntil.toISOString(),
+    nonce
+  };
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  const proofValue = await params.parent.sign(data);
+  return __spreadProps(__spreadValues({}, body), { proof: { type: "Ed25519Signature2020", verificationMethod: `${params.parent.did}#keys-1`, proofValue } });
+}
+async function verifyDelegation(delegation) {
+  if (new Date(delegation.validFrom) > /* @__PURE__ */ new Date()) return false;
+  if (delegation.validUntil && new Date(delegation.validUntil) < /* @__PURE__ */ new Date()) return false;
+  const _a = delegation, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, delegation.issuer);
+}
+async function verifyEphemeralDelegation(token) {
+  if (new Date(token.validUntil) < /* @__PURE__ */ new Date()) return false;
+  const _a = token, { proof } = _a, body = __objRest(_a, ["proof"]);
+  const data = new TextEncoder().encode(JSON.stringify(body));
+  return AIPIdentity.verify(data, proof.proofValue, token.parentDid);
+}
+
+// src/resolver.ts
+var KeyResolver = class {
+  async resolve(did) {
+    if (!did.startsWith("did:key:")) {
+      throw new Error(`KeyResolver only supports did:key, got: ${did}`);
+    }
+    const pubBytes = didKeyToPublicKey(did);
+    const keyId = `${did}#keys-1`;
+    const multibase = did.slice(8);
+    return {
+      "@context": ["https://www.w3.org/ns/did/v1"],
+      id: did,
+      controller: did,
+      verificationMethod: [{ id: keyId, type: "Ed25519VerificationKey2020", controller: did, publicKeyMultibase: multibase }],
+      authentication: [keyId],
+      assertionMethod: [keyId]
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIPIdentity,
+  KeyResolver,
+  buildCredential,
+  buildDelegation,
+  buildEphemeralDelegation,
+  buildPresentation,
+  didKeyToPublicKey,
+  publicKeyToDIDKey,
+  validateDIDKey,
+  verifyCredential,
+  verifyDelegation,
+  verifyEphemeralDelegation,
+  verifyPresentation
+});

package/node_modules/@prismer/aip-sdk/dist/index.d.cts

@@ -0,0 +1,174 @@
+/**
+ * AIPIdentity — standalone DID identity class (no platform dependency)
+ */
+interface DIDDocument {
+    '@context': string[];
+    id: string;
+    controller: string;
+    verificationMethod: {
+        id: string;
+        type: string;
+        controller: string;
+        publicKeyMultibase: string;
+    }[];
+    authentication: string[];
+    assertionMethod: string[];
+    capabilityDelegation: string[];
+    capabilityInvocation: string[];
+    service?: {
+        id: string;
+        type: string;
+        serviceEndpoint: string;
+    }[];
+    'aip:capabilities'?: string[];
+    created: string;
+    updated: string;
+}
+interface SignedPayload {
+    senderDid: string;
+    signature: string;
+    payload: Uint8Array;
+}
+declare class AIPIdentity {
+    readonly did: string;
+    readonly publicKey: Uint8Array;
+    private readonly privateKey;
+    private constructor();
+    static create(): Promise<AIPIdentity>;
+    /**
+     * @deprecated Compatibility derivation for existing Prismer Cloud identities.
+     * New applications should create and persist a random identity with create().
+     * The deterministic output remains unchanged throughout the 2.x release line.
+     */
+    static fromApiKey(apiKey: string): Promise<AIPIdentity>;
+    static fromPrivateKey(key: Uint8Array): Promise<AIPIdentity>;
+    get publicKeyBase64(): string;
+    sign(data: Uint8Array): Promise<string>;
+    static verify(data: Uint8Array, sigB64: string, signerDid: string): Promise<boolean>;
+    getDIDDocument(params?: {
+        services?: {
+            type: string;
+            endpoint: string;
+        }[];
+        capabilities?: string[];
+    }): DIDDocument;
+    exportPrivateKey(): string;
+}
+
+/**
+ * Verifiable Credentials and Presentations (W3C VC Data Model v2)
+ */
+
+interface VerifiableCredential {
+    '@context': string[];
+    type: string[];
+    issuer: string;
+    validFrom: string;
+    credentialSubject: {
+        id: string;
+        [key: string]: any;
+    };
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofPurpose: string;
+        created: string;
+        proofValue: string;
+    };
+}
+interface VerifiablePresentation {
+    '@context': string[];
+    type: string[];
+    holder: string;
+    verifiableCredential: VerifiableCredential[];
+    proof: {
+        type: string;
+        verificationMethod: string;
+        challenge: string;
+        proofValue: string;
+    };
+}
+declare function buildCredential(params: {
+    issuer: AIPIdentity;
+    holderDid: string;
+    type: string;
+    claims: Record<string, any>;
+}): Promise<VerifiableCredential>;
+declare function buildPresentation(params: {
+    holder: AIPIdentity;
+    credentials: VerifiableCredential[];
+    challenge: string;
+}): Promise<VerifiablePresentation>;
+declare function verifyCredential(vc: VerifiableCredential): Promise<boolean>;
+declare function verifyPresentation(vp: VerifiablePresentation, expectedChallenge: string): Promise<boolean>;
+
+/**
+ * Verifiable and Ephemeral Delegations
+ */
+
+interface VerifiableDelegation {
+    '@context': string[];
+    type: string[];
+    issuer: string;
+    validFrom: string;
+    validUntil?: string;
+    credentialSubject: {
+        id: string;
+        'aip:scope': string[];
+        'aip:role'?: string;
+    };
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofPurpose: string;
+        created: string;
+        proofValue: string;
+    };
+}
+interface EphemeralDelegation {
+    type: 'EphemeralDelegation';
+    parentDid: string;
+    sessionId: string;
+    scope: string[];
+    validFrom: string;
+    validUntil: string;
+    nonce: string;
+    proof: {
+        type: string;
+        verificationMethod: string;
+        proofValue: string;
+    };
+}
+declare function buildDelegation(params: {
+    issuer: AIPIdentity;
+    subjectDid: string;
+    scope: string[];
+    role?: string;
+    validDays?: number;
+}): Promise<VerifiableDelegation>;
+declare function buildEphemeralDelegation(params: {
+    parent: AIPIdentity;
+    scope: string[];
+    ttlSeconds: number;
+}): Promise<EphemeralDelegation>;
+declare function verifyDelegation(delegation: VerifiableDelegation): Promise<boolean>;
+declare function verifyEphemeralDelegation(token: EphemeralDelegation): Promise<boolean>;
+
+declare function publicKeyToDIDKey(pubBytes: Uint8Array): string;
+declare function didKeyToPublicKey(did: string): Uint8Array;
+declare function validateDIDKey(did: string): boolean;
+
+/**
+ * DID Resolver — resolve did:key locally, did:web via HTTPS
+ */
+interface DIDResolver {
+    resolve(did: string): Promise<any>;
+}
+/**
+ * KeyResolver — resolves did:key locally (no network).
+ */
+declare class KeyResolver implements DIDResolver {
+    resolve(did: string): Promise<any>;
+}
+
+export { AIPIdentity, type DIDDocument, type DIDResolver, type EphemeralDelegation, KeyResolver, type SignedPayload, type VerifiableCredential, type VerifiableDelegation, type VerifiablePresentation, buildCredential, buildDelegation, buildEphemeralDelegation, buildPresentation, didKeyToPublicKey, publicKeyToDIDKey, validateDIDKey, verifyCredential, verifyDelegation, verifyEphemeralDelegation, verifyPresentation };