@learncard/core 6.4.0 → 7.0.0

package/dist/core.d.ts

@@ -4645,16 +4645,10 @@ declare const VerificationItemValidator: z.ZodObject<{
 	check: string;
 }>;
 export declare type VerificationItem = z.infer<typeof VerificationItemValidator>;
-declare const StorageTypeValidator: z.ZodEnum<[
-	"ceramic"
-]>;
-/** @group IDXPlugin */
-export declare type StorageType = z.infer<typeof StorageTypeValidator>;
 /** @group IDXPlugin */
 export declare type IDXCredential<Metadata extends Record<string, any> = Record<never, never>> = {
 	id: string;
-	title: string;
-	storageType?: StorageType;
+	uri: string;
 	[key: string]: any;
 } & Metadata;
 declare const JWKValidator: z.ZodObject<{
@@ -4750,29 +4744,16 @@ export declare type Token = {
 };
 /** @group Ethereum Plugin */
 export declare type TokenList = Token[];
-/** @group IDXPlugin */
-export declare type CeramicIDXArgs = {
-	modelData: ModelAliases;
-	credentialAlias: string;
-	ceramicEndpoint: string;
-	defaultContentFamily: string;
+/** @group VC Resolution Plugin */
+export declare type LC_URI<URI extends string = ""> = string | URI;
+/** @group VC Resolution Plugin */
+export declare type VCResolutionPluginMethods = {
+	resolveCredential: (uri?: LC_URI) => Promise<VC | undefined>;
 };
-/** @group IDXPlugin */
-export declare type IDXPluginMethods = {
-	getCredentialsListFromIdx: <Metadata extends Record<string, any> = Record<never, never>>(alias?: string) => Promise<CredentialsList<Metadata>>;
-	publishContentToCeramic: (cred: any) => Promise<string>;
-	readContentFromCeramic: (streamId: string) => Promise<any>;
-	getVerifiableCredentialFromIdx: (title: string) => Promise<VC>;
-	getVerifiableCredentialsFromIdx: () => Promise<VC[]>;
-	addVerifiableCredentialInIdx: <Metadata extends Record<string, any> = Record<never, never>>(cred: IDXCredential<Metadata>) => Promise<StreamID>;
-	removeVerifiableCredentialInIdx: (title: string) => Promise<StreamID>;
+/** @group VC Resolution Plugin */
+export declare type ResolutionExtension<URI extends string> = {
+	resolveCredential: (uri?: LC_URI<URI>) => Promise<VC | undefined>;
 };
-/** @group IDXPlugin */
-export declare type CredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
-	credentials: Array<IDXCredential<Metadata>>;
-};
-/** @group IDXPlugin */
-export declare const CredentialsListValidator: z.ZodType<CredentialsList>;
 export declare type Last<T extends any[]> = T extends [
 	...any[],
 	infer R
@@ -4806,6 +4787,52 @@ export declare type Wallet<PluginNames extends string = "", PluginMethods extend
 		Methods
 	]>>>;
 };
+/** @group IDXPlugin */
+export declare type CeramicIDXArgs = {
+	modelData: ModelAliases;
+	credentialAlias: string;
+	ceramicEndpoint: string;
+	defaultContentFamily: string;
+};
+/** @group IDXPlugin */
+export declare type CeramicURI = `lc:ceramic:${string}`;
+/** @group IDXPlugin */
+export declare const CeramicURIValidator: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/** @group IDXPlugin */
+export declare type IDXPluginMethods<URI extends string = ""> = {
+	getCredentialsListFromIdx: <Metadata extends Record<string, any> = Record<never, never>>(alias?: string) => Promise<CredentialsList<Metadata>>;
+	publishContentToCeramic: (cred: any) => Promise<CeramicURI>;
+	readContentFromCeramic: (streamId: string) => Promise<any>;
+	getVerifiableCredentialFromIdx: (id: string) => Promise<VC | undefined>;
+	getVerifiableCredentialsFromIdx: () => Promise<VC[]>;
+	addVerifiableCredentialInIdx: <Metadata extends Record<string, any> = Record<never, never>>(cred: IDXCredential<Metadata>) => Promise<CeramicURI>;
+	removeVerifiableCredentialInIdx: (title: string) => Promise<StreamID>;
+} & ResolutionExtension<URI | CeramicURI>;
+/** @group IDXPlugin */
+export declare type IDXPluginDependentMethods<URI extends string = ""> = {
+	getKey: () => string;
+} & ResolutionExtension<URI>;
+/** @group IDXPlugin */
+export declare type CredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
+	credentials: Array<IDXCredential<Metadata>>;
+};
+/** @group IDXPlugin */
+export declare const CredentialsListValidator: z.ZodType<CredentialsList>;
+/** @group IDXPlugin */
+export declare type BackwardsCompatIDXCredential<Metadata extends Record<string, any> = Record<never, never>> = {
+	[key: string]: any;
+	id: string;
+	title: string;
+	storageType?: "ceramic";
+} & Metadata;
+/** @group IDXPlugin */
+export declare const BackwardsCompatIDXCredentialValidator: z.ZodType<BackwardsCompatIDXCredential>;
+/** @group IDXPlugin */
+export declare type BackwardsCompatCredentialsList<Metadata extends Record<string, any> = Record<never, never>> = {
+	credentials: Array<IDXCredential<Metadata> | BackwardsCompatIDXCredential<Metadata>>;
+};
+/** @group IDXPlugin */
+export declare const BackwardsCompatCredentialsListValidator: z.ZodType<BackwardsCompatCredentialsList>;
 /** @group VC Plugin */
 export declare type VCPluginDependentMethods = {
 	getSubjectDid: (type: "key") => string;
@@ -4982,6 +5009,39 @@ export declare type VCAPIPluginMethods = {
 	getTestVc: (subject?: string) => UnsignedVC;
 	getTestVp: (credential?: VC) => Promise<UnsignedVP>;
 };
+/**
+ *
+ * @group Plugins
+ */
+export declare const getDidKitPlugin: (input?: InitInput | Promise<InitInput>) => Promise<Plugin<"DIDKit", DidkitPluginMethods>>;
+/**
+ *
+ * @group Plugins
+ */
+export declare const getDidKeyPlugin: <DidMethod extends string>(wallet: Wallet<string, DependentMethods<DidMethod>>, key: string) => Promise<Plugin<"DID Key", DidKeyPluginMethods<DidMethod>, Record<never, never>>>;
+/**
+ * @group Plugins
+ */
+export declare const getVCPlugin: (wallet: Wallet<string, VCPluginDependentMethods>) => Plugin<"VC", VCPluginMethods, VCPluginDependentMethods>;
+/**
+ * @group Plugins
+ */
+export declare const getIDXPlugin: <URI extends string = "">(wallet: Wallet<any, IDXPluginDependentMethods<URI>>, { modelData, credentialAlias, ceramicEndpoint, defaultContentFamily }: CeramicIDXArgs) => Promise<Plugin<"IDX", IDXPluginMethods<URI>, Record<never, never>>>;
+/**
+ * @group Plugins
+ */
+export declare const ExpirationPlugin: (wallet: Wallet<any, VerifyExtension>) => Plugin<"Expiration", VerifyExtension>;
+/**
+ * @group Plugins
+ */
+export declare const getEthereumPlugin: (initWallet: Wallet<string, {
+	getSubjectDid: (type: DidMethod) => string;
+	getSubjectKeypair: (type?: Algorithm) => JWK;
+}>, config: EthereumConfig) => Plugin<"Ethereum", EthereumPluginMethods>;
+/**
+ * @group Plugins
+ */
+export declare const getVpqrPlugin: (wallet: Wallet<string, VpqrPluginDependentMethods>) => Plugin<"Vpqr", VpqrPluginMethods>;
 /**
  * Wallet holder's did
  *
@@ -5047,7 +5107,7 @@ export declare type VerifyPresentation = (presentation: VP, options?: Partial<Pr
  *
  * @group LearnCard Methods
  */
-export declare type GetCredential = (title: string) => Promise<VC>;
+export declare type GetCredential = (title: string) => Promise<VC | undefined>;
 /**
  * Returns all credentials from IDX
  *
@@ -5061,35 +5121,31 @@ export declare type GetCredentials = () => Promise<VC[]>;
  */
 export declare type GetCredentialsList = <Metadata extends Record<string, any> = Record<never, never>>() => Promise<IDXCredential<Metadata>[]>;
 /**
- * Publishes a credential to Ceramic, returning the credential's stream ID
+ * Publishes a credential to Ceramic, returning the credential's Ceramic URI
  *
- * This stream ID may then be shared/persisted/resolved to gain access to the credential
+ * This URI may then be shared/persisted/resolved to gain access to the credential
  *
- * Resolving a stream ID can be done by passing the stream ID to `readFromCeramic`
+ * Resolving a URI can be done by passing the URI to `resolveCredential`
  *
  * @group LearnCard Methods
  */
-export declare type PublishCredential = (credential: VC) => Promise<string>;
+export declare type PublishCredential = (credential: VC) => Promise<CeramicURI>;
 /**
- * Adds a stream ID  pointing to a credential (such as the one returned by `publishCredential`)
- * to IDX with a bespoke title
+ * Adds a URI pointing to a credential (such as the one returned by `publishCredential`)
+ * to IDX with a bespoke ID
  *
- * The credential may then be retrieved using `getCredential` and passing in that bespoke title,
- * or by using `getCredentials` to get a list of all credentials that have been added to IDX
+ * The credential may then be retrieved using `getCredential` and passing in that bespoke ID,
+ * or by using `getCredentials`/`getCredentialsList` to get a list of all credentials that have been added to IDX
  *
  * @group LearnCard Methods
  */
 export declare type AddCredential = <Metadata extends Record<string, any> = Record<never, never>>(credential: IDXCredential<Metadata>) => Promise<void>;
 /**
- * Adds a stream ID  pointing to a credential (such as the one returned by `publishCredential`)
- * to IDX with a bespoke title
- *
- * The credential may then be retrieved using `getCredential` and passing in that bespoke title,
- * or by using `getCredentials` to get a list of all credentials that have been added to IDX
+ * Removes a credential from IDX by passing in its bespoke ID
  *
  * @group LearnCard Methods
  */
-export declare type RemoveCredential = (title: string) => Promise<void>;
+export declare type RemoveCredential = (id: string) => Promise<void>;
 /**
  * Resolves a did to its did document
  *
@@ -5099,12 +5155,18 @@ export declare type ResolveDid = (did: string, inputMetadata?: InputMetadata) =>
 /**
  * Resolves a stream ID, returning its contents
  *
+ * @group LearnCard Methods
+ */
+export declare type ReadFromCeramic = (streamId: string) => Promise<any>;
+/**
+ * Resolves a LearnCard URI (e.g. lc:ceramic:1234561)
+ *
  * This can be given the return value of `publishCredential` to gain access to the credential
  * that was published
  *
  * @group LearnCard Methods
  */
-export declare type ReadFromCeramic = (streamId: string) => Promise<any>;
+export declare type ResolveCredential = (URI?: string | "" | `lc:ceramic:${string}`) => Promise<VC | undefined>;
 /**
  * Returns an example credential, optionally allowing a subject's did to be passed in
  *
@@ -5238,6 +5300,7 @@ export declare type AllLearnCardMethods = {
 	removeCredential: RemoveCredential;
 	resolveDid: ResolveDid;
 	readFromCeramic: ReadFromCeramic;
+	resolveCredential: ResolveCredential;
 	getTestVc: GetTestVc;
 	getTestVp: GetTestVp;
 	getEthereumAddress: GetEthereumAddress;
@@ -5256,10 +5319,11 @@ export declare type AllLearnCardMethods = {
 	storeCredentialViaChapiDidAuth: StoreCredentialViaChapiDidAuth;
 };
 /** @group Universal Wallets */
-export declare type LearnCardRawWallet = Wallet<"DIDKit" | "DID Key" | "VC" | "VC Templates" | "IDX" | "Expiration" | "Ethereum" | "Vpqr" | "CHAPI", MergeObjects<[
+export declare type LearnCardRawWallet = Wallet<"DIDKit" | "DID Key" | "VC" | "VC Templates" | "VC Resolution" | "IDX" | "Expiration" | "Ethereum" | "Vpqr" | "CHAPI", MergeObjects<[
 	DidKeyPluginMethods<DidMethod>,
 	VCPluginMethods,
 	VCTemplatePluginMethods,
+	VCResolutionPluginMethods,
 	IDXPluginMethods,
 	EthereumPluginMethods,
 	VpqrPluginMethods,
@@ -5352,41 +5416,6 @@ export declare function initLearnCard(config: WalletFromKey["args"]): Promise<Wa
 export declare function initLearnCard(config: WalletFromVcApi["args"]): Promise<WalletFromVcApi["returnValue"]>;
 /** @group Universal Wallets */
 export declare const generateWallet: <PluginNames extends string, PluginMethods extends Record<string, (...args: any[]) => any> = Record<never, never>>(contents?: any[], _wallet?: Partial<Wallet<any, PluginMethods>>) => Promise<Wallet<PluginNames, PluginMethods>>;
-/**
- *
- * @group Plugins
- */
-export declare const getDidKitPlugin: (input?: InitInput | Promise<InitInput>) => Promise<Plugin<"DIDKit", DidkitPluginMethods>>;
-/**
- *
- * @group Plugins
- */
-export declare const getDidKeyPlugin: <DidMethod extends string>(wallet: Wallet<string, DependentMethods<DidMethod>>, key: string) => Promise<Plugin<"DID Key", DidKeyPluginMethods<DidMethod>, Record<never, never>>>;
-/**
- * @group Plugins
- */
-export declare const getVCPlugin: (wallet: Wallet<string, VCPluginDependentMethods>) => Plugin<"VC", VCPluginMethods, VCPluginDependentMethods>;
-/**
- * @group Plugins
- */
-export declare const getIDXPlugin: (wallet: Wallet<any, {
-	getKey: () => string;
-}>, { modelData, credentialAlias, ceramicEndpoint, defaultContentFamily }: CeramicIDXArgs) => Promise<Plugin<"IDX", IDXPluginMethods>>;
-/**
- * @group Plugins
- */
-export declare const ExpirationPlugin: (wallet: Wallet<any, VerifyExtension>) => Plugin<"Expiration", VerifyExtension>;
-/**
- * @group Plugins
- */
-export declare const getEthereumPlugin: (initWallet: Wallet<string, {
-	getSubjectDid: (type: DidMethod) => string;
-	getSubjectKeypair: (type?: Algorithm) => JWK;
-}>, config: EthereumConfig) => Plugin<"Ethereum", EthereumPluginMethods>;
-/**
- * @group Plugins
- */
-export declare const getVpqrPlugin: (wallet: Wallet<string, VpqrPluginDependentMethods>) => Plugin<"Vpqr", VpqrPluginMethods>;
 export * from "@wallet/init";
 export { Wallet, Plugin } from "types/wallet";
 export * from "types/LearnCard";

package/dist/core.esm.js

@@ -42367,13 +42367,7 @@ var CredentialInfoValidator = mod.object({
   issuee: ProfileValidator.optional(),
   credentialSubject: CredentialSubjectValidator.optional()
 });
-var StorageTypeValidator = mod.enum(["ceramic"]);
-var StorageTypeEnum = StorageTypeValidator.enum;
-var IDXCredentialValidator = mod.object({
-  id: mod.string(),
-  title: mod.string(),
-  storageType: StorageTypeValidator.optional()
-}).catchall(mod.any());
+var IDXCredentialValidator = mod.object({ id: mod.string(), uri: mod.string() }).catchall(mod.any());
 var JWKValidator = mod.object({
   kty: mod.string(),
   crv: mod.string(),
@@ -56701,8 +56695,16 @@ var CeramicClient = class {
 };
 __name(CeramicClient, "CeramicClient");
 
+// src/wallet/plugins/idx/helpers.ts
+var streamIdToCeramicURI = /* @__PURE__ */ __name((id) => `lc:ceramic:${id}`, "streamIdToCeramicURI");
+
 // src/wallet/plugins/idx/types.ts
+var CeramicURIValidator = mod.string().refine((string2) => string2.split(":").length === 3 && string2.split(":")[0] === "lc", "URI must be of the form lc:${storage}:${url}").refine((string2) => string2.split(":")[1] === "ceramic", "URI must use storage type ceramic (i.e. must be lc:ceramic:${streamID})");
 var CredentialsListValidator = mod.object({ credentials: IDXCredentialValidator.array() }).strict();
+var BackwardsCompatIDXCredentialValidator = mod.object({ id: mod.string(), title: mod.string(), storageType: mod.literal("ceramic").optional() }).catchall(mod.any());
+var BackwardsCompatCredentialsListValidator = mod.object({
+  credentials: IDXCredentialValidator.or(BackwardsCompatIDXCredentialValidator).array()
+}).strict();
 
 // src/wallet/plugins/idx/idx.ts
 var getCeramicClientFromWalletSuite = /* @__PURE__ */ __name((wallet, ceramicEndpoint) => __async(void 0, null, function* () {
@@ -56727,38 +56729,32 @@ var getIDXPlugin = /* @__PURE__ */ __name((_0, _1) => __async(void 0, [_0, _1],
     const validationResult = yield CredentialsListValidator.spa(list);
     if (validationResult.success)
       return validationResult.data;
+    const backwardsCompatValidationResult = yield BackwardsCompatCredentialsListValidator.spa(list);
+    if (backwardsCompatValidationResult.success) {
+      const oldCreds = backwardsCompatValidationResult.data.credentials;
+      const newCreds = oldCreds.map((cred) => {
+        if ("uri" in cred)
+          return cred;
+        const _a = cred, { title, id, storageType } = _a, rest = __objRest(_a, ["title", "id", "storageType"]);
+        return __spreadProps(__spreadValues({}, rest), {
+          id: title,
+          uri: `lc:ceramic:${id.replace("ceramic://", "")}`
+        });
+      });
+      const credentialsList = { credentials: newCreds };
+      yield dataStore.set(credentialAlias, credentialsList);
+      return credentialsList;
+    }
     console.error(validationResult.error);
     throw new Error("Invalid credentials list stored in IDX");
   }), "getCredentialsListFromIdx");
-  const addCredentialStreamIdToIdx = /* @__PURE__ */ __name((_record, alias) => __async(void 0, null, function* () {
-    const record = IDXCredentialValidator.parse(_record);
-    if (!record)
-      throw new Error("record is required");
-    if (!record.id)
-      throw Error("No streamId provided");
-    if (record.id.indexOf("ceramic://") === -1)
-      record.id = "ceramic://" + record.id;
-    if (!alias)
-      alias = credentialAlias;
-    const existing = yield getCredentialsListFromIdx(alias);
-    const indexOfExistingCredential = existing.credentials.findIndex((credential) => {
-      return credential.title === record.title;
-    });
-    if (indexOfExistingCredential > -1) {
-      existing.credentials[indexOfExistingCredential] = __spreadValues({
-        storageType: StorageTypeEnum.ceramic
-      }, record);
-    } else
-      existing.credentials.push(__spreadValues({ storageType: StorageTypeEnum.ceramic }, record));
-    return dataStore.set(alias, existing);
-  }), "addCredentialStreamIdToIdx");
-  const removeCredentialFromIdx = /* @__PURE__ */ __name((title, alias) => __async(void 0, null, function* () {
-    if (!title)
-      throw new Error("record is required");
+  const removeCredentialFromIdx = /* @__PURE__ */ __name((id, alias) => __async(void 0, null, function* () {
+    if (!id)
+      throw new Error("Must provide id to remove");
     if (!alias)
       alias = credentialAlias;
     const existing = yield getCredentialsListFromIdx(alias);
-    existing.credentials = existing.credentials.filter((credential) => credential.title !== title);
+    existing.credentials = existing.credentials.filter((credential) => credential.id !== id);
     return dataStore.set(alias, existing);
   }), "removeCredentialFromIdx");
   const publishContentToCeramic = /* @__PURE__ */ __name((_02, ..._12) => __async(void 0, [_02, ..._12], function* (content, metadata = {}, options = {}) {
@@ -56783,30 +56779,56 @@ var getIDXPlugin = /* @__PURE__ */ __name((_0, _1) => __async(void 0, [_0, _1],
         return getCredentialsListFromIdx(alias);
       }),
       publishContentToCeramic: (_wallet, cred) => __async(void 0, null, function* () {
-        return publishContentToCeramic(cred);
+        return streamIdToCeramicURI(yield publishContentToCeramic(cred));
       }),
       readContentFromCeramic: (_wallet, streamId) => __async(void 0, null, function* () {
         return readContentFromCeramic(streamId);
       }),
-      getVerifiableCredentialFromIdx: (_wallet, title) => __async(void 0, null, function* () {
+      getVerifiableCredentialFromIdx: (_wallet, id) => __async(void 0, null, function* () {
         var _a;
         const credentialList = yield getCredentialsListFromIdx();
-        const credential = (_a = credentialList == null ? void 0 : credentialList.credentials) == null ? void 0 : _a.find((cred) => (cred == null ? void 0 : cred.title) === title);
-        return credential && (yield readContentFromCeramic(credential.id));
+        const credential = (_a = credentialList == null ? void 0 : credentialList.credentials) == null ? void 0 : _a.find((cred) => (cred == null ? void 0 : cred.id) === id);
+        return (credential == null ? void 0 : credential.uri) ? _wallet.pluginMethods.resolveCredential(credential.uri) : void 0;
       }),
-      getVerifiableCredentialsFromIdx: () => __async(void 0, null, function* () {
+      getVerifiableCredentialsFromIdx: (_wallet) => __async(void 0, null, function* () {
         var _a, _b;
         const credentialList = yield getCredentialsListFromIdx();
-        const streamIds = (_b = (_a = credentialList == null ? void 0 : credentialList.credentials) == null ? void 0 : _a.map((credential) => credential == null ? void 0 : credential.id)) != null ? _b : [];
-        return Promise.all(streamIds.map((streamId) => __async(void 0, null, function* () {
-          return readContentFromCeramic(streamId);
-        })));
+        const uris = (_b = (_a = credentialList == null ? void 0 : credentialList.credentials) == null ? void 0 : _a.map((credential) => credential == null ? void 0 : credential.uri)) != null ? _b : [];
+        return (yield Promise.all(uris.map((uri) => __async(void 0, null, function* () {
+          return _wallet.pluginMethods.resolveCredential(uri);
+        })))).filter((vc) => !!vc);
       }),
       addVerifiableCredentialInIdx: (_wallet, idxCredential) => __async(void 0, null, function* () {
-        return addCredentialStreamIdToIdx(idxCredential);
+        const record = IDXCredentialValidator.parse(idxCredential);
+        if (!record)
+          throw new Error("record is required");
+        if (!record.uri)
+          throw Error("No URI provided");
+        yield _wallet.pluginMethods.resolveCredential(record.uri);
+        const existing = yield getCredentialsListFromIdx(credentialAlias);
+        const indexOfExistingCredential = existing.credentials.findIndex((credential) => {
+          return credential.id === record.id;
+        });
+        if (indexOfExistingCredential > -1) {
+          existing.credentials[indexOfExistingCredential] = record;
+        } else
+          existing.credentials.push(record);
+        return streamIdToCeramicURI(yield dataStore.set(credentialAlias, existing));
+      }),
+      removeVerifiableCredentialInIdx: (_wallet, id) => __async(void 0, null, function* () {
+        return removeCredentialFromIdx(id);
       }),
-      removeVerifiableCredentialInIdx: (_wallet, title) => __async(void 0, null, function* () {
-        return removeCredentialFromIdx(title);
+      resolveCredential: (_wallet, uri) => __async(void 0, null, function* () {
+        if (!uri)
+          return void 0;
+        if (uri.startsWith("ceramic://")) {
+          return VCValidator.parseAsync(yield readContentFromCeramic(uri));
+        }
+        const verificationResult = yield CeramicURIValidator.spa(uri);
+        if (!verificationResult.success)
+          return wallet.pluginMethods.resolveCredential(uri);
+        const streamId = verificationResult.data.split(":")[2];
+        return VCValidator.parseAsync(yield readContentFromCeramic(streamId));
       })
     }
   };
@@ -60297,6 +60319,15 @@ var defaultEthereumArgs = {
   network: "mainnet"
 };
 
+// src/wallet/plugins/vc-resolution/index.ts
+var VCResolutionPlugin = {
+  pluginMethods: {
+    resolveCredential: (_wallet, uri) => __async(void 0, null, function* () {
+      throw new Error(`No Credential Resolution Plugins found that can resolve ${uri}`);
+    })
+  }
+};
+
 // src/wallet/initializers/walletFromKey.ts
 var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, ..._1], function* (key2, {
   ceramicIdx = defaultCeramicIDXArgs,
@@ -60308,7 +60339,8 @@ var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, .
   const didkeyWallet = yield didkitWallet.addPlugin(yield getDidKeyPlugin(didkitWallet, key2));
   const didkeyAndVCWallet = yield didkeyWallet.addPlugin(getVCPlugin(didkeyWallet));
   const templateWallet = yield didkeyAndVCWallet.addPlugin(getVCTemplatesPlugin());
-  const idxWallet = yield templateWallet.addPlugin(yield getIDXPlugin(templateWallet, ceramicIdx));
+  const resolutionWallet = yield templateWallet.addPlugin(VCResolutionPlugin);
+  const idxWallet = yield resolutionWallet.addPlugin(yield getIDXPlugin(resolutionWallet, ceramicIdx));
   const expirationWallet = yield idxWallet.addPlugin(ExpirationPlugin(idxWallet));
   const ethWallet = yield expirationWallet.addPlugin(getEthereumPlugin(expirationWallet, ethereumConfig));
   const vpqrWallet = yield ethWallet.addPlugin(getVpqrPlugin(ethWallet));
@@ -60337,6 +60369,7 @@ var walletFromKey = /* @__PURE__ */ __name((_0, ..._1) => __async(void 0, [_0, .
     }),
     resolveDid: wallet.pluginMethods.resolveDid,
     readFromCeramic: wallet.pluginMethods.readContentFromCeramic,
+    resolveCredential: wallet.pluginMethods.resolveCredential,
     getTestVc: wallet.pluginMethods.getTestVc,
     getTestVp: wallet.pluginMethods.getTestVp,
     vpFromQrCode: wallet.pluginMethods.vpFromQrCode,
@@ -60488,6 +60521,9 @@ function initLearnCard() {
 }
 __name(initLearnCard, "initLearnCard");
 export {
+  BackwardsCompatCredentialsListValidator,
+  BackwardsCompatIDXCredentialValidator,
+  CeramicURIValidator,
   CredentialsListValidator,
   ExpirationPlugin,
   emptyWallet,