@coinbase/agentkit 0.10.0 → 0.10.1

package/dist/action-providers/superfluid/graphQueries/endpoints.d.ts

@@ -0,0 +1,2 @@
+export declare const BASE_GRAPH_ENDPOINT = "https://subgraph-endpoints.superfluid.dev/base-mainnet/protocol-v1";
+export declare const BASE_SEPOLIA_GRAPH_ENDPOINT = "https://subgraph-endpoints.superfluid.dev/base-sepolia/protocol-v1";

package/dist/action-providers/superfluid/graphQueries/endpoints.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_SEPOLIA_GRAPH_ENDPOINT = exports.BASE_GRAPH_ENDPOINT = void 0;
+exports.BASE_GRAPH_ENDPOINT = "https://subgraph-endpoints.superfluid.dev/base-mainnet/protocol-v1";
+exports.BASE_SEPOLIA_GRAPH_ENDPOINT = "https://subgraph-endpoints.superfluid.dev/base-sepolia/protocol-v1";

package/dist/action-providers/superfluid/graphQueries/queries.d.ts

@@ -0,0 +1 @@
+export declare const getAccountOutflowQuery = "\n  query GetAccountData($id: ID!) {\n    accounts(where: { id: $id }) {\n      isSuperApp\n      inflows {\n        currentFlowRate\n        token {\n          symbol\n        }\n        sender {\n          id\n        }\n      }\n      outflows {\n        currentFlowRate\n        token {\n          symbol\n        }\n        receiver {\n          id\n        }\n      }\n      accountTokenSnapshots {\n        token {\n          id\n        }\n        totalNumberOfActiveStreams\n        totalNetFlowRate\n      }\n    }\n  }\n";

package/dist/action-providers/superfluid/graphQueries/queries.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountOutflowQuery = void 0;
+exports.getAccountOutflowQuery = `
+  query GetAccountData($id: ID!) {
+    accounts(where: { id: $id }) {
+      isSuperApp
+      inflows {
+        currentFlowRate
+        token {
+          symbol
+        }
+        sender {
+          id
+        }
+      }
+      outflows {
+        currentFlowRate
+        token {
+          symbol
+        }
+        receiver {
+          id
+        }
+      }
+      accountTokenSnapshots {
+        token {
+          id
+        }
+        totalNumberOfActiveStreams
+        totalNetFlowRate
+      }
+    }
+  }
+`;

package/dist/action-providers/superfluid/graphQueries/superfluidGraphQueries.d.ts

@@ -0,0 +1,8 @@
+import { SuperfluidAccountResponse } from "./types";
+/**
+ * Gets the current account outflows for the user
+ *
+ * @param userId - The user id of the account
+ * @returns The data on the current streams from the agent
+ */
+export declare function getAccountOutflow(userId: string): Promise<SuperfluidAccountResponse | undefined>;

package/dist/action-providers/superfluid/graphQueries/superfluidGraphQueries.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAccountOutflow = getAccountOutflow;
+const queries_1 = require("./queries");
+const endpoints_1 = require("./endpoints");
+/**
+ * Gets the current account outflows for the user
+ *
+ * @param userId - The user id of the account
+ * @returns The data on the current streams from the agent
+ */
+async function getAccountOutflow(userId) {
+    try {
+        const { GraphQLClient } = await import("graphql-request");
+        const client = new GraphQLClient(endpoints_1.BASE_GRAPH_ENDPOINT);
+        const variables = { id: userId.toLowerCase() };
+        const data = await client.request(queries_1.getAccountOutflowQuery, variables);
+        return data;
+    }
+    catch (error) {
+        console.error("Error fetching account data:", error);
+        return undefined;
+    }
+}

package/dist/action-providers/superfluid/graphQueries/types.d.ts

@@ -0,0 +1,27 @@
+export type SuperfluidAccountResponse = {
+    accounts: Account[];
+};
+type Account = {
+    isSuperApp: boolean;
+    inflows: Flow[];
+    outflows: Flow[];
+    accountTokenSnapshots: AccountTokenSnapshot[];
+};
+type Flow = {
+    currentFlowRate: string;
+    token: Token;
+    receiver: Receiver;
+};
+type Token = {
+    symbol?: string;
+    id?: string;
+};
+type Receiver = {
+    id: string;
+};
+type AccountTokenSnapshot = {
+    token: Token;
+    totalNumberOfActiveStreams: number;
+    totalNetFlowRate: string;
+};
+export {};

package/dist/action-providers/superfluid/graphQueries/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+export * from "./schemas";
+export * from "./superfluidStreamActionProvider";
+export * from "./superfluidPoolActionProvider";
+export * from "./superfluidQueryActionProvider";
+export * from "./superfluidWrapperActionProvider";
+export * from "./superfluidSuperTokenCreatorActionProvider";
+export * from "./superfluidActionProvider";

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

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./superfluidStreamActionProvider"), exports);
+__exportStar(require("./superfluidPoolActionProvider"), exports);
+__exportStar(require("./superfluidQueryActionProvider"), exports);
+__exportStar(require("./superfluidWrapperActionProvider"), exports);
+__exportStar(require("./superfluidSuperTokenCreatorActionProvider"), exports);
+__exportStar(require("./superfluidActionProvider"), exports);

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

@@ -0,0 +1,86 @@
+import { z } from "zod";
+/**
+ * Input schema for creating a Superfluid stream
+ */
+export declare const SuperfluidCreateStreamSchema: z.ZodObject<{
+    superTokenAddress: z.ZodString;
+    recipientAddress: z.ZodString;
+    flowRate: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    superTokenAddress: string;
+    recipientAddress: string;
+    flowRate: string;
+}, {
+    superTokenAddress: string;
+    recipientAddress: string;
+    flowRate: string;
+}>;
+/**
+ * Input schema for deleting a Superfluid stream
+ */
+export declare const SuperfluidDeleteStreamSchema: z.ZodObject<{
+    superTokenAddress: z.ZodString;
+    recipientAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    superTokenAddress: string;
+    recipientAddress: string;
+}, {
+    superTokenAddress: string;
+    recipientAddress: string;
+}>;
+/**
+ * Input schema for creating a Superfluid pool
+ */
+export declare const SuperfluidCreatePoolSchema: z.ZodObject<{
+    superTokenAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    superTokenAddress: string;
+}, {
+    superTokenAddress: string;
+}>;
+/**
+ * Input schema for updating a Superfluid pool
+ */
+export declare const SuperfluidUpdatePoolSchema: z.ZodObject<{
+    poolAddress: z.ZodString;
+    recipientAddress: z.ZodString;
+    units: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    recipientAddress: string;
+    poolAddress: string;
+    units: number;
+}, {
+    recipientAddress: string;
+    poolAddress: string;
+    units: number;
+}>;
+/**
+ * Input schema for wrapping a Superfluid token
+ */
+export declare const SuperfluidWrapTokenSchema: z.ZodObject<{
+    erc20TokenAddress: z.ZodString;
+    superTokenAddress: z.ZodString;
+    wrapAmount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    superTokenAddress: string;
+    erc20TokenAddress: string;
+    wrapAmount: number;
+}, {
+    superTokenAddress: string;
+    erc20TokenAddress: string;
+    wrapAmount: number;
+}>;
+/**
+ * Input schema for creating a Super Token
+ */
+export declare const SuperfluidCreateSuperTokenSchema: z.ZodObject<{
+    erc20TokenAddress: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    erc20TokenAddress: string;
+}, {
+    erc20TokenAddress: string;
+}>;
+/**
+ * Empty input schema used for Query action
+ */
+export declare const EmptySchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptySchema = exports.SuperfluidCreateSuperTokenSchema = exports.SuperfluidWrapTokenSchema = exports.SuperfluidUpdatePoolSchema = exports.SuperfluidCreatePoolSchema = exports.SuperfluidDeleteStreamSchema = exports.SuperfluidCreateStreamSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Input schema for creating a Superfluid stream
+ */
+exports.SuperfluidCreateStreamSchema = zod_1.z
+    .object({
+    superTokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The ERC20 Super token to start or update streaming"),
+    recipientAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The EVM address to stream the token to."),
+    flowRate: zod_1.z
+        .string()
+        .describe("The rate at which the ERC20 is streamed to the recipient, in wei per second."),
+})
+    .strip()
+    .describe("Input schema for creating or updating a Superfluid stream");
+/**
+ * Input schema for deleting a Superfluid stream
+ */
+exports.SuperfluidDeleteStreamSchema = zod_1.z
+    .object({
+    superTokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The ERC20 Super Token to start streaming"),
+    recipientAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The EVM address to stream the token to."),
+})
+    .strip()
+    .describe("Input schema for creating a Superfluid stream");
+/**
+ * Input schema for creating a Superfluid pool
+ */
+exports.SuperfluidCreatePoolSchema = zod_1.z
+    .object({
+    superTokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The ERC20 Super token for which to create a pool"),
+})
+    .strip()
+    .describe("Input schema for creating a Superfluid pool");
+/**
+ * Input schema for updating a Superfluid pool
+ */
+exports.SuperfluidUpdatePoolSchema = zod_1.z
+    .object({
+    poolAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The EVM address of the token pool"),
+    recipientAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The EVM address to stream the token to, from the pool."),
+    units: zod_1.z.number().describe("The new units of the recipient in the pool."),
+})
+    .strip()
+    .describe("Input schema for updating a Superfluid pool");
+/**
+ * Input schema for wrapping a Superfluid token
+ */
+exports.SuperfluidWrapTokenSchema = zod_1.z
+    .object({
+    erc20TokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The ERC20 token to wrap"),
+    superTokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token to wrap to"),
+    wrapAmount: zod_1.z
+        .number()
+        .describe("The amount of tokens to wrap in whole units (e.g. 1.5 WETH, 10 USDC)"),
+})
+    .strip()
+    .describe("Input schema for updating a Superfluid pool");
+/**
+ * Input schema for creating a Super Token
+ */
+exports.SuperfluidCreateSuperTokenSchema = zod_1.z
+    .object({
+    erc20TokenAddress: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The underlying ERC20 token"),
+})
+    .strip()
+    .describe("Input schema for creating a Super Token");
+/**
+ * Empty input schema used for Query action
+ */
+exports.EmptySchema = zod_1.z.object({}).strip().describe("Empty input schema");

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

@@ -0,0 +1,20 @@
+import { ActionProvider } from "../actionProvider";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { Network } from "../../network";
+/**
+ * SuperfluidActionProvider aggregates all Superfluid-related actions into a single provider.
+ */
+export declare class SuperfluidActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Superfluid Action Provider constructor
+     */
+    constructor();
+    /**
+     * Supports Base mainnet and Base sepolia like the underlying Superfluid providers.
+     *
+     * @param network - network to check
+     * @returns - A boolean if this action provider supports the network
+     */
+    supportsNetwork: (network: Network) => boolean;
+}
+export declare const superfluidActionProvider: () => SuperfluidActionProvider;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.superfluidActionProvider = exports.SuperfluidActionProvider = void 0;
+const actionProvider_1 = require("../actionProvider");
+const superfluidStreamActionProvider_1 = require("./superfluidStreamActionProvider");
+const superfluidPoolActionProvider_1 = require("./superfluidPoolActionProvider");
+const superfluidQueryActionProvider_1 = require("./superfluidQueryActionProvider");
+const superfluidWrapperActionProvider_1 = require("./superfluidWrapperActionProvider");
+const superfluidSuperTokenCreatorActionProvider_1 = require("./superfluidSuperTokenCreatorActionProvider");
+/**
+ * SuperfluidActionProvider aggregates all Superfluid-related actions into a single provider.
+ */
+class SuperfluidActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Superfluid Action Provider constructor
+     */
+    constructor() {
+        super("superfluid", [
+            new superfluidStreamActionProvider_1.SuperfluidStreamActionProvider(),
+            new superfluidPoolActionProvider_1.SuperfluidPoolActionProvider(),
+            new superfluidQueryActionProvider_1.SuperfluidQueryActionProvider(),
+            new superfluidWrapperActionProvider_1.SuperfluidWrapperActionProvider(),
+            new superfluidSuperTokenCreatorActionProvider_1.SuperfluidSuperTokenCreatorActionProvider(),
+        ]);
+        /**
+         * Supports Base mainnet and Base sepolia like the underlying Superfluid providers.
+         *
+         * @param network - network to check
+         * @returns - A boolean if this action provider supports the network
+         */
+        this.supportsNetwork = (network) => network.networkId === "base-mainnet" || network.networkId === "base-sepolia";
+    }
+}
+exports.SuperfluidActionProvider = SuperfluidActionProvider;
+const superfluidActionProvider = () => new SuperfluidActionProvider();
+exports.superfluidActionProvider = superfluidActionProvider;

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { SuperfluidCreatePoolSchema, SuperfluidUpdatePoolSchema } from "./schemas";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+export type CreatePoolArgs = readonly [
+    token: `0x${string}`,
+    admin: `0x${string}`,
+    config: {
+        transferabilityForUnitsOwner: boolean;
+        distributionFromAnyAddress: boolean;
+    }
+];
+/**
+ * SuperfluidPoolActionProvider is an action provider for Superfluid interactions.
+ */
+export declare class SuperfluidPoolActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the SuperfluidPoolActionProvider class.
+     */
+    constructor();
+    /**
+     * Creates a pool from the agent wallet to the recipient
+     *
+     * @param walletProvider - The wallet provider to start the pool from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    createPool(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidCreatePoolSchema>): Promise<string>;
+    /**
+     * Updates member units for a pool
+     *
+     * @param walletProvider - The wallet provider to start the pool from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    updatePool(walletProvider: EvmWalletProvider, args: z.infer<typeof SuperfluidUpdatePoolSchema>): 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 superfluidPoolActionProvider: () => SuperfluidPoolActionProvider;

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

@@ -0,0 +1,143 @@
+"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.superfluidPoolActionProvider = exports.SuperfluidPoolActionProvider = 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");
+/**
+ * SuperfluidPoolActionProvider is an action provider for Superfluid interactions.
+ */
+class SuperfluidPoolActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the SuperfluidPoolActionProvider class.
+     */
+    constructor() {
+        super("superfluid-pool", []);
+        /**
+         * 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 pool from the agent wallet to the recipient
+     *
+     * @param walletProvider - The wallet provider to start the pool from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    async createPool(walletProvider, args) {
+        try {
+            const config = {
+                transferabilityForUnitsOwner: false,
+                distributionFromAnyAddress: false,
+            };
+            const createArgs = [
+                args.superTokenAddress,
+                walletProvider.getAddress(),
+                config,
+            ];
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.GDAv1ForwarderABI,
+                functionName: "createPool",
+                args: createArgs,
+            });
+            const publicClient = walletProvider.getPublicClient();
+            // We don't get contract call results, so we need to simulate to get the pool address
+            const { result } = await publicClient.simulateContract({
+                address: constants_1.GDAv1ForwarderAddress,
+                abi: constants_1.GDAv1ForwarderABI,
+                functionName: "createPool",
+                args: createArgs,
+                account: walletProvider.getAddress(),
+            });
+            const [success, pool] = result;
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.GDAv1ForwarderAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            if (success) {
+                return `Created pool of token ${args.superTokenAddress} at ${pool}.  Transaction hash: ${hash}`;
+            }
+            else {
+                return `Failed to create token pool.`;
+            }
+        }
+        catch (error) {
+            return `Error creating Superfluid pool: ${error}`;
+        }
+    }
+    /**
+     * Updates member units for a pool
+     *
+     * @param walletProvider - The wallet provider to start the pool from.
+     * @param args - The input arguments for the action.
+     * @returns A JSON string containing the account details or error message
+     */
+    async updatePool(walletProvider, args) {
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.GDAv1ForwarderABI,
+                functionName: "updateMemberUnits",
+                args: [args.poolAddress, args.recipientAddress, BigInt(args.units), "0x"],
+            });
+            const hash = await walletProvider.sendTransaction({
+                to: constants_1.GDAv1ForwarderAddress,
+                data,
+            });
+            await walletProvider.waitForTransactionReceipt(hash);
+            return `Updated member units of pool ${args.poolAddress} for member ${args.recipientAddress}, with new member units ${args.units}.  Transaction hash: ${hash}`;
+        }
+        catch (error) {
+            return `Error updating Superfluid pool: ${error}`;
+        }
+    }
+}
+exports.SuperfluidPoolActionProvider = SuperfluidPoolActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "create_pool",
+        description: `
+This tool will create a Superfluid pool for a desired token on an EVM network.
+It takes the ERC20 token address to create a pool of the tokens to later be multi streamed to other wallets.
+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.SuperfluidCreatePoolSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidPoolActionProvider.prototype, "createPool", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "update_pool",
+        description: `
+This tool will update a Superfluid pool for a desired token on an EVM network.
+The pool must already have been created; this action merely updates the flow for a member of the pool.
+It takes the EVM address of the token pool contract that was created.
+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.SuperfluidUpdatePoolSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], SuperfluidPoolActionProvider.prototype, "updatePool", null);
+const superfluidPoolActionProvider = () => new SuperfluidPoolActionProvider();
+exports.superfluidPoolActionProvider = superfluidPoolActionProvider;

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

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