@coinbase/agentkit 0.0.0-nightly-20250820210426 → 0.0.0-nightly-20250821210420

package/dist/action-providers/superfluid/superfluidSuperTokenCreatorActionProvider.js

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superfluidSuperTokenCreatorActionProvider = exports.SuperfluidSuperTokenCreatorActionProvider = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const constants_2 = require("../erc20/constants");
+const parseLogs_1 = require("./utils/parseLogs");
+/**
+ * SuperfluidSuperTokenCreatorActionProvider is an action provider for Superfluid interactions.
+ */
+class SuperfluidSuperTokenCreatorActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SuperfluidSuperTokenCreatorActionProvider class.
+     */
+    constructor() {
+        super("superfluid-super-token-creator", []);
+        /**
+         * Checks if the Superfluid action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Superfluid action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+    }
+    /**
+     * Creates a new Super token
+     *
+     * @param walletProvider - The wallet provider to start the stream from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    async createSuperToken(walletProvider, args) {
+        try {
+            const decimals = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: constants_2.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const name = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: constants_2.abi,
+                functionName: "name",
+                args: [],
+            });
+            const symbol = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: constants_2.abi,
+                functionName: "symbol",
+                args: [],
+            });
+            const createSuperTokenData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.SuperTokenFactoryABI,
+                functionName: "createERC20Wrapper",
+                args: [
+                    args.erc20TokenAddress,
+                    decimals,
+                    2, // upgradeable
+                    `Super ${name}`,
+                    `${symbol}x`,
+                ],
+            });
+            const createSuperTokenHash = await walletProvider.sendTransaction({
+                to: walletProvider.getNetwork().networkId === "base-sepolia"
+                    ? constants_1.SuperTokenFactoryAddress_Base_Sepolia
+                    : constants_1.SuperTokenFactoryAddress,
+                data: createSuperTokenData,
+            });
+            const receipt = await walletProvider.waitForTransactionReceipt(createSuperTokenHash);
+            const superTokenAddress = (0, parseLogs_1.extractCreatedSuperTokenAddressAbi)(receipt);
+            return `Created super token for ${args.erc20TokenAddress}.  Super token address at ${superTokenAddress}  Transaction hash: ${createSuperTokenHash}`;
+        }
+        catch (error) {
+            return `Error creating Superfluid Super Token: ${error}`;
+        }
+    }
+}
+exports.SuperfluidSuperTokenCreatorActionProvider = SuperfluidSuperTokenCreatorActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "create_super_token",
+        description: `
+This action will create a Super token, essentially a wrapper token around an ERC20 that can freely stream between wallets.
+It will return the address of the newly created Supertoken.
+You should only take this action when requested.  A Supertoken implementation is needed to stream tokens or to wrap an ERC20 token.
+`,
+        schema: schemas_1.SuperfluidCreateSuperTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidSuperTokenCreatorActionProvider.prototype, "createSuperToken", null);
+const superfluidSuperTokenCreatorActionProvider = () => new SuperfluidSuperTokenCreatorActionProvider();
+exports.superfluidSuperTokenCreatorActionProvider = superfluidSuperTokenCreatorActionProvider;

package/dist/action-providers/superfluid/superfluidSuperTokenCreatorActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/superfluid/superfluidSuperTokenCreatorActionProvider.test.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const superfluidSuperTokenCreatorActionProvider_1 = require("./superfluidSuperTokenCreatorActionProvider");
+describe("SuperfluidSuperTokenCreatorActionProvider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_ERC20_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_DECIMALS = 18;
+    const MOCK_NAME = "TestToken";
+    const MOCK_SYMBOL = "TT";
+    let mockWallet;
+    const actionProvider = (0, superfluidSuperTokenCreatorActionProvider_1.superfluidSuperTokenCreatorActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm" }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            readContract: jest.fn(),
+            call: jest.fn(),
+        };
+        mockWallet.sendTransaction.mockResolvedValue("0xmockhash");
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+        mockWallet.readContract.mockImplementation(async ({ address, functionName, args }) => {
+            if (functionName === "decimals")
+                return MOCK_DECIMALS;
+            if (functionName === "name")
+                return MOCK_NAME;
+            if (functionName === "symbol")
+                return MOCK_SYMBOL;
+            throw new Error(`No mock for ${functionName}(${JSON.stringify(args)}) @ ${address}`);
+        });
+    });
+    describe("create super token", () => {
+        it("should successfully create a superfluid super token", async () => {
+            const args = {
+                erc20TokenAddress: MOCK_ERC20_CONTRACT,
+            };
+            await actionProvider.createSuperToken(mockWallet, args);
+            const createSuperTokenData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.SuperTokenFactoryABI,
+                functionName: "createERC20Wrapper",
+                args: [
+                    args.erc20TokenAddress,
+                    MOCK_DECIMALS,
+                    2, // upgradeable
+                    `Super ${MOCK_NAME}`,
+                    `${MOCK_SYMBOL}x`,
+                ],
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: constants_1.SuperTokenFactoryAddress,
+                data: createSuperTokenData,
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for Base", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false for non-base networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "bitcoin",
+                networkId: "any",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/action-providers/superfluid/superfluidWrapperActionProvider.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { SuperfluidWrapTokenSchema } from "./schemas";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * SuperfluidStreamActionProvider is an action provider for wrapping superfluid token.
+ */
+export declare class SuperfluidWrapperActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SuperfluidWrapperActionProvider class.
+     */
+    constructor();
+    /**
+     * Wraps a token to a Super token
+     * The Super token must already exist
+     * If it does not, see SuperfluidCreateSuperTokenAction
+     *
+     * @param walletProvider - The wallet provider to start the stream from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    wrapToken(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidWrapTokenSchema>): Promise<string>;
+    /**
+     * Checks if the Superfluid action provider supports the given network.
+     *
+     * @param network - The network to check.
+     * @returns True if the Superfluid action provider supports the network, false otherwise.
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const superfluidWrapperActionProvider: () => SuperfluidWrapperActionProvider;

package/dist/action-providers/superfluid/superfluidWrapperActionProvider.js

@@ -0,0 +1,101 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superfluidWrapperActionProvider = exports.SuperfluidWrapperActionProvider = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("./schemas");
+const constants_1 = require("./constants");
+const viem_1 = require("viem");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const constants_2 = require("../erc20/constants");
+/**
+ * SuperfluidStreamActionProvider is an action provider for wrapping superfluid token.
+ */
+class SuperfluidWrapperActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SuperfluidWrapperActionProvider class.
+     */
+    constructor() {
+        super("superfluid-wrap", []);
+        /**
+         * Checks if the Superfluid action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Superfluid action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+    }
+    /**
+     * Wraps a token to a Super token
+     * The Super token must already exist
+     * If it does not, see SuperfluidCreateSuperTokenAction
+     *
+     * @param walletProvider - The wallet provider to start the stream from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    async wrapToken(walletProvider, args) {
+        try {
+            const decimals = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: constants_2.abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const amount = (0, viem_1.parseUnits)(String(args.wrapAmount), Number(decimals));
+            const approveData = (0, viem_1.encodeFunctionData)({
+                abi: constants_2.abi,
+                functionName: "approve",
+                args: [args.superTokenAddress, amount],
+            });
+            const approveHash = await walletProvider.sendTransaction({
+                to: args.erc20TokenAddress,
+                data: approveData,
+            });
+            await walletProvider.waitForTransactionReceipt(approveHash);
+            const wrapData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.ISuperTokenAbi,
+                functionName: "upgrade",
+                args: [amount],
+            });
+            const wrapHash = await walletProvider.sendTransaction({
+                to: args.superTokenAddress,
+                data: wrapData,
+            });
+            await walletProvider.waitForTransactionReceipt(wrapHash);
+            return `Wrapped ${args.wrapAmount} of token ${args.erc20TokenAddress} as a SuperToken.  Transaction hash: ${wrapHash}`;
+        }
+        catch (error) {
+            return `Error wrapping Superfluid token: ${error}`;
+        }
+    }
+}
+exports.SuperfluidWrapperActionProvider = SuperfluidWrapperActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "wrap_superfluid_token",
+        description: `
+This tool will directly wrap an amount of ERC20 tokens into its corresponding Super token.
+The user must provide the erc20 address, and the super token address.
+If this fails, the most likely culprits are:
+1. You don't own any of the ERC20 token, or
+2. The Super token does not exist.  If it does not exist, suggest the user create the Super token with your SuperTokenCreator action.
+        `,
+        schema: schemas_1.SuperfluidWrapTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidWrapperActionProvider.prototype, "wrapToken", null);
+const superfluidWrapperActionProvider = () => new SuperfluidWrapperActionProvider();
+exports.superfluidWrapperActionProvider = superfluidWrapperActionProvider;

package/dist/action-providers/superfluid/superfluidWrapperActionProvider.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action-providers/superfluid/superfluidWrapperActionProvider.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const superfluidWrapperActionProvider_1 = require("./superfluidWrapperActionProvider");
+const constants_2 = require("../erc20/constants");
+describe("SuperfluidWrapperActionProvider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_ERC20_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_SUPERTOKEN_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_WRAP_AMOUNT = 100;
+    const MOCK_DECIMALS = 18;
+    const MOCK_NAME = "TestToken";
+    const MOCK_SYMBOL = "TT";
+    let mockWallet;
+    const actionProvider = (0, superfluidWrapperActionProvider_1.superfluidWrapperActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm" }),
+            sendTransaction: jest.fn(),
+            waitForTransactionReceipt: jest.fn(),
+            readContract: jest.fn(),
+            call: jest.fn(),
+        };
+        mockWallet.sendTransaction.mockResolvedValue("0xmockhash");
+        mockWallet.waitForTransactionReceipt.mockResolvedValue({});
+        mockWallet.readContract.mockImplementation(async ({ address, functionName, args }) => {
+            if (functionName === "decimals")
+                return MOCK_DECIMALS;
+            if (functionName === "name")
+                return MOCK_NAME;
+            if (functionName === "symbol")
+                return MOCK_SYMBOL;
+            throw new Error(`No mock for ${functionName}(${JSON.stringify(args)}) @ ${address}`);
+        });
+    });
+    describe("wraps an erc20 into a super token", () => {
+        it("should successfully wrap an erc20 to a super token", async () => {
+            const args = {
+                erc20TokenAddress: MOCK_ERC20_CONTRACT,
+                superTokenAddress: MOCK_SUPERTOKEN_CONTRACT,
+                wrapAmount: MOCK_WRAP_AMOUNT,
+            };
+            await actionProvider.wrapToken(mockWallet, args);
+            const amount = (0, viem_1.parseUnits)(String(args.wrapAmount), Number(MOCK_DECIMALS));
+            const approveData = (0, viem_1.encodeFunctionData)({
+                abi: constants_2.abi,
+                functionName: "approve",
+                args: [MOCK_SUPERTOKEN_CONTRACT, amount],
+            });
+            const wrapData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.ISuperTokenAbi,
+                functionName: "upgrade",
+                args: [amount],
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledTimes(2);
+            expect(mockWallet.sendTransaction).toHaveBeenNthCalledWith(1, {
+                to: MOCK_ERC20_CONTRACT,
+                data: approveData,
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenNthCalledWith(2, {
+                to: MOCK_SUPERTOKEN_CONTRACT,
+                data: wrapData,
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for Base", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false for non-base networks", () => {
+            const result = actionProvider.supportsNetwork({
+                protocolFamily: "bitcoin",
+                networkId: "any",
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/action-providers/superfluid/utils/parseLogs.d.ts

@@ -0,0 +1,18 @@
+import { type Hex } from "viem";
+type RawLog = {
+    address: `0x${string}`;
+    data: Hex;
+    topics: readonly `0x${string}`[];
+};
+type TxReceipt = {
+    to?: `0x${string}` | null;
+    logs: RawLog[];
+};
+/**
+ * Extracts the super token address using the contract abi
+ *
+ * @param receipt - the transaction receipt from creating the super token
+ * @returns - The contract address of the created Super Token
+ */
+export declare function extractCreatedSuperTokenAddressAbi(receipt: TxReceipt): `0x${string}`;
+export {};

package/dist/action-providers/superfluid/utils/parseLogs.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCreatedSuperTokenAddressAbi = extractCreatedSuperTokenAddressAbi;
+const constants_1 = require("../constants");
+const viem_1 = require("viem");
+/**
+ * Casts the topics to a tuple
+ *
+ * @param topics - the topics to search for
+ * @returns - A tuple of topics
+ */
+function asTopicTuple(topics) {
+    if (!topics.length) {
+        throw new Error("Log has no topics (anonymous event?)");
+    }
+    return [topics[0], ...topics.slice(1)];
+}
+/**
+ * Checks for records to avoid any cast
+ *
+ * @param value - The value to check
+ * @returns - A boolean if the record is valid
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+const TOKEN_KEYS = ["token", "superToken", "proxy"];
+/**
+ * Pulls a 0x-address string from decoded args under one of: token | superToken | proxy
+ *
+ * @param args - The unknown value to check
+ * @returns - A contract address of the super token, or null
+ */
+function pickTokenLike(args) {
+    if (!isRecord(args))
+        return null;
+    for (const key of TOKEN_KEYS) {
+        const v = args[key];
+        if (typeof v === "string" && v.startsWith("0x")) {
+            return v;
+        }
+    }
+    return null;
+}
+/**
+ * Extracts the super token address using the contract abi
+ *
+ * @param receipt - the transaction receipt from creating the super token
+ * @returns - The contract address of the created Super Token
+ */
+function extractCreatedSuperTokenAddressAbi(receipt) {
+    const factory = receipt.to?.toLowerCase();
+    if (!factory)
+        throw new Error("Missing receipt.to (factory address)");
+    for (const log of receipt.logs) {
+        if (log.address.toLowerCase() !== factory)
+            continue;
+        if (!log.topics.length)
+            continue; // skip anonymous logs
+        try {
+            const { eventName, args } = (0, viem_1.decodeEventLog)({
+                abi: constants_1.SuperTokenFactoryABI,
+                data: log.data,
+                topics: asTopicTuple(log.topics),
+            });
+            if (eventName === "SuperTokenCreated") {
+                const token = pickTokenLike(args);
+                if (!token)
+                    throw new Error("Token arg missing on SuperTokenCreated");
+                return (0, viem_1.getAddress)(token);
+            }
+        }
+        catch {
+            // not a matching event for this signature — ignore
+        }
+    }
+    throw new Error("SuperTokenCreated not found on factory logs");
+}

package/dist/wallet-providers/cdpSmartWalletProvider.d.ts

@@ -1,5 +1,5 @@
-import { CdpClient, EvmSmartAccount } from "@coinbase/cdp-sdk";
-import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicClient, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
+import { CdpClient, EvmSmartAccount, EvmServerAccount } from "@coinbase/cdp-sdk";
+import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, PublicClient, ReadContractParameters, ReadContractReturnType, TransactionRequest, LocalAccount } from "viem";
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
 import { WalletProviderWithClient, CdpSmartWalletProviderConfig } from "./cdpShared";
@@ -9,6 +9,7 @@ import { WalletProviderWithClient, CdpSmartWalletProviderConfig } from "./cdpSha
 export declare class CdpSmartWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
     smartAccount: EvmSmartAccount;
+    ownerAccount: LocalAccount | EvmServerAccount;
     /**
      * Constructs a new CdpSmartWalletProvider.
      *

package/dist/wallet-providers/cdpSmartWalletProvider.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _CdpSmartWalletProvider_instances, _CdpSmartWalletProvider_publicClient, _CdpSmartWalletProvider_ownerAccount, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_paymasterUrl, _CdpSmartWalletProvider_getCdpSdkNetwork;
+var _CdpSmartWalletProvider_instances, _CdpSmartWalletProvider_publicClient, _CdpSmartWalletProvider_cdp, _CdpSmartWalletProvider_network, _CdpSmartWalletProvider_paymasterUrl, _CdpSmartWalletProvider_getCdpSdkNetwork;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CdpSmartWalletProvider = void 0;
 const cdp_sdk_1 = require("@coinbase/cdp-sdk");
@@ -30,12 +30,11 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         super();
         _CdpSmartWalletProvider_instances.add(this);
         _CdpSmartWalletProvider_publicClient.set(this, void 0);
-        _CdpSmartWalletProvider_ownerAccount.set(this, void 0);
         _CdpSmartWalletProvider_cdp.set(this, void 0);
         _CdpSmartWalletProvider_network.set(this, void 0);
         _CdpSmartWalletProvider_paymasterUrl.set(this, void 0);
         this.smartAccount = config.smartAccount;
-        __classPrivateFieldSet(this, _CdpSmartWalletProvider_ownerAccount, config.ownerAccount, "f");
+        this.ownerAccount = config.ownerAccount;
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_cdp, config.cdp, "f");
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_publicClient, config.publicClient, "f");
         __classPrivateFieldSet(this, _CdpSmartWalletProvider_network, config.network, "f");
@@ -115,7 +114,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         return {
             name: this.smartAccount.name,
             address: this.smartAccount.address,
-            ownerAddress: __classPrivateFieldGet(this, _CdpSmartWalletProvider_ownerAccount, "f").address,
+            ownerAddress: this.ownerAccount.address,
         };
     }
     /**
@@ -272,7 +271,7 @@ class CdpSmartWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
     }
 }
 exports.CdpSmartWalletProvider = CdpSmartWalletProvider;
-_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_ownerAccount = new WeakMap(), _CdpSmartWalletProvider_cdp = new WeakMap(), _CdpSmartWalletProvider_network = new WeakMap(), _CdpSmartWalletProvider_paymasterUrl = new WeakMap(), _CdpSmartWalletProvider_instances = new WeakSet(), _CdpSmartWalletProvider_getCdpSdkNetwork = function _CdpSmartWalletProvider_getCdpSdkNetwork() {
+_CdpSmartWalletProvider_publicClient = new WeakMap(), _CdpSmartWalletProvider_cdp = new WeakMap(), _CdpSmartWalletProvider_network = new WeakMap(), _CdpSmartWalletProvider_paymasterUrl = new WeakMap(), _CdpSmartWalletProvider_instances = new WeakSet(), _CdpSmartWalletProvider_getCdpSdkNetwork = function _CdpSmartWalletProvider_getCdpSdkNetwork() {
     switch (__classPrivateFieldGet(this, _CdpSmartWalletProvider_network, "f").networkId) {
         case "base-sepolia":
             return "base-sepolia";

package/dist/wallet-providers/viemWalletProvider.d.ts

@@ -13,6 +13,10 @@ export interface ViemWalletProviderGasConfig {
      * An internal multiplier on fee per gas estimation.
      */
     feePerGasMultiplier?: number;
+    /**
+     * Optional RPC URL override for Viem public client.
+     */
+    rpcUrl?: string;
 }
 /**
  * A wallet provider that uses the Viem library.

package/dist/wallet-providers/viemWalletProvider.js

@@ -36,9 +36,10 @@ class ViemWalletProvider extends evmWalletProvider_1.EvmWalletProvider {
         _ViemWalletProvider_gasLimitMultiplier.set(this, void 0);
         _ViemWalletProvider_feePerGasMultiplier.set(this, void 0);
         __classPrivateFieldSet(this, _ViemWalletProvider_walletClient, walletClient, "f");
+        const rpcUrl = gasConfig?.rpcUrl || process.env.RPC_URL;
         __classPrivateFieldSet(this, _ViemWalletProvider_publicClient, (0, viem_1.createPublicClient)({
             chain: walletClient.chain,
-            transport: (0, viem_1.http)(),
+            transport: rpcUrl ? (0, viem_1.http)(rpcUrl) : (0, viem_1.http)(),
         }), "f");
         __classPrivateFieldSet(this, _ViemWalletProvider_gasLimitMultiplier, Math.max(gasConfig?.gasLimitMultiplier ?? 1.2, 1), "f");
         __classPrivateFieldSet(this, _ViemWalletProvider_feePerGasMultiplier, Math.max(gasConfig?.feePerGasMultiplier ?? 1, 1), "f");

package/package.json

@@ -2,7 +2,7 @@
   "name": "@coinbase/agentkit",
   "description": "Coinbase AgentKit core primitives",
   "repository": "https://github.com/coinbase/agentkit",
-  "version": "0.0.0-nightly-20250820210426",
+  "version": "0.0.0-nightly-20250821210420",
   "author": "Coinbase Inc.",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
   "dependencies": {
     "@across-protocol/app-sdk": "^0.2.0",
     "@alloralabs/allora-sdk": "^0.1.0",
-    "@coinbase/cdp-sdk": "^1.34.0",
+    "@coinbase/cdp-sdk": "^1.36.0",
     "@coinbase/coinbase-sdk": "^0.20.0",
     "@jup-ag/api": "^6.0.39",
     "@privy-io/public-api": "2.18.5",
@@ -40,6 +40,7 @@
     "canonicalize": "^2.1.0",
     "decimal.js": "^10.5.0",
     "ethers": "^6.13.5",
+    "graphql-request": "^7.2.0",
     "md5": "^2.3.0",
     "opensea-js": "^7.1.18",
     "reflect-metadata": "^0.2.2",