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

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

@@ -1,5 +1,5 @@
 import { describe, expect, vi } from "vitest";
-import { parseEther } from "viem";
+import { parseEther, Address, parseEventLogs } from "viem";
 import { zoraSepolia } from "viem/chains";
 import {
   forkUrls,
@@ -7,8 +7,12 @@ import {
   simulateAndWriteContractWithRetries,
 } from "src/anvil";
 import { createCollectorClient } from "src/sdk";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
-import { setupContractAndToken } from "src/fixtures/contract-setup";
+import {
+  zoraCreator1155ImplABI,
+  commentsABI,
+  callerAndCommenterABI,
+} 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";
@@ -17,7 +21,7 @@ import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
 
 describe("secondary", () => {
   makeAnvilTest({
-    forkBlockNumber: 14653556,
+    forkBlockNumber: 16072399,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(
@@ -25,16 +29,11 @@ describe("secondary", () => {
     async ({
       viemClients: { publicClient, chain, walletClient, testClient },
     }) => {
-      const creatorAccount = (await walletClient.getAddresses()!)[0]!;
       const collectorAccount = (await walletClient.getAddresses()!)[1]!;
 
-      const { contractAddress, newTokenId } = await setupContractAndToken({
-        chain,
-        publicClient,
-        creatorAccount,
-        walletClient,
-      });
-
+      const contractAddress: Address =
+        "0xd42557f24034b53e7340a40bb5813ef9ba88f2b4";
+      const newTokenId = 4n;
       await testClient.setBalance({
         address: collectorAccount,
         value: parseEther("100"),
@@ -50,7 +49,10 @@ describe("secondary", () => {
         tokenId: newTokenId,
       });
 
-      expect(secondaryInfo?.secondaryActivated).toBe(false);
+      expect(secondaryInfo).toBeDefined();
+
+      expect(secondaryInfo!.minimumMintsForCountdown).toBe(1111n);
+      expect(secondaryInfo!.secondaryActivated).toBe(false);
 
       const buyResult = await collectorClient.buy1155OnSecondary({
         account: collectorAccount,
@@ -65,7 +67,7 @@ describe("secondary", () => {
   );
 
   makeAnvilTest({
-    forkBlockNumber: 14653556,
+    forkBlockNumber: 16072399,
     forkUrl: forkUrls.zoraSepolia,
     anvilChainId: zoraSepolia.id,
   })(
@@ -73,16 +75,12 @@ describe("secondary", () => {
     async ({
       viemClients: { publicClient, chain, walletClient, testClient },
     }) => {
-      const creatorAccount = (await walletClient.getAddresses()!)[0]!;
       const collectorAccount = (await walletClient.getAddresses()!)[1]!;
 
-      const { contractAddress, newTokenId, mintGetter } =
-        await setupContractAndToken({
-          chain,
-          publicClient,
-          creatorAccount,
-          walletClient,
-        });
+      const mintGetter = new SubgraphMintGetter(chain.id);
+      const contractAddress: Address =
+        "0xd42557f24034b53e7340a40bb5813ef9ba88f2b4";
+      const newTokenId = 4n;
 
       await testClient.setBalance({
         address: collectorAccount,
@@ -109,13 +107,25 @@ describe("secondary", () => {
         mintGetter,
       });
 
+      const secondaryInfo = await collectorClient.getSecondaryInfo({
+        contract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      expect(secondaryInfo).toBeDefined();
+      expect(secondaryInfo!.mintCount).toBeGreaterThan(0n);
+
       // mint 1 less than expected minimum market.
       // make sure that there is no sale end
+      const quantityToMintFirst =
+        secondaryInfo!.minimumMintsForCountdown! -
+        secondaryInfo!.mintCount -
+        1n;
+
       const { parameters: collectParameters } = await collectorClient.mint({
         minterAccount: collectorAccount,
         mintType: "1155",
-        // mint 1 less than expected minimum market.
-        quantityToMint: 1111n - 1n,
+        quantityToMint: quantityToMintFirst,
         tokenId: newTokenId,
         tokenContract: contractAddress,
       });
@@ -245,8 +255,122 @@ describe("secondary", () => {
         args: [collectorAccount, newTokenId],
       });
 
-      expect(balance).toBe(1111n + quantityToBuy - quantityToSell);
+      expect(balance).toBe(
+        quantityToMintFirst + 1n + quantityToBuy - quantityToSell,
+      );
     },
     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,6 +4,8 @@ import {
   zoraCreator1155ImplABI,
   safeTransferSwapAbiParameters,
   secondarySwapABI,
+  callerAndCommenterABI,
+  callerAndCommenterAddress,
 } from "@zoralabs/protocol-deployments";
 import { makeContractParameters, PublicClient } from "src/utils";
 import { getUniswapQuote } from "./uniswap/uniswapQuote";
@@ -15,6 +17,7 @@ import {
   QuotePrice,
   BuyWithSlippageInput,
   SellWithSlippageInput,
+  SecondaryInfo,
 } from "./types";
 
 // uniswap's auto slippage for L2s is 0.5% -> 0.005
@@ -26,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) {
@@ -45,6 +50,8 @@ type Call =
     };
 
 async function makeBuy({
+  contract,
+  tokenId,
   erc20z,
   poolBalance,
   amount,
@@ -54,8 +61,11 @@ async function makeBuy({
   chainId,
   slippage,
   publicClient,
+  comment,
 }: {
   erc20z: Address;
+  contract: Address;
+  tokenId: bigint;
   poolBalance: { erc20z: bigint };
   amount: bigint;
   quantity: bigint;
@@ -63,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,
@@ -98,7 +225,7 @@ async function makeBuy({
         costWithSlippage,
         0n,
       ],
-      account: account,
+      account,
       value: costWithSlippage,
     }),
   };
@@ -124,6 +251,7 @@ export async function buyWithSlippage({
   account,
   slippage = UNISWAP_SLIPPAGE,
   recipient,
+  comment,
 }: BuyWithSlippageInput & {
   chainId: number;
   publicClient: PublicClient;
@@ -158,6 +286,8 @@ export async function buyWithSlippage({
 
   const call = await makeBuy({
     erc20z,
+    contract,
+    tokenId,
     poolBalance,
     amount,
     quantity,
@@ -165,6 +295,7 @@ export async function buyWithSlippage({
     recipient,
     chainId,
     slippage,
+    comment,
     publicClient,
   });
 
@@ -331,7 +462,7 @@ export class SecondaryClient {
   }: {
     contract: Address;
     tokenId: bigint;
-  }) {
+  }): Promise<SecondaryInfo | undefined> {
     return getSecondaryInfo({
       contract,
       tokenId,

package/src/secondary/types.ts

@@ -47,18 +47,33 @@ 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
 export type SellWithSlippageInput = BuyWithSlippageInput;
 
+// Base type for shared properties
 export type SecondaryInfo = {
-  // Whether the secondary market is activated
+  // Boolean if the secondary market has been launched
   secondaryActivated: boolean;
-  // Address of the liquidity pool for the erc20z to WETH pair
+  // The Uniswap pool address
   pool: Address;
-  // Address of the erc20z token
+  // The ERC20z address
   erc20z: Address;
-  // Timestamp when the secondary market will end
+  // The ERC20Z name
+  name: string;
+  // The ERC20Z symbol
+  symbol: string;
+  // Earliest time in seconds a token can be minted
+  saleStart: bigint;
+  // Latest time in seconds a token can be minted. Gets set after the market countdown has started.
   saleEnd?: bigint;
+  // The amount of time after the `minimumMarketEth` is reached until the secondary market can be launched, in seconds.
+  marketCountdown?: bigint;
+  // minimum quantity of tokens that must have been minted to launch the countdown.
+  minimumMintsForCountdown?: bigint;
+  // mints so far
+  mintCount: bigint;
 };

package/src/secondary/utils.ts

@@ -1,4 +1,4 @@
-import { Address } from "viem";
+import { Address, parseEther } from "viem";
 import { PublicClient } from "src/utils";
 import {
   zoraTimedSaleStrategyABI,
@@ -16,15 +16,22 @@ export async function getSecondaryInfo({
   publicClient: PublicClient;
   chainId: number;
 }): Promise<SecondaryInfo | undefined> {
-  const result = await publicClient.readContract({
-    abi: zoraTimedSaleStrategyABI,
-    address:
-      zoraTimedSaleStrategyAddress[
-        chainId as keyof typeof zoraTimedSaleStrategyAddress
-      ],
-    functionName: "sale",
-    args: [contract, tokenId],
-  });
+  let result;
+
+  try {
+    result = await publicClient.readContract({
+      abi: zoraTimedSaleStrategyABI,
+      address:
+        zoraTimedSaleStrategyAddress[
+          chainId as keyof typeof zoraTimedSaleStrategyAddress
+        ],
+      functionName: "saleV2",
+      args: [contract, tokenId],
+    });
+  } catch (e) {
+    console.error(e);
+    return undefined;
+  }
 
   // if there is no erc20zAddress, we can assume that secondary market has not been configured for this contract and token.
   if (!result.erc20zAddress) {
@@ -36,5 +43,18 @@ export async function getSecondaryInfo({
     pool: result.poolAddress,
     secondaryActivated: result.secondaryActivated,
     saleEnd: result.saleEnd === 0n ? undefined : result.saleEnd,
+    saleStart: result.saleStart,
+    name: result.name,
+    symbol: result.symbol,
+    marketCountdown:
+      result.marketCountdown === 0n ? undefined : result.marketCountdown,
+    minimumMintsForCountdown:
+      result.minimumMarketEth === 0n
+        ? undefined
+        : result.minimumMarketEth / parseEther("0.0000111"),
+    mintCount:
+      (await publicClient.getBalance({
+        address: result.erc20zAddress,
+      })) / parseEther("0.0000111"),
   };
 }

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(

package/src/test-utils.ts

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