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

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

@@ -0,0 +1,212 @@
+/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ */
+export declare const bundledVincentPolicy: import("@lit-protocol/vincent-tool-sdk").BundledVincentPolicy<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;
+}>>>, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAA0D,CAAC"}

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

@@ -0,0 +1,14 @@
+"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_tool_sdk_1 = require("@lit-protocol/vincent-tool-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_tool_sdk_1.asBundledVincentPolicy)(vincent_policy_1.vincentPolicy, vincent_policy_metadata_json_1.default.ipfsCid);

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

@@ -0,0 +1,13 @@
+/**
+ * DO NOT EDIT THIS FILE. IT IS GENERATED ON BUILD.
+ */
+ 
+import { asBundledVincentPolicy } from '@lit-protocol/vincent-tool-sdk';
+import { vincentPolicy } from '../lib/vincent-policy';
+import metadata from './vincent-policy-metadata.json';
+
+if(!metadata.ipfsCid) {
+  throw new Error('ipfsCid is not defined in metadata JSON file');
+}
+
+export const bundledVincentPolicy = asBundledVincentPolicy(vincentPolicy, metadata.ipfsCid);

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

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

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,8 @@
+"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;

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,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vincent_tool_sdk_1 = require("@lit-protocol/vincent-tool-sdk");
+const vincent_policy_1 = require("./vincent-policy");
+(async () => {
+    return await (0, vincent_tool_sdk_1.vincentPolicyHandler)({
+        vincentPolicy: vincent_policy_1.vincentPolicy,
+        context,
+        toolParams,
+    });
+})();

package/dist/src/lib/policy-helpers/calculate-usd-value.d.ts

@@ -0,0 +1,7 @@
+import { ethers } from 'ethers';
+export declare const calculateUsdValue: ({ ethRpcUrl, chainlinkPriceFeedAddress, amountInWeth, }: {
+    ethRpcUrl: string;
+    chainlinkPriceFeedAddress: string;
+    amountInWeth: ethers.BigNumber;
+}) => Promise<ethers.BigNumber>;
+//# sourceMappingURL=calculate-usd-value.d.ts.map

package/dist/src/lib/policy-helpers/calculate-usd-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-usd-value.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/calculate-usd-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAIhC,eAAO,MAAM,iBAAiB,GAAU,yDAIrC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,yBAAyB,EAAE,MAAM,CAAC;IAClC,YAAY,EAAE,MAAM,CAAC,SAAS,CAAC;CAChC,KAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAgB3B,CAAC"}

package/dist/src/lib/policy-helpers/calculate-usd-value.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateUsdValue = void 0;
+const ethers_1 = require("ethers");
+const get_eth_usd_price_1 = require("./get-eth-usd-price");
+const calculateUsdValue = async ({ ethRpcUrl, chainlinkPriceFeedAddress, amountInWeth, }) => {
+    const ethPriceInUsd = await (0, get_eth_usd_price_1.getEthUsdPriceFromChainlink)({ ethRpcUrl, chainlinkPriceFeedAddress });
+    // Calculate USD value (8 decimals precision)
+    const CHAINLINK_DECIMALS = 8;
+    const WETH_DECIMALS = 18; // WETH decimals
+    const amountInUsd = amountInWeth
+        .mul(ethPriceInUsd)
+        .div(ethers_1.ethers.utils.parseUnits('1', WETH_DECIMALS));
+    console.log(`Calculate token amount in USDC (calculateUsdValue)`, {
+        tokenAmountInWeth: ethers_1.ethers.utils.formatUnits(amountInWeth, WETH_DECIMALS),
+        ethPriceInUsd: ethers_1.ethers.utils.formatUnits(ethPriceInUsd, CHAINLINK_DECIMALS),
+        tokenAmountInUsd: ethers_1.ethers.utils.formatUnits(amountInUsd, CHAINLINK_DECIMALS),
+    });
+    return amountInUsd;
+};
+exports.calculateUsdValue = calculateUsdValue;

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

@@ -0,0 +1,16 @@
+export declare const checkIfBuyAmountAllowed: ({ ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenDecimals, buyAmount, maxDailySpendingLimitInUsdCents, pkpEthAddress, appId, }: {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: `0x${string}`;
+    tokenDecimals: number;
+    buyAmount: number;
+    maxDailySpendingLimitInUsdCents: bigint;
+    pkpEthAddress: `0x${string}`;
+    appId: number;
+}) => Promise<{
+    buyAmountAllowed: boolean;
+    buyAmountInUsd: bigint;
+    adjustedMaxDailySpendingLimit: bigint;
+}>;
+//# sourceMappingURL=check-spending-limit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-spending-limit.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/check-spending-limit.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,uBAAuB,GAAU,oJAU3C;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,KAAK,MAAM,EAAE,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B,EAAE,MAAM,CAAC;IACxC,aAAa,EAAE,KAAK,MAAM,EAAE,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,OAAO,CAAC;IACV,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,6BAA6B,EAAE,MAAM,CAAC;CACvC,CAoCA,CAAC"}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfBuyAmountAllowed = void 0;
+const get_token_amount_in_usd_1 = require("./get-token-amount-in-usd");
+const spending_limit_contract_1 = require("./spending-limit-contract");
+const checkIfBuyAmountAllowed = async ({ ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenDecimals, buyAmount, maxDailySpendingLimitInUsdCents, pkpEthAddress, appId, }) => {
+    const buyAmountInUsd = await (0, get_token_amount_in_usd_1.getTokenAmountInUsd)({
+        ethRpcUrl,
+        rpcUrlForUniswap,
+        chainIdForUniswap,
+        tokenAddress,
+        tokenDecimals,
+        tokenAmount: buyAmount,
+    });
+    // maxDailySpendingLimitInUsdCents has 2 decimal precision, but tokenAmountInUsd has 8,
+    // so we multiply by 10^6 to match the precision
+    const adjustedMaxDailySpendingLimit = maxDailySpendingLimitInUsdCents * 1000000n;
+    console.log(`Adjusted maxDailySpendingLimitInUsdCents to 8 decimal precision: ${adjustedMaxDailySpendingLimit.toString()} (spendingLimitPolicyPrecheck)`);
+    const spendingLimitContract = (0, spending_limit_contract_1.getSpendingLimitContractInstance)();
+    const buyAmountAllowed = await spendingLimitContract.checkLimit(pkpEthAddress, BigInt(appId), buyAmountInUsd.toBigInt(), adjustedMaxDailySpendingLimit, 86400n);
+    console.log(`Buy amount allowed: ${JSON.stringify(buyAmountAllowed)} (spendingLimitPolicyPrecheck)`);
+    return {
+        buyAmountAllowed,
+        buyAmountInUsd: buyAmountInUsd.toBigInt(),
+        adjustedMaxDailySpendingLimit,
+    };
+};
+exports.checkIfBuyAmountAllowed = checkIfBuyAmountAllowed;

package/dist/src/lib/policy-helpers/get-eth-usd-price.d.ts

@@ -0,0 +1,6 @@
+import { ethers } from 'ethers';
+export declare const getEthUsdPriceFromChainlink: ({ chainlinkPriceFeedAddress, ethRpcUrl, }: {
+    chainlinkPriceFeedAddress: string;
+    ethRpcUrl: string;
+}) => Promise<ethers.BigNumber>;
+//# sourceMappingURL=get-eth-usd-price.d.ts.map

package/dist/src/lib/policy-helpers/get-eth-usd-price.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-eth-usd-price.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/get-eth-usd-price.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,eAAO,MAAM,2BAA2B,GAAU,2CAG/C;IACD,yBAAyB,EAAE,MAAM,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB,KAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAiB3B,CAAC"}

package/dist/src/lib/policy-helpers/get-eth-usd-price.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEthUsdPriceFromChainlink = void 0;
+const ethers_1 = require("ethers");
+const CHAINLINK_AGGREGATOR_ABI = [
+    'function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)',
+];
+const getEthUsdPriceFromChainlink = async ({ chainlinkPriceFeedAddress, ethRpcUrl, }) => {
+    console.log(`Getting ETH price in USD from Chainlink (getEthUsdPriceFromChainlink)`, {
+        chainlinkPriceFeedAddress,
+        ethRpcUrl,
+    });
+    const provider = new ethers_1.ethers.providers.StaticJsonRpcProvider(ethRpcUrl);
+    const contract = new ethers_1.ethers.Contract(chainlinkPriceFeedAddress, CHAINLINK_AGGREGATOR_ABI, provider);
+    const [_, answer] = await contract.latestRoundData();
+    console.log(`Got ETH price in USD (getEthUsdPriceFromChainlink)`, {
+        ethPriceInUsd: ethers_1.ethers.utils.formatUnits(answer, 8),
+    });
+    return answer;
+};
+exports.getEthUsdPriceFromChainlink = getEthUsdPriceFromChainlink;

package/dist/src/lib/policy-helpers/get-token-amount-in-usd.d.ts

@@ -0,0 +1,10 @@
+import { ethers } from 'ethers';
+export declare const getTokenAmountInUsd: ({ ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenAmount, tokenDecimals, }: {
+    ethRpcUrl: string;
+    rpcUrlForUniswap: string;
+    chainIdForUniswap: number;
+    tokenAddress: string;
+    tokenDecimals: number;
+    tokenAmount: number;
+}) => Promise<ethers.BigNumber>;
+//# sourceMappingURL=get-token-amount-in-usd.d.ts.map

package/dist/src/lib/policy-helpers/get-token-amount-in-usd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-token-amount-in-usd.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/get-token-amount-in-usd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAWhC,eAAO,MAAM,mBAAmB,GAAU,+FAOvC;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,KAAG,OAAO,CAAC,MAAM,CAAC,SAAS,CAiE3B,CAAC"}

package/dist/src/lib/policy-helpers/get-token-amount-in-usd.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAmountInUsd = void 0;
+const ethers_1 = require("ethers");
+const calculate_usd_value_1 = require("./calculate-usd-value");
+const get_uniswap_quote_1 = require("./get-uniswap-quote");
+const ETH_MAINNET_WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+/**
+ * Source: https://docs.chain.link/data-feeds/price-feeds/addresses/?network=ethereum&page=1&search=ETH%2FUSD
+ */
+const ETH_MAINNET_ETH_USD_CHAINLINK_FEED = '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419';
+const getTokenAmountInUsd = async ({ ethRpcUrl, rpcUrlForUniswap, chainIdForUniswap, tokenAddress, tokenAmount, tokenDecimals, }) => {
+    console.log(`Getting token amount in USD (getTokenAmountInUsd)`, {
+        ethRpcUrl,
+        rpcUrlForUniswap,
+        chainIdForUniswap,
+        tokenAddress,
+        tokenAmount,
+        tokenDecimals,
+        ethMainnetWethAddress: ETH_MAINNET_WETH_ADDRESS,
+        ethMainnetEthUsdChainlinkFeed: ETH_MAINNET_ETH_USD_CHAINLINK_FEED,
+    });
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider(rpcUrlForUniswap);
+    const tokenInContract = new ethers_1.ethers.Contract(tokenAddress, ['function symbol() view returns (string)'], provider);
+    const tokenInSymbol = await tokenInContract.symbol();
+    console.log(`tokenInSymbol: ${tokenInSymbol} (getTokenAmountInUsd)`);
+    // Special case for WETH - no need to get a quote since it's already in ETH terms
+    if (tokenInSymbol.toUpperCase() === 'WETH') {
+        console.log(`Token is WETH, using amount directly: ${tokenAmount} (getTokenAmountInUsd)`);
+        const amountInWeth = ethers_1.ethers.utils.parseUnits(tokenAmount.toString(), tokenDecimals);
+        return (0, calculate_usd_value_1.calculateUsdValue)({
+            ethRpcUrl,
+            chainlinkPriceFeedAddress: ETH_MAINNET_ETH_USD_CHAINLINK_FEED,
+            amountInWeth,
+        });
+    }
+    console.log(`Getting price in WETH from Uniswap (getTokenAmountInUsd)`, {
+        tokenInAddress: tokenAddress,
+        tokenInDecimals: tokenDecimals,
+        tokenInAmount: tokenAmount,
+        tokenOutAddress: ETH_MAINNET_WETH_ADDRESS,
+        tokenOutDecimals: 18,
+        rpcUrl: rpcUrlForUniswap,
+        chainId: chainIdForUniswap,
+    });
+    const amountInWeth = await (0, get_uniswap_quote_1.getUniswapQuote)({
+        tokenInAddress: tokenAddress,
+        tokenInDecimals: tokenDecimals,
+        tokenInAmount: tokenAmount,
+        tokenOutAddress: ETH_MAINNET_WETH_ADDRESS,
+        tokenOutDecimals: 18,
+        rpcUrl: rpcUrlForUniswap,
+        chainId: chainIdForUniswap,
+    });
+    // Convert WETH amount to USD
+    const amountInUsdc = await (0, calculate_usd_value_1.calculateUsdValue)({
+        ethRpcUrl,
+        chainlinkPriceFeedAddress: ETH_MAINNET_ETH_USD_CHAINLINK_FEED,
+        amountInWeth: amountInWeth.bestQuote,
+    });
+    console.log('Calculated token amount in USDC (getTokenAmountInUsd)', {
+        amountInWeth: ethers_1.ethers.utils.formatUnits(amountInWeth.bestQuote, 18),
+        amountInUsdc: ethers_1.ethers.utils.formatUnits(amountInUsdc, 8),
+    });
+    return amountInUsdc;
+};
+exports.getTokenAmountInUsd = getTokenAmountInUsd;

package/dist/src/lib/policy-helpers/get-uniswap-quote.d.ts

@@ -0,0 +1,15 @@
+import { ethers } from 'ethers';
+export declare const getUniswapQuote: ({ rpcUrl, chainId, tokenInAddress, tokenInDecimals, tokenInAmount, tokenOutAddress, tokenOutDecimals, }: {
+    rpcUrl: string;
+    chainId: number;
+    tokenInAddress: string;
+    tokenInDecimals: number;
+    tokenInAmount: number;
+    tokenOutAddress: string;
+    tokenOutDecimals: number;
+}) => Promise<{
+    bestQuote: ethers.BigNumber;
+    bestFee: number;
+    amountOutMin: ethers.BigNumber;
+}>;
+//# sourceMappingURL=get-uniswap-quote.d.ts.map

package/dist/src/lib/policy-helpers/get-uniswap-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-uniswap-quote.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/get-uniswap-quote.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAMhC,eAAO,MAAM,eAAe,GAAU,yGAQnC;IACD,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,KAAG,OAAO,CAAC;IACV,SAAS,EAAE,MAAM,CAAC,SAAS,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC,SAAS,CAAC;CAChC,CA8HA,CAAC"}

package/dist/src/lib/policy-helpers/get-uniswap-quote.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniswapQuote = void 0;
+const sdk_core_1 = require("@uniswap/sdk-core");
+const ethers_1 = require("ethers");
+const UNISWAP_V3_QUOTER_INTERFACE = new ethers_1.ethers.utils.Interface([
+    'function quoteExactInputSingle((address tokenIn, address tokenOut, uint256 amountIn, uint24 fee, uint160 sqrtPriceLimitX96)) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)',
+]);
+const getUniswapQuote = async ({ rpcUrl, chainId, tokenInAddress, tokenInDecimals, tokenInAmount, tokenOutAddress, tokenOutDecimals, }) => {
+    console.log('Getting Uniswap Quote (getUniswapQuote)', {
+        rpcUrl,
+        chainId,
+        tokenInAddress,
+        tokenInDecimals,
+        tokenInAmount,
+        tokenOutAddress,
+        tokenOutDecimals,
+    });
+    const chainAddressMap = sdk_core_1.CHAIN_TO_ADDRESSES_MAP[chainId];
+    if (chainAddressMap === undefined)
+        throw new Error(`Unsupported chainId: ${chainId} (getUniswapQuote)`);
+    if (chainAddressMap.quoterAddress === undefined)
+        throw new Error(`No Uniswap V3 Quoter Address found for chainId: ${chainId} (getUniswapQuote)`);
+    const quoterAddress = chainAddressMap.quoterAddress;
+    console.log(`Using Quoter Address: ${quoterAddress} (getUniswapQuote)`);
+    const uniswapRpcProvider = new ethers_1.ethers.providers.StaticJsonRpcProvider(rpcUrl);
+    const formattedTokenInAmount = ethers_1.ethers.utils.parseUnits(tokenInAmount.toString(), tokenInDecimals);
+    console.log('Amount conversion:', {
+        original: tokenInAmount,
+        decimals: tokenInDecimals,
+        wei: formattedTokenInAmount.toString(),
+        formatted: ethers_1.ethers.utils.formatUnits(formattedTokenInAmount, tokenInDecimals),
+    });
+    let bestQuote = null;
+    let bestFee = null;
+    const feeTiers = [3000, 500]; // Supported fee tiers (0.3% and 0.05%)
+    for (const fee of feeTiers) {
+        try {
+            const quoteParams = {
+                tokenIn: tokenInAddress,
+                tokenOut: tokenOutAddress,
+                amountIn: formattedTokenInAmount.toString(),
+                fee,
+                sqrtPriceLimitX96: 0,
+            };
+            console.log(`Attempting quote with fee tier ${fee / 10000}% (getUniswapQuote)`);
+            console.log('Quote parameters (getUniswapQuote):', quoteParams);
+            const quote = await uniswapRpcProvider.call({
+                to: quoterAddress,
+                data: UNISWAP_V3_QUOTER_INTERFACE.encodeFunctionData('quoteExactInputSingle', [
+                    quoteParams,
+                ]),
+            });
+            console.log('Raw quote response (getUniswapQuote):', quote);
+            const [amountOut] = UNISWAP_V3_QUOTER_INTERFACE.decodeFunctionResult('quoteExactInputSingle', quote);
+            const currentQuote = ethers_1.ethers.BigNumber.from(amountOut);
+            if (currentQuote.isZero()) {
+                console.log(`Quote is 0 for fee tier ${fee / 10000}% - skipping (getUniswapQuote)`);
+                continue;
+            }
+            const formattedQuote = ethers_1.ethers.utils.formatUnits(currentQuote, tokenOutDecimals);
+            console.log(`Quote for fee tier ${fee / 10000}% (getUniswapQuote):`, {
+                raw: currentQuote.toString(),
+                formatted: formattedQuote,
+            });
+            if (!bestQuote || currentQuote.gt(bestQuote)) {
+                bestQuote = currentQuote;
+                bestFee = fee;
+                console.log(`New best quote found with fee tier ${fee / 10000}% (getUniswapQuote): ${formattedQuote}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            // Check if this is an ethers contract error with expected properties
+            if ('reason' in err && 'message' in err && 'code' in err) {
+                if (err.reason === 'Unexpected error') {
+                    console.log(`Unexpected error thrown, probably no pool found for fee tier ${fee / 10000}% (getUniswapQuote)`, err);
+                }
+                else {
+                    console.log(`Quoter call failed for fee tier ${fee / 10000}% (getUniswapQuote)`, {
+                        message: err.message,
+                        reason: err.reason,
+                        code: err.code,
+                    });
+                }
+                continue;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    if (!bestQuote || !bestFee) {
+        throw new Error('Failed to get quote from Uniswap V3. No valid pool found for this token pair or quote returned 0 (getUniswapQuote)');
+    }
+    // Calculate minimum output with 0.5% slippage tolerance
+    const slippageTolerance = 0.005;
+    const amountOutMin = bestQuote.mul(1000 - slippageTolerance * 1000).div(1000);
+    console.log('Final quote details:', {
+        bestFee: `${bestFee / 10000}%`,
+        bestQuote: {
+            raw: bestQuote.toString(),
+            formatted: ethers_1.ethers.utils.formatUnits(bestQuote, tokenOutDecimals),
+        },
+        minimumOutput: {
+            raw: amountOutMin.toString(),
+            formatted: ethers_1.ethers.utils.formatUnits(amountOutMin, tokenOutDecimals),
+        },
+        slippageTolerance: `${slippageTolerance * 100}%`,
+    });
+    return { bestQuote, bestFee, amountOutMin };
+};
+exports.getUniswapQuote = getUniswapQuote;

package/dist/src/lib/policy-helpers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './get-token-amount-in-usd';
+export * from './get-uniswap-quote';
+export * from './send-spend-tx';
+export * from './sign-tx';
+export * from './check-spending-limit';
+export * from './spending-limit-contract';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/policy-helpers/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}

package/dist/src/lib/policy-helpers/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./get-token-amount-in-usd"), exports);
+tslib_1.__exportStar(require("./get-uniswap-quote"), exports);
+tslib_1.__exportStar(require("./send-spend-tx"), exports);
+tslib_1.__exportStar(require("./sign-tx"), exports);
+tslib_1.__exportStar(require("./check-spending-limit"), exports);
+tslib_1.__exportStar(require("./spending-limit-contract"), exports);