@learncard/didkit-plugin 1.9.3 → 1.9.5

package/src/didkit/pkg/didkit_wasm_bg.wasm.d.ts

@@ -0,0 +1,51 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const DIDAuth: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const JWKFromTezos: (a: number, b: number) => any;
+export const clearCache: () => any;
+export const completeDelegateCapability: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const completeInvokeCapability: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const completeIssueCredential: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const completeIssuePresentation: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const contextLoader: (a: number, b: number) => any;
+export const createDagJwe: (a: any, b: number, c: number) => any;
+export const createJwe: (a: number, b: number, c: number, d: number) => any;
+export const decryptDagJwe: (a: number, b: number, c: number, d: number) => any;
+export const decryptJwe: (a: number, b: number, c: number, d: number) => any;
+export const delegateCapability: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const didResolver: (a: number, b: number, c: number, d: number) => any;
+export const didToVerificationMethod: (a: number, b: number) => any;
+export const generateEd25519Key: () => [number, number, number, number];
+export const generateEd25519KeyFromBytes: (a: number, b: number) => [number, number, number, number];
+export const generateSecp256k1Key: () => [number, number, number, number];
+export const generateSecp256k1KeyFromBytes: (a: number, b: number) => [number, number, number, number];
+export const getVersion: () => [number, number];
+export const invokeCapability: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const issueCredential: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const issuePresentation: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const keyToDID: (a: number, b: number, c: number, d: number) => [number, number, number, number];
+export const keyToVerificationMethod: (a: number, b: number, c: number, d: number) => any;
+export const prepareDelegateCapability: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const prepareInvokeCapability: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => any;
+export const prepareIssueCredential: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const prepareIssuePresentation: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const resolveDID: (a: number, b: number, c: number, d: number) => any;
+export const verifyCredential: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const verifyDelegation: (a: number, b: number) => any;
+export const verifyInvocation: (a: number, b: number, c: number, d: number) => any;
+export const verifyInvocationSignature: (a: number, b: number) => any;
+export const verifyPresentation: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const didkit_error_code: () => number;
+export const didkit_error_message: () => number;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_export_4: WebAssembly.Table;
+export const __wbindgen_export_5: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const closure4149_externref_shim: (a: number, b: number, c: any) => void;
+export const closure4546_externref_shim: (a: number, b: number, c: any, d: any) => void;
+export const __wbindgen_start: () => void;

package/src/helpers.ts

@@ -0,0 +1,41 @@
+import { LearnCard } from '@learncard/core';
+
+export const getContextURIs = (jsonld: Record<string, any>) => {
+    const contexts: string[] = [];
+
+    const traverse = (obj: Record<string, any>) => {
+        if (typeof obj !== 'object' || obj === null) return;
+
+        if (obj['@context']) {
+            if (Array.isArray(obj['@context'])) contexts.push(...obj['@context']);
+            else contexts.push(obj['@context']);
+        }
+
+        Object.keys(obj).forEach(key => {
+            traverse(obj[key]);
+        });
+    };
+
+    traverse(jsonld);
+
+    return contexts;
+};
+
+export const getDocumentMap = async (
+    learnCard: LearnCard<any, 'context'>,
+    obj: Record<string, any>,
+    allowRemoteContexts = false
+) => {
+    const uris = getContextURIs(obj);
+    const resolvedDocs = await Promise.all(
+        uris.map(async uri => learnCard.context.resolveDocument(uri, allowRemoteContexts))
+    );
+
+    return uris.reduce<Record<string, string>>((acc, cur, index) => {
+        const resolvedDoc = resolvedDocs[index];
+
+        if (resolvedDoc) acc[cur] = JSON.stringify(resolvedDoc);
+
+        return acc;
+    }, {});
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './plugin';
+export * from './helpers';

package/src/plugin.ts

@@ -0,0 +1,200 @@
+import init, {
+    InitInput,
+    generateEd25519KeyFromBytes,
+    generateSecp256k1KeyFromBytes,
+    keyToDID,
+    keyToVerificationMethod,
+    didToVerificationMethod,
+    issueCredential,
+    verifyCredential,
+    issuePresentation,
+    verifyPresentation,
+    contextLoader,
+    resolveDID,
+    didResolver,
+    createJwe,
+    decryptJwe,
+    createDagJwe,
+    decryptDagJwe,
+    clearCache,
+} from './didkit/index';
+import { getDocumentMap } from './helpers';
+
+import { DIDKitPlugin, DidMethod } from './types';
+
+/**
+ j
+ * @group Plugins
+ */
+export const getDidKitPlugin = async (
+    input?: InitInput | Promise<InitInput>,
+    allowRemoteContexts = false
+): Promise<DIDKitPlugin> => {
+    await init(input);
+
+    const memoizedDids: Partial<Record<DidMethod, string>> = {};
+
+    return {
+        name: 'DIDKit',
+        displayName: 'DIDKit',
+        description:
+            'Provides an interface to DIDKit, which allows for the generation of key material, as well as signing and verifying credentials and presentations',
+        context: {
+            resolveStaticDocument: async (_learnCard, url) => {
+                try {
+                    return JSON.parse((await contextLoader(url)) ?? '') || undefined;
+                } catch (error) {
+                    _learnCard.debug?.(error);
+
+                    return undefined;
+                }
+            },
+        },
+        methods: {
+            generateEd25519KeyFromBytes: (_learnCard, bytes) =>
+                JSON.parse(generateEd25519KeyFromBytes(bytes)),
+
+            generateSecp256k1KeyFromBytes: (_learnCard, bytes) =>
+                JSON.parse(generateSecp256k1KeyFromBytes(bytes)),
+
+            keyToDid: (_learnCard, type, keypair) => {
+                return keyToDID(type, JSON.stringify(keypair));
+            },
+
+            keyToVerificationMethod: async (_learnCard, type, keypair) =>
+                keyToVerificationMethod(type, JSON.stringify(keypair)),
+
+            didToVerificationMethod: async (_learnCard, did) => didToVerificationMethod(did),
+
+            issueCredential: async (_learnCard, credential, options, keypair) => {
+                return JSON.parse(
+                    await issueCredential(
+                        JSON.stringify(credential),
+                        JSON.stringify(options),
+                        JSON.stringify(keypair),
+                        JSON.stringify(
+                            await getDocumentMap(_learnCard, credential, allowRemoteContexts)
+                        )
+                    )
+                );
+            },
+
+            verifyCredential: async (_learnCard, credential, options = {}) => {
+                return JSON.parse(
+                    await verifyCredential(
+                        JSON.stringify(credential),
+                        JSON.stringify(options),
+                        JSON.stringify(
+                            await getDocumentMap(_learnCard, credential, allowRemoteContexts)
+                        )
+                    )
+                );
+            },
+
+            issuePresentation: async (_learnCard, presentation, options, keypair) => {
+                const isJwt = options.proofFormat === 'jwt';
+
+                const result = await issuePresentation(
+                    JSON.stringify(presentation),
+                    JSON.stringify(options),
+                    JSON.stringify(keypair),
+                    JSON.stringify(
+                        await getDocumentMap(_learnCard, presentation, allowRemoteContexts)
+                    )
+                );
+
+                return isJwt ? result : JSON.parse(result);
+            },
+
+            verifyPresentation: async (_learnCard, presentation, options = {}) => {
+                const isJwt = typeof presentation === 'string';
+
+                return JSON.parse(
+                    await verifyPresentation(
+                        isJwt ? presentation : JSON.stringify(presentation),
+                        JSON.stringify(options),
+                        isJwt
+                            ? '{}'
+                            : JSON.stringify(
+                                  await getDocumentMap(
+                                      _learnCard,
+                                      presentation,
+                                      allowRemoteContexts
+                                  )
+                              )
+                    )
+                );
+            },
+
+            contextLoader: async (_learnCard, url) => {
+                try {
+                    return JSON.parse((await contextLoader(url)) ?? '') || undefined;
+                } catch (error) {
+                    _learnCard.debug?.(error);
+
+                    return undefined;
+                }
+            },
+
+            resolveDid: async (_learnCard, did, inputMetadata = {}) =>
+                JSON.parse(await resolveDID(did, JSON.stringify(inputMetadata))),
+
+            didResolver: async (_learnCard, did, inputMetadata = {}) =>
+                JSON.parse(await didResolver(did, JSON.stringify(inputMetadata))),
+
+            createJwe: async (_learnCard, cleartext, recipients) =>
+                JSON.parse(await createJwe(cleartext, recipients)),
+
+            decryptJwe: async (_learnCard, jwe, jwks) =>
+                decryptJwe(
+                    JSON.stringify(jwe),
+                    jwks.map(jwk => JSON.stringify(jwk))
+                ),
+
+            createDagJwe: async (_learnCard, cleartext, recipients) =>
+                JSON.parse(await createDagJwe(cleartext as any, recipients)),
+
+            decryptDagJwe: async (_learnCard, jwe, jwks) => {
+                // Didkit is serializing numbers as BigInts when crossing the WASM boundary, so we
+                // need to convert them back to numbers
+                const convertBigIntsToNumbers = (obj: any): any => {
+                    if (obj === null || obj === undefined) return obj;
+
+                    // Convert BigInt to Number
+                    if (typeof obj === 'bigint') return Number(obj);
+
+                    // Handle arrays
+                    if (Array.isArray(obj)) return obj.map(convertBigIntsToNumbers);
+
+                    // Return primitives as-is
+                    if (typeof obj !== 'object') return obj;
+
+                    // -- Handle objects --
+
+                    // Quick check if the object has any nested objects that need conversion
+                    const hasNestedObjects = Object.values(obj).some(
+                        val => typeof val === 'bigint' || (typeof val === 'object' && val !== null)
+                    );
+                    if (!hasNestedObjects) return obj; // Fast path for simple objects
+
+                    const result: Record<string, any> = {};
+                    for (const key in obj) {
+                        result[key] = convertBigIntsToNumbers(obj[key]);
+                    }
+                    return result;
+                };
+
+                return convertBigIntsToNumbers(
+                    await decryptDagJwe(
+                        JSON.stringify(jwe),
+                        jwks.map(jwk => JSON.stringify(jwk))
+                    )
+                );
+            },
+
+            clearDidWebCache: async () => {
+                await clearCache();
+            },
+        },
+    };
+};

package/src/types.ts

@@ -0,0 +1,96 @@
+import {
+    JWE,
+    JWKWithPrivateKey,
+    UnsignedVC,
+    UnsignedVP,
+    VC,
+    VP,
+    VerificationCheck,
+    DidDocument,
+} from '@learncard/types';
+import type { DIDResolutionResult } from 'dids';
+import { Plugin } from '@learncard/core';
+
+/** @group DIDKit Plugin */
+export type DidMethod =
+    | 'key'
+    | 'tz'
+    | 'ethr'
+    | `pkh:${
+          | 'tz'
+          | 'tezos'
+          | 'sol'
+          | 'solana'
+          | 'eth'
+          | 'celo'
+          | 'poly'
+          | 'btc'
+          | 'doge'
+          | 'eip155'
+          | 'bip122'}`
+    | `pkh:eip155:${string}`
+    | `pkh:bip122:${string}`;
+
+/** @group DIDKit Plugin */
+export type DataIntegrityCryptosuite =
+    | 'eddsa-rdfc-2022'
+    | 'eddsa-2022'
+    | 'json-eddsa-2022'
+    | 'ecdsa-2019'
+    | 'jcs-ecdsa-2019';
+
+/** @group DIDKit Plugin */
+export type ProofOptions = {
+    type?: string;
+    verificationMethod?: string;
+    proofPurpose?: string;
+    proofFormat?: string;
+    created?: string;
+    challenge?: string;
+    domain?: string;
+    checks?: ('proof' | 'JWS' | 'credentialStatus' | 'credentialSchema')[];
+    cryptosuite?: DataIntegrityCryptosuite;
+};
+
+/** @group DIDKit Plugin */
+export type InputMetadata = {
+    accept?: string;
+    versionId?: string;
+    versionTime?: string;
+    noCache?: boolean;
+};
+
+/** @group DIDKit Plugin */
+export type DidkitPluginMethods = {
+    generateEd25519KeyFromBytes: (bytes: Uint8Array) => JWKWithPrivateKey;
+    generateSecp256k1KeyFromBytes: (bytes: Uint8Array) => JWKWithPrivateKey;
+    keyToDid: (type: DidMethod, keypair: JWKWithPrivateKey) => string;
+    keyToVerificationMethod: (type: string, keypair: JWKWithPrivateKey) => Promise<string>;
+    didToVerificationMethod: (did: string) => Promise<string>;
+    issueCredential: (
+        credential: UnsignedVC,
+        options: ProofOptions,
+        keypair: JWKWithPrivateKey
+    ) => Promise<VC>;
+    verifyCredential: (credential: VC, options?: ProofOptions) => Promise<VerificationCheck>;
+    issuePresentation: (
+        presentation: UnsignedVP,
+        options: ProofOptions,
+        keypair: JWKWithPrivateKey
+    ) => Promise<VP>;
+    verifyPresentation: (
+        presentation: VP | string,
+        options?: ProofOptions
+    ) => Promise<VerificationCheck>;
+    contextLoader: (url: string) => Promise<Record<string, any>>;
+    resolveDid: (did: string, inputMetadata?: InputMetadata) => Promise<DidDocument>;
+    didResolver: (did: string, inputMetadata?: InputMetadata) => Promise<DIDResolutionResult>;
+    createJwe: (cleartext: string, recipients: string[]) => Promise<JWE>;
+    decryptJwe: (jwe: JWE, jwks: JWKWithPrivateKey[]) => Promise<string>;
+    createDagJwe: <T>(cleartext: T, recipients: string[]) => Promise<JWE>;
+    decryptDagJwe: <T>(jwe: JWE, jwks: JWKWithPrivateKey[]) => Promise<T>;
+    clearDidWebCache: () => Promise<void>;
+};
+
+/** @group DIDKit Plugin */
+export type DIDKitPlugin = Plugin<'DIDKit', 'context', DidkitPluginMethods>;