@lit-protocol/vincent-app-sdk 0.0.4-mma

package/dist/README.md

@@ -0,0 +1,216 @@
+# Vincent SDK
+
+## Installation
+
+```
+npm install @lit-protocol/vincent-app-sdk
+```
+
+## Usage
+
+# Client (Web)
+
+## WebAuthClient
+
+The Vincent Web Auth Client provides methods for managing user authentication, JWT tokens, and consent flows in Vincent applications.
+
+### Methods
+
+#### redirectToConsentPage()
+
+Redirects the user to the Vincent consent page to obtain authorization. Once the user has completed the vincent consent flow
+they will be redirected back to your app with a signed JWT that you can use to authenticate requests against your backend APIs
+
+- When a JWT is expired, you need to use this method to get a new JWT
+
+#### isLoginUri()
+
+Checks if the current window location contains a Vincent login JWT. You can use this method to know that you should update login state with the newly provided JWT
+
+- Returns: Boolean indicating if the URI contains a login JWT
+
+#### decodeVincentLoginJWT(expectedAudience)
+
+Decodes a Vincent login JWT. Performs basic sanity check but does not perform full verify() logic. You will want to run `verify()` from the jwt tools to verify the JWT is fully valid and not expired etc.
+
+- The expected audience is typically your app's domain -- it should be one of your valid redirectUri values from your Vincent app configuration
+
+- Returns: An object containing both the original JWT string and the decoded JWT object
+
+#### removeLoginJWTFromURI()
+
+Removes the login JWT parameter from the current URI. Call this after you have verified and stored the JWT for later usage.
+
+### Basic Usage
+
+```typescript
+import { getWebAuthClient } from '@lit-protocol/vincent-app-sdk/webaAthClient';
+import { isExpired } from '@lit-protocol/vincent-app-sdk/jwt';
+
+const vincentAppClient = getWebAuthClient({ appId: MY_APP_ID });
+// ... In your app logic:
+if (vincentAppClient.isLogin()) {
+  // Handle app logic for the user has just logged in
+  const { decoded, jwt } = vincentAppClient.decodeVincentLoginJWT(window.location.origin);
+  // Store `jwt` for later usage; the user is now logged in.
+} else {
+  // Handle app logic for the user is _already logged in_ (check for stored & unexpired JWT)
+
+  const jwt = localStorage.getItem('VINCENT_AUTH_JWT');
+  if (jwt && isExpired(jwt)) {
+    // User must re-log in
+    vincentAppClient.redirectToConsentPage({ redirectUri: window.location.href });
+  }
+
+  if (!jwt) {
+    // Handle app logic for the user is not yet logged in
+    vincentAppClient.redirectToConsentPage({ redirectUri: window.location.href });
+  }
+}
+```
+
+# Backend
+
+In your backend, you will have to verify the JWT to make sure the user has granted you the required permissions to act on their behalf.
+
+## VincentToolClient
+
+The Vincent Tool Client uses an ethers signer for your delegatee account to run Vincent Tools on behalf of your app users.
+
+This client will typically be used by an AI agent or your app backend service, as it requires a signer that conforms to the ethers v5 signer API, and with access to your delegatee account's private key to authenticate with the LIT network when executing the Vincent Tool.
+
+### Configuration
+
+```typescript
+interface VincentToolClientConfig {
+  ethersSigner: ethers.Signer; // An ethers v5 compatible signer
+  vincentToolCid: string; // The CID of the Vincent Tool to execute
+}
+```
+
+### Methods
+
+#### execute(params: VincentToolParams): Promise<ExecuteJsResponse>
+
+Executes a Vincent Tool with the provided parameters.
+
+- `params`: Record<string, unknown> - Parameters to pass to the Vincent Tool
+- Returns: Promise resolving to an ExecuteJsResponse from the LIT network
+
+### Tool execution
+
+```typescript
+import { getVincentToolClient } from '@lit-protocol/vincent-app-sdk/toolClient';
+// Import the tool you want to execute
+import { bundledVincentTool as erc20BundledTool } from '@lit-protocol/vincent-tool-erc20-approval';
+
+// One of delegatee signers from your app's Vincent Dashboard
+const delegateeSigner = new ethers.Wallet('YOUR_DELEGATEE_PRIVATE_KEY');
+
+// Initialize the Vincent Tool Client
+const toolClient = getVincentToolClient({
+  ethersSigner: delegateeSigner,
+  bundledVincentTool: erc20BundledTool,
+});
+const delegatorPkpEthAddress = '0x09182301238';
+
+const toolParams = {
+  // Fill with the params your tool needs
+};
+
+// Run precheck to see if tool should be executed
+const precheckResult = await client.precheck(toolParams, {
+  delegatorPkpEthAddress,
+});
+
+if (precheckResult.success === true) {
+  // Execute the Vincent Tool
+  const executeResult = await client.execute(toolParams, {
+    delegatorPkpEthAddress,
+  });
+
+  // ...tool has executed, you can check `executeResult` for details
+}
+```
+
+### Usage
+
+### Authentication
+
+A basic Express authentication middleware factory function is provided with the SDK.
+
+- Create an express middleware using `getAuthenticateUserExpressHandler()`
+- Once you have added the middleware to your route, use `authenticatedRequestHandler()` to provide
+  type-safe access to `req.user` in your downstream RequestHandler functions.
+- When defining your authenticated routes, use the `ExpressAuthHelpers` type to type your functions and function arguments.
+
+See getAuthenticateUserExpressHandler() documentation to see the source for the express authentication route handler
+
+```typescript
+import {
+  authenticatedRequestHandler,
+  getAuthenticateUserExpressHandler,
+} from '@lit-protocol/vincent-app-sdk/expressMiddleware';
+
+import type { AuthenticatedRequest } from '@lit-protocol/vincent-app-sdk/expressMiddleware';
+
+const { ALLOWED_AUDIENCE } = process.env;
+
+const authenticateUserMiddleware = getAuthenticateUserExpressHandler(ALLOWED_AUDIENCE);
+
+// Define an authenticated route handler
+const getUserProfile = async (req: AuthenticatedRequest, res: Response) => {
+  // Access authenticated user information
+  const { pkpAddress } = req.user;
+
+  // Fetch and return user data
+  const userData = await userRepository.findByAddress(pkpAddress);
+  res.json(userData);
+};
+
+// Use in Express route with authentication
+app.get('/profile', authenticateUser, authenticatedRequestHandler(getUserProfile));
+```
+
+## JWT Authentication
+
+### Overview
+
+The JWT authentication system in Vincent SDK allows for secure communication between user applications and Vincent Tools. JWTs are used to verify user consent and authorize tool executions.
+
+### Authentication Flow
+
+1. User initiates an action requiring Vincent Tool access
+2. Application redirects to the Vincent consent page using `VincentWebAppClient.redirectToConsentPage()`
+3. User provides consent for the requested tools/policies
+4. User is redirected back to the application with a JWT in the URL
+5. Application validates and stores the JWT using `VincentWebAppClient` methods
+6. JWT is used to authenticate with the app backend
+
+### JWT Structure
+
+Vincent JWTs contain:
+
+- User account identity information (pkpAddress and pkpPublicKey)
+- Expiration timestamp
+- Signature from the Vincent authorization service
+
+### Error Handling
+
+When JWT validation fails, descriptive error messages are thrown to help with troubleshooting.
+
+### Usage Notes
+
+- JWTs have an expiration time after which they are no longer valid
+- When a JWT expires, redirect the user to the consent page to obtain a new one using the `VincentWebAppClient`
+
+## Release
+
+Pre-requisites:
+
+- You will need a valid npm account with access to the `@lit-protocol` organization.
+- Run `pnpm vercel login` at sdk root to get a authentication token for vercel
+- Also you will need to fill the `.env` file with the vercel project and org ids for the [vincent-docs](https://vercel.com/lit-protocol/vincent-docs) project.
+
+Then run `pnpm release` on the repository root. It will prompt you to update the Vincent SDK version and then ask you to confirm the release.
+This process will also generate a `CHANGELOG.md` record with the changes for the release and update typedoc in vercel after publishing the SDK.

package/dist/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@lit-protocol/vincent-app-sdk",
+  "version": "1.0.2",
+  "description": "Vincent SDK for browser and backend",
+  "author": "Lit Protocol",
+  "license": "ISC",
+  "access": "public",
+  "packageManager": "pnpm@10.7.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^20.11.1",
+    "pnpm": "10.7.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    "./jwt": {
+      "import": "./dist/src/jwt/index.js",
+      "require": "./dist/src/jwt/index.js",
+      "types": "./dist/src/jwt/index.d.ts"
+    },
+    "./toolClient": {
+      "import": "./dist/src/toolClient/index.js",
+      "require": "./dist/src/toolClient/index.js",
+      "types": "./dist/src/toolClient/index.d.ts"
+    },
+    "./webAuthClient": {
+      "import": "./dist/src/webAuthClient/index.js",
+      "require": "./dist/src/webAuthClient/index.js",
+      "types": "./dist/src/webAuthClient/index.d.ts"
+    },
+    "./expressMiddleware": {
+      "import": "./dist/src/expressMiddleware/index.js",
+      "require": "./dist/src/expressMiddleware/index.js",
+      "types": "./dist/src/expressMiddleware/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/src/utils/index.js",
+      "require": "./dist/src/utils/index.js",
+      "types": "./dist/src/utils/index.d.ts"
+    }
+  },
+  "keywords": [
+    "jwt",
+    "authentication",
+    "sdk"
+  ],
+  "scripts": {
+    "type-tests": "./scripts/run-typecheck.sh",
+    "watch:type-tests": "chokidar 'src/**/*' --initial --await-write-finish --delay 100 --silent -c './scripts/run-typecheck.sh'",
+    "typecheck": "./scripts/precommit-check.sh"
+  },
+  "dependencies": {
+    "@lit-protocol/auth-helpers": "^7.0.9",
+    "@lit-protocol/constants": "^7.0.8",
+    "@lit-protocol/lit-node-client": "^7.0.8",
+    "@lit-protocol/vincent-contracts-sdk": "workspace:*",
+    "@lit-protocol/vincent-tool-sdk": "workspace:*",
+    "@noble/secp256k1": "^2.2.3",
+    "did-jwt": "^8.0.8",
+    "ethers": "5.8.0",
+    "tslib": "^2.8.1",
+    "zod": "3.25.64"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/**/*",
+    "*.md"
+  ],
+  "devDependencies": {
+    "@lit-protocol/pkp-ethers": "^7.2.0",
+    "@lit-protocol/types": "^7.0.8",
+    "@types/express": "^5.0.1",
+    "chokidar-cli": "^3.0.0",
+    "live-server": "^1.2.2",
+    "typedoc": "0.27.9",
+    "typedoc-material-theme": "1.3.0",
+    "typedoc-plugin-extras": "^4.0.0",
+    "typedoc-plugin-zod": "^1.4.1",
+    "vercel": "^41.6.2"
+  },
+  "types": "./src/index.d.ts",
+  "main": "./src/index.js",
+  "type": "commonjs"
+}

package/dist/src/expressMiddleware/express.d.ts

@@ -0,0 +1,63 @@
+import type { NextFunction, Request, Response } from 'express';
+import type { AuthenticatedRequestHandler } from './types';
+/** Returns an Express middleware function to authenticate a user using a JWT token, and a type-guard wrapper function
+ * for type-safe usage of route handlers guarded by the middleware.
+ *
+ * The `middleware()` function:
+ * - Checks the `Authorization` header for a Bearer token, verifies the token, and checks its audience.
+ * - If the token is valid, it attaches the user information (decoded JWT, and raw JWT string) to the request object
+ * - If the token is missing or invalid, it returns a 401 Unauthorized response with an error message.
+ *
+ * Designate what field on `req` should be set with the JWT with the `userKey` configuration option.
+ *
+ * The `handler()` function:
+ * - Provides a type-safe reference to `req` where the `userKey` you have provided is correctly inferred to the appropriate type
+ * - Note that it is still your responsibility to ensure you have attached the `middleware` somewhere in the chain before you use the `handler()`
+ *   - If you forget, the `handler()` function will throw an error if the expected `req[userKey]` does not exist.
+ *
+ * See [express.js documentation](https://expressjs.com/en/guide/writing-middleware.html) for details on writing your route handler
+ * @category API
+ *
+ * @example
+ * ```typescript
+ * import { createVincentUserMiddleware } from '@lit-protocol/vincent-app-sdk/expressMiddleware';
+ *
+ * // In your environment configuration
+ * const ALLOWED_AUDIENCE = 'https://yourapp.example.com';
+ * const VINCENT_APP_ID = 555; // Provided by the vincent app registry
+ *
+ * const { middleware, handler } = createVincentUserMiddleware({
+ *  allowedAudience: ALLOWED_AUDIENCE,
+ *  requiredAppId: VINCENT_APP_ID,
+ *  userKey: 'vincentUser',
+ * });
+ *
+ * // Apply to routes that require authentication; req is guaranteed authenticated because it is wrapped in `handler()`
+ * app.get('/protected-resource', middleware, handler((req, res) => {
+ *     // handler() gives you the correct inferred type of `req[userKey]`
+ *     const pkpAddress = req.vincentUser.decodedJWT.payload.pkp.ethAddress;
+ *     const appInfo = req.vincentUser.decodedJWT.payload.app;
+ *
+ *     if(appInfo) {
+ *       res.json({ message: `Hello, user with PKP address ${pkpAddress}. You are authenticated for app ${appInfo.id} @ v${appInfo.version}` });
+ *       return;
+ *     }
+ *
+ *     res.json({ message: `Hello, user with PKP address ${pkpAddress}.` });
+ *   })
+ * );
+ * ```
+ *
+ * See the code below for the implementation used by the `middleware` returned by this function. You can adapt this logic
+ * to the HTTP framework of your choice.
+ *
+ */
+export declare function createVincentUserMiddleware<const UserKey extends string>(config: {
+    allowedAudience: string;
+    userKey: UserKey;
+    requiredAppId: number | undefined;
+}): {
+    middleware: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+    handler: (handler: AuthenticatedRequestHandler<UserKey>) => (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+};
+//# sourceMappingURL=express.d.ts.map

package/dist/src/expressMiddleware/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/expressMiddleware/express.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,KAAK,EAAwB,2BAA2B,EAAkB,MAAM,SAAS,CAAC;AAwBjG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,CAAC,OAAO,SAAS,MAAM,EAAE,MAAM,EAAE;IAChF,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;sBA8BoB,OAAO,OAAO,QAAQ,QAAQ,YAAY;iEArBnD,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY;EAJ1D"}

package/dist/src/expressMiddleware/express.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVincentUserMiddleware = createVincentUserMiddleware;
+const jwt_1 = require("../jwt");
+const utils_1 = require("../jwt/core/utils");
+function assertAuthenticatedRequest(req, userKey) {
+    // @ts-expect-error It's an assertion
+    if (!(userKey in req) || typeof req[userKey] !== 'object' || !req[userKey]) {
+        throw new Error('Request is not an AuthenticatedRequest: Missing or invalid "user" property');
+    }
+    // Cast with a type assertion
+    const user = req[userKey];
+    const { decodedJWT, rawJWT } = user;
+    if (typeof rawJWT !== 'string' || !(0, utils_1.isDefinedObject)(decodedJWT)) {
+        throw new Error('Request is not an AuthenticatedRequest: Invalid "user" properties');
+    }
+}
+/** Returns an Express middleware function to authenticate a user using a JWT token, and a type-guard wrapper function
+ * for type-safe usage of route handlers guarded by the middleware.
+ *
+ * The `middleware()` function:
+ * - Checks the `Authorization` header for a Bearer token, verifies the token, and checks its audience.
+ * - If the token is valid, it attaches the user information (decoded JWT, and raw JWT string) to the request object
+ * - If the token is missing or invalid, it returns a 401 Unauthorized response with an error message.
+ *
+ * Designate what field on `req` should be set with the JWT with the `userKey` configuration option.
+ *
+ * The `handler()` function:
+ * - Provides a type-safe reference to `req` where the `userKey` you have provided is correctly inferred to the appropriate type
+ * - Note that it is still your responsibility to ensure you have attached the `middleware` somewhere in the chain before you use the `handler()`
+ *   - If you forget, the `handler()` function will throw an error if the expected `req[userKey]` does not exist.
+ *
+ * See [express.js documentation](https://expressjs.com/en/guide/writing-middleware.html) for details on writing your route handler
+ * @category API
+ *
+ * @example
+ * ```typescript
+ * import { createVincentUserMiddleware } from '@lit-protocol/vincent-app-sdk/expressMiddleware';
+ *
+ * // In your environment configuration
+ * const ALLOWED_AUDIENCE = 'https://yourapp.example.com';
+ * const VINCENT_APP_ID = 555; // Provided by the vincent app registry
+ *
+ * const { middleware, handler } = createVincentUserMiddleware({
+ *  allowedAudience: ALLOWED_AUDIENCE,
+ *  requiredAppId: VINCENT_APP_ID,
+ *  userKey: 'vincentUser',
+ * });
+ *
+ * // Apply to routes that require authentication; req is guaranteed authenticated because it is wrapped in `handler()`
+ * app.get('/protected-resource', middleware, handler((req, res) => {
+ *     // handler() gives you the correct inferred type of `req[userKey]`
+ *     const pkpAddress = req.vincentUser.decodedJWT.payload.pkp.ethAddress;
+ *     const appInfo = req.vincentUser.decodedJWT.payload.app;
+ *
+ *     if(appInfo) {
+ *       res.json({ message: `Hello, user with PKP address ${pkpAddress}. You are authenticated for app ${appInfo.id} @ v${appInfo.version}` });
+ *       return;
+ *     }
+ *
+ *     res.json({ message: `Hello, user with PKP address ${pkpAddress}.` });
+ *   })
+ * );
+ * ```
+ *
+ * See the code below for the implementation used by the `middleware` returned by this function. You can adapt this logic
+ * to the HTTP framework of your choice.
+ *
+ */
+function createVincentUserMiddleware(config) {
+    return {
+        middleware: getAuthenticateUserExpressHandler(config),
+        handler: authenticatedRequestHandler(config.userKey),
+    };
+}
+function authenticatedRequestHandler(userKey) {
+    return function (handler) {
+        return (req, res, next) => {
+            try {
+                assertAuthenticatedRequest(req, userKey);
+                return handler(req, res, next);
+            }
+            catch (_a) {
+                res.status(401).json({ error: 'Not authenticated' });
+            }
+        };
+    };
+}
+// #region expressHandlerTSDocExample
+function getAuthenticateUserExpressHandler({ allowedAudience, requiredAppId, userKey, }) {
+    return async (req, res, next) => {
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            res.status(401).json({ error: 'No token provided' });
+            return;
+        }
+        const parts = authHeader.split(' ');
+        if (parts.length !== 2) {
+            res.status(401).json({ error: `Invalid authorization header - expected "Bearer <token>"` });
+            return;
+        }
+        const [scheme, rawJWT] = parts;
+        if (!/^Bearer$/i.test(scheme)) {
+            res.status(401).json({ error: `Expected "Bearer" scheme, got "${scheme}"` });
+            return;
+        }
+        try {
+            const decodedJWT = (0, jwt_1.verify)({ jwt: rawJWT, expectedAudience: allowedAudience, requiredAppId });
+            if (!decodedJWT) {
+                res.status(401).json({ error: 'Invalid token' });
+                return;
+            }
+            req[userKey] = {
+                decodedJWT,
+                rawJWT,
+            };
+            next();
+        }
+        catch (e) {
+            res.status(401).json({ error: `Invalid token: ${e.message}` });
+        }
+    };
+}
+// #endregion expressHandlerTSDocExample
+//# sourceMappingURL=express.js.map

package/dist/src/expressMiddleware/express.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.js","sourceRoot":"","sources":["../../../src/expressMiddleware/express.ts"],"names":[],"mappings":"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"}

package/dist/src/expressMiddleware/index.d.ts

@@ -0,0 +1,14 @@
+/** Express middleware is used to add a VincentJWT-specific authentication to your Express.js server routes
+ *
+ * All functionality is encapsulated into a single factory function -- see {@link createVincentUserMiddleware} for details
+ *
+ * You can see the source for the Express authentication handler below; use this as a reference to implement
+ * your own midddleware/authentication for other frameworks! Pull requests are welcome.
+ * {@includeCode ./express.ts#expressHandlerTSDocExample}
+ *
+ * @packageDocumentation
+ * @module expressMiddleware
+ * */
+export { createVincentUserMiddleware } from './express';
+export type { AuthenticatedRequest, AuthenticatedRequestHandler, ExtractRequestHandlerParams, VincentJWTData, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/expressMiddleware/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expressMiddleware/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;KAUK;AAEL,OAAO,EAAE,2BAA2B,EAAE,MAAM,WAAW,CAAC;AAExD,YAAY,EACV,oBAAoB,EACpB,2BAA2B,EAC3B,2BAA2B,EAC3B,cAAc,GACf,MAAM,SAAS,CAAC"}

package/dist/src/expressMiddleware/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/** Express middleware is used to add a VincentJWT-specific authentication to your Express.js server routes
+ *
+ * All functionality is encapsulated into a single factory function -- see {@link createVincentUserMiddleware} for details
+ *
+ * You can see the source for the Express authentication handler below; use this as a reference to implement
+ * your own midddleware/authentication for other frameworks! Pull requests are welcome.
+ * {@includeCode ./express.ts#expressHandlerTSDocExample}
+ *
+ * @packageDocumentation
+ * @module expressMiddleware
+ * */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVincentUserMiddleware = void 0;
+var express_1 = require("./express");
+Object.defineProperty(exports, "createVincentUserMiddleware", { enumerable: true, get: function () { return express_1.createVincentUserMiddleware; } });
+//# sourceMappingURL=index.js.map

package/dist/src/expressMiddleware/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/expressMiddleware/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;KAUK;;;AAEL,qCAAwD;AAA/C,sHAAA,2BAA2B,OAAA"}

package/dist/src/expressMiddleware/types.d.ts

@@ -0,0 +1,31 @@
+import type { NextFunction, Request, RequestHandler, Response } from 'express';
+import type { VincentJWT } from '../jwt/types';
+/** Extract the params type from the original Express.js RequestHandler
+ *
+ * You probably don't need this type; see { @link createVincentUserMiddleware } for details
+ *
+ * @category Interfaces
+ * */
+export type ExtractRequestHandlerParams<T> = T extends RequestHandler<infer P, infer ResBody, infer ReqBody, infer ReqQuery, infer Locals> ? [P, ResBody, ReqBody, ReqQuery, Locals] : never;
+/**
+ * An Express.js RequestHandler that guarantees the request is authenticated with a PKP address
+ *
+ * You probably don't need this type; see { @link createVincentUserMiddleware } for details
+ *
+ * @category Interfaces
+ * */
+export type AuthenticatedRequestHandler<UserKey extends string, P = ExtractRequestHandlerParams<RequestHandler>[0], ResBody = ExtractRequestHandlerParams<RequestHandler>[1], ReqBody = ExtractRequestHandlerParams<RequestHandler>[2], ReqQuery = ExtractRequestHandlerParams<RequestHandler>[3], Locals extends Record<string, any> = ExtractRequestHandlerParams<RequestHandler>[4]> = (req: AuthenticatedRequest<UserKey, P, ResBody, ReqBody, ReqQuery>, res: Response<ResBody, Locals>, next: NextFunction) => void | Promise<void>;
+export interface VincentJWTData {
+    decodedJWT: VincentJWT;
+    rawJWT: string;
+}
+/** An interface that extends the Express.js Request interface to include authenticated user data
+ *
+ * You probably don't need this type; see { @link createVincentUserMiddleware } for details
+ *
+ * @category Interfaces
+ * */
+export type AuthenticatedRequest<UserKey extends string, P = any, ResBody = any, ReqBody = any, ReqQuery = any> = Request<P, ResBody, ReqBody, ReqQuery> & {
+    [K in UserKey]: VincentJWTData;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/expressMiddleware/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/expressMiddleware/types.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;KAKK;AACL,MAAM,MAAM,2BAA2B,CAAC,CAAC,IACvC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,OAAO,EAAE,MAAM,OAAO,EAAE,MAAM,QAAQ,EAAE,MAAM,MAAM,CAAC,GACzF,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,GACvC,KAAK,CAAC;AAEZ;;;;;;KAMK;AACL,MAAM,MAAM,2BAA2B,CACrC,OAAO,SAAS,MAAM,EACtB,CAAC,GAAG,2BAA2B,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EAClD,OAAO,GAAG,2BAA2B,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACxD,OAAO,GAAG,2BAA2B,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACxD,QAAQ,GAAG,2BAA2B,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,EACzD,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,2BAA2B,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IACjF,CACF,GAAG,EAAE,oBAAoB,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EACjE,GAAG,EAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,EAC9B,IAAI,EAAE,YAAY,KACf,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;KAKK;AACL,MAAM,MAAM,oBAAoB,CAC9B,OAAO,SAAS,MAAM,EACtB,CAAC,GAAG,GAAG,EACP,OAAO,GAAG,GAAG,EACb,OAAO,GAAG,GAAG,EACb,QAAQ,GAAG,GAAG,IACZ,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,GAAG;KAC1C,CAAC,IAAI,OAAO,GAAG,cAAc;CAC/B,CAAC"}

package/dist/src/expressMiddleware/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/expressMiddleware/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/expressMiddleware/types.ts"],"names":[],"mappings":""}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":""}

package/dist/src/internal/LitNodeClient/LitNodeClientInstance.d.ts

@@ -0,0 +1,14 @@
+import type { LIT_NETWORKS_KEYS } from '@lit-protocol/types';
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
+export declare class LitNodeClientInstance {
+    private readonly litNodeClientInstance;
+    private isConnected;
+    private connectHandle;
+    constructor({ network }: {
+        network: LIT_NETWORKS_KEYS;
+    });
+    connect(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    get litNodeClient(): LitNodeClient;
+}
+//# sourceMappingURL=LitNodeClientInstance.d.ts.map

package/dist/src/internal/LitNodeClient/LitNodeClientInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LitNodeClientInstance.d.ts","sourceRoot":"","sources":["../../../../src/internal/LitNodeClient/LitNodeClientInstance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAE9D,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgB;IAEtD,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO,CAAC,aAAa,CAAiC;gBAE1C,EAAE,OAAO,EAAE,EAAE;QAAE,OAAO,EAAE,iBAAiB,CAAA;KAAE;IAOjD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IA4B3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAqBjC,IAAI,aAAa,IAAI,aAAa,CAEjC;CACF"}