@alchemy/wallet-apis 5.0.0-beta.9 → 5.0.1

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
+import type { SolanaChainId } from "@alchemy/wallet-api-types";
 import type {
   Account,
   Address,
@@ -12,31 +13,61 @@ import type {
 } from "viem";
 import type { InternalState } from "./internal";
 import type { SmartWalletActions } from "./decorators/smartWalletActions";
+import type { SolanaSmartWalletActions } from "./decorators/solanaSmartWalletActions";
 
 export type BaseWalletClient<
   TExtend extends { [key: string]: unknown } | undefined =
     | { [key: string]: unknown }
     | undefined,
+  TAccount extends Account | undefined = JsonRpcAccount<Address>,
 > = Client<
   Transport<"alchemyHttp">,
   Chain,
-  JsonRpcAccount<Address>,
+  TAccount,
   WalletServerViemRpcSchema,
   TExtend
 >;
 
-export type InnerWalletApiClient = BaseWalletClient<{
-  internal: InternalState | undefined; // undefined if you want to skip using an internal cache
-  owner: SmartWalletSigner;
-  policyIds?: string[];
-}>;
-
 export type SignerClient = WalletClient<Transport, Chain | undefined, Account>;
 
 export type SmartWalletSigner = LocalAccount | SignerClient;
 
 export type SmartWalletClient = BaseWalletClient<SmartWalletActions>;
 
+export type SolanaSmartWalletClient = BaseWalletClient<
+  SolanaSmartWalletActions & { solanaAccount: string },
+  undefined
+>;
+
+/** Solana signer interface. Takes serialized tx bytes, returns signed serialized tx bytes. */
+export interface SolanaSigner {
+  address: string;
+  signTransaction(input: {
+    transaction: Uint8Array;
+    [key: string]: unknown;
+  }): Promise<{ signedTransaction: Uint8Array }>;
+}
+
+export interface SolanaChainDef extends Chain {
+  solanaChainId: SolanaChainId;
+}
+
+export type InnerWalletApiClient = BaseWalletClient<{
+  internal: InternalState | undefined;
+  owner: SmartWalletSigner;
+  policyIds?: string[];
+}>;
+
+export type InnerSolanaWalletApiClient = BaseWalletClient<
+  {
+    internal: InternalState | undefined;
+    owner: SolanaSigner;
+    solanaAccount: string;
+    policyIds?: string[];
+  },
+  undefined
+>;
+
 export type OptionalChainId<T> = T extends { chainId: number }
   ? Omit<T, "chainId"> & { chainId?: number | undefined }
   : T;

package/src/utils/assertions.ts

@@ -1,5 +1,10 @@
-import type { Client, LocalAccount } from "viem";
-import type { InnerWalletApiClient, SignerClient } from "../types.js";
+import type { Chain, Client, LocalAccount } from "viem";
+import type {
+  InnerWalletApiClient,
+  InnerSolanaWalletApiClient,
+  SignerClient,
+  SolanaChainDef,
+} from "../types.js";
 import { BaseError } from "@alchemy/common";
 
 /**
@@ -14,6 +19,12 @@ export function isSmartWalletClient(
   return client.name === "alchemySmartWalletClient" && "owner" in client;
 }
 
+export function isSolanaClient(
+  client: Client,
+): client is InnerSolanaWalletApiClient {
+  return client.name === "alchemySolanaSmartWalletClient" && "owner" in client;
+}
+
 /**
  * Assertion function that throws an error if the client is not an Alchemy Smart Wallet Client.
  * After this function returns successfully, TypeScript will narrow the client type.
@@ -31,6 +42,10 @@ export function assertSmartWalletClient(
   }
 }
 
+export function isSolanaChain(chain: Chain): chain is SolanaChainDef {
+  return "solanaChainId" in chain;
+}
+
 export function isLocalAccount(
   signer: LocalAccount | SignerClient,
 ): signer is LocalAccount {

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

@@ -4,8 +4,10 @@ import {
   type Hex,
   type SignableMessage,
   bytesToHex,
+  type TypedData,
   type TypedDataDefinition,
   getTypesForEIP712Domain,
+  validateTypedData,
 } from "viem";
 import type { TypedDataDefinition as WalletServerTypedDataDefinition } from "@alchemy/wallet-api-types";
 
@@ -29,13 +31,16 @@ 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,
   message,
   types,
-}: TypedDataDefinition): WalletServerTypedDataDefinition => {
+}: TypedDataDefinition<
+  TypedData | Record<string, unknown>
+>): WalletServerTypedDataDefinition => {
+  validateTypedData({ domain, primaryType, message, types });
   return {
     domain: {
       ...domain,
@@ -48,7 +53,7 @@ export const typedDataToJsonSafe = ({
       ...Object.fromEntries(
         Object.entries(types).map(([key, value]) => [
           key,
-          value ? [...value] : [],
+          Array.isArray(value) ? [...value] : [],
         ]),
       ),
       EIP712Domain: [...getTypesForEIP712Domain({ domain })],

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.9";
+export const VERSION = "5.0.1";