Merge branch 'main' into feature/getBalanceOther

src/agent/index.ts

@@ -36,6 +36,8 @@ import {
   getOwnedAllDomains,
   resolveAllDomains,
   create_gibwork_task,
+  rock_paper_scissor,
+  create_TipLink,
 } from "../tools";
 import {
   CollectionDeployment,
@@ -345,4 +347,14 @@ export class SolanaAgentKit {
       payer ? new PublicKey(payer) : undefined,
     );
   }
+
+  async rockPaperScissors(
+    amount: number,
+    choice: "rock" | "paper" | "scissors",
+  ) {
+    return rock_paper_scissor(this, amount, choice);
+  }
+  async createTiplink(amount: number, splmintAddress?: PublicKey) {
+    return create_TipLink(this, amount, splmintAddress);
+  }
 }

src/langchain/index.ts

@@ -1272,6 +1272,103 @@ export class SolanaCreateGibworkTask extends Tool {
   }
 }
 
+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 = toJSON(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 function createSolanaTools(solanaKit: SolanaAgentKit) {
   return [
     new SolanaBalanceTool(solanaKit),
@@ -1307,5 +1404,7 @@ export function createSolanaTools(solanaKit: SolanaAgentKit) {
     new SolanaGetMainDomain(solanaKit),
     new SolanaResolveAllDomainsTool(solanaKit),
     new SolanaCreateGibworkTask(solanaKit),
+    new SolanaRockPaperScissorsTool(solanaKit),
+    new SolanaTipLinkTool(solanaKit),
   ];
 }

src/tools/create_tiplinks.ts

@@ -0,0 +1,112 @@
+import { TipLink } from "@tiplink/api";
+import {
+  Transaction,
+  SystemProgram,
+  LAMPORTS_PER_SOL,
+  sendAndConfirmTransaction,
+  PublicKey,
+  ComputeBudgetProgram,
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress,
+  createTransferInstruction,
+  getMint,
+  createAssociatedTokenAccountInstruction,
+} from "@solana/spl-token";
+import { SolanaAgentKit } from "../index";
+
+const MINIMUM_SOL_BALANCE = 0.003 * LAMPORTS_PER_SOL;
+
+export async function create_TipLink(
+  agent: SolanaAgentKit,
+  amount: number,
+  splmintAddress?: PublicKey,
+): Promise<{ url: string; signature: string }> {
+  try {
+    const tiplink = await TipLink.create();
+
+    if (!splmintAddress) {
+      const transaction = new Transaction();
+      transaction.add(
+        SystemProgram.transfer({
+          fromPubkey: agent.wallet_address,
+          toPubkey: tiplink.keypair.publicKey,
+          lamports: amount * LAMPORTS_PER_SOL,
+        }),
+      );
+
+      const signature = await sendAndConfirmTransaction(
+        agent.connection,
+        transaction,
+        [agent.wallet],
+        { commitment: "confirmed" },
+      );
+
+      return {
+        url: tiplink.url.toString(),
+        signature,
+      };
+    } else {
+      const fromAta = await getAssociatedTokenAddress(
+        splmintAddress,
+        agent.wallet_address,
+      );
+      const toAta = await getAssociatedTokenAddress(
+        splmintAddress,
+        tiplink.keypair.publicKey,
+      );
+
+      const mintInfo = await getMint(agent.connection, splmintAddress);
+      const adjustedAmount = amount * Math.pow(10, mintInfo.decimals);
+
+      const transaction = new Transaction();
+
+      transaction.add(
+        ComputeBudgetProgram.setComputeUnitPrice({
+          microLamports: 5000,
+        }),
+      );
+
+      transaction.add(
+        SystemProgram.transfer({
+          fromPubkey: agent.wallet_address,
+          toPubkey: tiplink.keypair.publicKey,
+          lamports: MINIMUM_SOL_BALANCE,
+        }),
+      );
+
+      transaction.add(
+        createAssociatedTokenAccountInstruction(
+          agent.wallet_address,
+          toAta,
+          tiplink.keypair.publicKey,
+          splmintAddress,
+        ),
+      );
+
+      transaction.add(
+        createTransferInstruction(
+          fromAta,
+          toAta,
+          agent.wallet_address,
+          adjustedAmount,
+        ),
+      );
+
+      const signature = await sendAndConfirmTransaction(
+        agent.connection,
+        transaction,
+        [agent.wallet],
+        { commitment: "confirmed" },
+      );
+
+      return {
+        url: tiplink.url.toString(),
+        signature,
+      };
+    }
+  } catch (error: any) {
+    console.error("Error creating TipLink or sending funds:", error.message);
+    throw new Error(`Failed to create TipLink: ${error.message}`);
+  }
+}

src/tools/index.ts

@@ -38,3 +38,6 @@ export * from "./openbook_create_market";
 export * from "./pyth_fetch_price";
 
 export * from "./create_gibwork_task";
+
+export * from "./rock_paper_scissor";
+export * from "./create_tiplinks";

src/tools/rock_paper_scissor.ts

@@ -0,0 +1,132 @@
+import { sendAndConfirmTransaction, Transaction } from "@solana/web3.js";
+import { SolanaAgentKit } from "../agent";
+
+export async function rock_paper_scissor(
+  agent: SolanaAgentKit,
+  amount: number,
+  choice: "rock" | "paper" | "scissors",
+) {
+  try {
+    const res = await fetch(
+      `https://rps.sendarcade.fun/api/actions/bot?amount=${amount}&choice=${choice}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          account: agent.wallet.publicKey.toBase58(),
+        }),
+      },
+    );
+
+    const data = await res.json();
+    if (data.transaction) {
+      const txn = Transaction.from(Buffer.from(data.transaction, "base64"));
+      txn.sign(agent.wallet);
+      txn.recentBlockhash = (
+        await agent.connection.getLatestBlockhash()
+      ).blockhash;
+      const sig = await sendAndConfirmTransaction(
+        agent.connection,
+        txn,
+        [agent.wallet],
+        { commitment: "confirmed" },
+      );
+      const href = data.links?.next?.href;
+      return await outcome(agent, sig, href);
+    } else {
+      return "failed";
+    }
+  } catch (error: any) {
+    console.error(error);
+    throw new Error(`RPS game failed: ${error.message}`);
+  }
+}
+async function outcome(
+  agent: SolanaAgentKit,
+  sig: string,
+  href: string,
+): Promise<string> {
+  try {
+    const res = await fetch(
+      "https://rps.sendarcade.fun" + href, // href = /api/actions/outcome?id=...
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          account: agent.wallet.publicKey.toBase58(),
+          signature: sig,
+        }),
+      },
+    );
+
+    const data: any = await res.json();
+    const title = data.title;
+    if (title.startsWith("You lost")) {
+      return title;
+    }
+    const next_href = data.links?.actions?.[0]?.href;
+    return title + "\n" + (await won(agent, next_href));
+  } catch (error: any) {
+    console.error(error);
+    throw new Error(`RPS outcome failed: ${error.message}`);
+  }
+}
+async function won(agent: SolanaAgentKit, href: string): Promise<string> {
+  try {
+    const res = await fetch(
+      "https://rps.sendarcade.fun" + href, // href = /api/actions/won?id=...
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          account: agent.wallet.publicKey.toBase58(),
+        }),
+      },
+    );
+
+    const data: any = await res.json();
+    if (data.transaction) {
+      const txn = Transaction.from(Buffer.from(data.transaction, "base64"));
+      txn.partialSign(agent.wallet);
+      await agent.connection.sendRawTransaction(txn.serialize(), {
+        preflightCommitment: "confirmed",
+      });
+    } else {
+      return "Failed to claim prize.";
+    }
+    const next_href = data.links?.next?.href;
+    return await postWin(agent, next_href);
+  } catch (error: any) {
+    console.error(error);
+    throw new Error(`RPS outcome failed: ${error.message}`);
+  }
+}
+async function postWin(agent: SolanaAgentKit, href: string): Promise<string> {
+  try {
+    const res = await fetch(
+      "https://rps.sendarcade.fun" + href, // href = /api/actions/postwin?id=...
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          account: agent.wallet.publicKey.toBase58(),
+        }),
+      },
+    );
+
+    const data: any = await res.json();
+    const title = data.title;
+    return "Prize claimed Successfully" + "\n" + title;
+  } catch (error: any) {
+    console.error(error);
+    throw new Error(`RPS outcome failed: ${error.message}`);
+  }
+}