create-message-kit 1.1.9 → 1.1.10-beta.2

package/templates/gated/src/index.ts

@@ -0,0 +1,64 @@
+import { run, xmtpClient, XMTPContext } from "@xmtp/message-kit";
+import { Client } from "@xmtp/node-sdk";
+import { startServer } from "./lib/gated.js";
+import { verifiedRequest } from "./lib/nft.js";
+const { client } = await xmtpClient({ hideInitLogMessage: true });
+startServer(client, verifiedRequest);
+
+run(async (context: XMTPContext) => {
+  const {
+    message: {
+      sender,
+      content: { skill },
+    },
+    client,
+    group,
+  } = context;
+
+  if (skill == "id") {
+    console.log(group?.id);
+  } else if (skill === "create") {
+    await context.send("Creating group...");
+    const group = await createGroup(
+      client,
+      sender.address,
+      client.accountAddress,
+    );
+
+    await context.send(
+      `Group created!\n- ID: ${group.id}\n- Group Frame URL: https://converse.xyz/group/${group.id}: \n- This url will deelink to the group inside Converse\n- Once in the other group you can share the invite with your friends.`,
+    );
+    return;
+  } else {
+    await context.send(
+      "👋 Welcome to the Gated Bot Group!\nTo get started, type /create to set up a new group. 🚀\nThis example will check if the user has a particular nft and add them to the group if they do.\nOnce your group is created, you'll receive a unique Group ID and URL.\nShare the URL with friends to invite them to join your group!",
+    );
+  }
+});
+
+async function createGroup(
+  client: Client,
+  senderAddress: string,
+  clientAddress: string,
+) {
+  let senderInboxId = "";
+  const group = await client?.conversations.newConversation([
+    senderAddress,
+    clientAddress,
+  ]);
+  const members = await group.members();
+  const senderMember = members.find((member) =>
+    member.accountAddresses.includes(senderAddress.toLowerCase()),
+  );
+  if (senderMember) {
+    const 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;
+}

package/templates/gated/src/lib/gated.ts

@@ -0,0 +1,51 @@
+// Import necessary modules
+import express from "express";
+import { Client } from "@xmtp/node-sdk";
+
+export function startServer(
+  client: Client,
+  verifiedRequest: (walletAddress: string, groupId: string) => Promise<boolean>,
+) {
+  async function addWalletToGroup(
+    walletAddress: string,
+    groupId: string,
+  ): Promise<string> {
+    const conversation =
+      await client.conversations.getConversationById(groupId);
+    const verified = await verifiedRequest(walletAddress, groupId);
+    if (!verified) {
+      console.log("User cant be added to the group");
+      return "not verified";
+    } else {
+      try {
+        await conversation?.addMembers([walletAddress]);
+        console.log(`Added wallet address: ${walletAddress} to the group`);
+        return "success";
+      } catch (error: any) {
+        console.log(error.message);
+        return "error";
+      }
+    }
+  }
+
+  // Endpoint to add wallet address to a group from an external source
+  const app = express();
+  app.use(express.json());
+  app.post("/add-wallet", async (req, res) => {
+    try {
+      const { walletAddress, groupId } = req.body;
+      const result = await addWalletToGroup(walletAddress, groupId);
+      res.status(200).send(result);
+    } catch (error: any) {
+      res.status(400).send(error.message);
+    }
+  });
+  // Start the server
+  const PORT = process.env.PORT || 3000;
+  const url = process.env.URL || `http://localhost:${PORT}`;
+  app.listen(PORT, () => {
+    console.warn(
+      `Use this endpoint to add a wallet to a group indicated by the groupId\n${url}/add-wallet <body: {walletAddress, groupId}>`,
+    );
+  });
+}

package/templates/gated/src/lib/nft.ts

@@ -0,0 +1,37 @@
+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 verifiedRequest(
+  walletAddress: string,
+  groupId: string
+): Promise<boolean> {
+  console.log("new-request", {
+    groupId,
+    walletAddress,
+  });
+
+  const alchemy = new Alchemy(settings);
+  try {
+    const nfts = await alchemy.nft.getNftsForOwner(walletAddress);
+    const collectionSlug = "XMTPeople"; // The slug for the collection
+
+    const ownsNft = nfts.ownedNfts.some(
+      (nft: any) =>
+        nft.contract.name.toLowerCase() === collectionSlug.toLowerCase()
+    );
+    console.log(
+      `NFTs owned on ${Network.BASE_MAINNET}:`,
+      nfts.ownedNfts.length
+    );
+    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/gated/src/skills.ts

@@ -0,0 +1,24 @@
+import type { SkillGroup } from "@xmtp/message-kit";
+
+export const skills: SkillGroup[] = [
+  {
+    name: "Group Id",
+    description: "Create and get group id.",
+    skills: [
+      {
+        skill: "/create",
+        examples: ["/create"],
+        adminOnly: true,
+        params: {},
+        description: "Create a new group.",
+      },
+      {
+        skill: "/id",
+        examples: ["/id"],
+        adminOnly: true,
+        params: {},
+        description: "Get group id.",
+      },
+    ],
+  },
+];

package/templates/gpt/.yarnrc.yml

@@ -0,0 +1,4 @@
+compressionLevel: mixed
+enableGlobalCache: false
+enableTelemetry: false
+nodeLinker: node-modules

package/templates/gpt/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "gpt",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w & sleep 1 && node --watch dist/index.js",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@xmtp/message-kit": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/templates/gpt/src/index.ts

@@ -1,38 +1,17 @@
 import {
   run,
-  HandlerContext,
-  textGeneration,
-  processMultilineResponse,
+  agentReply,
+  replaceVariables,
+  XMTPContext,
 } from "@xmtp/message-kit";
-import { agent_prompt } from "./prompt.js";
 
-if (!process.env.OPEN_AI_API_KEY) {
-  console.error("OPEN_AI_API_KEY is not set");
-}
-
-run(async (context: HandlerContext) => {
-  if (!process.env.OPEN_AI_API_KEY) {
-    context.send("gm");
-    return;
-  }
+import { systemPrompt } from "./prompt.js";
 
+run(async (context: XMTPContext) => {
   const {
-    message: {
-      content: { text, params },
-      sender,
-    },
+    message: { sender },
   } = context;
 
-  try {
-    let userPrompt = params?.prompt ?? text;
-    const { reply } = await textGeneration(
-      sender.address,
-      userPrompt,
-      await agent_prompt(sender.address),
-    );
-    await processMultilineResponse(sender.address, reply, context);
-  } catch (error) {
-    console.error("Error during OpenAI call:", error);
-    await context.send("An error occurred while processing your request.");
-  }
+  let prompt = await replaceVariables(systemPrompt, sender.address, [], "@bot");
+  await agentReply(context, prompt);
 });

package/templates/gpt/src/prompt.ts

@@ -1,20 +1,10 @@
-import { defaultPromptTemplate } from "@xmtp/message-kit";
+export const systemPrompt = `
+You are a helpful and playful agent called {agent_name} that lives inside a web3 messaging app called Converse.
 
-export async function agent_prompt(senderAddress: string) {
-  let fineTunedPrompt = `
- 
-  ### Context
-  
-  You are a helpful agent that lives inside a web3 messaging group that helps interpret user requests and execute commands.
-  The message was sent by @${senderAddress}
-  
+{rules}
 
-  Important:
-  - If a user asks jokes, make jokes about web3 devs\n
-  - If the user asks about performing an action and you can think of a command that would help, answer directly with the command and nothing else. 
-  - Populate the command with the correct or random values. Always return commands with real values only, using usernames with @ and excluding addresses.\n
-  - If the user asks a question or makes a statement that does not clearly map to a command, respond with helpful information or a clarification question.\n
-  - If the user is grateful, respond asking for a tip in a playful manner.
-  `;
-  return defaultPromptTemplate(fineTunedPrompt, senderAddress, [], "@bot");
-}
+{skills}
+
+{user_context}
+
+`;

package/templates/group/.yarnrc.yml

@@ -0,0 +1,4 @@
+compressionLevel: mixed
+enableGlobalCache: false
+enableTelemetry: false
+nodeLinker: node-modules

package/templates/group/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "group",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w & sleep 1 && node --watch dist/index.js",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@xmtp/message-kit": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/templates/group/src/{handler → handlers}/game.ts

@@ -1,7 +1,23 @@
-import { HandlerContext } from "@xmtp/message-kit";
+import { XMTPContext } from "@xmtp/message-kit";
+import type { skillAction } from "@xmtp/message-kit";
 
-// Handler function to process game-related
-export async function handler(context: HandlerContext) {
+export const registerSkill: skillAction[] = [
+  {
+    skill: "/game [game]",
+    handler: handleGames,
+    description: "Play a game.",
+    examples: ["/game wordle", "/game slot", "/game help"],
+    params: {
+      game: {
+        default: "",
+        type: "string",
+        values: ["wordle", "slot", "help"],
+      },
+    },
+  },
+];
+
+export async function handleGames(context: XMTPContext) {
   const {
     message: {
       content: { skill, params, text },

package/templates/group/src/{handler → handlers}/helpers.ts

@@ -1,12 +1,31 @@
-import { HandlerContext } from "@xmtp/message-kit";
+import { XMTPContext } from "@xmtp/message-kit";
 
-export async function handler(context: HandlerContext) {
+import type { skillAction } from "@xmtp/message-kit";
+
+export const registerSkill: skillAction[] = [
+  {
+    skill: "/help",
+    examples: ["/help"],
+    handler: handleHelp,
+    description: "Get help with the bot.",
+    params: {},
+  },
+  {
+    skill: "/id",
+    examples: ["/id"],
+    handler: handleHelp,
+    description: "Get the group ID.",
+    params: {},
+  },
+];
+
+export async function handleHelp(context: XMTPContext) {
   const {
-    skills,
     message: {
       content: { skill },
     },
     group,
+    skills,
   } = context;
 
   if (skill == "help") {

package/templates/group/src/handlers/payment.ts

@@ -0,0 +1,51 @@
+import { getUserInfo, XMTPContext } from "@xmtp/message-kit";
+import type { skillAction } from "@xmtp/message-kit";
+export const registerSkill: skillAction[] = [
+  {
+    skill: "/pay [amount] [token] [username]",
+    examples: ["/pay 10 usdc vitalik.eth", "/pay 1 @alix"],
+    description:
+      "Send a specified amount of a cryptocurrency to a destination address.",
+    handler: handlePay,
+    params: {
+      amount: {
+        default: 10,
+        type: "number",
+      },
+      token: {
+        default: "usdc",
+        type: "string",
+        values: ["eth", "dai", "usdc", "degen"], // Accepted tokens
+      },
+      username: {
+        default: "",
+        type: "username",
+      },
+    },
+  },
+];
+
+export async function handlePay(context: XMTPContext) {
+  const {
+    message: {
+      content: { params },
+    },
+  } = context;
+  const txpayUrl = "https://txpay.vercel.app";
+
+  const { amount: amountSend, token: tokenSend, username } = params;
+  let senderInfo = await getUserInfo(username);
+  if (!amountSend || !tokenSend || !senderInfo) {
+    context.reply(
+      "Missing required parameters. Please provide amount, token, and username.",
+    );
+    return {
+      code: 400,
+      message:
+        "Missing required parameters. Please provide amount, token, and username.",
+    };
+  }
+
+  let sendUrl = `${txpayUrl}/?&amount=${amountSend}&token=${tokenSend}&receiver=${senderInfo.address}`;
+  await context.send(`${sendUrl}`);
+}

package/templates/group/src/handlers/tipping.ts

@@ -0,0 +1,60 @@
+import { getUserInfo, AbstractedMember, XMTPContext } from "@xmtp/message-kit";
+import type { skillAction } from "@xmtp/message-kit";
+
+export const registerSkill: skillAction[] = [
+  {
+    skill: "/tip [usernames] [amount] [token]",
+    examples: ["/tip @vitalik 10 usdc"],
+    description: "Tip users in a specified token.",
+    handler: handleTipping,
+    params: {
+      username: {
+        default: "",
+        plural: true,
+        type: "username",
+      },
+      amount: {
+        default: 10,
+        type: "number",
+      },
+      token: {
+        default: "usdc",
+        type: "string",
+        values: ["eth", "dai", "usdc", "degen"],
+      },
+    },
+  },
+];
+
+export async function handleTipping(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        skill,
+        params: { amount, username },
+      },
+      sender,
+    },
+  } = context;
+  let receivers: AbstractedMember[] = [];
+
+  receivers = await Promise.all(
+    username.map((username: string) => getUserInfo(username)),
+  );
+
+  if (!sender || receivers.length === 0 || amount === 0) {
+    context.reply("Sender or receiver or amount not found.");
+  }
+  const receiverAddresses = receivers.map((receiver) => receiver.address);
+
+  context.sendTo(
+    `You received ${amount} tokens from ${sender.address}.`,
+    receiverAddresses,
+  );
+
+  // Notify sender of the transaction details
+  context.sendTo(
+    `You sent ${amount * receiverAddresses.length} tokens in total.`,
+    [sender.address],
+  );
+}

package/templates/group/src/index.ts

@@ -1,25 +1,38 @@
-import { run, HandlerContext } from "@xmtp/message-kit";
-import { textGeneration, processMultilineResponse } from "@xmtp/message-kit";
-import { agent_prompt } from "./prompt.js";
+import {
+  run,
+  agentReply,
+  XMTPContext,
+  replaceVariables,
+} from "@xmtp/message-kit";
+import { registerSkill as tippingSkill } from "./handlers/tipping.js";
+import { registerSkill as paymentSkill } from "./handlers/payment.js";
+import { registerSkill as gameSkill } from "./handlers/game.js";
+import { registerSkill as helperSkill } from "./handlers/helpers.js";
+import { systemPrompt } from "./prompt.js";
 
-run(async (context: HandlerContext) => {
-  const {
-    message: {
-      content: { text, params },
-      sender,
-    },
-  } = context;
+export const skills = [
+  {
+    name: "Group bot",
+    tag: "@bot",
+    description: "Group agent for tipping payments, games and more.",
+    skills: [...tippingSkill, ...paymentSkill, ...gameSkill, ...helperSkill],
+  },
+];
 
-  try {
-    let userPrompt = params?.prompt ?? text;
-    const { reply } = await textGeneration(
+run(
+  async (context: XMTPContext) => {
+    const {
+      message: { sender },
+      skills,
+    } = context;
+
+    let prompt = await replaceVariables(
+      systemPrompt,
       sender.address,
-      userPrompt,
-      await agent_prompt(sender.address),
+      skills,
+      "@bot",
     );
-    await processMultilineResponse(sender.address, reply, context);
-  } catch (error) {
-    console.error("Error during OpenAI call:", error);
-    await context.send("An error occurred while processing your request.");
-  }
-});
+    await agentReply(context, prompt);
+  },
+  { skills },
+);

package/templates/group/src/prompt.ts

@@ -1,28 +1,33 @@
-import { skills } from "./skills.js";
-import { defaultPromptTemplate } from "@xmtp/message-kit";
+export const systemPrompt = `
+{persona}
 
-export async function agent_prompt(senderAddress: string) {
-  let fineTunedPrompt = `
-## Example response
+{rules}
 
-1. If user wants to play a game, use the skill 'game' and specify the game type.
-  Hey! Sure let's do that.\n/game wordle
+{user_context}
+
+{skills}
+
+## Response Scenarios
+
+1. If the user wants to play a game suggest direcly a game like wordle:
+  Let's play wordle!
+  /game wordle
   
 2. When user wants to pay a specific token:
-  I'll help you pay 1 USDC to 0x123...\n/pay 1 [token] 0x123456789...
+  I'll help you pay 1 USDC to 0x123...
+  /pay 1 [token] 0x123456789...
   *This will return a url to pay
 
 3. If the user wants to pay a eth domain:
-  I'll help you pay 1 USDC to vitalik.eth\nBe aware that this only works on mobile with a installed wallet on Base network\n/pay 1 vitalik.eth
+  I'll help you pay 1 USDC to vitalik.eth
+  Be aware that this only works on mobile with a installed wallet on Base network
+  /pay 1 vitalik.eth
   *This will return a url to pay
 
 4. If the user wants to pay a username:
-  I'll help you pay 1 USDC to @fabri\nBe aware that this only works on mobile with a installed wallet on Base network\n/pay 1 @fabri
+  I'll help you pay 1 USDC to @fabri
+  Be aware that this only works on mobile with a installed wallet on Base network
+  /pay 1 @fabri
   *This will return a url to pay
 
-5. If the user wants to play a game suggest direcly a game like wordle:
-  Let's play wordle!\n/game wordle
-  `;
-
-  return defaultPromptTemplate(fineTunedPrompt, senderAddress, skills, "@bot");
-}
+`;