@lit-protocol/vincent-policy-send-counter 0.1.0 → 0.2.0

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

@@ -1,209 +1,248 @@
-export declare const vincentPolicy: import("node_modules/@lit-protocol/vincent-ability-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;
+export declare const vincentPolicy: import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").VincentPolicy<"@lit-protocol/vincent-policy-send-counter-limit", import("zod").ZodObject<{
+    to: import("zod").ZodString;
+    amount: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }>, import("zod").ZodObject<{
-    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+    maxSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    reason: import("zod").ZodLiteral<"Attempted buy amount exceeds daily limit">;
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    reason: import("zod").ZodString;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    secondsUntilReset: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    reason: "Attempted buy amount exceeds daily limit";
-    buyAmountInUsd: number;
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    reason: string;
 }, {
-    maxSpendingLimitInUsd: number;
-    reason: "Attempted buy amount exceeds daily limit";
-    buyAmountInUsd: number;
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    reason: string;
 }>, import("zod").ZodObject<{
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: 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, {
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    secondsUntilReset: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    timeWindowSeconds: number;
     reason: string;
-    maxSpendingLimitInUsd?: number | undefined;
-    buyAmountInUsd?: number | undefined;
 }, {
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    timeWindowSeconds: number;
     reason: string;
-    maxSpendingLimitInUsd?: number | undefined;
-    buyAmountInUsd?: number | undefined;
 }>, import("zod").ZodObject<{
-    amountSpentUsd: import("zod").ZodNumber;
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    amountSpentUsd: number;
-    maxSpendingLimitInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    amountSpentUsd: number;
-    maxSpendingLimitInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    spendTxHash: import("zod").ZodString;
+    recorded: import("zod").ZodBoolean;
+    newCount: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    spendTxHash: string;
+    remainingSends: number;
+    recorded: boolean;
+    newCount: number;
 }, {
-    spendTxHash: string;
+    remainingSends: number;
+    recorded: boolean;
+    newCount: number;
 }>, import("zod").ZodObject<{
-    error: import("zod").ZodString;
+    reason: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    error: string;
+    reason: string;
 }, {
-    error: string;
+    reason: string;
 }>, import("node_modules/@lit-protocol/vincent-ability-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;
+    to: import("zod").ZodString;
+    amount: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }>, import("zod").ZodObject<{
-    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+    maxSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: 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, {
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    secondsUntilReset: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
+}, "strip", import("zod").ZodTypeAny, {
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    timeWindowSeconds: number;
     reason: string;
-    maxSpendingLimitInUsd?: number | undefined;
-    buyAmountInUsd?: number | undefined;
 }, {
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    timeWindowSeconds: number;
     reason: string;
-    maxSpendingLimitInUsd?: number | undefined;
-    buyAmountInUsd?: number | undefined;
 }>>, import("node_modules/@lit-protocol/vincent-ability-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;
+    to: import("zod").ZodString;
+    amount: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }, {
-    ethRpcUrl: string;
-    rpcUrlForUniswap: string;
-    chainIdForUniswap: number;
-    tokenAddress: string;
-    tokenDecimals: number;
-    buyAmount: number;
+    to: string;
+    amount: string;
 }>, import("zod").ZodObject<{
-    maxDailySpendingLimitInUsdCents: import("zod").ZodBigInt;
+    maxSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxDailySpendingLimitInUsdCents: bigint;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    maxSpendingLimitInUsd: number;
-    buyAmountInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    reason: import("zod").ZodLiteral<"Attempted buy amount exceeds daily limit">;
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
-    buyAmountInUsd: import("zod").ZodNumber;
+    reason: import("zod").ZodString;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    secondsUntilReset: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    maxSpendingLimitInUsd: number;
-    reason: "Attempted buy amount exceeds daily limit";
-    buyAmountInUsd: number;
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    reason: string;
 }, {
-    maxSpendingLimitInUsd: number;
-    reason: "Attempted buy amount exceeds daily limit";
-    buyAmountInUsd: number;
+    currentCount: number;
+    secondsUntilReset: number;
+    maxSends: number;
+    reason: string;
 }>>, import("node_modules/@lit-protocol/vincent-ability-sdk/dist/src/lib/types").CommitLifecycleFunction<import("zod").ZodObject<{
-    amountSpentUsd: import("zod").ZodNumber;
-    maxSpendingLimitInUsd: import("zod").ZodNumber;
+    currentCount: import("zod").ZodNumber;
+    maxSends: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
+    timeWindowSeconds: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    amountSpentUsd: number;
-    maxSpendingLimitInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }, {
-    amountSpentUsd: number;
-    maxSpendingLimitInUsd: number;
+    currentCount: number;
+    remainingSends: number;
+    maxSends: number;
+    timeWindowSeconds: number;
 }>, import("zod").ZodObject<{
-    spendTxHash: import("zod").ZodString;
+    recorded: import("zod").ZodBoolean;
+    newCount: import("zod").ZodNumber;
+    remainingSends: import("zod").ZodNumber;
 }, "strip", import("zod").ZodTypeAny, {
-    spendTxHash: string;
+    remainingSends: number;
+    recorded: boolean;
+    newCount: number;
 }, {
-    spendTxHash: string;
+    remainingSends: number;
+    recorded: boolean;
+    newCount: number;
 }>, import("zod").ZodObject<{
-    error: import("zod").ZodString;
+    reason: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    error: string;
+    reason: string;
 }, {
-    error: string;
+    reason: string;
 }>>>;
 //# sourceMappingURL=vincent-policy.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vincent-policy.d.ts","sourceRoot":"","sources":["../../../src/lib/vincent-policy.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoJxB,CAAC"}
+{"version":3,"file":"vincent-policy.d.ts","sourceRoot":"","sources":["../../../src/lib/vincent-policy.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgRxB,CAAC"}

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

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.vincentPolicy = void 0;
 const vincent_ability_sdk_1 = require("@lit-protocol/vincent-ability-sdk");
-const send_spend_tx_1 = require("./policy-helpers/send-spend-tx");
-const check_spending_limit_1 = require("./policy-helpers/check-spending-limit");
+const vincent_scaffold_sdk_1 = require("@lit-protocol/vincent-scaffold-sdk");
+const index_1 = require("./helpers/index");
 const schemas_1 = require("./schemas");
+const counterSignatures_1 = require("./abi/counterSignatures");
 exports.vincentPolicy = (0, vincent_ability_sdk_1.createVincentPolicy)({
-    packageName: '@lit-protocol/vincent-policy-spending-limit',
+    packageName: '@lit-protocol/vincent-policy-send-counter-limit',
     abilityParamsSchema: schemas_1.abilityParamsSchema,
     userParamsSchema: schemas_1.userParamsSchema,
     commitParamsSchema: schemas_1.commitParamsSchema,
@@ -17,55 +18,75 @@ exports.vincentPolicy = (0, vincent_ability_sdk_1.createVincentPolicy)({
     commitAllowResultSchema: schemas_1.commitAllowResultSchema,
     commitDenyResultSchema: schemas_1.commitDenyResultSchema,
     precheck: async ({ abilityParams, userParams }, { allow, deny, appId, delegation: { delegatorPkpInfo } }) => {
-        console.log('Prechecking spending limit policy', { abilityParams, userParams });
-        const { ethAddress } = delegatorPkpInfo;
-        const { buyAmount, ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenDecimals, } = abilityParams;
-        const { maxDailySpendingLimitInUsdCents } = userParams;
-        const { buyAmountAllowed, buyAmountInUsd, adjustedMaxDailySpendingLimit } = await (0, check_spending_limit_1.checkIfBuyAmountAllowed)({
-            ethRpcUrl,
-            rpcUrlForUniswap,
-            chainIdForUniswap,
-            tokenAddress: tokenAddress,
-            tokenDecimals,
-            buyAmount,
-            maxDailySpendingLimitInUsdCents,
-            pkpEthAddress: ethAddress,
+        console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🔍 POLICY PRECHECK CALLED');
+        console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🔍 Policy precheck params:', {
+            abilityParams,
+            userParams,
+            ethAddress: delegatorPkpInfo.ethAddress,
             appId,
         });
-        return buyAmountAllowed
-            ? allow({
-                maxSpendingLimitInUsd: Number(adjustedMaxDailySpendingLimit),
-                buyAmountInUsd: Number(buyAmountInUsd),
-            })
-            : deny({
-                reason: 'Attempted buy amount exceeds daily limit',
-                maxSpendingLimitInUsd: Number(adjustedMaxDailySpendingLimit),
-                buyAmountInUsd: Number(buyAmountInUsd),
+        // Only use what we actually need - no defaults in policy logic
+        const { maxSends, timeWindowSeconds } = userParams;
+        const { ethAddress } = delegatorPkpInfo;
+        try {
+            // Check current send limit for the user
+            const limitCheck = await (0, index_1.checkSendLimit)(ethAddress, maxSends, timeWindowSeconds);
+            if (!limitCheck.allowed) {
+                const denyResult = {
+                    reason: `Send limit exceeded. Maximum ${maxSends} sends per ${timeWindowSeconds} seconds. Try again in ${limitCheck.secondsUntilReset} seconds.`,
+                    currentCount: limitCheck.currentCount,
+                    maxSends: maxSends,
+                    secondsUntilReset: limitCheck.secondsUntilReset || 0,
+                };
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 POLICY PRECHECK DENYING REQUEST:');
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 Deny result:', JSON.stringify(denyResult, null, 2));
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 Current count:', limitCheck.currentCount);
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 Max sends:', maxSends);
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 Limit check result:', JSON.stringify(limitCheck, null, 2));
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 About to call deny() function...');
+                const denyResponse = deny(denyResult);
+                console.log('[@lit-protocol/vincent-policy-send-counter-limit/precheck] 🚫 POLICY PRECHECK DENY RESPONSE:', JSON.stringify(denyResponse, null, 2));
+                return denyResponse;
+            }
+            const allowResult = {
+                maxSends,
+                timeWindowSeconds,
+                currentCount: limitCheck.currentCount,
+                remainingSends: limitCheck.remainingSends,
+            };
+            console.log('[SendLimitPolicy/precheck] ✅ POLICY PRECHECK ALLOWING REQUEST:');
+            console.log('[SendLimitPolicy/precheck] ✅ Allow result:', JSON.stringify(allowResult, null, 2));
+            console.log('[SendLimitPolicy/precheck] ✅ Current count:', limitCheck.currentCount);
+            console.log('[SendLimitPolicy/precheck] ✅ Max sends:', maxSends);
+            console.log('[SendLimitPolicy/precheck] ✅ Remaining sends:', limitCheck.remainingSends);
+            const allowResponse = allow(allowResult);
+            console.log('[SendLimitPolicy/precheck] ✅ POLICY PRECHECK ALLOW RESPONSE:', JSON.stringify(allowResponse, null, 2));
+            return allowResponse;
+        }
+        catch (error) {
+            console.error('[SendLimitPolicy/precheck] Error in precheck:', error);
+            return deny({
+                maxSends,
+                reason: `Policy error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                currentCount: 0,
+                secondsUntilReset: 0,
             });
+        }
     },
-    evaluate: async ({ abilityParams, userParams }, { allow, deny, appId, delegation: { delegatorPkpInfo } }) => {
+    evaluate: async ({ abilityParams, userParams }, { allow, deny, delegation: { delegatorPkpInfo } }) => {
+        console.log('[@lit-protocol/vincent-policy-send-counter-limit/evaluate] Evaluating send limit policy', {
+            abilityParams,
+            userParams,
+        });
+        // Only use what we actually need - no defaults in policy logic
+        const { maxSends, timeWindowSeconds } = userParams;
         const { ethAddress } = delegatorPkpInfo;
-        console.log('Evaluating spending limit policy', JSON.stringify(abilityParams));
-        const { buyAmount, ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenDecimals, } = abilityParams;
-        const { maxDailySpendingLimitInUsdCents } = userParams;
-        const checkBuyAmountResponse = await Lit.Actions.runOnce({ waitForResponse: true, name: 'checkBuyAmount' }, async () => {
+        const checkSendResponse = await Lit.Actions.runOnce({ waitForResponse: true, name: 'checkSendLimit' }, async () => {
             try {
-                const { buyAmountAllowed, buyAmountInUsd, adjustedMaxDailySpendingLimit } = await (0, check_spending_limit_1.checkIfBuyAmountAllowed)({
-                    ethRpcUrl,
-                    rpcUrlForUniswap,
-                    chainIdForUniswap,
-                    tokenAddress: tokenAddress,
-                    tokenDecimals,
-                    buyAmount,
-                    maxDailySpendingLimitInUsdCents,
-                    pkpEthAddress: ethAddress,
-                    appId,
-                });
+                const limitCheck = await (0, index_1.checkSendLimit)(ethAddress, maxSends, timeWindowSeconds);
                 return JSON.stringify({
                     status: 'success',
-                    buyAmountAllowed,
-                    buyAmountInUsd: buyAmountInUsd.toString(),
-                    adjustedMaxDailySpendingLimit: adjustedMaxDailySpendingLimit.toString(),
+                    ...limitCheck,
                 });
             }
             catch (error) {
@@ -75,43 +96,93 @@ exports.vincentPolicy = (0, vincent_ability_sdk_1.createVincentPolicy)({
                 });
             }
         });
-        const parsedCheckBuyAmountResponse = JSON.parse(checkBuyAmountResponse);
-        if (parsedCheckBuyAmountResponse.status === 'error') {
+        const parsedResponse = JSON.parse(checkSendResponse);
+        if (parsedResponse.status === 'error') {
             return deny({
-                reason: `Error checking buy amount: ${parsedCheckBuyAmountResponse.error} (evaluate)`,
+                maxSends,
+                timeWindowSeconds,
+                reason: `Error checking send limit: ${parsedResponse.error} (evaluate)`,
+                currentCount: 0,
+                secondsUntilReset: 0,
             });
         }
-        const { buyAmountAllowed, buyAmountInUsd, adjustedMaxDailySpendingLimit } = parsedCheckBuyAmountResponse;
-        console.log('Evaluated spending limit policy', {
-            buyAmountAllowed,
-            buyAmountInUsd,
-            adjustedMaxDailySpendingLimit,
-        });
-        return buyAmountAllowed
-            ? allow({
-                maxSpendingLimitInUsd: Number(adjustedMaxDailySpendingLimit),
-                buyAmountInUsd: Number(buyAmountInUsd),
-            })
-            : deny({
-                reason: 'Attempted buy amount exceeds daily limit',
-                maxSpendingLimitInUsd: Number(adjustedMaxDailySpendingLimit),
-                buyAmountInUsd: Number(buyAmountInUsd),
+        const { allowed, currentCount, remainingSends, secondsUntilReset } = parsedResponse;
+        if (!allowed) {
+            return deny({
+                reason: `Send limit exceeded during evaluation. Maximum ${maxSends} sends per ${timeWindowSeconds} seconds. Try again in ${secondsUntilReset} seconds.`,
+                currentCount,
+                maxSends,
+                timeWindowSeconds,
+                secondsUntilReset: secondsUntilReset || 0,
             });
-    },
-    commit: async (params, { allow, appId, delegation: { delegatorPkpInfo } }) => {
-        const { ethAddress, publicKey } = delegatorPkpInfo;
-        const { amountSpentUsd, maxSpendingLimitInUsd } = params;
-        const spendTxHash = await (0, send_spend_tx_1.sendSpendTx)({
-            appId,
-            amountSpentUsd,
-            maxSpendingLimitInUsd,
-            spendingLimitDuration: 86400, // number of seconds in a day
-            pkpEthAddress: ethAddress,
-            pkpPubKey: publicKey,
+        }
+        console.log('[@lit-protocol/vincent-policy-send-counter-limit/evaluate] Evaluated send limit policy', {
+            currentCount,
+            maxSends,
+            remainingSends,
         });
         return allow({
-            spendTxHash,
+            currentCount,
+            maxSends,
+            remainingSends,
+            timeWindowSeconds,
         });
     },
+    commit: async ({ currentCount, maxSends, timeWindowSeconds }, { allow, appId, delegation: { delegatorPkpInfo } }) => {
+        const { ethAddress } = delegatorPkpInfo;
+        console.log('[@lit-protocol/vincent-policy-send-counter-limit/commit] 🚀 IM COMMITING!');
+        // Check if we need to reset the counter first
+        const checkResponse = await (0, index_1.checkSendLimit)(ethAddress, maxSends, timeWindowSeconds);
+        if (checkResponse.shouldReset) {
+            console.log(`[@lit-protocol/vincent-policy-send-counter-limit/commit] Resetting counter for ${ethAddress} due to time window expiration`);
+            try {
+                await (0, index_1.resetSendCounter)(ethAddress, delegatorPkpInfo.publicKey);
+                console.log(`[@lit-protocol/vincent-policy-send-counter-limit/commit] Counter reset successful for ${ethAddress}`);
+            }
+            catch (error) {
+                console.warn(`Counter reset failed for ${ethAddress}:`, error);
+                // Continue anyway, the counter will still work
+            }
+        }
+        try {
+            // Record the send to the smart contract
+            console.log(`[@lit-protocol/vincent-policy-send-counter-limit/commit] Recording send to contract for ${ethAddress} (appId: ${appId})`);
+            // Execute the contract call to increment the counter directly
+            console.log(`[@lit-protocol/vincent-policy-send-counter-limit/commit] Calling incrementByAddress(${ethAddress}) on contract ${counterSignatures_1.counterSignatures.address}`);
+            // Call contract directly without Lit.Actions.runOnce wrapper
+            const txHash = await vincent_scaffold_sdk_1.laUtils.transaction.handler.contractCall({
+                provider: new ethers.providers.JsonRpcProvider(await Lit.Actions.getRpcUrl({ chain: 'yellowstone' })),
+                pkpPublicKey: delegatorPkpInfo.publicKey,
+                callerAddress: ethAddress,
+                abi: [counterSignatures_1.counterSignatures.methods.increment],
+                contractAddress: counterSignatures_1.counterSignatures.address,
+                functionName: 'increment',
+                args: [],
+            });
+            const newCount = currentCount + 1;
+            const remainingSends = maxSends - newCount;
+            console.log('[@lit-protocol/vincent-policy-send-counter-limit/commit] Policy commit successful', {
+                ethAddress,
+                newCount,
+                maxSends,
+                remainingSends,
+                txHash,
+            });
+            return allow({
+                recorded: true,
+                newCount,
+                remainingSends: Math.max(0, remainingSends),
+            });
+        }
+        catch (error) {
+            console.error('[@lit-protocol/vincent-policy-send-counter-limit/commit] Error in commit phase:', error);
+            // Still return success since the transaction itself succeeded
+            return allow({
+                recorded: false,
+                newCount: currentCount + 1,
+                remainingSends: Math.max(0, maxSends - currentCount - 1),
+            });
+        }
+    },
 });
 //# sourceMappingURL=vincent-policy.js.map