@zoralabs/coins-sdk 0.6.0 → 0.7.1

package/dist/index.js

@@ -4,133 +4,12 @@ import {
   coinFactoryABI as zoraFactoryImplABI
 } from "@zoralabs/protocol-deployments";
 import {
-  parseEventLogs,
-  isAddressEqual
+  decodeFunctionData,
+  isAddressEqual,
+  parseEventLogs
 } from "viem";
 import { base as base3 } from "viem/chains";
 
-// src/utils/validateClientNetwork.ts
-import { base, baseSepolia } from "viem/chains";
-var validateClientNetwork = (publicClient) => {
-  const clientChainId = publicClient?.chain?.id;
-  if (clientChainId === base.id) {
-    return;
-  }
-  if (clientChainId === baseSepolia.id) {
-    return;
-  }
-  throw new Error(
-    "Client network needs to be base or baseSepolia for current coin deployments."
-  );
-};
-
-// src/metadata/cleanAndValidateMetadataURI.ts
-function cleanAndValidateMetadataURI(uri) {
-  if (uri.startsWith("ipfs://")) {
-    return uri.replace(
-      "ipfs://",
-      "https://magic.decentralized-content.com/ipfs/"
-    );
-  }
-  if (uri.startsWith("ar://")) {
-    return uri.replace("ar://", "http://arweave.net/");
-  }
-  if (uri.startsWith("data:")) {
-    return uri;
-  }
-  if (uri.startsWith("http://") || uri.startsWith("https://")) {
-    return uri;
-  }
-  throw new Error("Invalid metadata URI");
-}
-
-// src/metadata/validateMetadataJSON.ts
-function validateURIString(uri) {
-  if (typeof uri !== "string") {
-    throw new Error("URI must be a string");
-  }
-  if (uri.startsWith("ipfs://")) {
-    return true;
-  }
-  if (uri.startsWith("ar://")) {
-    return true;
-  }
-  if (uri.startsWith("https://")) {
-    return true;
-  }
-  if (uri.startsWith("data:")) {
-    return true;
-  }
-  return false;
-}
-function validateMetadataJSON(metadata) {
-  if (typeof metadata !== "object" || !metadata) {
-    throw new Error("Metadata must be an object and exist");
-  }
-  if (typeof metadata.name !== "string") {
-    throw new Error("Metadata name is required and must be a string");
-  }
-  if (typeof metadata.description !== "string") {
-    throw new Error("Metadata description is required and must be a string");
-  }
-  if (typeof metadata.image === "string") {
-    if (!validateURIString(metadata.image)) {
-      throw new Error("Metadata image is not a valid URI");
-    }
-  } else {
-    throw new Error("Metadata image is required and must be a string");
-  }
-  if ("animation_url" in metadata) {
-    if (typeof metadata.animation_url !== "string") {
-      throw new Error("Metadata animation_url, if provided, must be a string");
-    }
-    if (!validateURIString(metadata.animation_url)) {
-      throw new Error("Metadata animation_url is not a valid URI");
-    }
-  }
-  const content = "content" in metadata && metadata.content;
-  if (content) {
-    if (typeof content.uri !== "string") {
-      throw new Error("If provided, content.uri must be a string");
-    }
-    if (!validateURIString(content.uri)) {
-      throw new Error("If provided, content.uri must be a valid URI string");
-    }
-    if (typeof content.mime !== "string") {
-      throw new Error("If provided, content.mime must be a string");
-    }
-  }
-  return true;
-}
-
-// src/metadata/validateMetadataURIContent.ts
-async function validateMetadataURIContent(metadataURI) {
-  const cleanedURI = cleanAndValidateMetadataURI(metadataURI);
-  const response = await fetch(cleanedURI);
-  if (!response.ok) {
-    throw new Error("Metadata fetch failed");
-  }
-  if (!["application/json", "text/plain"].includes(
-    response.headers.get("content-type") ?? ""
-  )) {
-    throw new Error("Metadata is not a valid JSON or plain text response type");
-  }
-  const metadataJson = await response.json();
-  return validateMetadataJSON(metadataJson);
-}
-
-// src/utils/getChainFromId.ts
-import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
-function getChainFromId(chainId) {
-  if (chainId === base2.id) {
-    return base2;
-  }
-  if (chainId === baseSepolia2.id) {
-    return baseSepolia2;
-  }
-  throw new Error(`Chain ID ${chainId} not supported`);
-}
-
 // src/client/client.gen.ts
 import {
   createClient,
@@ -643,6 +522,160 @@ var getProfileBySocialHandle2 = async (query, options) => {
   });
 };
 
+// src/metadata/cleanAndValidateMetadataURI.ts
+function cleanAndValidateMetadataURI(uri) {
+  if (uri.startsWith("ipfs://")) {
+    return uri.replace(
+      "ipfs://",
+      "https://magic.decentralized-content.com/ipfs/"
+    );
+  }
+  if (uri.startsWith("ar://")) {
+    return uri.replace("ar://", "http://arweave.net/");
+  }
+  if (uri.startsWith("data:")) {
+    return uri;
+  }
+  if (uri.startsWith("http://") || uri.startsWith("https://")) {
+    return uri;
+  }
+  throw new Error("Invalid metadata URI");
+}
+
+// src/metadata/validateMetadataJSON.ts
+function validateURIString(uri) {
+  if (typeof uri !== "string") {
+    throw new Error("URI must be a string");
+  }
+  if (uri.startsWith("ipfs://")) {
+    return true;
+  }
+  if (uri.startsWith("ar://")) {
+    return true;
+  }
+  if (uri.startsWith("https://")) {
+    return true;
+  }
+  if (uri.startsWith("data:")) {
+    return true;
+  }
+  return false;
+}
+function validateMetadataJSON(metadata) {
+  if (typeof metadata !== "object" || !metadata) {
+    throw new Error("Metadata must be an object and exist");
+  }
+  if (typeof metadata.name !== "string") {
+    throw new Error("Metadata name is required and must be a string");
+  }
+  if (typeof metadata.description !== "string") {
+    throw new Error("Metadata description is required and must be a string");
+  }
+  if (typeof metadata.image === "string") {
+    if (!validateURIString(metadata.image)) {
+      throw new Error("Metadata image is not a valid URI");
+    }
+  } else {
+    throw new Error("Metadata image is required and must be a string");
+  }
+  if ("animation_url" in metadata) {
+    if (typeof metadata.animation_url !== "string") {
+      throw new Error("Metadata animation_url, if provided, must be a string");
+    }
+    if (!validateURIString(metadata.animation_url)) {
+      throw new Error("Metadata animation_url is not a valid URI");
+    }
+  }
+  const content = "content" in metadata && metadata.content;
+  if (content) {
+    if (typeof content.uri !== "string") {
+      throw new Error("If provided, content.uri must be a string");
+    }
+    if (!validateURIString(content.uri)) {
+      throw new Error("If provided, content.uri must be a valid URI string");
+    }
+    if (typeof content.mime !== "string") {
+      throw new Error("If provided, content.mime must be a string");
+    }
+  }
+  return true;
+}
+
+// src/metadata/validateMetadataURIContent.ts
+async function validateMetadataURIContent(metadataURI) {
+  let response;
+  const cleanedURI = cleanAndValidateMetadataURI(metadataURI);
+  try {
+    response = await fetch(cleanedURI);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Metadata fetch failed for URL '${cleanedURI}': ${errorMessage}`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Metadata fetch failed for URL '${cleanedURI}': ${response.statusText ? `${response.statusText} (HTTP ${response.status})` : `HTTP ${response.status}`}`
+    );
+  }
+  if (!["application/json", "text/plain"].includes(
+    response.headers.get("content-type") ?? ""
+  )) {
+    throw new Error("Metadata is not a valid JSON or plain text response type");
+  }
+  const metadataJson = await response.json();
+  return validateMetadataJSON(metadataJson);
+}
+
+// src/utils/calls.ts
+import {
+  concatHex,
+  encodeFunctionData
+} from "viem";
+var EMPTY_HEX = "0x";
+var isContractCall = (call) => {
+  return call.address !== void 0 && call.abi !== void 0 && call.functionName !== void 0;
+};
+var isSendCall = (call) => {
+  return !isContractCall(call) && call.to !== void 0;
+};
+function toGenericCall(call) {
+  if (isSendCall(call)) {
+    return {
+      to: call.to,
+      value: call.value ?? 0n,
+      data: EMPTY_HEX
+    };
+  }
+  const { dataSuffix } = call;
+  const callData = encodeFunctionData(call);
+  const data = dataSuffix ? concatHex([callData, dataSuffix]) : callData;
+  return {
+    to: call.address,
+    value: call.value ?? 0n,
+    data
+  };
+}
+function toUserOperationCalls(calls) {
+  return calls.map((call) => ({
+    to: call.to,
+    data: call.data,
+    value: call.value
+  }));
+}
+
+// src/utils/getChainFromId.ts
+import { base, baseSepolia } from "viem/chains";
+function getChainFromId(chainId) {
+  if (chainId === base.id) {
+    return base;
+  }
+  if (chainId === baseSepolia.id) {
+    return baseSepolia;
+  }
+  throw new Error(`Chain ID ${chainId} not supported`);
+}
+
 // src/utils/rethrowDecodedRevert.ts
 import {
   BaseError,
@@ -678,6 +711,89 @@ function rethrowDecodedRevert(err, abi) {
   throw err;
 }
 
+// src/utils/userOperation.ts
+import { formatEther } from "viem";
+var prepareUserOperation = async ({
+  bundlerClient,
+  account,
+  calls
+}) => {
+  const prepared = await bundlerClient.prepareUserOperation({
+    account,
+    calls
+  });
+  return prepared;
+};
+var submitUserOperation = async ({
+  bundlerClient,
+  account,
+  userOperation
+}) => {
+  let hash;
+  const signature = await account.signUserOperation(userOperation);
+  try {
+    hash = await bundlerClient.sendUserOperation({
+      account,
+      ...userOperation,
+      signature
+    });
+  } catch (error) {
+    if (isGasError(error)) {
+      throw new CoinbaseGasError(error);
+    }
+    throw error;
+  }
+  return bundlerClient.waitForUserOperationReceipt({ hash });
+};
+var CoinbaseGasError = class extends Error {
+  constructor(error) {
+    let message;
+    let available;
+    let required;
+    const match = error.details.match(
+      /precheck failed: sender balance and deposit together is (\d+)? but must be at least (\d+)? to pay for this operation/
+    );
+    if (match) {
+      available = match[1] ? BigInt(match[1]) : void 0;
+      required = match[2] ? BigInt(match[2]) : void 0;
+      if (available !== void 0 && required !== void 0) {
+        message = `Insufficient balance. You need at least ${formatEther(required)} ETH to pay for this operation, but you only have ${formatEther(available)} ETH.`;
+      } else if (required !== void 0) {
+        message = `Insufficient balance. Make sure you have at least ${formatEther(required)} ETH in your wallet.`;
+      } else {
+        message = `Insufficient balance. Make sure you have enough ETH to pay for this operation.`;
+      }
+    } else {
+      message = error.details ?? error.message;
+    }
+    super(message);
+    this.cause = error.cause;
+    this.details = error.details;
+    this.available = available;
+    this.required = required;
+  }
+};
+function isGasError(error) {
+  return error.details?.startsWith(
+    "precheck failed: sender balance and deposit together is"
+  ) ?? false;
+}
+
+// src/utils/validateClientNetwork.ts
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
+var validateClientNetwork = (publicClient) => {
+  const clientChainId = publicClient?.chain?.id;
+  if (clientChainId === base2.id) {
+    return;
+  }
+  if (clientChainId === baseSepolia2.id) {
+    return;
+  }
+  throw new Error(
+    "Client network needs to be base or baseSepolia for current coin deployments."
+  );
+};
+
 // src/actions/createCoin.ts
 var STARTING_MARKET_CAPS = {
   LOW: "LOW",
@@ -703,7 +819,8 @@ async function createCoinCall({
   payoutRecipientOverride,
   additionalOwners,
   platformReferrer,
-  skipMetadataValidation = false
+  skipMetadataValidation = false,
+  enableSmartWalletRouting
 }) {
   if (!skipMetadataValidation) {
     await validateMetadataURIContent(metadata.uri);
@@ -717,7 +834,8 @@ async function createCoinCall({
     symbol,
     platformReferrer,
     additionalOwners,
-    payoutRecipientOverride
+    payoutRecipientOverride,
+    enableSmartWalletRouting
   });
   if (!createContentRequest.data?.calls) {
     throw new Error("Failed to create content calldata");
@@ -728,36 +846,19 @@ async function createCoinCall({
       data: data.data,
       value: BigInt(data.value)
     })),
-    predictedCoinAddress: createContentRequest.data.predictedCoinAddress
+    predictedCoinAddress: createContentRequest.data.predictedCoinAddress,
+    usedSmartWalletRouting: createContentRequest.data.usedSmartWalletRouting
   };
 }
-function getCoinCreateFromLogs(receipt) {
-  const eventLogs = parseEventLogs({
-    abi: zoraFactoryImplABI,
-    logs: receipt.logs
-  });
-  return eventLogs.find((log) => log.eventName === "CoinCreatedV4")?.args;
-}
-async function createCoin({
-  call,
-  walletClient,
-  publicClient,
-  options
-}) {
-  validateClientNetwork(publicClient);
-  const chainId = call.chainId ?? publicClient.chain.id;
-  const callRequest = await createCoinCall({
-    ...call,
-    chainId
-  });
-  if (callRequest.calls.length !== 1) {
+function validateCreateCoinCalls(calls, chainId) {
+  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];
+  const coinFactoryAddressForChain = coinFactoryAddress[chainId];
   if (!isAddressEqual(createContentCall.to, coinFactoryAddressForChain)) {
     throw new Error("Creator coin is not supported for this SDK version");
   }
@@ -766,22 +867,87 @@ async function createCoin({
       "Creator coin and purchase is not supported for this SDK version."
     );
   }
-  const selectedAccount = (typeof options?.account === "string" ? void 0 : options?.account) ?? walletClient.account;
-  if (!selectedAccount) {
+}
+function validateCreateCoinSmartWalletCalls(calls, { usedSmartWalletRouting }) {
+  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");
+  }
+  const createContentCall = calls[0];
+  if (!createContentCall) {
+    throw new Error("Failed to load create content calldata from API");
+  }
+  if (createContentCall.value !== 0n) {
+    throw new Error(
+      "Creator coin and purchase is not supported for this SDK version."
+    );
+  }
+}
+function getCoinCreateFromLogs(receipt) {
+  const eventLogs = parseEventLogs({
+    abi: zoraFactoryImplABI,
+    logs: receipt.logs
+  });
+  return eventLogs.find((log) => log.eventName === "CoinCreatedV4")?.args;
+}
+var coinbaseSmartWalletExecuteABI = [
+  {
+    type: "function",
+    name: "execute",
+    stateMutability: "payable",
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+function unwrapSmartWalletExecuteCall(call) {
+  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 };
+}
+function selectExecutionAccount(walletClient, account) {
+  const selected = (typeof account === "string" ? void 0 : account) ?? walletClient.account;
+  if (!selected) {
     throw new Error("Account is required");
   }
+  return selected;
+}
+async function executeCreateContentCall({
+  createContentCall,
+  account,
+  walletClient,
+  publicClient,
+  skipValidateTransaction
+}) {
   const viemCall = {
     ...createContentCall,
-    account: selectedAccount
+    account
   };
-  if (!options?.skipValidateTransaction) {
+  if (!skipValidateTransaction) {
     try {
       await publicClient.call(viemCall);
     } catch (err) {
       rethrowDecodedRevert(err, zoraFactoryImplABI);
     }
   }
-  const gasEstimate = options?.skipValidateTransaction ? 10000000n : await publicClient.estimateGas(viemCall);
+  const gasEstimate = skipValidateTransaction ? 10000000n : await publicClient.estimateGas(viemCall);
   const gasPrice = await publicClient.getGasPrice();
   const hash = await (async () => {
     try {
@@ -807,6 +973,77 @@ async function createCoin({
     chain: getChainFromId(publicClient.chain.id)
   };
 }
+async function createCoin({
+  call,
+  walletClient,
+  publicClient,
+  options
+}) {
+  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
+  });
+}
+async function createCoinSmartWallet({
+  call,
+  bundlerClient,
+  publicClient
+}) {
+  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 });
+  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}` : ""}`
+    );
+  }
+  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)
+  };
+}
 
 // src/actions/updateCoinURI.ts
 import { coinABI } from "@zoralabs/protocol-deployments";
@@ -822,13 +1059,14 @@ function getAttribution() {
 }
 
 // src/actions/updateCoinURI.ts
-function updateCoinURICall({
-  newURI,
-  coin
-}) {
+function validateUpdateCoinURI({ newURI }) {
   if (!newURI.startsWith("ipfs://")) {
     throw new Error("URI needs to be an ipfs:// prefix uri");
   }
+}
+function updateCoinURICall(args) {
+  validateUpdateCoinURI(args);
+  const { coin, newURI } = args;
   return {
     abi: coinABI,
     address: coin,
@@ -852,16 +1090,56 @@ async function updateCoinURI(args, walletClient, publicClient, account) {
   );
   return { hash, receipt, uriUpdated };
 }
+async function updateCoinURISmartWallet(args, bundlerClient, publicClient, account) {
+  const resolvedAccount = account ?? bundlerClient.account;
+  if (!resolvedAccount) {
+    throw new Error("Account is required");
+  }
+  validateClientNetwork(publicClient);
+  const call = updateCoinURICall(args);
+  const calls = toUserOperationCalls([toGenericCall(call)]);
+  const userOp = await prepareUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    calls
+  });
+  const userOpReceipt = await submitUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    userOperation: userOp
+  });
+  if (!userOpReceipt.success) {
+    throw new Error(
+      `User operation reverted${userOpReceipt.reason ? `: ${userOpReceipt.reason}` : ""}`
+    );
+  }
+  const eventLogs = parseEventLogs2({ abi: coinABI, logs: userOpReceipt.logs });
+  const uriUpdated = eventLogs.find(
+    (log) => log.eventName === "ContractURIUpdated"
+  );
+  return {
+    hash: userOpReceipt.receipt.transactionHash,
+    receipt: userOpReceipt.receipt,
+    uriUpdated
+  };
+}
 
 // src/actions/updatePayoutRecipient.ts
 import { coinABI as coinABI2 } from "@zoralabs/protocol-deployments";
 import {
+  isAddress,
   parseEventLogs as parseEventLogs3
 } from "viem";
-function updatePayoutRecipientCall({
-  newPayoutRecipient,
-  coin
+function validateUpdatePayoutRecipient({
+  newPayoutRecipient
 }) {
+  if (!isAddress(newPayoutRecipient)) {
+    throw new Error("Payout recipient must be a valid address");
+  }
+}
+function updatePayoutRecipientCall(args) {
+  validateUpdatePayoutRecipient(args);
+  const { coin, newPayoutRecipient } = args;
   return {
     abi: coinABI2,
     address: coin,
@@ -885,10 +1163,44 @@ async function updatePayoutRecipient(args, walletClient, publicClient, account)
   );
   return { hash, receipt, payoutRecipientUpdated };
 }
+async function updatePayoutRecipientSmartWallet(args, bundlerClient, publicClient, account) {
+  const resolvedAccount = account ?? bundlerClient.account;
+  if (!resolvedAccount) {
+    throw new Error("Account is required");
+  }
+  validateClientNetwork(publicClient);
+  const call = updatePayoutRecipientCall(args);
+  const calls = toUserOperationCalls([toGenericCall(call)]);
+  const userOp = await prepareUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    calls
+  });
+  const userOpReceipt = await submitUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    userOperation: userOp
+  });
+  if (!userOpReceipt.success) {
+    throw new Error(
+      `User operation reverted${userOpReceipt.reason ? `: ${userOpReceipt.reason}` : ""}`
+    );
+  }
+  const eventLogs = parseEventLogs3({ abi: coinABI2, logs: userOpReceipt.logs });
+  const payoutRecipientUpdated = eventLogs.find(
+    (log) => log.eventName === "CoinPayoutRecipientUpdated"
+  );
+  return {
+    hash: userOpReceipt.receipt.transactionHash,
+    receipt: userOpReceipt.receipt,
+    payoutRecipientUpdated
+  };
+}
 
 // src/actions/tradeCoin.ts
 import { permit2ABI, permit2Address } from "@zoralabs/protocol-deployments";
 import {
+  encodeFunctionData as encodeFunctionData2,
   erc20Abi,
   maxUint256
 } from "viem";
@@ -916,6 +1228,73 @@ var PERMIT_SINGLE_TYPES = {
     { name: "nonce", type: "uint48" }
   ]
 };
+async function resolveTradePermits({
+  quote,
+  owner,
+  publicClient,
+  signTypedData
+}) {
+  const signatures = [];
+  const approvalCalls = [];
+  if (!quote.permits) {
+    return { signatures, approvalCalls };
+  }
+  for (const permit of quote.permits) {
+    const [, , nonce] = await publicClient.readContract({
+      abi: permit2ABI,
+      address: permit2Address[base4.id],
+      functionName: "allowance",
+      args: [
+        owner,
+        permit.permit.details.token,
+        permit.permit.spender
+      ]
+    });
+    const permitToken = permit.permit.details.token;
+    const allowance = await publicClient.readContract({
+      abi: erc20Abi,
+      address: permitToken,
+      functionName: "allowance",
+      args: [owner, permit2Address[base4.id]]
+    });
+    if (allowance < BigInt(permit.permit.details.amount)) {
+      approvalCalls.push({
+        to: permitToken,
+        data: encodeFunctionData2({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [permit2Address[base4.id], maxUint256]
+        }),
+        value: 0n
+      });
+    }
+    const message = {
+      details: {
+        token: permit.permit.details.token,
+        amount: BigInt(permit.permit.details.amount),
+        expiration: Number(permit.permit.details.expiration),
+        nonce
+      },
+      spender: permit.permit.spender,
+      sigDeadline: BigInt(permit.permit.sigDeadline)
+    };
+    const signature = await signTypedData({
+      domain: {
+        name: "Permit2",
+        chainId: base4.id,
+        verifyingContract: permit2Address[base4.id]
+      },
+      primaryType: "PermitSingle",
+      types: PERMIT_SINGLE_TYPES,
+      message
+    });
+    signatures.push({
+      signature,
+      permit: convertBigIntToString(message)
+    });
+  }
+  return { signatures, approvalCalls };
+}
 async function tradeCoin({
   tradeParameters,
   walletClient,
@@ -930,71 +1309,24 @@ async function tradeCoin({
   if (!account) {
     throw new Error("Account is required");
   }
+  const resolvedAccount = account;
+  const owner = typeof resolvedAccount === "string" ? resolvedAccount : resolvedAccount.address;
   if (!tradeParameters.recipient) {
-    tradeParameters.recipient = typeof account === "string" ? account : account.address;
+    tradeParameters.recipient = owner;
   }
-  const signatures = [];
-  if (quote.permits) {
-    for (const permit of quote.permits) {
-      const [, , nonce] = await publicClient.readContract({
-        abi: permit2ABI,
-        address: permit2Address[base4.id],
-        functionName: "allowance",
-        args: [
-          typeof account === "string" ? account : account.address,
-          permit.permit.details.token,
-          permit.permit.spender
-        ]
-      });
-      const permitToken = permit.permit.details.token;
-      const allowance = await publicClient.readContract({
-        abi: erc20Abi,
-        address: permitToken,
-        functionName: "allowance",
-        args: [
-          typeof account === "string" ? account : account.address,
-          permit2Address[base4.id]
-        ]
-      });
-      if (allowance < BigInt(permit.permit.details.amount)) {
-        const approvalTx = await walletClient.writeContract({
-          abi: erc20Abi,
-          address: permitToken,
-          functionName: "approve",
-          chain: base4,
-          args: [permit2Address[base4.id], maxUint256],
-          account
-        });
-        await publicClient.waitForTransactionReceipt({
-          hash: approvalTx
-        });
-      }
-      const message = {
-        details: {
-          token: permit.permit.details.token,
-          amount: BigInt(permit.permit.details.amount),
-          expiration: Number(permit.permit.details.expiration),
-          nonce
-        },
-        spender: permit.permit.spender,
-        sigDeadline: BigInt(permit.permit.sigDeadline)
-      };
-      const signature = await walletClient.signTypedData({
-        domain: {
-          name: "Permit2",
-          chainId: base4.id,
-          verifyingContract: permit2Address[base4.id]
-        },
-        primaryType: "PermitSingle",
-        types: PERMIT_SINGLE_TYPES,
-        message,
-        account
-      });
-      signatures.push({
-        signature,
-        permit: convertBigIntToString(message)
-      });
-    }
+  const { signatures, approvalCalls } = await resolveTradePermits({
+    quote,
+    owner,
+    publicClient,
+    signTypedData: (typedData) => walletClient.signTypedData({ ...typedData, account: resolvedAccount })
+  });
+  for (const approvalCall of approvalCalls) {
+    const approvalTx = await walletClient.sendTransaction({
+      ...approvalCall,
+      account: resolvedAccount,
+      chain: base4
+    });
+    await publicClient.waitForTransactionReceipt({ hash: approvalTx });
   }
   const newQuote = await createTradeCall({
     ...tradeParameters,
@@ -1005,7 +1337,7 @@ async function tradeCoin({
     data: newQuote.call.data,
     value: BigInt(newQuote.call.value),
     chain: base4,
-    account
+    account: resolvedAccount
   };
   if (validateTransaction) {
     await publicClient.call(call);
@@ -1022,13 +1354,69 @@ async function tradeCoin({
   });
   return receipt;
 }
-async function createTradeCall(tradeParameters) {
+async function tradeCoinSmartWallet({
+  tradeParameters,
+  bundlerClient,
+  account,
+  publicClient
+}) {
+  const resolvedAccount = account ?? bundlerClient.account;
+  if (!resolvedAccount) {
+    throw new Error("Account is required");
+  }
+  const owner = resolvedAccount.address;
+  const params = {
+    ...tradeParameters,
+    sender: owner,
+    recipient: tradeParameters.recipient ?? owner
+  };
+  const quote = await createTradeCall(params);
+  const { signatures, approvalCalls } = await resolveTradePermits({
+    quote,
+    owner,
+    publicClient,
+    signTypedData: (typedData) => resolvedAccount.signTypedData(typedData)
+  });
+  const newQuote = await createTradeCall({
+    ...params,
+    signatures
+  });
+  const tradeCall = {
+    to: newQuote.call.target,
+    data: newQuote.call.data,
+    value: BigInt(newQuote.call.value)
+  };
+  const calls = toUserOperationCalls([...approvalCalls, tradeCall]);
+  const userOp = await prepareUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    calls
+  });
+  const userOpReceipt = await submitUserOperation({
+    bundlerClient,
+    account: resolvedAccount,
+    userOperation: userOp
+  });
+  if (!userOpReceipt.success) {
+    throw new Error(
+      `User operation reverted${userOpReceipt.reason ? `: ${userOpReceipt.reason}` : ""}`
+    );
+  }
+  return userOpReceipt.receipt;
+}
+function validateTradeParameters(tradeParameters) {
   if (tradeParameters.slippage && tradeParameters.slippage > 1) {
     throw new Error("Slippage must be less than 1, max 0.99");
   }
   if (tradeParameters.amountIn === BigInt(0)) {
     throw new Error("Amount in must be greater than 0");
   }
+}
+async function createTradeCall(tradeParameters) {
+  return createQuote(tradeParameters);
+}
+async function createQuote(tradeParameters) {
+  validateTradeParameters(tradeParameters);
   const quote = await postQuote({
     body: {
       tokenIn: tradeParameters.sell,
@@ -1057,6 +1445,12 @@ async function createTradeCall(tradeParameters) {
 import { createConfig as createConfig2 } from "@hey-api/client-fetch";
 var apiGet = (path, data) => client.get({ url: path, query: data, ...getApiKeyMeta() });
 var apiPost = (path, data) => client.post({ url: path, body: data, ...getApiKeyMeta() });
+var apiUrl = (path) => {
+  const baseUrl = client.getConfig().baseUrl ?? "";
+  const normalizedBase = baseUrl.replace(/\/+$/, "");
+  const normalizedPath = path.replace(/^\/+/, "");
+  return `${normalizedBase}/${normalizedPath}`;
+};
 var setApiBaseUrl = (baseUrl) => {
   client.setConfig(createConfig2({ baseUrl }));
 };
@@ -1309,14 +1703,18 @@ function createZoraUploaderForCreator(creatorAddress) {
 }
 export {
   CoinMetadataBuilder,
+  CoinbaseGasError,
   CreateConstants,
   ZoraUploader,
   apiGet,
   apiPost,
+  apiUrl,
   cleanAndValidateMetadataURI,
   createCoin,
   createCoinCall,
+  createCoinSmartWallet,
   createMetadataBuilder,
+  createQuote,
   createTradeCall,
   createZoraUploaderForCreator,
   getCoin2 as getCoin,
@@ -1363,15 +1761,29 @@ export {
   getTrends,
   getURLFromUploadResult,
   getWalletTradeActivity2 as getWalletTradeActivity,
+  isContractCall,
+  isSendCall,
+  prepareUserOperation,
   setApiBaseUrl,
   setApiKey,
+  submitUserOperation,
+  toGenericCall,
+  toUserOperationCalls,
   tradeCoin,
+  tradeCoinSmartWallet,
   updateCoinURI,
   updateCoinURICall,
+  updateCoinURISmartWallet,
   updatePayoutRecipient,
   updatePayoutRecipientCall,
+  updatePayoutRecipientSmartWallet,
+  validateCreateCoinCalls,
+  validateCreateCoinSmartWalletCalls,
   validateImageMimeType,
   validateMetadataJSON,
-  validateMetadataURIContent
+  validateMetadataURIContent,
+  validateTradeParameters,
+  validateUpdateCoinURI,
+  validateUpdatePayoutRecipient
 };
 //# sourceMappingURL=index.js.map