@learncard/network-plugin 2.5.23 → 2.6.1

package/dist/lcn-plugin.cjs.development.js

@@ -7400,6 +7400,23 @@ var getClient = /* @__PURE__ */ __name2(async (url, didAuthFunction) => {
   });
   return trpc;
 }, "getClient");
+var getApiTokenClient = /* @__PURE__ */ __name2(async (url, apiToken) => {
+  const trpc = createTRPCClient({
+    links: [
+      httpBatchLink({
+        methodOverride: "POST",
+        url,
+        maxURLLength: 3072,
+        headers: { Authorization: `Bearer ${apiToken}` },
+        transformer: {
+          input: import_helpers.RegExpTransformer,
+          output: { serialize: (o) => o, deserialize: (o) => o }
+        }
+      })
+    ]
+  });
+  return trpc;
+}, "getApiTokenClient");
 
 // ../../../node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
 var util;
@@ -17658,21 +17675,56 @@ var isVC2Format = /* @__PURE__ */ __name4((credential) => {
 }, "isVC2Format");
 
 // src/plugin.ts
-var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) => {
-  let did = learnCard.id.did();
+async function getLearnCardNetworkPlugin(learnCard, url, apiToken) {
+  let did = "";
+  try {
+    const idPlane = learnCard?.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 = await getClient(url, async (challenge) => {
+  const client = apiToken ? await getApiTokenClient(url, apiToken) : 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;
   });
   let userData;
+  learnCard?.debug?.("LCN: initial getProfile query starting", { apiToken: !!apiToken });
   const initialQuery = client.profile.getProfile.query().then((result) => {
     userData = result;
     if (userData?.did)
       did = userData.did;
+    learnCard?.debug?.("LCN: initial getProfile success", { did });
+    return result;
+  }).catch((error) => {
+    learnCard?.debug?.("LCN: getProfile failed (non-fatal)", error);
+    return void 0;
   });
+  const ensureUser = /* @__PURE__ */ __name(async () => {
+    try {
+      await initialQuery;
+    } catch {
+    }
+    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;
+  }, "ensureUser");
   return {
     name: "LearnCard Network",
     displayName: "LearnCard Network",
@@ -17681,9 +17733,9 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
       did: (_learnCard, method) => {
         if (!method || method === "web")
           return did;
-        return learnCard.id.did(method);
+        return learnCard.id?.did?.(method);
       },
-      keypair: (_learnCard, algorithm) => learnCard.id.keypair(algorithm)
+      keypair: (_learnCard, algorithm) => learnCard.id?.keypair?.(algorithm)
     },
     read: {
       get: async (_learnCard, vcUri) => {
@@ -17699,9 +17751,16 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         try {
           let result = await client.storage.resolve.query({ uri: vcUri });
           if ("ciphertext" in result) {
-            result = await _learnCard.invoke.decryptDagJwe(result, [
-              _learnCard.id.keypair()
-            ]);
+            try {
+              const kp = _learnCard.id.keypair();
+              result = await _learnCard.invoke.decryptDagJwe(result, [kp]);
+            } catch (e) {
+              _learnCard.debug?.(
+                "LCN read.get: skipping decryption (no keypair?)",
+                e
+              );
+              return void 0;
+            }
           }
           return await VCValidator.or(VPValidator).parseAsync(result);
         } catch (error) {
@@ -17717,15 +17776,24 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
       },
       uploadEncrypted: async (_learnCard, credential, { recipients = [] } = { recipients: [] }) => {
         _learnCard.debug?.("learnCard.store['LearnCard Network'].upload");
-        const jwe = await _learnCard.invoke.createDagJwe(credential, [
-          _learnCard.id.did(),
-          ...recipients
-        ]);
+        await ensureUser();
+        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(credential, recipientsList);
         return client.storage.store.mutate({ item: jwe });
       }
     },
     methods: {
       createProfile: async (_learnCard, profile) => {
+        try {
+          await ensureUser();
+        } catch {
+        }
         if (userData)
           throw new Error("Account already exists!");
         const newDid = await client.profile.createProfile.mutate(profile);
@@ -17734,8 +17802,10 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return newDid;
       },
       createServiceProfile: async (_learnCard, profile) => {
-        if (userData)
-          throw new Error("Account already exists!");
+        try {
+          await ensureUser();
+        } catch {
+        }
         const newDid = await client.profile.createServiceProfile.mutate(profile);
         userData = await client.profile.getProfile.query();
         did = newDid;
@@ -17746,14 +17816,12 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return newDid;
       },
       createProfileManager: async (_learnCard, profile) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const newDid = await client.profileManager.createProfileManager.mutate(profile);
         return newDid;
       },
       createChildProfileManager: async (_learnCard, parentUri, profile) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const newDid = await client.profileManager.createChildProfileManager.mutate({
           parentUri,
           profile
@@ -17761,27 +17829,23 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return newDid;
       },
       createManagedServiceProfile: async (_learnCard, profile) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const newDid = await client.profile.createManagedServiceProfile.mutate(profile);
         return newDid;
       },
       getAvailableProfiles: async (_learnCard, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.getAvailableProfiles.query(options);
       },
       getManagedProfiles: async (_learnCard, options = {}) => {
         return client.profileManager.getManagedProfiles.query(options);
       },
       getManagedServiceProfiles: async (_learnCard, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.getManagedServiceProfiles.query(options);
       },
       updateProfile: async (_learnCard, profile) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.profile.updateProfile.mutate(profile);
         if (result) {
           userData = await client.profile.getProfile.query();
@@ -17803,9 +17867,12 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return false;
       },
       getProfile: async (_learnCard, profileId) => {
-        await initialQuery;
+        try {
+          await ensureUser();
+        } catch {
+        }
         if (!profileId)
-          return client.profile.getProfile.query();
+          return userData;
         return client.profile.getOtherProfile.query({ profileId });
       },
       getProfileManagerProfile: async (_learnCard, id) => {
@@ -17828,102 +17895,84 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       connectWith: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.connectWith.mutate({ profileId });
       },
       cancelConnectionRequest: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.cancelConnectionRequest.mutate({ profileId });
       },
       connectWithInvite: async (_learnCard, profileId, challenge) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.connectWithInvite.mutate({ profileId, challenge });
       },
       disconnectWith: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.disconnectWith.mutate({ profileId });
       },
       acceptConnectionRequest: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.acceptConnectionRequest.mutate({ profileId });
       },
       getConnections: async (_learnCard) => {
         console.warn(
           "The getConnections method is deprecated! Please use getPaginatedConnections instead!"
         );
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.connections.query();
       },
       getPaginatedConnections: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.paginatedConnections.query(options);
       },
       getPendingConnections: async (_learnCard) => {
         console.warn(
           "The getPendingConnections method is deprecated! Please use getPaginatedPendingConnections instead!"
         );
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.pendingConnections.query();
       },
       getPaginatedPendingConnections: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.paginatedPendingConnections.query(options);
       },
       getConnectionRequests: async (_learnCard) => {
         console.warn(
           "The getConnectionRequests method is deprecated! Please use getPaginatedConnectionRequests instead!"
         );
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.connectionRequests.query();
       },
       getPaginatedConnectionRequests: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.paginatedConnectionRequests.query(options);
       },
       generateInvite: async (_learnCard, challenge, expiration, maxUses) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.generateInvite.mutate({ challenge, expiration, maxUses });
       },
       listInvites: async () => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.listInvites.query();
       },
       invalidateInvite: async (_learnCard, challenge) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.invalidateInvite.mutate({ challenge });
       },
       blockProfile: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.blockProfile.mutate({ profileId });
       },
       unblockProfile: async (_learnCard, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.unblockProfile.mutate({ profileId });
       },
       getBlockedProfiles: async () => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.blocked.query();
       },
       sendCredential: async (_learnCard, profileId, vc, encrypt = true) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         if (!encrypt) {
           return client.credential.sendCredential.mutate({ profileId, credential: vc });
         }
@@ -17931,39 +17980,33 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         if (!target)
           throw new Error("Could not find target account");
         const credential = await _learnCard.invoke.createDagJwe(vc, [
-          userData.did,
+          _learnCard.id.did(),
           target.did
         ]);
         return client.credential.sendCredential.mutate({ profileId, credential });
       },
       acceptCredential: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.credential.acceptCredential.mutate({ uri, options });
       },
       getReceivedCredentials: async (_learnCard, from) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.credential.receivedCredentials.query({ from });
       },
       getSentCredentials: async (_learnCard, to) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.credential.sentCredentials.query({ to });
       },
       getIncomingCredentials: async (_learnCard, from) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.credential.incomingCredentials.query({ from });
       },
       deleteCredential: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.credential.deleteCredential.mutate({ uri });
       },
       sendPresentation: async (_learnCard, profileId, vp, encrypt = true) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         if (!encrypt) {
           return client.presentation.sendPresentation.mutate({
             profileId,
@@ -17974,128 +18017,106 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         if (!target)
           throw new Error("Could not find target account");
         const presentation = await _learnCard.invoke.createDagJwe(vp, [
-          userData.did,
+          _learnCard.id.did(),
           target.did
         ]);
         return client.presentation.sendPresentation.mutate({ profileId, presentation });
       },
       acceptPresentation: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.presentation.acceptPresentation.mutate({ uri });
       },
       getReceivedPresentations: async (_learnCard, from) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.presentation.receivedPresentations.query({ from });
       },
       getSentPresentations: async (_learnCard, to) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.presentation.sentPresentations.query({ to });
       },
       getIncomingPresentations: async (_learnCard, from) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.presentation.incomingPresentations.query({ from });
       },
       deletePresentation: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.presentation.deletePresentation.mutate({ uri });
       },
       createBoost: async (_learnCard, credential, metadata) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.createBoost.mutate({ credential, ...metadata });
       },
       createChildBoost: async (_learnCard, parentUri, credential, metadata) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.createChildBoost.mutate({
           parentUri,
           boost: { credential, ...metadata }
         });
       },
       getBoost: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoost.query({ uri });
       },
       getBoosts: async (_learnCard, query) => {
         console.warn(
           "The getBoosts method is deprecated! Please use getPaginatedBoosts instead!"
         );
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoosts.query({ query });
       },
       countBoosts: async (_learnCard, query) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.countBoosts.query({ query });
       },
       getPaginatedBoosts: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getPaginatedBoosts.query(options);
       },
       getBoostChildren: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostChildren.query({ uri, ...options });
       },
       countBoostChildren: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.countBoostChildren.query({ uri, ...options });
       },
       getBoostSiblings: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostSiblings.query({ uri, ...options });
       },
       countBoostSiblings: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.countBoostSiblings.query({ uri, ...options });
       },
       getFamilialBoosts: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getFamilialBoosts.query({ uri, ...options });
       },
       countFamilialBoosts: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.countFamilialBoosts.query({ uri, ...options });
       },
       getBoostParents: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostParents.query({ uri, ...options });
       },
       countBoostParents: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.countBoostParents.query({ uri, ...options });
       },
       makeBoostParent: async (_learnCard, uris) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.makeBoostParent.mutate(uris);
       },
       removeBoostParent: async (_learnCard, uris) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.removeBoostParent.mutate(uris);
       },
       getBoostRecipients: async (_learnCard, uri, limit = 25, skip = void 0, includeUnacceptedBoosts = true) => {
         console.warn(
           "The getBoostRecipients method is deprecated! Please use getPaginatedBoostRecipients instead!"
         );
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostRecipients.query({
           uri,
           limit,
@@ -18104,8 +18125,7 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       getPaginatedBoostRecipients: async (_learnCard, uri, limit = 25, cursor = void 0, includeUnacceptedBoosts = true, query) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getPaginatedBoostRecipients.query({
           uri,
           limit,
@@ -18115,8 +18135,7 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       getPaginatedBoostRecipientsWithChildren: async (_learnCard, uri, limit = 25, cursor = void 0, includeUnacceptedBoosts = true, boostQuery, profileQuery, numberOfGenerations = 1) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getPaginatedBoostRecipientsWithChildren.query({
           uri,
           limit,
@@ -18139,13 +18158,11 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       countBoostRecipients: async (_learnCard, uri, includeUnacceptedBoosts = true) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostRecipientCount.query({ uri, includeUnacceptedBoosts });
       },
       getConnectedBoostRecipients: async (_learnCard, uri, { limit = 25, cursor = void 0, includeUnacceptedBoosts = true, query } = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getConnectedBoostRecipients.query({
           uri,
           limit,
@@ -18155,41 +18172,35 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       countConnectedBoostRecipients: async (_learnCard, uri, includeUnacceptedBoosts = true) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getConnectedBoostRecipientCount.query({
           uri,
           includeUnacceptedBoosts
         });
       },
       getBoostChildrenProfileManagers: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getChildrenProfileManagers.query({ uri, ...options });
       },
       updateBoost: async (_learnCard, uri, updates, credential) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.updateBoost.mutate({
           uri,
           updates: { ...credential && { credential }, ...updates }
         });
       },
       getBoostAdmins: async (_learnCard, uri, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.getBoostAdmins.query({ uri, ...options });
       },
       getBoostPermissions: async (_learnCard, uri, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         if (!profileId)
           return client.boost.getBoostPermissions.query({ uri });
         return client.boost.getOtherBoostPermissions.query({ uri, profileId });
       },
       updateBoostPermissions: async (_learnCard, uri, updates, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         if (!profileId)
           return client.boost.updateBoostPermissions.query({ uri, updates });
         const result = await client.boost.updateOtherBoostPermissions.query({
@@ -18202,29 +18213,25 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return result;
       },
       addBoostAdmin: async (_learnCard, uri, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.boost.addBoostAdmin.mutate({ uri, profileId });
         if (result)
           await _learnCard.invoke.clearDidWebCache?.();
         return result;
       },
       removeBoostAdmin: async (_learnCard, uri, profileId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.boost.removeBoostAdmin.mutate({ uri, profileId });
         if (result)
           await _learnCard.invoke.clearDidWebCache?.();
         return result;
       },
       deleteBoost: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.deleteBoost.mutate({ uri });
       },
       sendBoost: async (_learnCard, profileId, boostUri, options = { encrypt: true, skipNotification: false }) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await _learnCard.invoke.resolveFromLCN(boostUri);
         const data = await UnsignedVCValidator.spa(result);
         if (!data.success)
@@ -18265,7 +18272,7 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         }
         const lcnDid = await client.utilities.getDid.query();
         const credential = await _learnCard.invoke.createDagJwe(vc, [
-          userData.did,
+          _learnCard.id.did(),
           targetProfile.did,
           lcnDid
         ]);
@@ -18279,37 +18286,31 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       registerSigningAuthority: async (_learnCard, endpoint, name, _did) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.registerSigningAuthority.mutate({
           endpoint,
           name,
           did: _did
         });
       },
-      getRegisteredSigningAuthorities: async (_learnCard, _endpoint, _name, _did) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+      getRegisteredSigningAuthorities: async (_learnCard) => {
+        await ensureUser();
         return client.profile.signingAuthorities.query();
       },
       getRegisteredSigningAuthority: async (_learnCard, endpoint, name) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.signingAuthority.query({ endpoint, name });
       },
       setPrimaryRegisteredSigningAuthority: async (_learnCard, endpoint, name) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.setPrimarySigningAuthority.mutate({ endpoint, name });
       },
       getPrimaryRegisteredSigningAuthority: async (_learnCard) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.profile.primarySigningAuthority.query();
       },
       generateClaimLink: async (_learnCard, boostUri, claimLinkSA, options, challenge) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.generateClaimLink.mutate({
           boostUri,
           claimLinkSA,
@@ -18318,23 +18319,19 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       claimBoostWithLink: async (_learnCard, boostUri, challenge) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.boost.claimBoostWithLink.mutate({ boostUri, challenge });
       },
       createContract: async (_learnCard, contract) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.createConsentFlowContract.mutate(contract);
       },
       addAutoBoostsToContract: async (_learnCard, contractUri, autoboosts) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.addAutoBoostsToContract.mutate({ contractUri, autoboosts });
       },
       removeAutoBoostsFromContract: async (_learnCard, contractUri, boostUris) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.removeAutoBoostsFromContract.mutate({
           contractUri,
           boostUris
@@ -18344,33 +18341,27 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         return client.contracts.getConsentFlowContract.query({ uri });
       },
       getContracts: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getConsentFlowContracts.query(options);
       },
       deleteContract: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.deleteConsentFlowContract.mutate({ uri });
       },
       getConsentFlowData: async (_learnCard, uri, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getConsentedDataForContract.query({ uri, ...options });
       },
       getConsentFlowDataForDid: async (_learnCard, did2, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getConsentedDataForDid.query({ did: did2, ...options });
       },
       getAllConsentFlowData: async (_learnCard, query = {}, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getConsentedData.query({ query, ...options });
       },
       writeCredentialToContract: async (_learnCard, did2, contractUri, credential, boostUri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.writeCredentialToContract.mutate({
           did: did2,
           contractUri,
@@ -18379,8 +18370,7 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       consentToContract: async (_learnCard, contractUri, { terms, expiresAt, oneTime }, recipientToken) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.consentToContract.mutate({
           contractUri,
           terms,
@@ -18390,13 +18380,11 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       getConsentedContracts: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getConsentedContracts.query(options);
       },
       updateContractTerms: async (_learnCard, uri, { terms, expiresAt, oneTime }) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.updateConsentedContractTerms.mutate({
           uri,
           terms,
@@ -18405,118 +18393,99 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
         });
       },
       withdrawConsent: async (_learnCard, uri) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.withdrawConsent.mutate({ uri });
       },
       getConsentFlowTransactions: async (_learnCard, uri, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getTermsTransactionHistory.query({ uri, ...options });
       },
       getCredentialsForContract: async (_learnCard, termsUri, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.getCredentialsForContract.query({ termsUri, ...options });
       },
       getConsentFlowCredentials: async (_learnCard, options = {}) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        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) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contracts.syncCredentialsToContract.mutate({
           termsUri,
           categories
         });
       },
       addDidMetadata: async (_learnCard, metadata) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.didMetadata.addDidMetadata.mutate(metadata);
         if (result)
           await _learnCard.invoke.clearDidWebCache?.();
         return result;
       },
       getDidMetadata: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.didMetadata.getDidMetadata.query({ id });
       },
       getMyDidMetadata: async () => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.didMetadata.getMyDidMetadata.query();
       },
       updateDidMetadata: async (_learnCard, id, updates) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.didMetadata.updateDidMetadata.mutate({ id, updates });
         if (result)
           await _learnCard.invoke.clearDidWebCache?.();
         return result;
       },
       deleteDidMetadata: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const result = await client.didMetadata.deleteDidMetadata.mutate({ id });
         if (result)
           await _learnCard.invoke.clearDidWebCache?.();
         return result;
       },
       createClaimHook: async (_learnCard, hook) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.claimHook.createClaimHook.mutate({ hook });
       },
       getClaimHooksForBoost: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.claimHook.getClaimHooksForBoost.query(options);
       },
       deleteClaimHook: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.claimHook.deleteClaimHook.mutate({ id });
       },
       addAuthGrant: async (_learnCard, authGrant) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.addAuthGrant.mutate(authGrant);
       },
       revokeAuthGrant: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.revokeAuthGrant.mutate({ id });
       },
       deleteAuthGrant: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.deleteAuthGrant.mutate({ id });
       },
       updateAuthGrant: async (_learnCard, id, updates) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.updateAuthGrant.mutate({ id, updates });
       },
       getAuthGrant: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.getAuthGrant.query({ id });
       },
       getAuthGrants: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.authGrants.getAuthGrants.query(options);
       },
       getAPITokenForAuthGrant: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         const authGrant = await client.authGrants.getAuthGrant.query({ id });
         if (!authGrant)
           throw new Error("Auth grant not found");
@@ -18528,52 +18497,44 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
           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({
+        const apiToken2 = await _learnCard.invoke.getDidAuthVp({
           challenge: authGrant.challenge,
           proofFormat: "jwt"
         });
-        if (!apiToken)
+        if (!apiToken2)
           throw new Error("Failed to get API Token for auth grant");
-        return apiToken;
+        return apiToken2;
       },
       sendCredentialViaInbox: async (_learnCard, issueInboxCredential) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.inbox.issue.mutate(issueInboxCredential);
       },
       getMySentInboxCredentials: async (_learnCard, options) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.inbox.getMyIssuedCredentials.query(options);
       },
       getInboxCredential: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.inbox.getInboxCredential.query({ credentialId: id });
       },
       addContactMethod: async (_learnCard, contactMethod) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contactMethods.addContactMethod.mutate(contactMethod);
       },
       getMyContactMethods: async (_learnCard) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contactMethods.getMyContactMethods.query();
       },
       setPrimaryContactMethod: async (_learnCard, contactMethodId) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contactMethods.setPrimaryContactMethod.mutate({ contactMethodId });
       },
       verifyContactMethod: async (_learnCard, token) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contactMethods.verifyContactMethod.mutate({ token });
       },
       removeContactMethod: async (_learnCard, id) => {
-        if (!userData)
-          throw new Error("Please make an account first!");
+        await ensureUser();
         return client.contactMethods.removeContactMethod.mutate({ id });
       },
       resolveFromLCN: async (_learnCard, uri) => {
@@ -18583,7 +18544,8 @@ var getLearnCardNetworkPlugin = /* @__PURE__ */ __name(async (learnCard, url) =>
       getLCNClient: () => client
     }
   };
-}, "getLearnCardNetworkPlugin");
+}
+__name(getLearnCardNetworkPlugin, "getLearnCardNetworkPlugin");
 var getVerifyBoostPlugin = /* @__PURE__ */ __name(async (learnCard, trustedBoostRegistryUrl) => {
   const DEFAULT_TRUSTED_BOOST_REGISTRY = [
     {