@alchemy/wallet-apis 5.0.0-beta.28 → 5.0.0-beta.29

package/src/utils/capabilities.ts

@@ -2,17 +2,18 @@ import {
   PrepareCallsCapabilities as PrepareCallsCapabilitiesSchema,
   SendPreparedCallsCapabilities as SendPreparedCallsCapabilitiesSchema,
 } from "@alchemy/wallet-api-types/capabilities";
-import type { StaticDecode } from "typebox";
-import type { InnerWalletApiClient } from "../types.js";
+import type { z } from "zod";
+import type {
+  InnerWalletApiClient,
+  InnerSolanaWalletApiClient,
+} from "../types.js";
 
 /**
  * Decoded capabilities matching the schema shape (uses `paymasterService` key).
  * `ResolveCapabilities` renames this to `paymaster` for client-facing types.
  */
-type DecodedPrepareCallsCaps = StaticDecode<
-  typeof PrepareCallsCapabilitiesSchema
->;
-type DecodedSendPreparedCallsCaps = StaticDecode<
+type DecodedPrepareCallsCaps = z.output<typeof PrepareCallsCapabilitiesSchema>;
+type DecodedSendPreparedCallsCaps = z.output<
   typeof SendPreparedCallsCapabilitiesSchema
 >;
 
@@ -60,7 +61,7 @@ function hasNoPaymasterServiceField(
 
 /**
  * Converts capabilities (with `paymaster`) to RPC capabilities (with `paymasterService`)
- * for use with Value.Encode before sending to the RPC.
+ * for use with `encode` before sending to the RPC.
  *
  * @param {PrepareCallsCapabilities | SendPreparedCallsCapabilities | undefined} capabilities - Capabilities object containing a `paymaster` field
  * @returns {DecodedPrepareCallsCaps | DecodedSendPreparedCallsCaps | undefined} RPC capabilities with `paymasterService`, or undefined if input is undefined
@@ -82,7 +83,7 @@ export function toRpcCapabilities(
 }
 
 /**
- * Converts RPC capabilities (with `paymasterService`) from Value.Decode
+ * Converts RPC capabilities (with `paymasterService`) from `decode`
  * to capabilities (with `paymaster`).
  *
  * @param {DecodedPrepareCallsCaps | DecodedSendPreparedCallsCaps | undefined} capabilities - RPC capabilities object containing a `paymasterService` field
@@ -135,6 +136,37 @@ export const mergeClientCapabilities = <
   } as T;
 };
 
+export type SolanaPaymasterCapability = {
+  policyId: string;
+  webhookData?: string;
+};
+
+export type SolanaPrepareCallsCapabilities = {
+  paymaster?: SolanaPaymasterCapability;
+};
+
+/**
+ * Merges Solana client-level capabilities (policyId from factory) with
+ * request-level capabilities. Request-level takes priority if provided.
+ *
+ * @param {InnerSolanaWalletApiClient} client - The Solana wallet API client
+ * @param {SolanaPrepareCallsCapabilities | undefined} capabilities - Request capabilities to merge with
+ * @returns {SolanaPrepareCallsCapabilities | undefined} The merged capabilities
+ */
+export const mergeSolanaClientCapabilities = (
+  client: InnerSolanaWalletApiClient,
+  capabilities: SolanaPrepareCallsCapabilities | undefined,
+): SolanaPrepareCallsCapabilities | undefined => {
+  if (!client.policyIds?.length || capabilities?.paymaster) {
+    return capabilities;
+  }
+
+  return {
+    ...capabilities,
+    paymaster: { policyId: client.policyIds[0] },
+  };
+};
+
 /**
  * Extracts capabilities from prepareCalls that are usable for sendPreparedCalls.
  * Only permissions and paymaster (policyId/policyIds & webhookData) are supported.

package/src/utils/format.ts

@@ -31,7 +31,7 @@ export const signableMessageToJsonSafe = (
 };
 
 // Purposefully not using `formatTypedData` from the wallet server types pkg
-// here, since that would require typebox at runtime (which breaks RN).
+// here, since that would require zod at runtime (which breaks RN).
 export const typedDataToJsonSafe = ({
   domain,
   primaryType,

package/src/utils/schema.ts

@@ -1,109 +1,98 @@
-import type {
-  TObject,
-  TSchema,
-  TTuple,
-  StaticDecode,
-  StaticEncode,
-} from "typebox";
-import { Value, EncodeError, DecodeError, Pointer } from "typebox/value";
+import { z } from "zod";
 import { BaseError } from "@alchemy/common";
 
 /** Constraint for RPC method schemas from `@alchemy/wallet-api-types/rpc`. */
-type RpcMethodSchema = TObject<{
-  Request: TObject<{
-    method: TSchema;
-    params: TTuple<[TSchema, ...TSchema[]]>;
+type RpcMethodSchema = z.ZodObject<{
+  Request: z.ZodObject<{
+    method: z.ZodType;
+    params: z.ZodTuple<[z.ZodType, ...z.ZodType[]]>;
   }>;
-  ReturnType: TSchema;
+  ReturnType: z.ZodType;
 }>;
 
-export function methodSchema<TReq extends TSchema, TRes extends TSchema>(
-  schema: TObject<{
-    Request: TObject<{ method: TSchema; params: TTuple<[TReq, ...TSchema[]]> }>;
+export function methodSchema<TReq extends z.ZodType, TRes extends z.ZodType>(
+  schema: z.ZodObject<{
+    Request: z.ZodObject<{
+      method: z.ZodType;
+      params: z.ZodTuple<[TReq, ...z.ZodType[]]>;
+    }>;
     ReturnType: TRes;
   }>,
 ): { request: TReq; response: TRes } {
   return {
-    request: schema.properties.Request.properties.params.items[0],
-    response: schema.properties.ReturnType,
+    request: schema.shape.Request.shape.params.def.items[0],
+    response: schema.shape.ReturnType,
   };
 }
 
 /** Extracts the decoded params type from a method schema. */
-export type MethodParams<T extends RpcMethodSchema> = StaticDecode<
-  T["properties"]["Request"]["properties"]["params"]["items"][0]
+export type MethodParams<T extends RpcMethodSchema> = z.output<
+  T["shape"]["Request"]["shape"]["params"]["def"]["items"][0]
 >;
 
 /** Extracts the decoded response type from a method schema. */
-export type MethodResponse<T extends RpcMethodSchema> = StaticDecode<
-  T["properties"]["ReturnType"]
+export type MethodResponse<T extends RpcMethodSchema> = z.output<
+  T["shape"]["ReturnType"]
 >;
 
-/**
- * Formats an {@link EncodeError} or {@link DecodeError} into a human-readable
- * string describing what went wrong, including the JSON path and the schema's
- * custom error message (if any).
- *
- * @param {TSchema} schema - The TypeBox schema that validation was run against.
- * @param {EncodeError | DecodeError} error - The error thrown by {@link Value.Encode} or {@link Value.Decode}.
- * @returns {string} A formatted error string prefixed with `"Invalid params"`.
- */
-function formatCodecError(
-  schema: TSchema,
-  error: EncodeError | DecodeError,
-): string {
-  // Use only the first error — it's the most specific. Subsequent errors are
-  // typically cascade noise from union/anyOf branches.
-  const causeError = error.cause.errors[0];
-  // errors is typed as an open array — guard against the (practically
-  // impossible) empty case.
-  if (!causeError) return "Invalid params";
+function isUnionIssue(
+  issue: z.core.$ZodIssue,
+): issue is z.core.$ZodIssueInvalidUnion {
+  return issue.code === "invalid_union";
+}
 
-  const path = causeError.instancePath || "(root)";
+function formatCodecError(error: z.ZodError): string {
+  let issue: z.core.$ZodIssue | undefined = error.issues[0];
+  if (!issue) return "Invalid params";
 
-  // Prefer the schema's custom errorMessage annotation over the generic locale message.
-  let message = causeError.message;
-  const schemaPointer = causeError.schemaPath.replace(/^#/, "");
-  if (schemaPointer) {
-    const schemaNode = Pointer.Get(schema, schemaPointer);
-    if (
-      schemaNode &&
-      typeof schemaNode === "object" &&
-      "errorMessage" in schemaNode &&
-      typeof (schemaNode as Record<string, unknown>).errorMessage === "string"
-    ) {
-      message = (schemaNode as Record<string, unknown>).errorMessage as string;
+  // For union errors, drill into the branch with the fewest issues (closest match).
+  // Accumulate paths as we drill — each union level carries a partial path.
+  const pathPrefix: PropertyKey[] = [];
+  while (isUnionIssue(issue)) {
+    pathPrefix.push(...issue.path);
+    let best: z.core.$ZodIssue[] | undefined;
+    for (const branch of issue.errors) {
+      if (!best || branch.length < best.length) best = branch;
     }
+    const next = best?.[0];
+    if (!next) break;
+    issue = next;
   }
 
-  return `Invalid params: ${path}: ${message}`;
+  const fullPath = [...pathPrefix, ...issue.path];
+  const path =
+    fullPath.length > 0 ? "/" + fullPath.map(String).join("/") + ": " : "";
+
+  return `Invalid params: ${path}${issue.message}`;
 }
 
-// Type-safe wrapper around `Value.Encode` with human-readable errors.
-export function encode<const T extends TSchema>(
+export function encode<const T extends z.ZodType>(
   schema: T,
-  value: StaticDecode<T>,
-): StaticEncode<T> {
+  value: z.output<T>,
+): z.input<T> {
   try {
-    return Value.Encode(schema, value);
+    return schema.encode(value);
   } catch (error) {
-    if (error instanceof EncodeError) {
-      throw new BaseError(formatCodecError(schema, error), { cause: error });
+    if (error instanceof z.ZodError) {
+      throw new BaseError(formatCodecError(error), {
+        cause: error as Error,
+      });
     }
     throw error;
   }
 }
 
-// Type-safe wrapper around `Value.Decode` with human-readable errors.
-export function decode<const T extends TSchema>(
+export function decode<const T extends z.ZodType>(
   schema: T,
-  value: StaticEncode<T>,
-): StaticDecode<T> {
+  value: z.input<T>,
+): z.output<T> {
   try {
-    return Value.Decode(schema, value);
+    return schema.decode(value);
   } catch (error) {
-    if (error instanceof DecodeError) {
-      throw new BaseError(formatCodecError(schema, error), { cause: error });
+    if (error instanceof z.ZodError) {
+      throw new BaseError(formatCodecError(error), {
+        cause: error as Error,
+      });
     }
     throw error;
   }

package/src/version.ts

@@ -1,3 +1,3 @@
 // This file is autogenerated by inject-version.ts. Any changes will be
 // overwritten on commit!
-export const VERSION = "5.0.0-beta.28";
+export const VERSION = "5.0.0-beta.29";