@learncard/claimable-boosts-plugin 1.1.24 → 1.1.26

package/package.json

@@ -1,56 +1,58 @@
 {
-  "name": "@learncard/claimable-boosts-plugin",
-  "version": "1.1.24",
-  "description": "",
-  "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/claimable-boosts-plugin.esm.js",
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/claimable-boosts-plugin.esm.js"
-      },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      }
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "author": "Learning Economy Foundation (www.learningeconomy.io)",
-  "license": "MIT",
-  "homepage": "https://github.com/learningeconomy/LearnCard/tree/main/packages/plugins/claimable-boosts/README.md",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/learningeconomy/LearnCard"
-  },
-  "bugs": {
-    "url": "https://github.com/learningeconomy/LearnCard/issues"
-  },
-  "devDependencies": {
-    "@types/jest": "^29.2.2",
-    "@types/node": "^17.0.31",
-    "aqu": "0.4.3",
-    "esbuild": "^0.27.1",
-    "esbuild-jest": "^0.5.0",
-    "esbuild-plugin-copy": "^1.3.0",
-    "jest": "^29.3.0",
-    "shx": "^0.3.4",
-    "ts-jest": "^29.0.3"
-  },
-  "types": "./dist/index.d.ts",
-  "dependencies": {
-    "@learncard/core": "9.4.24",
-    "@learncard/types": "5.17.4"
-  },
-  "sideEffects": false,
-  "scripts": {
-    "build": "node ./scripts/build.mjs && shx cp ./scripts/mixedEntypoint.js ./dist/index.cjs && tsc --p tsconfig.json && shx cp ./dist/index.d.ts ./dist/index.d.cts",
-    "test": "jest --passWithNoTests",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --silent --ci --coverage --coverageReporters=\"text\" --coverageReporters=\"text-summary\""
-  }
-}
+    "name": "@learncard/claimable-boosts-plugin",
+    "version": "1.1.26",
+    "description": "",
+    "type": "module",
+    "main": "./dist/index.cjs",
+    "module": "./dist/claimable-boosts-plugin.esm.js",
+    "exports": {
+        ".": {
+            "development": "./src/index.ts",
+            "import": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/claimable-boosts-plugin.esm.js"
+            },
+            "require": {
+                "types": "./dist/index.d.cts",
+                "default": "./dist/index.cjs"
+            }
+        }
+    },
+    "files": [
+        "dist",
+        "src"
+    ],
+    "scripts": {
+        "build": "node ./scripts/build.mjs && shx cp ./scripts/mixedEntypoint.js ./dist/index.cjs && tsc --p tsconfig.json && shx cp ./dist/index.d.ts ./dist/index.d.cts",
+        "test": "jest --passWithNoTests",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --silent --ci --coverage --coverageReporters=\"text\" --coverageReporters=\"text-summary\""
+    },
+    "author": "Learning Economy Foundation (www.learningeconomy.io)",
+    "license": "MIT",
+    "homepage": "https://github.com/learningeconomy/LearnCard/tree/main/packages/plugins/claimable-boosts/README.md",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/learningeconomy/LearnCard"
+    },
+    "bugs": {
+        "url": "https://github.com/learningeconomy/LearnCard/issues"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.2.2",
+        "@types/node": "^17.0.31",
+        "aqu": "0.4.3",
+        "esbuild": "^0.27.1",
+        "esbuild-jest": "^0.5.0",
+        "esbuild-plugin-copy": "^1.3.0",
+        "jest": "^29.3.0",
+        "shx": "^0.3.4",
+        "ts-jest": "^29.0.3"
+    },
+    "types": "./dist/index.d.ts",
+    "dependencies": {
+        "@learncard/core": "9.4.26",
+        "@learncard/types": "5.17.5"
+    },
+    "sideEffects": false
+}

package/src/index.ts

@@ -0,0 +1,127 @@
+import { LCNBoostClaimLinkOptionsType } from '@learncard/types';
+import {
+    ClaimableBoostsPlugin,
+    ClaimableBoostsPluginDependentMethods,
+    SigningAuthorityType,
+} from './types';
+
+import { LearnCard } from '@learncard/core';
+
+export * from './types';
+
+const DEFAULT_RELATIONSHIP_NAME = 'lca-sa';
+
+/**
+ * @group Plugins
+ */
+export const getClaimableBoostsPlugin = (
+    learnCard: LearnCard<any, any, ClaimableBoostsPluginDependentMethods>
+): ClaimableBoostsPlugin => {
+    return {
+        name: 'ClaimableBoosts',
+        displayName: 'Claimable Boosts',
+        description:
+            'Simple claimable boost creation plugin that handles signing authority management.',
+        methods: {
+            generateBoostClaimLink: async (
+                _learnCard: LearnCard<any, any, ClaimableBoostsPluginDependentMethods>,
+                boostURI: string,
+                options?: LCNBoostClaimLinkOptionsType
+            ) => {
+                _learnCard.debug?.('Generating boost claim link...', boostURI, options);
+                return _generateBoostClaimLink(_learnCard, boostURI, options);
+            },
+        },
+    };
+};
+
+const _generateBoostClaimLink = async (
+    _learnCard: LearnCard<any, any, ClaimableBoostsPluginDependentMethods>,
+    boostURI: string,
+    options?: LCNBoostClaimLinkOptionsType
+): Promise<string> => {
+    try {
+        const rsas = await _learnCard.invoke.getRegisteredSigningAuthorities();
+        _learnCard.debug?.('Registered Signing Authorities', rsas);
+
+        if (rsas?.length > 0) {
+            const rsa = rsas[0];
+            _learnCard.debug?.('Using Existing Signing Authority', rsa);
+
+            // generate claim link with existing rsa
+            const _boostClaimLink = await _learnCard.invoke.generateClaimLink(
+                boostURI,
+                {
+                    name: rsa?.relationship?.name || '',
+                    endpoint: rsa?.signingAuthority?.endpoint || '',
+                },
+                options
+            );
+
+            if (!_boostClaimLink) {
+                throw new Error('Failed to generate claim link');
+            }
+
+            return `https://learncard.app/claim/boost?claim=true&boostUri=${_boostClaimLink.boostUri}&challenge=${_boostClaimLink.challenge}`;
+        }
+
+        // find existing signing authority
+        const signingAuthorities = await _learnCard.invoke.getSigningAuthorities();
+        _learnCard.debug?.('Existing Signing Authorities', signingAuthorities);
+
+        let sa: SigningAuthorityType | undefined;
+        if (signingAuthorities && Array.isArray(signingAuthorities)) {
+            sa = signingAuthorities.find(
+                (signingAuthority: SigningAuthorityType) =>
+                    signingAuthority.name === DEFAULT_RELATIONSHIP_NAME
+            );
+        }
+
+        if (!sa) {
+            // create signing authority
+            const newSa = await _learnCard.invoke.createSigningAuthority(DEFAULT_RELATIONSHIP_NAME);
+            _learnCard.debug?.('Creating New Signing Authority', newSa);
+            if (!newSa) {
+                throw new Error('Failed to create signing authority');
+            }
+            sa = {
+                ownerDid: newSa.ownerDid,
+                name: DEFAULT_RELATIONSHIP_NAME,
+                endpoint: newSa.endpoint,
+                did: newSa.did,
+            };
+        }
+
+        // register signing authority
+        const rsa = await _learnCard.invoke.registerSigningAuthority(
+            sa?.endpoint || '',
+            sa?.name || '',
+            sa?.did || ''
+        );
+
+        _learnCard.debug?.('Registering Signing Authority with Network', sa);
+
+        if (!rsa) {
+            throw new Error('Failed to register signing authority');
+        }
+
+        const _boostClaimLink = await _learnCard.invoke.generateClaimLink(
+            boostURI,
+            {
+                name: sa?.name || '',
+                endpoint: sa?.endpoint || '',
+            },
+            options
+        );
+        _learnCard.debug?.('Generating Claim Link', _boostClaimLink);
+
+        if (!_boostClaimLink) {
+            throw new Error('Failed to generate claim link');
+        }
+
+        return `https://learncard.app/claim/boost?claim=true&boostUri=${_boostClaimLink.boostUri}&challenge=${_boostClaimLink.challenge}`;
+    } catch (error) {
+        _learnCard.debug?.('Error generateBoostClaimLink:', error);
+        throw new Error('Failed to generate boost claim link: ' + (error as Error).message);
+    }
+};

package/src/test/index.test.ts

@@ -0,0 +1,56 @@
+import { getClaimableBoostsPlugin } from '../';
+
+describe('Claimable Boosts Plugin', () => {
+    it('exposes a function', () => {
+        expect(getClaimableBoostsPlugin).toBeDefined();
+    });
+
+    it('returns a plugin', () => {
+        const plugin = getClaimableBoostsPlugin({
+            invoke: {
+                generateClaimLink: jest.fn(),
+                getRegisteredSigningAuthorities: jest.fn(),
+            },
+        } as any);
+        expect(plugin).toBeDefined();
+    });
+
+    it('returns a plugin with the correct name', () => {
+        const plugin = getClaimableBoostsPlugin({
+            invoke: {
+                generateClaimLink: jest.fn(),
+                getRegisteredSigningAuthorities: jest.fn(),
+            },
+        } as any);
+        expect(plugin.name).toBe('ClaimableBoosts');
+    });
+
+    it('generates a claim link for a boost', async () => {
+        const mockGenerateClaimLink = jest.fn().mockResolvedValue({
+            boostUri: 'test-uri',
+            challenge: 'test-challenge'
+        });
+        const mockGetRegisteredSigningAuthorities = jest.fn().mockResolvedValue([{
+            relationship: { name: 'test-name' },
+            signingAuthority: { endpoint: 'test-endpoint' }
+        }]);
+
+        const mockLearnCard = {
+            invoke: {
+                generateClaimLink: mockGenerateClaimLink,
+                getRegisteredSigningAuthorities: mockGetRegisteredSigningAuthorities,
+            },
+        };
+
+        const plugin = getClaimableBoostsPlugin(mockLearnCard as any);
+
+        const result = await plugin.methods.generateBoostClaimLink(mockLearnCard as any, 'test-boost-uri');
+        expect(result).toBe('https://learncard.app/claim/boost?claim=true&boostUri=test-uri&challenge=test-challenge');
+        
+        expect(mockGetRegisteredSigningAuthorities).toHaveBeenCalled();
+        expect(mockGenerateClaimLink).toHaveBeenCalledWith('test-boost-uri', {
+            name: 'test-name',
+            endpoint: 'test-endpoint'
+        }, undefined);
+    });
+});

package/src/types.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { Plugin } from '@learncard/core';
+import { LCNBoostClaimLinkOptionsType } from '@learncard/types';
+import { LCNSigningAuthorityForUserType } from '@learncard/types';
+
+export const SigningAuthorityValidator = z.object({
+    _id: z.string().optional(),
+    ownerDid: z.string(),
+    name: z.string(),
+    did: z.string().optional(),
+    endpoint: z.string().optional(),
+});
+
+export type SigningAuthorityType = z.infer<typeof SigningAuthorityValidator>;
+
+/** @group Claimable Boosts Plugin */
+export type ClaimableBoostsPluginMethods = {
+    generateBoostClaimLink: (
+        boostURI: string,
+        options?: LCNBoostClaimLinkOptionsType
+    ) => Promise<string>;
+};
+
+/** @group Claimable Boosts Plugin */
+export type ClaimableBoostsPluginDependentMethods = {
+    createSigningAuthority: (name: string) => Promise<SigningAuthorityType | false>;
+    getSigningAuthorities: () => Promise<SigningAuthorityType[] | false>;
+    getRegisteredSigningAuthorities: () => Promise<LCNSigningAuthorityForUserType[]>;
+    registerSigningAuthority: (endpoint: string, name: string, did: string) => Promise<boolean>;
+    generateClaimLink: (
+        boostUri: string,
+        claimLinkSA: {
+            name: string;
+            endpoint: string;
+        },
+        options?: LCNBoostClaimLinkOptionsType,
+        challenge?: string
+    ) => Promise<{
+        boostUri: string;
+        challenge: string;
+    }>;
+};
+
+export type ClaimableBoostsPlugin = Plugin<
+    'ClaimableBoosts',
+    any,
+    ClaimableBoostsPluginMethods,
+    any,
+    ClaimableBoostsPluginDependentMethods
+>;