Merge pull request #16 from macalinao/igm/send-tx-updates

Improve transaction sending

Author: macalinao

.changeset/clear-grapes-laugh.md

@@ -0,0 +1,5 @@
+---
+"@macalinao/grill": minor
+---
+
+Restructure sendTX types, add error toasts for transaction signing rejected

.changeset/kind-women-boil.md

@@ -0,0 +1,5 @@
+---
+"@macalinao/zod-solana": patch
+---
+
+Fix TypeScript issues with Zod type

packages/grill/src/contexts/grill-context.ts

@@ -2,7 +2,7 @@ import type { DataLoader } from "@macalinao/dataloader-es";
 import type { Address, EncodedAccount } from "@solana/kit";
 import type { GetExplorerLinkArgs } from "gill";
 import { createContext, useContext } from "react";
-import type { SendTXFunction } from "../utils/internal/create-send-tx.js";
+import type { SendTXFunction } from "../utils/types.js";
 
 export type GetExplorerLinkFunction = (args?: GetExplorerLinkArgs) => string;
 

packages/grill/src/hooks/use-send-tx.ts

@@ -1,9 +1,6 @@
 import { useGrillContext } from "../contexts/grill-context.js";
 
-export type {
-  SendTXFunction,
-  SendTXOptions,
-} from "../utils/internal/create-send-tx.js";
+export type { SendTXFunction, SendTXOptions } from "../utils/types.js";
 
 /**
  * Hook that provides a function to send transactions using the modern @solana/kit API

packages/grill/src/providers/grill-provider.tsx

@@ -80,6 +80,29 @@ export const GrillProvider: FC<GrillProviderProps> = ({
           break;
         }
 
+        case "error-transaction-send-failed": {
+          console.error("Error sending transaction", event);
+          const description = event.errorMessage;
+
+          if (existingToastId) {
+            // Update existing toast to error
+            toast.error(event.title, {
+              id: existingToastId,
+              description,
+              duration: errorToastDuration,
+            });
+          } else {
+            // Create new error toast if somehow we don't have one
+            toast.error(event.title, {
+              description,
+              duration: errorToastDuration,
+            });
+          }
+          // Clean up toast ID after error
+          toastIds.current.delete(txId);
+          break;
+        }
+
         case "preparing": {
           // Clean up any existing toast for this transaction
           if (existingToastId) {
@@ -160,6 +183,7 @@ export const GrillProvider: FC<GrillProviderProps> = ({
         }
 
         case "error-transaction-failed": {
+          console.error("Transaction failed", event);
           const description = event.errorMessage;
           const action = createExplorerAction(event.explorerLink);
 

packages/grill/src/types.ts

@@ -15,6 +15,10 @@ export type TransactionStatusEvent = {
   | {
       type: "awaiting-wallet-signature";
     }
+  | {
+      type: "error-transaction-send-failed";
+      errorMessage: string;
+    }
   | {
       type: "waiting-for-confirmation";
       sig: Signature;

packages/grill/src/utils/index.ts

@@ -3,3 +3,4 @@ export * from "./get-signature-from-bytes.js";
 export * from "./get-solscan-explorer-link.js";
 export * from "./poll-confirm-transaction.js";
 export * from "./refetch-accounts.js";
+export * from "./types.js";

packages/grill/src/utils/internal/create-send-tx.ts

@@ -1,10 +1,9 @@
 import type {
   Address,
-  AddressesByLookupTableAddress,
   Instruction,
   Signature,
+  SignatureBytes,
   TransactionSendingSigner,
-  TransactionSigner,
 } from "@solana/kit";
 import {
   compressTransactionMessageUsingAddressLookupTables,
@@ -16,17 +15,7 @@ import type { GetExplorerLinkFunction } from "../../contexts/grill-context.js";
 import type { TransactionStatusEvent } from "../../types.js";
 import { getSignatureFromBytes } from "../get-signature-from-bytes.js";
 import { pollConfirmTransaction } from "../poll-confirm-transaction.js";
-
-export interface SendTXOptions {
-  luts?: AddressesByLookupTableAddress;
-  signers?: TransactionSigner[];
-}
-
-export type SendTXFunction = (
-  name: string,
-  ixs: readonly Instruction[],
-  options?: SendTXOptions,
-) => Promise<Signature>;
+import type { SendTXFunction, SendTXOptions } from "../types.js";
 
 export interface CreateSendTXParams {
   signer: TransactionSendingSigner | null;
@@ -77,13 +66,18 @@ export const createSendTX = ({
       instructions: [...ixs],
       latestBlockhash,
       // the compute budget values are HIGHLY recommend to be set in order to maximize your transaction landing rate
-      // TODO(igm): make this configurable and/or dynamic based on the instructions
-      computeUnitLimit: 1_400_000,
-      computeUnitPrice: 100_000n,
+      computeUnitLimit:
+        options.computeUnitLimit === null
+          ? undefined
+          : (options.computeUnitLimit ?? 1_400_000),
+      computeUnitPrice:
+        options.computeUnitPrice === null
+          ? undefined
+          : (options.computeUnitPrice ?? 100_000n),
     });
 
     // Apply address lookup tables if provided to compress the transaction
-    const addressLookupTables = options.luts ?? {};
+    const addressLookupTables = options.lookupTables ?? {};
     const finalTransactionMessage =
       Object.keys(addressLookupTables).length > 0
         ? compressTransactionMessageUsingAddressLookupTables(
@@ -98,9 +92,22 @@ export const createSendTX = ({
     });
 
     // Send transaction using wallet adapter
-    const sigBytes = await signAndSendTransactionMessageWithSigners(
-      finalTransactionMessage,
-    );
+    let sigBytes: SignatureBytes;
+    try {
+      sigBytes = await signAndSendTransactionMessageWithSigners(
+        finalTransactionMessage,
+      );
+    } catch (error: unknown) {
+      const errorMessage =
+        error instanceof Error ? error.message : "Failed to send transaction";
+      onTransactionStatusEvent({
+        ...baseEvent,
+        type: "error-transaction-send-failed",
+        errorMessage,
+      });
+      throw error;
+    }
+
     const sig = getSignatureFromBytes(sigBytes);
     const sentTxEvent = {
       ...baseEvent,
@@ -130,7 +137,15 @@ export const createSendTX = ({
         .filter((key) => key.writable)
         .map((k) => k.pubkey);
       if (writableAccounts.length > 0) {
-        await refetchAccounts(writableAccounts);
+        const waitForAccountRefetch = options.waitForAccountRefetch ?? true;
+        if (waitForAccountRefetch) {
+          await refetchAccounts(writableAccounts);
+        } else {
+          // Refetch in background without waiting
+          refetchAccounts(writableAccounts).catch((error: unknown) => {
+            console.warn("Failed to refetch accounts in background:", error);
+          });
+        }
       }
 
       if (result.meta?.logMessages) {

packages/grill/src/utils/types.ts

@@ -0,0 +1,36 @@
+import type {
+  AddressesByLookupTableAddress,
+  Instruction,
+  Signature,
+} from "@solana/kit";
+
+export interface SendTXOptions {
+  lookupTables?: AddressesByLookupTableAddress;
+  /**
+   * Compute unit limit for the transaction.
+   * Set to null to omit compute unit limit instruction.
+   * Defaults to 1,400,000 if not specified.
+   */
+  computeUnitLimit?: number | null;
+  /**
+   * Compute unit price for the transaction in microlamports.
+   * Set to null to omit compute unit price instruction.
+   * Defaults to 100,000 if not specified.
+   */
+  computeUnitPrice?: bigint | null;
+  /**
+   * Whether to wait for account refetch after transaction confirmation.
+   * When true (default), the function will wait for all writable accounts
+   * to be refetched before resolving. When false, the function will
+   * resolve immediately after confirmation and accounts will be refetched
+   * in the background.
+   * @default true
+   */
+  waitForAccountRefetch?: boolean;
+}
+
+export type SendTXFunction = (
+  name: string,
+  ixs: readonly Instruction[],
+  options?: SendTXOptions,
+) => Promise<Signature>;

packages/zod-solana/src/address-schema.ts

@@ -7,7 +7,7 @@ import { z } from "zod";
  * Validates that a string is a valid Solana address and transforms it to an Address type.
  * Compatible with both Zod v3 and v4.
  */
-export const addressSchema: z.ZodType<Address> = z
+export const addressSchema: z.ZodType<Address, string> = z
   .string()
   .transform((val, ctx) => {
     try {