@zoralabs/coins-sdk 0.2.4 → 0.2.6

package/dist/index.js

@@ -532,6 +532,9 @@ async function updatePayoutRecipient(args, walletClient, publicClient) {
   return { hash, receipt, payoutRecipientUpdated };
 }
 
+// src/actions/tradeCoin.ts
+import { permit2ABI, permit2Address } from "@zoralabs/protocol-deployments";
+
 // src/client/client.gen.ts
 import {
   createClient,
@@ -580,6 +583,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: [
@@ -628,12 +647,173 @@ var getProfileCoins = (options) => {
     ...options
   });
 };
+var postQuote = (options) => {
+  return (options?.client ?? client).post({
+    security: [
+      {
+        name: "api-key",
+        type: "apiKey"
+      }
+    ],
+    url: "/quote",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+};
+
+// src/actions/tradeCoin.ts
+import {
+  erc20Abi as erc20Abi2,
+  maxUint256
+} from "viem";
+import { base as base6 } from "viem/chains";
+function convertBigIntToString(permit) {
+  return {
+    ...permit,
+    details: {
+      ...permit.details,
+      amount: `${permit.details.amount}`
+    },
+    sigDeadline: `${permit.sigDeadline}`
+  };
+}
+var PERMIT_SINGLE_TYPES = {
+  PermitSingle: [
+    { name: "details", type: "PermitDetails" },
+    { name: "spender", type: "address" },
+    { name: "sigDeadline", type: "uint256" }
+  ],
+  PermitDetails: [
+    { name: "token", type: "address" },
+    { name: "amount", type: "uint160" },
+    { name: "expiration", type: "uint48" },
+    { name: "nonce", type: "uint48" }
+  ]
+};
+async function tradeCoin(tradeParameters, walletClient, account, publicClient, validateTransaction = true) {
+  const quote = await createTradeCall(tradeParameters);
+  const signatures = [];
+  if (quote.permits) {
+    for (const permit of quote.permits) {
+      const [, nonce] = await publicClient.readContract({
+        abi: permit2ABI,
+        address: permit2Address[base6.id],
+        functionName: "allowance",
+        args: [
+          permit.permit.details.token,
+          account.address,
+          permit.permit.spender
+        ]
+      });
+      const permitToken = permit.permit.details.token;
+      const allowance = await publicClient.readContract({
+        abi: erc20Abi2,
+        address: permitToken,
+        functionName: "allowance",
+        args: [permitToken, permit2Address[base6.id]]
+      });
+      if (allowance < BigInt(permit.permit.details.amount)) {
+        const approvalTx = await walletClient.writeContract({
+          abi: erc20Abi2,
+          address: permitToken,
+          functionName: "approve",
+          chain: base6,
+          args: [permit2Address[base6.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: base6.id,
+          verifyingContract: permit2Address[base6.id]
+        },
+        primaryType: "PermitSingle",
+        types: PERMIT_SINGLE_TYPES,
+        message,
+        account
+      });
+      signatures.push({
+        signature,
+        permit: convertBigIntToString(message)
+      });
+    }
+  }
+  const newQuote = await createTradeCall({
+    ...tradeParameters,
+    signatures
+  });
+  const call = {
+    to: newQuote.call.target,
+    data: newQuote.call.data,
+    value: BigInt(newQuote.call.value),
+    chain: base6,
+    account
+  };
+  if (validateTransaction) {
+    await publicClient.call(call);
+  }
+  const gasEstimate = validateTransaction ? await publicClient.estimateGas(call) : 10000000n;
+  const gasPrice = await publicClient.getGasPrice();
+  const tx = await walletClient.sendTransaction({
+    ...call,
+    gasPrice,
+    gas: gasEstimate
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: tx
+  });
+  return receipt;
+}
+async function createTradeCall(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");
+  }
+  const quote = await postQuote({
+    body: {
+      tokenIn: tradeParameters.sell,
+      tokenOut: tradeParameters.buy,
+      amountIn: tradeParameters.amountIn.toString(),
+      slippage: tradeParameters.slippage,
+      chainId: base6.id,
+      sender: tradeParameters.sender,
+      recipient: tradeParameters.recipient || tradeParameters.sender,
+      signatures: tradeParameters.signatures
+    }
+  });
+  if (!quote.data) {
+    throw new Error("Quote failed");
+  }
+  return quote.data;
+}
 
 // src/api/api-key.ts
 var apiKey;
 function setApiKey(key) {
   apiKey = key;
 }
+function getApiKey() {
+  return apiKey;
+}
 function getApiKeyMeta() {
   if (!apiKey) {
     return {};
@@ -703,12 +883,233 @@ 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,
+  createTradeCall,
+  createZoraUploaderForCreator,
   getCoin2 as getCoin,
   getCoinComments2 as getCoinComments,
   getCoinCreateFromLogs,
@@ -723,11 +1124,14 @@ export {
   getProfile2 as getProfile,
   getProfileBalances2 as getProfileBalances,
   getProfileCoins2 as getProfileCoins,
+  getURLFromUploadResult,
   setApiKey,
+  tradeCoin,
   updateCoinURI,
   updateCoinURICall,
   updatePayoutRecipient,
   updatePayoutRecipientCall,
+  validateImageMimeType,
   validateMetadataJSON,
   validateMetadataURIContent
 };