rewrite the connection utils for memo and transfer sol

Author: ngundotra

examples/next-js/package-lock.json

@@ -33,7 +33,8 @@
     "tailwindcss-animate": "^1.0.7",
     "tweetnacl": "^1.0.3",
     "vaul": "^0.9.1",
-    "zod": "^3.23.8"
+    "zod": "^3.23.8",
+    "zod-validation-error": "^3.4.0"
   },
   "devDependencies": {
     "@types/node": "^20",

examples/next-js/package.json

@@ -0,0 +1,32 @@
+import { TransactionInstruction, PublicKey } from "@solana/web3.js";
+
+/**
+ * Memo Program ID on Solana
+ * This is a system program that allows writing arbitrary data to the blockchain
+ */
+export const MEMO_PROGRAM_ID = new PublicKey("MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr");
+
+/**
+ * Creates an instruction to write a memo to the Solana blockchain
+ * 
+ * @param message - The message to write to the blockchain
+ * @param signers - Array of public keys that need to sign this instruction
+ * @returns TransactionInstruction for the memo program
+ * 
+ * Usage:
+ * const instruction = createMemoInstruction("Hello Solana!", [signer.publicKey]);
+ */
+export function createMemoInstruction(
+  message: string,
+  signers: PublicKey[] = []
+): TransactionInstruction {
+  return new TransactionInstruction({
+    programId: MEMO_PROGRAM_ID,
+    keys: signers.map((pubkey) => ({
+      pubkey,
+      isSigner: true,
+      isWritable: false,
+    })),
+    data: Buffer.from(message, "utf-8"),
+  });
+} 

examples/next-js/src/app/api/actions/memo/instruction.ts

@@ -5,95 +5,102 @@
 import {
   ActionPostResponse,
   createPostResponse,
-  MEMO_PROGRAM_ID,
   ActionGetResponse,
-  ActionPostRequest,
   createActionHeaders,
-  ActionError,
+  Action,
+  ActionPostRequest,
 } from "@solana/actions";
 import {
-  clusterApiUrl,
-  ComputeBudgetProgram,
-  Connection,
   PublicKey,
-  Transaction,
-  TransactionInstruction,
+  TransactionMessage,
+  VersionedTransaction,
 } from "@solana/web3.js";
+import { createActionRoutes } from "../../utils/action-handler";
+import { getConnection } from "../../utils/connection";
+import { MemoQuerySchema } from "./schema";
+
+// Create memo program instruction
+import { createMemoInstruction } from "./instruction";
 
-// create the standard headers for this route (including CORS)
 const headers = createActionHeaders();
 
-export const GET = async (req: Request) => {
-  const payload: ActionGetResponse = {
+async function handleGet(req: Request): Promise<ActionGetResponse> {
+  const requestUrl = new URL(req.url);
+  const baseHref = new URL("/api/actions/memo", requestUrl.origin).toString();
+
+  return {
     type: "action",
-    title: "Actions Example - Simple On-chain Memo",
-    icon: new URL("/solana_devs.jpg", new URL(req.url).origin).toString(),
-    description: "Send a message on-chain using a Memo",
-    label: "Send Memo",
+    title: "Actions Example - Write Memo",
+    icon: new URL("/solana_devs.jpg", requestUrl.origin).toString(),
+    description: "Write a message to the Solana network",
+    label: "Write",
+    links: {
+      actions: [
+        {
+          label: "Write Message",
+          href: `${baseHref}?message={message}`,
+          parameters: [
+            {
+              type: "textarea",
+              name: "message",
+              label: "Enter your message",
+              required: true,
+              min: 1,
+              max: 256,
+            },
+          ],
+        },
+      ],
+    },
   };
+}
+
+async function handlePost(req: Request): Promise<ActionPostResponse> {
+  const requestUrl = new URL(req.url);
+  const { message } = parseQueryParams(requestUrl);
+
+  const body: ActionPostRequest = await req.json();
+  const account = new PublicKey(body.account);
+
+  const connection = getConnection();
+  const { blockhash } = await connection.getLatestBlockhash();
 
-  return Response.json(payload, {
-    headers,
+  // Create the memo instruction
+  const memoInstruction = createMemoInstruction(message, [account]);
+
+  // Create a versioned transaction
+  const messageV0 = new TransactionMessage({
+    payerKey: account,
+    recentBlockhash: blockhash,
+    instructions: [memoInstruction],
+  }).compileToV0Message();
+
+  const transaction = new VersionedTransaction(messageV0);
+
+  return createPostResponse({
+    fields: {
+      transaction,
+      message: `Write memo: "${message}"`,
+    },
   });
-};
-
-// DO NOT FORGET TO INCLUDE THE `OPTIONS` HTTP METHOD
-// THIS WILL ENSURE CORS WORKS FOR BLINKS
-export const OPTIONS = async () => Response.json(null, { headers });
-
-export const POST = async (req: Request) => {
-  try {
-    const body: ActionPostRequest = await req.json();
-
-    let account: PublicKey;
-    try {
-      account = new PublicKey(body.account);
-    } catch (err) {
-      throw 'Invalid "account" provided';
-    }
-
-    const connection = new Connection(
-      process.env.SOLANA_RPC! || clusterApiUrl("devnet"),
-    );
-
-    const transaction = new Transaction().add(
-      // note: `createPostResponse` requires at least 1 non-memo instruction
-      ComputeBudgetProgram.setComputeUnitPrice({
-        microLamports: 1000,
-      }),
-      new TransactionInstruction({
-        programId: new PublicKey(MEMO_PROGRAM_ID),
-        data: Buffer.from("this is a simple memo message2", "utf8"),
-        keys: [],
-      }),
-    );
-
-    // set the end user as the fee payer
-    transaction.feePayer = account;
-
-    transaction.recentBlockhash = (
-      await connection.getLatestBlockhash()
-    ).blockhash;
-
-    const payload: ActionPostResponse = await createPostResponse({
-      fields: {
-        transaction,
-        message: "Post this memo on-chain",
-      },
-      // no additional signers are required for this transaction
-      // signers: [],
-    });
-
-    return Response.json(payload, {
-      headers,
-    });
-  } catch (err) {
-    console.log(err);
-    let actionError: ActionError = { message: "An unknown error occurred" };
-    if (typeof err == "string") actionError.message = err;
-    return Response.json(actionError, {
-      status: 400,
-      headers,
-    });
+}
+
+function parseQueryParams(requestUrl: URL) {
+  const result = MemoQuerySchema.safeParse(
+    Object.fromEntries(requestUrl.searchParams)
+  );
+
+  if (!result.success) {
+    throw result.error;
   }
-};
+
+  return result.data;
+}
+
+export const { GET, POST, OPTIONS } = createActionRoutes(
+  {
+    GET: handleGet,
+    POST: handlePost,
+  },
+  headers
+);

examples/next-js/src/app/api/actions/memo/route.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const MemoQuerySchema = z.object({
+  message: z.string().min(1, "Message is required").max(256, "Message must be less than 256 characters"),
+});
+
+export type MemoQuery = z.infer<typeof MemoQuerySchema>;

examples/next-js/src/app/api/actions/memo/schema.ts

@@ -1,7 +1 @@
-import { PublicKey } from "@solana/web3.js";
-
-export const DEFAULT_SOL_ADDRESS: PublicKey = new PublicKey(
-  "nick6zJc6HpW3kfBm4xS2dmbuVRyb5F3AnUvj5ymzR5", // devnet wallet
-);
-
 export const DEFAULT_SOL_AMOUNT: number = 1.0;