create-message-kit 1.2.13 → 1.2.15

package/templates/faucet/src/plugins/redis.ts

@@ -0,0 +1,15 @@
+import { createClient } from "@redis/client";
+import { RedisClientType } from "@redis/client";
+
+export const getRedisClient = async () => {
+  const client = createClient({
+    url: process.env.REDIS_CONNECTION_STRING,
+  });
+
+  client.on("error", (err) => {
+    console.error("Redis client error:", err);
+  });
+
+  await client.connect();
+  return client as RedisClientType;
+};

package/templates/faucet/src/prompt.ts

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

package/templates/faucet/src/skills/faucet.ts

@@ -0,0 +1,140 @@
+import { XMTPContext, clearMemory, Skill } from "@xmtp/message-kit";
+import { getRedisClient } from "../plugins/redis.js";
+import {
+  FIVE_MINUTES,
+  LearnWeb3Client,
+  Network,
+} from "../plugins/learnweb3.js";
+
+export const faucet: Skill[] = [
+  {
+    skill: "faucet",
+    handler: handleFaucet,
+    examples: [
+      "/faucet 0x1234567890123456789012345678901234567890 sepolia",
+      "/faucet 0x1234567890123456789012345678901234567890 arbitrum_sepolia",
+      "/faucet 0x1234567890123456789012345678901234567890 base_sepolia",
+    ],
+    description: "Get some testnet tokens.",
+    params: {
+      address: {
+        type: "string",
+      },
+      network: {
+        type: "string",
+      },
+    },
+  },
+  {
+    skill: "/networks",
+    handler: handleFaucet,
+    examples: ["/networks"],
+    description: "Get the list of supported networks.",
+  },
+];
+
+export async function handleFaucet(context: XMTPContext) {
+  const { message } = context;
+  const redisClient = await getRedisClient();
+  const {
+    content: { skill, params },
+    sender,
+  } = message;
+
+  // Initialize LearnWeb3Client
+  const learnWeb3Client = new LearnWeb3Client();
+
+  // Fetch supported networks from Redis cache or API
+  let supportedNetworks: Network[];
+  const cachedSupportedNetworksData =
+    await redisClient.get("supported-networks");
+  supportedNetworks = JSON.parse(
+    cachedSupportedNetworksData!,
+  ).supportedNetworks;
+
+  if (skill === "networks") {
+    if (
+      !cachedSupportedNetworksData ||
+      Date.now() >
+        parseInt(JSON.parse(cachedSupportedNetworksData).lastSyncedAt) +
+          FIVE_MINUTES
+    ) {
+      console.log("Cleared cache");
+      const updatedSupportedNetworksData = await learnWeb3Client.getNetworks();
+      await redisClient.set(
+        "supported-networks",
+        JSON.stringify({
+          lastSyncedAt: Date.now(),
+          supportedNetworks: updatedSupportedNetworksData,
+        }),
+      );
+      supportedNetworks = updatedSupportedNetworksData;
+    } else {
+      supportedNetworks = JSON.parse(
+        cachedSupportedNetworksData!,
+      ).supportedNetworks;
+    }
+
+    supportedNetworks = supportedNetworks.filter(
+      (n) =>
+        !n.networkId.toLowerCase().includes("starknet") &&
+        !n.networkId.toLowerCase().includes("fuel") &&
+        !n.networkId.toLowerCase().includes("mode"),
+    );
+
+    const networkList = supportedNetworks.map((n, index) => {
+      return `${index + 1}. ${n.networkId
+        .replace(/_/g, " ")
+        .replace(/\b\w/g, (l) => l.toUpperCase())}`;
+    });
+
+    return {
+      message: `Available networks:\n\n${networkList.join("\n")}`,
+      code: 200,
+    };
+  } else if (skill === "faucet") {
+    const { network } = params;
+    const selectedNetwork = supportedNetworks.find(
+      (n) => n.networkId === network,
+    );
+
+    if (!selectedNetwork) {
+      await context.send("Invalid network. Please select a valid option.");
+      return;
+    }
+
+    await context.send(
+      "Your testnet tokens are being processed. Please wait a moment for the transaction to process.",
+    );
+
+    const result = await learnWeb3Client.dripTokens(
+      selectedNetwork.networkId,
+      sender.address,
+    );
+
+    if (!result.ok) {
+      await context.send(
+        `❌ Sorry, there was an error processing your request:\n\n"${result.error!}"`,
+      );
+      // Clear any in-memory cache or state related to the prompt
+      clearMemory();
+      return;
+    }
+
+    await context.send("Here's your transaction receipt:");
+    await context.send(
+      `${process.env.FRAME_BASE_URL}?txLink=${result.value}&networkLogo=${
+        selectedNetwork?.networkLogo
+      }&networkName=${selectedNetwork?.networkName.replaceAll(
+        " ",
+        "-",
+      )}&tokenName=${selectedNetwork?.tokenName}&amount=${
+        selectedNetwork?.dripAmount
+      }`,
+    );
+    // Clear any in-memory cache or state related to the prompt
+    clearMemory();
+  } else {
+    await context.send("Unknown skill. Please use 'list' or 'drip'.");
+  }
+}

package/templates/gated-group/.cursorrules

@@ -0,0 +1,290 @@
+# MessageKit Skill Template
+
+## Examples
+
+### Check if a Domain is Available
+
+
+import { ensUrl } from "../index.js";
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Define Skill
+export const checkDomain: Skill[] = [
+  {
+    skill: "check",
+    handler: handler,
+    examples: ["/check vitalik.eth", "/check fabri.base.eth"],
+    description: "Check if a domain is available.",
+    params: {
+      domain: {
+        type: "string",
+      },
+    },
+  },
+];
+
+// Handler Implementation
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { domain },
+      },
+    },
+  } = context;
+
+  const data = await context.getUserInfo(domain);
+
+  if (!data?.address) {
+    let message = `Looks like ${domain} is available! Here you can register it: ${ensUrl}${domain} or would you like to see some cool alternatives?`;
+    return {
+      code: 200,
+      message,
+    };
+  } else {
+    let message = `Looks like ${domain} is already registered!`;
+    await context.executeSkill("/cool " + domain);
+    return {
+      code: 404,
+      message,
+    };
+  }
+}
+
+### Generate a payment request
+
+
+import { XMTPContext } from "@xmtp/message-kit";
+import type { Skill } from "@xmtp/message-kit";
+
+// Define Skill
+export const paymentRequest: Skill[] = [
+  {
+    skill: "pay",
+    examples: [
+      "/pay 10 vitalik.eth",
+      "/pay 1 usdc to 0xC60E6Bb79322392761BFe3081E302aEB79B30B03",
+    ],
+    description:
+      "Send a specified amount of a cryptocurrency to a destination address. \nWhen tipping, you can assume it's 1 USDC.",
+    handler: handler,
+    params: {
+      amount: {
+        default: 10,
+        type: "number",
+      },
+      token: {
+        default: "usdc",
+        type: "string",
+        values: ["eth", "dai", "usdc", "degen"], // Accepted tokens
+      },
+      username: {
+        default: "",
+        type: "username",
+      },
+      address: {
+        default: "",
+        type: "address",
+      },
+    },
+  },
+];
+
+// Handler Implementation
+export async function handler(context: XMTPContext) {
+  const {
+    message: {
+      content: {
+        params: { amount, token, username, address },
+      },
+    },
+  } = context;
+  let receiverAddress = address;
+  if (username) {
+    receiverAddress = (await context.getUserInfo(username))?.address;
+  }
+  if (address) {
+    // Prioritize address over username
+    receiverAddress = address;
+  }
+
+  await context.requestPayment(amount, token, receiverAddress);
+}
+
+
+## Types
+
+import { XMTPContext } from "../plugins/xmtp.js";
+import { ClientOptions, GroupMember } from "@xmtp/node-sdk";
+import { ContentTypeId } from "@xmtp/content-type-primitives";
+
+export type MessageAbstracted = {
+  id: string;
+  sent: Date;
+  content: {
+    text?: string | undefined;
+    reply?: string | undefined;
+    previousMsg?: string | undefined;
+    react?: string | undefined;
+    content?: any | undefined;
+    params?: any | undefined;
+    reference?: string | undefined;
+    skill?: string | undefined;
+  };
+  version: "v2" | "v3";
+  sender: AbstractedMember;
+  typeId: string;
+};
+export type GroupAbstracted = {
+  id: string;
+  sync: () => Promise<void>;
+  addMembers: (addresses: string[]) => Promise<void>;
+  addMembersByInboxId: (inboxIds: string[]) => Promise<void>;
+  send: (content: string, contentType?: ContentTypeId) => Promise<string>;
+  isAdmin: (inboxId: string) => boolean;
+  isSuperAdmin: (inboxId: string) => boolean;
+  admins: string[];
+  superAdmins: string[];
+  createdAt: Date;
+  members: GroupMember[];
+};
+export type SkillResponse = {
+  code: number;
+  message: string;
+  data?: any;
+};
+
+export type SkillHandler = (
+  context: XMTPContext,
+) => Promise<SkillResponse | void>;
+
+export type Handler = (context: XMTPContext) => Promise<void>;
+
+export type RunConfig = {
+  // client options from XMTP client
+  client?: ClientOptions;
+  // private key to be used for the client, if not, default from env
+  privateKey?: string;
+  // if true, the init log message with messagekit logo and stuff will be hidden
+  experimental?: boolean;
+  // hide the init log message with messagekit logo and stuff
+  hideInitLogMessage?: boolean;
+  // if true, attachments will be enabled
+  attachments?: boolean;
+  // if true, member changes will be enabled, like adding members to the group
+  memberChange?: boolean;
+  // skills to be used
+  agent?: Agent;
+  // model to be used
+  gptModel?: string;
+};
+export interface SkillParamConfig {
+  default?: string | number | boolean;
+  type:
+    | "number"
+    | "string"
+    | "username"
+    | "quoted"
+    | "address"
+    | "prompt"
+    | "url";
+  plural?: boolean;
+  values?: string[]; // Accepted values for the parameter
+}
+
+export interface Frame {
+  title: string;
+  buttons: { content: string; action: string; target: string }[];
+  image: string;
+}
+export interface Agent {
+  name: string;
+  description: string;
+  tag: string;
+  skills: Skill[];
+}
+export interface Skill {
+  skill: string;
+  handler?: SkillHandler | undefined;
+  adminOnly?: boolean;
+  description: string;
+  examples: string[];
+  params: Record<string, SkillParamConfig>;
+}
+
+export interface AbstractedMember {
+  inboxId: string;
+  address: string;
+  accountAddresses: string[];
+  installationIds?: string[];
+}
+
+export type MetadataValue = string | number | boolean;
+export type Metadata = Record<string, MetadataValue | MetadataValue[]>;
+
+
+## Example final prompt
+
+Your are a helpful and playful ens agent called @bot that lives inside a messaging app called Converse.
+
+
+# Rules
+- You can respond with multiple messages if needed. Each message should be separated by a newline character.
+- You can trigger skills by only sending the command in a newline message.
+- Each command starts with a slash (/).
+- Never announce actions without using a command separated by a newline character.
+- Never use markdown in your responses.
+- Do not make guesses or assumptions
+- Only answer if the verified information is in the prompt.
+- Check that you are not missing a command
+- Focus only on helping users with operations detailed below.
+- Date: Fri, 06 Dec 2024 16:03:22 GMT
+- When mentioning any action related to available skills, you MUST trigger the corresponding command in a new line
+- If you suggest an action that has a command, you must trigger that command
+
+
+## User context
+- Start by fetch their domain from or Converse username
+- Call the user by their name or domain, in case they have one
+- Ask for a name (if they don't have one) so you can suggest domains.
+- Message sent date: 2024-12-06T16:03:36.582Z
+- Users address is: 0x40f08f0f853d1c42c61815652b7ccd5a50f0be09
+- Users name is: ArizonaOregon
+- Converse username is: ArizonaOregon
+
+## Commands
+/check [domain] - Check if a domain is available.
+/cool [domain] - Get cool alternatives for a .eth domain.
+/info [domain] - Get detailed information about an ENS domain including owner, expiry date, and resolver.
+/register [domain] - Register a new ENS domain. Returns a URL to complete the registration process.
+/renew [domain] - Extend the registration period of your ENS domain. Returns a URL to complete the renewal.
+/reset  - Reset the conversation clearing memory and usernames cache.
+/pay [amount] [token] [username] [address] - Send a specified amount of a cryptocurrency to a destination address. 
+When tipping, you can asume its 1 usdc.
+
+## Examples
+/check vitalik.eth
+/check fabri.base.eth
+/cool vitalik.eth
+/info nick.eth
+/register vitalik.eth
+/renew fabri.base.eth
+/reset
+/pay 10 vitalik.eth
+/pay 1 usdc to 0xC60E6Bb79322392761BFe3081E302aEB79B30B03
+
+## Scenarios
+1. Missing commands in responses
+   **Issue**: Sometimes responses are sent without the required command.
+   **Example**:
+   Incorrect:
+   > "Looks like vitalik.eth is registered! What about these cool alternatives?"
+   Correct:
+   > "Looks like vitalik.eth is registered! What about these cool alternatives?
+   > /cool vitalik.eth"
+
+   Incorrect:
+   > Here is a summary of your TODOs. I will now send it via email.
+   Correct:
+   > /todo

package/templates/gated-group/.env.example

@@ -0,0 +1,3 @@
+KEY= # the private key of the wallet
+TEST_ENCRYPTION_KEY= # a different private key for encryption
+OPENAI_API_KEY= # sk-proj-...

package/templates/gated-group/.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/gated-group/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "gated-group",
+  "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",
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.20",
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/templates/gated-group/src/index.ts

@@ -0,0 +1,17 @@
+import { run, XMTPContext, Agent, xmtpClient } from "@xmtp/message-kit";
+import { gated } from "./skills/gated.js";
+import { startGatedGroupServer } from "./skills/gated.js";
+
+const { client } = await xmtpClient({
+  hideInitLogMessage: true,
+});
+
+startGatedGroupServer(client);
+
+export const agent: Agent = {
+  name: "Gated Group Creator Agent",
+  tag: "@bot",
+  description: "A gated group creator agent.",
+  skills: [...gated],
+};
+run(async (context: XMTPContext) => {}, { agent });

package/templates/gated-group/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/gated-group/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/gated-group/src/prompt.ts

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