@coinbase/agentkit 0.0.0-nightly-20250808210408 → 0.0.0-nightly-20250815210416

package/dist/action-providers/cdp/cdpSmartWalletActionProvider.test.js

@@ -0,0 +1,199 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdpSmartWalletActionProvider_1 = require("./cdpSmartWalletActionProvider");
+const schemas_1 = require("./schemas");
+const spendPermissionUtils = __importStar(require("./spendPermissionUtils"));
+// Mock the CDP SDK and utility functions
+jest.mock("@coinbase/cdp-sdk");
+jest.mock("./spendPermissionUtils");
+describe("CDP Smart Wallet Action Provider", () => {
+    let actionProvider;
+    let mockWalletProvider;
+    let mockCdpClient;
+    let mockSmartAccount;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSmartAccount = {
+            useSpendPermission: jest.fn(),
+            address: "0x1234567890123456789012345678901234567890",
+        };
+        mockCdpClient = {
+            evm: {
+                listSpendPermissions: jest.fn(),
+            },
+        };
+        mockWalletProvider = {
+            getNetwork: jest.fn(),
+            getAddress: jest.fn(),
+            getClient: jest.fn(),
+            smartAccount: mockSmartAccount,
+        };
+        actionProvider = new cdpSmartWalletActionProvider_1.CdpSmartWalletActionProvider();
+    });
+    describe("listSpendPermissions", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+        });
+        it("should successfully list spend permissions for EVM networks", async () => {
+            const expectedResult = "Found 1 spend permission(s):\n1. Token: ETH, Allowance: 1000, Period: 3600 seconds, Start: 123456, End: 234567";
+            spendPermissionUtils.listSpendPermissionsForSpender.mockResolvedValue(expectedResult);
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(result).toBe(expectedResult);
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            const result = await actionProvider.listSpendPermissions(mockWalletProvider, mockArgs);
+            expect(result).toBe("Spend permissions are currently only supported on EVM networks.");
+            expect(spendPermissionUtils.listSpendPermissionsForSpender).not.toHaveBeenCalled();
+        });
+        it("should validate input schema", () => {
+            const validInput = { smartAccountAddress: "0xabcd1234567890123456789012345678901234567890" };
+            const invalidInput = { invalidField: "invalid" };
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.ListSpendPermissionsSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("useSpendPermission", () => {
+        const mockArgs = {
+            smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+            value: "1000",
+        };
+        beforeEach(() => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-sepolia",
+            });
+            mockWalletProvider.getAddress.mockReturnValue("0x1234567890123456789012345678901234567890");
+            mockWalletProvider.getClient.mockReturnValue(mockCdpClient);
+        });
+        it("should successfully use spend permission for EVM networks", async () => {
+            const mockPermission = {
+                spender: "0x1234567890123456789012345678901234567890",
+                token: "ETH",
+                allowance: "1000",
+                period: 3600,
+                start: 123456,
+                end: 234567,
+            };
+            const mockSpendResult = {
+                status: "completed",
+                transactionHash: "0xabcd1234",
+            };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            const result = await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(spendPermissionUtils.findLatestSpendPermission).toHaveBeenCalledWith(mockCdpClient, mockArgs.smartAccountAddress, "0x1234567890123456789012345678901234567890");
+            expect(mockSmartAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(1000),
+                network: "base-sepolia",
+            });
+            expect(result).toBe("Successfully spent 1000 tokens using spend permission. Status: completed");
+        });
+        it("should handle base-mainnet network conversion", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            const mockSpendResult = { status: "completed" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockResolvedValue(mockSpendResult);
+            await actionProvider.useSpendPermission(mockWalletProvider, mockArgs);
+            expect(mockSmartAccount.useSpendPermission).toHaveBeenCalledWith({
+                spendPermission: mockPermission,
+                value: BigInt(1000),
+                network: "base",
+            });
+        });
+        it("should throw error for unsupported networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            });
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: ethereum-mainnet");
+        });
+        it("should return error message for non-EVM networks", async () => {
+            mockWalletProvider.getNetwork.mockReturnValue({
+                protocolFamily: "svm",
+                networkId: "solana-devnet",
+            });
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Unsupported network for smart wallets: solana-devnet");
+        });
+        it("should handle spend permission not found error", async () => {
+            spendPermissionUtils.findLatestSpendPermission.mockRejectedValue(new Error("No spend permissions found"));
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Failed to use spend permission: Error: No spend permissions found");
+        });
+        it("should handle smart account use permission failure", async () => {
+            const mockPermission = { spender: "0x1234", token: "ETH" };
+            spendPermissionUtils.findLatestSpendPermission.mockResolvedValue(mockPermission);
+            mockSmartAccount.useSpendPermission.mockRejectedValue(new Error("Transaction failed"));
+            await expect(actionProvider.useSpendPermission(mockWalletProvider, mockArgs)).rejects.toThrow("Failed to use spend permission: Error: Transaction failed");
+        });
+        it("should validate input schema", () => {
+            const validInput = {
+                smartAccountAddress: "0xabcd1234567890123456789012345678901234567890",
+                value: "1000",
+            };
+            const invalidInput = {
+                wrongField: "0xabcd1234567890123456789012345678901234567890",
+                // Missing required fields
+            };
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(validInput)).not.toThrow();
+            expect(() => schemas_1.UseSpendPermissionSchema.parse(invalidInput)).toThrow();
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for any network", () => {
+            const evmNetwork = { protocolFamily: "evm", networkId: "base-sepolia" };
+            const svmNetwork = { protocolFamily: "svm", networkId: "solana-devnet" };
+            expect(actionProvider.supportsNetwork(evmNetwork)).toBe(true);
+            expect(actionProvider.supportsNetwork(svmNetwork)).toBe(true);
+        });
+    });
+});

package/dist/action-providers/cdp/index.d.ts

@@ -1,2 +1,5 @@
 export * from "./schemas";
 export * from "./cdpApiActionProvider";
+export * from "./cdpSmartWalletActionProvider";
+export * from "./cdpEvmWalletActionProvider";
+export * from "./spendPermissionUtils";

package/dist/action-providers/cdp/index.js

@@ -16,3 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./schemas"), exports);
 __exportStar(require("./cdpApiActionProvider"), exports);
+__exportStar(require("./cdpSmartWalletActionProvider"), exports);
+__exportStar(require("./cdpEvmWalletActionProvider"), exports);
+__exportStar(require("./spendPermissionUtils"), exports);

package/dist/action-providers/cdp/schemas.d.ts

@@ -28,3 +28,32 @@ export declare const SwapSchema: z.ZodObject<{
     toAssetId: string;
     network?: string | undefined;
 }>;
+/**
+ * Input schema for listing spend permissions action.
+ */
+export declare const ListSpendPermissionsSchema: z.ZodObject<{
+    smartAccountAddress: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    smartAccountAddress: string;
+    network?: string | undefined;
+}, {
+    smartAccountAddress: string;
+    network?: string | undefined;
+}>;
+/**
+ * Input schema for using a spend permission action.
+ */
+export declare const UseSpendPermissionSchema: z.ZodObject<{
+    smartAccountAddress: z.ZodString;
+    value: z.ZodString;
+    network: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    smartAccountAddress: string;
+    network?: string | undefined;
+}, {
+    value: string;
+    smartAccountAddress: string;
+    network?: string | undefined;
+}>;

package/dist/action-providers/cdp/schemas.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapSchema = exports.RequestFaucetFundsV2Schema = void 0;
+exports.UseSpendPermissionSchema = exports.ListSpendPermissionsSchema = exports.SwapSchema = exports.RequestFaucetFundsV2Schema = void 0;
 const zod_1 = require("zod");
 /**
  * Input schema for request faucet funds action.
@@ -26,3 +26,34 @@ exports.SwapSchema = zod_1.z
 })
     .strip()
     .describe("Instructions for swapping tokens");
+/**
+ * Input schema for listing spend permissions action.
+ */
+exports.ListSpendPermissionsSchema = zod_1.z
+    .object({
+    smartAccountAddress: zod_1.z
+        .string()
+        .describe("The smart account address that has granted spend permissions"),
+    network: zod_1.z
+        .string()
+        .optional()
+        .describe("The network to list permissions on (defaults to wallet's network)"),
+})
+    .strip()
+    .describe("Instructions for listing spend permissions for a smart account");
+/**
+ * Input schema for using a spend permission action.
+ */
+exports.UseSpendPermissionSchema = zod_1.z
+    .object({
+    smartAccountAddress: zod_1.z
+        .string()
+        .describe("The smart account address that has granted the spend permission"),
+    value: zod_1.z.string().describe("The amount to spend (in the token's units)"),
+    network: zod_1.z
+        .string()
+        .optional()
+        .describe("The network to perform the spend on (defaults to wallet's network)"),
+})
+    .strip()
+    .describe("Instructions for using a spend permission");

package/dist/action-providers/cdp/spendPermissionUtils.d.ts

@@ -0,0 +1,24 @@
+import { CdpClient, type SpendPermission } from "@coinbase/cdp-sdk";
+import type { Address } from "viem";
+/**
+ * Shared utility functions for spend permission operations.
+ */
+/**
+ * Lists and formats spend permissions for a given smart account and spender.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to filter permissions by
+ * @returns A formatted string containing the spend permissions or an error message
+ */
+export declare function listSpendPermissionsForSpender(cdpClient: CdpClient, smartAccountAddress: Address, spenderAddress: Address): Promise<string>;
+/**
+ * Finds and retrieves the latest valid spend permission for a given spender from a smart account.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to find permissions for
+ * @returns The latest spend permission or throws an error if none found
+ * @throws Error if no permissions found or permission is invalid
+ */
+export declare function findLatestSpendPermission(cdpClient: CdpClient, smartAccountAddress: Address, spenderAddress: Address): Promise<SpendPermission>;

package/dist/action-providers/cdp/spendPermissionUtils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSpendPermissionsForSpender = listSpendPermissionsForSpender;
+exports.findLatestSpendPermission = findLatestSpendPermission;
+/**
+ * Shared utility functions for spend permission operations.
+ */
+/**
+ * Lists and formats spend permissions for a given smart account and spender.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to filter permissions by
+ * @returns A formatted string containing the spend permissions or an error message
+ */
+async function listSpendPermissionsForSpender(cdpClient, smartAccountAddress, spenderAddress) {
+    try {
+        // List all spend permissions for the smart account
+        const allPermissions = await cdpClient.evm.listSpendPermissions({
+            address: smartAccountAddress,
+        });
+        // Filter permissions where current wallet is the spender
+        const relevantPermissions = allPermissions.spendPermissions.filter(p => p.permission?.spender.toLowerCase() === spenderAddress.toLowerCase());
+        if (relevantPermissions.length === 0) {
+            return `No spend permissions found for spender ${spenderAddress} on smart account ${smartAccountAddress}`;
+        }
+        // Format the permissions for display
+        const formattedPermissions = relevantPermissions
+            .map((p, index) => {
+            const perm = p.permission;
+            if (!perm)
+                return `${index + 1}. Invalid permission`;
+            return `${index + 1}. Token: ${perm.token}, Allowance: ${perm.allowance}, Period: ${perm.period} seconds, Start: ${perm.start}, End: ${perm.end}`;
+        })
+            .join("\n");
+        return `Found ${relevantPermissions.length} spend permission(s):\n${formattedPermissions}`;
+    }
+    catch (error) {
+        return `Failed to list spend permissions: ${error}`;
+    }
+}
+/**
+ * Finds and retrieves the latest valid spend permission for a given spender from a smart account.
+ *
+ * @param cdpClient - The CDP client to use for API calls
+ * @param smartAccountAddress - The smart account address to check permissions for
+ * @param spenderAddress - The spender address to find permissions for
+ * @returns The latest spend permission or throws an error if none found
+ * @throws Error if no permissions found or permission is invalid
+ */
+async function findLatestSpendPermission(cdpClient, smartAccountAddress, spenderAddress) {
+    const allPermissions = await cdpClient.evm.listSpendPermissions({
+        address: smartAccountAddress,
+    });
+    // Filter permissions where current wallet is the spender
+    const relevantPermissions = allPermissions.spendPermissions.filter(p => p.permission?.spender.toLowerCase() === spenderAddress.toLowerCase());
+    if (relevantPermissions.length === 0) {
+        throw new Error(`No spend permissions found for spender ${spenderAddress} on smart account ${smartAccountAddress}`);
+    }
+    // Use the latest permission (last in the array)
+    const latestPermissionWrapper = relevantPermissions.at(-1);
+    if (!latestPermissionWrapper?.permission) {
+        throw new Error("Invalid spend permission found");
+    }
+    return latestPermissionWrapper.permission;
+}

package/dist/action-providers/flaunch/flaunchActionProvider.js

@@ -209,11 +209,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
                 signature = await walletProvider.signTypedData(typedData);
                 permitSingle = message;
             }
-            const viemPublicClient = (0, viem_1.createPublicClient)({
-                chain: network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId],
-                transport: (0, viem_1.http)(),
-            });
-            const quoteResult = await viemPublicClient.simulateContract({
+            const quoteResult = await walletProvider.getPublicClient().simulateContract({
                 address: constants_1.QuoterAddress[chainId],
                 abi: constants_1.QUOTER_ABI,
                 functionName: "quoteExactInput",
@@ -308,17 +304,13 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
             throw new Error("Chain ID is not set.");
         }
         try {
-            const viemPublicClient = (0, viem_1.createPublicClient)({
-                chain: network_1.NETWORK_ID_TO_VIEM_CHAIN[networkId],
-                transport: (0, viem_1.http)(),
-            });
             let amountIn;
             let amountOutMin;
             let amountOut;
             let amountInMax;
             if (swapType === "EXACT_IN") {
                 amountIn = (0, viem_1.parseEther)(swapParams.amountIn);
-                const quoteResult = await viemPublicClient.simulateContract({
+                const quoteResult = await walletProvider.getPublicClient().simulateContract({
                     address: constants_1.QuoterAddress[chainId],
                     abi: constants_1.QUOTER_ABI,
                     functionName: "quoteExactInput",
@@ -351,7 +343,7 @@ class FlaunchActionProvider extends actionProvider_1.ActionProvider {
             else {
                 // EXACT_OUT
                 amountOut = (0, viem_1.parseEther)(swapParams.amountOut);
-                const quoteResult = await viemPublicClient.simulateContract({
+                const quoteResult = await walletProvider.getPublicClient().simulateContract({
                     address: constants_1.QuoterAddress[chainId],
                     abi: constants_1.QUOTER_ABI,
                     functionName: "quoteExactOutput",

package/dist/action-providers/flaunch/flaunchActionProvider.test.js

@@ -116,6 +116,11 @@ describe("FlaunchActionProvider", () => {
                 return undefined;
             }),
             signTypedData: jest.fn().mockResolvedValue("0xsignature"),
+            getPublicClient: jest.fn().mockReturnValue({
+                simulateContract: jest.fn().mockResolvedValue({
+                    result: [BigInt(1000000000000000000)],
+                }),
+            }),
         };
     });
     describe("network support", () => {

package/dist/action-providers/truemarkets/truemarketsActionProvider.d.ts

@@ -4,25 +4,13 @@ import { Network } from "../../network";
 import { GetTruthMarketsSchema, GetTruthMarketDetailsSchema } from "./schemas";
 import { EvmWalletProvider } from "../../wallet-providers";
 /**
- * Configuration options for the TrueMarketsActionProvider.
- */
-export interface TrueMarketsActionProviderConfig {
-    /**
-     * RPC URL for creating the Viem public client
-     */
-    RPC_URL?: string;
-}
-/**
- * TrueMarketsActionProvider provides actions to interact with TrueMarkets contracts.
+ * Action provider for TrueMarkets interactions.
  */
 export declare class TrueMarketsActionProvider extends ActionProvider<EvmWalletProvider> {
-    #private;
     /**
-     * Constructor for the TrueMarketsActionProvider.
-     *
-     * @param config - The configuration options for the TrueMarketsActionProvider.
+     * Creates a new TrueMarkets action provider.
      */
-    constructor(config?: TrueMarketsActionProviderConfig);
+    constructor();
     /**
      * Gets active markets from the TruthMarketManager contract.
      *
@@ -48,4 +36,4 @@ export declare class TrueMarketsActionProvider extends ActionProvider<EvmWalletP
      */
     supportsNetwork: (network: Network) => boolean;
 }
-export declare const truemarketsActionProvider: (config?: TrueMarketsActionProviderConfig) => TrueMarketsActionProvider;
+export declare const truemarketsActionProvider: () => TrueMarketsActionProvider;

package/dist/action-providers/truemarkets/truemarketsActionProvider.js

@@ -8,18 +8,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _TrueMarketsActionProvider_publicClient;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truemarketsActionProvider = exports.TrueMarketsActionProvider = void 0;
 const zod_1 = require("zod");
@@ -30,19 +18,15 @@ const constants_1 = require("./constants");
 const constants_2 = require("../erc20/constants");
 const wallet_providers_1 = require("../../wallet-providers");
 const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
 /**
- * TrueMarketsActionProvider provides actions to interact with TrueMarkets contracts.
+ * Action provider for TrueMarkets interactions.
  */
 class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
     /**
-     * Constructor for the TrueMarketsActionProvider.
-     *
-     * @param config - The configuration options for the TrueMarketsActionProvider.
+     * Creates a new TrueMarkets action provider.
      */
-    constructor(config) {
+    constructor() {
         super("truemarkets", []);
-        _TrueMarketsActionProvider_publicClient.set(this, void 0);
         /**
          * Checks if the TrueMarkets action provider supports the given network.
          * Currently only supports Base mainnet.
@@ -51,10 +35,6 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
          * @returns True if the TrueMarkets action provider supports the network, false otherwise.
          */
         this.supportsNetwork = (network) => network.networkId === "base-mainnet";
-        __classPrivateFieldSet(this, _TrueMarketsActionProvider_publicClient, (0, viem_1.createPublicClient)({
-            chain: chains_1.base,
-            transport: config?.RPC_URL ? (0, viem_1.http)(config.RPC_URL) : (0, viem_1.http)(),
-        }), "f");
     }
     /**
      * Gets active markets from the TruthMarketManager contract.
@@ -105,7 +85,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                 functionName: "getActiveMarketAddress",
                 args: [BigInt(index)],
             }));
-            const marketAddresses = await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").multicall({
+            const marketAddresses = await walletProvider.getPublicClient().multicall({
                 contracts: addressCalls,
             });
             // Filter out errors and extract results
@@ -124,7 +104,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                 abi: constants_1.TruthMarketABI,
                 functionName: "marketQuestion",
             }));
-            const marketQuestionsResult = await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").multicall({
+            const marketQuestionsResult = await walletProvider.getPublicClient().multicall({
                 contracts: questionCalls,
             });
             // Create market objects mapping indices to addresses and questions
@@ -175,7 +155,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                     });
                 }
                 try {
-                    marketAddress = (await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").readContract({
+                    marketAddress = (await walletProvider.getPublicClient().readContract({
                         address: constants_1.TruthMarketManager_ADDRESS,
                         abi: constants_1.TruthMarketManagerABI,
                         functionName: "getActiveMarketAddress",
@@ -227,7 +207,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                     functionName: "winningPosition",
                 },
             ];
-            const basicInfoResults = await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").multicall({
+            const basicInfoResults = await walletProvider.getPublicClient().multicall({
                 contracts: basicInfoCalls,
             });
             // Extract results, handling potential errors
@@ -279,7 +259,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                     functionName: "slot0",
                 },
             ];
-            const poolInfoResults = await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").multicall({
+            const poolInfoResults = await walletProvider.getPublicClient().multicall({
                 contracts: poolInfoCalls,
             });
             if (poolInfoResults.some(result => result.status === "failure")) {
@@ -331,7 +311,7 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
                     args: [noPool],
                 },
             ];
-            const balanceResults = await __classPrivateFieldGet(this, _TrueMarketsActionProvider_publicClient, "f").multicall({
+            const balanceResults = await walletProvider.getPublicClient().multicall({
                 contracts: balanceCalls,
             });
             if (balanceResults.some(result => result.status === "failure")) {
@@ -430,7 +410,6 @@ class TrueMarketsActionProvider extends actionProvider_1.ActionProvider {
     }
 }
 exports.TrueMarketsActionProvider = TrueMarketsActionProvider;
-_TrueMarketsActionProvider_publicClient = new WeakMap();
 __decorate([
     (0, actionDecorator_1.CreateAction)({
         name: "get_prediction_markets",
@@ -465,5 +444,5 @@ __decorate([
     __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
     __metadata("design:returntype", Promise)
 ], TrueMarketsActionProvider.prototype, "getPredictionMarketDetails", null);
-const truemarketsActionProvider = (config) => new TrueMarketsActionProvider(config);
+const truemarketsActionProvider = () => new TrueMarketsActionProvider();
 exports.truemarketsActionProvider = truemarketsActionProvider;