@lit-protocol/vincent-policy-spending-limit 1.0.0-1

package/dist/src/lib/policy-helpers/send-spend-tx.d.ts

@@ -0,0 +1,9 @@
+export declare const sendSpendTx: ({ appId, amountSpentUsd, maxSpendingLimitInUsd, spendingLimitDuration, pkpEthAddress, pkpPubKey, }: {
+    appId: number;
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+    spendingLimitDuration: number;
+    pkpEthAddress: string;
+    pkpPubKey: string;
+}) => Promise<any>;
+//# sourceMappingURL=send-spend-tx.d.ts.map

package/dist/src/lib/policy-helpers/send-spend-tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"send-spend-tx.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/send-spend-tx.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,WAAW,GAAU,oGAO/B;IACD,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB,iBAqGA,CAAC"}

package/dist/src/lib/policy-helpers/send-spend-tx.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSpendTx = void 0;
+const ethers_1 = require("ethers");
+const spending_limit_contract_1 = require("./spending-limit-contract");
+const sign_tx_1 = require("./sign-tx");
+const sendSpendTx = async ({ appId, amountSpentUsd, maxSpendingLimitInUsd, spendingLimitDuration, pkpEthAddress, pkpPubKey, }) => {
+    const spendingLimitContract = (0, spending_limit_contract_1.getSpendingLimitContractInstance)();
+    const buildPartialSpendTxResponse = await Lit.Actions.runOnce({ waitForResponse: true, name: 'send spend tx gas estimation' }, async () => {
+        console.log(`Preparing transaction to send to Spending Limit Contract: ${spending_limit_contract_1.SPENDING_LIMIT_CONTRACT_ADDRESS} (sendSpendTx)`);
+        try {
+            console.log(`Estimating gas for spending limit transaction...`);
+            // Get current gas price and nonce
+            const [feeData, nonce] = await Promise.all([
+                spendingLimitContract.provider.getFeeData(),
+                spendingLimitContract.provider.getTransactionCount(pkpEthAddress),
+            ]);
+            // Encode function data
+            const txData = spendingLimitContract.interface.encodeFunctionData('spend', [
+                BigInt(appId),
+                BigInt(amountSpentUsd),
+                BigInt(maxSpendingLimitInUsd),
+                BigInt(spendingLimitDuration),
+            ]);
+            // Estimate gas
+            const estimatedGas = await spendingLimitContract.estimateGas.spend(BigInt(appId), BigInt(amountSpentUsd), BigInt(maxSpendingLimitInUsd), BigInt(spendingLimitDuration), { from: pkpEthAddress });
+            console.log('fetching nonce for pkpEthAddress: ', pkpEthAddress, ' (sendSpendTx)');
+            return JSON.stringify({
+                status: 'success',
+                data: txData,
+                gasLimit: estimatedGas.toString(),
+                maxFeePerGas: feeData.maxFeePerGas?.toString() || '0',
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas?.toString() || '0',
+                nonce: nonce.toString(),
+            });
+        }
+        catch (error) {
+            return attemptToDecodeSpendLimitExceededError(error, spendingLimitContract);
+        }
+    });
+    const parsedBuildPartialSpendTxResponse = JSON.parse(buildPartialSpendTxResponse);
+    if (parsedBuildPartialSpendTxResponse.status === 'error') {
+        throw new Error(`Error estimating gas for spending limit transaction: ${parsedBuildPartialSpendTxResponse.error}`);
+    }
+    const { gasLimit, maxFeePerGas, maxPriorityFeePerGas, nonce, data } = parsedBuildPartialSpendTxResponse;
+    // Create ethers Transaction object
+    const unsignedSpendTx = {
+        to: spending_limit_contract_1.SPENDING_LIMIT_CONTRACT_ADDRESS,
+        data: data,
+        value: ethers_1.ethers.BigNumber.from(0),
+        gasLimit: ethers_1.ethers.BigNumber.from(gasLimit),
+        maxFeePerGas: ethers_1.ethers.BigNumber.from(maxFeePerGas),
+        maxPriorityFeePerGas: ethers_1.ethers.BigNumber.from(maxPriorityFeePerGas),
+        nonce: Number(nonce),
+        chainId: 175188,
+        type: 2, // EIP-1559 transaction type
+    };
+    console.log(`Signing spend transaction: ${safeStringify(unsignedSpendTx)} (sendSpendTx)`);
+    const signedSpendTx = await (0, sign_tx_1.signTx)(pkpPubKey, unsignedSpendTx, 'spendingLimitSig');
+    console.log(`Broadcasting spend transaction...`);
+    const spendTxResponse = await Lit.Actions.runOnce({ waitForResponse: true, name: 'spendTxSender' }, async () => {
+        try {
+            const txResponse = await spendingLimitContract.provider.sendTransaction(signedSpendTx);
+            return JSON.stringify({
+                status: 'success',
+                txHash: txResponse.hash,
+            });
+        }
+        catch (error) {
+            return attemptToDecodeSpendLimitExceededError(error, spendingLimitContract);
+        }
+    });
+    console.log(`Spend transaction response: ${spendTxResponse} (sendSpendTx)`);
+    const parsedSpendTxResponse = JSON.parse(spendTxResponse);
+    if (parsedSpendTxResponse.status === 'error') {
+        throw new Error(`Error sending spend transaction: ${parsedSpendTxResponse.error}`);
+    }
+    return parsedSpendTxResponse.txHash;
+};
+exports.sendSpendTx = sendSpendTx;
+const safeStringify = (obj) => {
+    return JSON.stringify(obj, (_, value) => {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (ethers_1.ethers.BigNumber.isBigNumber(value)) {
+            return value.toString();
+        }
+        return value;
+    });
+};
+const attemptToDecodeSpendLimitExceededError = (error, contract) => {
+    try {
+        // Check if it's an ethers revert error with data
+        if (error && typeof error === 'object' && 'reason' in error) {
+            const ethersError = error;
+            // Try to decode custom error from error data
+            if (ethersError.data) {
+                try {
+                    const decoded = contract.interface.parseError(ethersError.data);
+                    if (decoded.name === 'SpendLimitExceeded' && decoded.args) {
+                        const [user, appId, amount, limit] = decoded.args;
+                        return JSON.stringify({
+                            status: 'error',
+                            error: `Spending limit exceeded. User: ${user}, App ID: ${appId.toString()}, Attempted spend amount: ${amount.toString()}, Daily spend limit: ${limit.toString()}`,
+                        });
+                    }
+                }
+                catch (parseError) {
+                    // If parsing fails, fall through to generic error handling
+                }
+            }
+            // Handle standard revert with reason string
+            if (ethersError.reason) {
+                return JSON.stringify({
+                    status: 'error',
+                    error: `Contract reverted: ${ethersError.reason}`,
+                });
+            }
+        }
+        // Handle ethers CALL_EXCEPTION errors
+        if (error && typeof error === 'object' && 'code' in error) {
+            const ethersError = error;
+            if (ethersError.code === 'CALL_EXCEPTION' && ethersError.errorArgs) {
+                const [user, appId, amount, limit] = ethersError.errorArgs;
+                return JSON.stringify({
+                    status: 'error',
+                    error: `Spending limit exceeded. User: ${user}, App ID: ${appId.toString()}, Attempted spend amount: ${amount.toString()}, Daily spend limit: ${limit.toString()}`,
+                });
+            }
+        }
+    }
+    catch (decodingError) {
+        return JSON.stringify({
+            status: 'error',
+            error: `Failed to decode revert reason: ${decodingError}`,
+        });
+    }
+    return JSON.stringify({
+        status: 'error',
+        error: error?.toString() || 'Unknown error',
+    });
+};

package/dist/src/lib/policy-helpers/sign-tx.d.ts

@@ -0,0 +1,3 @@
+import { ethers } from 'ethers';
+export declare const signTx: (pkpPublicKey: string, tx: ethers.Transaction, sigName: string) => Promise<string>;
+//# sourceMappingURL=sign-tx.d.ts.map

package/dist/src/lib/policy-helpers/sign-tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sign-tx.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/sign-tx.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAYhC,eAAO,MAAM,MAAM,GAAU,cAAc,MAAM,EAAE,IAAI,MAAM,CAAC,WAAW,EAAE,SAAS,MAAM,oBA2BzF,CAAC"}

package/dist/src/lib/policy-helpers/sign-tx.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signTx = void 0;
+const ethers_1 = require("ethers");
+const signTx = async (pkpPublicKey, tx, sigName) => {
+    // Remove 0x prefix if it exists, Lit expects a hex string without 0x prefix
+    const publicKeyForLit = pkpPublicKey.replace(/^0x/, '');
+    console.log(`Signing using PKP Public Key: ${publicKeyForLit} (signTx)`);
+    const unsignedSerializedTx = ethers_1.ethers.utils.serializeTransaction(tx);
+    const txHash = ethers_1.ethers.utils.keccak256(unsignedSerializedTx);
+    console.log('Tx hash (signTx)', txHash);
+    const signatureResponse = await Lit.Actions.signAndCombineEcdsa({
+        toSign: ethers_1.ethers.utils.arrayify(txHash),
+        publicKey: publicKeyForLit,
+        sigName,
+    });
+    const { r, s, v } = JSON.parse(signatureResponse);
+    const ethersJoinedSignature = ethers_1.ethers.utils.joinSignature({
+        r: '0x' + r.substring(2),
+        s: '0x' + s,
+        v: v,
+    });
+    const signedSerializedTx = ethers_1.ethers.utils.serializeTransaction(tx, ethersJoinedSignature);
+    console.log('Signed serialized tx (signTx)', signedSerializedTx);
+    return signedSerializedTx;
+};
+exports.signTx = signTx;

package/dist/src/lib/policy-helpers/spending-limit-contract.d.ts

@@ -0,0 +1,4 @@
+import { ethers } from 'ethers';
+export declare const SPENDING_LIMIT_CONTRACT_ADDRESS = "0x756fa449de893446b26e10c6c66e62ccabee908c";
+export declare const getSpendingLimitContractInstance: () => ethers.Contract;
+//# sourceMappingURL=spending-limit-contract.d.ts.map

package/dist/src/lib/policy-helpers/spending-limit-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spending-limit-contract.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/spending-limit-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAkBhC,eAAO,MAAM,+BAA+B,+CAA+C,CAAC;AAE5F,eAAO,MAAM,gCAAgC,uBAM5C,CAAC"}

package/dist/src/lib/policy-helpers/spending-limit-contract.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpendingLimitContractInstance = exports.SPENDING_LIMIT_CONTRACT_ADDRESS = void 0;
+const ethers_1 = require("ethers");
+const SPENDING_LIMIT_CONTRACT_ABI = [
+    'event Spent(address indexed spender, uint256 indexed appId, uint256 amount, uint256 timestamp)',
+    'error EmptyAppIdsArray(address user)',
+    'error SpendLimitExceeded(address user, uint256 appId, uint256 amount, uint256 limit)',
+    'error ZeroAppIdNotAllowed(address user)',
+    'error ZeroDurationQuery(address user)',
+    'function checkLimit(address user, uint256 appId, uint256 amountToSpend, uint256 userMaxSpendLimit, uint256 duration) view returns (bool)',
+    'function getAppSpendHistory(address user, uint256 appId, uint256 duration) view returns ((uint256 timestamp, uint256 runningSpend)[] history)',
+    'function getAppsSpentInDuration(address user, uint256[] appIds, uint256 duration) view returns (uint256)',
+    'function getTotalSpent(address user, uint256 duration) view returns (uint256)',
+    'function spend(uint256 appId, uint256 amount, uint256 userMaxSpendLimit, uint256 duration)',
+];
+exports.SPENDING_LIMIT_CONTRACT_ADDRESS = '0x756fa449de893446b26e10c6c66e62ccabee908c';
+const getSpendingLimitContractInstance = () => {
+    return new ethers_1.ethers.Contract(exports.SPENDING_LIMIT_CONTRACT_ADDRESS, SPENDING_LIMIT_CONTRACT_ABI, new ethers_1.ethers.providers.StaticJsonRpcProvider('https://yellowstone-rpc.litprotocol.com/'));
+};
+exports.getSpendingLimitContractInstance = getSpendingLimitContractInstance;

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

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare const toolParamsSchema: z.ZodObject<{
+    ethRpcUrl: z.ZodString;
+    rpcUrlForUniswap: z.ZodString;
+    chainIdForUniswap: z.ZodNumber;
+    tokenAddress: z.ZodString;
+    tokenDecimals: z.ZodNumber;
+    buyAmount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}>;
+export declare const userParamsSchema: z.ZodObject<{
+    maxDailySpendingLimitInUsdCents: z.ZodBigInt;
+}, "strip", z.ZodTypeAny, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}>;
+export declare const precheckAllowResultSchema: z.ZodObject<{
+    maxSpendingLimitInUsd: z.ZodNumber;
+    buyAmountInUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>;
+export declare const precheckDenyResultSchema: z.ZodObject<{
+    reason: z.ZodLiteral<"Attempted buy amount exceeds daily limit">;
+    maxSpendingLimitInUsd: z.ZodNumber;
+    buyAmountInUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}>;
+export declare const evalAllowResultSchema: z.ZodObject<{
+    maxSpendingLimitInUsd: z.ZodNumber;
+    buyAmountInUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>;
+export declare const evalDenyResultSchema: z.ZodObject<{
+    reason: z.ZodString;
+    maxSpendingLimitInUsd: z.ZodOptional<z.ZodNumber>;
+    buyAmountInUsd: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}>;
+export declare const commitParamsSchema: z.ZodObject<{
+    amountSpentUsd: z.ZodNumber;
+    maxSpendingLimitInUsd: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}>;
+export declare const commitAllowResultSchema: z.ZodObject<{
+    spendTxHash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    spendTxHash: string;
+}, {
+    spendTxHash: string;
+}>;
+export declare const commitDenyResultSchema: z.ZodObject<{
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>;
+//# 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,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;EAE3B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;EAGpC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAInC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;EAI/B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;EAG7B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;;EAElC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;EAEjC,CAAC"}

package/dist/src/lib/schemas.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitDenyResultSchema = exports.commitAllowResultSchema = exports.commitParamsSchema = exports.evalDenyResultSchema = exports.evalAllowResultSchema = exports.precheckDenyResultSchema = exports.precheckAllowResultSchema = exports.userParamsSchema = exports.toolParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.toolParamsSchema = zod_1.z.object({
+    ethRpcUrl: zod_1.z.string(),
+    rpcUrlForUniswap: zod_1.z.string(),
+    chainIdForUniswap: zod_1.z.number(),
+    tokenAddress: zod_1.z.string(),
+    tokenDecimals: zod_1.z.number(),
+    buyAmount: zod_1.z.number(),
+});
+exports.userParamsSchema = zod_1.z.object({
+    maxDailySpendingLimitInUsdCents: zod_1.z.bigint(),
+});
+exports.precheckAllowResultSchema = zod_1.z.object({
+    maxSpendingLimitInUsd: zod_1.z.number(),
+    buyAmountInUsd: zod_1.z.number(),
+});
+exports.precheckDenyResultSchema = zod_1.z.object({
+    reason: zod_1.z.literal('Attempted buy amount exceeds daily limit'),
+    maxSpendingLimitInUsd: zod_1.z.number(),
+    buyAmountInUsd: zod_1.z.number(),
+});
+exports.evalAllowResultSchema = zod_1.z.object({
+    maxSpendingLimitInUsd: zod_1.z.number(),
+    buyAmountInUsd: zod_1.z.number(),
+});
+exports.evalDenyResultSchema = zod_1.z.object({
+    reason: zod_1.z.string(),
+    maxSpendingLimitInUsd: zod_1.z.number().optional(),
+    buyAmountInUsd: zod_1.z.number().optional(),
+});
+exports.commitParamsSchema = zod_1.z.object({
+    amountSpentUsd: zod_1.z.number(),
+    maxSpendingLimitInUsd: zod_1.z.number(),
+});
+exports.commitAllowResultSchema = zod_1.z.object({
+    spendTxHash: zod_1.z.string(),
+});
+exports.commitDenyResultSchema = zod_1.z.object({
+    error: zod_1.z.string(),
+});

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

@@ -0,0 +1,209 @@
+export declare const vincentPolicy: import("node_modules/@lit-protocol/vincent-tool-sdk/dist/src/lib/types").VincentPolicy<"@lit-protocol/vincent-policy-spending-limit", import("zod").ZodObject<{
+    ethRpcUrl: import("zod").ZodString;
+    rpcUrlForUniswap: import("zod").ZodString;
+    chainIdForUniswap: import("zod").ZodNumber;
+    tokenAddress: import("zod").ZodString;
+    tokenDecimals: import("zod").ZodNumber;
+    buyAmount: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}>, import("zod").ZodObject<{
+    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+}, "strip", import("zod").ZodTypeAny, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}>, import("zod").ZodObject<{
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodLiteral<"Attempted buy amount exceeds daily limit">;
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}>, import("zod").ZodObject<{
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    maxSpendingLimitInUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+    buyAmountInUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}>, import("zod").ZodObject<{
+    amountSpentUsd: import("zod").ZodNumber;
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}>, import("zod").ZodObject<{
+    spendTxHash: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    spendTxHash: string;
+}, {
+    spendTxHash: string;
+}>, import("zod").ZodObject<{
+    error: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>, import("node_modules/@lit-protocol/vincent-tool-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    ethRpcUrl: import("zod").ZodString;
+    rpcUrlForUniswap: import("zod").ZodString;
+    chainIdForUniswap: import("zod").ZodNumber;
+    tokenAddress: import("zod").ZodString;
+    tokenDecimals: import("zod").ZodNumber;
+    buyAmount: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}>, import("zod").ZodObject<{
+    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+}, "strip", import("zod").ZodTypeAny, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}>, import("zod").ZodObject<{
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodString;
+    maxSpendingLimitInUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+    buyAmountInUsd: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, "strip", import("zod").ZodTypeAny, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}, {
+    reason: string;
+    maxSpendingLimitInUsd?: number | undefined;
+    buyAmountInUsd?: number | undefined;
+}>>, import("node_modules/@lit-protocol/vincent-tool-sdk/dist/src/lib/types").PolicyLifecycleFunction<import("zod").ZodObject<{
+    ethRpcUrl: import("zod").ZodString;
+    rpcUrlForUniswap: import("zod").ZodString;
+    chainIdForUniswap: import("zod").ZodNumber;
+    tokenAddress: import("zod").ZodString;
+    tokenDecimals: import("zod").ZodNumber;
+    buyAmount: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}, {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    buyAmount: number;
+}>, import("zod").ZodObject<{
+    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+}, "strip", import("zod").ZodTypeAny, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}, {
+    maxDailySpendingLimitInUsdCents: bigint;
+}>, import("zod").ZodObject<{
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    buyAmountInUsd: number;
+}>, import("zod").ZodObject<{
+    reason: import("zod").ZodLiteral<"Attempted buy amount exceeds daily limit">;
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    buyAmountInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}, {
+    maxSpendingLimitInUsd: number;
+    reason: "Attempted buy amount exceeds daily limit";
+    buyAmountInUsd: number;
+}>>, import("node_modules/@lit-protocol/vincent-tool-sdk/dist/src/lib/types").CommitLifecycleFunction<import("zod").ZodObject<{
+    amountSpentUsd: import("zod").ZodNumber;
+    maxSpendingLimitInUsd: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}, {
+    amountSpentUsd: number;
+    maxSpendingLimitInUsd: number;
+}>, import("zod").ZodObject<{
+    spendTxHash: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    spendTxHash: string;
+}, {
+    spendTxHash: string;
+}>, import("zod").ZodObject<{
+    error: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    error: string;
+}, {
+    error: string;
+}>>>;
+//# 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":"AA4BA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoJxB,CAAC"}