@coinbase/agentkit 0.10.0 → 0.10.1

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 viem_2 = require("viem");
+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: viem_2.erc20Abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const name = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: viem_2.erc20Abi,
+                functionName: "name",
+                args: [],
+            });
+            const symbol = await walletProvider.readContract({
+                address: args.erc20TokenAddress,
+                abi: viem_2.erc20Abi,
+                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 viem_2 = require("viem");
+/**
+ * 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: viem_2.erc20Abi,
+                functionName: "decimals",
+                args: [],
+            });
+            const amount = (0, viem_1.parseUnits)(String(args.wrapAmount), Number(decimals));
+            const approveData = (0, viem_1.encodeFunctionData)({
+                abi: viem_2.erc20Abi,
+                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 viem_2 = require("viem");
+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: viem_2.erc20Abi,
+                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/action-providers/truemarkets/truemarketsActionProvider.d.ts

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