@zoralabs/coins-sdk 0.6.0 → 0.7.0

package/dist/utils/calls.d.ts

@@ -0,0 +1,61 @@
+import { type Abi, type Address, type ContractFunctionArgs, type ContractFunctionName, type ContractFunctionParameters, type Hex } from "viem";
+type WritableMutability = "payable" | "nonpayable";
+type WritableFunction<abi extends Abi | readonly unknown[]> = ContractFunctionName<abi, WritableMutability>;
+type WritableArgs<abi extends Abi | readonly unknown[], functionName extends WritableFunction<abi>> = ContractFunctionArgs<abi, WritableMutability, functionName>;
+export type ContractCall<abi extends Abi | readonly unknown[] = readonly unknown[], fn extends WritableFunction<abi> = WritableFunction<abi>, args extends WritableArgs<abi, fn> = WritableArgs<abi, fn>> = ContractFunctionParameters<abi, WritableMutability, fn, args> & {
+    /** Optional ETH value to send with the call. */
+    value?: bigint;
+    /**
+     * Optional calldata appended after the encoded function data, e.g. for
+     * attribution. Mirrors viem's `dataSuffix`; concatenated by {@link toGenericCall}.
+     */
+    dataSuffix?: Hex;
+};
+export declare const isContractCall: (call: ContractCall | SendCall) => call is ContractCall;
+export type SendCall = {
+    to: Address;
+    value?: bigint;
+};
+export declare const isSendCall: (call: ContractCall | SendCall) => call is SendCall;
+/**
+ * A normalized, fully-encoded contract call.
+ *
+ * This is the canonical call shape emitted by the action `createAndValidate*Calls`
+ * builders. It intentionally matches the encoded-call form accepted by both
+ * `walletClient.sendTransaction` (EOA execution) and viem's bundler client
+ * `prepareUserOperation` / `sendUserOperation` (smart wallet / user operation
+ * execution), so a single call list can drive either flow.
+ */
+export type GenericCall = {
+    to: Address;
+    data: Hex;
+    value: bigint;
+};
+/**
+ * The encoded-call shape accepted by viem's bundler client `calls` parameter
+ * (`prepareUserOperation` / `sendUserOperation`).
+ *
+ * `data` and `value` are optional on viem's side; we always populate them from a
+ * {@link GenericCall}.
+ */
+export type UserOperationCall = {
+    to: Address;
+    data?: Hex;
+    value?: bigint;
+};
+/**
+ * Converts a contract call or send call to a generic call.
+ */
+export declare function toGenericCall(call: ContractCall | SendCall): GenericCall;
+/**
+ * Adapts a list of {@link GenericCall} into the call shape expected by viem's
+ * bundler client.
+ *
+ * A {@link GenericCall} is already fully encoded calldata, so this is a thin
+ * adapter rather than an encoder. It exists as an explicit seam: it owns any
+ * future divergence between our `GenericCall` shape and viem's user-operation
+ * call type, and keeps the conversion point obvious at call sites.
+ */
+export declare function toUserOperationCalls(calls: GenericCall[]): UserOperationCall[];
+export {};
+//# sourceMappingURL=calls.d.ts.map

package/dist/utils/calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calls.d.ts","sourceRoot":"","sources":["../../src/utils/calls.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EACR,KAAK,OAAO,EAEZ,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAE/B,KAAK,GAAG,EACT,MAAM,MAAM,CAAC;AAId,KAAK,kBAAkB,GAAG,SAAS,GAAG,YAAY,CAAC;AAEnD,KAAK,gBAAgB,CAAC,GAAG,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,IACxD,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;AAEhD,KAAK,YAAY,CACf,GAAG,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EACpC,YAAY,SAAS,gBAAgB,CAAC,GAAG,CAAC,IACxC,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,EAAE,YAAY,CAAC,CAAC;AAEhE,MAAM,MAAM,YAAY,CACtB,GAAG,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,GAAG,SAAS,OAAO,EAAE,EACzD,EAAE,SAAS,gBAAgB,CAAC,GAAG,CAAC,GAAG,gBAAgB,CAAC,GAAG,CAAC,EACxD,IAAI,SAAS,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,YAAY,CAAC,GAAG,EAAE,EAAE,CAAC,IACxD,0BAA0B,CAAC,GAAG,EAAE,kBAAkB,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG;IAClE,gDAAgD;IAChD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,UAAU,CAAC,EAAE,GAAG,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,MAAM,YAAY,GAAG,QAAQ,KAC5B,IAAI,IAAI,YAMV,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,YAAY,GAAG,QAAQ,KAAG,IAAI,IAAI,QAElE,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,QAAQ,GAAG,WAAW,CAsBxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAAE,GACnB,iBAAiB,EAAE,CAMrB"}

package/dist/utils/userOperation.d.ts

@@ -0,0 +1,44 @@
+import type { BundlerClient, SmartAccount, UserOperation, UserOperationReceipt } from "viem/account-abstraction";
+import { UserOperationCall } from "./calls";
+export type PreparedUserOperation = UserOperation<"0.6">;
+/**
+ * Prepares a user operation from a list of contract calls.
+ * Returns a fully-populated UserOperation (gas estimated, nonce filled) with a
+ * stub signature from gas estimation. Must be re-signed before submitting.
+ */
+export declare const prepareUserOperation: ({ bundlerClient, account, calls, }: {
+    bundlerClient: BundlerClient;
+    account: SmartAccount;
+    calls: readonly UserOperationCall[];
+}) => Promise<PreparedUserOperation>;
+/**
+ * Signs and submits a prepared user operation, then waits for the receipt.
+ *
+ * The prepared op carries a stub signature from gas estimation, so we re-sign
+ * here before sending. Otherwise viem's sendUserOperation would forward the
+ * stub and the bundler would reject it as invalid.
+ */
+export declare const submitUserOperation: ({ bundlerClient, account, userOperation, }: {
+    bundlerClient: BundlerClient;
+    account: SmartAccount;
+    userOperation: PreparedUserOperation;
+}) => Promise<UserOperationReceipt>;
+type CoinbaseBundlerError = {
+    stack: string;
+    message: string;
+    cause: unknown;
+    details: string;
+    docsPath: string;
+    shortMessage: string;
+    version: string;
+    name: string;
+};
+export declare class CoinbaseGasError extends Error {
+    cause: unknown;
+    details: string;
+    required?: bigint;
+    available?: bigint;
+    constructor(error: CoinbaseBundlerError);
+}
+export {};
+//# sourceMappingURL=userOperation.d.ts.map

package/dist/utils/userOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userOperation.d.ts","sourceRoot":"","sources":["../../src/utils/userOperation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;AAEzD;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAU,oCAIxC;IACD,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACrC,KAAG,OAAO,CAAC,qBAAqB,CAMhC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAU,4CAIvC;IACD,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,aAAa,EAAE,qBAAqB,CAAC;CACtC,KAAG,OAAO,CAAC,oBAAoB,CAmB/B,CAAC;AAEF,KAAK,oBAAoB,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;gBACP,KAAK,EAAE,oBAAoB;CA8BxC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/coins-sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "repository": "https://github.com/ourzora/zora-protocol",
   "license": "MIT",
   "type": "module",

package/src/actions/createCoin.ts

@@ -3,23 +3,30 @@ import {
   coinFactoryABI as zoraFactoryImplABI,
 } from "@zoralabs/protocol-deployments";
 import {
+  Account,
   Address,
-  TransactionReceipt,
-  WalletClient,
   ContractEventArgsFromTopics,
-  parseEventLogs,
+  decodeFunctionData,
   Hex,
-  Account,
   isAddressEqual,
+  parseEventLogs,
+  TransactionReceipt,
+  WalletClient,
 } from "viem";
+import { BundlerClient } from "viem/account-abstraction";
 import { base } from "viem/chains";
-import { validateClientNetwork } from "../utils/validateClientNetwork";
-import { GenericPublicClient } from "../utils/genericPublicClient";
+import { postCreateContent } from "../api";
 import { validateMetadataURIContent } from "../metadata";
 import { ValidMetadataURI } from "../uploader/types";
+import { GenericCall, toUserOperationCalls } from "../utils/calls";
+import { GenericPublicClient } from "../utils/genericPublicClient";
 import { getChainFromId } from "../utils/getChainFromId";
-import { postCreateContent } from "../api";
 import { rethrowDecodedRevert } from "../utils/rethrowDecodedRevert";
+import {
+  prepareUserOperation,
+  submitUserOperation,
+} from "../utils/userOperation";
+import { validateClientNetwork } from "../utils/validateClientNetwork";
 
 export type CoinDeploymentLogArgs = ContractEventArgsFromTopics<
   typeof zoraFactoryImplABI,
@@ -62,6 +69,13 @@ export type CreateCoinArgs = {
   additionalOwners?: Address[];
   payoutRecipientOverride?: Address;
   skipMetadataValidation?: boolean;
+  /**
+   * Enable smart wallet routing. When true, the API resolves the creator's
+   * linked smart wallet and returns a single call wrapped in the smart wallet's
+   * `execute`, so the coin is deployed and owned by the smart wallet (executed by
+   * an owner EOA). Used by {@link createCoinSmartWallet}. Defaults to false.
+   */
+  enableSmartWalletRouting?: boolean;
 };
 
 type TransactionParameters = {
@@ -73,6 +87,12 @@ type TransactionParameters = {
 type CreateCoinCallResponse = {
   calls: TransactionParameters[];
   predictedCoinAddress: Address;
+  /**
+   * Whether the API applied smart wallet routing. False (or undefined) means the
+   * call targets the factory directly (EOA creation); true means it is wrapped in
+   * the smart wallet's `execute`.
+   */
+  usedSmartWalletRouting?: boolean;
 };
 
 export async function createCoinCall({
@@ -86,6 +106,7 @@ export async function createCoinCall({
   additionalOwners,
   platformReferrer,
   skipMetadataValidation = false,
+  enableSmartWalletRouting,
 }: CreateCoinArgs): Promise<CreateCoinCallResponse> {
   // Validate metadata URI
   if (!skipMetadataValidation) {
@@ -102,6 +123,7 @@ export async function createCoinCall({
     platformReferrer,
     additionalOwners,
     payoutRecipientOverride,
+    enableSmartWalletRouting,
   });
 
   if (!createContentRequest.data?.calls) {
@@ -116,93 +138,201 @@ export async function createCoinCall({
     })),
     predictedCoinAddress: createContentRequest.data
       .predictedCoinAddress as Address,
+    usedSmartWalletRouting: createContentRequest.data.usedSmartWalletRouting,
   };
 }
 
 /**
- * Gets the deployed coin address from transaction receipt logs
- * @param receipt Transaction receipt containing the CoinCreated event
- * @returns The deployment information if found
+ * Validates the assembled calls for creating a coin.
+ *
+ * Asserts the invariants this SDK version supports: a single call, targeting the
+ * coin factory for the given chain, with no attached value (no buy-on-create).
+ * Shared by both the EOA execution path (`createCoin`) and the user-operation
+ * path so both validate identically.
  */
-export function getCoinCreateFromLogs(
-  receipt: TransactionReceipt,
-): CoinDeploymentLogArgs | undefined {
-  const eventLogs = parseEventLogs({
-    abi: zoraFactoryImplABI,
-    logs: receipt.logs,
-  });
-
-  return eventLogs.find((log) => log.eventName === "CoinCreatedV4")?.args;
-}
-
-// Update createCoin to return both receipt and coin address
-export async function createCoin({
-  call,
-  walletClient,
-  publicClient,
-  options,
-}: {
-  call: CreateCoinArgs;
-  walletClient: WalletClient;
-  publicClient: GenericPublicClient;
-  options?: {
-    gasMultiplier?: number;
-    account?: Account | Address;
-    skipValidateTransaction?: boolean;
-  };
-}) {
-  validateClientNetwork(publicClient);
-
-  const chainId = call.chainId ?? publicClient.chain.id;
-
-  const callRequest = await createCoinCall({
-    ...call,
-    chainId,
-  });
-
-  if (callRequest.calls.length !== 1) {
+export function validateCreateCoinCalls(
+  calls: GenericCall[],
+  chainId: number,
+): void {
+  if (calls.length !== 1) {
     throw new Error("Only one call is supported for this SDK version");
   }
 
-  const createContentCall = callRequest.calls[0];
+  const createContentCall = calls[0];
 
   if (!createContentCall) {
     throw new Error("Failed to load create content calldata from API");
   }
 
   const coinFactoryAddressForChain =
-    coinFactoryAddress[call.chainId as keyof typeof coinFactoryAddress];
+    coinFactoryAddress[chainId as keyof typeof coinFactoryAddress];
 
   // Sanity check that the call is for the correct factory contract
   if (!isAddressEqual(createContentCall.to, coinFactoryAddressForChain)) {
     throw new Error("Creator coin is not supported for this SDK version");
   }
 
-  // Sanity check to ensure no buy orders are sent with there parameters
+  // Sanity check to ensure no buy orders are sent with these parameters
   if (createContentCall.value !== 0n) {
     throw new Error(
       "Creator coin and purchase is not supported for this SDK version.",
     );
   }
+}
+
+/**
+ * Validates the assembled calls for creating a coin via smart wallet routing.
+ *
+ * Unlike {@link validateCreateCoinCalls}, the call targets the creator's smart
+ * wallet (its `execute` method), not the factory — so the factory-target check
+ * does not apply. The key guard is that the API actually applied routing:
+ * `enableSmartWalletRouting` is best-effort and silently falls back to EOA
+ * creation when the creator has no linked smart wallet, which must not be
+ * mistaken for a smart wallet creation.
+ */
+export function validateCreateCoinSmartWalletCalls(
+  calls: GenericCall[],
+  { usedSmartWalletRouting }: { usedSmartWalletRouting?: boolean },
+): void {
+  if (!usedSmartWalletRouting) {
+    throw new Error(
+      "Smart wallet routing was not applied. The creator must have a linked smart wallet; otherwise use createCoin for EOA creation.",
+    );
+  }
+
+  if (calls.length !== 1) {
+    throw new Error("Only one call is supported for this SDK version");
+  }
 
-  // Prefer a LocalAccount from the wallet client when available to ensure
-  // offline signing (eth_sendRawTransaction) instead of wallet_sendTransaction
-  // which can error when a `from` field is present.
-  const selectedAccount =
-    (typeof options?.account === "string" ? undefined : options?.account) ??
-    walletClient.account;
+  const createContentCall = calls[0];
 
-  if (!selectedAccount) {
+  if (!createContentCall) {
+    throw new Error("Failed to load create content calldata from API");
+  }
+
+  // Sanity check to ensure no buy orders are sent with these parameters
+  if (createContentCall.value !== 0n) {
+    throw new Error(
+      "Creator coin and purchase is not supported for this SDK version.",
+    );
+  }
+}
+
+/**
+ * Gets the deployed coin address from transaction receipt logs
+ * @param receipt Transaction receipt containing the CoinCreated event
+ * @returns The deployment information if found
+ */
+export function getCoinCreateFromLogs(
+  receipt: TransactionReceipt,
+): CoinDeploymentLogArgs | undefined {
+  const eventLogs = parseEventLogs({
+    abi: zoraFactoryImplABI,
+    logs: receipt.logs,
+  });
+
+  return eventLogs.find((log) => log.eventName === "CoinCreatedV4")?.args;
+}
+
+type CreateCoinOptions = {
+  gasMultiplier?: number;
+  account?: Account | Address;
+  skipValidateTransaction?: boolean;
+};
+
+/** Minimal ABI for the Coinbase Smart Wallet `execute` method, used to unwrap a routed call. */
+const coinbaseSmartWalletExecuteABI = [
+  {
+    type: "function",
+    name: "execute",
+    stateMutability: "payable",
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" },
+    ],
+    outputs: [],
+  },
+] as const;
+
+/**
+ * Unwraps the smart wallet `execute(target, value, data)` call that the API
+ * returns under smart wallet routing into its inner factory call.
+ *
+ * The bundler/account (`toCoinbaseSmartAccount.encodeCalls`) re-wraps a single
+ * call in `execute` when forming the user operation, so the inner call — not the
+ * pre-wrapped one — must be fed to the user-operation path; passing the wrapped
+ * call would double-wrap it. The inner call still executes with the smart wallet
+ * as `msg.sender`, so the deployed coin's CREATE2 address is unchanged (the API's
+ * predicted address remains valid).
+ *
+ * Throws if the call is not a recognizable `execute` call, so an unexpected shape
+ * fails loudly rather than silently double-wrapping.
+ */
+function unwrapSmartWalletExecuteCall(call: GenericCall): GenericCall {
+  let decoded;
+  try {
+    decoded = decodeFunctionData({
+      abi: coinbaseSmartWalletExecuteABI,
+      data: call.data,
+    });
+  } catch {
+    throw new Error(
+      "Expected a smart wallet `execute` call from smart wallet routing, but the routed call could not be decoded.",
+    );
+  }
+
+  const [target, value, data] = decoded.args;
+  return { to: target, value, data };
+}
+
+/**
+ * Selects the account used to sign and send the create transaction.
+ *
+ * Prefers a LocalAccount from the wallet client when available to ensure offline
+ * signing (eth_sendRawTransaction) instead of wallet_sendTransaction, which can
+ * error when a `from` field is present.
+ */
+function selectExecutionAccount(
+  walletClient: WalletClient,
+  account?: Account | Address,
+): Account {
+  const selected =
+    (typeof account === "string" ? undefined : account) ?? walletClient.account;
+
+  if (!selected) {
     throw new Error("Account is required");
   }
 
+  return selected;
+}
+
+/**
+ * Simulates, gas-estimates, sends and awaits a single create call, then parses
+ * the deployment from the receipt logs. Shared by {@link createCoin} (factory
+ * call) and {@link createCoinSmartWallet} (smart wallet `execute` call) so both
+ * return the same shape.
+ */
+async function executeCreateContentCall({
+  createContentCall,
+  account,
+  walletClient,
+  publicClient,
+  skipValidateTransaction,
+}: {
+  createContentCall: GenericCall;
+  account: Account;
+  walletClient: WalletClient;
+  publicClient: GenericPublicClient;
+  skipValidateTransaction?: boolean;
+}) {
   const viemCall = {
     ...createContentCall,
-    account: selectedAccount,
+    account,
   };
 
   // simulate call
-  if (!options?.skipValidateTransaction) {
+  if (!skipValidateTransaction) {
     try {
       await publicClient.call(viemCall);
     } catch (err) {
@@ -210,7 +340,7 @@ export async function createCoin({
     }
   }
 
-  const gasEstimate = options?.skipValidateTransaction
+  const gasEstimate = skipValidateTransaction
     ? 10_000_000n
     : await publicClient.estimateGas(viemCall);
   const gasPrice = await publicClient.getGasPrice();
@@ -242,3 +372,127 @@ export async function createCoin({
     chain: getChainFromId(publicClient.chain.id),
   };
 }
+
+// Update createCoin to return both receipt and coin address
+export async function createCoin({
+  call,
+  walletClient,
+  publicClient,
+  options,
+}: {
+  call: CreateCoinArgs;
+  walletClient: WalletClient;
+  publicClient: GenericPublicClient;
+  options?: CreateCoinOptions;
+}) {
+  validateClientNetwork(publicClient);
+
+  const chainId = call.chainId ?? publicClient.chain.id;
+
+  const { calls } = await createCoinCall({
+    ...call,
+    chainId,
+  });
+
+  validateCreateCoinCalls(calls, chainId);
+
+  const createContentCall = calls[0]!;
+
+  const account = selectExecutionAccount(walletClient, options?.account);
+
+  return executeCreateContentCall({
+    createContentCall,
+    account,
+    walletClient,
+    publicClient,
+    skipValidateTransaction: options?.skipValidateTransaction,
+  });
+}
+
+/**
+ * Creates a coin owned by the caller's smart wallet via a user operation.
+ *
+ * Requests smart wallet routing from the API, which resolves the creator's
+ * linked smart wallet and returns the deploy wrapped in the smart wallet's
+ * `execute`. That wrapped call is unwrapped to its inner factory call and
+ * submitted as a user operation through `bundlerClient` — so the smart wallet
+ * deploys and owns the coin while gas is paid from the smart wallet's
+ * user-operation prefund (rather than from an owner EOA). The bundler/account
+ * re-wraps the inner call in `execute` itself, and the smart wallet remains
+ * `msg.sender`, so the deployed coin's CREATE2 address matches the API's
+ * prediction.
+ *
+ * Mirrors {@link createCoin}'s return shape. Throws if the API did not apply
+ * routing (e.g. the creator has no linked smart wallet) — use {@link createCoin}
+ * for EOA creation in that case.
+ */
+export async function createCoinSmartWallet({
+  call,
+  bundlerClient,
+  publicClient,
+}: {
+  call: CreateCoinArgs;
+  bundlerClient: BundlerClient;
+  publicClient: GenericPublicClient;
+  // `options` is accepted for signature parity with createCoin but does not
+  // apply to the user-operation path: the account comes from the bundler client,
+  // and gas/validation are handled by the bundler during preparation.
+  options?: CreateCoinOptions;
+}) {
+  validateClientNetwork(publicClient);
+
+  const account = bundlerClient.account;
+  if (!account) {
+    throw new Error("Account is required: the bundler client has no account");
+  }
+
+  const chainId = call.chainId ?? publicClient.chain.id;
+
+  const { calls, usedSmartWalletRouting } = await createCoinCall({
+    ...call,
+    chainId,
+    enableSmartWalletRouting: true,
+  });
+
+  validateCreateCoinSmartWalletCalls(calls, { usedSmartWalletRouting });
+
+  // Unwrap the routed `execute` call so the bundler re-wraps the inner call
+  // itself instead of double-wrapping (see unwrapSmartWalletExecuteCall).
+  const innerCall = unwrapSmartWalletExecuteCall(calls[0]!);
+
+  const userOperation = await prepareUserOperation({
+    bundlerClient,
+    account,
+    calls: toUserOperationCalls([innerCall]),
+  });
+
+  const userOpReceipt = await submitUserOperation({
+    bundlerClient,
+    account,
+    userOperation,
+  });
+
+  if (!userOpReceipt.success) {
+    throw new Error(
+      `User operation reverted${userOpReceipt.reason ? `: ${userOpReceipt.reason}` : ""}`,
+    );
+  }
+
+  // Parse the deployment from this user operation's own logs (not the whole
+  // bundle's), so a co-bundled CoinCreatedV4 can't be misattributed.
+  const eventLogs = parseEventLogs({
+    abi: zoraFactoryImplABI,
+    logs: userOpReceipt.logs,
+  });
+  const deployment = eventLogs.find(
+    (log) => log.eventName === "CoinCreatedV4",
+  )?.args;
+
+  return {
+    hash: userOpReceipt.receipt.transactionHash,
+    receipt: userOpReceipt.receipt,
+    address: deployment?.coin,
+    deployment,
+    chain: getChainFromId(publicClient.chain.id),
+  };
+}