mirror of
https://github.com/d0zingcat/solana-agent-kit.git
synced 2026-05-18 07:36:46 +00:00
1878 lines
54 KiB
TypeScript
1878 lines
54 KiB
TypeScript
import { PublicKey } from "@solana/web3.js";
|
|
import Decimal from "decimal.js";
|
|
import { Tool } from "langchain/tools";
|
|
import {
|
|
GibworkCreateTaskReponse,
|
|
PythFetchPriceResponse,
|
|
SolanaAgentKit,
|
|
} from "../index";
|
|
import { create_image } from "../tools/create_image";
|
|
import { BN } from "@coral-xyz/anchor";
|
|
import { FEE_TIERS } from "../tools";
|
|
|
|
export class SolanaBalanceTool extends Tool {
|
|
name = "solana_balance";
|
|
description = `Get the balance of a Solana wallet or token account.
|
|
|
|
If you want to get the balance of your wallet, you don't need to provide the tokenAddress.
|
|
If no tokenAddress is provided, the balance will be in SOL.
|
|
|
|
Inputs ( input is a JSON string ):
|
|
tokenAddress: string, eg "So11111111111111111111111111111111111111112" (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const tokenAddress = input ? new PublicKey(input) : undefined;
|
|
const balance = await this.solanaKit.getBalance(tokenAddress);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
balance,
|
|
token: input || "SOL",
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaBalanceOtherTool extends Tool {
|
|
name = "solana_balance_other";
|
|
description = `Get the balance of a Solana wallet or token account which is different from the agent's wallet.
|
|
|
|
If no tokenAddress is provided, the SOL balance of the wallet will be returned.
|
|
|
|
Inputs ( input is a JSON string ):
|
|
walletAddress: string, eg "GDEkQF7UMr7RLv1KQKMtm8E2w3iafxJLtyXu3HVQZnME" (required)
|
|
tokenAddress: string, eg "SENDdRQtYMWaQrBroBrJ2Q53fgVuq95CV9UPGEvpCxa" (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const { walletAddress, tokenAddress } = JSON.parse(input);
|
|
|
|
const tokenPubKey = tokenAddress
|
|
? new PublicKey(tokenAddress)
|
|
: undefined;
|
|
|
|
const balance = await this.solanaKit.getBalanceOther(
|
|
new PublicKey(walletAddress),
|
|
tokenPubKey,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
balance,
|
|
wallet: walletAddress,
|
|
token: tokenAddress || "SOL",
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTransferTool extends Tool {
|
|
name = "solana_transfer";
|
|
description = `Transfer tokens or SOL to another address ( also called as wallet address ).
|
|
|
|
Inputs ( input is a JSON string ):
|
|
to: string, eg "8x2dR8Mpzuz2YqyZyZjUbYWKSWesBo5jMx2Q9Y86udVk" (required)
|
|
amount: number, eg 1 (required)
|
|
mint?: string, eg "So11111111111111111111111111111111111111112" or "SENDdRQtYMWaQrBroBrJ2Q53fgVuq95CV9UPGEvpCxa" (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const recipient = new PublicKey(parsedInput.to);
|
|
const mintAddress = parsedInput.mint
|
|
? new PublicKey(parsedInput.mint)
|
|
: undefined;
|
|
|
|
const tx = await this.solanaKit.transfer(
|
|
recipient,
|
|
parsedInput.amount,
|
|
mintAddress,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Transfer completed successfully",
|
|
amount: parsedInput.amount,
|
|
recipient: parsedInput.to,
|
|
token: parsedInput.mint || "SOL",
|
|
transaction: tx,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaDeployTokenTool extends Tool {
|
|
name = "solana_deploy_token";
|
|
description = `Deploy a new token on Solana blockchain.
|
|
|
|
Inputs (input is a JSON string):
|
|
name: string, eg "My Token" (required)
|
|
uri: string, eg "https://example.com/token.json" (required)
|
|
symbol: string, eg "MTK" (required)
|
|
decimals?: number, eg 9 (optional, defaults to 9)
|
|
initialSupply?: number, eg 1000000 (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const result = await this.solanaKit.deployToken(
|
|
parsedInput.name,
|
|
parsedInput.uri,
|
|
parsedInput.symbol,
|
|
parsedInput.decimals,
|
|
parsedInput.initialSupply,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Token deployed successfully",
|
|
mintAddress: result.mint.toString(),
|
|
decimals: parsedInput.decimals || 9,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaDeployCollectionTool extends Tool {
|
|
name = "solana_deploy_collection";
|
|
description = `Deploy a new NFT collection on Solana blockchain.
|
|
|
|
Inputs (input is a JSON string):
|
|
name: string, eg "My Collection" (required)
|
|
uri: string, eg "https://example.com/collection.json" (required)
|
|
royaltyBasisPoints?: number, eg 500 for 5% (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const result = await this.solanaKit.deployCollection(parsedInput);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Collection deployed successfully",
|
|
collectionAddress: result.collectionAddress.toString(),
|
|
name: parsedInput.name,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaMintNFTTool extends Tool {
|
|
name = "solana_mint_nft";
|
|
description = `Mint a new NFT in a collection on Solana blockchain.
|
|
|
|
Inputs (input is a JSON string):
|
|
collectionMint: string, eg "J1S9H3QjnRtBbbuD4HjPV6RpRhwuk4zKbxsnCHuTgh9w" (required) - The address of the collection to mint into
|
|
name: string, eg "My NFT" (required)
|
|
uri: string, eg "https://example.com/nft.json" (required)
|
|
recipient?: string, eg "9aUn5swQzUTRanaaTwmszxiv89cvFwUCjEBv1vZCoT1u" (optional) - The wallet to receive the NFT, defaults to agent's wallet which is ${this.solanaKit.wallet_address.toString()}`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const result = await this.solanaKit.mintNFT(
|
|
new PublicKey(parsedInput.collectionMint),
|
|
{
|
|
name: parsedInput.name,
|
|
uri: parsedInput.uri,
|
|
},
|
|
parsedInput.recipient
|
|
? new PublicKey(parsedInput.recipient)
|
|
: this.solanaKit.wallet_address,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "NFT minted successfully",
|
|
mintAddress: result.mint.toString(),
|
|
metadata: {
|
|
name: parsedInput.name,
|
|
symbol: parsedInput.symbol,
|
|
uri: parsedInput.uri,
|
|
},
|
|
recipient: parsedInput.recipient || result.mint.toString(),
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTradeTool extends Tool {
|
|
name = "solana_trade";
|
|
description = `This tool can be used to swap tokens to another token ( It uses Jupiter Exchange ).
|
|
|
|
Inputs ( input is a JSON string ):
|
|
outputMint: string, eg "So11111111111111111111111111111111111111112" or "SENDdRQtYMWaQrBroBrJ2Q53fgVuq95CV9UPGEvpCxa" (required)
|
|
inputAmount: number, eg 1 or 0.01 (required)
|
|
inputMint?: string, eg "So11111111111111111111111111111111111111112" (optional)
|
|
slippageBps?: number, eg 100 (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.trade(
|
|
new PublicKey(parsedInput.outputMint),
|
|
parsedInput.inputAmount,
|
|
parsedInput.inputMint
|
|
? new PublicKey(parsedInput.inputMint)
|
|
: new PublicKey("So11111111111111111111111111111111111111112"),
|
|
parsedInput.slippageBps,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Trade executed successfully",
|
|
transaction: tx,
|
|
inputAmount: parsedInput.inputAmount,
|
|
inputToken: parsedInput.inputMint || "SOL",
|
|
outputToken: parsedInput.outputMint,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaLimitOrderTool extends Tool {
|
|
name = "solana_limit_order";
|
|
description = `This tool can be used to place limit orders using Manifest.
|
|
|
|
Inputs ( input is a JSON string ):
|
|
marketId: PublicKey, eg "ENhU8LsaR7vDD2G1CsWcsuSGNrih9Cv5WZEk7q9kPapQ" for SOL/USDC (required)
|
|
quantity: number, eg 1 or 0.01 (required)
|
|
side: string, eg "Buy" or "Sell" (required)
|
|
price: number, in tokens eg 200 for SOL/USDC (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.limitOrder(
|
|
new PublicKey(parsedInput.marketId),
|
|
parsedInput.quantity,
|
|
parsedInput.side,
|
|
parsedInput.price,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Trade executed successfully",
|
|
transaction: tx,
|
|
marketId: parsedInput.marketId,
|
|
quantity: parsedInput.quantity,
|
|
side: parsedInput.side,
|
|
price: parsedInput.price,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaCancelAllOrdersTool extends Tool {
|
|
name = "solana_cancel_all_orders";
|
|
description = `This tool can be used to cancel all orders from a Manifest market.
|
|
|
|
Input ( input is a JSON string ):
|
|
marketId: string, eg "ENhU8LsaR7vDD2G1CsWcsuSGNrih9Cv5WZEk7q9kPapQ" for SOL/USDC (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const marketId = new PublicKey(input.trim());
|
|
const tx = await this.solanaKit.cancelAllOrders(marketId);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Cancel orders successfully",
|
|
transaction: tx,
|
|
marketId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaWithdrawAllTool extends Tool {
|
|
name = "solana_withdraw_all";
|
|
description = `This tool can be used to withdraw all funds from a Manifest market.
|
|
|
|
Input ( input is a JSON string ):
|
|
marketId: string, eg "ENhU8LsaR7vDD2G1CsWcsuSGNrih9Cv5WZEk7q9kPapQ" for SOL/USDC (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const marketId = new PublicKey(input.trim());
|
|
const tx = await this.solanaKit.withdrawAll(marketId);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Withdrew successfully",
|
|
transaction: tx,
|
|
marketId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRequestFundsTool extends Tool {
|
|
name = "solana_request_funds";
|
|
description = "Request SOL from Solana faucet (devnet/testnet only)";
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(_input: string): Promise<string> {
|
|
try {
|
|
await this.solanaKit.requestFaucetFunds();
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Successfully requested faucet funds",
|
|
network: this.solanaKit.connection.rpcEndpoint.split("/")[2],
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRegisterDomainTool extends Tool {
|
|
name = "solana_register_domain";
|
|
description = `Register a .sol domain name for your wallet.
|
|
|
|
Inputs:
|
|
name: string, eg "pumpfun.sol" (required)
|
|
spaceKB: number, eg 1 (optional, default is 1)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
private validateInput(input: any): void {
|
|
if (!input.name || typeof input.name !== "string") {
|
|
throw new Error("name is required and must be a string");
|
|
}
|
|
if (
|
|
input.spaceKB !== undefined &&
|
|
(typeof input.spaceKB !== "number" || input.spaceKB <= 0)
|
|
) {
|
|
throw new Error("spaceKB must be a positive number when provided");
|
|
}
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
this.validateInput(parsedInput);
|
|
|
|
const tx = await this.solanaKit.registerDomain(
|
|
parsedInput.name,
|
|
parsedInput.spaceKB || 1,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Domain registered successfully",
|
|
transaction: tx,
|
|
domain: `${parsedInput.name}.sol`,
|
|
spaceKB: parsedInput.spaceKB || 1,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaResolveDomainTool extends Tool {
|
|
name = "solana_resolve_domain";
|
|
description = `Resolve ONLY .sol domain names to a Solana PublicKey.
|
|
This tool is exclusively for .sol domains.
|
|
DO NOT use this for other domain types like .blink, .bonk, etc.
|
|
|
|
Inputs:
|
|
domain: string, eg "pumpfun.sol" (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const domain = input.trim();
|
|
const publicKey = await this.solanaKit.resolveSolDomain(domain);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Domain resolved successfully",
|
|
publicKey: publicKey.toBase58(),
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetDomainTool extends Tool {
|
|
name = "solana_get_domain";
|
|
description = `Retrieve the .sol domain associated for a given account address.
|
|
|
|
Inputs:
|
|
account: string, eg "4Be9CvxqHW6BYiRAxW9Q3xu1ycTMWaL5z8NX4HR3ha7t" (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const account = new PublicKey(input.trim());
|
|
const domain = await this.solanaKit.getPrimaryDomain(account);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Primary domain retrieved successfully",
|
|
domain,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetWalletAddressTool extends Tool {
|
|
name = "solana_get_wallet_address";
|
|
description = `Get the wallet address of the agent`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(_input: string): Promise<string> {
|
|
return this.solanaKit.wallet_address.toString();
|
|
}
|
|
}
|
|
|
|
export class SolanaPumpfunTokenLaunchTool extends Tool {
|
|
name = "solana_launch_pumpfun_token";
|
|
|
|
description = `This tool can be used to launch a token on Pump.fun,
|
|
do not use this tool for any other purpose, or for creating SPL tokens.
|
|
If the user asks you to chose the parameters, you should generate valid values.
|
|
For generating the image, you can use the solana_create_image tool.
|
|
|
|
Inputs:
|
|
tokenName: string, eg "PumpFun Token",
|
|
tokenTicker: string, eg "PUMP",
|
|
description: string, eg "PumpFun Token is a token on the Solana blockchain",
|
|
imageUrl: string, eg "https://i.imgur.com/UFm07Np_d.png`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
private validateInput(input: any): void {
|
|
if (!input.tokenName || typeof input.tokenName !== "string") {
|
|
throw new Error("tokenName is required and must be a string");
|
|
}
|
|
if (!input.tokenTicker || typeof input.tokenTicker !== "string") {
|
|
throw new Error("tokenTicker is required and must be a string");
|
|
}
|
|
if (!input.description || typeof input.description !== "string") {
|
|
throw new Error("description is required and must be a string");
|
|
}
|
|
if (!input.imageUrl || typeof input.imageUrl !== "string") {
|
|
throw new Error("imageUrl is required and must be a string");
|
|
}
|
|
if (
|
|
input.initialLiquiditySOL !== undefined &&
|
|
typeof input.initialLiquiditySOL !== "number"
|
|
) {
|
|
throw new Error("initialLiquiditySOL must be a number when provided");
|
|
}
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
// Parse and normalize input
|
|
input = input.trim();
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
this.validateInput(parsedInput);
|
|
|
|
// Launch token with validated input
|
|
await this.solanaKit.launchPumpFunToken(
|
|
parsedInput.tokenName,
|
|
parsedInput.tokenTicker,
|
|
parsedInput.description,
|
|
parsedInput.imageUrl,
|
|
{
|
|
twitter: parsedInput.twitter,
|
|
telegram: parsedInput.telegram,
|
|
website: parsedInput.website,
|
|
initialLiquiditySOL: parsedInput.initialLiquiditySOL,
|
|
},
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Token launched successfully on Pump.fun",
|
|
tokenName: parsedInput.tokenName,
|
|
tokenTicker: parsedInput.tokenTicker,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaCreateImageTool extends Tool {
|
|
name = "solana_create_image";
|
|
description =
|
|
"Create an image using OpenAI's DALL-E. Input should be a string prompt for the image.";
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
private validateInput(input: string): void {
|
|
if (typeof input !== "string" || input.trim().length === 0) {
|
|
throw new Error("Input must be a non-empty string prompt");
|
|
}
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
this.validateInput(input);
|
|
const result = await create_image(this.solanaKit, input.trim());
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Image created successfully",
|
|
...result,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaLendAssetTool extends Tool {
|
|
name = "solana_lend_asset";
|
|
description = `Lend idle USDC for yield using Lulo. ( only USDC is supported )
|
|
|
|
Inputs (input is a json string):
|
|
amount: number, eg 1, 0.01 (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const amount = JSON.parse(input).amount || input;
|
|
|
|
const tx = await this.solanaKit.lendAssets(amount);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Asset lent successfully",
|
|
transaction: tx,
|
|
amount,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTPSCalculatorTool extends Tool {
|
|
name = "solana_get_tps";
|
|
description = "Get the current TPS of the Solana network";
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(_input: string): Promise<string> {
|
|
try {
|
|
const tps = await this.solanaKit.getTPS();
|
|
return `Solana (mainnet-beta) current transactions per second: ${tps}`;
|
|
} catch (error: any) {
|
|
return `Error fetching TPS: ${error.message}`;
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaStakeTool extends Tool {
|
|
name = "solana_stake";
|
|
description = `This tool can be used to stake your SOL (Solana), also called as SOL staking or liquid staking.
|
|
|
|
Inputs ( input is a JSON string ):
|
|
amount: number, eg 1 or 0.01 (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input) || Number(input);
|
|
|
|
const tx = await this.solanaKit.stake(parsedInput.amount);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Staked successfully",
|
|
transaction: tx,
|
|
amount: parsedInput.amount,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Tool to fetch the price of a token in USDC
|
|
*/
|
|
export class SolanaFetchPriceTool extends Tool {
|
|
name = "solana_fetch_price";
|
|
description = `Fetch the price of a given token in USDC.
|
|
|
|
Inputs:
|
|
- tokenId: string, the mint address of the token, e.g., "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN"`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const price = await this.solanaKit.fetchTokenPrice(input.trim());
|
|
return JSON.stringify({
|
|
status: "success",
|
|
tokenId: input.trim(),
|
|
priceInUSDC: price,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTokenDataTool extends Tool {
|
|
name = "solana_token_data";
|
|
description = `Get the token data for a given token mint address
|
|
|
|
Inputs: mintAddress is required.
|
|
mintAddress: string, eg "So11111111111111111111111111111111111111112" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = input.trim();
|
|
|
|
const tokenData = await this.solanaKit.getTokenDataByAddress(parsedInput);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
tokenData,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTokenDataByTickerTool extends Tool {
|
|
name = "solana_token_data_by_ticker";
|
|
description = `Get the token data for a given token ticker
|
|
|
|
Inputs: ticker is required.
|
|
ticker: string, eg "USDC" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const ticker = input.trim();
|
|
const tokenData = await this.solanaKit.getTokenDataByTicker(ticker);
|
|
return JSON.stringify({
|
|
status: "success",
|
|
tokenData,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaCompressedAirdropTool extends Tool {
|
|
name = "solana_compressed_airdrop";
|
|
description = `Airdrop SPL tokens with ZK Compression (also called as airdropping tokens)
|
|
|
|
Inputs (input is a JSON string):
|
|
mintAddress: string, the mint address of the token, e.g., "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN" (required)
|
|
amount: number, the amount of tokens to airdrop per recipient, e.g., 42 (required)
|
|
decimals: number, the decimals of the token, e.g., 6 (required)
|
|
recipients: string[], the recipient addresses, e.g., ["1nc1nerator11111111111111111111111111111111"] (required)
|
|
priorityFeeInLamports: number, the priority fee in lamports. Default is 30_000. (optional)
|
|
shouldLog: boolean, whether to log progress to stdout. Default is false. (optional)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const txs = await this.solanaKit.sendCompressedAirdrop(
|
|
parsedInput.mintAddress,
|
|
parsedInput.amount,
|
|
parsedInput.decimals,
|
|
parsedInput.recipients,
|
|
parsedInput.priorityFeeInLamports || 30_000,
|
|
parsedInput.shouldLog || false,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: `Airdropped ${parsedInput.amount} tokens to ${parsedInput.recipients.length} recipients.`,
|
|
transactionHashes: txs,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaClosePosition extends Tool {
|
|
name = "orca_close_position";
|
|
description = `Closes an existing liquidity position in an Orca Whirlpool. This function fetches the position
|
|
details using the provided mint address and closes the position with a 1% slippage.
|
|
|
|
Inputs (JSON string):
|
|
- positionMintAddress: string, the address of the position mint that represents the liquidity position.`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
const positionMintAddress = new PublicKey(
|
|
inputFormat.positionMintAddress,
|
|
);
|
|
|
|
const txId = await this.solanaKit.orcaClosePosition(positionMintAddress);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Liquidity position closed successfully.",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOrcaCreateCLMM extends Tool {
|
|
name = "orca_create_clmm";
|
|
description = `Create a Concentrated Liquidity Market Maker (CLMM) pool on Orca, the most efficient and capital-optimized CLMM on Solana. This function initializes a CLMM pool but does not add liquidity. You can add liquidity later using a centered position or a single-sided position.
|
|
|
|
Inputs (JSON string):
|
|
- mintDeploy: string, the mint of the token you want to deploy (required).
|
|
- mintPair: string, The mint of the token you want to pair the deployed mint with (required).
|
|
- initialPrice: number, initial price of mintA in terms of mintB, e.g., 0.001 (required).
|
|
- feeTier: number, fee tier in bps. Options: 1, 2, 4, 5, 16, 30, 65, 100, 200 (required).`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
const mintA = new PublicKey(inputFormat.mintDeploy);
|
|
const mintB = new PublicKey(inputFormat.mintPair);
|
|
const initialPrice = new Decimal(inputFormat.initialPrice);
|
|
const feeTier = inputFormat.feeTier;
|
|
|
|
if (!feeTier || !(feeTier in FEE_TIERS)) {
|
|
throw new Error(
|
|
`Invalid feeTier. Available options: ${Object.keys(FEE_TIERS).join(
|
|
", ",
|
|
)}`,
|
|
);
|
|
}
|
|
|
|
const txId = await this.solanaKit.orcaCreateCLMM(
|
|
mintA,
|
|
mintB,
|
|
initialPrice,
|
|
feeTier,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message:
|
|
"CLMM pool created successfully. Note: No liquidity was added.",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOrcaCreateSingleSideLiquidityPool extends Tool {
|
|
name = "orca_create_single_sided_liquidity_pool";
|
|
description = `Create a single-sided liquidity pool on Orca, the most efficient and capital-optimized CLMM platform on Solana.
|
|
|
|
This function initializes a single-sided liquidity pool, ideal for community driven project, fair launches, and fundraising. Minimize price impact by setting a narrow price range.
|
|
|
|
Inputs (JSON string):
|
|
- depositTokenAmount: number, in units of the deposit token including decimals, e.g., 1000000000 (required).
|
|
- depositTokenMint: string, mint address of the deposit token, e.g., "DepositTokenMintAddress" (required).
|
|
- otherTokenMint: string, mint address of the other token, e.g., "OtherTokenMintAddress" (required).
|
|
- initialPrice: number, initial price of the deposit token in terms of the other token, e.g., 0.001 (required).
|
|
- maxPrice: number, maximum price at which liquidity is added, e.g., 5.0 (required).
|
|
- feeTier: number, fee tier for the pool in bps. Options: 1, 2, 4, 5, 16, 30, 65, 100, 200 (required).`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
const depositTokenAmount = inputFormat.depositTokenAmount;
|
|
const depositTokenMint = new PublicKey(inputFormat.depositTokenMint);
|
|
const otherTokenMint = new PublicKey(inputFormat.otherTokenMint);
|
|
const initialPrice = new Decimal(inputFormat.initialPrice);
|
|
const maxPrice = new Decimal(inputFormat.maxPrice);
|
|
const feeTier = inputFormat.feeTier;
|
|
|
|
if (!feeTier || !(feeTier in FEE_TIERS)) {
|
|
throw new Error(
|
|
`Invalid feeTier. Available options: ${Object.keys(FEE_TIERS).join(
|
|
", ",
|
|
)}`,
|
|
);
|
|
}
|
|
|
|
const txId = await this.solanaKit.orcaCreateSingleSidedLiquidityPool(
|
|
depositTokenAmount,
|
|
depositTokenMint,
|
|
otherTokenMint,
|
|
initialPrice,
|
|
maxPrice,
|
|
feeTier,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Single-sided Whirlpool created successfully",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOrcaFetchPositions extends Tool {
|
|
name = "orca_fetch_positions";
|
|
description = `Fetch all the liquidity positions in an Orca Whirlpool by owner. Returns an object with positiont mint addresses as keys and position status details as values.`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(): Promise<string> {
|
|
try {
|
|
const txId = await this.solanaKit.orcaFetchPositions();
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Liquidity positions fetched.",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOrcaOpenCenteredPosition extends Tool {
|
|
name = "orca_open_centered_position_with_liquidity";
|
|
description = `Add liquidity to a CLMM by opening a centered position in an Orca Whirlpool, the most efficient liquidity pool on Solana.
|
|
|
|
Inputs (JSON string):
|
|
- whirlpoolAddress: string, address of the Orca Whirlpool (required).
|
|
- priceOffsetBps: number, bps offset (one side) from the current pool price, e.g., 500 for 5% (required).
|
|
- inputTokenMint: string, mint address of the deposit token (required).
|
|
- inputAmount: number, amount of the deposit token, e.g., 100.0 (required).`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
const whirlpoolAddress = new PublicKey(inputFormat.whirlpoolAddress);
|
|
const priceOffsetBps = parseInt(inputFormat.priceOffsetBps, 10);
|
|
const inputTokenMint = new PublicKey(inputFormat.inputTokenMint);
|
|
const inputAmount = new Decimal(inputFormat.inputAmount);
|
|
|
|
if (priceOffsetBps < 0) {
|
|
throw new Error(
|
|
"Invalid distanceFromCurrentPriceBps. It must be equal or greater than 0.",
|
|
);
|
|
}
|
|
|
|
const txId = await this.solanaKit.orcaOpenCenteredPositionWithLiquidity(
|
|
whirlpoolAddress,
|
|
priceOffsetBps,
|
|
inputTokenMint,
|
|
inputAmount,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Centered liquidity position opened successfully.",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOrcaOpenSingleSidedPosition extends Tool {
|
|
name = "orca_open_single_sided_position";
|
|
description = `Add liquidity to a CLMM by opening a single-sided position in an Orca Whirlpool, the most efficient liquidity pool on Solana.
|
|
|
|
Inputs (JSON string):
|
|
- whirlpoolAddress: string, address of the Orca Whirlpool (required).
|
|
- distanceFromCurrentPriceBps: number, distance in basis points from the current price for the position (required).
|
|
- widthBps: number, width of the position in basis points (required).
|
|
- inputTokenMint: string, mint address of the deposit token (required).
|
|
- inputAmount: number, amount of the deposit token, e.g., 100.0 (required).`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
const whirlpoolAddress = new PublicKey(inputFormat.whirlpoolAddress);
|
|
const distanceFromCurrentPriceBps =
|
|
inputFormat.distanceFromCurrentPriceBps;
|
|
const widthBps = inputFormat.widthBps;
|
|
const inputTokenMint = new PublicKey(inputFormat.inputTokenMint);
|
|
const inputAmount = new Decimal(inputFormat.inputAmount);
|
|
|
|
if (distanceFromCurrentPriceBps < 0 || widthBps < 0) {
|
|
throw new Error(
|
|
"Invalid distanceFromCurrentPriceBps or width. It must be equal or greater than 0.",
|
|
);
|
|
}
|
|
|
|
const txId = await this.solanaKit.orcaOpenSingleSidedPosition(
|
|
whirlpoolAddress,
|
|
distanceFromCurrentPriceBps,
|
|
widthBps,
|
|
inputTokenMint,
|
|
inputAmount,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Single-sided liquidity position opened successfully.",
|
|
transaction: txId,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRaydiumCreateAmmV4 extends Tool {
|
|
name = "raydium_create_ammV4";
|
|
description = `Raydium's Legacy AMM that requires an OpenBook marketID
|
|
|
|
Inputs (input is a json string):
|
|
marketId: string (required)
|
|
baseAmount: number(int), eg: 111111 (required)
|
|
quoteAmount: number(int), eg: 111111 (required)
|
|
startTime: number(seconds), eg: now number or zero (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.raydiumCreateAmmV4(
|
|
new PublicKey(inputFormat.marketId),
|
|
new BN(inputFormat.baseAmount),
|
|
new BN(inputFormat.quoteAmount),
|
|
new BN(inputFormat.startTime),
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Raydium amm v4 pool created successfully",
|
|
transaction: tx,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRaydiumCreateClmm extends Tool {
|
|
name = "raydium_create_clmm";
|
|
description = `Concentrated liquidity market maker, custom liquidity ranges, increased capital efficiency
|
|
|
|
Inputs (input is a json string):
|
|
mint1: string (required)
|
|
mint2: string (required)
|
|
configId: string (required) stores pool info, id, index, protocolFeeRate, tradeFeeRate, tickSpacing, fundFeeRate
|
|
initialPrice: number, eg: 123.12 (required)
|
|
startTime: number(seconds), eg: now number or zero (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.raydiumCreateClmm(
|
|
new PublicKey(inputFormat.mint1),
|
|
new PublicKey(inputFormat.mint2),
|
|
|
|
new PublicKey(inputFormat.configId),
|
|
|
|
new Decimal(inputFormat.initialPrice),
|
|
new BN(inputFormat.startTime),
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Raydium clmm pool created successfully",
|
|
transaction: tx,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRaydiumCreateCpmm extends Tool {
|
|
name = "raydium_create_cpmm";
|
|
description = `Raydium's newest CPMM, does not require marketID, supports Token 2022 standard
|
|
|
|
Inputs (input is a json string):
|
|
mint1: string (required)
|
|
mint2: string (required)
|
|
configId: string (required), stores pool info, index, protocolFeeRate, tradeFeeRate, fundFeeRate, createPoolFee
|
|
mintAAmount: number(int), eg: 1111 (required)
|
|
mintBAmount: number(int), eg: 2222 (required)
|
|
startTime: number(seconds), eg: now number or zero (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.raydiumCreateCpmm(
|
|
new PublicKey(inputFormat.mint1),
|
|
new PublicKey(inputFormat.mint2),
|
|
|
|
new PublicKey(inputFormat.configId),
|
|
|
|
new BN(inputFormat.mintAAmount),
|
|
new BN(inputFormat.mintBAmount),
|
|
|
|
new BN(inputFormat.startTime),
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Raydium cpmm pool created successfully",
|
|
transaction: tx,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaOpenbookCreateMarket extends Tool {
|
|
name = "solana_openbook_create_market";
|
|
description = `Openbook marketId, required for ammv4
|
|
|
|
Inputs (input is a json string):
|
|
baseMint: string (required)
|
|
quoteMint: string (required)
|
|
lotSize: number (required)
|
|
tickSize: number (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.openbookCreateMarket(
|
|
new PublicKey(inputFormat.baseMint),
|
|
new PublicKey(inputFormat.quoteMint),
|
|
|
|
inputFormat.lotSize,
|
|
inputFormat.tickSize,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Openbook market created successfully",
|
|
transaction: tx,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaManifestCreateMarket extends Tool {
|
|
name = "solana_manifest_create_market";
|
|
description = `Manifest market
|
|
|
|
Inputs (input is a json string):
|
|
baseMint: string (required)
|
|
quoteMint: string (required)
|
|
`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const inputFormat = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.manifestCreateMarket(
|
|
new PublicKey(inputFormat.baseMint),
|
|
new PublicKey(inputFormat.quoteMint),
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Create manifest market successfully",
|
|
transaction: tx[0],
|
|
marketId: tx[1],
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaPythFetchPrice extends Tool {
|
|
name = "solana_pyth_fetch_price";
|
|
description = `Fetch the price of a given price feed from Pyth's Hermes service
|
|
|
|
Inputs:
|
|
priceFeedID: string, the price feed ID, e.g., "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43" for BTC/USD`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const price = await this.solanaKit.pythFetchPrice(input);
|
|
const response: PythFetchPriceResponse = {
|
|
status: "success",
|
|
priceFeedID: input,
|
|
price,
|
|
};
|
|
return JSON.stringify(response);
|
|
} catch (error: any) {
|
|
const response: PythFetchPriceResponse = {
|
|
status: "error",
|
|
priceFeedID: input,
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
};
|
|
return JSON.stringify(response);
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaResolveAllDomainsTool extends Tool {
|
|
name = "solana_resolve_all_domains";
|
|
description = `Resolve domain names to a public key for ALL domain types EXCEPT .sol domains.
|
|
Use this for domains like .blink, .bonk, etc.
|
|
DO NOT use this for .sol domains (use solana_resolve_domain instead).
|
|
|
|
Input:
|
|
domain: string, eg "mydomain.blink" or "mydomain.bonk" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const owner = await this.solanaKit.resolveAllDomains(input);
|
|
|
|
if (!owner) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: "Domain not found",
|
|
code: "DOMAIN_NOT_FOUND",
|
|
});
|
|
}
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Domain resolved successfully",
|
|
owner: owner?.toString(),
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "DOMAIN_RESOLUTION_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetOwnedDomains extends Tool {
|
|
name = "solana_get_owned_domains";
|
|
description = `Get all domains owned by a specific wallet address.
|
|
|
|
Inputs:
|
|
owner: string, eg "4Be9CvxqHW6BYiRAxW9Q3xu1ycTMWaL5z8NX4HR3ha7t" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const ownerPubkey = new PublicKey(input.trim());
|
|
const domains = await this.solanaKit.getOwnedAllDomains(ownerPubkey);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Owned domains fetched successfully",
|
|
domains,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "FETCH_OWNED_DOMAINS_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetOwnedTldDomains extends Tool {
|
|
name = "solana_get_owned_tld_domains";
|
|
description = `Get all domains owned by the agent's wallet for a specific TLD.
|
|
|
|
Inputs:
|
|
tld: string, eg "bonk" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const domains = await this.solanaKit.getOwnedDomainsForTLD(input);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "TLD domains fetched successfully",
|
|
domains,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "FETCH_TLD_DOMAINS_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetAllTlds extends Tool {
|
|
name = "solana_get_all_tlds";
|
|
description = `Get all active top-level domains (TLDs) in the AllDomains Name Service`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(): Promise<string> {
|
|
try {
|
|
const tlds = await this.solanaKit.getAllDomainsTLDs();
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "TLDs fetched successfully",
|
|
tlds,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "FETCH_TLDS_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaGetMainDomain extends Tool {
|
|
name = "solana_get_main_domain";
|
|
description = `Get the main/favorite domain for a given wallet address.
|
|
|
|
Inputs:
|
|
owner: string, eg "4Be9CvxqHW6BYiRAxW9Q3xu1ycTMWaL5z8NX4HR3ha7t" (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
async _call(input: string): Promise<string> {
|
|
try {
|
|
const ownerPubkey = new PublicKey(input.trim());
|
|
const mainDomain =
|
|
await this.solanaKit.getMainAllDomainsDomain(ownerPubkey);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "Main domain fetched successfully",
|
|
domain: mainDomain,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "FETCH_MAIN_DOMAIN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaCreateGibworkTask extends Tool {
|
|
name = "create_gibwork_task";
|
|
description = `Create a task on Gibwork.
|
|
|
|
Inputs (input is a JSON string):
|
|
title: string, title of the task (required)
|
|
content: string, description of the task (required)
|
|
requirements: string, requirements to complete the task (required)
|
|
tags: string[], list of tags associated with the task (required)
|
|
payer: string, payer address (optional, defaults to agent wallet)
|
|
tokenMintAddress: string, the mint address of the token, e.g., "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN" (required)
|
|
amount: number, payment amount (required)
|
|
`;
|
|
|
|
constructor(private solanaSdk: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const taskData = await this.solanaSdk.createGibworkTask(
|
|
parsedInput.title,
|
|
parsedInput.content,
|
|
parsedInput.requirements,
|
|
parsedInput.tags,
|
|
parsedInput.tokenMintAddress,
|
|
parsedInput.amount,
|
|
parsedInput.payer,
|
|
);
|
|
|
|
const response: GibworkCreateTaskReponse = {
|
|
status: "success",
|
|
taskId: taskData.taskId,
|
|
signature: taskData.signature,
|
|
};
|
|
|
|
return JSON.stringify(response);
|
|
} catch (err: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: err.message,
|
|
code: err.code || "CREATE_TASK_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaRockPaperScissorsTool extends Tool {
|
|
name = "rock_paper_scissors";
|
|
description = `Play rock paper scissors to win SEND coins.
|
|
|
|
Inputs (input is a JSON string):
|
|
choice: string, either "rock", "paper", or "scissors" (required)
|
|
amount: number, amount of SOL to play with - must be 0.1, 0.01, or 0.005 SOL (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
private validateInput(input: any): void {
|
|
if (input.choice !== undefined) {
|
|
throw new Error("choice is required.");
|
|
}
|
|
if (
|
|
input.amount !== undefined &&
|
|
(typeof input.spaceKB !== "number" || input.spaceKB <= 0)
|
|
) {
|
|
throw new Error("amount must be a positive number when provided");
|
|
}
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
this.validateInput(parsedInput);
|
|
const result = await this.solanaKit.rockPaperScissors(
|
|
Number(parsedInput['"amount"']),
|
|
parsedInput['"choice"'].replace(/^"|"$/g, "") as
|
|
| "rock"
|
|
| "paper"
|
|
| "scissors",
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: result,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaTipLinkTool extends Tool {
|
|
name = "solana_tiplink";
|
|
description = `Create a TipLink for transferring SOL or SPL tokens.
|
|
Input is a JSON string with:
|
|
- amount: number (required) - Amount to transfer
|
|
- splmintAddress: string (optional) - SPL token mint address`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
if (!parsedInput.amount) {
|
|
throw new Error("Amount is required");
|
|
}
|
|
|
|
const amount = parseFloat(parsedInput.amount);
|
|
const splmintAddress = parsedInput.splmintAddress
|
|
? new PublicKey(parsedInput.splmintAddress)
|
|
: undefined;
|
|
|
|
const { url, signature } = await this.solanaKit.createTiplink(
|
|
amount,
|
|
splmintAddress,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
url,
|
|
signature,
|
|
amount,
|
|
tokenType: splmintAddress ? "SPL" : "SOL",
|
|
message: `TipLink created successfully`,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaListNFTForSaleTool extends Tool {
|
|
name = "solana_list_nft_for_sale";
|
|
description = `List an NFT for sale on Tensor Trade.
|
|
|
|
Inputs (input is a JSON string):
|
|
nftMint: string, the mint address of the NFT (required)
|
|
price: number, price in SOL (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
// Validate NFT ownership first
|
|
const nftAccount =
|
|
await this.solanaKit.connection.getTokenAccountsByOwner(
|
|
this.solanaKit.wallet_address,
|
|
{ mint: new PublicKey(parsedInput.nftMint) },
|
|
);
|
|
|
|
if (nftAccount.value.length === 0) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message:
|
|
"NFT not found in wallet. Please make sure you own this NFT.",
|
|
code: "NFT_NOT_FOUND",
|
|
});
|
|
}
|
|
|
|
const tx = await this.solanaKit.tensorListNFT(
|
|
new PublicKey(parsedInput.nftMint),
|
|
parsedInput.price,
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "NFT listed for sale successfully",
|
|
transaction: tx,
|
|
price: parsedInput.price,
|
|
nftMint: parsedInput.nftMint,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export class SolanaCancelNFTListingTool extends Tool {
|
|
name = "solana_cancel_nft_listing";
|
|
description = `Cancel an NFT listing on Tensor Trade.
|
|
|
|
Inputs (input is a JSON string):
|
|
nftMint: string, the mint address of the NFT (required)`;
|
|
|
|
constructor(private solanaKit: SolanaAgentKit) {
|
|
super();
|
|
}
|
|
|
|
protected async _call(input: string): Promise<string> {
|
|
try {
|
|
const parsedInput = JSON.parse(input);
|
|
|
|
const tx = await this.solanaKit.tensorCancelListing(
|
|
new PublicKey(parsedInput.nftMint),
|
|
);
|
|
|
|
return JSON.stringify({
|
|
status: "success",
|
|
message: "NFT listing cancelled successfully",
|
|
transaction: tx,
|
|
nftMint: parsedInput.nftMint,
|
|
});
|
|
} catch (error: any) {
|
|
return JSON.stringify({
|
|
status: "error",
|
|
message: error.message,
|
|
code: error.code || "UNKNOWN_ERROR",
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
export function createSolanaTools(solanaKit: SolanaAgentKit) {
|
|
return [
|
|
new SolanaBalanceTool(solanaKit),
|
|
new SolanaBalanceOtherTool(solanaKit),
|
|
new SolanaTransferTool(solanaKit),
|
|
new SolanaDeployTokenTool(solanaKit),
|
|
new SolanaDeployCollectionTool(solanaKit),
|
|
new SolanaMintNFTTool(solanaKit),
|
|
new SolanaTradeTool(solanaKit),
|
|
new SolanaRequestFundsTool(solanaKit),
|
|
new SolanaRegisterDomainTool(solanaKit),
|
|
new SolanaGetWalletAddressTool(solanaKit),
|
|
new SolanaPumpfunTokenLaunchTool(solanaKit),
|
|
new SolanaCreateImageTool(solanaKit),
|
|
new SolanaLendAssetTool(solanaKit),
|
|
new SolanaTPSCalculatorTool(solanaKit),
|
|
new SolanaStakeTool(solanaKit),
|
|
new SolanaFetchPriceTool(solanaKit),
|
|
new SolanaGetDomainTool(solanaKit),
|
|
new SolanaTokenDataTool(solanaKit),
|
|
new SolanaTokenDataByTickerTool(solanaKit),
|
|
new SolanaCompressedAirdropTool(solanaKit),
|
|
new SolanaRaydiumCreateAmmV4(solanaKit),
|
|
new SolanaRaydiumCreateClmm(solanaKit),
|
|
new SolanaRaydiumCreateCpmm(solanaKit),
|
|
new SolanaOpenbookCreateMarket(solanaKit),
|
|
new SolanaManifestCreateMarket(solanaKit),
|
|
new SolanaLimitOrderTool(solanaKit),
|
|
new SolanaCancelAllOrdersTool(solanaKit),
|
|
new SolanaWithdrawAllTool(solanaKit),
|
|
new SolanaClosePosition(solanaKit),
|
|
new SolanaOrcaCreateCLMM(solanaKit),
|
|
new SolanaOrcaCreateSingleSideLiquidityPool(solanaKit),
|
|
new SolanaOrcaFetchPositions(solanaKit),
|
|
new SolanaOrcaOpenCenteredPosition(solanaKit),
|
|
new SolanaOrcaOpenSingleSidedPosition(solanaKit),
|
|
new SolanaPythFetchPrice(solanaKit),
|
|
new SolanaResolveDomainTool(solanaKit),
|
|
new SolanaGetOwnedDomains(solanaKit),
|
|
new SolanaGetOwnedTldDomains(solanaKit),
|
|
new SolanaGetAllTlds(solanaKit),
|
|
new SolanaGetMainDomain(solanaKit),
|
|
new SolanaResolveAllDomainsTool(solanaKit),
|
|
new SolanaCreateGibworkTask(solanaKit),
|
|
new SolanaRockPaperScissorsTool(solanaKit),
|
|
new SolanaTipLinkTool(solanaKit),
|
|
new SolanaListNFTForSaleTool(solanaKit),
|
|
new SolanaCancelNFTListingTool(solanaKit),
|
|
];
|
|
}
|