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

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

@@ -1,5 +1,5 @@
 import { describe, expect, vi } from "vitest";
-import { parseEther, Address } from "viem";
+import { parseEther, Address, parseEventLogs } from "viem";
 import { zoraSepolia } from "viem/chains";
 import {
   forkUrls,
@@ -7,13 +7,22 @@ import {
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
 import { createCollectorClient } from "src/sdk";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  zoraCreator1155ImplABI,
+  commentsABI,
+  callerAndCommenterABI,
+  PermitBuyOnSecondaryAndComment,
+  permitBuyOnSecondaryAndCommentTypedDataDefinition,
+  callerAndCommenterAddress,
+  sparkValue,
+} 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({
@@ -257,4 +266,241 @@ 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,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-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: 17667435,
+  forkBlockNumber: 22029945,
 });
 describe("Sponsored Mints Spender with Relay", () => {
   anvilTest(
@@ -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;