@coinbase/agentkit 0.10.0 → 0.10.1

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

@@ -13,20 +13,20 @@ export declare const RequestFaucetFundsV2Schema: z.ZodObject<{
  * Input schema for swap tokens action.
  */
 export declare const SwapSchema: z.ZodObject<{
-    fromAssetId: z.ZodString;
-    toAssetId: z.ZodString;
-    amount: z.ZodString;
-    network: z.ZodOptional<z.ZodString>;
+    fromToken: z.ZodString;
+    toToken: z.ZodString;
+    fromAmount: z.ZodString;
+    slippageBps: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
-    amount: string;
-    fromAssetId: string;
-    toAssetId: string;
-    network?: string | undefined;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    slippageBps: number;
 }, {
-    amount: string;
-    fromAssetId: string;
-    toAssetId: string;
-    network?: string | undefined;
+    fromToken: string;
+    toToken: string;
+    fromAmount: string;
+    slippageBps?: number | undefined;
 }>;
 /**
  * Input schema for listing spend permissions action.

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

@@ -16,13 +16,25 @@ exports.RequestFaucetFundsV2Schema = zod_1.z
  */
 exports.SwapSchema = zod_1.z
     .object({
-    fromAssetId: zod_1.z.string().describe("The asset ID to swap from (e.g., 'eth', 'usdc')"),
-    toAssetId: zod_1.z.string().describe("The asset ID to swap to (e.g., 'eth', 'usdc')"),
-    amount: zod_1.z.string().describe("The amount to swap (in the from asset's units)"),
-    network: zod_1.z
+    fromToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to swap from"),
+    toToken: zod_1.z
+        .string()
+        .regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address format")
+        .describe("The token contract address to swap to"),
+    fromAmount: zod_1.z
         .string()
+        .describe("The amount of fromToken to sell in whole units (e.g., 1.5 WETH, 10.5 USDC)"),
+    slippageBps: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(10000)
         .optional()
-        .describe("The network to perform the swap on (defaults to wallet's network)"),
+        .default(100)
+        .describe("The maximum acceptable slippage in basis points (0-10000, default: 100 = 1%)"),
 })
     .strip()
     .describe("Instructions for swapping tokens");

package/dist/action-providers/cdp/swapUtils.d.ts

@@ -0,0 +1,32 @@
+import { EvmWalletProvider } from "../../wallet-providers";
+export declare const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+export declare function isNativeEth(token: string): boolean;
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+export declare function getTokenDetails(walletProvider: EvmWalletProvider, fromToken: string, toToken: string): Promise<{
+    fromTokenDecimals: number;
+    toTokenDecimals: number;
+    fromTokenName: string;
+    toTokenName: string;
+}>;
+/**
+ * Retry function with exponential backoff
+ *
+ * @param fn - The function to retry
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param baseDelay - Base delay in milliseconds (default: 1000)
+ * @returns Promise that resolves with the function result or rejects with the last error
+ */
+export declare function retryWithExponentialBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;

package/dist/action-providers/cdp/swapUtils.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PERMIT2_ADDRESS = void 0;
+exports.isNativeEth = isNativeEth;
+exports.getTokenDetails = getTokenDetails;
+exports.retryWithExponentialBackoff = retryWithExponentialBackoff;
+const viem_1 = require("viem");
+// Permit2 contract address is the same across all networks
+exports.PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+/**
+ * Checks if a token is native ETH.
+ *
+ * @param token - The token address to check.
+ * @returns True if the token is native ETH, false otherwise.
+ */
+function isNativeEth(token) {
+    return token.toLowerCase() === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+}
+/**
+ * Gets the details (decimals and name) for both fromToken and toToken
+ *
+ * @param walletProvider - The EVM wallet provider to read contracts
+ * @param fromToken - The contract address of the from token
+ * @param toToken - The contract address of the to token
+ * @returns Promise<{fromTokenDecimals: number, toTokenDecimals: number, fromTokenName: string, toTokenName: string}>
+ */
+async function getTokenDetails(walletProvider, fromToken, toToken) {
+    // Initialize default values for native ETH
+    let fromTokenDecimals = 18;
+    let fromTokenName = "ETH";
+    let toTokenDecimals = 18;
+    let toTokenName = "ETH";
+    // Prepare multicall contracts array
+    const contracts = [];
+    const contractIndexMap = {
+        fromDecimals: -1,
+        fromName: -1,
+        toDecimals: -1,
+        toName: -1,
+    };
+    // Add from token contracts if not native ETH
+    if (!isNativeEth(fromToken)) {
+        contractIndexMap.fromDecimals = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.fromName = contracts.length;
+        contracts.push({
+            address: fromToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Add to token contracts if not native ETH
+    if (!isNativeEth(toToken)) {
+        contractIndexMap.toDecimals = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "decimals",
+        });
+        contractIndexMap.toName = contracts.length;
+        contracts.push({
+            address: toToken,
+            abi: viem_1.erc20Abi,
+            functionName: "name",
+        });
+    }
+    // Execute multicall if there are contracts to call
+    if (contracts.length > 0) {
+        try {
+            const results = await walletProvider.getPublicClient().multicall({
+                contracts,
+            });
+            // Extract from token details
+            if (contractIndexMap.fromDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.fromDecimals];
+                const nameResult = results[contractIndexMap.fromName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    fromTokenDecimals = decimalsResult.result;
+                    fromTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for fromToken ${fromToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+            // Extract to token details
+            if (contractIndexMap.toDecimals !== -1) {
+                const decimalsResult = results[contractIndexMap.toDecimals];
+                const nameResult = results[contractIndexMap.toName];
+                if (decimalsResult.status === "success" && nameResult.status === "success") {
+                    toTokenDecimals = decimalsResult.result;
+                    toTokenName = nameResult.result;
+                }
+                else {
+                    throw new Error(`Failed to read details for toToken ${toToken}. This address may not be a valid ERC20 contract.`);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read token details via multicall. Error: ${error}`);
+        }
+    }
+    return { fromTokenDecimals, toTokenDecimals, fromTokenName, toTokenName };
+}
+/**
+ * Utility function to sleep for a given number of milliseconds
+ *
+ * @param ms - Number of milliseconds to sleep
+ * @returns Promise that resolves after the specified delay
+ */
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Retry function with exponential backoff
+ *
+ * @param fn - The function to retry
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param baseDelay - Base delay in milliseconds (default: 1000)
+ * @returns Promise that resolves with the function result or rejects with the last error
+ */
+async function retryWithExponentialBackoff(fn, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        // Wait before each attempt
+        // Calculate delay with exponential backoff: baseDelay * 2^attempt
+        const delay = baseDelay * Math.pow(2, attempt);
+        await sleep(delay);
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // If this was the last attempt, throw the error
+            if (attempt === maxRetries) {
+                throw lastError;
+            }
+        }
+    }
+    throw lastError;
+}

package/dist/action-providers/clanker/clankerActionProvider.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { ActionProvider } from "../actionProvider";
+import { Network } from "../../network";
+import { EvmWalletProvider } from "../../wallet-providers";
+import { ClankTokenSchema } from "./schemas";
+/**
+ * ClankerActionProvider provides actions for clanker operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+export declare class ClankerActionProvider extends ActionProvider<EvmWalletProvider> {
+    /**
+     * Constructor for the ClankerActionProvider.
+     */
+    constructor();
+    /**
+     * Clanker action provider
+     *
+     * @description
+     * This action deploys a clanker token using the Clanker sdk
+     * It automatically includes the coin in the Clanker ecosystem
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param args - Clanker arguments (modify these to fine tune token deployment, like initial quote token and rewards config)
+     * @returns A promise that resolves to a string describing the clanker result
+     */
+    clankToken(walletProvider: EvmWalletProvider, args: z.infer<typeof ClankTokenSchema>): Promise<string>;
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network: Network): boolean;
+}
+/**
+ * Factory function to create a new ClankerActionProvider instance.
+ *
+ * @returns A new ClankerActionProvider instance
+ */
+export declare const clankerActionProvider: () => ClankerActionProvider;

package/dist/action-providers/clanker/clankerActionProvider.js

@@ -0,0 +1,130 @@
+"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.clankerActionProvider = exports.ClankerActionProvider = void 0;
+const zod_1 = require("zod");
+const actionProvider_1 = require("../actionProvider");
+const actionDecorator_1 = require("../actionDecorator");
+const wallet_providers_1 = require("../../wallet-providers");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+/**
+ * ClankerActionProvider provides actions for clanker operations.
+ *
+ * @description
+ * This provider is designed to work with EvmWalletProvider for blockchain interactions.
+ * It supports all evm networks.
+ */
+class ClankerActionProvider extends actionProvider_1.ActionProvider {
+    /**
+     * Constructor for the ClankerActionProvider.
+     */
+    constructor() {
+        super("clanker", []);
+    }
+    /**
+     * Clanker action provider
+     *
+     * @description
+     * This action deploys a clanker token using the Clanker sdk
+     * It automatically includes the coin in the Clanker ecosystem
+     *
+     * @param walletProvider - The wallet provider instance for blockchain interactions
+     * @param args - Clanker arguments (modify these to fine tune token deployment, like initial quote token and rewards config)
+     * @returns A promise that resolves to a string describing the clanker result
+     */
+    async clankToken(walletProvider, args) {
+        const network = walletProvider.getNetwork();
+        const networkId = network.networkId || "base-mainnet";
+        if (!this.supportsNetwork(network)) {
+            return `Can't Clank token; network ${networkId} is not supported`;
+        }
+        const clanker = await (0, utils_1.createClankerClient)(walletProvider, networkId);
+        const lockDuration = args.lockDuration_Days * 24 * 60 * 60;
+        const vestingDuration = args.vestingDuration_Days * 24 * 60 * 60;
+        const tokenConfig = {
+            name: args.tokenName,
+            symbol: args.tokenSymbol,
+            image: args.image,
+            metadata: {
+                socialMediaUrls: args.socialMediaUrls,
+                description: args.description,
+            },
+            context: {
+                interface: args.interface,
+                id: args.id,
+            },
+            tokenAdmin: walletProvider.getAddress(),
+            vault: {
+                percentage: args.vaultPercentage,
+                lockupDuration: lockDuration,
+                vestingDuration: vestingDuration,
+            },
+            chainId: Number(network.chainId),
+        };
+        try {
+            const res = await clanker.deploy(tokenConfig);
+            if ("error" in res) {
+                return `There was an error deploying the clanker token: ${res}`;
+            }
+            const { txHash } = res;
+            const confirmed = await res.waitForTransaction();
+            if ("error" in confirmed) {
+                return `There was an error confirming the clanker token deployment: ${confirmed}`;
+            }
+            const { address } = confirmed;
+            return `Clanker token deployed at ${address}!  View the transaction at ${txHash}, or view the token page at https://clanker.world/clanker/${address}`;
+        }
+        catch (error) {
+            return `There was an error deploying the clanker token: ${error}`;
+        }
+    }
+    /**
+     * Checks if this provider supports the given network.
+     *
+     * @param network - The network to check support for
+     * @returns True if the network is supported
+     */
+    supportsNetwork(network) {
+        return (network.networkId === "base-mainnet" ||
+            network.networkId === "base-sepolia" ||
+            network.networkId === "arbitrum-mainnet");
+    }
+}
+exports.ClankerActionProvider = ClankerActionProvider;
+__decorate([
+    (0, actionDecorator_1.CreateAction)({
+        name: "clank_token",
+        description: `
+his tool will launch a Clanker token using the Clanker SDK.
+It takes the following inputs:
+- tokenName: The name of the deployed token
+- tokenSymbol: The symbol of the deployed token  
+- description: An optional description of the token or token project
+- socialMediaUrls: An optional array of social media links for the token, each with a platform and url
+- image: A normal or ipfs URL pointing to the image of the token
+- vaultPercentage: The percentage of the token supply to allocate to a vault accessible to the deployed after the lockup period with optional vesting
+- lockDuration_Days: The lock duration of the tokens in the vault (in days) (minimum 7 days)
+- vestingDuration_Days: The duration (in days) that the token should vest after lockup period, vesting is linear.
+  `,
+        schema: schemas_1.ClankTokenSchema,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [wallet_providers_1.EvmWalletProvider, void 0]),
+    __metadata("design:returntype", Promise)
+], ClankerActionProvider.prototype, "clankToken", null);
+/**
+ * Factory function to create a new ClankerActionProvider instance.
+ *
+ * @returns A new ClankerActionProvider instance
+ */
+const clankerActionProvider = () => new ClankerActionProvider();
+exports.clankerActionProvider = clankerActionProvider;

package/dist/action-providers/clanker/clankerActionProvider.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Clanker Action Provider tests
+ */
+export {};

package/dist/action-providers/clanker/clankerActionProvider.test.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Clanker Action Provider tests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const clankerActionProvider_1 = require("./clankerActionProvider");
+const schemas_1 = require("./schemas");
+const utils_1 = require("./utils");
+jest.mock("./utils", () => ({
+    createClankerClient: jest.fn(),
+}));
+const createClankerClientMock = utils_1.createClankerClient;
+const DEPLOYED_HASH = "0xdeadbeef";
+const DEPLOYED_TOKEN_ADDRESS = "0xabc123abc123abc123abc123abc123abc123abc1";
+describe("Clanker action provider tests", () => {
+    const provider = (0, clankerActionProvider_1.clankerActionProvider)();
+    let mockWalletProvider;
+    beforeEach(() => {
+        mockWalletProvider = {
+            getAddress: jest.fn(),
+            getBalance: jest.fn(),
+            getName: jest.fn(),
+            getNetwork: jest.fn().mockReturnValue({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            }),
+            nativeTransfer: jest.fn(),
+        };
+        const fakeClanker = {
+            deploy: jest.fn(async (_tokenCfg) => ({
+                txHash: DEPLOYED_HASH,
+                waitForTransaction: async () => ({ address: DEPLOYED_TOKEN_ADDRESS }),
+            })),
+        };
+        createClankerClientMock.mockResolvedValue(fakeClanker);
+    });
+    describe("network validation", () => {
+        it("should support the protocol family and network", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            })).toBe(true);
+        });
+        it("should not support other protocol families", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "other-protocol-family",
+            })).toBe(false);
+        });
+        it("should handle invalid network objects", () => {
+            expect(provider.supportsNetwork({ protocolFamily: "invalid-protocol" })).toBe(false);
+            expect(provider.supportsNetwork({})).toBe(false);
+        });
+    });
+    describe("schema validation", () => {
+        it("should validate example action schema", () => {
+            const validInput = {
+                tokenName: "testTokenName",
+                tokenSymbol: "TTN",
+                image: "https://test.com",
+                vaultPercentage: 10,
+                vestingDuration_Days: 30,
+                lockDuration_Days: 30,
+                interface: "CDP AgentKit",
+                id: "test-id",
+            };
+            const parseResult = schemas_1.ClankTokenSchema.safeParse(validInput);
+            expect(parseResult.success).toBe(true);
+            if (parseResult.success) {
+                expect(parseResult.data.tokenName).toBe("testTokenName");
+                expect(parseResult.data.tokenSymbol).toBe("TTN");
+                expect(parseResult.data.image).toBe("https://test.com");
+                expect(parseResult.data.vaultPercentage).toBe(10);
+                expect(parseResult.data.vestingDuration_Days).toBe(30);
+                expect(parseResult.data.lockDuration_Days).toBe(30);
+            }
+        });
+        it("should reject invalid example action input", () => {
+            const invalidInput = {
+                fieldName: "",
+                amount: "invalid",
+            };
+            const parseResult = schemas_1.ClankTokenSchema.safeParse(invalidInput);
+            expect(parseResult.success).toBe(false);
+        });
+    });
+    describe("clanker action execution", () => {
+        it("should execute the clanker action with wallet provider", async () => {
+            const args = {
+                tokenName: "testTokenName",
+                tokenSymbol: "TTN",
+                image: "https://test.com",
+                vaultPercentage: 10,
+                vestingDuration_Days: 30,
+                lockDuration_Days: 30,
+                interface: "CDP AgentKit",
+                id: "test-id",
+            };
+            const result = await provider.clankToken(mockWalletProvider, args);
+            expect(result).toContain(`Clanker token deployed at ${DEPLOYED_TOKEN_ADDRESS}`);
+            expect(result).toContain(`View the transaction at ${DEPLOYED_HASH}`);
+            expect(mockWalletProvider.getNetwork).toHaveBeenCalled();
+            expect(createClankerClientMock).toHaveBeenCalledWith(expect.any(Object), expect.any(String));
+        });
+    });
+    describe("supportsNetwork", () => {
+        it("should return true for base-mainnet with evm protocol", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "base-mainnet",
+            })).toBe(true);
+        });
+        it("should return false for non-base networks", () => {
+            expect(provider.supportsNetwork({
+                protocolFamily: "evm",
+                networkId: "ethereum-mainnet",
+            })).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from "./clankerActionProvider";
+export * from "./schemas";

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

@@ -0,0 +1,18 @@
+"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("./clankerActionProvider"), exports);
+__exportStar(require("./schemas"), exports);

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

@@ -0,0 +1,56 @@
+import { z } from "zod";
+/**
+ * Action schemas for the clanker action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the clanker action provider.
+ */
+export declare const ClankTokenSchema: z.ZodObject<{
+    tokenName: z.ZodString;
+    tokenSymbol: z.ZodString;
+    image: z.ZodString;
+    vaultPercentage: z.ZodNumber;
+    lockDuration_Days: z.ZodNumber;
+    vestingDuration_Days: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    socialMediaUrls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        platform: z.ZodString;
+        url: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        platform: string;
+    }, {
+        url: string;
+        platform: string;
+    }>, "many">>;
+    interface: z.ZodDefault<z.ZodString>;
+    id: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    tokenSymbol: string;
+    image: string;
+    tokenName: string;
+    vaultPercentage: number;
+    lockDuration_Days: number;
+    vestingDuration_Days: number;
+    interface: string;
+    description?: string | undefined;
+    socialMediaUrls?: {
+        url: string;
+        platform: string;
+    }[] | undefined;
+}, {
+    tokenSymbol: string;
+    image: string;
+    tokenName: string;
+    vaultPercentage: number;
+    lockDuration_Days: number;
+    vestingDuration_Days: number;
+    id?: string | undefined;
+    description?: string | undefined;
+    socialMediaUrls?: {
+        url: string;
+        platform: string;
+    }[] | undefined;
+    interface?: string | undefined;
+}>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClankTokenSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Action schemas for the clanker action provider.
+ *
+ * This file contains the Zod schemas that define the shape and validation
+ * rules for action parameters in the clanker action provider.
+ */
+exports.ClankTokenSchema = zod_1.z
+    .object({
+    tokenName: zod_1.z.string().min(1).max(100).describe("The name of the token (max 100 characters)"),
+    tokenSymbol: zod_1.z.string().min(1).max(10).describe("The symbol of the token (max 10 characters)"),
+    image: zod_1.z.string().url().describe("Normal or ipfs URL pointing to the token image"),
+    vaultPercentage: zod_1.z
+        .number()
+        .min(0)
+        .max(90)
+        .describe("Percentage of token supply allocated to a vault that can be claimed by deployer after lockup period with optional vesting"),
+    lockDuration_Days: zod_1.z
+        .number()
+        .min(7)
+        .describe("Lockup duration of token (in days), minimum 7 days"),
+    vestingDuration_Days: zod_1.z
+        .number()
+        .min(0)
+        .describe("Vesting duration of token after lockup has passed (in days). Vesting is linear over the duration"),
+    description: zod_1.z
+        .string()
+        .optional()
+        .describe("Description of the token or token project (optional)"),
+    socialMediaUrls: zod_1.z
+        .array(zod_1.z.object({ platform: zod_1.z.string(), url: zod_1.z.string() }))
+        .optional()
+        .describe("Socials for the token. These may be displayed on aggregators."),
+    interface: zod_1.z
+        .string()
+        .default("CDP AgentKit")
+        .describe('System the token was deployed via. Defaults to "CDP AgentKit".'),
+    id: zod_1.z
+        .string()
+        .default("")
+        .describe("User id of the poster on the social platform the token was deployed from. Used for provenance and will be verified by aggregators."),
+})
+    .strip()
+    .describe("Instructions for deploying a Clanker token");