@learncard/network-plugin 3.0.0 → 3.1.0

package/src/plugin.ts

@@ -30,6 +30,7 @@ import {
     getCredentialStatusArray,
     injectManagedRefreshService as injectSharedManagedRefreshService,
     isVC2Format,
+    isEncrypted,
     resolveStorageReadResult,
 } from '@learncard/helpers';
 import Mustache from 'mustache';
@@ -544,6 +545,8 @@ const isActAsDenial = (error: unknown): boolean => {
     }
     return false;
 };
+const getInboxFailureReason = (reason: unknown): string =>
+    reason instanceof Error ? `${reason.name}: ${reason.message}` : String(reason);
 
 /**
  * @group Plugins
@@ -1147,6 +1150,73 @@ export async function getLearnCardNetworkPlugin(
                 return client.profile.invalidateInvite.mutate({ challenge });
             },
 
+            createShareLink: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.create.mutate(input);
+            },
+            putShareLinkAttachmentChunk: async (_learnCard, input) => {
+                await ensureUser();
+                return client.shareLinks.putAttachmentChunk.mutate(input);
+            },
+            deleteShareLinkAttachmentChunks: async (_learnCard, input) => {
+                await ensureUser();
+                return client.shareLinks.deleteAttachmentChunks.mutate(input);
+            },
+            getShareLinkAttachmentChunk: async (_learnCard, input) =>
+                client.publicShareLinks.attachmentChunk.mutate(input),
+            updateShareLink: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.update.mutate(input);
+            },
+            revokeShareLink: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.revoke.mutate(input);
+            },
+            getShareLink: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.shareLinks.get.query({ id });
+            },
+            getShareLinkOperationStatus: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.getOperationStatus.query(input);
+            },
+            retryShareLinkOperation: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.retry.mutate(input);
+            },
+            getShareLinkRecovery: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.shareLinks.getRecovery.query({ id });
+            },
+            getShareLinkOwnerContent: async (_learnCard, id) => {
+                await ensureUser();
+
+                return client.shareLinks.getContent.query({ id });
+            },
+            listShareLinks: async (_learnCard, input) => {
+                await ensureUser();
+
+                return client.shareLinks.list.query(input);
+            },
+
+            // Anonymous public methods: deliberately NO `ensureUser()`. A viewer
+            // has no account and must not need one.
+            // POST keeps an optional passcode in the request body and out of URLs,
+            // access logs, browser history and referrers.
+            resolveShareLink: async (_learnCard, id, passcode) =>
+                client.publicShareLinks.resolve.mutate({ id, passcode }),
+            getShareLinkContent: async (_learnCard, id, passcode) =>
+                client.publicShareLinks.content.mutate({ id, passcode }),
+            acknowledgeShareLinkView: async (_learnCard, receipt) =>
+                client.publicShareLinks.acknowledgeView.mutate({ receipt }),
+
             blockProfile: async (_learnCard, profileId) => {
                 await ensureUser();
 
@@ -1291,13 +1361,19 @@ export async function getLearnCardNetworkPlugin(
                 return client.credential.deleteCredential.mutate({ uri });
             },
 
-            sendPresentation: async (_learnCard, profileId, vp, encrypt = true) => {
+            sendPresentation: async (_learnCard, profileId, vp, metadataOrEncrypt, encrypt) => {
                 await ensureUser();
 
-                if (!encrypt) {
+                const metadata =
+                    typeof metadataOrEncrypt === 'object' ? metadataOrEncrypt : undefined;
+                const shouldEncrypt =
+                    typeof metadataOrEncrypt === 'boolean' ? metadataOrEncrypt : (encrypt ?? true);
+
+                if (!shouldEncrypt) {
                     return client.presentation.sendPresentation.mutate({
                         profileId,
                         presentation: vp,
+                        metadata,
                     });
                 }
 
@@ -1311,7 +1387,11 @@ export async function getLearnCardNetworkPlugin(
                     target.did,
                 ]);
 
-                return client.presentation.sendPresentation.mutate({ profileId, presentation });
+                return client.presentation.sendPresentation.mutate({
+                    profileId,
+                    presentation,
+                    metadata,
+                });
             },
             acceptPresentation: async (_learnCard, uri) => {
                 await ensureUser();
@@ -2286,6 +2366,14 @@ export async function getLearnCardNetworkPlugin(
                 });
             },
 
+            addContractRecipient: async (_learnCard, contractUri, recipient) => {
+                await ensureUser();
+                return client.contracts.addContractRecipient.mutate({ contractUri, recipient });
+            },
+            removeContractRecipient: async (_learnCard, contractUri, recipient) => {
+                await ensureUser();
+                return client.contracts.removeContractRecipient.mutate({ contractUri, recipient });
+            },
             getContract: async (_learnCard, uri) => {
                 return client.contracts.getConsentFlowContract.query({ uri });
             },
@@ -2340,7 +2428,7 @@ export async function getLearnCardNetworkPlugin(
             consentToContract: async (
                 _learnCard,
                 contractUri,
-                { terms, expiresAt, oneTime },
+                { terms, expiresAt, oneTime, audienceVersion, expectedRequestId },
                 recipientToken
             ) => {
                 await ensureUser();
@@ -2350,6 +2438,8 @@ export async function getLearnCardNetworkPlugin(
                     terms,
                     expiresAt,
                     oneTime,
+                    audienceVersion,
+                    expectedRequestId,
                     recipientToken, // for SmartResume
                 });
             },
@@ -2360,7 +2450,11 @@ export async function getLearnCardNetworkPlugin(
                 return client.contracts.getConsentedContracts.query(options);
             },
 
-            updateContractTerms: async (_learnCard, uri, { terms, expiresAt, oneTime }) => {
+            updateContractTerms: async (
+                _learnCard,
+                uri,
+                { terms, expiresAt, oneTime, audienceVersion }
+            ) => {
                 await ensureUser();
 
                 return client.contracts.updateConsentedContractTerms.mutate({
@@ -2368,6 +2462,7 @@ export async function getLearnCardNetworkPlugin(
                     terms,
                     expiresAt,
                     oneTime,
+                    audienceVersion,
                 });
             },
 
@@ -2407,12 +2502,18 @@ export async function getLearnCardNetworkPlugin(
                 return client.contracts.verifyConsent.query({ uri, profileId });
             },
 
-            syncCredentialsToContract: async (_learnCard, termsUri, categories) => {
+            syncCredentialsToContract: async (
+                _learnCard,
+                termsUri,
+                categories,
+                audienceVersion
+            ) => {
                 await ensureUser();
 
                 return client.contracts.syncCredentialsToContract.mutate({
                     termsUri,
                     categories,
+                    audienceVersion,
                 });
             },
 
@@ -2424,6 +2525,14 @@ export async function getLearnCardNetworkPlugin(
                 });
             },
 
+            sendContractRequest: async (_learnCard, request) => {
+                await ensureUser();
+                return client.contracts.sendContractRequest.mutate(request);
+            },
+            denyContractRequest: async (_learnCard, contractUri) => {
+                await ensureUser();
+                return client.contracts.denyContractRequest.mutate({ contractUri });
+            },
             sendAiInsightsContractRequest: async (
                 _learnCard,
                 contractUri,
@@ -2683,10 +2792,34 @@ export async function getLearnCardNetworkPlugin(
 
                 return client.inbox.getInboxCredential.query({ credentialId: id });
             },
-            finalizeInboxCredentials: async _learnCard => {
+            finalizeInboxCredentials: async learnCard => {
                 await ensureUser();
-
-                return client.inbox.finalize.mutate();
+                const result = await client.inbox.finalize.mutate();
+                const results = await Promise.allSettled(
+                    result.deliveries.map(async delivery => ({
+                        ...delivery,
+                        credential: VCValidator.parse(
+                            isEncrypted(delivery.credential)
+                                ? await learnCard.invoke.decryptDagJwe(delivery.credential, [
+                                      learnCard.id.keypair(),
+                                  ])
+                                : delivery.credential
+                        ),
+                    }))
+                );
+                const deliveries = results.flatMap((delivery, index) => {
+                    if (delivery.status === 'fulfilled') return [delivery.value];
+                    console.warn(
+                        `Failed to finalize inbox delivery ${result.deliveries[index].id}: ${getInboxFailureReason(delivery.reason)}`
+                    );
+                    return [];
+                });
+                return {
+                    ...result,
+                    deliveries,
+                    verifiableCredentials: deliveries.map(delivery => delivery.credential),
+                    errors: result.errors + results.length - deliveries.length,
+                };
             },
             recoverInboxCredentials: async (learnCard, options = {}) => {
                 const result = await client.inbox.getMyInboxDeliveries.query(options);
@@ -2700,9 +2833,13 @@ export async function getLearnCardNetworkPlugin(
                         ),
                     }))
                 );
-                const records = results.flatMap(record =>
-                    record.status === 'fulfilled' ? [record.value] : []
-                );
+                const records = results.flatMap((record, index) => {
+                    if (record.status === 'fulfilled') return [record.value];
+                    console.warn(
+                        `Failed to recover inbox delivery ${result.records[index].id}: ${getInboxFailureReason(record.reason)}`
+                    );
+                    return [];
+                });
                 return { ...result, records, failed: results.length - records.length };
             },
             sendGuardianApprovalEmail: async (_learnCard, options) => {
@@ -3017,6 +3154,24 @@ export async function getLearnCardNetworkPlugin(
                 return client.appStore.unsubmitForReview.mutate({ listingId });
             },
 
+            submitAppStoreListingUpdate: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.submitListingUpdate.mutate({ listingId });
+            },
+
+            withdrawAppStoreListingUpdate: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.withdrawListingUpdate.mutate({ listingId });
+            },
+
+            discardAppStoreListingUpdate: async (_learnCard, listingId) => {
+                await ensureUser();
+
+                return client.appStore.discardListingUpdate.mutate({ listingId });
+            },
+
             getListingsForIntegration: async (_learnCard, integrationId, options = {}) => {
                 await ensureUser();
 
@@ -3032,6 +3187,39 @@ export async function getLearnCardNetworkPlugin(
                 return client.appStore.countListingsForIntegration.query({ integrationId });
             },
 
+            submitAppManifest: async (_learnCard, integrationId, manifest) => {
+                await ensureUser();
+                return client.appStore.submitAppManifest.mutate({ integrationId, manifest });
+            },
+
+            getManifestVersions: async (_learnCard, integrationId, options) => {
+                await ensureUser();
+                return client.appStore.getManifestVersions.query({ integrationId, ...options });
+            },
+
+            getManifestVersion: async (_learnCard, integrationId, version) => {
+                await ensureUser();
+                return client.appStore.getManifestVersion.query({ integrationId, version });
+            },
+
+            getManifestDiff: async (_learnCard, integrationId, toVersion, fromVersion) => {
+                await ensureUser();
+                return client.appStore.getManifestDiff.query({
+                    integrationId,
+                    toVersion,
+                    fromVersion,
+                });
+            },
+
+            applyManifestVersion: async (_learnCard, integrationId, version, listingId) => {
+                await ensureUser();
+                return client.appStore.applyManifestVersion.mutate({
+                    integrationId,
+                    version,
+                    listingId,
+                });
+            },
+
             browseAppStore: async (_learnCard, options) => {
                 return client.appStore.browseListedApps.query(options);
             },
@@ -3111,6 +3299,12 @@ export async function getLearnCardNetworkPlugin(
                 return client.appStore.adminGetAllListings.query(options);
             },
 
+            adminReviewListingUpdate: async (_learnCard, listingId, approve) => {
+                await ensureUser();
+
+                return client.appStore.adminReviewListingUpdate.mutate({ listingId, approve });
+            },
+
             // App Store Boost Management
             addBoostToApp: async (_learnCard, listingId, boostUri, templateAlias) => {
                 await ensureUser();

package/src/test/inbox-finalize-crypto.test.ts

@@ -0,0 +1,61 @@
+import { readFile } from 'node:fs/promises';
+import { generateLearnCard } from '@learncard/core';
+import { getDidKitPlugin } from '@learncard/didkit-plugin';
+import { getDidKeyPlugin } from '@learncard/didkey-plugin';
+import { getVCPlugin } from '@learncard/vc-plugin';
+import { getClient as getBrainClient } from '@learncard/network-brain-client';
+import { vi, expect, it } from 'vitest';
+import { getLearnCardNetworkPlugin } from '../';
+import { SAMPLE_VCS } from './mocks/sample-vcs';
+
+vi.mock('@learncard/network-brain-client', () => ({
+    getClient: vi.fn(),
+    getApiTokenClient: vi.fn(),
+}));
+
+it('preserves valid siblings through finalization and recovery despite wrong-key and credential-validation failures', async () => {
+    const didkit = readFile(
+        require.resolve('@learncard/didkit-plugin/dist/didkit/didkit_wasm_bg.wasm')
+    );
+    const makeCard = async (seed: string) => {
+        const card = await (await generateLearnCard()).addPlugin(await getDidKitPlugin(didkit));
+        const identity = await card.addPlugin(await getDidKeyPlugin(card, seed, 'key'));
+        return identity.addPlugin(await getVCPlugin(identity));
+    };
+    const holder = await makeCard('a'.repeat(64));
+    const otherHolder = await makeCard('b'.repeat(64));
+    const credential = SAMPLE_VCS.VALID_BOOST;
+    const wrongHolderJwe = await holder.invoke.createDagJwe(credential, [otherHolder.id.did()]);
+    const validJwe = await holder.invoke.createDagJwe(credential, [holder.id.did()]);
+    const invalidCredentialJwe = await holder.invoke.createDagJwe({}, [holder.id.did()]);
+    const deliveries = [
+        { id: 'wrong-holder', credential: wrongHolderJwe },
+        { id: 'invalid-credential', credential: invalidCredentialJwe },
+        { id: 'valid-sibling', credential: validJwe },
+    ];
+    const client = {
+        profile: { getProfile: { query: vi.fn().mockResolvedValue({ did: holder.id.did() }) } },
+        inbox: {
+            finalize: {
+                mutate: vi
+                    .fn()
+                    .mockResolvedValue({ processed: 3, claimed: 3, errors: 0, deliveries }),
+            },
+            getMyInboxDeliveries: {
+                query: vi.fn().mockResolvedValue({ records: deliveries, hasMore: false }),
+            },
+        },
+    };
+    vi.mocked(getBrainClient).mockResolvedValue(client as never);
+    const plugin = await getLearnCardNetworkPlugin(holder, 'https://network.example');
+    const network = await holder.addPlugin(plugin);
+
+    const result = await network.invoke.finalizeInboxCredentials();
+    expect(result.deliveries).toEqual([{ id: 'valid-sibling', credential }]);
+    expect(result.verifiableCredentials).toEqual([credential]);
+    expect(result.errors).toBe(2);
+
+    const recovery = await network.invoke.recoverInboxCredentials({});
+    expect(recovery.records).toEqual([{ id: 'valid-sibling', credential }]);
+    expect(recovery.failed).toBe(2);
+});

package/src/test/index.test.ts

@@ -757,36 +757,3 @@ describe.skip('LearnCard Network Plugin', () => {
         });
     });
 });
-
-it('recovers valid deliveries despite decryption and validation failures on the page', async () => {
-    const client = {
-        ...getMockClient(),
-        inbox: {
-            getMyInboxDeliveries: {
-                query: vi.fn().mockResolvedValue({
-                    records: [
-                        { id: 'bad-decrypt', credential: 'broken' },
-                        { id: 'bad-vc', credential: {} },
-                        { id: 'good', credential: { type: ['VerifiableCredential'] } },
-                    ],
-                    hasMore: true,
-                    cursor: 'good',
-                }),
-            },
-        },
-    };
-    vi.mocked(getBrainClient).mockResolvedValue(client as any);
-    const wallet = getMockLearnCard();
-    wallet.id.keypair = () => ({ publicKey: 'key' });
-    wallet.invoke.decryptDagJwe = vi.fn(async (credential: any) => {
-        if (credential === 'broken') throw new Error('Cannot decrypt');
-        return credential;
-    });
-    const plugin = await getLearnCardNetworkPlugin(wallet, 'https://network.example');
-    expect(await plugin.methods?.recoverInboxCredentials(wallet, {})).toEqual({
-        records: [{ id: 'good', credential: { type: ['VerifiableCredential'] } }],
-        failed: 2,
-        hasMore: true,
-        cursor: 'good',
-    });
-});