@coinbase/agentkit 0.1.0

package/dist/action-providers/wow/wowActionProvider.js

@@ -0,0 +1,223 @@
+"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.wowActionProvider = exports.WowActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const wallet_providers_1 = require("../../wallet-providers");
+const actionDecorator_1 = require("../actionDecorator");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const utils_2 = require("./uniswap/utils");
+const viem_1 = require("viem");
+const schemas_1 = require("./schemas");
+/**
+ * WowActionProvider is an action provider for Wow protocol interactions.
+ */
+class WowActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the WowActionProvider class.
+     */
+    constructor() {
+        super("wow", []);
+        /**
+         * Checks if the Wow action provider supports the given network.
+         *
+         * @param network - The network to check.
+         * @returns True if the Wow action provider supports the network, false otherwise.
+         */
+        this.supportsNetwork = (network) => network.protocolFamily === "evm" && constants_1.SUPPORTED_NETWORKS.includes(network.networkId);
+    }
+    /**
+     * Buys a Zora Wow ERC20 memecoin with ETH.
+     *
+     * @param wallet - The wallet to create the token from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token purchase details.
+     */
+    async buyToken(wallet, args) {
+        try {
+            const tokenQuote = await (0, utils_1.getBuyQuote)(wallet, args.contractAddress, args.amountEthInWei);
+            // Multiply by 99/100 and floor to get 99% of quote as minimum
+            const minTokens = BigInt(Math.floor(Number(tokenQuote) * 99)) / BigInt(100);
+            const hasGraduated = await (0, utils_2.getHasGraduated)(wallet, args.contractAddress);
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WOW_ABI,
+                functionName: "buy",
+                args: [
+                    wallet.getAddress(),
+                    wallet.getAddress(),
+                    "0x0000000000000000000000000000000000000000",
+                    "",
+                    hasGraduated ? 1n : 0n,
+                    minTokens,
+                    0n,
+                ],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.contractAddress,
+                data,
+                value: BigInt(args.amountEthInWei),
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Purchased WoW ERC20 memecoin with transaction hash: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error buying Zora Wow ERC20 memecoin: ${error}`;
+        }
+    }
+    /**
+     * Creates a Zora Wow ERC20 memecoin.
+     *
+     * @param wallet - The wallet to create the token from.
+     * @param args - The input arguments for the action.
+     * @returns A message containing the token creation details.
+     */
+    async createToken(wallet, args) {
+        const factoryAddress = (0, constants_1.getFactoryAddress)(wallet.getNetwork().networkId);
+        try {
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WOW_FACTORY_ABI,
+                functionName: "deploy",
+                args: [
+                    wallet.getAddress(),
+                    "0x0000000000000000000000000000000000000000",
+                    args.tokenUri || constants_1.GENERIC_TOKEN_METADATA_URI,
+                    args.name,
+                    args.symbol,
+                ],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: factoryAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Created WoW ERC20 memecoin ${args.name} with symbol ${args.symbol} on network ${wallet.getNetwork().networkId}.\nTransaction hash for the token creation: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error creating Zora Wow ERC20 memecoin: ${error}`;
+        }
+    }
+    /**
+     * Sells WOW tokens for ETH.
+     *
+     * @param wallet - The wallet to sell the tokens from.
+     * @param args - The input arguments for the action.
+     * @returns A message confirming the sale with the transaction hash.
+     */
+    async sellToken(wallet, args) {
+        try {
+            const ethQuote = await (0, utils_1.getSellQuote)(wallet, args.contractAddress, args.amountTokensInWei);
+            const hasGraduated = await (0, utils_2.getHasGraduated)(wallet, args.contractAddress);
+            // Multiply by 98/100 and floor to get 98% of quote as minimum
+            const minEth = BigInt(Math.floor(Number(ethQuote) * 98)) / BigInt(100);
+            const data = (0, viem_1.encodeFunctionData)({
+                abi: constants_1.WOW_ABI,
+                functionName: "sell",
+                args: [
+                    BigInt(args.amountTokensInWei),
+                    wallet.getAddress(),
+                    "0x0000000000000000000000000000000000000000",
+                    "",
+                    hasGraduated ? 1n : 0n,
+                    minEth,
+                    0n,
+                ],
+            });
+            const txHash = await wallet.sendTransaction({
+                to: args.contractAddress,
+                data,
+            });
+            const receipt = await wallet.waitForTransactionReceipt(txHash);
+            return `Sold WoW ERC20 memecoin with transaction hash: ${txHash}, and receipt:\n${JSON.stringify(receipt)}`;
+        }
+        catch (error) {
+            return `Error selling Zora Wow ERC20 memecoin: ${error}`;
+        }
+    }
+}
+exports.WowActionProvider = WowActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "buy_token",
+        description: `
+This tool can only be used to buy a Zora Wow ERC20 memecoin (also can be referred to as a bonding curve token) with ETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- WOW token contract address
+- Address to receive the tokens  
+- Amount of ETH to spend (in wei)
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action. 
+- 1 wei = 0.000000000000000001 ETH
+- Minimum purchase amount is 100000000000000 wei (0.0000001 ETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')`,
+        schema: schemas_1.WowBuyTokenInput,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WowActionProvider.prototype, "buyToken", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "create_token",
+        description: `
+This tool can only be used to create a Zora Wow ERC20 memecoin (also can be referred to as a bonding curve token) using the WoW factory.
+Do not use this tool for any other purpose, or for creating other types of tokens.
+
+Inputs:
+- Token name (e.g. WowCoin)
+- Token symbol (e.g. WOW) 
+- Token URI (optional) - Contains metadata about the token
+
+Important notes:
+- Uses a bonding curve - no upfront liquidity needed
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')`,
+        schema: schemas_1.WowCreateTokenInput,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WowActionProvider.prototype, "createToken", null);
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "sell_token",
+        description: `
+This tool can only be used to sell a Zora Wow ERC20 memecoin (also can be referred to as a bonding curve token) for ETH.
+Do not use this tool for any other purpose, or trading other assets.
+
+Inputs:
+- WOW token contract address
+- Amount of tokens to sell (in wei)
+
+Important notes:
+- The amount is a string and cannot have any decimal points, since the unit of measurement is wei.
+- Make sure to use the exact amount provided, and if there's any doubt, check by getting more information before continuing with the action. 
+- 1 wei = 0.000000000000000001 ETH
+- Minimum purchase amount is 100000000000000 wei (0.0000001 ETH)
+- Only supported on the following networks:
+  - Base Sepolia (ie, 'base-sepolia')
+  - Base Mainnet (ie, 'base', 'base-mainnet')`,
+        schema: schemas_1.WowSellTokenInput,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], WowActionProvider.prototype, "sellToken", null);
+const wowActionProvider = () => new WowActionProvider();
+exports.wowActionProvider = wowActionProvider;

package/dist/action-providers/wow/wowActionProvider.test.d.ts

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

package/dist/action-providers/wow/wowActionProvider.test.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const wowActionProvider_1 = require("./wowActionProvider");
+const constants_1 = require("./constants");
+const utils_1 = require("./utils");
+const utils_2 = require("./uniswap/utils");
+const schemas_1 = require("./schemas");
+jest.mock("./utils", () => ({
+    getBuyQuote: jest.fn(),
+    getSellQuote: jest.fn(),
+}));
+jest.mock("./uniswap/utils", () => ({
+    getHasGraduated: jest.fn(),
+}));
+describe("WowActionProvider", () => {
+    const MOCK_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
+    const INVALID_ADDRESS = "0xinvalid";
+    const MOCK_AMOUNT_ETH_IN_WEI = BigInt("100000000000000000");
+    const INVALID_WEI = "1.5"; // Wei amounts can't have decimals
+    const MOCK_AMOUNT_TOKENS_IN_WEI = BigInt("1000000000000000000");
+    const MOCK_NAME = "Test Token";
+    const MOCK_SYMBOL = "TEST";
+    const MOCK_URI = "ipfs://QmY1GqprFYvojCcUEKgqHeDj9uhZD9jmYGrQTfA9vAE78J";
+    const INVALID_URI = "not-a-url";
+    const MOCK_TX_HASH = "0xabcdef1234567890";
+    const MOCK_ADDRESS = "0x9876543210987654321098765432109876543210";
+    let provider;
+    let mockWallet;
+    beforeEach(() => {
+        mockWallet = {
+            getAddress: jest.fn().mockReturnValue(MOCK_ADDRESS),
+            getNetwork: jest.fn().mockReturnValue({ protocolFamily: "evm", networkId: "base-sepolia" }),
+            sendTransaction: jest.fn().mockResolvedValue(MOCK_TX_HASH),
+            waitForTransactionReceipt: jest.fn().mockResolvedValue({}),
+            readContract: jest.fn(),
+        };
+        provider = new wowActionProvider_1.WowActionProvider();
+        utils_1.getBuyQuote.mockResolvedValue("1000000000000000000");
+        utils_1.getSellQuote.mockResolvedValue("1000000000000000000");
+        utils_2.getHasGraduated.mockResolvedValue(true);
+    });
+    describe("Input Validation", () => {
+        describe("buyToken", () => {
+            it("should validate Ethereum addresses", () => {
+                const result = schemas_1.WowBuyTokenInput.safeParse({
+                    contractAddress: INVALID_ADDRESS,
+                    amountEthInWei: MOCK_AMOUNT_ETH_IN_WEI.toString(),
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].message).toContain("Invalid address");
+                }
+            });
+            it("should validate wei amount format", () => {
+                const result = schemas_1.WowBuyTokenInput.safeParse({
+                    contractAddress: MOCK_CONTRACT_ADDRESS,
+                    amountEthInWei: INVALID_WEI,
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].message).toBe("Must be a valid wei amount");
+                }
+            });
+            it("should accept valid input", () => {
+                const result = schemas_1.WowBuyTokenInput.safeParse({
+                    contractAddress: MOCK_CONTRACT_ADDRESS,
+                    amountEthInWei: MOCK_AMOUNT_ETH_IN_WEI.toString(),
+                });
+                expect(result.success).toBe(true);
+            });
+        });
+        describe("createToken", () => {
+            it("should require non-empty name", () => {
+                const result = schemas_1.WowCreateTokenInput.safeParse({
+                    name: "",
+                    symbol: MOCK_SYMBOL,
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].code).toBe("too_small");
+                }
+            });
+            it("should require non-empty symbol", () => {
+                const result = schemas_1.WowCreateTokenInput.safeParse({
+                    name: MOCK_NAME,
+                    symbol: "",
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].code).toBe("too_small");
+                }
+            });
+            it("should validate tokenUri format if provided", () => {
+                const result = schemas_1.WowCreateTokenInput.safeParse({
+                    name: MOCK_NAME,
+                    symbol: MOCK_SYMBOL,
+                    tokenUri: INVALID_URI,
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].code).toBe("invalid_string");
+                }
+            });
+            it("should accept valid input with proper URL", () => {
+                const result = schemas_1.WowCreateTokenInput.safeParse({
+                    name: MOCK_NAME,
+                    symbol: MOCK_SYMBOL,
+                    tokenUri: MOCK_URI,
+                });
+                expect(result.success).toBe(true);
+            });
+        });
+        describe("sellToken", () => {
+            it("should validate Ethereum addresses", () => {
+                const result = schemas_1.WowSellTokenInput.safeParse({
+                    contractAddress: INVALID_ADDRESS,
+                    amountTokensInWei: MOCK_AMOUNT_TOKENS_IN_WEI.toString(),
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].message).toContain("Invalid address");
+                }
+            });
+            it("should validate wei amount format", () => {
+                const result = schemas_1.WowSellTokenInput.safeParse({
+                    contractAddress: MOCK_CONTRACT_ADDRESS,
+                    amountTokensInWei: INVALID_WEI,
+                });
+                expect(result.success).toBe(false);
+                if (!result.success) {
+                    expect(result.error.issues[0].message).toBe("Must be a valid wei amount");
+                }
+            });
+            it("should accept valid input", () => {
+                const result = schemas_1.WowSellTokenInput.safeParse({
+                    contractAddress: MOCK_CONTRACT_ADDRESS,
+                    amountTokensInWei: MOCK_AMOUNT_TOKENS_IN_WEI.toString(),
+                });
+                expect(result.success).toBe(true);
+            });
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for supported networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-mainnet" })).toBe(true);
+        });
+        it("should return false for unsupported networks", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "base-sepolia" })).toBe(false);
+            expect(provider.supportsNetwork({ protocolFamily: "evm", networkId: "ethereum" })).toBe(false);
+            expect(provider.supportsNetwork({ protocolFamily: "bitcoin", networkId: "base-mainnet" })).toBe(false);
+        });
+    });
+    describe("buyToken", () => {
+        it("should successfully buy tokens", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT_ADDRESS,
+                amountEthInWei: MOCK_AMOUNT_ETH_IN_WEI.toString(),
+            };
+            const response = await provider.buyToken(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_CONTRACT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WOW_ABI,
+                    functionName: "buy",
+                    args: [
+                        MOCK_ADDRESS,
+                        MOCK_ADDRESS,
+                        "0x0000000000000000000000000000000000000000",
+                        "",
+                        1n,
+                        BigInt(Math.floor(Number("1000000000000000000") * 99)) / BigInt(100),
+                        0n,
+                    ],
+                }),
+                value: MOCK_AMOUNT_ETH_IN_WEI,
+            });
+            expect(response).toContain("Purchased WoW ERC20 memecoin");
+            expect(response).toContain(MOCK_TX_HASH);
+        });
+        it("should handle buy errors", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT_ADDRESS,
+                amountEthInWei: MOCK_AMOUNT_ETH_IN_WEI.toString(),
+            };
+            const error = new Error("Buy failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const response = await provider.buyToken(mockWallet, args);
+            expect(response).toContain(`Error buying Zora Wow ERC20 memecoin: ${error}`);
+        });
+    });
+    describe("createToken", () => {
+        it("should successfully create a token", async () => {
+            const args = {
+                name: MOCK_NAME,
+                symbol: MOCK_SYMBOL,
+                tokenUri: MOCK_URI,
+            };
+            const response = await provider.createToken(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: expect.any(String),
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WOW_FACTORY_ABI,
+                    functionName: "deploy",
+                    args: [
+                        MOCK_ADDRESS,
+                        "0x0000000000000000000000000000000000000000",
+                        MOCK_URI,
+                        MOCK_NAME,
+                        MOCK_SYMBOL,
+                    ],
+                }),
+            });
+            expect(response).toContain(`Created WoW ERC20 memecoin ${MOCK_NAME}`);
+            expect(response).toContain(`with symbol ${MOCK_SYMBOL}`);
+            expect(response).toContain(MOCK_TX_HASH);
+        });
+        it("should use default token URI if not provided", async () => {
+            const args = {
+                name: MOCK_NAME,
+                symbol: MOCK_SYMBOL,
+            };
+            await provider.createToken(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: expect.any(String),
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WOW_FACTORY_ABI,
+                    functionName: "deploy",
+                    args: [
+                        MOCK_ADDRESS,
+                        "0x0000000000000000000000000000000000000000",
+                        constants_1.GENERIC_TOKEN_METADATA_URI,
+                        MOCK_NAME,
+                        MOCK_SYMBOL,
+                    ],
+                }),
+            });
+        });
+        it("should handle create errors", async () => {
+            const args = {
+                name: MOCK_NAME,
+                symbol: MOCK_SYMBOL,
+            };
+            const error = new Error("Create failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const response = await provider.createToken(mockWallet, args);
+            expect(response).toContain(`Error creating Zora Wow ERC20 memecoin: ${error}`);
+        });
+    });
+    describe("sellToken", () => {
+        it("should successfully sell tokens", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT_ADDRESS,
+                amountTokensInWei: MOCK_AMOUNT_TOKENS_IN_WEI.toString(),
+            };
+            const response = await provider.sellToken(mockWallet, args);
+            expect(mockWallet.sendTransaction).toHaveBeenCalledWith({
+                to: MOCK_CONTRACT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: constants_1.WOW_ABI,
+                    functionName: "sell",
+                    args: [
+                        MOCK_AMOUNT_TOKENS_IN_WEI,
+                        MOCK_ADDRESS,
+                        "0x0000000000000000000000000000000000000000",
+                        "",
+                        1n,
+                        BigInt(Math.floor(Number("1000000000000000000") * 98)) / BigInt(100),
+                        0n,
+                    ],
+                }),
+            });
+            expect(response).toContain("Sold WoW ERC20 memecoin");
+            expect(response).toContain(MOCK_TX_HASH);
+        });
+        it("should handle sell errors", async () => {
+            const args = {
+                contractAddress: MOCK_CONTRACT_ADDRESS,
+                amountTokensInWei: MOCK_AMOUNT_TOKENS_IN_WEI.toString(),
+            };
+            const error = new Error("Sell failed");
+            mockWallet.sendTransaction.mockRejectedValue(error);
+            const response = await provider.sellToken(mockWallet, args);
+            expect(response).toContain(`Error selling Zora Wow ERC20 memecoin: ${error}`);
+        });
+    });
+});

package/dist/agentkit.d.ts

@@ -0,0 +1,45 @@
+import { WalletProvider } from "./wallet-providers";
+import { Action, ActionProvider } from "./action-providers";
+/**
+ * Configuration options for AgentKit
+ */
+type AgentKitOptions = {
+    cdpApiKeyName?: string;
+    cdpApiKeyPrivateKey?: string;
+    walletProvider?: WalletProvider;
+    actionProviders?: ActionProvider[];
+};
+/**
+ * AgentKit
+ */
+export declare class AgentKit {
+    private walletProvider;
+    private actionProviders;
+    /**
+     * Initializes a new AgentKit instance
+     *
+     * @param config - Configuration options for the AgentKit
+     * @param config.walletProvider - The wallet provider to use
+     * @param config.actionProviders - The action providers to use
+     * @param config.actions - The actions to use
+     */
+    private constructor();
+    /**
+     * Initializes a new AgentKit instance
+     *
+     * @param config - Configuration options for the AgentKit
+     * @param config.walletProvider - The wallet provider to use
+     * @param config.actionProviders - The action providers to use
+     * @param config.actions - The actions to use
+     *
+     * @returns A new AgentKit instance
+     */
+    static from(config?: AgentKitOptions): Promise<AgentKit>;
+    /**
+     * Returns the actions available to the AgentKit.
+     *
+     * @returns An array of actions
+     */
+    getActions(): Action[];
+}
+export {};

package/dist/agentkit.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentKit = void 0;
+const wallet_providers_1 = require("./wallet-providers");
+const action_providers_1 = require("./action-providers");
+/**
+ * AgentKit
+ */
+class AgentKit {
+    /**
+     * Initializes a new AgentKit instance
+     *
+     * @param config - Configuration options for the AgentKit
+     * @param config.walletProvider - The wallet provider to use
+     * @param config.actionProviders - The action providers to use
+     * @param config.actions - The actions to use
+     */
+    constructor(config) {
+        this.walletProvider = config.walletProvider;
+        this.actionProviders = config.actionProviders || [(0, action_providers_1.walletActionProvider)()];
+    }
+    /**
+     * Initializes a new AgentKit instance
+     *
+     * @param config - Configuration options for the AgentKit
+     * @param config.walletProvider - The wallet provider to use
+     * @param config.actionProviders - The action providers to use
+     * @param config.actions - The actions to use
+     *
+     * @returns A new AgentKit instance
+     */
+    static async from(config = { actionProviders: [(0, action_providers_1.walletActionProvider)()] }) {
+        let walletProvider = config.walletProvider;
+        if (!config.walletProvider) {
+            if (!config.cdpApiKeyName || !config.cdpApiKeyPrivateKey) {
+                throw new Error("cdpApiKeyName and cdpApiKeyPrivateKey are required if not providing a walletProvider");
+            }
+            walletProvider = await wallet_providers_1.CdpWalletProvider.configureWithWallet({
+                apiKeyName: config.cdpApiKeyName,
+                apiKeyPrivateKey: config.cdpApiKeyPrivateKey,
+            });
+        }
+        return new AgentKit({ ...config, walletProvider: walletProvider });
+    }
+    /**
+     * Returns the actions available to the AgentKit.
+     *
+     * @returns An array of actions
+     */
+    getActions() {
+        const actions = [];
+        for (const actionProvider of this.actionProviders) {
+            if (actionProvider.supportsNetwork(this.walletProvider.getNetwork())) {
+                actions.push(...actionProvider.getActions(this.walletProvider));
+            }
+        }
+        return actions;
+    }
+}
+exports.AgentKit = AgentKit;

package/dist/analytics/index.d.ts

@@ -0,0 +1 @@
+export * from "./sendAnalyticsEvent";

package/dist/analytics/index.js

@@ -0,0 +1,17 @@
+"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("./sendAnalyticsEvent"), exports);

package/dist/analytics/sendAnalyticsEvent.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The required data for an analytics event
+ *
+ * Accepts arbitrary additional fields
+ */
+type RequiredEventData = {
+    /**
+     * The event that took place, e.g. initialize_wallet_provider, agent_action_invocation
+     */
+    action: string;
+    /**
+     * The component that the event took place in, e.g. wallet_provider, agent_action
+     */
+    component: string;
+    /**
+     * The name of the event. This should match the name in AEC
+     */
+    name: string;
+    /**
+     * The timestamp of the event. If not provided, the current time will be used.
+     */
+    timestamp?: number;
+} & Record<string, string | undefined>;
+/**
+ * Sends an analytics event to the default endpoint
+ *
+ * @param event - The event data containing required action, component and name fields
+ * @returns Promise that resolves when the event is sent
+ */
+export declare function sendAnalyticsEvent(event: RequiredEventData): Promise<void>;
+export {};