@zoralabs/protocol-sdk 0.11.7-COMMENTS.0 → 0.11.8

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,22 +7,13 @@ import {
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
 import { createCollectorClient } from "src/sdk";
-import {
-  zoraCreator1155ImplABI,
-  commentsABI,
-  callerAndCommenterABI,
-  PermitBuyOnSecondaryAndComment,
-  permitBuyOnSecondaryAndCommentTypedDataDefinition,
-  callerAndCommenterAddress,
-  sparkValue,
-} 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";
 import { mockTimedSaleStrategyTokenQueryResult } from "src/fixtures/mint-query-results";
 import { new1155ContractVersion } from "src/create/contract-setup";
 import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
-import { randomNonce } from "src/test-utils";
 
 describe("secondary", () => {
   makeAnvilTest({
@@ -266,241 +257,4 @@ describe("secondary", () => {
     },
     30_000,
   );
-
-  makeAnvilTest({
-    forkBlockNumber: 16339853,
-    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 executorAccount = (await walletClient.getAddresses()!)[3]!;
-
-      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);
-
-      // PERMIT BUY TEST
-      const buyResultASecondTime = await collectorClient.buy1155OnSecondary({
-        account: collectorAccount,
-        quantity: 5n,
-        contract: contractAddress,
-        tokenId: newTokenId,
-        comment: "test comment",
-      });
-
-      const valueToSend = (buyResultASecondTime.price!.wei.total * 105n) / 100n;
-
-      const { timestamp } = await publicClient.getBlock();
-
-      const permitBuy: PermitBuyOnSecondaryAndComment = {
-        collection: contractAddress,
-        tokenId: newTokenId,
-        quantity: 5n,
-        commenter: collectorAccount,
-        comment: "test comment",
-        maxEthToSpend: valueToSend,
-        deadline: timestamp + 30n,
-        sqrtPriceLimitX96: 0n,
-        nonce: randomNonce(),
-        sourceChainId: chain.id,
-        destinationChainId: chain.id,
-      };
-
-      const permitBuySignature = await walletClient.signTypedData(
-        permitBuyOnSecondaryAndCommentTypedDataDefinition(permitBuy),
-      );
-
-      await testClient.setBalance({
-        address: executorAccount,
-        value: parseEther("1"),
-      });
-
-      const { request } = await publicClient.simulateContract({
-        abi: callerAndCommenterABI,
-        address:
-          callerAndCommenterAddress[
-            chain.id as keyof typeof callerAndCommenterAddress
-          ],
-        functionName: "permitBuyOnSecondaryAndComment",
-        args: [permitBuy, permitBuySignature],
-        value: valueToSend,
-        account: executorAccount,
-      });
-
-      await simulateAndWriteContractWithRetries({
-        parameters: request,
-        walletClient,
-        publicClient,
-      });
-
-      // now PERMIT SELL ON SECONDARY TEST
-      const quantityToSell = 3n;
-
-      const sellResult = await collectorClient.sell1155OnSecondary({
-        account: collectorAccount,
-        quantity: quantityToSell,
-        contract: contractAddress,
-        tokenId: newTokenId,
-      });
-
-      expect(sellResult.error).toBeUndefined();
-
-      // approve 1155s for callerAndCommenter to transfer, when selling
-      await simulateAndWriteContractWithRetries({
-        parameters: {
-          abi: zoraCreator1155ImplABI,
-          address: contractAddress,
-          functionName: "setApprovalForAll",
-          account: collectorAccount,
-          args: [
-            callerAndCommenterAddress[
-              chain.id as keyof typeof callerAndCommenterAddress
-            ],
-            true,
-          ],
-        },
-        walletClient,
-        publicClient,
-      });
-
-      // now sell on secondary with comment
-      // by calling the caller and commenter contract
-      // if including a comment, must send sparkValue() as value
-      // function signature:
-      // function sellOnSecondaryAndComment(
-      //   address commenter,
-      //   uint256 quantity,
-      //   address collection,
-      //   uint256 tokenId,
-      //   address payable recipient,
-      //   uint256 minEthToAcquire,
-      //   uint160 sqrtPriceLimitX96,
-      //   string calldata comment
-      // )
-      await simulateAndWriteContractWithRetries({
-        parameters: {
-          abi: callerAndCommenterABI,
-          address:
-            callerAndCommenterAddress[
-              chain.id as keyof typeof callerAndCommenterAddress
-            ],
-          functionName: "sellOnSecondaryAndComment",
-          account: collectorAccount,
-          args: [
-            collectorAccount,
-            quantityToSell,
-            contractAddress,
-            newTokenId,
-            collectorAccount,
-            // sell result with slippage
-            (sellResult.price!.wei.total * 95n) / 100n,
-            0n,
-            "test comment",
-          ],
-          value: sparkValue(),
-        },
-        walletClient,
-        publicClient,
-      });
-    },
-    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: 22160611,
 });
 describe("Sponsored Mints Spender with Relay", () => {
   anvilTest(
@@ -179,6 +179,5 @@ describe("Sponsored Mints Spender with Relay", () => {
 
       expect(transferReceipt.status).toBe("success");
     },
-    20_000,
   );
 });

package/src/test-utils.ts

@@ -7,11 +7,8 @@ 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) => {
@@ -20,8 +17,6 @@ export const waitForSuccess = async (hash: Hex, publicClient: PublicClient) => {
   });
 
   expect(receipt.status).toBe("success");
-
-  return receipt;
 };
 
 export const getFixedPricedMinter = async ({
@@ -42,17 +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,
-  };
-}
-
-export const randomNonce = () =>
-  keccak256(toBytes(Math.round(Math.random() * 1000)));
-export const thirtySecondsFromNow = () =>
-  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;