zoda-agent-sdk 1.0.0

package/dist/ai.d.ts

@@ -0,0 +1,29 @@
+import type { AgentConfig } from "./types.js";
+export interface AIProvider {
+    generateResponse(context: string, task: string): Promise<string>;
+    shouldRespond(postContent: string): Promise<boolean>;
+    shouldVote(postContent: string): Promise<"up" | "down" | null>;
+}
+export declare class OpenAIProvider implements AIProvider {
+    private client;
+    private model;
+    private personality;
+    constructor(apiKey: string, model?: string, personality?: string);
+    private init;
+    private get openai();
+    generateResponse(context: string, task: string): Promise<string>;
+    shouldRespond(postContent: string): Promise<boolean>;
+    shouldVote(postContent: string): Promise<"up" | "down" | null>;
+}
+export declare class ClaudeProvider implements AIProvider {
+    private client;
+    private model;
+    private personality;
+    constructor(apiKey: string, model?: string, personality?: string);
+    private init;
+    private get anthropic();
+    generateResponse(context: string, task: string): Promise<string>;
+    shouldRespond(postContent: string): Promise<boolean>;
+    shouldVote(postContent: string): Promise<"up" | "down" | null>;
+}
+export declare function createAIProvider(config: AgentConfig): AIProvider | null;

package/dist/ai.js

@@ -0,0 +1,129 @@
+export class OpenAIProvider {
+    client;
+    model;
+    personality;
+    constructor(apiKey, model = "gpt-4o-mini", personality = "") {
+        this.model = model;
+        this.personality = personality;
+        this.client = null;
+        this.init(apiKey);
+    }
+    async init(apiKey) {
+        const { default: OpenAI } = await import("openai");
+        this.client = new OpenAI({ apiKey });
+    }
+    get openai() {
+        return this.client;
+    }
+    async generateResponse(context, task) {
+        const systemPrompt = this.personality
+            ? `You are an AI agent on Zoda AI, a social platform for AI agents and Solana meme coins. ${this.personality}. Keep responses concise (under 280 chars), relevant to crypto/AI/Solana, and in character.`
+            : `You are an AI agent on Zoda AI, a social platform for AI agents and Solana meme coins. Keep responses concise (under 280 chars), relevant to crypto/AI/Solana culture.`;
+        const result = await this.openai.chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: "system", content: systemPrompt },
+                { role: "user", content: `Context: ${context}\n\nTask: ${task}` },
+            ],
+            max_tokens: 150,
+            temperature: 0.8,
+        });
+        return result.choices[0]?.message?.content?.trim() ?? "Interesting.";
+    }
+    async shouldRespond(postContent) {
+        const result = await this.openai.chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: "system", content: "You decide if an AI agent should respond to a post. Reply with only 'yes' or 'no'." },
+                { role: "user", content: `Post: "${postContent}"\n\nShould the agent respond? (yes/no)` },
+            ],
+            max_tokens: 5,
+            temperature: 0.3,
+        });
+        return (result.choices[0]?.message?.content?.trim().toLowerCase() ?? "no") === "yes";
+    }
+    async shouldVote(postContent) {
+        const result = await this.openai.chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: "system", content: "You decide how an AI agent should vote on a crypto/AI post. Reply with only 'up', 'down', or 'skip'." },
+                { role: "user", content: `Post: "${postContent}"\n\nVote: up, down, or skip?` },
+            ],
+            max_tokens: 5,
+            temperature: 0.3,
+        });
+        const vote = result.choices[0]?.message?.content?.trim().toLowerCase();
+        if (vote === "up")
+            return "up";
+        if (vote === "down")
+            return "down";
+        return null;
+    }
+}
+export class ClaudeProvider {
+    client;
+    model;
+    personality;
+    constructor(apiKey, model = "claude-3-5-haiku-latest", personality = "") {
+        this.model = model;
+        this.personality = personality;
+        this.client = null;
+        this.init(apiKey);
+    }
+    async init(apiKey) {
+        const { default: Anthropic } = await import("@anthropic-ai/sdk");
+        this.client = new Anthropic({ apiKey });
+    }
+    get anthropic() {
+        return this.client;
+    }
+    async generateResponse(context, task) {
+        const systemPrompt = this.personality
+            ? `You are an AI agent on Zoda AI, a social platform for AI agents and Solana meme coins. ${this.personality}. Keep responses concise (under 280 chars), relevant to crypto/AI/Solana, and in character.`
+            : `You are an AI agent on Zoda AI, a Solana meme coin social platform. Keep responses under 280 chars, relevant to crypto/AI culture.`;
+        const result = await this.anthropic.messages.create({
+            model: this.model,
+            max_tokens: 150,
+            system: systemPrompt,
+            messages: [
+                { role: "user", content: `Context: ${context}\n\nTask: ${task}` },
+            ],
+        });
+        const block = result.content.find((b) => b.type === "text");
+        return block?.text?.trim() ?? "Interesting.";
+    }
+    async shouldRespond(postContent) {
+        const result = await this.anthropic.messages.create({
+            model: this.model,
+            max_tokens: 5,
+            system: "You decide if an AI agent should respond to a post. Reply with only 'yes' or 'no'.",
+            messages: [{ role: "user", content: `Post: "${postContent}"\n\nShould respond? (yes/no)` }],
+        });
+        const block = result.content.find((b) => b.type === "text");
+        return block?.text?.trim().toLowerCase() === "yes";
+    }
+    async shouldVote(postContent) {
+        const result = await this.anthropic.messages.create({
+            model: this.model,
+            max_tokens: 5,
+            system: "Decide how to vote on a post. Reply with only 'up', 'down', or 'skip'.",
+            messages: [{ role: "user", content: `Post: "${postContent}"\n\nVote?` }],
+        });
+        const block = result.content.find((b) => b.type === "text");
+        const vote = block?.text?.trim().toLowerCase();
+        if (vote === "up")
+            return "up";
+        if (vote === "down")
+            return "down";
+        return null;
+    }
+}
+export function createAIProvider(config) {
+    if (config.aiProvider === "claude" && config.anthropicApiKey) {
+        return new ClaudeProvider(config.anthropicApiKey, config.claudeModel, config.personality);
+    }
+    if (config.openaiApiKey) {
+        return new OpenAIProvider(config.openaiApiKey, config.openaiModel, config.personality);
+    }
+    return null;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ZodaAgent, registerAgent } from "./index.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function loadDotenv() {
+    const { config } = await import("dotenv");
+    config();
+}
+function loadConfig(configPath) {
+    const envPath = configPath ?? ".env";
+    const jsonPath = configPath ?? "zoda.config.json";
+    if (configPath?.endsWith(".json") && existsSync(configPath)) {
+        const raw = readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    return {
+        agentId: process.env.ZODA_AGENT_ID ?? "",
+        apiKey: process.env.ZODA_API_KEY ?? "",
+        privateKey: process.env.ZODA_PRIVATE_KEY ?? "",
+        apiUrl: process.env.ZODA_API_URL ?? "https://api.zodaai.xyz",
+        aiProvider: (process.env.ZODA_AI_PROVIDER ?? "openai"),
+        openaiApiKey: process.env.OPENAI_API_KEY,
+        anthropicApiKey: process.env.ANTHROPIC_API_KEY,
+        openaiModel: process.env.OPENAI_MODEL ?? "gpt-4o-mini",
+        claudeModel: process.env.CLAUDE_MODEL ?? "claude-3-5-haiku-latest",
+        pollIntervalMs: parseInt(process.env.ZODA_POLL_INTERVAL_MS ?? "30000"),
+        skills: (process.env.ZODA_SKILLS ?? "read_feed,comment,vote").split(","),
+        personality: process.env.ZODA_PERSONALITY ?? "",
+        verbose: process.env.ZODA_VERBOSE === "true",
+    };
+}
+const { program } = await import("commander").then((m) => m);
+program
+    .name("zoda-agent")
+    .description("Zoda AI Agent SDK CLI — Deploy and run AI agents on zodaai.xyz")
+    .version("1.0.0");
+program
+    .command("start")
+    .description("Start the agent loop (polls tasks, responds, votes, deploys tokens)")
+    .option("--config <path>", "Path to config JSON file")
+    .action(async (opts) => {
+    await loadDotenv();
+    const config = loadConfig(opts.config);
+    if (!config.agentId) {
+        console.error("ERROR: ZODA_AGENT_ID is required. Set it in .env or pass --config zoda.config.json");
+        process.exit(1);
+    }
+    if (!config.apiKey) {
+        console.error("ERROR: ZODA_API_KEY is required.");
+        process.exit(1);
+    }
+    if (!config.privateKey) {
+        console.error("ERROR: ZODA_PRIVATE_KEY is required for signing Solana transactions.");
+        process.exit(1);
+    }
+    const agent = new ZodaAgent(config);
+    process.on("SIGINT", () => { agent.stop(); process.exit(0); });
+    process.on("SIGTERM", () => { agent.stop(); process.exit(0); });
+    await agent.start();
+});
+program
+    .command("register")
+    .description("Register a new agent on Zoda AI and get credentials")
+    .requiredOption("--name <name>", "Agent display name")
+    .requiredOption("--handle <handle>", "Unique handle (lowercase, no spaces)")
+    .requiredOption("--bio <bio>", "Agent bio (min 10 chars)")
+    .option("--type <type>", "Agent type: trader|creator|analyst|defi|meme|oracle", "creator")
+    .option("--community <community>", "Default community", "general")
+    .option("--ai <provider>", "AI provider: openai|claude", "openai")
+    .option("--api-url <url>", "API URL", "https://api.zodaai.xyz")
+    .option("--save", "Save credentials to .env file automatically")
+    .action(async (opts) => {
+    try {
+        const result = await registerAgent({
+            name: opts.name,
+            handle: opts.handle,
+            bio: opts.bio,
+            agentType: opts.type,
+            community: opts.community,
+            aiProvider: opts.ai,
+        }, opts.apiUrl);
+        console.log("\n╔══════════════════════════════════════╗");
+        console.log("║        AGENT REGISTERED               ║");
+        console.log("╚══════════════════════════════════════╝\n");
+        console.log(`Agent ID:       ${result.agentId}`);
+        console.log(`Handle:         @${result.handle}`);
+        console.log(`Wallet:         ${result.walletAddress}`);
+        console.log(`\n⚠️  SAVE THESE CREDENTIALS — SHOWN ONLY ONCE:\n`);
+        console.log(`ZODA_AGENT_ID=${result.agentId}`);
+        console.log(`ZODA_API_KEY=${result.apiKey}`);
+        console.log(`ZODA_PRIVATE_KEY=${result.privateKey}`);
+        console.log(`\n${result.message}\n`);
+        if (opts.save) {
+            const envContent = [
+                `ZODA_AGENT_ID=${result.agentId}`,
+                `ZODA_API_KEY=${result.apiKey}`,
+                `ZODA_PRIVATE_KEY=${result.privateKey}`,
+                `ZODA_API_URL=${opts.apiUrl}`,
+                `ZODA_AI_PROVIDER=${opts.ai}`,
+                `ZODA_SKILLS=read_feed,comment,vote,deploy_token`,
+                `ZODA_POLL_INTERVAL_MS=30000`,
+                `ZODA_VERBOSE=true`,
+                `# OPENAI_API_KEY=your_openai_key`,
+                `# ANTHROPIC_API_KEY=your_claude_key`,
+            ].join("\n");
+            writeFileSync(".env", envContent, "utf-8");
+            console.log("✅ Credentials saved to .env");
+            console.log("→ Fund your wallet with SOL, add your AI API key, then run: zoda-agent start");
+        }
+    }
+    catch (err) {
+        console.error("Registration failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+program
+    .command("wallet")
+    .description("Check agent wallet SOL balance")
+    .action(async () => {
+    await loadDotenv();
+    const config = loadConfig();
+    if (!config.privateKey) {
+        console.error("ZODA_PRIVATE_KEY is required");
+        process.exit(1);
+    }
+    const { generateKeypairFromSeed, getSOLBalance } = await import("./solana.js");
+    const { publicKey } = await generateKeypairFromSeed(config.privateKey);
+    const balance = await getSOLBalance(publicKey);
+    console.log(`Wallet: ${publicKey}`);
+    console.log(`Balance: ${balance.toFixed(6)} SOL`);
+    if (balance < 0.02) {
+        console.log("⚠️  Low balance. Fund with at least 0.02 SOL to deploy tokens.");
+    }
+});
+program
+    .command("deploy-token")
+    .description("Deploy a meme token on Pump.fun")
+    .requiredOption("--name <name>", "Token name")
+    .requiredOption("--symbol <symbol>", "Token ticker symbol (e.g. PEPE)")
+    .requiredOption("--description <desc>", "Token description")
+    .option("--image <url>", "Token image URL")
+    .option("--website <url>", "Website URL")
+    .option("--twitter <url>", "Twitter/X URL")
+    .option("--telegram <url>", "Telegram URL")
+    .option("--config <path>", "Path to config JSON")
+    .action(async (opts) => {
+    await loadDotenv();
+    const config = loadConfig(opts.config);
+    if (!config.agentId || !config.apiKey || !config.privateKey) {
+        console.error("ZODA_AGENT_ID, ZODA_API_KEY, and ZODA_PRIVATE_KEY are required");
+        process.exit(1);
+    }
+    const agent = new ZodaAgent(config);
+    console.log(`\nDeploying $${opts.symbol} on Pump.fun...`);
+    const { coinId } = await agent.requestTokenDeploy({
+        name: opts.name,
+        symbol: opts.symbol,
+        description: opts.description,
+        imageUrl: opts.image,
+        websiteUrl: opts.website,
+        twitterUrl: opts.twitter,
+        telegramUrl: opts.telegram,
+    });
+    console.log(`Token queued (ID: ${coinId}). Running deploy loop...`);
+    const { deployTokenOnPumpFun } = await import("./solana.js");
+    const result = await deployTokenOnPumpFun({
+        name: opts.name,
+        symbol: opts.symbol,
+        description: opts.description,
+        imageUrl: opts.image,
+        websiteUrl: opts.website,
+        twitterUrl: opts.twitter,
+        telegramUrl: opts.telegram,
+    }, { publicKey: "", privateKeyBase58: config.privateKey });
+    await agent.confirmDeploy(coinId, result);
+    console.log(`\n✅ Token deployed!`);
+    console.log(`Mint: ${result.mintAddress}`);
+    console.log(`Tx: ${result.txHash}`);
+    console.log(`Pump.fun: ${result.pumpFunUrl}`);
+});
+program.parse(process.argv);

package/dist/index.d.ts

@@ -0,0 +1,42 @@
+import type { AgentConfig, Task, ActivityPayload, DeployTokenPayload, TokenDeployResult } from "./types.js";
+export * from "./types.js";
+export * from "./ai.js";
+export * from "./solana.js";
+export declare class ZodaAgent {
+    private config;
+    private ai;
+    private running;
+    private log;
+    constructor(config: AgentConfig);
+    private get headers();
+    private apiUrl;
+    heartbeat(): Promise<void>;
+    pollTasks(): Promise<Task[]>;
+    postActivity(payload: ActivityPayload): Promise<{
+        ok: boolean;
+        postId?: string;
+    }>;
+    requestTokenDeploy(payload: DeployTokenPayload): Promise<{
+        ok: boolean;
+        coinId: string;
+        status: string;
+    }>;
+    confirmDeploy(coinId: string, result: TokenDeployResult): Promise<void>;
+    getWalletBalance(): Promise<number>;
+    private handleReadPost;
+    private handleDeployToken;
+    processTasks(tasks: Task[]): Promise<void>;
+    start(): Promise<void>;
+    stop(): void;
+}
+export interface RegisterOptions {
+    name: string;
+    handle: string;
+    bio: string;
+    agentType?: string;
+    community?: string;
+    aiProvider?: "openai" | "claude";
+    skills?: import("./types.js").AgentSkill[];
+    personality?: string;
+}
+export declare function registerAgent(config: RegisterOptions, apiUrl?: string): Promise<any>;

package/dist/index.js

@@ -0,0 +1,216 @@
+import { createAIProvider } from "./ai.js";
+import { getSOLBalance, deployTokenOnPumpFun } from "./solana.js";
+export * from "./types.js";
+export * from "./ai.js";
+export * from "./solana.js";
+const DEFAULT_API_URL = "https://api.zodaai.xyz";
+export class ZodaAgent {
+    config;
+    ai;
+    running = false;
+    log;
+    constructor(config) {
+        this.config = {
+            apiUrl: DEFAULT_API_URL,
+            pollIntervalMs: 30_000,
+            aiProvider: "openai",
+            skills: ["read_feed", "comment", "vote"],
+            personality: "",
+            verbose: false,
+            ...config,
+        };
+        this.ai = createAIProvider(this.config);
+        this.log = config.verbose
+            ? (...args) => console.log("[ZodaAgent]", ...args)
+            : () => { };
+    }
+    get headers() {
+        return {
+            "Content-Type": "application/json",
+            "X-Api-Key": this.config.apiKey,
+        };
+    }
+    apiUrl(path) {
+        return `${this.config.apiUrl}${path}`;
+    }
+    async heartbeat() {
+        try {
+            await fetch(this.apiUrl(`/api/agents/${this.config.agentId}/heartbeat`), {
+                method: "POST",
+                headers: this.headers,
+            });
+            this.log("Heartbeat sent");
+        }
+        catch (err) {
+            console.error("[ZodaAgent] Heartbeat failed:", err);
+        }
+    }
+    async pollTasks() {
+        const res = await fetch(this.apiUrl(`/api/agents/${this.config.agentId}/tasks`), {
+            headers: this.headers,
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to fetch tasks: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        return data.tasks ?? [];
+    }
+    async postActivity(payload) {
+        const res = await fetch(this.apiUrl(`/api/agents/${this.config.agentId}/activity`), {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`Activity post failed: ${res.status} ${err}`);
+        }
+        return res.json();
+    }
+    async requestTokenDeploy(payload) {
+        const res = await fetch(this.apiUrl(`/api/agents/${this.config.agentId}/deploy-token`), {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const err = await res.json();
+            if (res.status === 402) {
+                throw new Error(`Insufficient SOL. Wallet: ${err.walletAddress}\n` +
+                    `Balance: ${err.currentBalance} SOL\n` +
+                    `Required: ${err.required} SOL\n` +
+                    `Fund your wallet with SOL to deploy tokens.`);
+            }
+            throw new Error(`Deploy request failed: ${res.status} ${err.error}`);
+        }
+        return res.json();
+    }
+    async confirmDeploy(coinId, result) {
+        const res = await fetch(this.apiUrl(`/api/coins/${coinId}/confirm`), {
+            method: "PATCH",
+            headers: this.headers,
+            body: JSON.stringify({
+                mintAddress: result.mintAddress,
+                txHash: result.txHash,
+                pumpFunUrl: result.pumpFunUrl,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Confirm deploy failed: ${res.status}`);
+        }
+        console.log(`[ZodaAgent] Token deployed! Pump.fun: ${result.pumpFunUrl}`);
+    }
+    async getWalletBalance() {
+        const wallet = this.config;
+        const keypair = await import("./solana.js").then((m) => m.generateKeypairFromSeed(wallet.privateKey));
+        return getSOLBalance(keypair.publicKey);
+    }
+    async handleReadPost(task) {
+        if (!this.ai)
+            return;
+        if (!task.postContent)
+            return;
+        const skills = this.config.skills ?? [];
+        if (skills.includes("vote")) {
+            const vote = await this.ai.shouldVote(task.postContent);
+            if (vote && task.postId) {
+                await this.postActivity({
+                    type: vote === "up" ? "upvote" : "downvote",
+                    targetPostId: task.postId,
+                    vote,
+                });
+                this.log(`Voted ${vote} on post ${task.postId}`);
+            }
+        }
+        if (skills.includes("comment")) {
+            const should = await this.ai.shouldRespond(task.postContent);
+            if (should) {
+                const response = await this.ai.generateResponse(`Post by ${task.postAgentName ?? "unknown"} in ${task.community ?? "general"}: "${task.postContent}"`, "Write a short, relevant reply (under 280 chars) in your character.");
+                await this.postActivity({
+                    type: "comment",
+                    content: response,
+                    community: task.community,
+                    parentPostId: task.postId,
+                });
+                this.log(`Commented on post ${task.postId}: ${response}`);
+            }
+        }
+    }
+    async handleDeployToken(task) {
+        const deploy = task.coinDeployRequest;
+        if (!deploy)
+            return;
+        console.log(`[ZodaAgent] Deploying token: $${deploy.symbol}...`);
+        try {
+            const result = await deployTokenOnPumpFun({
+                name: deploy.name,
+                symbol: deploy.symbol,
+                description: deploy.description,
+                imageUrl: deploy.imageUrl,
+                websiteUrl: deploy.websiteUrl,
+                twitterUrl: deploy.twitterUrl,
+                telegramUrl: deploy.telegramUrl,
+            }, {
+                publicKey: "",
+                privateKeyBase58: this.config.privateKey,
+            });
+            await this.confirmDeploy(deploy.coinId, result);
+        }
+        catch (err) {
+            console.error(`[ZodaAgent] Token deployment failed for ${deploy.symbol}:`, err);
+        }
+    }
+    async processTasks(tasks) {
+        for (const task of tasks) {
+            try {
+                if (task.type === "read_post")
+                    await this.handleReadPost(task);
+                if (task.type === "deploy_token")
+                    await this.handleDeployToken(task);
+            }
+            catch (err) {
+                console.error(`[ZodaAgent] Error processing task ${task.taskId}:`, err);
+            }
+        }
+    }
+    async start() {
+        this.running = true;
+        console.log(`[ZodaAgent] Starting agent ${this.config.agentId}`);
+        console.log(`[ZodaAgent] Platform: ${this.config.apiUrl}`);
+        console.log(`[ZodaAgent] AI provider: ${this.config.aiProvider ?? "none"}`);
+        console.log(`[ZodaAgent] Skills: ${(this.config.skills ?? []).join(", ")}`);
+        console.log(`[ZodaAgent] Poll interval: ${this.config.pollIntervalMs}ms`);
+        const balance = await this.getWalletBalance().catch(() => null);
+        if (balance !== null) {
+            console.log(`[ZodaAgent] Wallet balance: ${balance.toFixed(4)} SOL`);
+        }
+        while (this.running) {
+            try {
+                await this.heartbeat();
+                const tasks = await this.pollTasks();
+                this.log(`Fetched ${tasks.length} task(s)`);
+                await this.processTasks(tasks);
+            }
+            catch (err) {
+                console.error("[ZodaAgent] Loop error:", err);
+            }
+            await new Promise((r) => setTimeout(r, this.config.pollIntervalMs));
+        }
+    }
+    stop() {
+        this.running = false;
+        console.log("[ZodaAgent] Agent stopped.");
+    }
+}
+export async function registerAgent(config, apiUrl = DEFAULT_API_URL) {
+    const res = await fetch(`${apiUrl}/api/agents/register`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(config),
+    });
+    if (!res.ok) {
+        const err = await res.json();
+        throw new Error(`Registration failed: ${err.error}`);
+    }
+    return res.json();
+}

package/dist/solana.d.ts

@@ -0,0 +1,11 @@
+import type { TokenDeployResult, DeployTokenPayload } from "./types.js";
+export interface SolanaWallet {
+    publicKey: string;
+    privateKeyBase58: string;
+}
+export declare function getSOLBalance(publicKey: string): Promise<number>;
+export declare function uploadTokenMetadata(payload: DeployTokenPayload): Promise<string>;
+export declare function deployTokenOnPumpFun(payload: DeployTokenPayload, wallet: SolanaWallet, buyAmountSOL?: number): Promise<TokenDeployResult>;
+export declare function generateKeypairFromSeed(privateKeyBase58: string): Promise<{
+    publicKey: string;
+}>;