@learncard/cli 3.6.8 → 4.0.0

package/src/setup-signing.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { authorityName, setupSigning } from './setup-signing';
-import { loadProject } from './project';
-
-describe('signing authority setup', () => {
-    it('defaults to default-issuer and reuses the project selection', () => {
-        const project = { env: {}, existing: '', envPath: '/unused/.env' };
-        expect(authorityName(project)).toBe('default-issuer');
-        expect(authorityName({ ...project, env: { SIGNING_AUTHORITY_NAME: 'existing' } })).toBe(
-            'existing'
-        );
-        expect(authorityName(project, 'custom')).toBe('custom');
-    });
-    it('resumes after failed registration and leaves an existing primary untouched', async () => {
-        const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'lc-signing-'));
-        const log = vi.spyOn(console, 'log').mockImplementation(() => {});
-        const authority = {
-            name: 'default-issuer',
-            endpoint: 'https://issuer.example/api',
-            did: 'did:key:issuer',
-            ownerDid: 'did:key:owner',
-        };
-        const invoke = {
-            getRegisteredSigningAuthorities: vi.fn().mockResolvedValue([]),
-            getSigningAuthorities: vi.fn().mockResolvedValueOnce([]).mockResolvedValue([authority]),
-            createSigningAuthority: vi.fn().mockResolvedValue(authority),
-            registerSigningAuthority: vi
-                .fn()
-                .mockRejectedValueOnce(new Error('Connection lost'))
-                .mockResolvedValue(true),
-            setPrimaryRegisteredSigningAuthority: vi.fn().mockResolvedValue(true),
-        };
-        try {
-            const project = await loadProject(cwd);
-            await expect(setupSigning(project, { invoke })).rejects.toThrow('Connection lost');
-            await setupSigning(project, { invoke });
-            expect(invoke.createSigningAuthority).toHaveBeenCalledTimes(1);
-            expect(project.env.SIGNING_AUTHORITY_ENDPOINT).toBe(authority.endpoint);
-            invoke.getRegisteredSigningAuthorities.mockResolvedValue([
-                {
-                    signingAuthority: { endpoint: authority.endpoint },
-                    relationship: { name: authority.name, did: authority.did, isPrimary: true },
-                },
-            ]);
-            await setupSigning(project, { invoke });
-            expect(invoke.createSigningAuthority).toHaveBeenCalledTimes(1);
-            expect(invoke.setPrimaryRegisteredSigningAuthority).toHaveBeenCalledTimes(1);
-            expect(log).toHaveBeenCalledWith(
-                'Signing authority "default-issuer" is already your primary.'
-            );
-            const demoProject = { env: {}, existing: '', envPath: '/unused/.env' };
-            await setupSigning(demoProject, { invoke }, undefined, { persist: false });
-            expect(demoProject.env).toEqual({});
-        } finally {
-            log.mockRestore();
-            await fs.rm(cwd, { recursive: true, force: true });
-        }
-    });
-});

package/src/setup-signing.ts

@@ -1,185 +0,0 @@
-import type { LCALearnCard } from '@learncard/lca-api-plugin';
-import {
-    connect,
-    ensureIdentity,
-    ensureProfile,
-    loadProject,
-    saveProject,
-    type Project,
-    type ProjectOptions,
-    type NetworkCard,
-} from './project';
-import { out } from './out';
-
-export const authorityName = (project: Project, name?: string): string =>
-    name ?? project.env.SIGNING_AUTHORITY_NAME ?? 'default-issuer';
-
-export interface SigningAuthorityResult {
-    name: string;
-    endpoint: string;
-    did: string;
-    alreadyConfigured: boolean;
-}
-
-type SigningCard = {
-    invoke: Pick<
-        LCALearnCard['invoke'],
-        | 'getRegisteredSigningAuthorities'
-        | 'getSigningAuthorities'
-        | 'setPrimaryRegisteredSigningAuthority'
-        | 'createSigningAuthority'
-        | 'registerSigningAuthority'
-    >;
-};
-
-/** Create and register a hosted signer once; also repair a changed primary selection. */
-export const setupSigning = async (
-    project: Project,
-    learnCard: SigningCard,
-    requestedName?: string,
-    options: { persist?: boolean } = {}
-): Promise<SigningAuthorityResult> => {
-    const name = authorityName(project, requestedName);
-    const registered = (await learnCard.invoke.getRegisteredSigningAuthorities()).find(
-        authority =>
-            authority.relationship.name === name &&
-            (requestedName ||
-                !project.env.SIGNING_AUTHORITY_ENDPOINT ||
-                authority.signingAuthority.endpoint === project.env.SIGNING_AUTHORITY_ENDPOINT)
-    );
-    if (registered) {
-        const endpoint = registered.signingAuthority.endpoint;
-        if (!registered.relationship.isPrimary) {
-            if (!(await learnCard.invoke.setPrimaryRegisteredSigningAuthority(endpoint, name))) {
-                throw new Error(
-                    'Could not select the primary signing authority. Please try again.'
-                );
-            }
-        }
-        if (options.persist !== false) {
-            await saveProject(project, {
-                SIGNING_AUTHORITY_NAME: name,
-                SIGNING_AUTHORITY_ENDPOINT: endpoint,
-            });
-        }
-        out.log(`Signing authority "${name}" is already your primary.`);
-        return { name, endpoint, did: registered.relationship.did, alreadyConfigured: true };
-    }
-    const hosted = await learnCard.invoke.getSigningAuthorities();
-    if (!hosted) throw new Error('Could not look up hosted signing authorities. Please try again.');
-    const existing = hosted.find(authority => authority.name === name);
-    const authority = existing || (await learnCard.invoke.createSigningAuthority(name));
-    if (!authority || !authority.endpoint || !authority.did)
-        throw new Error('Could not create signing authority. Please try again.');
-    const registeredSuccessfully = await learnCard.invoke.registerSigningAuthority(
-        authority.endpoint,
-        authority.name,
-        authority.did
-    );
-    if (!registeredSuccessfully)
-        throw new Error('Could not register signing authority. Please try again.');
-    if (
-        !(await learnCard.invoke.setPrimaryRegisteredSigningAuthority(
-            authority.endpoint,
-            authority.name
-        ))
-    ) {
-        throw new Error('Could not select the primary signing authority. Please try again.');
-    }
-    if (options.persist !== false) {
-        await saveProject(project, {
-            SIGNING_AUTHORITY_NAME: authority.name,
-            SIGNING_AUTHORITY_ENDPOINT: authority.endpoint,
-        });
-    }
-    out.log(`LearnCard will now sign credentials for ${project.env.PROFILE_ID}.`);
-    out.log('What this did:');
-    out.log(
-        existing
-            ? `  const authority = (await learnCard.invoke.getSigningAuthorities()).find(authority => authority.name === ${JSON.stringify(name)});`
-            : `  const authority = await learnCard.invoke.createSigningAuthority(${JSON.stringify(name)});`
-    );
-    out.log(
-        '  await learnCard.invoke.registerSigningAuthority(authority.endpoint, authority.name, authority.did);'
-    );
-    out.log(
-        '  await learnCard.invoke.setPrimaryRegisteredSigningAuthority(authority.endpoint, authority.name);'
-    );
-    return {
-        name: authority.name,
-        endpoint: authority.endpoint,
-        did: authority.did,
-        alreadyConfigured: false,
-    };
-};
-
-type SetupSigningOptions = ProjectOptions & { endpoint?: string; did?: string };
-
-/** Register a signing service you run yourself instead of a LearnCard-hosted one. */
-const registerOwnAuthority = async (
-    project: Project,
-    learnCard: {
-        invoke: Pick<
-            NetworkCard['invoke'],
-            'registerSigningAuthority' | 'setPrimaryRegisteredSigningAuthority'
-        >;
-    },
-    name: string,
-    endpoint: string,
-    did: string
-) => {
-    if (!/^https:\/\//.test(endpoint)) throw new Error('--endpoint must be an https:// URL.');
-    if (!/^did:/.test(did)) throw new Error('--did must be a DID (did:web:..., did:key:...).');
-    if (!(await learnCard.invoke.registerSigningAuthority(endpoint, name, did)))
-        throw new Error('Could not register the signing authority.');
-    if (!(await learnCard.invoke.setPrimaryRegisteredSigningAuthority(endpoint, name)))
-        throw new Error('Could not set the signing authority as primary.');
-    await saveProject(project, {
-        SIGNING_AUTHORITY_NAME: name,
-        SIGNING_AUTHORITY_ENDPOINT: endpoint,
-    });
-    out.log(`Your service at ${endpoint} will now sign credentials for this profile.`);
-    out.log('What this did:');
-    out.log(
-        `  await learnCard.invoke.registerSigningAuthority(${JSON.stringify(endpoint)}, ${JSON.stringify(name)}, ${JSON.stringify(did)});`
-    );
-    out.log(
-        `  await learnCard.invoke.setPrimaryRegisteredSigningAuthority(${JSON.stringify(endpoint)}, ${JSON.stringify(name)});`
-    );
-    return { name, endpoint, did, alreadyConfigured: false };
-};
-
-export const runSetupSigning = async (options: SetupSigningOptions): Promise<void> => {
-    const project = await loadProject(process.cwd());
-    const identity = await ensureIdentity(project, { ...options, name: undefined });
-    if ((options.endpoint && !options.did) || (!options.endpoint && options.did))
-        throw new Error('Pass both --endpoint and --did to register your own signing service.');
-    let authority;
-    if (options.endpoint) {
-        const learnCard = await connect(project, options);
-        await ensureProfile(learnCard, identity, project);
-        authority = await registerOwnAuthority(
-            project,
-            learnCard,
-            options.name ?? 'my-issuer',
-            options.endpoint,
-            options.did!
-        );
-    } else {
-        const learnCard = await connect(project, { ...options, lca: true });
-        await ensureProfile(learnCard, identity, project);
-        authority = await setupSigning(project, learnCard, options.name);
-    }
-    out.set({
-        profileId: identity.profileId,
-        signingAuthority: {
-            name: authority.name,
-            endpoint: authority.endpoint,
-            did: authority.did,
-        },
-        alreadyConfigured: authority.alreadyConfigured,
-    });
-    out.log(
-        'Send from a template: npx @learncard/cli send --template\nSee it in the app: npx @learncard/cli open'
-    );
-};

package/src/snippet-files.ts

@@ -1,16 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { out } from './out';
-
-/** Preserve files a developer may already have customized. Returns whether this run wrote it. */
-export const writeSnippet = async (filename: string, source: string): Promise<boolean> => {
-    try {
-        await fs.writeFile(path.join(process.cwd(), filename), source, { flag: 'wx' });
-        out.log(`Wrote ./${filename}`);
-        return true;
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-        out.log(`Kept existing ./${filename}`);
-        return false;
-    }
-};

package/src/status.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatEvent, summarize } from './status';
-
-const created = {
-    activityId: 'a1',
-    eventType: 'CREATED',
-    timestamp: '2026-09-11T18:12:27.116Z',
-    recipientType: 'email',
-    recipientIdentifier: 'jane@example.com',
-    boost: { name: 'Quickstart Complete' },
-};
-
-describe('status', () => {
-    it('reports the latest event as the state and keeps the chain newest-first', () => {
-        const claimed = {
-            ...created,
-            eventType: 'CLAIMED',
-            timestamp: '2026-09-11T18:20:00.000Z',
-            credentialUri: 'lc:network:x/trpc:credential:1',
-        };
-        const s = summarize([created, claimed]);
-        expect(s.state).toBe('CLAIMED');
-        expect(s.credentialUri).toBe('lc:network:x/trpc:credential:1');
-        expect(s.events.map(e => e.type)).toEqual(['CLAIMED', 'CREATED']);
-    });
-
-    it('surfaces the failure reason on FAILED events', () => {
-        const failed = { ...created, eventType: 'FAILED', metadata: { error: 'bad email' } };
-        expect(formatEvent(failed)).toContain('FAILED');
-        expect(formatEvent(failed)).toContain('bad email');
-        expect(summarize([failed]).events[0]).toMatchObject({ type: 'FAILED', error: 'bad email' });
-    });
-});

package/src/status.ts

@@ -1,94 +0,0 @@
-import { connect, ensureIdentity, loadProject, type ProjectOptions } from './project';
-import { out } from './out';
-
-type ActivityEvent = {
-    activityId: string;
-    eventType: string;
-    timestamp: string;
-    recipientType: string;
-    recipientIdentifier: string;
-    credentialUri?: string;
-    status?: string;
-    boost?: { name?: string } | null;
-    metadata?: Record<string, unknown>;
-};
-
-const LATEST_FIRST = (a: ActivityEvent, b: ActivityEvent) => b.timestamp.localeCompare(a.timestamp);
-
-/** One human line per event: time, what happened, to whom. */
-export const formatEvent = (event: ActivityEvent): string => {
-    const when = event.timestamp.replace('T', ' ').slice(0, 19);
-    const failure = event.eventType === 'FAILED' ? `  ${String(event.metadata?.error ?? '')}` : '';
-    return `${when}  ${event.eventType.padEnd(9)} ${event.recipientIdentifier}${failure}`;
-};
-
-/** Collapse a chain into what a developer wants to know: the current state. */
-export const summarize = (chain: ActivityEvent[]) => {
-    const ordered = [...chain].sort(LATEST_FIRST);
-    const latest = ordered[0];
-    const claimed = chain.find(e => e.eventType === 'CLAIMED');
-    return {
-        state: latest?.eventType ?? 'UNKNOWN',
-        recipient: latest?.recipientIdentifier,
-        template: latest?.boost?.name,
-        credentialUri: claimed?.credentialUri ?? latest?.credentialUri,
-        credentialStatus: latest?.status,
-        events: ordered.map(e => ({
-            type: e.eventType,
-            at: e.timestamp,
-            ...(e.eventType === 'FAILED' && e.metadata?.error ? { error: e.metadata.error } : {}),
-        })),
-    };
-};
-
-type StatusOptions = ProjectOptions & { limit?: string; event?: string };
-
-export const runStatus = async (activityId: string | undefined, options: StatusOptions) => {
-    const project = await loadProject(process.cwd());
-    if (!project.env.SECURE_SEED)
-        throw new Error('No SECURE_SEED in .env. Send something first: npx @learncard/cli send');
-    await ensureIdentity(project, options);
-    const learnCard = await connect(project, options);
-
-    if (activityId) {
-        const chain = (await learnCard.invoke.getActivityChain({ activityId })) as ActivityEvent[];
-        if (!chain.length) throw new Error(`No activity found for ${activityId}.`);
-        const summary = summarize(chain);
-        out.log(`${summary.state}  ${summary.template ?? ''} → ${summary.recipient}`);
-        for (const e of [...chain].sort(LATEST_FIRST)) out.log(`  ${formatEvent(e)}`);
-        if (summary.credentialUri) out.log(`Credential: ${summary.credentialUri}`);
-        if (summary.state !== 'CLAIMED')
-            out.log('Not claimed yet. Re-run to check again, or use `webhook` to be told.');
-        out.set({ activityId, ...summary });
-        return;
-    }
-
-    const limit = Number(options.limit ?? 20);
-    const eventType = options.event?.toUpperCase();
-    const page = await learnCard.invoke.getMyActivities({
-        limit,
-        ...(eventType ? { eventType: eventType as never } : {}),
-    });
-    const records = page.records as ActivityEvent[];
-    if (!records.length) {
-        out.log('No sends yet. Try: npx @learncard/cli send');
-        out.set({ activities: [] });
-        return;
-    }
-    out.log('activityId                            state      recipient');
-    for (const r of records)
-        out.log(`${r.activityId}  ${r.eventType.padEnd(9)}  ${r.recipientIdentifier}`);
-    if (page.hasMore)
-        out.log(`…more. Raise --limit or filter with --event claimed|delivered|created.`);
-    out.log('Details for one: npx @learncard/cli status <activityId>');
-    out.set({
-        activities: records.map(r => ({
-            activityId: r.activityId,
-            state: r.eventType,
-            recipient: r.recipientIdentifier,
-            template: r.boost?.name,
-            at: r.timestamp,
-        })),
-        hasMore: page.hasMore,
-    });
-};

package/src/token.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateScope, SCOPE_RESOURCES } from './token';
-import { SEND_SH } from './generated/snippets';
-import { withEnvTokenLoader } from './project';
-
-describe('token scopes', () => {
-    it('accepts real resource names and wildcards', () => {
-        for (const resource of SCOPE_RESOURCES)
-            expect(validateScope(`${resource}:write`)).toBe(`${resource}:write`);
-        expect(validateScope('  boosts:write   inbox:read ')).toBe('boosts:write inbox:read');
-        expect(validateScope('*:*')).toBe('*:*');
-        expect(validateScope('')).toBe('');
-    });
-    it('rejects unknown resources, stale aliases, and malformed actions', () => {
-        expect(() => validateScope('unicorns:write')).toThrow('Unknown scope resource');
-        expect(() => validateScope('profile:write')).toThrow('profiles');
-        expect(() => validateScope('boosts:admin')).toThrow('read, write, delete');
-        expect(() => validateScope('boosts:write:extra')).toThrow();
-    });
-    it('writes send.sh that reads API_TOKEN from .env without executing it', () => {
-        const written = withEnvTokenLoader(SEND_SH);
-        expect(written).toContain("sed -n 's/^API_TOKEN=//p' .env");
-        expect(written).not.toMatch(/tr -d/);
-        expect(written).toContain('Bearer $TOKEN');
-        expect(written).not.toContain('. .env');
-        expect(written).not.toContain('source .env');
-    });
-});

package/src/token.ts

@@ -1,139 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import {
-    connect,
-    ensureIdentity,
-    ensureProfile,
-    loadProject,
-    saveProject,
-    type ProjectOptions,
-    localizeSnippet,
-    resolveServices,
-    withEnvTokenLoader,
-} from './project';
-import { out } from './out';
-
-// Route-derived resources documented in auth-grants-and-api-tokens.md (not the stale singular aliases).
-export const SCOPE_RESOURCES = [
-    'boosts',
-    'inbox',
-    'credentials',
-    'presentations',
-    'profiles',
-    'profileManagers',
-    'connections',
-    'contracts',
-    'contracts-data',
-    'signingAuthorities',
-    'authGrants',
-    'didMetadata',
-    'claimHooks',
-    'skills',
-    'app-store',
-    'integrations',
-    'contact-methods',
-    'activity',
-    'storage',
-] as const;
-
-export const validateScope = (scope: string): string => {
-    for (const part of scope.trim().split(/\s+/).filter(Boolean)) {
-        const [resource, action, extra] = part.split(':');
-        if (
-            extra !== undefined ||
-            !resource ||
-            (resource !== '*' && !SCOPE_RESOURCES.some(value => value === resource))
-        ) {
-            throw new Error(
-                `Unknown scope resource in "${part}". Choose: ${SCOPE_RESOURCES.join(', ')}, or *.`
-            );
-        }
-        if (!action || !['read', 'write', 'delete', '*'].includes(action)) {
-            throw new Error(`Invalid action in "${part}". Use read, write, delete, or *.`);
-        }
-    }
-    return scope.trim().split(/\s+/).filter(Boolean).join(' ');
-};
-
-export const runToken = async (
-    options: ProjectOptions & { scope?: string; revoke?: string; expires?: string; list?: boolean }
-): Promise<void> => {
-    const scope = validateScope(options.scope ?? 'boosts:write');
-    const project = await loadProject(process.cwd());
-    const identity = await ensureIdentity(project, { ...options, name: undefined });
-    const learnCard = await connect(project, options);
-    await ensureProfile(learnCard, identity, project);
-    if (options.list) {
-        const grants = (await learnCard.invoke.getAuthGrants()) ?? [];
-        for (const g of grants)
-            out.log(
-                `${g.id}  ${(g.status ?? '').padEnd(8)} ${(g.scope ?? '').padEnd(22)} ${g.name ?? ''}${
-                    g.expiresAt ? `  expires ${g.expiresAt.slice(0, 10)}` : ''
-                }`
-            );
-        if (!grants.length) out.log('No auth grants yet.');
-        out.set({
-            grants: grants.map(g => ({
-                id: g.id,
-                name: g.name,
-                scope: g.scope,
-                status: g.status,
-                expiresAt: g.expiresAt,
-            })),
-        });
-        return;
-    }
-    if (options.revoke) {
-        if (!(await learnCard.invoke.revokeAuthGrant(options.revoke)))
-            throw new Error('Could not revoke auth grant.');
-        out.log(`Revoked auth grant ${options.revoke}.`);
-        out.log('Create a replacement: npx @learncard/cli token');
-        out.set({ grantId: options.revoke });
-        return;
-    }
-    const id = await learnCard.invoke.addAuthGrant({
-        name: options.name ?? `cli-${new Date().toISOString().slice(0, 10)}`,
-        scope,
-        ...(options.expires
-            ? {
-                  expiresAt: new Date(
-                      Date.now() + Number(options.expires) * 86_400_000
-                  ).toISOString(),
-              }
-            : {}),
-    });
-    const token = await learnCard.invoke.getAPITokenForAuthGrant(id);
-    // Tighten existing files before writing the bearer credential.
-    await fs.chmod(project.envPath, 0o600);
-    await saveProject(project, { API_TOKEN: token, API_TOKEN_SCOPE: scope });
-    out.log(`Created auth grant ${id}.`);
-    out.log(
-        "Warning: this token won't be shown again by this command. It is saved in .env; keep it private."
-    );
-    out.log(token);
-    const file = path.join(process.cwd(), 'send.sh');
-    let wroteSendSh = false;
-    // Static import would make org schema validation require this absent-on-clean-checkout asset.
-    const { SEND_SH } = await import('./generated/snippets');
-    try {
-        await fs.writeFile(
-            file,
-            withEnvTokenLoader(
-                localizeSnippet(SEND_SH, resolveServices(project.env, options.network))
-            ),
-            {
-                flag: 'wx',
-                mode: 0o700,
-            }
-        );
-        out.log('Wrote ./send.sh');
-        wroteSendSh = true;
-    } catch (error) {
-        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-        out.log('Kept existing ./send.sh');
-    }
-    out.log(
-        'Next: save your send payload as request.json, then run sh ./send.sh (example: https://docs.learncard.com/start-here/your-first-integration).'
-    );
-    out.set({ grantId: id, scope, token, files: wroteSendSh ? ['./send.sh'] : [] });
-};

package/src/types.d.ts

@@ -1,17 +0,0 @@
-declare module 'gradient-string' {
-    const gradient: (...args: any[]) => any;
-    export default gradient;
-}
-
-declare module '@learncard/holder-continuity' {
-    export type ExportLearnCardBundleOptions = any;
-    export type LearnCardBundleWallet = any;
-    export type RestoreLearnCardFromBundleOptions = any;
-    export type RestoreLearnCardInit = any;
-
-    export const createLearnCardBundle: any;
-    export const exportLearnCardBundle: any;
-    export const importLearnCardBundle: any;
-    export const readLearnCardBundle: any;
-    export const restoreLearnCardFromBundle: any;
-}

package/src/verify.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatVerification, isPresentation, verificationFailed } from './verify';
-
-describe('verification output', () => {
-    it('formats raw checks and errors', () => {
-        const result = {
-            checks: ['expiration'],
-            errors: ['signature error: Bad signature'],
-            warnings: ['Review issuer'],
-        };
-        expect(formatVerification(result)).toEqual([
-            '✓ expiration',
-            '! Review issuer',
-            '✗ proof: Bad signature',
-        ]);
-        expect(verificationFailed(result)).toBe(true);
-    });
-    it('keeps warnings distinct from failures in prettified output', () => {
-        const result = [
-            { status: 'Success' as const, check: 'proof', message: 'Valid' },
-            { status: 'Error' as const, check: 'issuer', message: 'Not checked' },
-        ];
-        expect(formatVerification(result)).toEqual(['✓ proof', '! issuer: Not checked']);
-        expect(verificationFailed(result)).toBe(false);
-        expect(verificationFailed([{ status: 'Failed', check: 'proof', details: 'Invalid' }])).toBe(
-            true
-        );
-    });
-    it('detects presentations by string or array type', () => {
-        expect(isPresentation({ type: ['VerifiablePresentation'] })).toBe(true);
-        expect(isPresentation({ type: 'VerifiablePresentation' })).toBe(true);
-        expect(isPresentation({ type: ['VerifiableCredential'] })).toBe(false);
-        expect(isPresentation(null)).toBe(false);
-    });
-});