@zoralabs/coins-sdk 0.2.11 → 0.3.0

package/dist/index.js

@@ -1,26 +1,19 @@
 // src/actions/createCoin.ts
-import { coinFactoryABI as zoraFactoryImplABI } from "@zoralabs/protocol-deployments";
+import {
+  coinFactoryAddress,
+  coinFactoryABI as zoraFactoryImplABI
+} from "@zoralabs/protocol-deployments";
 import {
   parseEventLogs,
-  zeroAddress as zeroAddress2,
-  keccak256 as keccak2562,
-  toBytes
+  isAddressEqual
 } from "viem";
-import { base as base6, baseSepolia as baseSepolia4 } from "viem/chains";
-
-// src/constants.ts
-import { coinFactoryAddress as zoraFactoryImplAddress } from "@zoralabs/protocol-deployments";
-import { base } from "viem/chains";
-var COIN_FACTORY_ADDRESS = zoraFactoryImplAddress["8453"];
-var USDC_WETH_POOLS_BY_CHAIN = {
-  [base.id]: "0xd0b53D9277642d899DF5C87A3966A349A798F224"
-};
+import { base as base3 } from "viem/chains";
 
 // src/utils/validateClientNetwork.ts
-import { base as base2, baseSepolia } from "viem/chains";
+import { base, baseSepolia } from "viem/chains";
 var validateClientNetwork = (publicClient) => {
   const clientChainId = publicClient?.chain?.id;
-  if (clientChainId === base2.id) {
+  if (clientChainId === base.id) {
     return;
   }
   if (clientChainId === baseSepolia.id) {
@@ -126,324 +119,18 @@ async function validateMetadataURIContent(metadataURI) {
   return validateMetadataJSON(metadataJson);
 }
 
-// src/utils/attribution.ts
-import { keccak256, slice, toHex } from "viem";
-function getAttribution() {
-  const hash = keccak256(toHex("api-sdk.zora.engineering"));
-  return slice(hash, 0, 4);
-}
-
-// src/utils/poolConfigUtils.ts
-import { encodeMultiCurvePoolConfig } from "@zoralabs/protocol-deployments";
-import { parseUnits, zeroAddress } from "viem";
-import { base as base3, baseSepolia as baseSepolia2 } from "viem/chains";
-var ZORA_DECIMALS = 18;
-var ZORA_ADDRESS = "0x1111111111166b7fe7bd91427724b487980afc69";
-var COIN_ETH_PAIR_LOWER_TICK = -25e4;
-var COIN_ETH_PAIR_UPPER_TICK = -195e3;
-var COIN_ETH_PAIR_NUM_DISCOVERY_POSITIONS = 11;
-var COIN_ETH_PAIR_MAX_DISCOVERY_SUPPLY_SHARE = parseUnits("0.05", 18);
-var COIN_ETH_PAIR_POOL_CONFIG = {
-  [base3.id]: encodeMultiCurvePoolConfig({
-    currency: zeroAddress,
-    tickLower: [COIN_ETH_PAIR_LOWER_TICK],
-    tickUpper: [COIN_ETH_PAIR_UPPER_TICK],
-    numDiscoveryPositions: [COIN_ETH_PAIR_NUM_DISCOVERY_POSITIONS],
-    maxDiscoverySupplyShare: [COIN_ETH_PAIR_MAX_DISCOVERY_SUPPLY_SHARE]
-  }),
-  [baseSepolia2.id]: encodeMultiCurvePoolConfig({
-    currency: zeroAddress,
-    tickLower: [COIN_ETH_PAIR_LOWER_TICK],
-    tickUpper: [COIN_ETH_PAIR_UPPER_TICK],
-    numDiscoveryPositions: [COIN_ETH_PAIR_NUM_DISCOVERY_POSITIONS],
-    maxDiscoverySupplyShare: [COIN_ETH_PAIR_MAX_DISCOVERY_SUPPLY_SHARE]
-  })
-};
-var COIN_ZORA_PAIR_LOWER_TICK = -138e3;
-var COIN_ZORA_PAIR_UPPER_TICK = -81e3;
-var COIN_ZORA_PAIR_NUM_DISCOVERY_POSITIONS = 11;
-var COIN_ZORA_PAIR_MAX_DISCOVERY_SUPPLY_SHARE = parseUnits(
-  "0.05",
-  ZORA_DECIMALS
-);
-var COIN_ZORA_PAIR_POOL_CONFIG = {
-  [base3.id]: encodeMultiCurvePoolConfig({
-    currency: ZORA_ADDRESS,
-    tickLower: [COIN_ZORA_PAIR_LOWER_TICK],
-    tickUpper: [COIN_ZORA_PAIR_UPPER_TICK],
-    numDiscoveryPositions: [COIN_ZORA_PAIR_NUM_DISCOVERY_POSITIONS],
-    maxDiscoverySupplyShare: [COIN_ZORA_PAIR_MAX_DISCOVERY_SUPPLY_SHARE]
-  })
-};
-
-// src/utils/getPrepurchaseHook.ts
-import {
-  encodeBuySupplyWithMultiHopSwapRouterHookCall,
-  wethAddress
-} from "@zoralabs/protocol-deployments";
-import { concat, pad, toHex as toHex2 } from "viem";
-import { base as base4 } from "viem/chains";
-var BASE_UDSC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var USDC_ZORA_FEE = 3e3;
-var WETH_BASE_FEE = 3e3;
-var encodeFee = (fee) => pad(toHex2(fee), { size: 3 });
-var getPrepurchaseHook = async ({
-  payoutRecipient,
-  initialPurchase,
-  chainId
-}) => {
-  if (initialPurchase.currency !== 1 /* ETH */ && chainId !== base4.id) {
-    throw new Error("Initial purchase currency and/or chain not supported");
-  }
-  const path = concat([
-    wethAddress[base4.id],
-    encodeFee(WETH_BASE_FEE),
-    BASE_UDSC_ADDRESS,
-    encodeFee(USDC_ZORA_FEE),
-    ZORA_ADDRESS
-  ]);
-  return encodeBuySupplyWithMultiHopSwapRouterHookCall({
-    ethValue: initialPurchase.amount,
-    buyRecipient: payoutRecipient,
-    exactInputParams: {
-      path,
-      amountIn: initialPurchase.amount,
-      amountOutMinimum: initialPurchase.amountOutMinimum || 0n
-    },
-    chainId: base4.id
-  });
-};
-
 // src/utils/getChainFromId.ts
-import { base as base5, baseSepolia as baseSepolia3 } from "viem/chains";
+import { base as base2, baseSepolia as baseSepolia2 } from "viem/chains";
 function getChainFromId(chainId) {
-  if (chainId === base5.id) {
-    return base5;
+  if (chainId === base2.id) {
+    return base2;
   }
-  if (chainId === baseSepolia3.id) {
-    return baseSepolia3;
+  if (chainId === baseSepolia2.id) {
+    return baseSepolia2;
   }
   throw new Error(`Chain ID ${chainId} not supported`);
 }
 
-// src/actions/createCoin.ts
-var DeployCurrency = /* @__PURE__ */ ((DeployCurrency2) => {
-  DeployCurrency2[DeployCurrency2["ZORA"] = 1] = "ZORA";
-  DeployCurrency2[DeployCurrency2["ETH"] = 2] = "ETH";
-  return DeployCurrency2;
-})(DeployCurrency || {});
-var InitialPurchaseCurrency = /* @__PURE__ */ ((InitialPurchaseCurrency2) => {
-  InitialPurchaseCurrency2[InitialPurchaseCurrency2["ETH"] = 1] = "ETH";
-  return InitialPurchaseCurrency2;
-})(InitialPurchaseCurrency || {});
-function getPoolConfig(currency, chainId) {
-  if (currency === 1 /* ZORA */ && chainId == baseSepolia4.id) {
-    throw new Error("ZORA is not supported on Base Sepolia");
-  }
-  switch (currency) {
-    case 1 /* ZORA */:
-      return COIN_ZORA_PAIR_POOL_CONFIG[chainId];
-    case 2 /* ETH */:
-      return COIN_ETH_PAIR_POOL_CONFIG[chainId];
-    default:
-      throw new Error("Invalid currency");
-  }
-}
-async function createCoinCall({
-  name,
-  symbol,
-  uri,
-  owners,
-  payoutRecipient,
-  currency,
-  chainId = base6.id,
-  platformReferrer = "0x0000000000000000000000000000000000000000",
-  initialPurchase
-}) {
-  if (!owners) {
-    owners = [payoutRecipient];
-  }
-  if (!currency) {
-    currency = chainId !== base6.id ? 2 /* ETH */ : 1 /* ZORA */;
-  }
-  const poolConfig = getPoolConfig(currency, chainId);
-  await validateMetadataURIContent(uri);
-  let deployHook = {
-    hook: zeroAddress2,
-    hookData: "0x",
-    value: 0n
-  };
-  if (initialPurchase) {
-    deployHook = await getPrepurchaseHook({
-      initialPurchase,
-      payoutRecipient,
-      chainId
-    });
-  }
-  return {
-    abi: zoraFactoryImplABI,
-    functionName: "deploy",
-    address: COIN_FACTORY_ADDRESS,
-    args: [
-      payoutRecipient,
-      owners,
-      uri,
-      name,
-      symbol,
-      poolConfig,
-      platformReferrer,
-      deployHook.hook,
-      deployHook.hookData,
-      keccak2562(toBytes(Math.random().toString()))
-      // coinSalt
-    ],
-    value: deployHook.value,
-    dataSuffix: getAttribution()
-  };
-}
-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 createCoinRequest = await createCoinCall(call);
-  const { request } = await publicClient.simulateContract({
-    ...createCoinRequest,
-    account: options?.account ?? walletClient.account
-  });
-  if (request.gas) {
-    request.gas = request.gas * BigInt(options?.gasMultiplier ?? 100) / 100n;
-  }
-  const hash = await walletClient.writeContract(request);
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const deployment = getCoinCreateFromLogs(receipt);
-  return {
-    hash,
-    receipt,
-    address: deployment?.coin,
-    deployment,
-    chain: getChainFromId(publicClient.chain.id)
-  };
-}
-
-// src/actions/getOnchainCoinDetails.ts
-import { coinABI } from "@zoralabs/protocol-deployments";
-import { zeroAddress as zeroAddress3 } from "viem";
-async function getOnchainCoinDetails({
-  coin,
-  user = zeroAddress3,
-  publicClient
-}) {
-  validateClientNetwork(publicClient);
-  const [balance, owners, payoutRecipient] = await publicClient.multicall({
-    contracts: [
-      {
-        address: coin,
-        abi: coinABI,
-        functionName: "balanceOf",
-        args: [user]
-      },
-      {
-        address: coin,
-        abi: coinABI,
-        functionName: "owners"
-      },
-      {
-        address: coin,
-        abi: coinABI,
-        functionName: "payoutRecipient"
-      }
-    ],
-    allowFailure: false
-  });
-  return {
-    balance,
-    owners,
-    payoutRecipient
-  };
-}
-
-// src/actions/updateCoinURI.ts
-import { coinABI as coinABI2 } from "@zoralabs/protocol-deployments";
-import {
-  parseEventLogs as parseEventLogs2
-} from "viem";
-function updateCoinURICall({
-  newURI,
-  coin
-}) {
-  if (!newURI.startsWith("ipfs://")) {
-    throw new Error("URI needs to be an ipfs:// prefix uri");
-  }
-  return {
-    abi: coinABI2,
-    address: coin,
-    functionName: "setContractURI",
-    args: [newURI],
-    dataSuffix: getAttribution()
-  };
-}
-async function updateCoinURI(args, walletClient, publicClient) {
-  validateClientNetwork(publicClient);
-  const call = updateCoinURICall(args);
-  const { request } = await publicClient.simulateContract({
-    ...call,
-    account: walletClient.account
-  });
-  const hash = await walletClient.writeContract(request);
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const eventLogs = parseEventLogs2({ abi: coinABI2, logs: receipt.logs });
-  const uriUpdated = eventLogs.find(
-    (log) => log.eventName === "ContractURIUpdated"
-  );
-  return { hash, receipt, uriUpdated };
-}
-
-// src/actions/updatePayoutRecipient.ts
-import { coinABI as coinABI3 } from "@zoralabs/protocol-deployments";
-import {
-  parseEventLogs as parseEventLogs3
-} from "viem";
-function updatePayoutRecipientCall({
-  newPayoutRecipient,
-  coin
-}) {
-  return {
-    abi: coinABI3,
-    address: coin,
-    functionName: "setPayoutRecipient",
-    args: [newPayoutRecipient],
-    dataSuffix: getAttribution()
-  };
-}
-async function updatePayoutRecipient(args, walletClient, publicClient) {
-  validateClientNetwork(publicClient);
-  const call = updatePayoutRecipientCall(args);
-  const { request } = await publicClient.simulateContract({
-    ...call,
-    account: walletClient.account
-  });
-  const hash = await walletClient.writeContract(request);
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const eventLogs = parseEventLogs3({ abi: coinABI3, logs: receipt.logs });
-  const payoutRecipientUpdated = eventLogs.find(
-    (log) => log.eventName === "CoinPayoutRecipientUpdated"
-  );
-  return { hash, receipt, payoutRecipientUpdated };
-}
-
-// src/actions/tradeCoin.ts
-import { permit2ABI, permit2Address } from "@zoralabs/protocol-deployments";
-import {
-  erc20Abi,
-  maxUint256
-} from "viem";
-import { base as base7 } from "viem/chains";
-
 // src/client/client.gen.ts
 import {
   createClient,
@@ -596,8 +283,369 @@ var postQuote = (options) => {
     }
   });
 };
+var postCreateContent = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey"
+      }
+    ],
+    url: "/create/content",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+
+// src/api/api-key.ts
+var apiKey;
+function setApiKey(key) {
+  apiKey = key;
+}
+function getApiKey() {
+  return apiKey;
+}
+function getApiKeyMeta() {
+  if (!apiKey) {
+    return {};
+  }
+  return {
+    headers: {
+      "api-key": apiKey
+    }
+  };
+}
+
+// src/api/explore.ts
+var createExploreQuery = (query, listType, options) => getExplore({
+  ...options,
+  query: { ...query, listType },
+  ...getApiKeyMeta()
+});
+var getCoinsTopGainers = (query = {}, options) => createExploreQuery(query, "TOP_GAINERS", options);
+var getCoinsTopVolume24h = (query = {}, options) => createExploreQuery(query, "TOP_VOLUME_24H", options);
+var getCoinsMostValuable = (query = {}, options) => createExploreQuery(query, "MOST_VALUABLE", options);
+var getCoinsNew = (query = {}, options) => createExploreQuery(query, "NEW", options);
+var getCoinsLastTraded = (query = {}, options) => createExploreQuery(query, "LAST_TRADED", options);
+var getCoinsLastTradedUnique = (query = {}, options) => createExploreQuery(query, "LAST_TRADED_UNIQUE", options);
+var getCreatorCoins = (query = {}, options) => createExploreQuery(query, "NEW_CREATORS", options);
+var getMostValuableCreatorCoins = (query = {}, options) => createExploreQuery(query, "MOST_VALUABLE_CREATORS", options);
+
+// src/api/queries.ts
+var getCoin2 = async (query, options) => {
+  return await getCoin({
+    ...options,
+    query,
+    ...getApiKeyMeta()
+  });
+};
+var getCoins2 = async (query, options) => {
+  return await getCoins({
+    query: {
+      coins: query.coins.map((coinData) => JSON.stringify(coinData))
+    },
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getCoinHolders2 = async (query, options) => {
+  return await getCoinHolders({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getCoinSwaps2 = async (query, options) => {
+  return await getCoinSwaps({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getCoinComments2 = async (query, options) => {
+  return await getCoinComments({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getProfile2 = async (query, options) => {
+  return await getProfile({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getProfileCoins2 = async (query, options) => {
+  return await getProfileCoins({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+var getProfileBalances2 = async (query, options) => {
+  return await getProfileBalances({
+    query,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+
+// src/api/create.ts
+var postCreateContent2 = async (body, options) => {
+  return await postCreateContent({
+    ...options,
+    body,
+    ...getApiKeyMeta()
+  });
+};
+
+// src/utils/rethrowDecodedRevert.ts
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  decodeErrorResult
+} from "viem";
+function rethrowDecodedRevert(err, abi) {
+  if (err instanceof BaseError) {
+    const revertError = err.walk(
+      (e) => e instanceof ContractFunctionRevertedError
+    );
+    if (revertError instanceof ContractFunctionRevertedError) {
+      try {
+        const revertData = typeof revertError.data === "object" && revertError.data !== null && "data" in revertError.data ? revertError.data.data : revertError.data;
+        const decoded = decodeErrorResult({
+          abi,
+          data: revertData
+        });
+        const name = decoded.errorName;
+        const args = decoded.args;
+        const message = Array.isArray(args) && args.length > 0 ? `${name}(${args.map((a) => String(a)).join(", ")})` : name;
+        throw new Error(`Create coin transaction reverted: ${message}`);
+      } catch {
+        const errorName = revertError.data?.errorName;
+        if (errorName) {
+          const args = revertError.data?.args;
+          const message = Array.isArray(args) && args.length > 0 ? `${errorName}(${args.map((a) => String(a)).join(", ")})` : errorName;
+          throw new Error(`Create coin transaction reverted: ${message}`);
+        }
+      }
+    }
+  }
+  throw err;
+}
+
+// src/actions/createCoin.ts
+var STARTING_MARKET_CAPS = {
+  LOW: "LOW",
+  HIGH: "HIGH"
+};
+var CONTENT_COIN_CURRENCIES = {
+  CREATOR_COIN: "CREATOR_COIN",
+  ZORA: "ZORA",
+  ETH: "ETH",
+  CREATOR_COIN_OR_ZORA: "CREATOR_COIN_OR_ZORA"
+};
+var CreateConstants = {
+  StartingMarketCaps: STARTING_MARKET_CAPS,
+  ContentCoinCurrencies: CONTENT_COIN_CURRENCIES
+};
+async function createCoinCall({
+  creator,
+  name,
+  symbol,
+  metadata,
+  currency,
+  chainId = base3.id,
+  payoutRecipientOverride,
+  additionalOwners,
+  platformReferrer,
+  skipMetadataValidation = false
+}) {
+  if (!skipMetadataValidation) {
+    await validateMetadataURIContent(metadata.uri);
+  }
+  const createContentRequest = await postCreateContent2({
+    currency,
+    chainId,
+    metadata,
+    creator,
+    name,
+    symbol,
+    platformReferrer,
+    additionalOwners,
+    payoutRecipientOverride
+  });
+  if (!createContentRequest.data?.calls) {
+    throw new Error("Failed to create content calldata");
+  }
+  return createContentRequest.data.calls.map((data) => ({
+    to: data.to,
+    data: data.data,
+    value: BigInt(data.value)
+  }));
+}
+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 callRequest = await createCoinCall(call);
+  if (callRequest.length !== 1) {
+    throw new Error("Only one call is supported for this SDK version");
+  }
+  const createContentCall = callRequest[0];
+  if (!createContentCall) {
+    throw new Error("Failed to load create content calldata from API");
+  }
+  const coinFactoryAddressForChain = coinFactoryAddress[call.chainId];
+  if (!isAddressEqual(createContentCall.to, coinFactoryAddressForChain)) {
+    throw new Error("Creator coin is not supported for this SDK version");
+  }
+  if (createContentCall.value !== 0n) {
+    throw new Error(
+      "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) {
+    throw new Error("Account is required");
+  }
+  const viemCall = {
+    ...createContentCall,
+    account: selectedAccount
+  };
+  if (!options?.skipValidateTransaction) {
+    try {
+      await publicClient.call(viemCall);
+    } catch (err) {
+      rethrowDecodedRevert(err, zoraFactoryImplABI);
+    }
+  }
+  const gasEstimate = options?.skipValidateTransaction ? 10000000n : await publicClient.estimateGas(viemCall);
+  const gasPrice = await publicClient.getGasPrice();
+  const hash = await (async () => {
+    try {
+      return await walletClient.sendTransaction({
+        ...viemCall,
+        gasPrice,
+        gas: gasEstimate,
+        chain: publicClient.chain
+      });
+    } catch (err) {
+      rethrowDecodedRevert(err, zoraFactoryImplABI);
+    }
+  })();
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash
+  });
+  const deployment = getCoinCreateFromLogs(receipt);
+  return {
+    hash,
+    receipt,
+    address: deployment?.coin,
+    deployment,
+    chain: getChainFromId(publicClient.chain.id)
+  };
+}
+
+// src/actions/updateCoinURI.ts
+import { coinABI } from "@zoralabs/protocol-deployments";
+import {
+  parseEventLogs as parseEventLogs2
+} from "viem";
+
+// src/utils/attribution.ts
+import { keccak256, slice, toHex } from "viem";
+function getAttribution() {
+  const hash = keccak256(toHex("api-sdk.zora.engineering"));
+  return slice(hash, 0, 4);
+}
+
+// src/actions/updateCoinURI.ts
+function updateCoinURICall({
+  newURI,
+  coin
+}) {
+  if (!newURI.startsWith("ipfs://")) {
+    throw new Error("URI needs to be an ipfs:// prefix uri");
+  }
+  return {
+    abi: coinABI,
+    address: coin,
+    functionName: "setContractURI",
+    args: [newURI],
+    dataSuffix: getAttribution()
+  };
+}
+async function updateCoinURI(args, walletClient, publicClient) {
+  validateClientNetwork(publicClient);
+  const call = updateCoinURICall(args);
+  const { request } = await publicClient.simulateContract({
+    ...call,
+    account: walletClient.account
+  });
+  const hash = await walletClient.writeContract(request);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const eventLogs = parseEventLogs2({ abi: coinABI, logs: receipt.logs });
+  const uriUpdated = eventLogs.find(
+    (log) => log.eventName === "ContractURIUpdated"
+  );
+  return { hash, receipt, uriUpdated };
+}
+
+// src/actions/updatePayoutRecipient.ts
+import { coinABI as coinABI2 } from "@zoralabs/protocol-deployments";
+import {
+  parseEventLogs as parseEventLogs3
+} from "viem";
+function updatePayoutRecipientCall({
+  newPayoutRecipient,
+  coin
+}) {
+  return {
+    abi: coinABI2,
+    address: coin,
+    functionName: "setPayoutRecipient",
+    args: [newPayoutRecipient],
+    dataSuffix: getAttribution()
+  };
+}
+async function updatePayoutRecipient(args, walletClient, publicClient) {
+  validateClientNetwork(publicClient);
+  const call = updatePayoutRecipientCall(args);
+  const { request } = await publicClient.simulateContract({
+    ...call,
+    account: walletClient.account
+  });
+  const hash = await walletClient.writeContract(request);
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  const eventLogs = parseEventLogs3({ abi: coinABI2, logs: receipt.logs });
+  const payoutRecipientUpdated = eventLogs.find(
+    (log) => log.eventName === "CoinPayoutRecipientUpdated"
+  );
+  return { hash, receipt, payoutRecipientUpdated };
+}
 
 // src/actions/tradeCoin.ts
+import { permit2ABI, permit2Address } from "@zoralabs/protocol-deployments";
+import {
+  erc20Abi,
+  maxUint256
+} from "viem";
+import { base as base4 } from "viem/chains";
 function convertBigIntToString(permit) {
   return {
     ...permit,
@@ -643,7 +691,7 @@ async function tradeCoin({
     for (const permit of quote.permits) {
       const [, , nonce] = await publicClient.readContract({
         abi: permit2ABI,
-        address: permit2Address[base7.id],
+        address: permit2Address[base4.id],
         functionName: "allowance",
         args: [
           permit.permit.details.token,
@@ -658,7 +706,7 @@ async function tradeCoin({
         functionName: "allowance",
         args: [
           typeof account === "string" ? account : account.address,
-          permit2Address[base7.id]
+          permit2Address[base4.id]
         ]
       });
       if (allowance < BigInt(permit.permit.details.amount)) {
@@ -666,8 +714,8 @@ async function tradeCoin({
           abi: erc20Abi,
           address: permitToken,
           functionName: "approve",
-          chain: base7,
-          args: [permit2Address[base7.id], maxUint256],
+          chain: base4,
+          args: [permit2Address[base4.id], maxUint256],
           account
         });
         await publicClient.waitForTransactionReceipt({
@@ -687,8 +735,8 @@ async function tradeCoin({
       const signature = await walletClient.signTypedData({
         domain: {
           name: "Permit2",
-          chainId: base7.id,
-          verifyingContract: permit2Address[base7.id]
+          chainId: base4.id,
+          verifyingContract: permit2Address[base4.id]
         },
         primaryType: "PermitSingle",
         types: PERMIT_SINGLE_TYPES,
@@ -709,7 +757,7 @@ async function tradeCoin({
     to: newQuote.call.target,
     data: newQuote.call.data,
     value: BigInt(newQuote.call.value),
-    chain: base7,
+    chain: base4,
     account
   };
   if (validateTransaction) {
@@ -740,7 +788,7 @@ async function createTradeCall(tradeParameters) {
       tokenOut: tradeParameters.buy,
       amountIn: tradeParameters.amountIn.toString(),
       slippage: tradeParameters.slippage,
-      chainId: base7.id,
+      chainId: base4.id,
       sender: tradeParameters.sender,
       recipient: tradeParameters.recipient || tradeParameters.sender,
       signatures: tradeParameters.signatures
@@ -753,100 +801,6 @@ async function createTradeCall(tradeParameters) {
   return quote.data;
 }
 
-// src/api/api-key.ts
-var apiKey;
-function setApiKey(key) {
-  apiKey = key;
-}
-function getApiKey() {
-  return apiKey;
-}
-function getApiKeyMeta() {
-  if (!apiKey) {
-    return {};
-  }
-  return {
-    headers: {
-      "api-key": apiKey
-    }
-  };
-}
-
-// src/api/queries.ts
-var getCoin2 = async (query, options) => {
-  return await getCoin({
-    ...options,
-    query,
-    ...getApiKeyMeta()
-  });
-};
-var getCoins2 = async (query, options) => {
-  return await getCoins({
-    query: {
-      coins: query.coins.map((coinData) => JSON.stringify(coinData))
-    },
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getCoinHolders2 = async (query, options) => {
-  return await getCoinHolders({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getCoinSwaps2 = async (query, options) => {
-  return await getCoinSwaps({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getCoinComments2 = async (query, options) => {
-  return await getCoinComments({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getProfile2 = async (query, options) => {
-  return await getProfile({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getProfileCoins2 = async (query, options) => {
-  return await getProfileCoins({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-var getProfileBalances2 = async (query, options) => {
-  return await getProfileBalances({
-    query,
-    ...getApiKeyMeta(),
-    ...options
-  });
-};
-
-// src/api/explore.ts
-var createExploreQuery = (query, listType, options) => getExplore({
-  ...options,
-  query: { ...query, listType },
-  ...getApiKeyMeta()
-});
-var getCoinsTopGainers = (query = {}, options) => createExploreQuery(query, "TOP_GAINERS", options);
-var getCoinsTopVolume24h = (query = {}, options) => createExploreQuery(query, "TOP_VOLUME_24H", options);
-var getCoinsMostValuable = (query = {}, options) => createExploreQuery(query, "MOST_VALUABLE", options);
-var getCoinsNew = (query = {}, options) => createExploreQuery(query, "NEW", options);
-var getCoinsLastTraded = (query = {}, options) => createExploreQuery(query, "LAST_TRADED", options);
-var getCoinsLastTradedUnique = (query = {}, options) => createExploreQuery(query, "LAST_TRADED_UNIQUE", options);
-var getCreatorCoins = (query = {}, options) => createExploreQuery(query, "NEW_CREATORS", options);
-var getMostValuableCreatorCoins = (query = {}, options) => createExploreQuery(query, "MOST_VALUABLE_CREATORS", options);
-
 // src/uploader/metadata.ts
 function validateImageMimeType(mimeType) {
   if (![
@@ -991,7 +945,10 @@ var CoinMetadataBuilder = class {
       createMetadataParameters: {
         name: this.name,
         symbol: this.symbol,
-        uri: uploadResult.url
+        metadata: {
+          type: "RAW_URI",
+          uri: uploadResult.url
+        }
       },
       metadata
     };
@@ -1064,8 +1021,7 @@ function createZoraUploaderForCreator(creatorAddress) {
 }
 export {
   CoinMetadataBuilder,
-  DeployCurrency,
-  InitialPurchaseCurrency,
+  CreateConstants,
   ZoraUploader,
   cleanAndValidateMetadataURI,
   createCoin,
@@ -1087,7 +1043,6 @@ export {
   getCoinsTopVolume24h,
   getCreatorCoins,
   getMostValuableCreatorCoins,
-  getOnchainCoinDetails,
   getProfile2 as getProfile,
   getProfileBalances2 as getProfileBalances,
   getProfileCoins2 as getProfileCoins,