@learncard/network-plugin 2.13.4 → 2.13.6

package/src/plugin.ts

@@ -0,0 +1,2747 @@
+import { getClient, getApiTokenClient } from '@learncard/network-brain-client';
+import {
+    JWEValidator,
+    LCNProfile,
+    LCNVisibleProfile,
+    UnsignedVCValidator,
+    VCValidator,
+    VPValidator,
+    Profile,
+    ConsentFlowContractValidator,
+    ConsentFlowTermsValidator,
+    JWE,
+    UnsignedVC,
+    VC,
+    BitstringCredentialStatusEntry,
+    BitstringCredentialStatusPurpose,
+    StoredCredentialEnvelope,
+    StoredCredentialEnvelopeValidator,
+    isStoredCredentialEnvelope,
+} from '@learncard/types';
+import { LearnCard } from '@learncard/core';
+import { VerifyExtension } from '@learncard/vc-plugin';
+import {
+    getCredentialStatusArray,
+    isVC2Format,
+    resolveStorageReadResult,
+} from '@learncard/helpers';
+import Mustache from 'mustache';
+
+import {
+    LearnCardNetworkPluginDependentMethods,
+    LearnCardNetworkPlugin,
+    VerifyBoostPlugin,
+    TrustedBoostRegistryEntry,
+} from './types';
+
+const uint8ArrayToBase64Url = (bytes: Uint8Array): string => {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 1) binary += String.fromCharCode(bytes[i]!);
+    const base64 =
+        typeof btoa === 'function'
+            ? btoa(binary)
+            : Buffer.from(binary, 'binary').toString('base64');
+    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+};
+
+type WireEnvelope = StoredCredentialEnvelope & { data: string };
+
+const normalizeEnvelopeForTransport = <T>(
+    value: T
+): Exclude<T, StoredCredentialEnvelope> | WireEnvelope => {
+    if (!isStoredCredentialEnvelope(value)) {
+        return value as Exclude<T, StoredCredentialEnvelope>;
+    }
+    if (typeof value.data === 'string') return value as WireEnvelope;
+    return { ...value, data: uint8ArrayToBase64Url(value.data) };
+};
+
+/* -------------------------------------------------------------------------- *
+ * Boost template rendering helpers
+ * -------------------------------------------------------------------------- *
+ *
+ * A "boost" is stored on the server as a JSON string that may contain Mustache
+ * variables (e.g. `{{recipient_name}}`, `{{#evidence}}...{{/evidence}}`). When
+ * we send a boost to a recipient, we substitute those variables with values
+ * from `templateData` BEFORE the JSON is parsed back into a credential object.
+ *
+ * Because substitution happens against a raw JSON string, any user-supplied
+ * value (names, titles, descriptions, etc.) must be escaped so that control
+ * characters do not corrupt the JSON. The helpers below implement that
+ * escape-then-render pipeline, plus a small evidence-merging step for template
+ * data that carries an `evidence` field.
+ *
+ * The same behavior is implemented server-side in
+ * `brain-service/src/helpers/template.helpers.ts`. If you change the escaping
+ * rules here, mirror the change there (and vice versa) so that client-side
+ * and server-side rendering produce identical output.
+ * -------------------------------------------------------------------------- */
+
+/**
+ * Escapes a single scalar value so it can be safely inlined inside a JSON
+ * string literal.
+ *
+ * The order of replacements matters: backslashes MUST be escaped first,
+ * otherwise subsequent replacements (which themselves introduce backslashes)
+ * would be double-escaped and produce invalid JSON.
+ *
+ * Null / undefined coerce to an empty string so Mustache renders nothing
+ * rather than the literal text "null" / "undefined" inside the JSON.
+ *
+ * @param value - Any scalar value to be rendered into a JSON string position
+ * @returns A string whose characters are valid inside a JSON string literal
+ */
+const escapeJsonStringValue = (value: unknown): string => {
+    if (value === null || value === undefined) return '';
+
+    return String(value)
+        .replace(/\\/g, '\\\\') // backslash — must run first
+        .replace(/"/g, '\\"') // double quote — would close the JSON string
+        .replace(/\n/g, '\\n') // newline
+        .replace(/\r/g, '\\r') // carriage return
+        .replace(/\t/g, '\\t') // tab
+        .replace(/\f/g, '\\f') // form feed
+        .replace(/[\b]/g, '\\b'); // backspace (character class to dodge \b word-boundary)
+};
+
+/**
+ * Recursively walks a template-data value and escapes every string leaf for
+ * JSON safety, while preserving the original array / object shape.
+ *
+ * Keeping the structure intact is important because Mustache sections such as
+ * `{{#evidence}}...{{/evidence}}` iterate over arrays and read properties off
+ * the objects inside them — we cannot simply flatten everything to strings.
+ *
+ * Non-string primitives (numbers, booleans) are passed through untouched so
+ * that the template author can decide whether to render them quoted or bare.
+ */
+const prepareTemplateValue = (value: unknown): unknown => {
+    if (value === null || value === undefined) return '';
+    if (Array.isArray(value)) return value.map(prepareTemplateValue);
+    if (typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value as Record<string, unknown>).map(([key, nestedValue]) => [
+                key,
+                prepareTemplateValue(nestedValue),
+            ])
+        );
+    }
+    if (typeof value === 'string') return escapeJsonStringValue(value);
+
+    return value;
+};
+
+/**
+ * Top-level wrapper around {@link prepareTemplateValue} that returns a new
+ * object with every leaf string escaped for JSON safety.
+ *
+ * Only the direct top-level entries are enumerated here; deeper recursion is
+ * delegated to {@link prepareTemplateValue}.
+ */
+const prepareTemplateData = (templateData: Record<string, unknown>): Record<string, unknown> => {
+    const prepared: Record<string, unknown> = {};
+
+    for (const [key, value] of Object.entries(templateData)) {
+        prepared[key] = prepareTemplateValue(value);
+    }
+
+    return prepared;
+};
+
+/**
+ * Renders a Mustache-templated JSON string using `templateData`, with two
+ * LearnCard-specific adjustments on top of stock Mustache:
+ *
+ * 1. `templateData` is pre-escaped via {@link prepareTemplateData} so that
+ *    user-supplied strings do not break the surrounding JSON.
+ * 2. Plain `{{var}}` tags are rewritten to triple-mustache `{{{var}}}` to
+ *    disable Mustache's built-in HTML escaping. We want our own JSON escaping
+ *    (from step 1), not `&amp;` / `&quot;` HTML entities.
+ *
+ * Section / comment / partial / unescaped tags — anything starting with
+ * `#`, `^`, `/`, `!`, `>`, `&`, or `=` — are left alone; Mustache already
+ * handles those correctly.
+ *
+ * @param jsonString - The raw boost JSON string containing `{{variables}}`
+ * @param templateData - Values to substitute, keyed by variable name
+ * @returns The rendered JSON string, ready to be `JSON.parse`'d
+ */
+const renderTemplateJson = (jsonString: string, templateData: Record<string, unknown>): string => {
+    const preparedData = prepareTemplateData(templateData);
+
+    // Rewrite `{{var}}` → `{{{var}}}` so Mustache skips its HTML escaping.
+    // Anything with a control sigil (#, ^, /, !, >, &, =) is a section /
+    // comment / partial / unescaped tag and must be passed through verbatim.
+    const unescapedTemplate = jsonString.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (match, tag) => {
+        const trimmedTag = tag.trim();
+
+        return /^[#^/!>&=]/.test(trimmedTag) ? match : `{{{${trimmedTag}}}}`;
+    });
+
+    return Mustache.render(unescapedTemplate, preparedData);
+};
+
+/**
+ * Returns `true` if the boost template itself already references `evidence`
+ * as a Mustache variable / section (e.g. `{{evidence}}`, `{{#evidence}}`,
+ * `{{evidence.id}}`).
+ *
+ * The trailing `[.\s}]|$` boundary prevents false positives on tokens that
+ * merely START with the word `evidence`, such as `{{evidenceList}}` or
+ * `{{evidenceItem.foo}}` — those should NOT count as the author handling
+ * evidence themselves.
+ *
+ * When this returns `true` the caller should skip the auto-append step in
+ * {@link appendTemplateEvidence} to avoid duplicating entries (the template
+ * author is already placing evidence wherever they want it in the output).
+ */
+const hasDynamicEvidenceTemplate = (jsonString: string): boolean => {
+    return /\{\{\s*[#^/]?\s*evidence(?:[.\s}]|$)/.test(jsonString);
+};
+
+/**
+ * Merges any `evidence` entries supplied in `templateData` onto the boost's
+ * top-level `evidence` array.
+ *
+ * This exists because not every boost template opts into rendering evidence
+ * via a `{{evidence}}` section. For those templates we still want evidence
+ * supplied at send-time (e.g. a recipient-specific media attachment) to land
+ * on the final credential — so we append it as a post-render step.
+ *
+ * Behavior:
+ * - Skipped entirely when `allowAutoAppend` is `false`. The caller typically
+ *   derives that flag from {@link hasDynamicEvidenceTemplate} — if the
+ *   template renders evidence itself, we must NOT also append it here, or the
+ *   recipient would see the same evidence twice.
+ * - Accepts either a single evidence object or an array of them under
+ *   `templateData.evidence` and normalizes to an array.
+ * - Strips the internal `last` marker used by upstream list-rendering code;
+ *   that field is a rendering hint and should never land on the credential.
+ * - Preserves any evidence already present on the boost and appends the new
+ *   entries after it.
+ *
+ * @param boost - The parsed credential object produced by `JSON.parse`
+ * @param templateData - The same template data used for rendering; may contain an `evidence` field
+ * @param allowAutoAppend - Set to `false` when the template already renders evidence itself
+ * @returns A new boost object (or the original reference when nothing changed)
+ */
+const appendTemplateEvidence = (
+    boost: any,
+    templateData?: Record<string, unknown>,
+    allowAutoAppend: boolean = true
+) => {
+    if (!allowAutoAppend) return boost;
+
+    const templateEvidence = templateData?.evidence;
+
+    if (!templateEvidence) return boost;
+
+    // Accept either a single evidence object or an array; drop the `last`
+    // marker that upstream rendering code uses for iteration hints.
+    const normalizedTemplateEvidence = (
+        Array.isArray(templateEvidence) ? templateEvidence : [templateEvidence]
+    ).map(evidenceItem => {
+        if (evidenceItem && typeof evidenceItem === 'object' && 'last' in evidenceItem) {
+            const { last, ...rest } = evidenceItem as Record<string, unknown>;
+
+            return rest;
+        }
+
+        return evidenceItem;
+    });
+
+    if (normalizedTemplateEvidence.length === 0) return boost;
+
+    // Preserve any evidence the template already baked in, normalizing a
+    // single-object shape to an array so we can spread it.
+    const existingEvidence = boost.evidence
+        ? Array.isArray(boost.evidence)
+            ? boost.evidence
+            : [boost.evidence]
+        : [];
+
+    return {
+        ...boost,
+        evidence: [...existingEvidence, ...normalizedTemplateEvidence],
+    };
+};
+
+const hasDid = (profile: LCNProfile | LCNVisibleProfile | undefined): profile is LCNProfile => {
+    return (
+        !!profile && 'did' in profile && typeof profile.did === 'string' && profile.did.length > 0
+    );
+};
+
+const appendNetworkCredentialStatus = async (
+    client: any,
+    credential: UnsignedVC,
+    statusPurposes: BitstringCredentialStatusPurpose[] = ['revocation']
+): Promise<UnsignedVC> => {
+    if (!isVC2Format(credential)) return credential;
+
+    const existingStatuses = getCredentialStatusArray(credential);
+    const missingPurposes = statusPurposes.filter(statusPurpose => {
+        return !existingStatuses.some(
+            status =>
+                status.type === 'BitstringStatusListEntry' && status.statusPurpose === statusPurpose
+        );
+    });
+
+    if (missingPurposes.length === 0) return credential;
+
+    const entries = (await client.boost.allocateCredentialStatus.mutate({
+        statusPurposes: missingPurposes,
+    })) as BitstringCredentialStatusEntry[];
+
+    const credentialStatuses = [...existingStatuses, ...entries];
+    credential.credentialStatus = (
+        credentialStatuses.length === 1 ? credentialStatuses[0] : credentialStatuses
+    ) as UnsignedVC['credentialStatus'];
+
+    return credential;
+};
+
+const issueCredentialWithNetworkStatus = async (
+    learnCard: LearnCard<any, any, LearnCardNetworkPluginDependentMethods>,
+    client: any,
+    credential: UnsignedVC,
+    statusPurposes?: BitstringCredentialStatusPurpose[]
+): Promise<VC> => {
+    return learnCard.invoke.issueCredential(
+        await appendNetworkCredentialStatus(client, credential, statusPurposes)
+    );
+};
+
+export * from './types';
+
+export type GuardianApprovalGetter = () => string | undefined | Promise<string | undefined>;
+
+/**
+ * @group Plugins
+ */
+export async function getLearnCardNetworkPlugin(
+    learnCard: LearnCard<any, 'id', LearnCardNetworkPluginDependentMethods>,
+    url: string,
+    apiTokenOrOptions?: {
+        guardianApprovalGetter?: GuardianApprovalGetter;
+        extraHeaders?: Record<string, string>;
+    }
+): Promise<LearnCardNetworkPlugin>;
+export async function getLearnCardNetworkPlugin(
+    learnCard: LearnCard<any, any, LearnCardNetworkPluginDependentMethods>,
+    url: string,
+    apiToken: string,
+    options?: {
+        guardianApprovalGetter?: GuardianApprovalGetter;
+        extraHeaders?: Record<string, string>;
+    }
+): Promise<LearnCardNetworkPlugin>;
+export async function getLearnCardNetworkPlugin(
+    learnCard: LearnCard<any, any, LearnCardNetworkPluginDependentMethods>,
+    url: string,
+    apiTokenOrOptions?:
+        | string
+        | {
+              guardianApprovalGetter?: GuardianApprovalGetter;
+              extraHeaders?: Record<string, string>;
+          },
+    options?: {
+        guardianApprovalGetter?: GuardianApprovalGetter;
+        extraHeaders?: Record<string, string>;
+    }
+): Promise<LearnCardNetworkPlugin> {
+    const apiToken = typeof apiTokenOrOptions === 'string' ? apiTokenOrOptions : undefined;
+    const guardianApprovalGetter =
+        (typeof apiTokenOrOptions === 'object'
+            ? apiTokenOrOptions?.guardianApprovalGetter
+            : undefined) ?? options?.guardianApprovalGetter;
+
+    const extraHeaders =
+        (typeof apiTokenOrOptions === 'object' ? apiTokenOrOptions?.extraHeaders : undefined) ??
+        options?.extraHeaders;
+    // Initialize DID safely: in API-key mode there may be no local ID plane provider
+    let did = '';
+    try {
+        const idPlane = (learnCard as any)?.id;
+        if (idPlane && typeof idPlane.did === 'function') {
+            did = idPlane.did();
+        }
+    } catch {
+        learnCard?.debug?.('LCN: no local DID available at init; will fetch from profile');
+    }
+
+    learnCard?.debug?.('Adding LearnCardNetwork Plugin');
+    const client = apiToken
+        ? await getApiTokenClient(url, apiToken, guardianApprovalGetter, extraHeaders)
+        : await getClient(
+              url,
+              async challenge => {
+                  const jwt = await learnCard.invoke.getDidAuthVp({
+                      proofFormat: 'jwt',
+                      challenge,
+                  });
+
+                  if (typeof jwt !== 'string') throw new Error('Error getting DID-Auth-JWT!');
+
+                  return jwt;
+              },
+              guardianApprovalGetter,
+              extraHeaders
+          );
+
+    let userData: LCNProfile | undefined;
+
+    learnCard?.debug?.('LCN: initial getProfile query starting', { apiToken: !!apiToken });
+    const initialQuery = client.profile.getProfile
+        .query()
+        .then((result: LCNProfile | undefined) => {
+            userData = result;
+
+            if (userData?.did) did = userData.did;
+
+            learnCard?.debug?.('LCN: initial getProfile success', { did });
+            return result;
+        })
+        .catch((error: any) => {
+            // Non-fatal: API-key tokens may not have profiles:read; avoid unhandled rejection
+            learnCard?.debug?.('LCN: getProfile failed (non-fatal)', error);
+            return undefined;
+        });
+
+    // Ensure profile context is loaded (if available) before enforcing user presence.
+    // Prevents races where methods run before initial profile query resolves.
+    const ensureUser = async (): Promise<LCNProfile> => {
+        try {
+            await initialQuery;
+        } catch {
+            // ignore; initialQuery errors are non-fatal in API-key mode
+        }
+
+        // Retry once in API-token mode in case the initial query raced with method calls
+        if (!userData && apiToken) {
+            try {
+                learnCard?.debug?.('LCN ensureUser: retrying getProfile with apiToken');
+                const res = await client.profile.getProfile.query();
+                userData = res;
+                if (userData?.did) did = userData.did;
+                learnCard?.debug?.('LCN ensureUser: retry success', { did });
+            } catch (e) {
+                learnCard?.debug?.('LCN ensureUser: retry failed', e);
+            }
+        }
+
+        if (!userData) throw new Error('Please make an account first!');
+
+        return userData;
+    };
+
+    // Prefer authenticated boost retrieval for issuance flows.
+    // Falls back to storage resolve for backwards compatibility.
+    const getBoostTemplateForIssuance = async (_learnCard: any, boostUri: string) => {
+        try {
+            const boostRecord = await client.boost.getBoost.query({ uri: boostUri });
+            return boostRecord.boost;
+        } catch (error) {
+            learnCard?.debug?.(
+                'LCN: getBoost failed for template retrieval, falling back to resolveFromLCN',
+                error
+            );
+            return _learnCard.invoke.resolveFromLCN(boostUri);
+        }
+    };
+
+    const getInboxEndpointForDid = async (
+        _learnCard: any,
+        recipientDid: string
+    ): Promise<string> => {
+        const serviceUrl = new URL(url);
+        const serviceDomain = `${serviceUrl.hostname}${
+            serviceUrl.port ? `%3A${serviceUrl.port}` : ''
+        }`;
+        const localServiceDid = `did:web:${serviceDomain}`;
+
+        const getInferredServiceDid = (did: string): string | null => {
+            if (!did.startsWith('did:web:')) return null;
+
+            const parts = did.split(':');
+            if (parts.length < 3) return null;
+
+            const pathMarkerIndex = parts.findIndex((part, index) => {
+                if (index < 3) return false;
+                return part === 'users' || part === 'app' || part === 'manager';
+            });
+
+            if (pathMarkerIndex === -1) {
+                return did;
+            }
+
+            return `did:web:${parts.slice(2, pathMarkerIndex).join(':')}`;
+        };
+
+        const getInboxService = (didDoc: {
+            service?: Array<{
+                type: string | string[];
+                serviceEndpoint?: string;
+                serviceDid?: string;
+            }>;
+        }) =>
+            didDoc.service?.find(service => {
+                const type = Array.isArray(service.type) ? service.type[0] : service.type;
+                return type === 'UniversalInboxService' || type === 'LearnCardInboxService';
+            });
+
+        const inferredServiceDid = getInferredServiceDid(recipientDid);
+
+        if (inferredServiceDid === localServiceDid) {
+            return `${serviceUrl.origin}/api/inbox/receive`;
+        }
+
+        const didDoc = await _learnCard.invoke.resolveDid(recipientDid);
+        const inboxService = getInboxService(didDoc);
+
+        if ((inboxService?.serviceDid || inferredServiceDid) === localServiceDid) {
+            return `${serviceUrl.origin}/api/inbox/receive`;
+        }
+
+        if (!inboxService?.serviceEndpoint) {
+            throw new Error(
+                `Recipient DID ${recipientDid} does not have a UniversalInboxService endpoint in its DID document`
+            );
+        }
+
+        return inboxService.serviceEndpoint;
+    };
+
+    return {
+        name: 'LearnCard Network',
+        displayName: 'LearnCard Network',
+        description: 'LearnCard Network Integration',
+        id: {
+            did: (_learnCard, method) => {
+                if (!method || method === 'web') return did;
+
+                return (learnCard as any).id?.did?.(method);
+            },
+            keypair: (_learnCard, algorithm) => (learnCard as any).id?.keypair?.(algorithm),
+        },
+        read: {
+            get: async (_learnCard, vcUri) => {
+                _learnCard.debug?.("learnCard.read['LearnCard Network'].get");
+
+                if (!vcUri) return undefined;
+
+                const parts = vcUri.split(':');
+
+                if (parts.length !== 5) return undefined;
+
+                const [lc, method] = parts as [string, string, string, string, string];
+
+                if (lc !== 'lc' || method !== 'network') return undefined;
+
+                try {
+                    let result = await client.storage.resolve.query({ uri: vcUri });
+
+                    if ('ciphertext' in result) {
+                        try {
+                            const kp = _learnCard.id.keypair();
+                            result = await _learnCard.invoke.decryptDagJwe(result as JWE, [kp]);
+                        } catch (e) {
+                            _learnCard.debug?.(
+                                'LCN read.get: skipping decryption (no keypair?)',
+                                e
+                            );
+                            return undefined;
+                        }
+                    }
+
+                    const parsed = await VCValidator.or(VPValidator)
+                        .or(StoredCredentialEnvelopeValidator)
+                        .parseAsync(result);
+                    return resolveStorageReadResult(parsed);
+                } catch (error) {
+                    _learnCard.debug?.(error);
+                    return undefined;
+                }
+            },
+        },
+        store: {
+            upload: async (_learnCard, credential) => {
+                _learnCard.debug?.("learnCard.store['LearnCard Network'].upload");
+
+                return client.storage.store.mutate({
+                    item: normalizeEnvelopeForTransport(credential),
+                });
+            },
+            uploadEncrypted: async (
+                _learnCard,
+                credential,
+                { recipients = [] } = { recipients: [] }
+            ) => {
+                _learnCard.debug?.("learnCard.store['LearnCard Network'].upload");
+                await ensureUser();
+
+                // Use known DID if available (from init or loaded profile)
+                const selfDid = did || userData?.did || '';
+                const recipientsList = [selfDid, ...recipients].filter(Boolean);
+
+                if (recipientsList.length === 0) {
+                    throw new Error(
+                        'No recipients specified for encrypted upload; provide at least one DID'
+                    );
+                }
+
+                const jwe = await _learnCard.invoke.createDagJwe(
+                    normalizeEnvelopeForTransport(credential),
+                    recipientsList
+                );
+
+                return client.storage.store.mutate({ item: jwe });
+            },
+            delete: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.credential.deleteCredential.mutate({ uri });
+            },
+        },
+        methods: {
+            createProfile: async (_learnCard, profile) => {
+                try {
+                    await ensureUser();
+                } catch {
+                    // ignore; This is to prevent a race condition but we are expecting the profile
+                    // to not exist yet here.
+                }
+
+                if (userData) throw new Error('Account already exists!');
+
+                const newDid = await client.profile.createProfile.mutate(profile);
+
+                userData = await client.profile.getProfile.query();
+                did = newDid;
+
+                return newDid;
+            },
+            createServiceProfile: async (_learnCard, profile) => {
+                try {
+                    await ensureUser();
+                } catch {
+                    // ignore; This is to prevent a race condition but we are expecting the profile
+                    // to not exist yet here.
+                }
+
+                const newDid = await client.profile.createServiceProfile.mutate(profile);
+
+                userData = await client.profile.getProfile.query();
+                did = newDid;
+
+                return newDid;
+            },
+            createManagedProfile: async (_learnCard, profile) => {
+                const newDid = await client.profileManager.createManagedProfile.mutate(profile);
+
+                return newDid;
+            },
+            createProfileManager: async (_learnCard, profile) => {
+                await ensureUser();
+
+                const newDid = await client.profileManager.createProfileManager.mutate(profile);
+
+                return newDid;
+            },
+            createChildProfileManager: async (_learnCard, parentUri, profile) => {
+                await ensureUser();
+
+                const newDid = await client.profileManager.createChildProfileManager.mutate({
+                    parentUri,
+                    profile,
+                });
+
+                return newDid;
+            },
+            createManagedServiceProfile: async (_learnCard, profile) => {
+                await ensureUser();
+
+                const newDid = await client.profile.createManagedServiceProfile.mutate(profile);
+
+                return newDid;
+            },
+            getAvailableProfiles: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.profile.getAvailableProfiles.query(options);
+            },
+            getManagedProfiles: async (_learnCard, options = {}) => {
+                return client.profileManager.getManagedProfiles.query(options);
+            },
+            claimPendingGuardianLinks: async () => {
+                await ensureUser();
+                return client.inbox.claimPendingGuardianLinks.mutate({});
+            },
+            getMyManagedChildren: async () => {
+                await ensureUser();
+                return client.profileManager.getMyManagedChildren.query();
+            },
+            getMyGuardians: async () => {
+                await ensureUser();
+                return client.profileManager.getMyGuardians.query();
+            },
+            removeManagesRelationship: async (_learnCard, profileId) => {
+                await ensureUser();
+                return client.profileManager.removeManagesRelationship.mutate({ profileId });
+            },
+            getManagedServiceProfiles: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.profile.getManagedServiceProfiles.query(options);
+            },
+            updateProfile: async (_learnCard, profile) => {
+                await ensureUser();
+
+                const result = await client.profile.updateProfile.mutate(profile);
+
+                if (result) {
+                    userData = await client.profile.getProfile.query();
+
+                    return true;
+                }
+
+                return false;
+            },
+            updateProfileManagerProfile: async (_learnCard, manager) => {
+                return client.profileManager.updateProfileManager.mutate(manager);
+            },
+            deleteProfile: async () => {
+                if (!userData) throw new Error('Account does not exist!');
+
+                const result = await client.profile.deleteProfile.mutate();
+
+                if (result) {
+                    userData = undefined;
+
+                    return true;
+                }
+
+                return false;
+            },
+            getProfile: async (_learnCard, profileId) => {
+                try {
+                    await ensureUser();
+                } catch {}
+
+                // If no profileId is provided, return whatever we have cached locally.
+                if (!profileId) return userData;
+
+                return client.profile.getOtherProfile.query({ profileId });
+            },
+            getProfileManagerProfile: async (_learnCard, id) => {
+                if (!id) return client.profileManager.getProfileManager.query();
+
+                return client.profileManager.getOtherProfileManager.query({ id });
+            },
+            searchProfiles: async (
+                _learnCard,
+                input = '',
+                {
+                    limit = 25,
+                    includeSelf = false,
+                    includeConnectionStatus = false,
+                    includeServiceProfiles = false,
+                } = {}
+            ) => {
+                return client.profile.searchProfiles.query({
+                    input,
+                    limit,
+                    includeSelf,
+                    includeConnectionStatus,
+                    includeServiceProfiles,
+                });
+            },
+            connectWith: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.connectWith.mutate({ profileId });
+            },
+            connectWithExpiredInvite: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.connectWithExpiredInvite.mutate({ profileId });
+            },
+            cancelConnectionRequest: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.cancelConnectionRequest.mutate({ profileId });
+            },
+            connectWithInvite: async (_learnCard, profileId, challenge) => {
+                await ensureUser();
+
+                return client.profile.connectWithInvite.mutate({ profileId, challenge });
+            },
+            disconnectWith: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.disconnectWith.mutate({ profileId });
+            },
+            acceptConnectionRequest: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.acceptConnectionRequest.mutate({ profileId });
+            },
+            getConnections: async _learnCard => {
+                console.warn(
+                    'The getConnections method is deprecated! Please use getPaginatedConnections instead!'
+                );
+
+                await ensureUser();
+
+                return client.profile.connections.query();
+            },
+            getPaginatedConnections: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.profile.paginatedConnections.query(options);
+            },
+            getPendingConnections: async _learnCard => {
+                console.warn(
+                    'The getPendingConnections method is deprecated! Please use getPaginatedPendingConnections instead!'
+                );
+
+                await ensureUser();
+
+                return client.profile.pendingConnections.query();
+            },
+            getPaginatedPendingConnections: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.profile.paginatedPendingConnections.query(options);
+            },
+            getConnectionRequests: async _learnCard => {
+                console.warn(
+                    'The getConnectionRequests method is deprecated! Please use getPaginatedConnectionRequests instead!'
+                );
+
+                await ensureUser();
+
+                return client.profile.connectionRequests.query();
+            },
+            getPaginatedConnectionRequests: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.profile.paginatedConnectionRequests.query(options);
+            },
+
+            generateInvite: async (_learnCard, challenge, expiration, maxUses) => {
+                await ensureUser();
+
+                return client.profile.generateInvite.mutate({ challenge, expiration, maxUses });
+            },
+
+            listInvites: async () => {
+                await ensureUser();
+
+                return client.profile.listInvites.query();
+            },
+
+            invalidateInvite: async (_learnCard, challenge) => {
+                await ensureUser();
+
+                return client.profile.invalidateInvite.mutate({ challenge });
+            },
+
+            blockProfile: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.blockProfile.mutate({ profileId });
+            },
+            unblockProfile: async (_learnCard, profileId) => {
+                await ensureUser();
+
+                return client.profile.unblockProfile.mutate({ profileId });
+            },
+            getBlockedProfiles: async () => {
+                await ensureUser();
+
+                return client.profile.blocked.query();
+            },
+
+            sendCredential: async (_learnCard, profileId, vc, metadataOrEncrypt, encrypt) => {
+                await ensureUser();
+
+                if (profileId.startsWith('did:web:')) {
+                    const inboxEndpoint = await getInboxEndpointForDid(_learnCard, profileId);
+
+                    // Handle metadata parameter
+                    let metadata: Record<string, unknown> | undefined;
+                    if (typeof metadataOrEncrypt === 'object') {
+                        metadata = metadataOrEncrypt;
+                    }
+
+                    const myProfile = await client.profile.getProfile.query();
+                    const issuerDid = myProfile?.did || (await client.utilities.getDid.query());
+                    const issuerDisplayName = myProfile?.displayName || 'Unknown Issuer';
+                    const signedCredential = await issueCredentialWithNetworkStatus(
+                        _learnCard,
+                        client,
+                        vc
+                    );
+                    const didAuthJwt = await _learnCard.invoke.getDidAuthVp({
+                        proofFormat: 'jwt',
+                        challenge: `inbox-federation-${crypto.randomUUID()}`,
+                    });
+
+                    let receiveUrl = inboxEndpoint;
+
+                    if (receiveUrl.includes('localhost')) {
+                        receiveUrl = receiveUrl.replace('https://', 'http://');
+                    }
+
+                    const response = await fetch(receiveUrl, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${didAuthJwt}`,
+                        },
+                        body: JSON.stringify({
+                            recipientDid: profileId,
+                            credential: signedCredential,
+                            issuerDid,
+                            issuerDisplayName,
+                            configuration: {
+                                ...metadata,
+                                federatedFrom: issuerDid,
+                            },
+                        }),
+                        signal: AbortSignal.timeout(30000),
+                    });
+
+                    if (!response.ok) {
+                        const error = await response.text();
+                        throw new Error(`Federation failed: ${error}`);
+                    }
+
+                    const result = await response.json();
+                    return result.issuanceId;
+                }
+
+                // Handle backward compatibility: if metadataOrEncrypt is a boolean, it's the encrypt flag
+                let metadata: Record<string, unknown> | undefined;
+                let shouldEncrypt = true;
+
+                if (typeof metadataOrEncrypt === 'boolean') {
+                    shouldEncrypt = metadataOrEncrypt;
+                } else if (metadataOrEncrypt !== undefined) {
+                    metadata = metadataOrEncrypt;
+                    shouldEncrypt = encrypt ?? true;
+                } else {
+                    shouldEncrypt = encrypt ?? true;
+                }
+
+                if (!shouldEncrypt) {
+                    return client.credential.sendCredential.mutate({
+                        profileId,
+                        credential: vc,
+                        metadata,
+                    });
+                }
+
+                const target = await _learnCard.invoke.getProfile(profileId);
+
+                if (!target) throw new Error('Could not find target account');
+                if (!hasDid(target)) throw new Error('Could not find target DID');
+
+                const credential = await _learnCard.invoke.createDagJwe(vc, [
+                    _learnCard.id.did(),
+                    target.did,
+                ]);
+
+                return client.credential.sendCredential.mutate({
+                    profileId,
+                    credential,
+                    metadata,
+                });
+            },
+            acceptCredential: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.credential.acceptCredential.mutate({ uri, options });
+            },
+            getReceivedCredentials: async (_learnCard, from) => {
+                await ensureUser();
+
+                return client.credential.receivedCredentials.query({ from });
+            },
+            getRevokedCredentials: async () => {
+                await ensureUser();
+
+                return client.credential.getRevokedCredentials.query();
+            },
+            getSentCredentials: async (_learnCard, to) => {
+                await ensureUser();
+
+                return client.credential.sentCredentials.query({ to });
+            },
+            getIncomingCredentials: async (_learnCard, from) => {
+                await ensureUser();
+
+                return client.credential.incomingCredentials.query({ from });
+            },
+            deleteCredential: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.credential.deleteCredential.mutate({ uri });
+            },
+
+            sendPresentation: async (_learnCard, profileId, vp, encrypt = true) => {
+                await ensureUser();
+
+                if (!encrypt) {
+                    return client.presentation.sendPresentation.mutate({
+                        profileId,
+                        presentation: vp,
+                    });
+                }
+
+                const target = await _learnCard.invoke.getProfile(profileId);
+
+                if (!target) throw new Error('Could not find target account');
+                if (!hasDid(target)) throw new Error('Could not find target DID');
+
+                const presentation = await _learnCard.invoke.createDagJwe(vp, [
+                    _learnCard.id.did(),
+                    target.did,
+                ]);
+
+                return client.presentation.sendPresentation.mutate({ profileId, presentation });
+            },
+            acceptPresentation: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.presentation.acceptPresentation.mutate({ uri });
+            },
+            getReceivedPresentations: async (_learnCard, from) => {
+                await ensureUser();
+
+                return client.presentation.receivedPresentations.query({ from });
+            },
+            getSentPresentations: async (_learnCard, to) => {
+                await ensureUser();
+
+                return client.presentation.sentPresentations.query({ to });
+            },
+            getIncomingPresentations: async (_learnCard, from) => {
+                await ensureUser();
+
+                return client.presentation.incomingPresentations.query({ from });
+            },
+            deletePresentation: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.presentation.deletePresentation.mutate({ uri });
+            },
+
+            createBoost: async (_learnCard, credential, metadata) => {
+                await ensureUser();
+                const { skills, ...rest } = metadata ?? {};
+
+                const payload: any = { credential, ...rest };
+                if (Array.isArray(skills) && skills.length > 0) payload.skills = skills;
+
+                return client.boost.createBoost.mutate(payload);
+            },
+            createChildBoost: async (_learnCard, parentUri, credential, metadata) => {
+                await ensureUser();
+                const { skills, ...restMetadata } = metadata || {};
+
+                const payload: any = { parentUri, boost: { credential, ...restMetadata } };
+                if (Array.isArray(skills) && skills.length > 0) payload.skills = skills;
+
+                return client.boost.createChildBoost.mutate(payload);
+            },
+            getBoost: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.boost.getBoost.query({ uri });
+            },
+            getBoostSkills: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.boost.getBoostSkills.query({ uri });
+            },
+            getBoostFrameworks: async (_learnCard, uri, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                const { limit, cursor, query } = options ?? {};
+
+                return client.boost.getBoostFrameworks.query({ uri, limit, cursor, query });
+            },
+            getSkillsAvailableForBoost: async (_learnCard, uri) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.getSkillsAvailableForBoost.query({ uri });
+            },
+            searchSkillsAvailableForBoost: async (_learnCard, uri, query, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.searchSkillsAvailableForBoost.query({ uri, query, ...options });
+            },
+            getBoosts: async (_learnCard, query) => {
+                console.warn(
+                    'The getBoosts method is deprecated! Please use getPaginatedBoosts instead!'
+                );
+
+                await ensureUser();
+
+                return client.boost.getBoosts.query({ query });
+            },
+            countBoosts: async (_learnCard, query) => {
+                await ensureUser();
+
+                return client.boost.countBoosts.query({ query });
+            },
+            getPaginatedBoosts: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.boost.getPaginatedBoosts.query(options);
+            },
+            getBoostChildren: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.getBoostChildren.query({ uri, ...options });
+            },
+            countBoostChildren: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.countBoostChildren.query({ uri, ...options });
+            },
+            getBoostSiblings: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.getBoostSiblings.query({ uri, ...options });
+            },
+            countBoostSiblings: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.countBoostSiblings.query({ uri, ...options });
+            },
+            getFamilialBoosts: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.getFamilialBoosts.query({ uri, ...options });
+            },
+            countFamilialBoosts: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.countFamilialBoosts.query({ uri, ...options });
+            },
+            getBoostParents: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.getBoostParents.query({ uri, ...options });
+            },
+            countBoostParents: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.countBoostParents.query({ uri, ...options });
+            },
+            makeBoostParent: async (_learnCard, uris) => {
+                await ensureUser();
+
+                return client.boost.makeBoostParent.mutate(uris);
+            },
+            removeBoostParent: async (_learnCard, uris) => {
+                await ensureUser();
+
+                return client.boost.removeBoostParent.mutate(uris);
+            },
+            getBoostRecipients: async (
+                _learnCard,
+                uri,
+                limit = 25,
+                skip = undefined,
+                includeUnacceptedBoosts = true
+            ) => {
+                console.warn(
+                    'The getBoostRecipients method is deprecated! Please use getPaginatedBoostRecipients instead!'
+                );
+
+                await ensureUser();
+
+                return client.boost.getBoostRecipients.query({
+                    uri,
+                    limit,
+                    skip,
+                    includeUnacceptedBoosts,
+                });
+            },
+            getPaginatedBoostRecipients: async (
+                _learnCard,
+                uri,
+                limit = 25,
+                cursor = undefined,
+                includeUnacceptedBoosts = true,
+                query
+            ) => {
+                await ensureUser();
+
+                return client.boost.getPaginatedBoostRecipients.query({
+                    uri,
+                    limit,
+                    cursor,
+                    includeUnacceptedBoosts,
+                    query,
+                });
+            },
+            getPaginatedBoostRecipientsWithChildren: async (
+                _learnCard,
+                uri,
+                limit = 25,
+                cursor = undefined,
+                includeUnacceptedBoosts = true,
+                boostQuery,
+                profileQuery,
+                numberOfGenerations = 1
+            ) => {
+                await ensureUser();
+
+                return client.boost.getPaginatedBoostRecipientsWithChildren.query({
+                    uri,
+                    limit,
+                    cursor,
+                    includeUnacceptedBoosts,
+                    boostQuery,
+                    profileQuery,
+                    numberOfGenerations,
+                });
+            },
+            countBoostRecipientsWithChildren: async (
+                _learnCard,
+                uri,
+                includeUnacceptedBoosts = true,
+                boostQuery,
+                profileQuery,
+                numberOfGenerations = 1
+            ) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.getBoostRecipientsWithChildrenCount.query({
+                    uri,
+                    includeUnacceptedBoosts,
+                    boostQuery,
+                    profileQuery,
+                    numberOfGenerations,
+                });
+            },
+            countBoostRecipients: async (_learnCard, uri, includeUnacceptedBoosts = true) => {
+                await ensureUser();
+
+                return client.boost.getBoostRecipientCount.query({ uri, includeUnacceptedBoosts });
+            },
+            getConnectedBoostRecipients: async (
+                _learnCard,
+                uri,
+                { limit = 25, cursor = undefined, includeUnacceptedBoosts = true, query } = {}
+            ) => {
+                await ensureUser();
+
+                return client.boost.getConnectedBoostRecipients.query({
+                    uri,
+                    limit,
+                    cursor,
+                    includeUnacceptedBoosts,
+                    query,
+                });
+            },
+            countConnectedBoostRecipients: async (
+                _learnCard,
+                uri,
+                includeUnacceptedBoosts = true
+            ) => {
+                await ensureUser();
+
+                return client.boost.getConnectedBoostRecipientCount.query({
+                    uri,
+                    includeUnacceptedBoosts,
+                });
+            },
+            getBoostChildrenProfileManagers: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.boost.getChildrenProfileManagers.query({ uri, ...options });
+            },
+            updateBoost: async (_learnCard, uri, updates, credential) => {
+                await ensureUser();
+
+                // Allow passing skills similar to createBoost; send them at top-level, not inside updates
+                const { skills, ...restUpdates } = (updates as any) ?? {};
+
+                const payload: any = {
+                    uri,
+                    updates: { ...(credential && { credential }), ...restUpdates },
+                };
+
+                if (Array.isArray(skills)) payload.skills = skills;
+
+                return client.boost.updateBoost.mutate(payload);
+            },
+            attachFrameworkToBoost: async (_learnCard, boostUri, frameworkId) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.attachFrameworkToBoost.mutate({ boostUri, frameworkId });
+            },
+            detachFrameworkFromBoost: async (_learnCard, boostUri, frameworkId) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.detachFrameworkFromBoost.mutate({ boostUri, frameworkId });
+            },
+            alignBoostSkills: async (_learnCard, boostUri, skills) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.boost.alignBoostSkills.mutate({ boostUri, skills } as any);
+            },
+            getBoostAdmins: async (_learnCard, uri, options = {}) => {
+                await ensureUser();
+
+                return client.boost.getBoostAdmins.query({ uri, ...options });
+            },
+            getBoostPermissions: async (_learnCard, uri, profileId) => {
+                await ensureUser();
+
+                if (!profileId) return client.boost.getBoostPermissions.query({ uri });
+
+                return client.boost.getOtherBoostPermissions.query({ uri, profileId });
+            },
+            updateBoostPermissions: async (_learnCard, uri, updates, profileId) => {
+                await ensureUser();
+
+                if (!profileId) return client.boost.updateBoostPermissions.query({ uri, updates });
+
+                const result = await client.boost.updateOtherBoostPermissions.query({
+                    uri,
+                    profileId,
+                    updates,
+                });
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+            addBoostAdmin: async (_learnCard, uri, profileId) => {
+                await ensureUser();
+
+                const result = await client.boost.addBoostAdmin.mutate({ uri, profileId });
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+            removeBoostAdmin: async (_learnCard, uri, profileId) => {
+                await ensureUser();
+
+                const result = await client.boost.removeBoostAdmin.mutate({ uri, profileId });
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+            allocateCredentialStatus: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.boost.allocateCredentialStatus.mutate(options);
+            },
+            revokeBoostRecipient: async (
+                _learnCard,
+                boostUri,
+                recipientProfileId,
+                credentialUri
+            ) => {
+                await ensureUser();
+
+                const input = { boostUri, recipientProfileId };
+                if (credentialUri !== undefined) Object.assign(input, { credentialUri });
+
+                return client.boost.revokeBoostRecipient.mutate(input);
+            },
+            suspendBoostRecipient: async (
+                _learnCard,
+                boostUri,
+                recipientProfileId,
+                credentialUri
+            ) => {
+                await ensureUser();
+
+                const input = { boostUri, recipientProfileId };
+                if (credentialUri !== undefined) Object.assign(input, { credentialUri });
+
+                return client.boost.suspendBoostRecipient.mutate(input);
+            },
+            unsuspendBoostRecipient: async (
+                _learnCard,
+                boostUri,
+                recipientProfileId,
+                credentialUri
+            ) => {
+                await ensureUser();
+
+                const input = { boostUri, recipientProfileId };
+                if (credentialUri !== undefined) Object.assign(input, { credentialUri });
+
+                return client.boost.unsuspendBoostRecipient.mutate(input);
+            },
+            deleteBoost: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.boost.deleteBoost.mutate({ uri });
+            },
+            sendBoost: async (
+                _learnCard,
+                profileId,
+                boostUri,
+                options = { encrypt: true, skipNotification: false, templateData: {} }
+            ) => {
+                await ensureUser();
+
+                const result = await getBoostTemplateForIssuance(_learnCard, boostUri);
+                const data = await UnsignedVCValidator.spa(result);
+
+                if (!data.success) throw new Error('Did not get a valid boost from URI');
+
+                const targetProfile = await _learnCard.invoke.getProfile(profileId);
+
+                if (!targetProfile) throw new Error('Target profile not found');
+                if (!hasDid(targetProfile)) throw new Error('Target profile has no DID');
+
+                let boost = data.data;
+
+                if (isVC2Format(boost)) {
+                    boost.validFrom = new Date().toISOString();
+                } else {
+                    boost.issuanceDate = new Date().toISOString();
+                }
+                boost.issuer = _learnCard.id.did();
+
+                if (Array.isArray(boost.credentialSubject)) {
+                    boost.credentialSubject = boost.credentialSubject.map(subject => ({
+                        ...subject,
+                        id: targetProfile.did,
+                    }));
+                } else {
+                    boost.credentialSubject.id = targetProfile.did;
+                }
+
+                // Embed the boostURI into the boost credential for verification purposes.
+                if (boost?.type?.includes('BoostCredential')) boost.boostId = boostUri;
+
+                // Apply templateData if provided (Mustache templating)
+                if (
+                    typeof options === 'object' &&
+                    options.templateData &&
+                    Object.keys(options.templateData).length > 0
+                ) {
+                    const boostString = JSON.stringify(boost);
+                    const allowAutoAppendEvidence = !hasDynamicEvidenceTemplate(boostString);
+
+                    try {
+                        const rendered = renderTemplateJson(boostString, options.templateData);
+                        boost = JSON.parse(rendered);
+                        boost = appendTemplateEvidence(
+                            boost,
+                            options.templateData,
+                            allowAutoAppendEvidence
+                        );
+                    } catch (error) {
+                        throw new Error(
+                            `Template substitution failed: ${
+                                error instanceof Error ? error.message : 'Unknown error'
+                            }. ` +
+                                `Please check your templateData variables and ensure the rendered output is valid JSON.`
+                        );
+                    }
+                }
+
+                if (typeof options === 'object' && options.overideFn) {
+                    boost = options.overideFn(boost);
+                }
+
+                const statusPurposes =
+                    typeof options === 'object' ? options.statusPurposes : undefined;
+                const vc = await issueCredentialWithNetworkStatus(
+                    _learnCard,
+                    client,
+                    boost,
+                    statusPurposes
+                );
+
+                // options is allowed to be a boolean to maintain backwards compatibility
+                if ((typeof options === 'object' && !options.encrypt) || !options) {
+                    return client.boost.sendBoost.mutate({
+                        profileId,
+                        uri: boostUri,
+                        credential: vc,
+                        options: {
+                            skipNotification:
+                                typeof options === 'object' && options.skipNotification,
+                        },
+                    });
+                }
+
+                const lcnDid = await client.utilities.getDid.query();
+
+                const credential = await _learnCard.invoke.createDagJwe(vc, [
+                    _learnCard.id.did(),
+                    targetProfile.did,
+                    lcnDid,
+                ]);
+
+                return client.boost.sendBoost.mutate({
+                    profileId,
+                    uri: boostUri,
+                    credential,
+                    options: {
+                        skipNotification: typeof options === 'object' && options.skipNotification,
+                    },
+                });
+            },
+
+            registerSigningAuthority: async (_learnCard, endpoint, name, _did) => {
+                await ensureUser();
+
+                return client.profile.registerSigningAuthority.mutate({
+                    endpoint,
+                    name,
+                    did: _did,
+                });
+            },
+            getRegisteredSigningAuthorities: async _learnCard => {
+                await ensureUser();
+
+                return client.profile.signingAuthorities.query();
+            },
+            getRegisteredSigningAuthority: async (_learnCard, endpoint, name) => {
+                await ensureUser();
+
+                return client.profile.signingAuthority.query({ endpoint, name });
+            },
+            setPrimaryRegisteredSigningAuthority: async (_learnCard, endpoint, name) => {
+                await ensureUser();
+
+                return client.profile.setPrimarySigningAuthority.mutate({ endpoint, name });
+            },
+            getPrimaryRegisteredSigningAuthority: async _learnCard => {
+                await ensureUser();
+
+                return client.profile.primarySigningAuthority.query();
+            },
+
+            generateClaimLink: async (_learnCard, boostUri, claimLinkSA, options, challenge) => {
+                await ensureUser();
+
+                return client.boost.generateClaimLink.mutate({
+                    boostUri,
+                    claimLinkSA,
+                    options,
+                    challenge,
+                });
+            },
+
+            claimBoostWithLink: async (_learnCard, boostUri, challenge) => {
+                await ensureUser();
+
+                return client.boost.claimBoostWithLink.mutate({ boostUri, challenge });
+            },
+
+            send: async (_learnCard, input) => {
+                await ensureUser();
+
+                if (input.type === 'boost') {
+                    const recipient = input.recipient;
+                    const isDid = recipient.startsWith('did:');
+                    const isEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(recipient);
+                    const isPhone = /^\+?[\d\s-]{10,}$/.test(recipient.replace(/[\s-]/g, ''));
+                    const serviceUrl = new URL(url);
+                    const serviceDomain = `${serviceUrl.hostname}${
+                        serviceUrl.port ? `%3A${serviceUrl.port}` : ''
+                    }`;
+                    const recipientDomain = recipient.startsWith('did:web:')
+                        ? recipient.split(':')[2]
+                        : undefined;
+                    const isRemoteDidWebRecipient =
+                        recipient.startsWith('did:web:') && recipientDomain !== serviceDomain;
+
+                    if (isRemoteDidWebRecipient && input.templateUri) {
+                        const boostRecord = await _learnCard.invoke.getBoost(input.templateUri);
+                        let boost = boostRecord.boost;
+                        const boostString = JSON.stringify(boost);
+                        const allowAutoAppendEvidence = !hasDynamicEvidenceTemplate(boostString);
+
+                        if (input.templateData && Object.keys(input.templateData).length > 0) {
+                            const rendered = renderTemplateJson(boostString, input.templateData);
+                            boost = JSON.parse(rendered);
+                            boost = appendTemplateEvidence(
+                                boost,
+                                input.templateData,
+                                allowAutoAppendEvidence
+                            );
+                        }
+
+                        if (isVC2Format(boost)) {
+                            boost.validFrom = new Date().toISOString();
+                        } else {
+                            boost.issuanceDate = new Date().toISOString();
+                        }
+
+                        boost.issuer = _learnCard.id.did();
+
+                        if (Array.isArray(boost.credentialSubject)) {
+                            boost.credentialSubject = boost.credentialSubject.map(subject => ({
+                                ...subject,
+                                id: recipient,
+                            }));
+                        } else {
+                            boost.credentialSubject = {
+                                ...boost.credentialSubject,
+                                id: recipient,
+                            };
+                        }
+
+                        if (boost.type?.includes('BoostCredential')) {
+                            boost.boostId = input.templateUri;
+                        }
+
+                        const signedCredential = await issueCredentialWithNetworkStatus(
+                            _learnCard,
+                            client,
+                            boost
+                        );
+                        const credentialUri = await _learnCard.invoke.sendCredential(
+                            recipient,
+                            signedCredential,
+                            {
+                                boostUri: input.templateUri,
+                                templateData: input.templateData,
+                                integrationId: input.integrationId,
+                            }
+                        );
+
+                        return {
+                            type: 'boost' as const,
+                            credentialUri,
+                            uri: input.templateUri,
+                            activityId: '',
+                        };
+                    }
+
+                    const canIssueLocally = 'issueCredential' in _learnCard.invoke;
+                    const isDirectRecipient = isDid || (!isEmail && !isPhone);
+
+                    if (canIssueLocally && isDirectRecipient && input.templateUri) {
+                        const result = await getBoostTemplateForIssuance(
+                            _learnCard,
+                            input.templateUri
+                        );
+                        const data = await UnsignedVCValidator.spa(result);
+
+                        if (data.success) {
+                            let targetDid: string;
+
+                            if (isDid) {
+                                targetDid = recipient;
+                            } else {
+                                const targetProfile = await _learnCard.invoke.getProfile(recipient);
+
+                                if (!hasDid(targetProfile)) return client.boost.send.mutate(input);
+
+                                targetDid = targetProfile.did;
+                            }
+
+                            let boost = data.data;
+                            const boostString = JSON.stringify(boost);
+                            const allowAutoAppendEvidence =
+                                !hasDynamicEvidenceTemplate(boostString);
+
+                            // Apply templateData if provided
+                            if (input.templateData && Object.keys(input.templateData).length > 0) {
+                                try {
+                                    const rendered = renderTemplateJson(
+                                        boostString,
+                                        input.templateData
+                                    );
+                                    boost = JSON.parse(rendered);
+                                    boost = appendTemplateEvidence(
+                                        boost,
+                                        input.templateData,
+                                        allowAutoAppendEvidence
+                                    );
+                                } catch (error) {
+                                    throw new Error(
+                                        `Failed to apply template data: ${
+                                            error instanceof Error ? error.message : 'Unknown error'
+                                        }`
+                                    );
+                                }
+                            }
+
+                            if (isVC2Format(boost)) {
+                                boost.validFrom = new Date().toISOString();
+                            } else {
+                                boost.issuanceDate = new Date().toISOString();
+                            }
+
+                            boost.issuer = _learnCard.id.did();
+
+                            if (Array.isArray(boost.credentialSubject)) {
+                                boost.credentialSubject = boost.credentialSubject.map(subject => ({
+                                    ...subject,
+                                    id: targetDid,
+                                }));
+                            } else {
+                                boost.credentialSubject = {
+                                    ...boost.credentialSubject,
+                                    id: targetDid,
+                                };
+                            }
+
+                            if (boost?.type?.includes('BoostCredential'))
+                                boost.boostId = input.templateUri;
+
+                            const signedCredential = await issueCredentialWithNetworkStatus(
+                                _learnCard,
+                                client,
+                                boost
+                            );
+
+                            if (isDid && recipient.startsWith('did:web:')) {
+                                const credentialUri = await _learnCard.invoke.sendCredential(
+                                    recipient,
+                                    signedCredential,
+                                    {
+                                        boostUri: input.templateUri,
+                                        templateData: input.templateData,
+                                        integrationId: input.integrationId,
+                                    }
+                                );
+
+                                return {
+                                    type: 'boost' as const,
+                                    credentialUri,
+                                    uri: input.templateUri,
+                                    activityId: '',
+                                };
+                            }
+
+                            return client.boost.send.mutate({
+                                ...input,
+                                signedCredential,
+                            });
+                        }
+                    }
+                }
+
+                // Let the brain service handle all routing (email/phone → inbox, profileId/DID → direct)
+                return client.boost.send.mutate(input);
+            },
+
+            createContract: async (_learnCard, contract) => {
+                await ensureUser();
+
+                return client.contracts.createConsentFlowContract.mutate(contract);
+            },
+
+            addAutoBoostsToContract: async (_learnCard, contractUri, autoboosts) => {
+                await ensureUser();
+
+                return client.contracts.addAutoBoostsToContract.mutate({ contractUri, autoboosts });
+            },
+
+            removeAutoBoostsFromContract: async (_learnCard, contractUri, boostUris) => {
+                await ensureUser();
+
+                return client.contracts.removeAutoBoostsFromContract.mutate({
+                    contractUri,
+                    boostUris,
+                });
+            },
+
+            getContract: async (_learnCard, uri) => {
+                return client.contracts.getConsentFlowContract.query({ uri });
+            },
+
+            getContracts: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.contracts.getConsentFlowContracts.query(options);
+            },
+
+            deleteContract: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.contracts.deleteConsentFlowContract.mutate({ uri });
+            },
+
+            getConsentFlowData: async (_learnCard, uri, options = {}) => {
+                await ensureUser();
+
+                return client.contracts.getConsentedDataForContract.query({ uri, ...options });
+            },
+
+            getConsentFlowDataForDid: async (_learnCard, did, options = {}) => {
+                await ensureUser();
+
+                return client.contracts.getConsentedDataForDid.query({ did, ...options });
+            },
+
+            getAllConsentFlowData: async (_learnCard, query = {}, options = {}) => {
+                await ensureUser();
+
+                return client.contracts.getConsentedData.query({ query, ...options });
+            },
+
+            writeCredentialToContract: async (
+                _learnCard,
+                did,
+                contractUri,
+                credential,
+                boostUri
+            ) => {
+                await ensureUser();
+
+                return client.contracts.writeCredentialToContract.mutate({
+                    did,
+                    contractUri,
+                    credential,
+                    boostUri,
+                });
+            },
+
+            consentToContract: async (
+                _learnCard,
+                contractUri,
+                { terms, expiresAt, oneTime },
+                recipientToken
+            ) => {
+                await ensureUser();
+
+                return client.contracts.consentToContract.mutate({
+                    contractUri,
+                    terms,
+                    expiresAt,
+                    oneTime,
+                    recipientToken, // for SmartResume
+                });
+            },
+
+            getConsentedContracts: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.contracts.getConsentedContracts.query(options);
+            },
+
+            updateContractTerms: async (_learnCard, uri, { terms, expiresAt, oneTime }) => {
+                await ensureUser();
+
+                return client.contracts.updateConsentedContractTerms.mutate({
+                    uri,
+                    terms,
+                    expiresAt,
+                    oneTime,
+                });
+            },
+
+            withdrawConsent: async (_learnCard, uri) => {
+                await ensureUser();
+
+                return client.contracts.withdrawConsent.mutate({ uri });
+            },
+
+            getConsentFlowTransactions: async (_learnCard, uri, options) => {
+                await ensureUser();
+
+                return client.contracts.getTermsTransactionHistory.query({ uri, ...options });
+            },
+
+            getHolderExportMetadata: async _learnCard => {
+                await ensureUser();
+
+                return client.credential.getHolderExportMetadata.query({});
+            },
+
+            getCredentialsForContract: async (_learnCard, termsUri, options = {}) => {
+                await ensureUser();
+
+                return client.contracts.getCredentialsForContract.query({ termsUri, ...options });
+            },
+
+            getConsentFlowCredentials: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.contracts.getAllCredentialsForTerms.query(options);
+            },
+
+            verifyConsent: async (_learnCard, uri, profileId) => {
+                await ensureUser();
+
+                return client.contracts.verifyConsent.query({ uri, profileId });
+            },
+
+            syncCredentialsToContract: async (_learnCard, termsUri, categories) => {
+                await ensureUser();
+
+                return client.contracts.syncCredentialsToContract.mutate({
+                    termsUri,
+                    categories,
+                });
+            },
+
+            deleteCredentialFromAllContracts: async (_learnCard, deletedUris) => {
+                await ensureUser();
+
+                return client.contracts.deleteCredentialFromAllContracts.mutate({
+                    deletedUris,
+                });
+            },
+
+            sendAiInsightsContractRequest: async (
+                _learnCard,
+                contractUri,
+                targetProfileId,
+                shareLink
+            ) => {
+                await ensureUser();
+
+                return client.contracts.sendAiInsightsContractRequest.mutate({
+                    contractUri,
+                    targetProfileId,
+                    shareLink,
+                });
+            },
+
+            sendAiInsightShareRequest: async (
+                _learnCard,
+                targetProfileId,
+                shareLink,
+                childProfileId
+            ) => {
+                await ensureUser();
+
+                return client.contracts.sendAiInsightShareRequest.mutate({
+                    targetProfileId,
+                    shareLink,
+                    childProfileId,
+                });
+            },
+
+            getContractSentRequests: async (_learnCard, contractUri) => {
+                await ensureUser();
+
+                return client.contracts.getContractSentRequests.query({
+                    contractUri,
+                });
+            },
+
+            getRequestStatusForProfile: async (
+                _learnCard,
+                targetProfileId,
+                contractId,
+                contractUri
+            ) => {
+                await ensureUser();
+
+                return client.contracts.getRequestStatusForProfile.query({
+                    targetProfileId,
+                    contractId: contractId ?? null,
+                    contractUri: contractUri ?? null,
+                });
+            },
+
+            getAllContractRequestsForProfile: async (_learnCard, targetProfileId) => {
+                await ensureUser();
+
+                return client.contracts.getAllContractRequestsForProfile.query({
+                    targetProfileId,
+                });
+            },
+
+            getSharedInsightsRequestsForProfile: async (_learnCard, targetProfileId) => {
+                await ensureUser();
+
+                return client.contracts.getSharedInsightsRequestsForProfile.query({
+                    targetProfileId,
+                });
+            },
+
+            forwardContractRequestToProfile: async (
+                _learnCard,
+                parentProfileId,
+                targetProfileId,
+                contractUri
+            ) => {
+                await ensureUser();
+
+                return client.contracts.forwardContractRequestToProfile.mutate({
+                    parentProfileId,
+                    targetProfileId,
+                    contractUri,
+                });
+            },
+
+            markContractRequestAsSeen: async (_learnCard, contractUri, targetProfileId) => {
+                await ensureUser();
+
+                return client.contracts.markContractRequestAsSeen.mutate({
+                    contractUri,
+                    targetProfileId,
+                });
+            },
+
+            cancelContractRequest: async (_learnCard, contractUri, targetProfileId) => {
+                await ensureUser();
+
+                return client.contracts.cancelContractRequest.mutate({
+                    contractUri,
+                    targetProfileId,
+                });
+            },
+
+            addDidMetadata: async (_learnCard, metadata) => {
+                await ensureUser();
+
+                const result = await client.didMetadata.addDidMetadata.mutate(metadata);
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+
+            getDidMetadata: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.didMetadata.getDidMetadata.query({ id });
+            },
+
+            getMyDidMetadata: async () => {
+                await ensureUser();
+
+                return client.didMetadata.getMyDidMetadata.query();
+            },
+
+            updateDidMetadata: async (_learnCard, id, updates) => {
+                await ensureUser();
+
+                const result = await client.didMetadata.updateDidMetadata.mutate({ id, updates });
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+
+            deleteDidMetadata: async (_learnCard, id) => {
+                await ensureUser();
+
+                const result = await client.didMetadata.deleteDidMetadata.mutate({ id });
+
+                if (result) await _learnCard.invoke.clearDidWebCache?.();
+
+                return result;
+            },
+
+            createClaimHook: async (_learnCard, hook) => {
+                await ensureUser();
+
+                return client.claimHook.createClaimHook.mutate({ hook });
+            },
+
+            getClaimHooksForBoost: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.claimHook.getClaimHooksForBoost.query(options);
+            },
+
+            deleteClaimHook: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.claimHook.deleteClaimHook.mutate({ id });
+            },
+
+            addAuthGrant: async (_learnCard, authGrant) => {
+                await ensureUser();
+
+                return client.authGrants.addAuthGrant.mutate(authGrant);
+            },
+            revokeAuthGrant: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.authGrants.revokeAuthGrant.mutate({ id });
+            },
+            deleteAuthGrant: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.authGrants.deleteAuthGrant.mutate({ id });
+            },
+            updateAuthGrant: async (_learnCard, id, updates) => {
+                await ensureUser();
+
+                return client.authGrants.updateAuthGrant.mutate({ id, updates });
+            },
+            getAuthGrant: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.authGrants.getAuthGrant.query({ id });
+            },
+            getAuthGrants: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.authGrants.getAuthGrants.query(options);
+            },
+            getAPITokenForAuthGrant: async (_learnCard, id) => {
+                await ensureUser();
+
+                const authGrant = await client.authGrants.getAuthGrant.query({ id });
+                if (!authGrant) throw new Error('Auth grant not found');
+                if (authGrant.status !== 'active') throw new Error('Auth grant is not active');
+                if (!authGrant.challenge) throw new Error('Auth grant has no challenge');
+                if (!authGrant.scope) throw new Error('Auth grant has no scope');
+                if (authGrant.expiresAt && new Date(authGrant.expiresAt) < new Date())
+                    throw new Error('Auth grant is expired');
+
+                const apiToken = (await _learnCard.invoke.getDidAuthVp({
+                    challenge: authGrant.challenge,
+                    proofFormat: 'jwt',
+                })) as string;
+
+                if (!apiToken) throw new Error('Failed to get API Token for auth grant');
+
+                return apiToken;
+            },
+
+            sendCredentialViaInbox: async (_learnCard, issueInboxCredential) => {
+                await ensureUser();
+
+                return client.inbox.issue.mutate(issueInboxCredential);
+            },
+            getMySentInboxCredentials: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.inbox.getMyIssuedCredentials.query(options);
+            },
+            getInboxCredential: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.inbox.getInboxCredential.query({ credentialId: id });
+            },
+            finalizeInboxCredentials: async _learnCard => {
+                await ensureUser();
+
+                return client.inbox.finalize.mutate();
+            },
+            sendGuardianApprovalEmail: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.inbox.sendGuardianApprovalEmail.mutate(options);
+            },
+            approveGuardianRequest: async (_learnCard, token) => {
+                // Open route; no auth required
+                return client.inbox.approveGuardianRequest.mutate({ token });
+            },
+            approveGuardianRequestByPath: async (_learnCard, token) => {
+                // Open route; no auth required
+                return client.inbox.approveGuardianRequestByPath.query({ token });
+            },
+            getGuardianPendingCredential: async (_learnCard, token) => {
+                // Open route; no auth required
+                return client.inbox.getGuardianPendingCredential.query({ token });
+            },
+            sendGuardianChallenge: async (_learnCard, token) => {
+                // Open route; no auth required
+                return client.inbox.sendGuardianChallenge.mutate({ token });
+            },
+            approveGuardianCredential: async (_learnCard, token, otpCode) => {
+                // Open route; no auth required
+                return client.inbox.approveGuardianCredential.mutate({ token, otpCode });
+            },
+            rejectGuardianCredential: async (_learnCard, token, otpCode) => {
+                // Open route; no auth required
+                return client.inbox.rejectGuardianCredential.mutate({ token, otpCode });
+            },
+            approveGuardianCredentialInApp: async (_learnCard, inboxCredentialId) => {
+                await ensureUser();
+                return client.inbox.approveGuardianCredentialInApp.mutate({ inboxCredentialId });
+            },
+            rejectGuardianCredentialInApp: async (_learnCard, inboxCredentialId) => {
+                await ensureUser();
+                return client.inbox.rejectGuardianCredentialInApp.mutate({ inboxCredentialId });
+            },
+            addContactMethod: async (_learnCard, contactMethod) => {
+                await ensureUser();
+
+                return client.contactMethods.addContactMethod.mutate(contactMethod);
+            },
+            getMyContactMethods: async _learnCard => {
+                await ensureUser();
+
+                return client.contactMethods.getMyContactMethods.query();
+            },
+            setPrimaryContactMethod: async (_learnCard, contactMethodId) => {
+                await ensureUser();
+
+                return client.contactMethods.setPrimaryContactMethod.mutate({ contactMethodId });
+            },
+            verifyContactMethod: async (_learnCard, token) => {
+                await ensureUser();
+
+                return client.contactMethods.verifyContactMethod.mutate({ token });
+            },
+            verifyContactMethodWithCredential: async (_learnCard, proofOfLoginJwt) => {
+                await ensureUser();
+
+                return client.contactMethods.verifyWithCredential.mutate({ proofOfLoginJwt });
+            },
+            removeContactMethod: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.contactMethods.removeContactMethod.mutate({ id });
+            },
+
+            // Skills & Skill Frameworks
+            syncFrameworkSkills: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.syncFrameworkSkills.mutate(input);
+            },
+            listSkillTags: async (_learnCard, frameworkId, skillId) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.listSkillTags.query({ frameworkId, id: skillId } as any);
+            },
+            addSkillTag: async (_learnCard, frameworkId, skillId, tag) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.addSkillTag.mutate({ frameworkId, id: skillId, tag } as any);
+            },
+            removeSkillTag: async (_learnCard, frameworkId, skillId, slug) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.removeSkillTag.mutate({
+                    frameworkId,
+                    id: skillId,
+                    slug,
+                } as any);
+            },
+            createManagedSkillFramework: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.createManaged.mutate(input);
+            },
+            createManagedSkillFrameworks: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.createManagedBatch.mutate(input);
+            },
+            createSkillFramework: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.create.mutate(input);
+            },
+            listMySkillFrameworks: async _learnCard => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.listMine.query();
+            },
+            getAllAvailableFrameworks: async (_learnCard, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.getAllAvailableFrameworks.query(options);
+            },
+            getSkillFrameworkById: async (_learnCard, id, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.getById.query({ id, ...options });
+            },
+            getBoostsThatUseFramework: async (_learnCard, frameworkId, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.getBoostsThatUseFramework.query({
+                    id: frameworkId,
+                    ...options,
+                });
+            },
+            countBoostsThatUseFramework: async (_learnCard, frameworkId, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.countBoostsThatUseFramework.query({
+                    id: frameworkId,
+                    ...options,
+                });
+            },
+            getFrameworkSkillTree: async (_learnCard, frameworkId, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.skills.getFrameworkSkillTree.query({ id: frameworkId, ...options });
+            },
+            getSkillChildren: async (_learnCard, frameworkId, skillId, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.skills.getSkillChildrenTree.query({
+                    frameworkId,
+                    id: skillId,
+                    ...options,
+                });
+            },
+            searchFrameworkSkills: async (_learnCard, frameworkId, query, options = {}) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.skills.searchFrameworkSkills.query({
+                    id: frameworkId,
+                    query,
+                    ...options,
+                });
+            },
+            semanticSearchSkills: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+
+                return client.skills.semanticSearchSkills.query(input);
+            },
+            updateSkillFramework: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.update.mutate(input);
+            },
+            deleteSkillFramework: async (_learnCard, id) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.delete.mutate({ id });
+            },
+            replaceSkillFrameworkSkills: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.replaceSkills.mutate(input);
+            },
+            countSkills: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.countSkills.query(input);
+            },
+            getFullSkillTree: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.getFullSkillTree.query(input);
+            },
+            getSkillPath: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.getSkillPath.query(input);
+            },
+            getSkillFrameworkAdmins: async (_learnCard, frameworkId) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.listFrameworkAdmins.query({ frameworkId });
+            },
+            addSkillFrameworkAdmin: async (_learnCard, frameworkId, profileId) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.addFrameworkAdmin.mutate({ frameworkId, profileId });
+            },
+            removeSkillFrameworkAdmin: async (_learnCard, frameworkId, profileId) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skillFrameworks.removeFrameworkAdmin.mutate({
+                    frameworkId,
+                    profileId,
+                });
+            },
+            getSkill: async (_learnCard, frameworkId, skillId) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.getSkill.query({ frameworkId, id: skillId });
+            },
+            createSkill: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.create.mutate(input);
+            },
+            createSkills: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.createMany.mutate(input);
+            },
+            updateSkill: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.update.mutate(input);
+            },
+            deleteSkill: async (_learnCard, input) => {
+                if (!userData) throw new Error('Please make an account first!');
+                return client.skills.delete.mutate(input);
+            },
+
+            // Integrations
+            addIntegration: async (_learnCard, integration) => {
+                await ensureUser();
+
+                return client.integrations.addIntegration.mutate(integration);
+            },
+            getIntegration: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.integrations.getIntegration.query({ id });
+            },
+            getIntegrations: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.integrations.getIntegrations.query(options);
+            },
+            countIntegrations: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.integrations.countIntegrations.query(options);
+            },
+            updateIntegration: async (_learnCard, id, updates) => {
+                await ensureUser();
+
+                return client.integrations.updateIntegration.mutate({ id, updates });
+            },
+            deleteIntegration: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.integrations.deleteIntegration.mutate({ id });
+            },
+
+            // App Store
+            createAppStoreListing: async (_learnCard, integrationId, listing) => {
+                await ensureUser();
+
+                return client.appStore.createListing.mutate({ integrationId, listing });
+            },
+            associateListingWithSigningAuthority: async (
+                _learnCard,
+                listingId,
+                endpoint,
+                name,
+                did,
+                isPrimary
+            ) => {
+                await ensureUser();
+
+                return client.appStore.associateListingWithSigningAuthority.mutate({
+                    listingId,
+                    endpoint,
+                    name,
+                    did,
+                    isPrimary,
+                });
+            },
+            getListingSigningAuthority: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.getListingSigningAuthority.query({ listingId });
+            },
+            getIntegrationForListing: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.getIntegrationForListing.query({ listingId });
+            },
+
+            getAppStoreListing: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.getListing.query({ listingId });
+            },
+
+            updateAppStoreListing: async (_learnCard, listingId, updates) => {
+                await ensureUser();
+
+                return client.appStore.updateListing.mutate({ listingId, updates });
+            },
+
+            deleteAppStoreListing: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.deleteListing.mutate({ listingId });
+            },
+
+            submitAppStoreListingForReview: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.submitForReview.mutate({ listingId });
+            },
+
+            unsubmitAppStoreListing: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.unsubmitForReview.mutate({ listingId });
+            },
+
+            getListingsForIntegration: async (_learnCard, integrationId, options = {}) => {
+                await ensureUser();
+
+                return client.appStore.getListingsForIntegration.query({
+                    integrationId,
+                    ...options,
+                });
+            },
+
+            countListingsForIntegration: async (_learnCard, integrationId) => {
+                await ensureUser();
+
+                return client.appStore.countListingsForIntegration.query({ integrationId });
+            },
+
+            browseAppStore: async (_learnCard, options) => {
+                return client.appStore.browseListedApps.query(options);
+            },
+
+            getPublicAppStoreListing: async (_learnCard, listingId) => {
+                return client.appStore.getPublicListing.query({ listingId });
+            },
+
+            getPublicAppStoreListingBySlug: async (_learnCard, slug) => {
+                return client.appStore.getPublicListingBySlug.query({ slug });
+            },
+
+            getAppStoreListingInstallCount: async (_learnCard, listingId) => {
+                return client.appStore.getListingInstallCount.query({ listingId });
+            },
+
+            installApp: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.installApp.mutate({ listingId });
+            },
+
+            uninstallApp: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.uninstallApp.mutate({ listingId });
+            },
+
+            getInstalledApps: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.appStore.getInstalledApps.query(options);
+            },
+
+            countInstalledApps: async _learnCard => {
+                await ensureUser();
+
+                return client.appStore.countInstalledApps.query();
+            },
+
+            isAppInstalled: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.isAppInstalled.query({ listingId });
+            },
+
+            getMyCredentialsFromApp: async (_learnCard, listingId, options = {}) => {
+                await ensureUser();
+
+                return client.appStore.getMyCredentialsFromApp.query({ listingId, ...options });
+            },
+
+            isAppStoreAdmin: async _learnCard => {
+                await ensureUser();
+
+                return client.appStore.isAdmin.query();
+            },
+
+            adminUpdateListingStatus: async (_learnCard, listingId, status) => {
+                await ensureUser();
+
+                return client.appStore.adminUpdateListingStatus.mutate({ listingId, status });
+            },
+
+            adminUpdatePromotionLevel: async (_learnCard, listingId, promotionLevel) => {
+                await ensureUser();
+
+                return client.appStore.adminUpdatePromotionLevel.mutate({
+                    listingId,
+                    promotionLevel,
+                });
+            },
+
+            adminGetAllListings: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.appStore.adminGetAllListings.query(options);
+            },
+
+            // App Store Boost Management
+            addBoostToApp: async (_learnCard, listingId, boostUri, templateAlias) => {
+                await ensureUser();
+
+                return client.appStore.addBoostToListing.mutate({
+                    listingId,
+                    boostUri,
+                    templateAlias,
+                });
+            },
+
+            associateBoostWithListing: async (_learnCard, listingId, boostUri, templateAlias) => {
+                await ensureUser();
+
+                return client.appStore.addBoostToListing.mutate({
+                    listingId,
+                    boostUri,
+                    templateAlias,
+                });
+            },
+
+            removeBoostFromApp: async (_learnCard, listingId, templateAlias) => {
+                await ensureUser();
+
+                return client.appStore.removeBoostFromListing.mutate({ listingId, templateAlias });
+            },
+
+            getAppBoosts: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.getBoostsForListing.query({ listingId });
+            },
+
+            // Generic App Event
+            sendAppEvent: async (_learnCard, listingId, event) => {
+                await ensureUser();
+
+                return client.appStore.appEvent.mutate({ listingId, event });
+            },
+
+            resolveFromLCN: async (_learnCard, uri) => {
+                const result = await client.storage.resolve.query({ uri });
+
+                return UnsignedVCValidator.or(VCValidator)
+                    .or(VPValidator)
+                    .or(JWEValidator)
+                    .or(ConsentFlowContractValidator)
+                    .or(ConsentFlowTermsValidator)
+                    .parseAsync(result);
+            },
+
+            getLCNClient: () => client,
+
+            // Activity
+            getMyActivities: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.activity.getMyActivities.query(options);
+            },
+
+            getActivityStats: async (_learnCard, options = {}) => {
+                await ensureUser();
+
+                return client.activity.getActivityStats.query(options);
+            },
+
+            getActivity: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.activity.getActivity.query(options);
+            },
+
+            getActivityChain: async (_learnCard, options) => {
+                await ensureUser();
+
+                return client.activity.getActivityChain.query(options);
+            },
+
+            isServiceTrusted: async (_learnCard, serviceDid) => {
+                const trustedServices = await client.federation.getTrustedServices.query({});
+                return trustedServices.some(s => s.did === serviceDid);
+            },
+
+            getTrustedServices: async () => {
+                return client.federation.getTrustedServices.query({});
+            },
+        },
+    };
+}
+
+/**
+ * @group Plugins
+ */
+export const getVerifyBoostPlugin = async (
+    learnCard: LearnCard<any, any, VerifyExtension>,
+    trustedBoostRegistryUrl?: string
+): Promise<VerifyBoostPlugin> => {
+    const DEFAULT_TRUSTED_BOOST_REGISTRY: TrustedBoostRegistryEntry[] = [
+        {
+            id: 'LearnCard Network',
+            url: 'https://network.learncard.com',
+            did: 'did:web:network.learncard.com',
+        },
+    ];
+
+    let boostRegistry: TrustedBoostRegistryEntry[];
+
+    if (trustedBoostRegistryUrl) {
+        const res = await fetch(trustedBoostRegistryUrl);
+        if (res.status === 200) {
+            boostRegistry = JSON.parse(await res.text());
+        } else {
+            boostRegistry = DEFAULT_TRUSTED_BOOST_REGISTRY;
+        }
+    } else {
+        boostRegistry = DEFAULT_TRUSTED_BOOST_REGISTRY;
+    }
+
+    const getIssuerDID = (issuer: string | Profile | undefined): string | undefined => {
+        if (!issuer) return;
+        if (typeof issuer === 'string') {
+            return issuer;
+        } else if ('id' in issuer && typeof issuer.id === 'string') {
+            return issuer.id;
+        } else {
+            return;
+        }
+    };
+    const getTrustedBoostVerifier = (
+        issuer: string | Profile | undefined
+    ): TrustedBoostRegistryEntry | undefined => {
+        const issuerDID = getIssuerDID(issuer);
+        if (!issuerDID) return;
+        return boostRegistry.find(o => o.did === issuerDID);
+    };
+    return {
+        name: 'VerifyBoost',
+        displayName: 'Verify Boost Extension',
+        description: 'Adds a check for validating Boost Credentials.',
+        methods: {
+            verifyCredential: async (_learnCard, credential, options) => {
+                const verificationCheck = await learnCard.invoke.verifyCredential(
+                    credential,
+                    options
+                );
+                const boostCredential = credential?.boostCredential;
+                try {
+                    if (boostCredential) {
+                        const verifyBoostCredential = await learnCard.invoke.verifyCredential(
+                            boostCredential
+                        );
+                        const boostCredentialErrors = verifyBoostCredential.errors ?? [];
+                        if (verifyBoostCredential.status?.length) {
+                            verificationCheck.status = [
+                                ...(verificationCheck.status ?? []),
+                                ...verifyBoostCredential.status,
+                            ];
+                        }
+
+                        if (!boostCredential?.boostId && !credential?.boostId) {
+                            verificationCheck.warnings.push(
+                                'Boost Authenticity could not be verified: Boost ID metadata is missing.'
+                            );
+                        }
+
+                        if (boostCredentialErrors.length > 0) {
+                            if (
+                                boostCredentialErrors.some(error =>
+                                    /revoked|suspend|status/i.test(error)
+                                )
+                            ) {
+                                verificationCheck.checks = verificationCheck.checks.filter(
+                                    check => check !== 'status'
+                                );
+                            }
+
+                            verificationCheck.errors = [
+                                ...boostCredentialErrors,
+                                ...(verificationCheck.errors || []),
+                                'Boost Credential could not be verified.',
+                            ];
+                        } else if (boostCredential?.boostId !== credential?.boostId) {
+                            verificationCheck.errors.push(
+                                'Boost Authenticity could not be verified: Boost ID metadata is mismatched.'
+                            );
+                        } else {
+                            const trustedBoostIssuer = getTrustedBoostVerifier(credential?.issuer);
+                            if (trustedBoostIssuer) {
+                                verificationCheck.checks.push(
+                                    `Boost is Authentic. Verified by ${trustedBoostIssuer.id}.`
+                                );
+                            } else {
+                                verificationCheck.warnings.push(
+                                    `Boost Authenticity could not be verified. Issuer is outside of trust network: ${getIssuerDID(
+                                        credential?.issuer
+                                    )}`
+                                );
+                            }
+                        }
+                    }
+                } catch {
+                    verificationCheck.errors.push('Boost authenticity could not be verified.');
+                }
+                return verificationCheck;
+            },
+        },
+    };
+};