@zoralabs/coins-sdk 0.2.3 → 0.2.5

package/dist/index.js

@@ -6,6 +6,7 @@ import {
   keccak256 as keccak2562,
   toBytes
 } from "viem";
+import { base as base5, baseSepolia as baseSepolia3 } from "viem/chains";
 
 // src/constants.ts
 import { coinFactoryAddress as zoraFactoryImplAddress } from "@zoralabs/protocol-deployments";
@@ -133,9 +134,6 @@ function getAttribution() {
   return slice(hash, 0, 4);
 }
 
-// src/actions/createCoin.ts
-import { base as base4, baseSepolia as baseSepolia3 } from "viem/chains";
-
 // src/utils/poolConfigUtils.ts
 import { encodeMultiCurvePoolConfig } from "@zoralabs/protocol-deployments";
 import { parseUnits, zeroAddress } from "viem";
@@ -179,12 +177,54 @@ var COIN_ZORA_PAIR_POOL_CONFIG = {
   })
 };
 
+// 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/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 == baseSepolia3.id) {
     throw new Error("ZORA is not supported on Base Sepolia");
@@ -205,17 +245,30 @@ async function createCoinCall({
   owners,
   payoutRecipient,
   currency,
-  chainId = base4.id,
-  platformReferrer = "0x0000000000000000000000000000000000000000"
+  chainId = base5.id,
+  platformReferrer = "0x0000000000000000000000000000000000000000",
+  initialPurchase
 }) {
   if (!owners) {
     owners = [payoutRecipient];
   }
   if (!currency) {
-    currency = chainId !== base4.id ? 2 /* ETH */ : 1 /* ZORA */;
+    currency = chainId !== base5.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",
@@ -228,13 +281,12 @@ async function createCoinCall({
       symbol,
       poolConfig,
       platformReferrer,
-      zeroAddress2,
-      // hookAddress
-      "0x",
-      // hookData
+      deployHook.hook,
+      deployHook.hookData,
       keccak2562(toBytes(Math.random().toString()))
       // coinSalt
     ],
+    value: deployHook.value,
     dataSuffix: getAttribution()
   };
 }
@@ -266,109 +318,17 @@ async function createCoin(call, walletClient, publicClient, options) {
   };
 }
 
-// src/actions/tradeCoin.ts
-import { coinABI } from "@zoralabs/protocol-deployments";
-import {
-  parseEther,
-  zeroAddress as zeroAddress3,
-  parseEventLogs as parseEventLogs2
-} from "viem";
-import { baseSepolia as baseSepolia4 } from "viem/chains";
-var OP_BRIDGE_ADDRESS = "0x4200000000000000000000000000000000000016";
-async function simulateBuy({
-  target,
-  requestedOrderSize,
-  publicClient
-}) {
-  const numberResult = await publicClient.simulateContract({
-    address: target,
-    abi: coinABI,
-    functionName: "buy",
-    dataSuffix: getAttribution(),
-    args: [
-      OP_BRIDGE_ADDRESS,
-      requestedOrderSize,
-      0n,
-      // minAmountOut
-      0n,
-      // sqrtPriceLimitX96
-      zeroAddress3
-      // tradeReferrer
-    ],
-    // We want to ensure that the multicall3 contract has enough ETH to buy in the simulation
-    stateOverride: [
-      {
-        address: baseSepolia4.contracts.multicall3.address,
-        balance: parseEther("10000000")
-      }
-    ]
-  });
-  const orderSize = numberResult.result[0];
-  const amountOut = numberResult.result[1];
-  return { orderSize, amountOut };
-}
-function tradeCoinCall({
-  target,
-  direction,
-  args: {
-    recipient,
-    orderSize,
-    minAmountOut = 0n,
-    sqrtPriceLimitX96 = 0n,
-    tradeReferrer = zeroAddress3
-  }
-}) {
-  return {
-    abi: coinABI,
-    functionName: direction,
-    address: target,
-    args: [
-      recipient,
-      orderSize,
-      minAmountOut,
-      sqrtPriceLimitX96,
-      tradeReferrer
-    ],
-    value: direction === "buy" ? orderSize : 0n
-  };
-}
-function getTradeFromLogs(receipt, direction) {
-  const eventLogs = parseEventLogs2({
-    abi: coinABI,
-    logs: receipt.logs
-  });
-  if (direction === "buy") {
-    return eventLogs.find((log) => log.eventName === "CoinBuy")?.args;
-  }
-  return eventLogs.find((log) => log.eventName === "CoinSell")?.args;
-}
-async function tradeCoin(params, walletClient, publicClient) {
-  validateClientNetwork(publicClient);
-  const { request } = await publicClient.simulateContract({
-    ...tradeCoinCall(params),
-    account: walletClient.account
-  });
-  const hash = await walletClient.writeContract(request);
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const trade = getTradeFromLogs(receipt, params.direction);
-  return {
-    hash,
-    receipt,
-    trade
-  };
-}
-
 // src/actions/getOnchainCoinDetails.ts
-import { coinABI as coinABI2, iUniswapV3PoolABI } from "@zoralabs/protocol-deployments";
+import { coinABI, iUniswapV3PoolABI } from "@zoralabs/protocol-deployments";
 import {
   erc20Abi,
   formatEther,
   isAddressEqual,
-  zeroAddress as zeroAddress4
+  zeroAddress as zeroAddress3
 } from "viem";
 async function getOnchainCoinDetails({
   coin,
-  user = zeroAddress4,
+  user = zeroAddress3,
   publicClient
 }) {
   validateClientNetwork(publicClient);
@@ -377,23 +337,23 @@ async function getOnchainCoinDetails({
       contracts: [
         {
           address: coin,
-          abi: coinABI2,
+          abi: coinABI,
           functionName: "balanceOf",
           args: [user]
         },
         {
           address: coin,
-          abi: coinABI2,
+          abi: coinABI,
           functionName: "poolAddress"
         },
         {
           address: coin,
-          abi: coinABI2,
+          abi: coinABI,
           functionName: "owners"
         },
         {
           address: coin,
-          abi: coinABI2,
+          abi: coinABI,
           functionName: "payoutRecipient"
         }
       ],
@@ -428,7 +388,7 @@ async function getOnchainCoinDetails({
       },
       {
         address: coin,
-        abi: coinABI2,
+        abi: coinABI,
         functionName: "totalSupply"
       },
       {
@@ -504,9 +464,9 @@ function uniswapV3SqrtPriceToBigIntScaled(sqrtPriceX96, token0Decimals, token1De
 }
 
 // src/actions/updateCoinURI.ts
-import { coinABI as coinABI3 } from "@zoralabs/protocol-deployments";
+import { coinABI as coinABI2 } from "@zoralabs/protocol-deployments";
 import {
-  parseEventLogs as parseEventLogs3
+  parseEventLogs as parseEventLogs2
 } from "viem";
 function updateCoinURICall({
   newURI,
@@ -516,7 +476,7 @@ function updateCoinURICall({
     throw new Error("URI needs to be an ipfs:// prefix uri");
   }
   return {
-    abi: coinABI3,
+    abi: coinABI2,
     address: coin,
     functionName: "setContractURI",
     args: [newURI],
@@ -532,7 +492,7 @@ async function updateCoinURI(args, walletClient, publicClient) {
   });
   const hash = await walletClient.writeContract(request);
   const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const eventLogs = parseEventLogs3({ abi: coinABI3, logs: receipt.logs });
+  const eventLogs = parseEventLogs2({ abi: coinABI2, logs: receipt.logs });
   const uriUpdated = eventLogs.find(
     (log) => log.eventName === "ContractURIUpdated"
   );
@@ -540,16 +500,16 @@ async function updateCoinURI(args, walletClient, publicClient) {
 }
 
 // src/actions/updatePayoutRecipient.ts
-import { coinABI as coinABI4 } from "@zoralabs/protocol-deployments";
+import { coinABI as coinABI3 } from "@zoralabs/protocol-deployments";
 import {
-  parseEventLogs as parseEventLogs4
+  parseEventLogs as parseEventLogs3
 } from "viem";
 function updatePayoutRecipientCall({
   newPayoutRecipient,
   coin
 }) {
   return {
-    abi: coinABI4,
+    abi: coinABI3,
     address: coin,
     functionName: "setPayoutRecipient",
     args: [newPayoutRecipient],
@@ -565,7 +525,7 @@ async function updatePayoutRecipient(args, walletClient, publicClient) {
   });
   const hash = await walletClient.writeContract(request);
   const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  const eventLogs = parseEventLogs4({ abi: coinABI4, logs: receipt.logs });
+  const eventLogs = parseEventLogs3({ abi: coinABI3, logs: receipt.logs });
   const payoutRecipientUpdated = eventLogs.find(
     (log) => log.eventName === "CoinPayoutRecipientUpdated"
   );
@@ -620,6 +580,22 @@ var getCoins = (options) => {
     ...options
   });
 };
+var setCreateUploadJwt = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey"
+      }
+    ],
+    url: "/createUploadJWT",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
 var getExplore = (options) => {
   return (options.client ?? client).get({
     security: [
@@ -674,6 +650,9 @@ var apiKey;
 function setApiKey(key) {
   apiKey = key;
 }
+function getApiKey() {
+  return apiKey;
+}
 function getApiKeyMeta() {
   if (!apiKey) {
     return {};
@@ -743,11 +722,232 @@ var getCoinsMostValuable = (query = {}, options) => createExploreQuery(query, "M
 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);
+
+// src/uploader/metadata.ts
+function validateImageMimeType(mimeType) {
+  if (![
+    "image/png",
+    "image/jpeg",
+    "image/jpg",
+    "image/gif",
+    "image/svg+xml"
+  ].includes(mimeType)) {
+    throw new Error("Image must be a PNG, JPEG, JPG, GIF or SVG");
+  }
+}
+function getURLFromUploadResult(uploadResult) {
+  return new URL(uploadResult.url);
+}
+var CoinMetadataBuilder = class {
+  withName(name) {
+    this.name = name;
+    if (typeof name !== "string") {
+      throw new Error("Name must be a string");
+    }
+    return this;
+  }
+  withSymbol(symbol) {
+    this.symbol = symbol;
+    if (typeof symbol !== "string") {
+      throw new Error("Symbol must be a string");
+    }
+    return this;
+  }
+  withDescription(description) {
+    this.description = description;
+    if (typeof description !== "string") {
+      throw new Error("Description must be a string");
+    }
+    return this;
+  }
+  withImage(image) {
+    if (this.imageURL) {
+      throw new Error("Image URL already set");
+    }
+    if (!(image instanceof File)) {
+      throw new Error("Image must be a File");
+    }
+    validateImageMimeType(image.type);
+    this.imageFile = image;
+    return this;
+  }
+  withImageURI(imageURI) {
+    if (this.imageFile) {
+      throw new Error("Image file already set");
+    }
+    if (typeof imageURI !== "string") {
+      throw new Error("Image URI must be a string");
+    }
+    const url = new URL(imageURI);
+    this.imageURL = url;
+    return this;
+  }
+  withProperties(properties) {
+    for (const [key, value] of Object.entries(properties)) {
+      if (typeof key !== "string") {
+        throw new Error("Property key must be a string");
+      }
+      if (typeof value !== "string") {
+        throw new Error("Property value must be a string");
+      }
+    }
+    if (!this.properties) {
+      this.properties = {};
+    }
+    this.properties = { ...this.properties, ...properties };
+    return this;
+  }
+  withMedia(media) {
+    if (this.mediaURL) {
+      throw new Error("Media URL already set");
+    }
+    if (!(media instanceof File)) {
+      throw new Error("Media must be a File");
+    }
+    this.mediaMimeType = media.type;
+    this.mediaFile = media;
+    return this;
+  }
+  withMediaURI(mediaURI, mediaMimeType) {
+    if (this.mediaFile) {
+      throw new Error("Media file already set");
+    }
+    if (typeof mediaURI !== "string") {
+      throw new Error("Media URI must be a string");
+    }
+    const url = new URL(mediaURI);
+    this.mediaURL = url;
+    this.mediaMimeType = mediaMimeType;
+    return this;
+  }
+  validate() {
+    if (!this.name) {
+      throw new Error("Name is required");
+    }
+    if (!this.symbol) {
+      throw new Error("Symbol is required");
+    }
+    if (!this.imageFile && !this.imageURL) {
+      throw new Error("Image is required");
+    }
+    return this;
+  }
+  generateMetadata() {
+    return {
+      name: this.name,
+      symbol: this.symbol,
+      description: this.description,
+      image: this.imageURL.toString(),
+      animation_url: this.mediaURL?.toString(),
+      content: this.mediaURL ? {
+        uri: this.mediaURL?.toString(),
+        mime: this.mediaMimeType
+      } : void 0,
+      properties: this.properties
+    };
+  }
+  async upload(uploader) {
+    this.validate();
+    if (this.imageFile) {
+      const uploadResult2 = await uploader.upload(this.imageFile);
+      this.imageURL = getURLFromUploadResult(uploadResult2);
+    }
+    if (this.mediaFile) {
+      const uploadResult2 = await uploader.upload(this.mediaFile);
+      this.mediaURL = getURLFromUploadResult(uploadResult2);
+    }
+    const metadata = this.generateMetadata();
+    const uploadResult = await uploader.upload(
+      new File([JSON.stringify(metadata)], "metadata.json", {
+        type: "application/json"
+      })
+    );
+    return {
+      url: getURLFromUploadResult(uploadResult).toString(),
+      createMetadataParameters: {
+        name: this.name,
+        symbol: this.symbol,
+        uri: uploadResult.url
+      },
+      metadata
+    };
+  }
+};
+function createMetadataBuilder() {
+  return new CoinMetadataBuilder();
+}
+
+// src/api/internal.ts
+var setCreateUploadJwt2 = async (body, options) => {
+  return await setCreateUploadJwt({
+    body,
+    ...getApiKeyMeta(),
+    ...options
+  });
+};
+
+// src/uploader/providers/zora.ts
+var ZoraUploader = class {
+  constructor(creatorAddress) {
+    this.creatorAddress = creatorAddress;
+    if (!getApiKey()) {
+      throw new Error("API key is required for metadata interactions");
+    }
+  }
+  async getJWTApiKey() {
+    if (this.jwtApiKey && this.jwtApiKeyExpiresAt && this.jwtApiKeyExpiresAt > Date.now()) {
+      return this.jwtApiKey;
+    }
+    this.jwtApiKeyExpiresAt = Date.now() + 1e3 * 60 * 60;
+    const response = await setCreateUploadJwt2({
+      creatorAddress: this.creatorAddress
+    });
+    this.jwtApiKey = response.data?.createUploadJwtFromApiKey;
+    if (!this.jwtApiKey) {
+      throw new Error("Failed to create upload JWT");
+    }
+    return this.jwtApiKey;
+  }
+  async upload(file) {
+    const jwtApiKey = await this.getJWTApiKey();
+    const formData = new FormData();
+    formData.append("file", file, file.name);
+    const response = await fetch(
+      "https://ipfs-uploader.zora.co/api/v0/add?cid-version=1",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${jwtApiKey}`,
+          Accept: "*/*"
+        },
+        body: formData
+      }
+    );
+    if (!response.ok) {
+      console.error(await response.text());
+      throw new Error(`Failed to upload file: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return {
+      url: `ipfs://${data.cid}`,
+      size: data.size,
+      mimeType: data.mimeType
+    };
+  }
+};
+function createZoraUploaderForCreator(creatorAddress) {
+  return new ZoraUploader(creatorAddress);
+}
 export {
+  CoinMetadataBuilder,
   DeployCurrency,
+  InitialPurchaseCurrency,
+  ZoraUploader,
   cleanAndValidateMetadataURI,
   createCoin,
   createCoinCall,
+  createMetadataBuilder,
+  createZoraUploaderForCreator,
   getCoin2 as getCoin,
   getCoinComments2 as getCoinComments,
   getCoinCreateFromLogs,
@@ -762,15 +962,13 @@ export {
   getProfile2 as getProfile,
   getProfileBalances2 as getProfileBalances,
   getProfileCoins2 as getProfileCoins,
-  getTradeFromLogs,
+  getURLFromUploadResult,
   setApiKey,
-  simulateBuy,
-  tradeCoin,
-  tradeCoinCall,
   updateCoinURI,
   updateCoinURICall,
   updatePayoutRecipient,
   updatePayoutRecipientCall,
+  validateImageMimeType,
   validateMetadataJSON,
   validateMetadataURIContent
 };