@learncard/core 8.4.2 → 8.5.0

package/dist/types/wallet.d.ts

@@ -0,0 +1,52 @@
+import { ControlPlane, GetPlanesForPlugins, PluginReadPlane, PluginStorePlane, PluginIndexPlane, PluginCachePlane, PluginIdPlane, LearnCardReadPlane, LearnCardStorePlane, LearnCardIndexPlane, LearnCardCachePlane, LearnCardIdPlane } from './planes';
+import { UnionToIntersection, MergeObjects } from './utilities';
+export type GenerateLearnCard<NewControlPlanes extends ControlPlane = never, NewMethods extends Record<string, (...args: any[]) => any> = Record<never, never>, ControlPlanes extends ControlPlane = never, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>> = LearnCard<any, [
+    ControlPlanes
+] extends [1 & ControlPlanes] ? NewControlPlanes : [NewControlPlanes] extends [1 & NewControlPlanes] ? ControlPlanes : ControlPlanes | NewControlPlanes, NewMethods & Methods>;
+export type AddImplicitLearnCardArgument<Functions extends Record<string, (...args: any[]) => any> = Record<never, never>, ControlPlanes extends ControlPlane = never, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>, DependentControlPlanes extends ControlPlane = never, DependentMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
+    [Key in keyof Functions]: <T extends GenerateLearnCard<ControlPlanes, Methods, DependentControlPlanes, DependentMethods>>(learnCard: T, ...args: Parameters<Functions[Key]>) => ReturnType<Functions[Key]>;
+};
+/** @group Universal Wallets */
+export type GetPluginMethods<Plugins extends Plugin[]> = undefined extends Plugins[1] ? NonNullable<Plugins[0]['_methods']> : UnionToIntersection<NonNullable<MergeObjects<{
+    [Key in keyof Plugins]: NonNullable<Plugins[Key]['_methods']>;
+}>>>;
+/** @group Universal Wallets */
+export type Plugin<Name extends string = string, ControlPlanes extends ControlPlane = any, Methods extends Record<string, (...args: any[]) => any> = Record<never, never>, DependentControlPlanes extends ControlPlane = never, DependentMethods extends Record<string, (...args: any[]) => any> = Record<never, never>> = {
+    name: Name;
+    displayName?: string;
+    description?: string;
+    methods: AddImplicitLearnCardArgument<Methods, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+    _methods?: Methods;
+    read?: {};
+    store?: {};
+    index?: {};
+    cache?: {};
+    id?: {};
+} & ([ControlPlanes] extends [1 & ControlPlanes] ? {} : ('read' extends ControlPlanes ? {
+    read: AddImplicitLearnCardArgument<PluginReadPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ('store' extends ControlPlanes ? {
+    store: AddImplicitLearnCardArgument<PluginStorePlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ('index' extends ControlPlanes ? {
+    index: AddImplicitLearnCardArgument<PluginIndexPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ('cache' extends ControlPlanes ? {
+    cache: AddImplicitLearnCardArgument<PluginCachePlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}) & ('id' extends ControlPlanes ? {
+    id: AddImplicitLearnCardArgument<PluginIdPlane, ControlPlanes, Methods, DependentControlPlanes, DependentMethods>;
+} : {}));
+/** @group Universal Wallets */
+export type LearnCard<Plugins extends Plugin[] = [], ControlPlanes extends ControlPlane = GetPlanesForPlugins<Plugins>, PluginMethods = GetPluginMethods<Plugins>> = {
+    plugins: Plugins;
+    invoke: PluginMethods;
+    addPlugin: <NewPlugin extends Plugin>(plugin: NewPlugin) => Promise<LearnCard<[...Plugins, NewPlugin]>>;
+    debug?: typeof console.log;
+} & ([ControlPlanes] extends [1 & ControlPlanes] ? {} : ('read' extends ControlPlanes ? {
+    read: LearnCardReadPlane<Plugins>;
+} : {}) & ('store' extends ControlPlanes ? {
+    store: LearnCardStorePlane<Plugins>;
+} : {}) & ('index' extends ControlPlanes ? {
+    index: LearnCardIndexPlane<Plugins>;
+} : {}) & ('cache' extends ControlPlanes ? {
+    cache: LearnCardCachePlane<Plugins>;
+} : {}) & ('id' extends ControlPlanes ? {
+    id: LearnCardIdPlane<Plugins>;
+} : {}));

package/dist/wallet/base/crypto.d.ts

@@ -0,0 +1,2 @@
+import crypto from 'isomorphic-webcrypto';
+export default crypto;

package/dist/wallet/base/helpers.d.ts

@@ -0,0 +1,16 @@
+import { LearnCard, Plugin } from '../../types/wallet';
+import { ControlPlane } from '../../types/planes';
+/** Type guard for removing null/undefined */
+export declare const isNotNull: <T>(item?: T | null | undefined) => item is T;
+/** Removes null/undefined from items in an array */
+export declare const filterNulls: <T>(array: (T | null | undefined)[]) => T[];
+/**
+ * Loops through an array, running a callback over it until that callback returns a value. Once the
+ * first value is found, it is returned. If no value is found, undefined is returned instead
+ */
+export declare const findFirstResult: <T, U>(array: T[], callback: (item: T) => U | undefined) => U | undefined;
+export declare const pluginImplementsPlane: <Plane extends ControlPlane>(plugin: Plugin, plane: Plane) => plugin is Plugin<any, Plane, Record<never, never>, never, Record<never, never>>;
+export declare const learnCardImplementsPlane: <Plane extends ControlPlane>(learnCard: LearnCard<any, any, any>, plane: Plane) => learnCard is LearnCard<any, Plane, any>;
+export declare const mapObject: <T extends string, U, V>(obj: Record<T, U>, callback: (value: U, index: number) => V) => Record<T, V>;
+export declare const isFulfilledAndNotEmpty: <T>(input: PromiseSettledResult<T>) => input is PromiseFulfilledResult<T>;
+export declare const uniqBy: <Obj extends Record<string, any>>(array: Obj[], key: keyof Obj | ((obj: Obj) => any)) => Obj[];

package/dist/wallet/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './wallet';
+export * from './crypto';

package/dist/wallet/base/wallet.d.ts

@@ -0,0 +1,15 @@
+import { LearnCard, GetPluginMethods, AddImplicitLearnCardArgument } from '../../types/wallet';
+import { GetPlanesForPlugins } from '../../types/planes';
+/** @group Universal Wallets */
+export declare const generateLearnCard: <Plugins extends {
+    name: string;
+    displayName?: string | undefined;
+    description?: string | undefined;
+    methods: AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+    _methods?: Record<never, never> | undefined;
+    read?: {} | undefined;
+    store?: {} | undefined;
+    index?: {} | undefined;
+    cache?: {} | undefined;
+    id?: {} | undefined;
+}[] = [], ControlPlanes extends GetPlanesForPlugins<Plugins> = GetPlanesForPlugins<Plugins>, PluginMethods extends GetPluginMethods<Plugins> = GetPluginMethods<Plugins>>(_learnCard?: Partial<LearnCard<Plugins, ControlPlanes, PluginMethods>>) => Promise<LearnCard<Plugins, ControlPlanes, PluginMethods>>;

package/dist/wallet/defaults.d.ts

@@ -0,0 +1,5 @@
+import { CeramicArgs } from './plugins/ceramic/types';
+import { IDXArgs } from './plugins/idx/types';
+import { EthereumConfig } from './plugins/EthereumPlugin/types';
+export declare const defaultCeramicIDXArgs: CeramicArgs & IDXArgs;
+export declare const defaultEthereumArgs: EthereumConfig;

package/dist/wallet/init.d.ts

@@ -0,0 +1,29 @@
+import { EmptyLearnCard, LearnCardFromSeed, LearnCardFromVcApi, CustomLearnCard } from '../types/LearnCard';
+export * from './initializers/customLearnCard';
+export * from './initializers/emptyLearnCard';
+export * from './initializers/learnCardFromSeed';
+export * from './initializers/apiLearnCard';
+/**
+ * Generates an Empty Wallet
+ *
+ * @group Init Functions
+ */
+export declare function initLearnCard(config?: EmptyLearnCard['args']): Promise<EmptyLearnCard['returnValue']>;
+/**
+ * Generates a full wallet from a 32 byte seed
+ *
+ * @group Init Functions
+ */
+export declare function initLearnCard(config: LearnCardFromSeed['args']): Promise<LearnCardFromSeed['returnValue']>;
+/**
+ * Generates a wallet that can sign VCs/VPs from a VC API
+ *
+ * @group Init Functions
+ */
+export declare function initLearnCard(config: LearnCardFromVcApi['args']): Promise<LearnCardFromVcApi['returnValue']>;
+/**
+ * Generates a custom wallet with no plugins added
+ *
+ * @group Init Functions
+ */
+export declare function initLearnCard(config: CustomLearnCard['args']): Promise<CustomLearnCard['returnValue']>;

package/dist/wallet/initializers/apiLearnCard.d.ts

@@ -0,0 +1,14 @@
+import { LearnCardFromVcApi } from '../../types/LearnCard';
+/**
+ * Generates a LearnCard Wallet from a 64 character seed string
+ *
+ * @group Init Functions
+ */
+export declare const learnCardFromApiUrl: ({ url, did, debug, }: {
+    url: string;
+    did?: string | undefined;
+    debug?: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    } | undefined;
+}) => Promise<LearnCardFromVcApi['returnValue']>;

package/dist/wallet/initializers/customLearnCard.d.ts

@@ -0,0 +1,7 @@
+import { CustomLearnCard } from '../../types/LearnCard';
+/**
+ * Generates a custom LearnCard with no plugins added
+ *
+ * @group Init Functions
+ */
+export declare const customLearnCard: ({ debug }?: Partial<CustomLearnCard['args']>) => Promise<CustomLearnCard['returnValue']>;

package/dist/wallet/initializers/emptyLearnCard.d.ts

@@ -0,0 +1,7 @@
+import { EmptyLearnCard } from '../../types/LearnCard';
+/**
+ * Generates an empty wallet with no key material
+ *
+ * @group Init Functions
+ */
+export declare const emptyLearnCard: ({ didkit, debug }?: EmptyLearnCard['args']) => Promise<EmptyLearnCard['returnValue']>;

package/dist/wallet/initializers/learnCardFromSeed.d.ts

@@ -0,0 +1,7 @@
+import { LearnCardConfig, LearnCardFromSeed } from '../../types/LearnCard';
+/**
+ * Generates a LearnCard Wallet from a 64 character seed string
+ *
+ * @group Init Functions
+ */
+export declare const learnCardFromSeed: (seed: string, { ceramicIdx, didkit, ethereumConfig, debug, }?: Partial<LearnCardConfig>) => Promise<LearnCardFromSeed['returnValue']>;

package/dist/wallet/plugins/EthereumPlugin/hardcodedTokens.d.ts

@@ -0,0 +1,22 @@
+export declare const hardcodedTokens: {
+    name: string;
+    address: string;
+    symbol: string;
+    decimals: number;
+    chainId: number;
+    logoURI: string;
+    extensions: {
+        bridgeInfo: {
+            '10': {
+                tokenAddress: string;
+            };
+            '137': {
+                tokenAddress: string;
+            };
+            '42161': {
+                tokenAddress: string;
+            };
+        };
+    };
+}[];
+export default hardcodedTokens;

package/dist/wallet/plugins/EthereumPlugin/helpers.d.ts

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+import { Token, TokenList } from './types';
+export declare const isAddress: (maybeAddress: string) => boolean;
+export declare const formatUnits: (units: ethers.BigNumberish, symbolOrAddress: string, tokenList: TokenList, chainId: number) => Promise<string>;
+export declare const parseUnits: (units: string, symbolOrAddress: string, tokenList: TokenList, chainId: number) => Promise<ethers.BigNumber>;
+export declare const getTokenFromSymbolOrAddress: (symbolOrAddress: string, tokenList: TokenList, chainId: number) => Promise<Token | undefined>;
+export declare const getChainIdFromProvider: (provider: ethers.providers.Provider) => Promise<number>;

package/dist/wallet/plugins/EthereumPlugin/index.d.ts

@@ -0,0 +1,7 @@
+import { LearnCard } from '../../../types/wallet';
+import { EthereumConfig, EthereumPlugin } from './types';
+export * from './types';
+/**
+ * @group Plugins
+ */
+export declare const getEthereumPlugin: (initLearnCard: LearnCard<any, 'id'>, config: EthereumConfig) => EthereumPlugin;

package/dist/wallet/plugins/EthereumPlugin/types.d.ts

@@ -0,0 +1,32 @@
+import { providers } from 'ethers';
+import { Plugin } from '../../../types/wallet';
+/** @group Ethereum Plugin */
+export type EthereumPluginMethods = {
+    getEthereumAddress: () => string;
+    getBalance: (symbolOrAddress?: string) => Promise<string>;
+    getBalanceForAddress: (walletAddress: string, symbolOrAddress?: string) => Promise<string>;
+    transferTokens: (tokenSymbolOrAddress: string, amount: number, toAddress: string) => Promise<string>;
+    getGasPrice: () => Promise<string>;
+    getCurrentNetwork: () => providers.Networkish;
+    changeNetwork: (network: providers.Networkish) => void;
+    addInfuraProjectId: (infuraProjectIdToAdd: string) => void;
+};
+/** @group Ethereum Plugin */
+export type EthereumConfig = {
+    infuraProjectId?: string;
+    network?: providers.Networkish;
+};
+/** @group Ethereum Plugin */
+export type Token = {
+    chainId: number;
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+    extensions: any;
+};
+/** @group Ethereum Plugin */
+export type TokenList = Token[];
+/** @group Ethereum Plugin */
+export type EthereumPlugin = Plugin<'Ethereum', any, EthereumPluginMethods, 'id'>;

package/dist/wallet/plugins/ceramic/ceramic.d.ts

@@ -0,0 +1,215 @@
+import { CeramicPlugin, CeramicPluginDependentMethods, CeramicArgs } from './types';
+import { LearnCard } from '../../../types/wallet';
+/**
+ * @group Plugins
+ */
+export declare const getCeramicPlugin: <URI extends string = "">(learnCard: {
+    plugins: any;
+    invoke: CeramicPluginDependentMethods<URI>;
+    addPlugin: <NewPlugin extends {
+        name: string;
+        displayName?: string | undefined;
+        description?: string | undefined;
+        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+        _methods?: Record<never, never> | undefined;
+        read?: {} | undefined;
+        store?: {} | undefined;
+        index?: {} | undefined;
+        cache?: {} | undefined;
+        id?: {} | undefined;
+    }>(plugin: NewPlugin) => Promise<{
+        plugins: [...any[], NewPlugin];
+        invoke: any;
+        addPlugin: <NewPlugin_1 extends {
+            name: string;
+            displayName?: string | undefined;
+            description?: string | undefined;
+            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+            _methods?: Record<never, never> | undefined;
+            read?: {} | undefined;
+            store?: {} | undefined;
+            index?: {} | undefined;
+            cache?: {} | undefined;
+            id?: {} | undefined;
+        }>(plugin: NewPlugin_1) => Promise<{
+            plugins: [...any[], NewPlugin, NewPlugin_1];
+            invoke: any;
+            addPlugin: <NewPlugin_2 extends {
+                name: string;
+                displayName?: string | undefined;
+                description?: string | undefined;
+                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                _methods?: Record<never, never> | undefined;
+                read?: {} | undefined;
+                store?: {} | undefined;
+                index?: {} | undefined;
+                cache?: {} | undefined;
+                id?: {} | undefined;
+            }>(plugin: NewPlugin_2) => Promise<{
+                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2];
+                invoke: any;
+                addPlugin: <NewPlugin_3 extends {
+                    name: string;
+                    displayName?: string | undefined;
+                    description?: string | undefined;
+                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                    _methods?: Record<never, never> | undefined;
+                    read?: {} | undefined;
+                    store?: {} | undefined;
+                    index?: {} | undefined;
+                    cache?: {} | undefined;
+                    id?: {} | undefined;
+                }>(plugin: NewPlugin_3) => Promise<{
+                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3];
+                    invoke: any;
+                    addPlugin: <NewPlugin_4 extends {
+                        name: string;
+                        displayName?: string | undefined;
+                        description?: string | undefined;
+                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                        _methods?: Record<never, never> | undefined;
+                        read?: {} | undefined;
+                        store?: {} | undefined;
+                        index?: {} | undefined;
+                        cache?: {} | undefined;
+                        id?: {} | undefined;
+                    }>(plugin: NewPlugin_4) => Promise<{
+                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4];
+                        invoke: any;
+                        addPlugin: <NewPlugin_5 extends {
+                            name: string;
+                            displayName?: string | undefined;
+                            description?: string | undefined;
+                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                            _methods?: Record<never, never> | undefined;
+                            read?: {} | undefined;
+                            store?: {} | undefined;
+                            index?: {} | undefined;
+                            cache?: {} | undefined;
+                            id?: {} | undefined;
+                        }>(plugin: NewPlugin_5) => Promise<{
+                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5];
+                            invoke: any;
+                            addPlugin: <NewPlugin_6 extends {
+                                name: string;
+                                displayName?: string | undefined;
+                                description?: string | undefined;
+                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                _methods?: Record<never, never> | undefined;
+                                read?: {} | undefined;
+                                store?: {} | undefined;
+                                index?: {} | undefined;
+                                cache?: {} | undefined;
+                                id?: {} | undefined;
+                            }>(plugin: NewPlugin_6) => Promise<{
+                                plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6];
+                                invoke: any;
+                                addPlugin: <NewPlugin_7 extends {
+                                    name: string;
+                                    displayName?: string | undefined;
+                                    description?: string | undefined;
+                                    methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                    _methods?: Record<never, never> | undefined;
+                                    read?: {} | undefined;
+                                    store?: {} | undefined;
+                                    index?: {} | undefined;
+                                    cache?: {} | undefined;
+                                    id?: {} | undefined;
+                                }>(plugin: NewPlugin_7) => Promise<{
+                                    plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7];
+                                    invoke: any;
+                                    addPlugin: <NewPlugin_8 extends {
+                                        name: string;
+                                        displayName?: string | undefined;
+                                        description?: string | undefined;
+                                        methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                        _methods?: Record<never, never> | undefined;
+                                        read?: {} | undefined;
+                                        store?: {} | undefined;
+                                        index?: {} | undefined;
+                                        cache?: {} | undefined;
+                                        id?: {} | undefined;
+                                    }>(plugin: NewPlugin_8) => Promise<{
+                                        plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8];
+                                        invoke: any;
+                                        addPlugin: <NewPlugin_9 extends {
+                                            name: string;
+                                            displayName?: string | undefined;
+                                            description?: string | undefined;
+                                            methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                            _methods?: Record<never, never> | undefined;
+                                            read?: {} | undefined;
+                                            store?: {} | undefined;
+                                            index?: {} | undefined;
+                                            cache?: {} | undefined;
+                                            id?: {} | undefined;
+                                        }>(plugin: NewPlugin_9) => Promise<{
+                                            plugins: [...any[], NewPlugin, NewPlugin_1, NewPlugin_2, NewPlugin_3, NewPlugin_4, NewPlugin_5, NewPlugin_6, NewPlugin_7, NewPlugin_8, NewPlugin_9];
+                                            invoke: any;
+                                            addPlugin: <NewPlugin_10 extends {
+                                                name: string;
+                                                displayName?: string | undefined;
+                                                description?: string | undefined;
+                                                methods: import("../../../types/wallet").AddImplicitLearnCardArgument<Record<never, never>, any, Record<never, never>, never, Record<never, never>>;
+                                                _methods?: Record<never, never> | undefined;
+                                                read?: {} | undefined;
+                                                store?: {} | undefined;
+                                                index?: {} | undefined;
+                                                cache?: {} | undefined;
+                                                id?: {} | undefined;
+                                            }>(plugin: NewPlugin_10) => Promise<any>;
+                                            debug?: {
+                                                (...data: any[]): void;
+                                                (message?: any, ...optionalParams: any[]): void;
+                                            } | undefined;
+                                        }>;
+                                        debug?: {
+                                            (...data: any[]): void;
+                                            (message?: any, ...optionalParams: any[]): void;
+                                        } | undefined;
+                                    }>;
+                                    debug?: {
+                                        (...data: any[]): void;
+                                        (message?: any, ...optionalParams: any[]): void;
+                                    } | undefined;
+                                }>;
+                                debug?: {
+                                    (...data: any[]): void;
+                                    (message?: any, ...optionalParams: any[]): void;
+                                } | undefined;
+                            }>;
+                            debug?: {
+                                (...data: any[]): void;
+                                (message?: any, ...optionalParams: any[]): void;
+                            } | undefined;
+                        }>;
+                        debug?: {
+                            (...data: any[]): void;
+                            (message?: any, ...optionalParams: any[]): void;
+                        } | undefined;
+                    }>;
+                    debug?: {
+                        (...data: any[]): void;
+                        (message?: any, ...optionalParams: any[]): void;
+                    } | undefined;
+                }>;
+                debug?: {
+                    (...data: any[]): void;
+                    (message?: any, ...optionalParams: any[]): void;
+                } | undefined;
+            }>;
+            debug?: {
+                (...data: any[]): void;
+                (message?: any, ...optionalParams: any[]): void;
+            } | undefined;
+        }>;
+        debug?: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        } | undefined;
+    }>;
+    debug?: {
+        (...data: any[]): void;
+        (message?: any, ...optionalParams: any[]): void;
+    } | undefined;
+}, { ceramicEndpoint, defaultContentFamily }: CeramicArgs) => Promise<CeramicPlugin>;

package/dist/wallet/plugins/ceramic/helpers.d.ts

@@ -0,0 +1,3 @@
+import { StreamID } from '@ceramicnetwork/streamid';
+import { CeramicURI } from './types';
+export declare const streamIdToCeramicURI: (id: string | StreamID) => CeramicURI;

package/dist/wallet/plugins/ceramic/index.d.ts

@@ -0,0 +1,4 @@
+import { getCeramicPlugin } from './ceramic';
+export { getCeramicPlugin } from './ceramic';
+export * from './types';
+export default getCeramicPlugin;

package/dist/wallet/plugins/ceramic/types.d.ts

@@ -0,0 +1,43 @@
+import type { DID, CreateJWEOptions, DIDResolutionResult } from 'dids';
+import { z } from 'zod';
+import { CeramicClient } from '@ceramicnetwork/http-client';
+import { Plugin } from '../../../types/wallet';
+import { ResolutionExtension } from '../vc-resolution';
+import { InputMetadata } from '../didkit';
+/** @group CeramicPlugin */
+export type CeramicArgs = {
+    ceramicEndpoint: string;
+    defaultContentFamily: string;
+};
+/** @group CeramicPlugin */
+export type CeramicURI = `lc:ceramic:${string}`;
+/** @group CeramicPlugin */
+export declare const CeramicURIValidator: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/**
+ * Settings for toggling JWE Encryption before uploading to Ceramic.
+ * @group CeramicPlugin
+ * @param encrypt enable JWE encryption on upload.
+ * @param controllersCanDecrypt helper to add Ceramic controller DIDs to recipients who can decrypt the JWE credential.
+ * @param recipients DIDs who can decrypt the JWE credential.
+ * @param options additional CreateJWEOptions for encryption.
+ */
+export type CeramicEncryptionParams = {
+    encrypt: boolean;
+    controllersCanDecrypt?: boolean;
+    recipients?: string[] | undefined;
+    options?: CreateJWEOptions | undefined;
+};
+/** @group CeramicPlugin */
+export type CeramicPluginMethods<URI extends string = ''> = {
+    publishContentToCeramic: (cred: any, encryption: CeramicEncryptionParams | undefined) => Promise<CeramicURI>;
+    readContentFromCeramic: (streamId: string) => Promise<any>;
+    getCeramicClient: () => CeramicClient;
+    getDIDObject: () => DID;
+} & ResolutionExtension<URI | CeramicURI>;
+/** @group CeramicPlugin */
+export type CeramicPluginDependentMethods<URI extends string = ''> = {
+    getKey: () => string;
+    didResolver: (did: string, inputMetadata?: InputMetadata) => Promise<DIDResolutionResult>;
+} & ResolutionExtension<URI>;
+/** @group CeramicPlugin */
+export type CeramicPlugin = Plugin<'Ceramic', 'read' | 'store', CeramicPluginMethods>;

package/dist/wallet/plugins/chapi/chapi.d.ts

@@ -0,0 +1,5 @@
+import { CHAPIPlugin } from './types';
+/**
+ * @group Plugins
+ */
+export declare const getCHAPIPlugin: () => Promise<CHAPIPlugin>;

package/dist/wallet/plugins/chapi/index.d.ts

@@ -0,0 +1,2 @@
+export { getCHAPIPlugin } from './chapi';
+export * from './types';

package/dist/wallet/plugins/chapi/types.d.ts

@@ -0,0 +1,88 @@
+import { UnsignedVC, VC, UnsignedVP, VP, VerificationCheck } from '@learncard/types';
+import { Plugin } from '../../../types/wallet';
+import { ProofOptions } from '../didkit/types';
+/** @group CHAPI Plugin */
+export type WebCredential = {
+    new (dataType: string, data: VP, options?: {
+        recommendedHandlerOrigins: string[];
+    }): WebCredential;
+    type: string;
+    dataType: string;
+    data: VP;
+    options: {
+        recommendedHandlerOrigins: string[];
+    };
+};
+/** @group CHAPI Plugin */
+export type CredentialRequestEvent = {
+    new (args: {
+        credentialHandler: any;
+        credentialRequestOrigin: string;
+        credentialRequestOptions: any;
+        hintKey: string;
+    }): CredentialRequestEvent;
+    type: string;
+    _credentialHandler: any;
+    credentialRequestOrigin: string;
+    credentialRequestOptions: any;
+    hintKey: string;
+    openWindow: (url: string) => Promise<any>;
+    respondWith: (handlerResponse: Promise<null | {
+        dataType: string;
+        data: any;
+    }>) => void;
+};
+/** @group CHAPI Plugin */
+export type CredentialStoreEvent = {
+    new (args: {
+        credentialHandler: any;
+        credentialRequestOrigin: string;
+        credential: WebCredential;
+        hintKey: string;
+    }): CredentialStoreEvent;
+    type: string;
+    _credentialHandler: any;
+    credentialRequestOrigin: string;
+    credential: WebCredential;
+    hintKey: string;
+    openWindow: (url: string) => Promise<any>;
+    respondWith: (handlerResponse: Promise<null | {
+        dataType: string;
+        data: any;
+    }>) => void;
+};
+/** @group CHAPI Plugin */
+export type HandlerResponse = {
+    type: 'redirect';
+    url: string;
+} | {
+    type: 'response';
+    dataType: string;
+    data: any;
+};
+/** @group CHAPI Plugin */
+export type CHAPIPluginDependentMethods = {
+    issueCredential: (credential: UnsignedVC, signingOptions?: Partial<ProofOptions>) => Promise<VC>;
+    issuePresentation: (credential: UnsignedVP, signingOptions?: Partial<ProofOptions>) => Promise<VP>;
+    verifyPresentation: (presentation: VP, options?: Partial<ProofOptions>) => Promise<VerificationCheck>;
+    getTestVp: (credential?: VC) => Promise<UnsignedVP>;
+};
+/** @group CHAPI Plugin */
+export type CHAPIPluginMethods = {
+    installChapiHandler: () => Promise<void>;
+    activateChapiHandler: (args: {
+        mediatorOrigin?: string;
+        get?: (event: CredentialRequestEvent) => Promise<HandlerResponse>;
+        store?: (event: CredentialStoreEvent) => Promise<HandlerResponse>;
+    }) => Promise<void>;
+    receiveChapiEvent: () => Promise<CredentialRequestEvent | CredentialStoreEvent>;
+    storeCredentialViaChapiDidAuth: (credential: UnsignedVC) => Promise<{
+        success: true;
+    } | {
+        success: false;
+        reason: 'did not auth' | 'auth failed verification' | 'did not store';
+    }>;
+    storePresentationViaChapi: (presentation: UnsignedVP | VP) => Promise<Credential | undefined>;
+};
+/** @group CHAPI Plugin */
+export type CHAPIPlugin = Plugin<'CHAPI', any, CHAPIPluginMethods, any, CHAPIPluginDependentMethods>;

package/dist/wallet/plugins/didkey/helpers.d.ts

@@ -0,0 +1,4 @@
+import { Algorithm } from './types';
+export declare const ED25519_METHODS: string[];
+export declare const SECP256K1_METHODS: string[];
+export declare const getAlgorithmForDidMethod: <DidMethod extends string>(didMethod: DidMethod) => Algorithm;