create-message-kit 1.2.13 → 1.2.15

package/templates/playground/.env.example

@@ -0,0 +1,6 @@
+OPENAI_API_KEY= # the API key for OpenAI
+TEST_ENCRYPTION_KEY= # a different private key for encryption
+KEY= # the private key of the wallet
+RESEND_API_KEY= # the API key for Resend
+FRAMEDL_API_KEY= # the API key for Framedl
+ALCHEMY_SDK= # the API key for Alchemy

package/templates/playground/.yarnrc.yml

@@ -0,0 +1,9 @@
+compressionLevel: mixed
+
+enableGlobalCache: false
+
+enableTelemetry: false
+
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-4.5.1.cjs

package/templates/playground/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "playground",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w & sleep 1 && NODE_NO_WARNINGS=1 node --watch dist/index.js",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@xmtp/message-kit": "workspace:*",
+    "alchemy-sdk": "^3.0.0",
+    "ethers": "^6.0.0",
+    "express": "^4.19.2",
+    "node-fetch": "^3.3.2",
+    "resend": "^4.0.1"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.20",
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/templates/playground/src/index.ts

@@ -0,0 +1,40 @@
+import {
+  run,
+  agentReply,
+  replaceVariables,
+  XMTPContext,
+  Agent,
+  xmtpClient,
+} from "@xmtp/message-kit";
+import fs from "fs";
+import { systemPrompt } from "./prompt.js";
+import { web } from "./skills/web.js";
+import { cryptoPrice } from "./skills/cryptoPrice.js";
+import { search } from "./skills/search.js";
+export const agent: Agent = {
+  name: "Playground Agent",
+  tag: "@bot",
+  description: "A playground agent with a lot of skills.",
+  skills: [...web, ...cryptoPrice, ...search],
+};
+
+// [!region gated]
+const { client } = await xmtpClient({
+  hideInitLogMessage: true,
+});
+
+run(
+  async (context: XMTPContext) => {
+    const {
+      message: { sender },
+      agent,
+    } = context;
+
+    let prompt = await replaceVariables(systemPrompt, sender.address, agent);
+
+    //This is only used for to update the docs.
+    fs.writeFileSync("example_prompt.md", prompt);
+    await agentReply(context, prompt);
+  },
+  { agent, experimental: true },
+);

package/templates/playground/src/plugins/alchemy.ts

@@ -0,0 +1,27 @@
+import { Alchemy, Network } from "alchemy-sdk";
+
+const settings = {
+  apiKey: process.env.ALCHEMY_API_KEY, // Replace with your Alchemy API key
+  network: Network.BASE_MAINNET, // Use the appropriate network
+};
+
+export async function checkNft(
+  walletAddress: string,
+  collectionSlug: string,
+): Promise<boolean> {
+  const alchemy = new Alchemy(settings);
+  try {
+    const nfts = await alchemy.nft.getNftsForOwner(walletAddress);
+
+    const ownsNft = nfts.ownedNfts.some(
+      (nft: any) =>
+        nft.contract.name.toLowerCase() === collectionSlug.toLowerCase(),
+    );
+    console.log("is the nft owned: ", ownsNft);
+    return ownsNft as boolean;
+  } catch (error) {
+    console.error("Error fetching NFTs from Alchemy:", error);
+  }
+
+  return false;
+}

package/templates/playground/src/plugins/minilog.ts

@@ -0,0 +1,26 @@
+import fetch from "node-fetch";
+
+export async function sendLog(title: string, description: string) {
+  const response = await fetch("https://api.minilog.dev/v1/logs/testlog", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: "Bearer pthsm38sccpux5acriqish7isz5inet7q73ef7br",
+    },
+    body: JSON.stringify({
+      application: "myapp-1",
+      severity: "DEBUG",
+      data: title,
+      metadata: {
+        title,
+        description,
+      },
+    }),
+  });
+  console.log(response);
+  if (!response.ok) {
+    console.error("Failed to send log:", response.statusText);
+  } else {
+    console.log("Log sent successfully");
+  }
+}

package/templates/playground/src/plugins/usdc.ts

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+import { generatePrivateKey } from "viem/accounts";
+import { ethers } from "ethers";
+
+// Define the Base network RPC URL
+const baseRpcUrl = "https://mainnet.base.org";
+
+// Create a provider
+const provider = new ethers.JsonRpcProvider(baseRpcUrl);
+
+// USDC contract address on Base (replace with actual address)
+const usdcAddress = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"; // Replace with the correct USDC contract address
+
+// ERC-20 ABI (balanceOf and transfer functions)
+const erc20Abi = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function transfer(address to, uint256 amount) returns (bool)",
+];
+
+export class USDCWallet {
+  walletDir: string;
+  senderAddress: string;
+  privateKey: string;
+  agentAddress: string;
+  usdcContract: ethers.Contract;
+  wallet: ethers.Wallet;
+
+  constructor(senderAddress: string) {
+    this.senderAddress = senderAddress;
+    this.walletDir = path.join(process.cwd(), `./.data/usdcwallets`);
+    if (!fs.existsSync(this.walletDir)) {
+      fs.mkdirSync(this.walletDir, { recursive: true });
+      console.warn("USDC wallet created and saved successfully.");
+    }
+
+    const walletFilePath = path.join(this.walletDir, `${senderAddress}.usdc`);
+
+    if (fs.existsSync(walletFilePath)) {
+      const walletData = fs.readFileSync(walletFilePath, "utf8");
+      this.privateKey = walletData.match(/KEY=(.+)/)?.[1]?.trim() ?? "";
+    } else {
+      this.privateKey = generatePrivateKey();
+      let usdcWallet = new ethers.Wallet(this.privateKey, provider);
+      const walletData = `KEY=${this.privateKey}\nADDRESS=${usdcWallet.address}`;
+      fs.writeFileSync(walletFilePath, walletData);
+    }
+
+    // Initialize wallet and USDC contract
+    this.wallet = new ethers.Wallet(this.privateKey, provider);
+    this.agentAddress = this.wallet.address;
+    this.usdcContract = new ethers.Contract(usdcAddress, erc20Abi, this.wallet);
+  }
+
+  async checkBalances(): Promise<{ usdc: number; eth: number }> {
+    try {
+      // Check USDC balance
+      console.log(this.agentAddress);
+      const usdcBalance = await this.usdcContract.balanceOf(this.agentAddress);
+      const formattedUsdcBalance = ethers.formatUnits(usdcBalance, 6); // USDC has 6 decimals
+      console.warn(`USDC Balance: ${formattedUsdcBalance}`);
+
+      // Check ETH balance
+      const ethBalance = await provider.getBalance(this.agentAddress);
+      const formattedEthBalance = ethers.formatUnits(ethBalance, 18);
+      console.warn(`ETH Balance: ${formattedEthBalance}`);
+
+      return {
+        usdc: parseFloat(formattedUsdcBalance),
+        eth: parseFloat(formattedEthBalance),
+      };
+    } catch (error) {
+      console.error("Error fetching balances:", error);
+      return { usdc: 0, eth: 0 };
+    }
+  }
+  async transferUsdc(to: string, amount: number) {
+    if (!ethers.isAddress(to)) {
+      throw new Error("Invalid recipient address");
+    } else if (typeof amount !== "number" || amount <= 0) {
+      throw new Error("Invalid transfer amount");
+    }
+    try {
+      const amountInWei = ethers.parseUnits(amount.toString(), 6); // USDC has 6 decimals
+      const adminAgent = new USDCWallet(to);
+      const tx = await this.usdcContract.transfer(
+        adminAgent.agentAddress,
+        amountInWei,
+      );
+      const receipt = await tx.wait();
+      if (receipt.status !== 1) {
+        throw new Error("Transaction failed or was reverted");
+      }
+    } catch (error) {
+      console.warn(`Transferred ${amount} USDC to ${to}.`);
+      throw error;
+    }
+  }
+}

package/templates/playground/src/plugins/xmtp.ts

@@ -0,0 +1,137 @@
+import { isOnXMTP, V3Client, V2Client } from "@xmtp/message-kit";
+
+export async function createGroup(
+  client: V3Client,
+  senderAddress: string,
+  clientAddress: string,
+) {
+  try {
+    let senderInboxId = "";
+    await client.conversations.sync();
+    const group = await client?.conversations.newGroup([
+      senderAddress,
+      clientAddress,
+    ]);
+    console.log("Group created", group?.id);
+    const members = await group.members();
+    const senderMember = members.find((member) =>
+      member.accountAddresses.includes(senderAddress.toLowerCase()),
+    );
+    if (senderMember) {
+      senderInboxId = senderMember.inboxId;
+      console.log("Sender's inboxId:", senderInboxId);
+    } else {
+      console.log("Sender not found in members list");
+    }
+    await group.addSuperAdmin(senderInboxId);
+    console.log(
+      "Sender is superAdmin",
+      await group.isSuperAdmin(senderInboxId),
+    );
+    await group.send(`Welcome to the new group!`);
+    await group.send(`You are now the admin of this group as well as the bot`);
+    return group;
+  } catch (error) {
+    console.log("Error creating group", error);
+    return null;
+  }
+}
+
+export async function removeFromGroup(
+  groupId: string,
+  client: V3Client,
+  v2client: V2Client,
+  senderAddress: string,
+): Promise<{ code: number; message: string }> {
+  try {
+    let lowerAddress = senderAddress.toLowerCase();
+    const { v2, v3 } = await isOnXMTP(client, v2client, lowerAddress);
+    console.warn("Checking if on XMTP: v2", v2, "v3", v3);
+    if (!v3)
+      return {
+        code: 400,
+        message: "You don't seem to have a v3 identity ",
+      };
+    const conversation =
+      await client.conversations.getConversationById(groupId);
+    console.warn("removing from group", conversation?.id);
+    await conversation?.sync();
+    await conversation?.removeMembers([lowerAddress]);
+    console.warn("Removed member from group");
+    await conversation?.sync();
+    const members = await conversation?.members();
+    console.warn("Number of members", members?.length);
+
+    let wasRemoved = true;
+    if (members) {
+      for (const member of members) {
+        let lowerMemberAddress = member.accountAddresses[0].toLowerCase();
+        if (lowerMemberAddress === lowerAddress) {
+          wasRemoved = false;
+          break;
+        }
+      }
+    }
+    return {
+      code: wasRemoved ? 200 : 400,
+      message: wasRemoved
+        ? "You have been removed from the group"
+        : "Failed to remove from group",
+    };
+  } catch (error) {
+    console.log("Error removing from group", error);
+    return {
+      code: 400,
+      message: "Failed to remove from group",
+    };
+  }
+}
+export async function addToGroup(
+  groupId: string,
+  client: V3Client,
+  address: string,
+  asAdmin: boolean = false,
+): Promise<{ code: number; message: string }> {
+  try {
+    let lowerAddress = address.toLowerCase();
+    const { v2, v3 } = await isOnXMTP(client, null, lowerAddress);
+    if (!v3)
+      return {
+        code: 400,
+        message: "You don't seem to have a v3 identity ",
+      };
+    const group = await client.conversations.getConversationById(groupId);
+    console.warn("Adding to group", group?.id);
+    await group?.sync();
+    await group?.addMembers([lowerAddress]);
+    console.warn("Added member to group");
+    await group?.sync();
+    if (asAdmin) {
+      await group?.addSuperAdmin(lowerAddress);
+    }
+    const members = await group?.members();
+    console.warn("Number of members", members?.length);
+
+    if (members) {
+      for (const member of members) {
+        let lowerMemberAddress = member.accountAddresses[0].toLowerCase();
+        if (lowerMemberAddress === lowerAddress) {
+          console.warn("Member exists", lowerMemberAddress);
+          return {
+            code: 200,
+            message: "You have been added to the group",
+          };
+        }
+      }
+    }
+    return {
+      code: 400,
+      message: "Failed to add to group",
+    };
+  } catch (error) {
+    return {
+      code: 400,
+      message: "Failed to add to group",
+    };
+  }
+}

package/templates/playground/src/prompt.ts

@@ -0,0 +1,11 @@
+export const systemPrompt = `
+Your are a helpful and playful community agent called {agent_name} that lives inside a messaging app called Converse.
+
+{rules}
+
+{user_context}
+
+{skills}
+
+{issues}
+`;

package/templates/playground/src/skills/broadcast.ts

@@ -0,0 +1,39 @@
+import { XMTPContext, Skill } from "@xmtp/message-kit";
+
+export const broadcast: Skill[] = [
+  {
+    skill: "send",
+    adminOnly: true,
+    handler: handler,
+    examples: ["/send Hello everyone, the event is starting now!"],
+    description: "Send updates to all subscribers.",
+    params: {
+      message: {
+        type: "prompt",
+      },
+    },
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { message },
+      },
+    },
+  } = context;
+
+  const fakeSubscribers = ["0x93E2fc3e99dFb1238eB9e0eF2580EFC5809C7204"];
+  await context.send("This is how your message will look like:");
+  await context.send(message);
+  const emailResponse = await context.awaitResponse(
+    "Are you sure you want to send this broadcast?\nType 'yes' to confirm.",
+    ["yes", "no"],
+  );
+  if (emailResponse === "yes") {
+    await context.send("Sending broadcast...");
+    await context.sendTo(message, fakeSubscribers);
+    await context.send("Broadcast sent!");
+  }
+}

package/templates/playground/src/skills/cash.ts

@@ -0,0 +1,122 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+import { USDCWallet } from "../plugins/usdc.js";
+
+export const cash: Skill[] = [
+  {
+    skill: "balance",
+    handler: balanceHandler,
+    examples: ["/balance"],
+    description: "Check your balance.",
+  },
+  {
+    skill: "fund",
+    handler: fundHandler,
+    examples: ["/fund 1", "/fund 10"],
+    params: {
+      amount: {
+        type: "number",
+        default: "",
+      },
+    },
+    description: "Fund your wallet. Returns a url to fund your wallet.",
+  },
+  {
+    skill: "transfer",
+    handler: transferHandler,
+    examples: ["/transfer 0x40f08f0f853d1c42c61815652b7ccd5a50f0be09 1"],
+    params: {
+      address: {
+        type: "address",
+        default: "",
+      },
+      amount: {
+        type: "number",
+        default: "",
+      },
+    },
+    description: "Transfer USDC to another address.",
+  },
+];
+
+async function balanceHandler(context: XMTPContext) {
+  const {
+    message: { sender },
+  } = context;
+  const usdcWallet = new USDCWallet(sender.address);
+  const { usdc } = await usdcWallet.checkBalances();
+  await context.send(
+    `Your balance is ${usdc} USDC. let me know if you want check again or to fund your wallet.`,
+  );
+}
+
+async function fundHandler(context: XMTPContext) {
+  try {
+    const {
+      message: {
+        sender,
+        content: {
+          params: { amount },
+        },
+      },
+    } = context;
+    const usdcWallet = new USDCWallet(sender.address);
+    const { usdc } = await usdcWallet.checkBalances();
+    const MAX_USDC = 10;
+
+    if (usdc >= MAX_USDC) {
+      await context.send(`Your balance is maxed out at ${MAX_USDC} USDC.`);
+      return;
+    }
+
+    const remainingLimit = MAX_USDC - usdc;
+    let fundAmount: number;
+
+    if (!amount) {
+      const options = Array.from(
+        { length: Math.floor(remainingLimit) },
+        (_, i) => (i + 1).toString(),
+      );
+      const response = await context.awaitResponse(
+        `Please specify the amount of USDC to prefund (1 to ${remainingLimit}):`,
+        options,
+      );
+      fundAmount = parseInt(response);
+    } else {
+      fundAmount = parseInt(amount);
+    }
+
+    if (isNaN(fundAmount) || fundAmount <= 0 || fundAmount > remainingLimit) {
+      await context.send(
+        `Invalid amount. Please specify a value between 1 and ${remainingLimit} USDC.`,
+      );
+      return;
+    }
+
+    await context.requestPayment(fundAmount, "USDC", usdcWallet.agentAddress);
+    await context.send(
+      "After funding, let me know so I can check your balance.",
+    );
+  } catch (error) {
+    await context.send(
+      "An error occurred while processing your request. Please try again.",
+    );
+  }
+}
+
+async function transferHandler(context: XMTPContext) {
+  const {
+    message: {
+      sender,
+      content: {
+        params: { address, amount },
+      },
+    },
+  } = context;
+  const usdcWallet = new USDCWallet(sender.address);
+  if (amount > 10) {
+    await context.send("You can only transfer up to 10 USDC at a time.");
+    return;
+  }
+  await usdcWallet.transferUsdc(address, amount);
+}

package/templates/playground/src/skills/cryptoPrice.ts

@@ -0,0 +1,63 @@
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Example skill structure
+export const cryptoPrice: Skill[] = [
+  {
+    skill: "price", 
+    handler: handler,
+    examples: ["/price BTC USD", "/price ETH EUR"],
+    description: "Get the current exchange rate for a cryptocurrency.",
+    params: {
+      crypto: {
+        type: "string",
+      },
+      currency: {
+        type: "string",
+        default: "USD",
+      },
+    },
+  },
+];
+
+async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { crypto, currency },
+      },
+    },
+  } = context;
+
+  try {
+    const response = await fetch(
+      `https://min-api.cryptocompare.com/data/price?fsym=${crypto}&tsyms=${currency}`
+    );
+
+    if (!response.ok) {
+      return {
+        code: response.status,
+        message: `Unable to fetch exchange rate: ${response.statusText}`,
+      };
+    }
+
+    const data = await response.json() as Record<string, number>;
+    
+    if (!data[currency]) {
+      return {
+        code: 400,
+        message: `Could not find exchange rate for ${crypto}/${currency}`,
+      };
+    }
+
+    return {
+      code: 200,
+      message: `1 ${crypto} = ${data[currency]} ${currency}`,
+    };
+  } catch (error: any) {
+    return {
+      code: 500,
+      message: `Error fetching exchange rate: ${error.message}`,
+    };
+  }
+}

package/templates/playground/src/skills/dalle.ts

@@ -0,0 +1,61 @@
+import { XMTPContext } from "@xmtp/message-kit";
+
+import type { Skill } from "@xmtp/message-kit";
+import OpenAI from "openai";
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+export const dalle: Skill[] = [
+  {
+    skill: "image",
+    handler: handler,
+    description: "Generate an image based on a prompt.",
+    examples: ["/image dog with a ball"],
+    params: {
+      prompt: {
+        type: "prompt",
+      },
+    },
+  },
+];
+
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      sender,
+      content: {
+        params: { prompt },
+      },
+    },
+  } = context;
+
+  if (!prompt) {
+    return {
+      code: 400,
+      message: "Missing required parameters. Please provide a prompt.",
+    };
+  }
+
+  try {
+    const response = await openai.images.generate({
+      prompt: prompt,
+      n: 1,
+      size: "1024x1024",
+    });
+
+    const imageUrl = response.data[0].url;
+    console.log(imageUrl);
+    const message = `Here is the image generated for the prompt "${prompt}": ${imageUrl}`;
+    context.send(message);
+  } catch (error) {
+    // @ts-ignore
+    const message = `Failed to generate image. Error: ${error?.message}
+    }`;
+    return {
+      code: 500,
+      message,
+    };
+  }
+}