@lit-protocol/vincent-policy-contract-whitelist 0.0.1-ea

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 0.0.2 (2025-08-01)
+
+### 🧱 Updated Dependencies
+
+- Updated ability-sdk to 2.0.0
+- Updated app-sdk to 2.0.0

package/CONTRIBUTING.md

@@ -0,0 +1,86 @@
+# Contributing to Vincent Policy Contract Whitelist
+
+This document provides guidelines for contributing to the Vincent Policy Contract Whitelist project.
+
+## Overview
+
+<!-- TODO -->
+
+## Setup
+
+1. Follow the global setup instructions in the repository root [CONTRIBUTING.md](../../../CONTRIBUTING.md).
+2. Install dependencies:
+   ```bash
+   pnpm install
+   ```
+
+## Development Workflow
+
+### Testing
+
+Run tests:
+
+```bash
+nx test policy-contract-whitelist
+```
+
+### Building the Lit Action
+
+Build the policy:
+
+```bash
+nx action:build policy-contract-whitelist
+```
+
+### Deploying the Lit Action to IPFS
+
+Building will be done automatically. Deploy the policy:
+
+```bash
+nx action:deploy policy-contract-whitelist
+```
+
+## Project Structure
+
+- `src/`: Source code
+  - `index.ts`: Main entry point
+
+## Policy Development Guidelines
+
+1. Use the Vincent Ability SDK to create policies
+2. Define clear schemas for ability parameters and user parameters
+3. Implement the policy lifecycle methods (evaluate, commit)
+4. Handle errors gracefully
+5. Write comprehensive tests for all functionality
+6. Document the policy's purpose and usage
+
+## Integration with Abilities
+
+<!-- TODO -->
+
+## Testing
+
+Write unit tests for all functionality:
+
+```bash
+pnpm test
+```
+
+## Documentation
+
+- Document the policy's purpose and usage
+- Update README.md when adding new features
+- Document the policy's parameters and behavior
+
+## Pull Request Process
+
+1. Ensure your code follows the coding standards
+2. Update documentation if necessary
+3. Include tests for new functionality
+4. Link any related issues in your pull request description
+5. Request a review from a maintainer
+
+## Additional Resources
+
+- [Vincent Documentation](https://docs.heyvincent.ai/)
+- [Vincent Ability SDK Documentation](../../libs/ability-sdk/README.md)

package/README.md

@@ -0,0 +1,140 @@
+# Vincent Policy: Contract Whitelist
+
+## Overview
+
+The Contract Whitelist Policy is a Vincent Policy that restricts the signing of EVM transactions to a predefined whitelist of contract addresses and function selectors across multiple chains. This policy provides critical security controls for Vincent Agent Wallets by ensuring they can only interact with trusted contracts and approved functions.
+
+This Vincent Policy is designed to work with Vincent Abilities, particularly the [@lit-protocol/vincent-ability-evm-transaction-signer](../ability-evm-transaction-signer/) ability, to provide granular control over which transactions can be signed.
+
+## How It Works
+
+The Contract Whitelist Policy is built using the Vincent Policy SDK and validates transactions against a hierarchical whitelist. Here's how it operates:
+
+- **Input**: Receives a serialized EVM transaction from the ability
+- **Parsing**: Uses `ethers.utils.parseTransaction` to extract transaction details
+- **Extraction**: Gets the chain ID, target contract address, and function selector (first 4 bytes of `data` field)
+- **Validation**: Checks against the whitelist hierarchy
+  - **Whitelist Matching**: The policy checks in order:
+    - Is the chain ID whitelisted?
+    - Is the contract address whitelisted for that chain?
+    - Is the function selector allowed (either explicitly or via wildcard `*`)?
+
+## Example Configuration
+
+```typescript
+const policyConfig = {
+  whitelist: {
+    // Ethereum Mainnet
+    '1': {
+      // WETH Contract - Specific functions only
+      '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2': {
+        functionSelectors: [
+          '0xa9059cbb', // transfer(address,uint256)
+          '0x23b872dd', // transferFrom(address,address,uint256)
+        ],
+      },
+      // USDC Contract - Single function only
+      '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48': {
+        functionSelectors: [
+          '0xa9059cbb', // transfer(address,uint256)
+        ],
+      },
+    },
+    // Base Mainnet
+    '8453': {
+      // Base WETH - All functions allowed via wildcard
+      '0x4200000000000000000000000000000000000006': {
+        functionSelectors: ['*'], // Allow ALL functions for this contract
+      },
+      // Another contract with mixed approach
+      '0x1234567890123456789012345678901234567890': {
+        functionSelectors: [
+          '0xa9059cbb', // transfer(address,uint256) - explicitly allowed
+          '*', // Plus all other functions via wildcard
+        ],
+      },
+    },
+  },
+};
+```
+
+### Wildcard Support
+
+The policy supports using `'*'` as a wildcard to allow all functions for a specific contract:
+
+- **Specific selectors only**: `['0xa9059cbb', '0x23b872dd']` - Only these exact functions are allowed
+- **Wildcard only**: `['*']` - All functions are allowed for this contract
+- **Mixed approach**: `['0xa9059cbb', '*']` - All functions are allowed (wildcard takes precedence)
+
+**Security Note**: Use wildcards carefully! Only use `'*'` for contracts you fully trust, as it allows any function call to that contract.
+
+## Integration with Abilities
+
+The Contract Whitelist Policy is designed to work seamlessly with Vincent Abilities, particularly the [Transaction Signer Ability](../ability-evm-transaction-signer/README.md):
+
+```typescript
+import { createVincentAbilityPolicy } from '@lit-protocol/vincent-ability-sdk';
+import { bundledVincentPolicy } from '@lit-protocol/vincent-policy-contract-whitelist';
+
+const ContractWhitelistPolicy = createVincentAbilityPolicy({
+  abilityParamsSchema,
+  bundledVincentPolicy,
+  abilityParameterMappings: {
+    serializedTransaction: 'serializedTransaction',
+  },
+});
+```
+
+See the comprehensive E2E test in [contract-whitelist.spec.ts](../abilities-e2e/test-e2e/contract-whitelist.spec.ts) for a complete example of:
+
+- Setting up permissions and the Contract Whitelist Policy
+- Executing the Transaction Signer Ability
+- Validating the signed transaction
+- Broadcasting the signed transaction to the network
+
+## Output Schemas
+
+### Precheck/Evaluation Allow Result
+
+```typescript
+{
+  chainId: number; // The validated chain ID
+  contractAddress: string; // The validated contract address
+  functionSelector: string; // The validated function selector
+  wildcardUsed: boolean; // Whether the wildcard "*" was used to allow this function
+}
+```
+
+The `wildcardUsed` property indicates whether the transaction was allowed through the wildcard (`'*'`) or through an explicit function selector:
+
+- `true`: The function was allowed via wildcard (function selector not explicitly listed)
+- `false`: The function was explicitly whitelisted (even if wildcard is also present)
+
+This information is valuable for auditing and security monitoring purposes.
+
+### Precheck/Evaluation Deny Result
+
+```typescript
+{
+  reason: string;                    // Why the transaction was denied
+  chainId?: number;                  // The chain ID (if available)
+  contractAddress?: string;          // The contract address (if available)
+  functionSelector?: string;         // The function selector (if available)
+}
+```
+
+## Building
+
+Run `pnpx nx build policy-contract-whitelist` to build the library.
+
+## Running E2E tests
+
+Run `pnpx nx run abilities-e2e:test-e2e packages/apps/abilities-e2e/test-e2e/contract-whitelist.spec.ts` to execute the E2E tests via [Jest](https://jestjs.io).
+
+## Contributing
+
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines on how to contribute to this project.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

package/dist/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@lit-protocol/vincent-policy-contract-whitelist",
+  "version": "0.0.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@lit-protocol/vincent-ability-sdk": "workspace:*",
+    "ethers": "^5.8.0",
+    "tslib": "2.8.1",
+    "zod": "^3.25.64"
+  },
+  "peerDependencies": {
+    "@lit-protocol/vincent-app-sdk": "workspace:^"
+  },
+  "devDependencies": {
+    "esbuild": "^0.19.12",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "ipfs-only-hash": "^4.0.0"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/**",
+    "*.md"
+  ],
+  "type": "commonjs"
+}

package/dist/src/generated/vincent-bundled-policy.d.ts

@@ -0,0 +1,191 @@
+/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ */
+export declare const bundledVincentPolicy: import("@lit-protocol/vincent-ability-sdk").BundledVincentPolicy<import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").VincentPolicy<"@lit-protocol/vincent-policy-contract-whitelist", import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>, import("zod").ZodUndefined, import("zod").ZodUndefined, import("zod").ZodUndefined, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>>, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>>, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").CommitLifecycleFunction<import("zod").ZodUndefined, import("zod").ZodUndefined, import("zod").ZodUndefined>>, string>;
+//# sourceMappingURL=vincent-bundled-policy.d.ts.map

package/dist/src/generated/vincent-bundled-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vincent-bundled-policy.d.ts","sourceRoot":"","sources":["../../../src/generated/vincent-bundled-policy.ts"],"names":[],"mappings":"AAAA;;GAEG;AAUH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sMAA0D,CAAC"}

package/dist/src/generated/vincent-bundled-policy.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundledVincentPolicy = void 0;
+const tslib_1 = require("tslib");
+const vincent_ability_sdk_1 = require("@lit-protocol/vincent-ability-sdk");
+const vincent_policy_1 = require("../lib/vincent-policy");
+const vincent_policy_metadata_json_1 = tslib_1.__importDefault(require("./vincent-policy-metadata.json"));
+if (!vincent_policy_metadata_json_1.default.ipfsCid) {
+    throw new Error('ipfsCid is not defined in metadata JSON file');
+}
+exports.bundledVincentPolicy = (0, vincent_ability_sdk_1.asBundledVincentPolicy)(vincent_policy_1.vincentPolicy, vincent_policy_metadata_json_1.default.ipfsCid);
+//# sourceMappingURL=vincent-bundled-policy.js.map

package/dist/src/generated/vincent-bundled-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vincent-bundled-policy.js","sourceRoot":"","sources":["../../../src/generated/vincent-bundled-policy.ts"],"names":[],"mappings":";AAAA;;GAEG;;;;AAEH,2EAA2E;AAC3E,0DAAsD;AACtD,0GAAsD;AAEtD,IAAG,CAAC,sCAAQ,CAAC,OAAO,EAAE,CAAC;IACrB,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;AAClE,CAAC;AAEY,QAAA,oBAAoB,GAAG,IAAA,4CAAsB,EAAC,8BAAa,EAAE,sCAAQ,CAAC,OAAO,CAAC,CAAC"}

package/dist/src/generated/vincent-policy-metadata.json

@@ -0,0 +1,3 @@
+{
+    "ipfsCid": "QmW45uW3wcTR6kAj6Fu1EScZpaV29jcDRVeQ4QKpKzR84G"
+}

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { bundledVincentPolicy } from './generated/vincent-bundled-policy';
+import * as vincentPolicyMetadata from './generated/vincent-policy-metadata.json';
+export { vincentPolicyMetadata };
+//# 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":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,qBAAqB,MAAM,0CAA0C,CAAC;AAElF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vincentPolicyMetadata = exports.bundledVincentPolicy = void 0;
+const tslib_1 = require("tslib");
+var vincent_bundled_policy_1 = require("./generated/vincent-bundled-policy");
+Object.defineProperty(exports, "bundledVincentPolicy", { enumerable: true, get: function () { return vincent_bundled_policy_1.bundledVincentPolicy; } });
+const vincentPolicyMetadata = tslib_1.__importStar(require("./generated/vincent-policy-metadata.json"));
+exports.vincentPolicyMetadata = vincentPolicyMetadata;
+//# 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":";;;;AAAA,6EAA0E;AAAjE,8HAAA,oBAAoB,OAAA;AAC7B,wGAAkF;AAEzE,sDAAqB"}

package/dist/src/lib/lit-action.d.ts

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

package/dist/src/lib/lit-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-action.d.ts","sourceRoot":"","sources":["../../../src/lib/lit-action.ts"],"names":[],"mappings":""}

package/dist/src/lib/lit-action.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vincent_ability_sdk_1 = require("@lit-protocol/vincent-ability-sdk");
+const vincent_policy_1 = require("./vincent-policy");
+(async () => {
+    return await (0, vincent_ability_sdk_1.vincentPolicyHandler)({
+        vincentPolicy: vincent_policy_1.vincentPolicy,
+        context,
+        abilityParams,
+    });
+})();
+//# sourceMappingURL=lit-action.js.map

package/dist/src/lib/lit-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit-action.js","sourceRoot":"","sources":["../../../src/lib/lit-action.ts"],"names":[],"mappings":";;AAAA,2EAAyE;AAEzE,qDAAiD;AAUjD,CAAC,KAAK,IAAI,EAAE;IACV,OAAO,MAAM,IAAA,0CAAoB,EAAC;QAChC,aAAa,EAAE,8BAAa;QAC5B,OAAO;QACP,aAAa;KACd,CAAC,CAAC;AACL,CAAC,CAAC,EAAE,CAAC"}

package/dist/src/lib/schemas.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export declare const abilityParamsSchema: z.ZodObject<{
+    serializedTransaction: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>;
+export declare const userParamsSchema: z.ZodObject<{
+    whitelist: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        functionSelectors: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>;
+export declare const precheckAllowResultSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    contractAddress: z.ZodString;
+    functionSelector: z.ZodString;
+    wildcardUsed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>;
+export declare const precheckDenyResultSchema: z.ZodObject<{
+    reason: z.ZodString;
+    chainId: z.ZodOptional<z.ZodNumber>;
+    contractAddress: z.ZodOptional<z.ZodString>;
+    functionSelector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>;
+export declare const evalAllowResultSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    contractAddress: z.ZodString;
+    functionSelector: z.ZodString;
+    wildcardUsed: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>;
+export declare const evalDenyResultSchema: z.ZodObject<{
+    reason: z.ZodString;
+    chainId: z.ZodOptional<z.ZodNumber>;
+    contractAddress: z.ZodOptional<z.ZodString>;
+    functionSelector: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/src/lib/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;EAI9B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAU3B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;EASpC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;EAcnC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAShC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAc/B,CAAC"}

package/dist/src/lib/schemas.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalDenyResultSchema = exports.evalAllowResultSchema = exports.precheckDenyResultSchema = exports.precheckAllowResultSchema = exports.userParamsSchema = exports.abilityParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.abilityParamsSchema = zod_1.z.object({
+    serializedTransaction: zod_1.z
+        .string()
+        .describe('The serialized transaction to be evaluated and signed'),
+});
+exports.userParamsSchema = zod_1.z.object({
+    whitelist: zod_1.z.record(zod_1.z.string(), // chainId
+    zod_1.z.record(zod_1.z.string(), // contract address
+    zod_1.z.object({
+        functionSelectors: zod_1.z.array(zod_1.z.string()),
+    }))),
+});
+exports.precheckAllowResultSchema = zod_1.z.object({
+    chainId: zod_1.z.number().describe('The chain ID the serialized transaction is being sent to'),
+    contractAddress: zod_1.z
+        .string()
+        .describe('The contract address the serialized transaction is being sent to'),
+    functionSelector: zod_1.z.string().describe('The function selector of the serialized transaction'),
+    wildcardUsed: zod_1.z
+        .boolean()
+        .describe('Whether the wildcard "*" was used to allow this function selector'),
+});
+exports.precheckDenyResultSchema = zod_1.z.object({
+    reason: zod_1.z.string().describe('The reason for denying the precheck.'),
+    chainId: zod_1.z
+        .number()
+        .describe('The chain ID the serialized transaction is being sent to')
+        .optional(),
+    contractAddress: zod_1.z
+        .string()
+        .describe('The contract address the serialized transaction is being sent to')
+        .optional(),
+    functionSelector: zod_1.z
+        .string()
+        .describe('The function selector of the serialized transaction')
+        .optional(),
+});
+exports.evalAllowResultSchema = zod_1.z.object({
+    chainId: zod_1.z.number().describe('The chain ID the serialized transaction is being sent to'),
+    contractAddress: zod_1.z
+        .string()
+        .describe('The contract address the serialized transaction is being sent to'),
+    functionSelector: zod_1.z.string().describe('The function selector of the serialized transaction'),
+    wildcardUsed: zod_1.z
+        .boolean()
+        .describe('Whether the wildcard "*" was used to allow this function selector'),
+});
+exports.evalDenyResultSchema = zod_1.z.object({
+    reason: zod_1.z.string().describe('The reason for denying the evaluation.'),
+    chainId: zod_1.z
+        .number()
+        .describe('The chain ID the serialized transaction is being sent to')
+        .optional(),
+    contractAddress: zod_1.z
+        .string()
+        .describe('The contract address the serialized transaction is being sent to')
+        .optional(),
+    functionSelector: zod_1.z
+        .string()
+        .describe('The function selector of the serialized transaction')
+        .optional(),
+});
+//# sourceMappingURL=schemas.js.map

package/dist/src/lib/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../src/lib/schemas.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAEX,QAAA,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,qBAAqB,EAAE,OAAC;SACrB,MAAM,EAAE;SACR,QAAQ,CAAC,uDAAuD,CAAC;CACrE,CAAC,CAAC;AAEU,QAAA,gBAAgB,GAAG,OAAC,CAAC,MAAM,CAAC;IACvC,SAAS,EAAE,OAAC,CAAC,MAAM,CACjB,OAAC,CAAC,MAAM,EAAE,EAAE,UAAU;IACtB,OAAC,CAAC,MAAM,CACN,OAAC,CAAC,MAAM,EAAE,EAAE,mBAAmB;IAC/B,OAAC,CAAC,MAAM,CAAC;QACP,iBAAiB,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;KACvC,CAAC,CACH,CACF;CACF,CAAC,CAAC;AAEU,QAAA,yBAAyB,GAAG,OAAC,CAAC,MAAM,CAAC;IAChD,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0DAA0D,CAAC;IACxF,eAAe,EAAE,OAAC;SACf,MAAM,EAAE;SACR,QAAQ,CAAC,kEAAkE,CAAC;IAC/E,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qDAAqD,CAAC;IAC5F,YAAY,EAAE,OAAC;SACZ,OAAO,EAAE;SACT,QAAQ,CAAC,mEAAmE,CAAC;CACjF,CAAC,CAAC;AAEU,QAAA,wBAAwB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC/C,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,sCAAsC,CAAC;IACnE,OAAO,EAAE,OAAC;SACP,MAAM,EAAE;SACR,QAAQ,CAAC,0DAA0D,CAAC;SACpE,QAAQ,EAAE;IACb,eAAe,EAAE,OAAC;SACf,MAAM,EAAE;SACR,QAAQ,CAAC,kEAAkE,CAAC;SAC5E,QAAQ,EAAE;IACb,gBAAgB,EAAE,OAAC;SAChB,MAAM,EAAE;SACR,QAAQ,CAAC,qDAAqD,CAAC;SAC/D,QAAQ,EAAE;CACd,CAAC,CAAC;AAEU,QAAA,qBAAqB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC5C,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,0DAA0D,CAAC;IACxF,eAAe,EAAE,OAAC;SACf,MAAM,EAAE;SACR,QAAQ,CAAC,kEAAkE,CAAC;IAC/E,gBAAgB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,qDAAqD,CAAC;IAC5F,YAAY,EAAE,OAAC;SACZ,OAAO,EAAE;SACT,QAAQ,CAAC,mEAAmE,CAAC;CACjF,CAAC,CAAC;AAEU,QAAA,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,wCAAwC,CAAC;IACrE,OAAO,EAAE,OAAC;SACP,MAAM,EAAE;SACR,QAAQ,CAAC,0DAA0D,CAAC;SACpE,QAAQ,EAAE;IACb,eAAe,EAAE,OAAC;SACf,MAAM,EAAE;SACR,QAAQ,CAAC,kEAAkE,CAAC;SAC5E,QAAQ,EAAE;IACb,gBAAgB,EAAE,OAAC;SAChB,MAAM,EAAE;SACR,QAAQ,CAAC,qDAAqD,CAAC;SAC/D,QAAQ,EAAE;CACd,CAAC,CAAC"}

package/dist/src/lib/vincent-policy.d.ts

@@ -0,0 +1,188 @@
+export declare const vincentPolicy: import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").VincentPolicy<"@lit-protocol/vincent-policy-contract-whitelist", import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>, import("zod").ZodUndefined, import("zod").ZodUndefined, import("zod").ZodUndefined, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>>, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    serializedTransaction: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    serializedTransaction: string;
+}, {
+    serializedTransaction: string;
+}>, import("zod").ZodObject<{
+    whitelist: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        functionSelectors: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        functionSelectors: string[];
+    }, {
+        functionSelectors: string[];
+    }>>>;
+}, "strip", import("zod").ZodTypeAny, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}, {
+    whitelist: Record<string, Record<string, {
+        functionSelectors: string[];
+    }>>;
+}>, import("zod").ZodObject<{
+    chainId: import("zod").ZodNumber;
+    contractAddress: import("zod").ZodString;
+    functionSelector: import("zod").ZodString;
+    wildcardUsed: import("zod").ZodBoolean;
+}, "strip", import("zod").ZodTypeAny, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}, {
+    chainId: number;
+    contractAddress: string;
+    functionSelector: string;
+    wildcardUsed: boolean;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    chainId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    contractAddress: import("zod").ZodOptional<import("zod").ZodString>;
+    functionSelector: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}, {
+    reason: string;
+    chainId?: number | undefined;
+    contractAddress?: string | undefined;
+    functionSelector?: string | undefined;
+}>>, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").CommitLifecycleFunction<import("zod").ZodUndefined, import("zod").ZodUndefined, import("zod").ZodUndefined>>;
+//# sourceMappingURL=vincent-policy.d.ts.map

package/dist/src/lib/vincent-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vincent-policy.d.ts","sourceRoot":"","sources":["../../../src/lib/vincent-policy.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6LAoIxB,CAAC"}

package/dist/src/lib/vincent-policy.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vincentPolicy = void 0;
+const vincent_ability_sdk_1 = require("@lit-protocol/vincent-ability-sdk");
+const ethers_1 = require("ethers");
+const schemas_1 = require("./schemas");
+exports.vincentPolicy = (0, vincent_ability_sdk_1.createVincentPolicy)({
+    packageName: '@lit-protocol/vincent-policy-contract-whitelist',
+    abilityParamsSchema: schemas_1.abilityParamsSchema,
+    userParamsSchema: schemas_1.userParamsSchema,
+    precheckAllowResultSchema: schemas_1.precheckAllowResultSchema,
+    precheckDenyResultSchema: schemas_1.precheckDenyResultSchema,
+    evalAllowResultSchema: schemas_1.evalAllowResultSchema,
+    evalDenyResultSchema: schemas_1.evalDenyResultSchema,
+    precheck: async ({ abilityParams, userParams }, { allow, deny }) => {
+        try {
+            const { serializedTransaction } = abilityParams;
+            const { whitelist } = userParams;
+            const transaction = ethers_1.ethers.utils.parseTransaction(serializedTransaction);
+            const { chainId, to: contractAddress, data } = transaction;
+            const functionSelector = data.slice(0, 10);
+            if (!contractAddress) {
+                return deny({
+                    reason: 'to property of serialized transaction not provided',
+                });
+            }
+            const chainWhitelist = whitelist[chainId];
+            if (!chainWhitelist) {
+                return deny({
+                    reason: 'Chain ID not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            const functionWhitelist = chainWhitelist[contractAddress];
+            if (!functionWhitelist) {
+                return deny({
+                    reason: 'Function selector not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            const hasSpecificSelector = functionWhitelist.functionSelectors.includes(functionSelector);
+            const hasWildcard = functionWhitelist.functionSelectors.includes('*');
+            if (!hasSpecificSelector && !hasWildcard) {
+                return deny({
+                    reason: 'Function selector not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            return allow({
+                chainId,
+                contractAddress,
+                functionSelector,
+                wildcardUsed: hasWildcard && !hasSpecificSelector,
+            });
+        }
+        catch (error) {
+            console.error('Precheck error:', error);
+            return deny({
+                reason: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    },
+    evaluate: async ({ abilityParams, userParams }, { allow, deny }) => {
+        try {
+            const { serializedTransaction } = abilityParams;
+            const { whitelist } = userParams;
+            const transaction = ethers_1.ethers.utils.parseTransaction(serializedTransaction);
+            const { chainId, to: contractAddress, data } = transaction;
+            const functionSelector = data.slice(0, 10);
+            if (!contractAddress) {
+                return deny({
+                    reason: 'to property of serialized transaction not provided',
+                });
+            }
+            const chainWhitelist = whitelist[chainId];
+            if (!chainWhitelist) {
+                return deny({
+                    reason: 'Chain ID not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            const functionWhitelist = chainWhitelist[contractAddress];
+            if (!functionWhitelist) {
+                return deny({
+                    reason: 'Function selector not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            const hasSpecificSelector = functionWhitelist.functionSelectors.includes(functionSelector);
+            const hasWildcard = functionWhitelist.functionSelectors.includes('*');
+            if (!hasSpecificSelector && !hasWildcard) {
+                return deny({
+                    reason: 'Function selector not whitelisted',
+                    chainId,
+                    contractAddress,
+                    functionSelector,
+                });
+            }
+            return allow({
+                chainId,
+                contractAddress,
+                functionSelector,
+                wildcardUsed: hasWildcard && !hasSpecificSelector,
+            });
+        }
+        catch (error) {
+            console.error('Precheck error:', error);
+            return deny({
+                reason: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    },
+});
+//# sourceMappingURL=vincent-policy.js.map

package/dist/src/lib/vincent-policy.js.map

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

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@lit-protocol/vincent-policy-contract-whitelist",
+  "version": "0.0.1-ea",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "ethers": "^5.8.0",
+    "tslib": "2.8.1",
+    "zod": "^3.25.64",
+    "@lit-protocol/vincent-ability-sdk": "2.0.0"
+  },
+  "peerDependencies": {
+    "@lit-protocol/vincent-app-sdk": "^2.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.19.12",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "ipfs-only-hash": "^4.0.0"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "files": [
+    "dist/**",
+    "*.md"
+  ]
+}