@coinbase/agentkit 0.9.1 → 0.10.0

package/dist/action-providers/zerion/types.d.ts

@@ -0,0 +1,125 @@
+export interface ZerionFungiblePositionsResponse {
+    links: {
+        self: string;
+    };
+    data: ZerionFungiblePosition[];
+}
+export interface ZerionPortfolioResponse {
+    links: {
+        self: string;
+    };
+    data: ZerionPortfolio;
+}
+export interface ZerionPortfolio {
+    type: string;
+    id: string;
+    attributes: PortfolioAttributes;
+}
+export interface PortfolioAttributes {
+    positions_distribution_by_type: {
+        wallet: number;
+        deposited: number;
+        borrowed: number;
+        locked: number;
+        staked: number;
+    };
+    positions_distribution_by_chain: {
+        [key: string]: number;
+    };
+    total: {
+        positions: number;
+    };
+    changes: {
+        absolute_1d: number;
+        percent_1d: number;
+    };
+}
+export interface ZerionFungiblePosition {
+    type: string;
+    id: string;
+    attributes: FungibleAttributes;
+    relationships: Relationships;
+}
+export interface FungibleAttributes {
+    parent: null | string;
+    protocol: null | string;
+    pool_address?: string;
+    group_id?: string;
+    name: string;
+    position_type: PositionType;
+    quantity: Quantity;
+    value: number | null;
+    price: number;
+    changes: Changes | null;
+    fungible_info: FungibleInfo;
+    flags: AttributesFlags;
+    updated_at: Date;
+    updated_at_block: number | null;
+    application_metadata?: ApplicationMetadata;
+}
+export interface ApplicationMetadata {
+    name: string;
+    icon: Icon;
+    url: string;
+}
+export interface Icon {
+    url: string;
+}
+export interface Changes {
+    absolute_1d: number;
+    percent_1d: number;
+}
+export interface AttributesFlags {
+    displayable: boolean;
+    is_trash: boolean;
+}
+export interface FungibleInfo {
+    name: string;
+    symbol: string;
+    icon: Icon | null;
+    flags: FungibleInfoFlags;
+    implementations: Implementation[];
+}
+export interface FungibleInfoFlags {
+    verified: boolean;
+}
+export interface Implementation {
+    chain_id: string;
+    address: null | string;
+    decimals: number;
+}
+export declare enum PositionType {
+    Deposit = "deposit",
+    Reward = "reward",
+    Staked = "staked",
+    Wallet = "wallet"
+}
+export interface Quantity {
+    int: string;
+    decimals: number;
+    float: number;
+    numeric: string;
+}
+export interface Relationships {
+    chain: Chain;
+    dapp?: Dapp;
+    fungible: Chain;
+}
+export interface Dapp {
+    data: Data;
+}
+export interface Chain {
+    links: {
+        related: string;
+    };
+    data: Data;
+}
+export interface Data {
+    type: DataType;
+    id: string;
+}
+export declare enum DataType {
+    Chains = "chains",
+    Dapps = "dapps",
+    Fungibles = "fungibles"
+}

package/dist/action-providers/zerion/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = exports.PositionType = void 0;
+var PositionType;
+(function (PositionType) {
+    PositionType["Deposit"] = "deposit";
+    PositionType["Reward"] = "reward";
+    PositionType["Staked"] = "staked";
+    PositionType["Wallet"] = "wallet";
+})(PositionType || (exports.PositionType = PositionType = {}));
+var DataType;
+(function (DataType) {
+    DataType["Chains"] = "chains";
+    DataType["Dapps"] = "dapps";
+    DataType["Fungibles"] = "fungibles";
+})(DataType || (exports.DataType = DataType = {}));

package/dist/action-providers/zerion/utils.d.ts

@@ -0,0 +1,3 @@
+import { ZerionFungiblePosition, ZerionPortfolio } from "./types";
+export declare const formatPortfolioData: (data: ZerionPortfolio) => string;
+export declare const formatPositionsData: (data: ZerionFungiblePosition[]) => string;

package/dist/action-providers/zerion/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPositionsData = exports.formatPortfolioData = void 0;
+const formatPortfolioData = (data) => {
+    // Total value
+    const totalValue = data.attributes.total.positions;
+    const totalValueStr = `$${totalValue.toFixed(2)}`;
+    // 24h change
+    const changePercent = data.attributes.changes.percent_1d;
+    const changeStr = `${changePercent.toFixed(2)}%`;
+    // Positions by type (filter out 0)
+    const types = Object.entries(data.attributes.positions_distribution_by_type)
+        .filter(([_, v]) => v > 0)
+        .map(([type, value]) => `${type}: $${value.toFixed(2)}`)
+        .join(", ");
+    // Positions by chain (top 5 by value)
+    const topChains = Object.entries(data.attributes.positions_distribution_by_chain)
+        .sort(([, a], [, b]) => b - a)
+        .slice(0, 5)
+        .map(([chain, value]) => `${chain}: $${value.toFixed(2)}`)
+        .join(", ");
+    // Final summary string
+    return `Wallet Portfolio Overview:
+- Total Value: ${totalValueStr}
+- 24h Change: ${changeStr}
+- Position Types: ${types}
+- Top Chains: ${topChains}`;
+};
+exports.formatPortfolioData = formatPortfolioData;
+const formatPositionsData = (data) => {
+    const filtered = data.filter(pos => pos.attributes.value !== null);
+    // Sort by value (descending)
+    const sorted = filtered.sort((a, b) => b.attributes.value - a.attributes.value);
+    const lines = [];
+    let totalValue = 0;
+    for (const pos of sorted) {
+        const { value, position_type, fungible_info, application_metadata } = pos.attributes;
+        const chain = pos.relationships.chain.data.id;
+        const protocolLine = application_metadata?.name ? `via ${application_metadata.name}` : "";
+        lines.push(`- ${fungible_info.symbol} (${fungible_info.name}) on ${chain} — $${value.toFixed(2)} [${position_type}${protocolLine ? " " + protocolLine : ""}]`);
+        totalValue += value;
+    }
+    return `Total Value: $${totalValue.toFixed(2)}\n\nToken Positions (>$1):\n${lines.join("\n")}`;
+};
+exports.formatPositionsData = formatPositionsData;

package/dist/action-providers/zerion/zerionActionProvider.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { Network } from "../../network";
+import { ActionProvider } from "../actionProvider";
+import { GetWalletPortfolioSchema } from "./schemas";
+/**
+ * Configuration options for the ZerionActionProvider.
+ */
+export interface ZerionActionProviderConfig {
+    /**
+     * Zerion API Key. Request new at https://zerion.io/api
+     */
+    apiKey?: string;
+}
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+export declare class ZerionActionProvider extends ActionProvider {
+    private readonly apiKey;
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config?: ZerionActionProviderConfig);
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getPortfolioOverview(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    getFungiblePositions(args: z.infer<typeof GetWalletPortfolioSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+export declare const zerionActionProvider: (config?: ZerionActionProviderConfig) => ZerionActionProvider;

package/dist/action-providers/zerion/zerionActionProvider.js

@@ -0,0 +1,159 @@
+"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.zerionActionProvider = exports.ZerionActionProvider = void 0;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const actionDecorator_1 = require("../actionDecorator");
+const actionProvider_1 = require("../actionProvider");
+const constants_1 = require("./constants");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * ZerionActionProvider provides actions for zerion operations.
+ *
+ * @description
+ * This provider is designed to provide EVM-based operations.
+ * It supports all EVM-based networks.
+ */
+class ZerionActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ZerionActionProvider.
+     *
+     * @param config - The configuration options for the ZerionActionProvider.
+     */
+    constructor(config = {}) {
+        super("zerion", []);
+        const apiKey = config.apiKey || process.env.ZERION_API_KEY;
+        if (!apiKey) {
+            throw new Error("ZERION_API_KEY is not configured.");
+        }
+        const encodedKey = Buffer.from(`${apiKey}:`).toString("base64");
+        this.apiKey = encodedKey;
+    }
+    /**
+     * Fetches and summarizes a crypto wallet's portfolio in USD.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getPortfolioOverview(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/portfolio?filter[positions]=no_filter&currency=usd`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPortfolioData)(data);
+        }
+        catch (error) {
+            return `Error fetching portfolio overview for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Retrieves and summarizes a wallet's fungible token holdings.
+     *
+     * @param args - Arguments defined by GetWalletPortfolioSchema
+     * @returns A promise that resolves to a string describing the action result
+     */
+    async getFungiblePositions(args) {
+        try {
+            const address = args.walletAddress || "";
+            if (!(0, viem_1.isAddress)(address)) {
+                return `Invalid wallet address: ${address}`;
+            }
+            const options = {
+                method: "GET",
+                headers: {
+                    accept: "application/json",
+                    authorization: `Basic ${this.apiKey}`,
+                },
+            };
+            const url = `${constants_1.ZERION_V1_BASE_URL}/wallets/${args.walletAddress}/positions?filter[positions]=no_filter&currency=usd&filter[trash]=only_non_trash&sort=value`;
+            const response = await fetch(url, options);
+            const { data } = await response.json();
+            return (0, utils_1.formatPositionsData)(data);
+        }
+        catch (error) {
+            return `Error fetching fungible positions for wallet ${args.walletAddress}: ${error}`;
+        }
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        // all protocol networks
+        return network.protocolFamily === "evm";
+    }
+}
+exports.ZerionActionProvider = ZerionActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_portfolio_overview",
+        description: `
+    Fetches and summarizes a crypto wallet's portfolio in USD. 
+    The tool returns a human-readable overview of the wallet's total value, value distribution across blockchains, position types (e.g., staked, deposited), and 24-hour performance change. 
+    Useful for providing quick insights into a wallet's DeFi and cross-chain holdings.
+    Input:
+    - walletAddress: The wallet address to fetch portfolio overview for.
+    Output a structured text summary with:
+    - Total portfolio value in USD
+    - 24h percentage change in value
+    - Breakdown of value by position types (e.g., wallet, deposited, staked, locked, borrowed)
+    - Top 5 chains by value distribution
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getPortfolioOverview", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "get_fungible_positions",
+        description: `
+    Retrieves and summarizes a wallet's fungible token holdings. 
+    For each token, it includes metadata such as symbol, name, holding value, associated protocol (if applicable), and the type of position (e.g., deposit, wallet, reward). 
+    The summary also reports the total USD value of all qualifying token positions.
+    Input:
+    - walletAddress: The wallet address to fetch fungible positions for.
+    Output a readable text summary including:
+    - All token positions
+    - For each: token name, symbol, USD value, chain, position type
+    - If applicable: protocol used and type of action (e.g. staked, deposited via protocol)
+    - A final total value in USD across all included positions
+  `,
+        schema: schemas_1.GetWalletPortfolioSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [void 0]),
+    __metadata("design:returntype", Promise)
+], ZerionActionProvider.prototype, "getFungiblePositions", null);
+/**
+ * Factory function to create a new ZerionActionProvider instance.
+ *
+ * @param config - The configuration options for the ZerionActionProvider.
+ * @returns A new ZerionActionProvider instance
+ */
+const zerionActionProvider = (config) => new ZerionActionProvider(config);
+exports.zerionActionProvider = zerionActionProvider;

package/dist/action-providers/zerion/zerionActionProvider.test.d.ts

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

package/dist/action-providers/zerion/zerionActionProvider.test.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zerionActionProvider_1 = require("./zerionActionProvider");
+const utils_1 = require("./utils");
+// Mocks for fetch and utils
+global.fetch = jest.fn();
+jest.mock("./utils", () => ({
+    formatPortfolioData: jest.fn(() => "formatted portfolio"),
+    formatPositionsData: jest.fn(() => "formatted positions"),
+}));
+describe("ZerionActionProvider", () => {
+    const mockApiKey = "test-api-key";
+    const originalEnv = process.env.ZERION_API_KEY;
+    const mockFungiblePositionResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/positions/",
+        },
+        data: [
+            {
+                type: "positions",
+                id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                attributes: {
+                    parent: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa-polygon-asset-none-",
+                    protocol: null,
+                    pool_address: "0x109830a1aaad605bbf02a9dfa7b0b92ec2fb7daa",
+                    name: "Asset",
+                    group_id: "0a771a0064dad468045899032c7fb01a971f973f7dff0a5cdc3ce199f45e94d7",
+                    position_type: "deposit",
+                    quantity: {
+                        int: "12345678",
+                        decimals: 5,
+                        float: 123.45678,
+                        numeric: "123.45678",
+                    },
+                    value: 5.384656557642683,
+                    price: 0.043615722,
+                    changes: {
+                        absolute_1d: 0.272309794,
+                        percent_1d: 5.326512552079021,
+                    },
+                    fungible_info: {
+                        name: "Bankless BED Index",
+                        symbol: "BED",
+                        description: "The BED index is meant to track crypto’s top 3 investab...",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        flags: {
+                            verified: true,
+                        },
+                        implementations: [
+                            {
+                                chain_id: "ethereum",
+                                address: "0x2af1df3ab0ab157e1e2ad8f88a7d04fbea0c7dc6",
+                                decimals: 18,
+                            },
+                        ],
+                    },
+                    flags: {
+                        displayable: true,
+                        is_trash: true,
+                    },
+                    updated_at: "2023-11-10T23:00:00Z",
+                    updated_at_block: 0,
+                    application_metadata: {
+                        name: "AAVE",
+                        icon: {
+                            url: "https://token-icons.s3.amazonaws.com/0x0391d2021f89dc339f60fff84546ea23e337750f.png",
+                        },
+                        url: "https://app.aave.com/",
+                    },
+                },
+                relationships: {
+                    chain: {
+                        links: {
+                            related: "https://api.zerion.io/v1/chains/polygon",
+                        },
+                        data: {
+                            type: "chains",
+                            id: "polygon",
+                        },
+                    },
+                    fungible: {
+                        links: {
+                            related: "https://api.zerion.io/v1/fungibles/0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                        data: {
+                            type: "fungibles",
+                            id: "0x111c47865ade3b172a928df8f990bc7f2a3b9aaa",
+                        },
+                    },
+                    dapp: {
+                        data: {
+                            type: "dapps",
+                            id: "aave-v3",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+    const mockPortfolioResponse = {
+        links: {
+            self: "https://api.zerion.io/v1/wallets/0x42b9df65b219b3dd36ff330a4dd8f327a6ada990/portfolio",
+        },
+        data: {
+            type: "portfolio",
+            id: "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990",
+            attributes: {
+                positions_distribution_by_type: {
+                    wallet: 1864.774102420957,
+                    deposited: 78.04192492782934,
+                    borrowed: 0.9751475798305564,
+                    locked: 5.780032725068765,
+                    staked: 66.13183205505294,
+                },
+                positions_distribution_by_chain: {
+                    arbitrum: 458.3555051522226,
+                    aurora: 72.01031337463428,
+                    avalanche: 17.128850607339444,
+                    base: 55.01550749900544,
+                    "binance-smart-chain": 5.561075880033699,
+                    celo: 31.293849330045006,
+                    ethereum: 1214.009900354964,
+                    fantom: 84.58514074264951,
+                    linea: 8.258227109505139,
+                    optimism: 573.032664994399,
+                    polygon: 64.31407562634853,
+                    xdai: 113.1679493137936,
+                    "zksync-era": 9.451002156306377,
+                },
+                total: {
+                    positions: 2017.4858230069574,
+                },
+                changes: {
+                    absolute_1d: 102.0271468171374,
+                    percent_1d: 5.326512552079021,
+                },
+            },
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env.ZERION_API_KEY = mockApiKey;
+    });
+    afterAll(() => {
+        process.env.ZERION_API_KEY = originalEnv;
+    });
+    it("should throw if no API key is provided", () => {
+        delete process.env.ZERION_API_KEY;
+        expect(() => new zerionActionProvider_1.ZerionActionProvider()).toThrow("ZERION_API_KEY is not configured.");
+    });
+    it("should use provided API key from config", () => {
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: "foo" });
+        expect(provider).toBeDefined();
+    });
+    // supportsNetwork tests
+    const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+    it("should support the protocol family", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "evm" })).toBe(true);
+    });
+    it("should not support other protocol families", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "other-protocol-family" })).toBe(false);
+    });
+    it("should handle invalid network objects", () => {
+        expect(provider.supportsNetwork({ protocolFamily: "invalid-protocol" })).toBe(false);
+        expect(provider.supportsNetwork({})).toBe(false);
+    });
+    describe("getPortfolioOverview", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getPortfolioOverview({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockPortfolioResponse),
+            });
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(utils_1.formatPortfolioData).toHaveBeenCalledWith(mockPortfolioResponse.data);
+            expect(result).toBe("formatted portfolio");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getPortfolioOverview({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching portfolio overview/);
+        });
+    });
+    describe("getFungiblePositions", () => {
+        const validAddress = "0x42b9df65b219b3dd36ff330a4dd8f327a6ada990";
+        const invalidAddress = "invalid-address";
+        const provider = new zerionActionProvider_1.ZerionActionProvider({ apiKey: mockApiKey });
+        it("returns error for invalid address", async () => {
+            const result = await provider.getFungiblePositions({ walletAddress: invalidAddress });
+            expect(result).toMatch(/Invalid wallet address/);
+        });
+        it("returns formatted data for valid address", async () => {
+            global.fetch.mockResolvedValueOnce({
+                json: jest.fn().mockResolvedValue(mockFungiblePositionResponse),
+            });
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(utils_1.formatPositionsData).toHaveBeenCalledWith(mockFungiblePositionResponse.data);
+            expect(result).toBe("formatted positions");
+        });
+        it("returns error on fetch failure", async () => {
+            global.fetch.mockRejectedValueOnce(new Error("fail"));
+            const result = await provider.getFungiblePositions({ walletAddress: validAddress });
+            expect(result).toMatch(/Error fetching fungible positions/);
+        });
+    });
+});

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

@@ -40,6 +40,10 @@ export interface CdpSmartWalletProviderConfig extends CdpWalletProviderConfig {
      * The name of the smart wallet.
      */
     smartAccountName?: string;
+    /**
+     * The paymaster URL for gasless transactions.
+     */
+    paymasterUrl?: string;
 }
 /**
  * A wallet provider that can be used to interact with the CDP.

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

@@ -1,4 +1,4 @@
-import { CdpClient } from "@coinbase/cdp-sdk";
+import { CdpClient, EvmSmartAccount } from "@coinbase/cdp-sdk";
 import { Abi, Address, ContractFunctionArgs, ContractFunctionName, Hex, ReadContractParameters, ReadContractReturnType, TransactionRequest } from "viem";
 import { Network } from "../network";
 import { EvmWalletProvider } from "./evmWalletProvider";
@@ -8,6 +8,7 @@ import { WalletProviderWithClient, CdpSmartWalletProviderConfig } from "./cdpSha
  */
 export declare class CdpSmartWalletProvider extends EvmWalletProvider implements WalletProviderWithClient {
     #private;
+    smartAccount: EvmSmartAccount;
     /**
      * Constructs a new CdpSmartWalletProvider.
      *
@@ -84,6 +85,12 @@ export declare class CdpSmartWalletProvider extends EvmWalletProvider implements
      * @returns The CDP client.
      */
     getClient(): CdpClient;
+    /**
+     * Gets the paymaster URL for gasless transactions.
+     *
+     * @returns The paymaster URL if configured, undefined otherwise.
+     */
+    getPaymasterUrl(): string | undefined;
     /**
      * Gets the balance of the smart wallet.
      *