@openentity/sdk 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -43,8 +43,11 @@ type VerifyResult = {
     signer?: string;
     error?: string;
 };
-export declare function signProof(obj: object, kp: KeyPair, created?: string): Promise<Proof>;
-export declare function signObject<T extends object>(obj: T, kp: KeyPair, created?: string): Promise<T & {
+/** eddsa-jcs-2022 hashData: sha256(JCS(proof config)) || sha256(JCS(document)). */
+export declare function hashData(obj: object, config: Omit<Proof, "proofValue">): Uint8Array;
+/** `verificationMethod` defaults to the did:key of `kp`; a did:web signer passes its own method id (for example `did:web:x#key-1`). */
+export declare function signProof(obj: object, kp: KeyPair, created?: string, verificationMethod?: string): Promise<Proof>;
+export declare function signObject<T extends object>(obj: T, kp: KeyPair, created?: string, verificationMethod?: string): Promise<T & {
     proof: Proof;
 }>;
 export declare function verifyProof(obj: object, proof: Proof, resolver?: Resolver): Promise<VerifyResult>;
@@ -72,9 +75,36 @@ export declare function buildDeclaration(input: {
     name: string;
     created?: string;
 }): object;
+/** The successor's unsigned seq 1 Entity Document: `prev` re-keyed, aliases dropped (their proofs name the old EID), `continuity.previous` set. */
+export declare function successorDocument(prev: Record<string, any>, next: KeyPair, created?: string): Record<string, any>;
+/** A Continuity Link signed by both keys (spec 9.2) plus the successor's document signed by the successor: the body of `POST /v1/continuity`. */
+export declare function buildRotation(previous: KeyPair, successor: KeyPair, document: Record<string, any>, o?: {
+    basis?: "rotation" | "migration";
+    created?: string;
+    nonce?: string;
+}): Promise<{
+    link: Record<string, any>;
+    document: Record<string, any>;
+}>;
+/**
+ * Rotate `previous` to a new key in one call: fetch the current document, build and sign the link, mint the stamp for the
+ * successor and submit. Nothing is persisted: on success the caller saves `successor` (its `privateJwk`) and only then retires
+ * the old key. Throws on any non-2xx answer.
+ */
+export declare function rotate(o: {
+    previous: KeyPair;
+    registry?: string;
+    successor?: KeyPair;
+    basis?: "rotation" | "migration";
+}): Promise<{
+    successor: KeyPair;
+    link: Record<string, any>;
+    document: Record<string, any>;
+    response: any;
+}>;
 /** sha256 hex of the canonical entry INCLUDING its proof: the next entry's `prev` (spec 7.4). */
 export declare function recordEntryHash(entry: object): Promise<string>;
-type ObjectType = "EntityDocument" | "Declaration" | "Withdrawal" | "RecordEntry" | "Attestation" | "Revocation" | "ContinuityLink" | "Dispute" | "LogLeaf";
+type ObjectType = "EntityDocument" | "Declaration" | "Withdrawal" | "Redaction" | "RecordEntry" | "Attestation" | "Revocation" | "ContinuityLink" | "Dispute" | "Presentation" | "LogLeaf";
 /** Schema check (spec Appendix A) plus size caps: 16 KB for a RecordEntry (7.4), 64 KB for anything else (5.2). */
 export declare function validate(type: ObjectType, obj: unknown): {
     ok: boolean;
@@ -101,4 +131,81 @@ export declare function signNote(body: string, keyName: string, kp: KeyPair): Pr
 /** C2SP vkey for a note key: `<name>+<key id hex>+<base64(0x01 || pubkey)>`. */
 export declare function noteVkey(keyName: string, publicKey: Uint8Array): string;
 export declare function verifyNote(note: string, keyName: string, publicKey: Uint8Array): Promise<boolean>;
+/** Sign a proof of control of `kp`'s EID for one audience and one verifier-issued nonce, optionally carrying attestations. */
+export declare function buildPresentation(kp: KeyPair, opts: {
+    audience: string;
+    nonce: string;
+    attestations?: object[];
+}): Promise<object>;
+type AttestationCheck = {
+    claim_type?: string;
+    issuer?: string;
+    ok: boolean;
+    error?: string;
+};
+/**
+ * Check a presentation the verifier asked for: schema, signature by the EID itself, audience, nonce, freshness (5 minutes).
+ * Each carried attestation is checked for subject, expiry and its issuer's signature; revocation needs the issuer or a
+ * registry and is the caller's to check when online. `ok` covers the presentation; attestations are reported one by one.
+ */
+export declare function verifyPresentation(p: any, opts: {
+    audience: string;
+    nonce: string;
+    now?: Date;
+    maxAgeSeconds?: number;
+    resolver?: Resolver;
+}): Promise<{
+    ok: boolean;
+    eid?: string;
+    errors: string[];
+    attestations: AttestationCheck[];
+}>;
+export declare const A2A_EXTENSION_URI = "https://openentity.org/spec/1.0";
+/** The AgentExtension entry that carries an EID in an A2A Agent Card's `capabilities.extensions`. */
+export declare function a2aExtension(eid: string, documentUrl: string): {
+    uri: string;
+    description: string;
+    required: boolean;
+    params: {
+        eid: string;
+        document: string;
+    };
+};
+/** A full A2A AgentCard for an Entity Document: each capability slug becomes a skill. `url` is the agent's A2A endpoint. */
+export declare function agentCard(doc: {
+    eid: string;
+    name: string;
+    description: string;
+    capabilities?: string[];
+}, opts: {
+    url: string;
+    documentUrl: string;
+    version?: string;
+}): {
+    name: string;
+    description: string;
+    url: string;
+    version: string;
+    capabilities: {
+        streaming: boolean;
+        pushNotifications: boolean;
+        extensions: {
+            uri: string;
+            description: string;
+            required: boolean;
+            params: {
+                eid: string;
+                document: string;
+            };
+        }[];
+    };
+    defaultInputModes: string[];
+    defaultOutputModes: string[];
+    skills: {
+        id: string;
+        name: string;
+        description: string;
+        tags: string[];
+    }[];
+};
 export {};