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

package/templates/ens-agent-pro/src/skills.ts

@@ -1,233 +0,0 @@
-import { DynamicStructuredTool } from "langchain/tools";
-import { getUserInfo } from "@xmtp/message-kit";
-import { clearMemory } from "@xmtp/message-kit";
-import { isAddress } from "viem";
-import { z } from "zod";
-
-const frameUrl = "https://ens.steer.fun/";
-const ensUrl = "https://app.ens.domains/";
-const txpayUrl = "https://txpay.vercel.app";
-const converseUrl = "https://converse.xyz/profile/";
-
-// Add interface for Converse API response
-interface ConverseProfile {
-  address: string;
-  avatar?: string;
-  formattedName?: string;
-  name?: string;
-  onXmtp: boolean;
-}
-
-// Add function to check XMTP status
-async function checkXMTPStatus(address: string): Promise<boolean> {
-  try {
-    const response = await fetch(converseUrl + address, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({ address }),
-    });
-
-    if (!response.ok) {
-      console.error(`Failed to check XMTP status: ${response.status}`);
-      return false;
-    }
-
-    const data = (await response.json()) as ConverseProfile;
-    return data.onXmtp;
-  } catch (error) {
-    console.error("Error checking XMTP status:", error);
-    return false;
-  }
-}
-
-const generateCoolAlternatives = (domain: string) => {
-  const suffixes = ["lfg", "cool", "degen", "moon", "base", "gm"];
-  const alternatives = [];
-  for (let i = 0; i < 5; i++) {
-    const randomPosition = Math.random() < 0.5;
-    const baseDomain = domain.replace(/\.eth$/, ""); // Remove any existing .eth suffix
-    alternatives.push(
-      randomPosition
-        ? `${suffixes[i]}${baseDomain}.eth`
-        : `${baseDomain}${suffixes[i]}.eth`,
-    );
-  }
-
-  return alternatives
-    .map(
-      (alternative: string, index: number) => `${index + 1}. ${alternative} ✨`,
-    )
-    .join("\n");
-};
-
-// Export tools array with all tools
-export const tools = [
-  new DynamicStructuredTool({
-    name: "reset_ens_conversation",
-    description: "Reset the ENS conversation and clear memory",
-    schema: z.object({}),
-    func: async () => {
-      clearMemory();
-      return "Conversation reset successfully.";
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "renew_ens_domain",
-    description:
-      "Generate renewal URL for an ENS domain. Only works if sender owns the domain",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to renew"),
-    }),
-    func: async ({ domain }) => {
-      const data = await getUserInfo(domain);
-      if (!data?.address) {
-        return "Domain not found or not registered.";
-      }
-      return `${frameUrl}frames/manage?name=${domain}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "register_ens_domain",
-    description: "Get URL to register a new ENS domain",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to register"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name";
-      return `${ensUrl}${domain}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_info",
-    description:
-      "Get detailed information about an ENS domain including owner, avatar, description, etc",
-    schema: z.object({
-      domain: z.string().describe("The ENS domain to get information about"),
-    }),
-    func: async ({ domain }) => {
-      const data = await getUserInfo(domain);
-      if (!data?.ensDomain) {
-        return "Domain not found.";
-      }
-
-      const formattedData = {
-        Address: data?.address,
-        "Avatar URL": data?.ensInfo?.avatar,
-        Description: data?.ensInfo?.description,
-        ENS: data?.ensDomain,
-        "Primary ENS": data?.ensInfo?.ens_primary,
-        GitHub: data?.ensInfo?.github,
-        Resolver: data?.ensInfo?.resolverAddress,
-        Twitter: data?.ensInfo?.twitter,
-        URL: `${ensUrl}${domain}`,
-      };
-
-      let message = "Domain information:\n\n";
-      for (const [key, value] of Object.entries(formattedData)) {
-        if (value) {
-          message += `${key}: ${value}\n`;
-        }
-      }
-      message +=
-        "\nWould you like to tip the domain owner for getting there first? 🤣";
-
-      // Check XMTP status if we have an address
-      if (data.address) {
-        const isOnXMTP = await checkXMTPStatus(data.address);
-        if (isOnXMTP) {
-          message += `\n\nAh, this domain is on XMTP! You can message it directly: https://converse.xyz/dm/${domain}`;
-        }
-      }
-
-      return message;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "check_ens_availability",
-    description: "Check if an ENS domain is available for registration",
-    schema: z.object({
-      domain: z
-        .string()
-        .transform((str) => str.replace(/^["'](.+)["']$/, "$1")) // Remove quotes if present
-        .transform((str) => str.toLowerCase())
-        .describe("The ENS domain to check availability for"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name to check.";
-
-      if (domain.includes(".") && !domain.endsWith(".eth")) {
-        return "Invalid ENS domain. Only .eth domains are supported.";
-      }
-
-      if (!domain.includes(".")) {
-        domain = `${domain}.eth`;
-      }
-
-      const data = await getUserInfo(domain);
-      if (!data?.address) {
-        return `Looks like ${domain} is available! Here you can register it: ${ensUrl}${domain} or would you like to see some cool alternatives?`;
-      } else {
-        const alternatives = generateCoolAlternatives(domain);
-        return `Looks like ${domain} is already registered!\n\nHere are some cool alternatives:\n${alternatives}`;
-      }
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_alternatives",
-    description: "Generate cool alternative names for an ENS domain",
-    schema: z.object({
-      domain: z
-        .string()
-        .describe("The ENS domain to generate alternatives for"),
-    }),
-    func: async ({ domain }) => {
-      if (!domain) return "Please provide a domain name.";
-      return `What about these cool alternatives?\n\n${generateCoolAlternatives(domain)}`;
-    },
-  }),
-
-  new DynamicStructuredTool({
-    name: "get_ens_tip_url",
-    description:
-      "Generate a URL to tip an ENS domain owner in USDC. Works with both ENS domains and Ethereum addresses.",
-    schema: z.object({
-      addressOrDomain: z
-        .string()
-        .describe("The ENS domain or Ethereum address to tip"),
-      amount: z
-        .number()
-        .optional()
-        .default(1)
-        .describe("The amount of USDC to tip"),
-    }),
-    func: async ({ addressOrDomain, amount }) => {
-      if (!addressOrDomain) {
-        return "Please provide an address or ENS domain to tip.";
-      }
-
-      let address: string | undefined;
-
-      if (isAddress(addressOrDomain)) {
-        address = addressOrDomain;
-      } else {
-        const data = await getUserInfo(addressOrDomain);
-        address = data?.address;
-      }
-
-      if (!address) {
-        return "Could not resolve address for tipping. Please provide a valid ENS domain or Ethereum address.";
-      }
-
-      let sendUrl = `${txpayUrl}/?&amount=${amount}&token=USDC&receiver=${address}`;
-      return sendUrl;
-    },
-  }),
-];

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

@@ -1,29 +0,0 @@
-import { getUserInfo, HandlerContext } from "@xmtp/message-kit";
-
-export async function handler(context: HandlerContext) {
-  const {
-    message: {
-      content: { skill, params },
-    },
-  } = context;
-  const txpayUrl = "https://txpay.vercel.app";
-
-  if (skill === "pay") {
-    const { amount: amountSend, token: tokenSend, username } = params;
-    console.log("username", username);
-    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/handler/tipping.ts

@@ -1,40 +0,0 @@
-import {
-  HandlerContext,
-  AbstractedMember,
-  SkillResponse,
-} from "@xmtp/message-kit";
-import { getUserInfo } from "@xmtp/message-kit";
-
-export async function handler(context: HandlerContext) {
-  const {
-    message: {
-      content: {
-        skill,
-        params: { amount, username },
-      },
-      sender,
-    },
-  } = context;
-  let receivers: AbstractedMember[] = [];
-
-  if (skill === "tip") {
-    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/skills.ts

@@ -1,87 +0,0 @@
-import { handler as tipping } from "./handler/tipping.js";
-import { handler as payment } from "./handler/payment.js";
-import { handler as games } from "./handler/game.js";
-import { handler as help } from "./handler/helpers.js";
-import type { SkillGroup } from "@xmtp/message-kit";
-
-export const skills: SkillGroup[] = [
-  {
-    name: "Group bot",
-    tag: "@bot",
-    description: "Group agent for tipping and transactions.",
-    skills: [
-      {
-        skill: "/tip [usernames] [amount] [token]",
-        examples: ["/tip @vitalik 10 usdc"],
-        description: "Tip users in a specified token.",
-        handler: tipping,
-        params: {
-          username: {
-            default: "",
-            plural: true,
-            type: "username",
-          },
-          amount: {
-            default: 10,
-            type: "number",
-          },
-          token: {
-            default: "usdc",
-            type: "string",
-            values: ["eth", "dai", "usdc", "degen"],
-          },
-        },
-      },
-      {
-        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: payment,
-        params: {
-          amount: {
-            default: 10,
-            type: "number",
-          },
-          token: {
-            default: "usdc",
-            type: "string",
-            values: ["eth", "dai", "usdc", "degen"], // Accepted tokens
-          },
-          username: {
-            default: "",
-            type: "username",
-          },
-        },
-      },
-      {
-        skill: "/game [game]",
-        handler: games,
-        description: "Play a game.",
-        examples: ["/game wordle", "/game slot", "/game help"],
-        params: {
-          game: {
-            default: "",
-            type: "string",
-            values: ["wordle", "slot", "help"],
-          },
-        },
-      },
-      {
-        skill: "/help",
-        examples: ["/help"],
-        handler: help,
-        description: "Get help with the bot.",
-        params: {},
-      },
-      {
-        skill: "/id",
-        adminOnly: true,
-        examples: ["/id"],
-        handler: help,
-        description: "Get the group ID.",
-        params: {},
-      },
-    ],
-  },
-];