@zoralabs/protocol-sdk 0.11.8 → 0.11.10

package/src/secondary/secondary-client.ts

@@ -4,6 +4,8 @@ import {
   zoraCreator1155ImplABI,
   safeTransferSwapAbiParameters,
   secondarySwapABI,
+  callerAndCommenterABI,
+  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { makeContractParameters, PublicClient } from "src/utils";
 import { getUniswapQuote } from "./uniswap/uniswapQuote";
@@ -27,6 +29,8 @@ const ERROR_INSUFFICIENT_POOL_SUPPLY = "Insufficient pool supply";
 const ERROR_SECONDARY_NOT_CONFIGURED =
   "Secondary not configured for given contract and token";
 export const ERROR_SECONDARY_NOT_STARTED = "Secondary market has not started";
+export const ERROR_RECIPIENT_MISMATCH =
+  "Recipient must be the same as the caller if there is a comment";
 
 // Helper function to create error objects
 function makeError(errorMessage: string) {
@@ -46,6 +50,8 @@ type Call =
     };
 
 async function makeBuy({
+  contract,
+  tokenId,
   erc20z,
   poolBalance,
   amount,
@@ -55,8 +61,11 @@ async function makeBuy({
   chainId,
   slippage,
   publicClient,
+  comment,
 }: {
   erc20z: Address;
+  contract: Address;
+  tokenId: bigint;
   poolBalance: { erc20z: bigint };
   amount: bigint;
   quantity: bigint;
@@ -64,27 +73,144 @@ async function makeBuy({
   recipient?: Address;
   chainId: number;
   slippage: number;
+  comment: string | undefined;
   publicClient: PublicClient;
 }): Promise<Call> {
   const costWithSlippage = calculateSlippageUp(amount, slippage);
+  const accountAddress = addressOrAccountAddress(account);
 
-  // we cannot buy all the available tokens in a pool (the quote fails if we try doing that)
-  const availableToBuy = poolBalance.erc20z / BigInt(1e18) - 1n;
+  const validationResult = await validateBuyConditions({
+    poolBalance,
+    quantity,
+    costWithSlippage,
+    accountAddress,
+    publicClient,
+  });
 
-  const accountAddress = addressOrAccountAddress(account);
+  if (validationResult.error) {
+    return makeError(validationResult.error);
+  }
 
+  if (comment && comment !== "") {
+    return handleBuyWithComment({
+      accountAddress,
+      recipient,
+      chainId,
+      quantity,
+      contract,
+      tokenId,
+      costWithSlippage,
+      comment,
+      account,
+    });
+  }
+
+  return handleBuyWithoutComment({
+    erc20z,
+    quantity,
+    recipient,
+    accountAddress,
+    costWithSlippage,
+    chainId,
+    account,
+  });
+}
+
+async function validateBuyConditions({
+  poolBalance,
+  quantity,
+  costWithSlippage,
+  accountAddress,
+  publicClient,
+}: {
+  poolBalance: { erc20z: bigint };
+  quantity: bigint;
+  costWithSlippage: bigint;
+  accountAddress: Address;
+  publicClient: PublicClient;
+}): Promise<{ error?: string }> {
+  const availableToBuy = poolBalance.erc20z / BigInt(1e18) - 1n;
   const availableToSpend = await publicClient.getBalance({
     address: accountAddress,
   });
 
   if (costWithSlippage > availableToSpend) {
-    return makeError(ERROR_INSUFFICIENT_WALLET_FUNDS);
+    return { error: ERROR_INSUFFICIENT_WALLET_FUNDS };
   }
 
   if (availableToBuy < BigInt(quantity)) {
-    return makeError(ERROR_INSUFFICIENT_POOL_SUPPLY);
+    return { error: ERROR_INSUFFICIENT_POOL_SUPPLY };
+  }
+
+  return {};
+}
+
+function handleBuyWithComment({
+  accountAddress,
+  recipient,
+  chainId,
+  quantity,
+  contract,
+  tokenId,
+  costWithSlippage,
+  comment,
+  account,
+}: {
+  accountAddress: Address;
+  recipient?: Address;
+  chainId: number;
+  quantity: bigint;
+  contract: Address;
+  tokenId: bigint;
+  costWithSlippage: bigint;
+  comment: string;
+  account: Address | Account;
+}): Call {
+  if (recipient && recipient !== accountAddress) {
+    return makeError(ERROR_RECIPIENT_MISMATCH);
   }
 
+  return {
+    parameters: makeContractParameters({
+      abi: callerAndCommenterABI,
+      address:
+        callerAndCommenterAddress[
+          chainId as keyof typeof callerAndCommenterAddress
+        ],
+      functionName: "buyOnSecondaryAndComment",
+      args: [
+        accountAddress,
+        quantity,
+        contract,
+        tokenId,
+        accountAddress,
+        costWithSlippage,
+        0n,
+        comment,
+      ],
+      account,
+      value: costWithSlippage,
+    }),
+  };
+}
+
+function handleBuyWithoutComment({
+  erc20z,
+  quantity,
+  recipient,
+  accountAddress,
+  costWithSlippage,
+  chainId,
+  account,
+}: {
+  erc20z: Address;
+  quantity: bigint;
+  recipient?: Address;
+  accountAddress: Address;
+  costWithSlippage: bigint;
+  chainId: number;
+  account: Address | Account;
+}): Call {
   return {
     parameters: makeContractParameters({
       abi: secondarySwapABI,
@@ -99,7 +225,7 @@ async function makeBuy({
         costWithSlippage,
         0n,
       ],
-      account: account,
+      account,
       value: costWithSlippage,
     }),
   };
@@ -125,6 +251,7 @@ export async function buyWithSlippage({
   account,
   slippage = UNISWAP_SLIPPAGE,
   recipient,
+  comment,
 }: BuyWithSlippageInput & {
   chainId: number;
   publicClient: PublicClient;
@@ -159,6 +286,8 @@ export async function buyWithSlippage({
 
   const call = await makeBuy({
     erc20z,
+    contract,
+    tokenId,
     poolBalance,
     amount,
     quantity,
@@ -166,6 +295,7 @@ export async function buyWithSlippage({
     recipient,
     chainId,
     slippage,
+    comment,
     publicClient,
   });
 

package/src/secondary/types.ts

@@ -47,6 +47,8 @@ export type BuyWithSlippageInput = {
   slippage?: number;
   // Optional recipient address (if different from buyer/seller)
   recipient?: Address;
+  // Optional comment to add to the swap
+  comment?: string;
 };
 
 // Same structure as BuyWithSlippageInput

package/src/sparks/sparks-contracts.ts

@@ -338,7 +338,7 @@ const encodePremintOnManager = ({
  * @param chainId - The ID of the chain where the MINTs are to be used
  * @param deadline - The deadline of the permit.
  * @param nonce - Random nonce of the permit.
- * @param tokenIds - The mint token ids to to use
+ * @param tokenIds - The mint token ids to use
  * @param quantities - The quantities of each token to use to collect the Zora Creator 1155 token with.  The sum of these quantities will be the total quantity of the Zora Creator 1155 token collected.
  * @param premint - If this is for a premint, the configuration of the premint to collect
  * @param collect - If this is for a non-premint, the configuration of the non-premint to collect

package/src/sparks/sparks-sponsored-sparks-spender.test.ts

@@ -179,5 +179,6 @@ describe("Sponsored Mints Spender with Relay", () => {
 
       expect(transferReceipt.status).toBe("success");
     },
+    20_000,
   );
 });

package/src/test-utils.ts

@@ -7,8 +7,11 @@ import {
   Hex,
   PublicClient,
   encodeAbiParameters,
+  keccak256,
+  toBytes,
   parseAbiParameters,
 } from "viem";
+import { NewContractParams } from "./create/types";
 import { expect } from "vitest";
 
 export const waitForSuccess = async (hash: Hex, publicClient: PublicClient) => {
@@ -17,6 +20,8 @@ export const waitForSuccess = async (hash: Hex, publicClient: PublicClient) => {
   });
 
   expect(receipt.status).toBe("success");
+
+  return receipt;
 };
 
 export const getFixedPricedMinter = async ({
@@ -37,3 +42,17 @@ export const fixedPriceMinterMinterArguments = ({
 }: {
   mintRecipient: Address;
 }) => encodeAbiParameters(parseAbiParameters("address"), [mintRecipient]);
+
+const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+export function randomNewContract(): NewContractParams {
+  return {
+    name: `testContract-${Math.round(Math.random() * 1_000_000)}`,
+    uri: demoContractMetadataURI,
+  };
+}
+
+export const randomNonce = () =>
+  keccak256(toBytes(Math.round(Math.random() * 1000)));
+export const thirtySecondsFromNow = () =>
+  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;