@coinbase/agentkit 0.9.1 → 0.10.1

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const superfluidPoolActionProvider_1 = require("./superfluidPoolActionProvider");
+describe("SuperfluidPoolActionProvider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_ERC20_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_CHAIN_ID = "8453";
+    let mockWallet;
+    const actionProvider = (0, superfluidPoolActionProvider_1.superfluidPoolActionProvider)();
+    // We'll assert on this directly (easier typing than asserting through the PublicClient type)
+    let simulateContractMock;
+    let mockPublicClient;
+    beforeEach(() => {
+        simulateContractMock = jest.fn().mockResolvedValue({
+            request: {},
+            result: [true, "0xDeCc403f23881285E05Df2BbC7Ebb9a88Dd8A554"],
+        });
+        // Minimal PublicClient stub with just the method we use
+        mockPublicClient = { simulateContract: simulateContractMock };
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm" }),
+            getPublicClient: jest.fn().mockReturnValue(mockPublicClient),
+            sendTransaction: jest.fn().mockResolvedValue("0xmockhash"),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({}),
+            readContract: jest.fn(),
+            call: jest.fn(),
+        };
+    });
+    describe("create pool", () => {
+        it("should successfully create a superfluid pool", async () => {
+            const args = {
+                superTokenAddress: MOCK_ERC20_CONTRACT,
+                chainId: MOCK_CHAIN_ID,
+            };
+            const config = {
+                transferabilityForUnitsOwner: false,
+                distributionFromAnyAddress: false,
+            };
+            const createArgs = [
+                MOCK_ERC20_CONTRACT,
+                mockWallet.getAddress(),
+                config,
+            ];
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.GDAv1ForwarderABI,
+                functionName: "createPool",
+                args: createArgs,
+            });
+            await actionProvider.createPool(mockWallet, args);
+            expect(simulateContractMock).toHaveBeenCalledWith({
+                address: constants_1.GDAv1ForwarderAddress,
+                abi: constants_1.GDAv1ForwarderABI,
+                functionName: "createPool",
+                args: createArgs,
+                account: MOCK_ADDRESS,
+            });
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: constants_1.GDAv1ForwarderAddress,
+                data,
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");
+        });
+        it("should handle pool creation errors", async () => {
+            simulateContractMock.mockRejectedValueOnce(new Error("sim failed"));
+            const args = {
+                superTokenAddress: MOCK_ERC20_CONTRACT,
+                chainId: MOCK_CHAIN_ID,
+            };
+            const response = await actionProvider.createPool(mockWallet, args);
+            expect(response).toContain("Error creating Superfluid pool:");
+        });
+    });
+    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/superfluidQueryActionProvider.d.ts

@@ -0,0 +1,27 @@
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { Network } from "../../network";
+/**
+ * SuperfluidQueryActionProvider is an action provider for Superfluid interactions.
+ */
+export declare class SuperfluidQueryActionProvider extends ActionProvider {
+    /**
+     * Constructor for the SuperfluidQueryActionProvider class.
+     */
+    constructor();
+    /**
+     * Gets a list of addresses to which a stream is open
+     *
+     * @param walletProvider - The wallet of the agent.
+     * @returns A JSON string containing the account details or error message
+     */
+    queryStreams(walletProvider: EvmWalletProvider): 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 superfluidQueryActionProvider: () => SuperfluidQueryActionProvider;

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

@@ -0,0 +1,71 @@
+"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.superfluidQueryActionProvider = exports.SuperfluidQueryActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const schemas_1 = require("./schemas");
+const superfluidGraphQueries_1 = require("./graphQueries/superfluidGraphQueries");
+/**
+ * SuperfluidQueryActionProvider is an action provider for Superfluid interactions.
+ */
+class SuperfluidQueryActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SuperfluidQueryActionProvider class.
+     */
+    constructor() {
+        super("superfluid-query", []);
+        /**
+         * 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";
+    }
+    /**
+     * Gets a list of addresses to which a stream is open
+     *
+     * @param walletProvider - The wallet of the agent.
+     * @returns A JSON string containing the account details or error message
+     */
+    async queryStreams(walletProvider) {
+        try {
+            const accountData = await (0, superfluidGraphQueries_1.getAccountOutflow)(walletProvider.getAddress());
+            const outflows = accountData?.accounts?.length ? accountData?.accounts[0].outflows : [];
+            const activeOutflows = outflows.filter(o => {
+                return parseInt(o.currentFlowRate) > 0;
+            });
+            return `Current outflows are ${JSON.stringify(activeOutflows)}`;
+        }
+        catch (error) {
+            return `Error querying Superfluid streams: ${error}`;
+        }
+    }
+}
+exports.SuperfluidQueryActionProvider = SuperfluidQueryActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "query_streams",
+        description: `
+This tool will query the Superfluid subgraph to find a list of addresses to which you are streaming a token.
+It takes nothing as input; you will be checking against your own wallet.
+It returns an array of account outflows, each with a receiver (wallet address), a token, and a flow rate. If the flow rate is greater than zero, there is a current flow.
+`,
+        schema: schemas_1.EmptySchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider]),
+    __metadata("design:returntype", Promise)
+], SuperfluidQueryActionProvider.prototype, "queryStreams", null);
+const superfluidQueryActionProvider = () => new SuperfluidQueryActionProvider();
+exports.superfluidQueryActionProvider = superfluidQueryActionProvider;

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const superfluidQueryActionProvider_1 = require("./superfluidQueryActionProvider");
+const superfluidGraphQueries_1 = require("./graphQueries/superfluidGraphQueries");
+jest.mock("./graphQueries/superfluidGraphQueries", () => ({
+    getAccountOutflow: jest.fn(async () => ({
+        accounts: [{ outflows: [{ receiver: "0x123", token: "0xABC", currentFlowRate: "100" }] }],
+    })),
+}));
+describe("SuperfluidQueryActionProvider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    let mockWallet;
+    const actionProvider = (0, superfluidQueryActionProvider_1.superfluidQueryActionProvider)();
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm" }),
+        };
+    });
+    describe("queryStreams", () => {
+        it("should return active outflows when streams exist", async () => {
+            const response = await actionProvider.queryStreams(mockWallet);
+            expect(response).toContain("Current outflows are");
+            expect(response).toContain("0x123");
+        });
+        it("should return an empty array when no active streams exist", async () => {
+            superfluidGraphQueries_1.getAccountOutflow.mockImplementation(async () => ({
+                accounts: [{ outflows: [] }],
+            }));
+            const response = await actionProvider.queryStreams(mockWallet);
+            expect(response).toBe("Current outflows are []");
+        });
+        it("should handle query errors gracefully", async () => {
+            superfluidGraphQueries_1.getAccountOutflow.mockImplementation(async () => {
+                throw new Error("Query failed");
+            });
+            const response = await actionProvider.queryStreams(mockWallet);
+            expect(response).toBe("Error querying Superfluid streams: Error: Query failed");
+        });
+    });
+    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/superfluidStreamActionProvider.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { SuperfluidCreateStreamSchema, SuperfluidDeleteStreamSchema } from "./schemas";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * SuperfluidStreamActionProvider is an action provider for Superfluid interactions.
+ */
+export declare class SuperfluidStreamActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SuperfluidStreamActionProvider class.
+     */
+    constructor();
+    /**
+     * Creates a stream from the agent wallet to the recipient
+     *
+     * @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
+     */
+    createStream(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidCreateStreamSchema>): Promise<string>;
+    /**
+     * Updates a stream from the agent wallet to the recipient
+     *
+     * @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
+     */
+    updateStream(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidCreateStreamSchema>): Promise<string>;
+    /**
+     * Deletes a stream from the agent wallet to the recipient
+     *
+     * @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
+     */
+    deleteStream(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidDeleteStreamSchema>): 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;
+    /**
+     * Gets the link to the Superfluid dashboard pertaining to the stream
+     *
+     * @param network - The current network
+     * @param tokenAddress - The ERC20 token address of the underlying stream
+     * @param senderAddress - The sender of the stream (the agent)
+     * @param recipientAddress - The recipient of the stream
+     * @returns The view link to the new stream on Superfluid
+     */
+    getStreamLink: (network: Network, tokenAddress: string, senderAddress: string, recipientAddress: string) => string;
+}
+export declare const superfluidStreamActionProvider: () => SuperfluidStreamActionProvider;

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

@@ -0,0 +1,191 @@
+"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.superfluidStreamActionProvider = exports.SuperfluidStreamActionProvider = 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");
+/**
+ * SuperfluidStreamActionProvider is an action provider for Superfluid interactions.
+ */
+class SuperfluidStreamActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SuperfluidStreamActionProvider class.
+     */
+    constructor() {
+        super("superfluid-stream", []);
+        /**
+         * 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";
+        /**
+         * Gets the link to the Superfluid dashboard pertaining to the stream
+         *
+         * @param network - The current network
+         * @param tokenAddress - The ERC20 token address of the underlying stream
+         * @param senderAddress - The sender of the stream (the agent)
+         * @param recipientAddress - The recipient of the stream
+         * @returns The view link to the new stream on Superfluid
+         */
+        this.getStreamLink = (network, tokenAddress, senderAddress, recipientAddress) => {
+            return `https://app.superfluid.finance/stream/${network.networkId}/${senderAddress}-${recipientAddress}-${tokenAddress}`;
+        };
+    }
+    /**
+     * Creates a stream from the agent wallet to the recipient
+     *
+     * @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 createStream(walletProvider, args) {
+        try {
+            const streamData = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.CFAv1ForwarderABI,
+                functionName: "createFlow",
+                args: [
+                    args.superTokenAddress,
+                    walletProvider.getAddress(),
+                    args.recipientAddress,
+                    BigInt(args.flowRate),
+                    "0x",
+                ],
+            });
+            const streamHash = await walletProvider.sendTransaction({
+                to: constants_1.CFAv1ForwarderAddress,
+                data: streamData,
+            });
+            await walletProvider.waitForTransactionReceipt(streamHash);
+            return `Created stream of token ${args.superTokenAddress} to ${args.recipientAddress} at a rate of ${args.flowRate}. The link to the stream is ${this.getStreamLink(walletProvider.getNetwork(), args.superTokenAddress, walletProvider.getAddress(), args.recipientAddress)}.  Transaction hash: ${streamHash}`;
+        }
+        catch (error) {
+            return `Error creating Superfluid stream: ${error}`;
+        }
+    }
+    /**
+     * Updates a stream from the agent wallet to the recipient
+     *
+     * @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 updateStream(walletProvider, args) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.CFAv1ForwarderABI,
+                functionName: "updateFlow",
+                args: [
+                    args.superTokenAddress,
+                    walletProvider.getAddress(),
+                    args.recipientAddress,
+                    BigInt(args.flowRate),
+                    "0x",
+                ],
+            });
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.CFAv1ForwarderAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Updated stream of token ${args.superTokenAddress} to ${args.recipientAddress} at a rate of ${args.flowRate}.  Transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error updating Superfluid stream: ${error}`;
+        }
+    }
+    /**
+     * Deletes a stream from the agent wallet to the recipient
+     *
+     * @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 deleteStream(walletProvider, args) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.CFAv1ForwarderABI,
+                functionName: "deleteFlow",
+                args: [
+                    args.superTokenAddress,
+                    walletProvider.getAddress(),
+                    args.recipientAddress,
+                    "0x",
+                ],
+            });
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.CFAv1ForwarderAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Stopped stream of token ${args.superTokenAddress} to ${args.recipientAddress}.  Transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error deleting Superfluid stream: ${error}`;
+        }
+    }
+}
+exports.SuperfluidStreamActionProvider = SuperfluidStreamActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "create_stream",
+        description: `
+This tool will create a Superfluid stream for a desired token on an EVM network.
+It takes the Super token address, a recipient address, and a stream rate to create a Superfluid stream.
+Assume the Super token already exists; if the action fails, tell the user to ensure the Super token exists.
+Superfluid will then start streaming the token to the recipient at the specified rate (wei per second).
+Do not use the ERC20 address as the destination address. If you are unsure of the destination address, please ask the user before proceeding.
+`,
+        schema: schemas_1.SuperfluidCreateStreamSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidStreamActionProvider.prototype, "createStream", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "update_stream",
+        description: `
+This tool will update a Superfluid stream for a desired token on an EVM network.
+It takes the ERC20 token address, a recipient address, and a stream rate to update a Superfluid stream.
+Superfluid will then start streaming the token with the updated flow rate to the recipient.
+Do not use the ERC20 address as the destination address. If you are unsure of the destination address, please ask the user before proceeding.
+`,
+        // schema same as create schema
+        schema: schemas_1.SuperfluidCreateStreamSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidStreamActionProvider.prototype, "updateStream", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "delete_stream",
+        description: `
+This tool will stop the streaming of a Superfluid ERC20 token.
+It takes the ERC20 token address and a recipient address to delete a Superfluid stream, if one is present.
+Superfluid will then stop streaming the token to the recipient.
+Do not use the ERC20 address as the destination address. If you are unsure of the destination address, please ask the user before proceeding.
+`,
+        schema: schemas_1.SuperfluidDeleteStreamSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidStreamActionProvider.prototype, "deleteStream", null);
+const superfluidStreamActionProvider = () => new SuperfluidStreamActionProvider();
+exports.superfluidStreamActionProvider = superfluidStreamActionProvider;

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

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

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const superfluidStreamActionProvider_1 = require("./superfluidStreamActionProvider");
+const constants_1 = require("./constants");
+describe("SuperfluidStreamActionProvider", () => {
+    const MOCK_ADDRESS = "0xe6b2af36b3bb8d47206a129ff11d5a2de2a63c83";
+    const MOCK_ERC20_CONTRACT = "0x1234567890123456789012345678901234567890";
+    const MOCK_RECIPIENT_ADDRESS = "0x9876543210987654321098765432109876543210";
+    const MOCK_FLOW_RATE = "123";
+    const MOCK_CHAIN_ID = "8453";
+    let mockWallet;
+    const actionProvider = (0, superfluidStreamActionProvider_1.superfluidStreamActionProvider)();
+    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({});
+    });
+    describe("create stream", () => {
+        it("should successfully create a superfluid stream", async () => {
+            const args = {
+                superTokenAddress: MOCK_ERC20_CONTRACT,
+                chainId: MOCK_CHAIN_ID,
+                recipientAddress: MOCK_RECIPIENT_ADDRESS,
+                flowRate: MOCK_FLOW_RATE,
+            };
+            await actionProvider.createStream(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: constants_1.CFAv1ForwarderAddress,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.CFAv1ForwarderABI,
+                    functionName: "createFlow",
+                    args: [
+                        MOCK_ERC20_CONTRACT,
+                        MOCK_ADDRESS,
+                        MOCK_RECIPIENT_ADDRESS,
+                        BigInt(MOCK_FLOW_RATE),
+                        "0x",
+                    ],
+                }),
+            });
+            expect(mockWallet.waitForTransactionReceipt).toHaveBeenCalledWith("0xmockhash");
+        });
+        it("should handle stream creation errors", async () => {
+            const error = new Error("Stream creation failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const args = {
+                superTokenAddress: MOCK_ERC20_CONTRACT,
+                chainId: MOCK_CHAIN_ID,
+                recipientAddress: MOCK_RECIPIENT_ADDRESS,
+                flowRate: MOCK_FLOW_RATE,
+            };
+            const response = await actionProvider.createStream(mockWallet, args);
+            expect(response).toBe(`Error creating Superfluid stream: ${error}`);
+        });
+    });
+    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/superfluidSuperTokenCreatorActionProvider.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { SuperfluidCreateSuperTokenSchema } from "./schemas";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+/**
+ * SuperfluidSuperTokenCreatorActionProvider is an action provider for Superfluid interactions.
+ */
+export declare class SuperfluidSuperTokenCreatorActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SuperfluidSuperTokenCreatorActionProvider class.
+     */
+    constructor();
+    /**
+     * 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
+     */
+    createSuperToken(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidCreateSuperTokenSchema>): 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 superfluidSuperTokenCreatorActionProvider: () => SuperfluidSuperTokenCreatorActionProvider;