@zoralabs/protocol-sdk 0.11.6-COMMENTS.0 → 0.11.6

package/src/mint/mint-transactions.ts

@@ -11,8 +11,6 @@ import {
   erc20MinterABI,
   zoraCreator1155ImplABI,
   zoraTimedSaleStrategyABI,
-  callerAndCommenterABI,
-  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { zora721Abi, zora1155LegacyAbi } from "src/constants";
 import {
@@ -34,11 +32,9 @@ import { AllowListEntry } from "src/allow-list/types";
 export function makeOnchainMintCall({
   token,
   mintParams,
-  chainId,
 }: {
   token: Concrete<OnchainSalesConfigAndTokenInfo>;
   mintParams: Omit<MakeMintParametersArgumentsBase, "tokenContract">;
-  chainId: number;
 }): SimulateContractParametersWithAccount {
   if (token.mintType === "721") {
     return makePrepareMint721TokenParams({
@@ -52,7 +48,6 @@ export function makeOnchainMintCall({
     salesConfigAndTokenInfo: token,
     tokenContract: token.contract.address,
     tokenId: token.tokenId!,
-    chainId,
     ...mintParams,
   });
 }
@@ -62,69 +57,6 @@ export type MintableParameters = Pick<
   "contractVersion" | "salesConfig"
 >;
 
-function makeZoraTimedSaleStrategyMintCall({
-  minterAccount,
-  salesConfigAndTokenInfo,
-  mintQuantity,
-  mintTo,
-  tokenContract,
-  tokenId,
-  mintReferral,
-  mintComment,
-  chainId,
-}: {
-  minterAccount: Address | Account;
-  salesConfigAndTokenInfo: Concrete<MintableParameters>;
-  mintQuantity: bigint;
-  mintTo: Address;
-  tokenContract: Address;
-  tokenId: GenericTokenIdTypes;
-  mintReferral?: Address;
-  mintComment?: string;
-  chainId: number;
-}) {
-  // if there is a mint comment, use the caller and commenter
-  if (mintComment && mintComment !== "") {
-    return makeContractParameters({
-      abi: callerAndCommenterABI,
-      address:
-        callerAndCommenterAddress[
-          chainId as keyof typeof callerAndCommenterAddress
-        ],
-      functionName: "timedSaleMintAndComment",
-      account: minterAccount,
-      value:
-        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
-      args: [
-        mintTo,
-        mintQuantity,
-        tokenContract,
-        tokenId,
-        mintReferral || zeroAddress,
-        mintComment,
-      ],
-    });
-  }
-
-  return makeContractParameters({
-    abi: zoraTimedSaleStrategyABI,
-    functionName: "mint",
-    account: minterAccount,
-    address: salesConfigAndTokenInfo.salesConfig.address,
-    value:
-      salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
-    /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
-    args: [
-      mintTo,
-      mintQuantity,
-      tokenContract,
-      BigInt(tokenId),
-      mintReferral || zeroAddress,
-      "",
-    ],
-  });
-}
-
 export function makePrepareMint1155TokenParams({
   tokenContract: tokenContract,
   tokenId,
@@ -135,11 +67,9 @@ export function makePrepareMint1155TokenParams({
   mintRecipient,
   quantityToMint,
   allowListEntry,
-  chainId,
 }: {
   salesConfigAndTokenInfo: Concrete<MintableParameters>;
   tokenId: GenericTokenIdTypes;
-  chainId: number;
 } & Pick<
   MakeMintParametersArgumentsBase,
   | "minterAccount"
@@ -171,16 +101,22 @@ export function makePrepareMint1155TokenParams({
   }
 
   if (saleType === "timed") {
-    return makeZoraTimedSaleStrategyMintCall({
-      minterAccount,
-      salesConfigAndTokenInfo,
-      mintQuantity,
-      mintTo,
-      tokenContract,
-      tokenId,
-      mintReferral,
-      mintComment,
-      chainId,
+    return makeContractParameters({
+      abi: zoraTimedSaleStrategyABI,
+      functionName: "mint",
+      account: minterAccount,
+      address: salesConfigAndTokenInfo.salesConfig.address,
+      value:
+        salesConfigAndTokenInfo.salesConfig.mintFeePerQuantity * mintQuantity,
+      /* args: mintTo, quantity, collection, tokenId, mintReferral, comment */
+      args: [
+        mintTo,
+        mintQuantity,
+        tokenContract,
+        BigInt(tokenId),
+        mintReferral || zeroAddress,
+        mintComment || "",
+      ],
     });
   }
 

package/src/sdk.ts

@@ -116,7 +116,6 @@ export function createCollectorClient(
     publicClient: params.publicClient,
     premintGetter: premintGetterToUse,
     mintGetter: mintGetterToUse,
-    chainId: params.chainId,
   });
   const secondaryClient = new SecondaryClient({
     publicClient: params.publicClient,

package/src/secondary/secondary-client.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, vi } from "vitest";
-import { parseEther, Address, parseEventLogs } from "viem";
+import { parseEther, Address } from "viem";
 import { zoraSepolia } from "viem/chains";
 import {
   forkUrls,
@@ -7,11 +7,7 @@ import {
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
 import { createCollectorClient } from "src/sdk";
-import {
-  zoraCreator1155ImplABI,
-  commentsABI,
-  callerAndCommenterABI,
-} from "@zoralabs/protocol-deployments";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
 import { SubgraphMintGetter } from "src/mint/subgraph-mint-getter";
 import { ERROR_SECONDARY_NOT_STARTED } from "./secondary-client";
 import { ISubgraphQuerier } from "src/apis/subgraph-querier";
@@ -261,116 +257,4 @@ describe("secondary", () => {
     },
     30_000,
   );
-
-  makeAnvilTest({
-    forkBlockNumber: 16123365,
-    forkUrl: forkUrls.zoraSepolia,
-    anvilChainId: zoraSepolia.id,
-  })(
-    "it can buy on secondary with a comment",
-    async ({
-      viemClients: { publicClient, chain, walletClient, testClient },
-    }) => {
-      const collectorAccount = (await walletClient.getAddresses()!)[1]!;
-
-      const mintGetter = new SubgraphMintGetter(chain.id);
-      const contractAddress: Address =
-        "0xd42557f24034b53e7340a40bb5813ef9ba88f2b4";
-      const newTokenId = 4n;
-
-      await testClient.setBalance({
-        address: collectorAccount,
-        value: parseEther("100"),
-      });
-
-      mintGetter.subgraphQuerier.query = vi
-        .fn<ISubgraphQuerier["query"]>()
-        .mockResolvedValue({
-          zoraCreateToken: mockTimedSaleStrategyTokenQueryResult({
-            chainId: chain.id,
-            tokenId: newTokenId,
-            contractAddress,
-            contractVersion:
-              new1155ContractVersion[
-                chain.id as keyof typeof new1155ContractVersion
-              ],
-          }),
-        });
-
-      const collectorClient = createCollectorClient({
-        chainId: chain.id,
-        publicClient,
-        mintGetter,
-      });
-
-      const secondaryInfo = await collectorClient.getSecondaryInfo({
-        contract: contractAddress,
-        tokenId: newTokenId,
-      });
-
-      // mint enough to start the countdown
-      const quantityToMint =
-        secondaryInfo!.minimumMintsForCountdown! - secondaryInfo!.mintCount;
-
-      const { parameters: collectParameters } = await collectorClient.mint({
-        minterAccount: collectorAccount,
-        mintType: "1155",
-        quantityToMint: quantityToMint,
-        tokenId: newTokenId,
-        tokenContract: contractAddress,
-      });
-
-      await simulateAndWriteContractWithRetries({
-        parameters: collectParameters,
-        walletClient,
-        publicClient,
-      });
-
-      await advanceToSaleAndAndLaunchMarket({
-        contractAddress,
-        tokenId: newTokenId,
-        testClient,
-        publicClient,
-        walletClient,
-        collectorClient,
-        chainId: chain.id,
-        account: collectorAccount,
-      });
-
-      const buyResult = await collectorClient.buy1155OnSecondary({
-        account: collectorAccount,
-        quantity: 5n,
-        contract: contractAddress,
-        tokenId: newTokenId,
-        comment: "test comment",
-      });
-
-      const receipt = await simulateAndWriteContractWithRetries({
-        parameters: buyResult.parameters!,
-        walletClient,
-        publicClient,
-      });
-
-      const commentedEvent = parseEventLogs({
-        abi: commentsABI,
-        logs: receipt.logs,
-        eventName: "Commented",
-      });
-
-      expect(commentedEvent[0]).toBeDefined();
-      expect(commentedEvent[0]!.args.text).toBe("test comment");
-
-      const boughtAndCommentedEvent = parseEventLogs({
-        abi: callerAndCommenterABI,
-        logs: receipt.logs,
-        eventName: "SwappedOnSecondaryAndCommented",
-      });
-
-      expect(boughtAndCommentedEvent[0]).toBeDefined();
-      expect(boughtAndCommentedEvent[0]!.args.comment).toBe("test comment");
-      expect(boughtAndCommentedEvent[0]!.args.quantity).toBe(5n);
-      expect(boughtAndCommentedEvent[0]!.args.swapDirection).toBe(0);
-    },
-    20_000,
-  );
 });

package/src/secondary/secondary-client.ts

@@ -4,8 +4,6 @@ import {
   zoraCreator1155ImplABI,
   safeTransferSwapAbiParameters,
   secondarySwapABI,
-  callerAndCommenterABI,
-  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { makeContractParameters, PublicClient } from "src/utils";
 import { getUniswapQuote } from "./uniswap/uniswapQuote";
@@ -29,8 +27,6 @@ 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) {
@@ -50,8 +46,6 @@ type Call =
     };
 
 async function makeBuy({
-  contract,
-  tokenId,
   erc20z,
   poolBalance,
   amount,
@@ -61,11 +55,8 @@ async function makeBuy({
   chainId,
   slippage,
   publicClient,
-  comment,
 }: {
   erc20z: Address;
-  contract: Address;
-  tokenId: bigint;
   poolBalance: { erc20z: bigint };
   amount: bigint;
   quantity: bigint;
@@ -73,144 +64,27 @@ 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);
-
-  const validationResult = await validateBuyConditions({
-    poolBalance,
-    quantity,
-    costWithSlippage,
-    accountAddress,
-    publicClient,
-  });
-
-  if (validationResult.error) {
-    return makeError(validationResult.error);
-  }
 
-  if (comment && comment !== "") {
-    return handleBuyWithComment({
-      accountAddress,
-      recipient,
-      chainId,
-      quantity,
-      contract,
-      tokenId,
-      costWithSlippage,
-      comment,
-      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;
 
-  return handleBuyWithoutComment({
-    erc20z,
-    quantity,
-    recipient,
-    accountAddress,
-    costWithSlippage,
-    chainId,
-    account,
-  });
-}
+  const accountAddress = addressOrAccountAddress(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 { error: ERROR_INSUFFICIENT_WALLET_FUNDS };
+    return makeError(ERROR_INSUFFICIENT_WALLET_FUNDS);
   }
 
   if (availableToBuy < BigInt(quantity)) {
-    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 makeError(ERROR_INSUFFICIENT_POOL_SUPPLY);
   }
 
-  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,
@@ -225,7 +99,7 @@ function handleBuyWithoutComment({
         costWithSlippage,
         0n,
       ],
-      account,
+      account: account,
       value: costWithSlippage,
     }),
   };
@@ -251,7 +125,6 @@ export async function buyWithSlippage({
   account,
   slippage = UNISWAP_SLIPPAGE,
   recipient,
-  comment,
 }: BuyWithSlippageInput & {
   chainId: number;
   publicClient: PublicClient;
@@ -286,8 +159,6 @@ export async function buyWithSlippage({
 
   const call = await makeBuy({
     erc20z,
-    contract,
-    tokenId,
     poolBalance,
     amount,
     quantity,
@@ -295,7 +166,6 @@ export async function buyWithSlippage({
     recipient,
     chainId,
     slippage,
-    comment,
     publicClient,
   });
 

package/src/secondary/types.ts

@@ -47,8 +47,6 @@ 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-sponsored-sparks-spender.test.ts

@@ -19,7 +19,7 @@ import { zoraSparksManagerImplABI } from "@zoralabs/protocol-deployments";
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraMainnet,
   anvilChainId: zora.id,
-  forkBlockNumber: 22029945,
+  forkBlockNumber: 17667435,
 });
 describe("Sponsored Mints Spender with Relay", () => {
   anvilTest(

package/src/test-utils.ts

@@ -9,7 +9,6 @@ import {
   encodeAbiParameters,
   parseAbiParameters,
 } from "viem";
-import { NewContractParams } from "./create/types";
 import { expect } from "vitest";
 
 export const waitForSuccess = async (hash: Hex, publicClient: PublicClient) => {
@@ -18,8 +17,6 @@ export const waitForSuccess = async (hash: Hex, publicClient: PublicClient) => {
   });
 
   expect(receipt.status).toBe("success");
-
-  return receipt;
 };
 
 export const getFixedPricedMinter = async ({
@@ -40,12 +37,3 @@ 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,
-  };
-}