@zoralabs/protocol-sdk 0.11.3-COMMENTS.0 → 0.11.3-COMMENTS.3

package/dist/preminter.d.ts

@@ -27,8 +27,8 @@ export declare const preminterTypedDataDefinition: ({ verifyingContract, premint
     domain?: {
         chainId?: number | undefined;
         name?: string | undefined;
-        salt?: import("abitype").ResolvedRegister["bytesType"]["outputs"] | undefined;
-        verifyingContract?: Address | undefined;
+        salt?: import("viem").ResolvedRegister["bytesType"]["outputs"] | undefined;
+        verifyingContract?: import("viem").Address | undefined;
         version?: string | undefined;
     } | undefined;
     message: Record<string, unknown>;

package/dist/preminter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preminter.d.ts","sourceRoot":"","sources":["../src/preminter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,EACL,qCAAqC,IAAI,YAAY,EAEtD,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGL,GAAG,EACH,YAAY,EACb,MAAM,MAAM,CAAC;AAEd,KAAK,aAAa,GAAG,kBAAkB,CACrC,OAAO,YAAY,EACnB,WAAW,CACZ,CAAC,QAAQ,CAAC,CAAC;AAEZ,KAAK,sBAAsB,GAAG,6BAA6B,CAAC,aAAa,CAAC,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AACtD,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAI/D,eAAO,MAAM,4BAA4B,mDAItC;IACD,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;;;;;;;;;;;;;;;;eAsGsqE,+CAA8B;;;;;CAzDpsE,CAAC;AAEF,wBAAsB,kBAAkB,CAAC,EACvC,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,SAAS,EACT,OAAO,EACP,YAAY,GACb,EAAE;IACD,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,GAAG,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,YAAY,CAAC;CAC5B,GAAG,OAAO,CAAC;IACV,YAAY,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC,CAqCD"}
+{"version":3,"file":"preminter.d.ts","sourceRoot":"","sources":["../src/preminter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,kBAAkB,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAC5E,OAAO,EACL,qCAAqC,IAAI,YAAY,EAEtD,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAGL,GAAG,EACH,YAAY,EACb,MAAM,MAAM,CAAC;AAEd,KAAK,aAAa,GAAG,kBAAkB,CACrC,OAAO,YAAY,EACnB,WAAW,CACZ,CAAC,QAAQ,CAAC,CAAC;AAEZ,KAAK,sBAAsB,GAAG,6BAA6B,CAAC,aAAa,CAAC,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,aAAa,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AACtD,MAAM,MAAM,mBAAmB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAI/D,eAAO,MAAM,4BAA4B,mDAItC;IACD,iBAAiB,EAAE,OAAO,CAAC;IAC3B,aAAa,EAAE,aAAa,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;CACjB;;;;;;;;;;;;;;;;eAsGgoE,4CAA8B;;;;;CAzD9pE,CAAC;AAEF,wBAAsB,kBAAkB,CAAC,EACvC,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,SAAS,EACT,OAAO,EACP,YAAY,GACb,EAAE;IACD,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,GAAG,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,YAAY,CAAC;CAC5B,GAAG,OAAO,CAAC;IACV,YAAY,EAAE,OAAO,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC,CAqCD"}

package/dist/test-utils.d.ts

@@ -1,6 +1,7 @@
 import { zoraCreator1155FactoryImplAddress } from "@zoralabs/protocol-deployments";
 import { Address, Hex, PublicClient } from "viem";
-export declare const waitForSuccess: (hash: Hex, publicClient: PublicClient) => Promise<void>;
+import { NewContractParams } from "./create/types";
+export declare const waitForSuccess: (hash: Hex, publicClient: PublicClient) => Promise<import("viem").TransactionReceipt>;
 export declare const getFixedPricedMinter: ({ publicClient, chainId, }: {
     publicClient: PublicClient;
     chainId: keyof typeof zoraCreator1155FactoryImplAddress;
@@ -8,4 +9,5 @@ export declare const getFixedPricedMinter: ({ publicClient, chainId, }: {
 export declare const fixedPriceMinterMinterArguments: ({ mintRecipient, }: {
     mintRecipient: Address;
 }) => `0x${string}`;
+export declare function randomNewContract(): NewContractParams;
 //# sourceMappingURL=test-utils.d.ts.map

package/dist/test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iCAAiC,EAClC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,OAAO,EACP,GAAG,EACH,YAAY,EAGb,MAAM,MAAM,CAAC;AAGd,eAAO,MAAM,cAAc,SAAgB,GAAG,gBAAgB,YAAY,kBAMzE,CAAC;AAEF,eAAO,MAAM,oBAAoB,+BAG9B;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,MAAM,OAAO,iCAAiC,CAAC;CACzD,2BAKG,CAAC;AAEL,eAAO,MAAM,+BAA+B,uBAEzC;IACD,aAAa,EAAE,OAAO,CAAC;CACxB,kBAAwE,CAAC"}
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../src/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iCAAiC,EAClC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,OAAO,EACP,GAAG,EACH,YAAY,EAGb,MAAM,MAAM,CAAC;AACd,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD,eAAO,MAAM,cAAc,SAAgB,GAAG,gBAAgB,YAAY,+CAQzE,CAAC;AAEF,eAAO,MAAM,oBAAoB,+BAG9B;IACD,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,MAAM,OAAO,iCAAiC,CAAC;CACzD,2BAKG,CAAC;AAEL,eAAO,MAAM,+BAA+B,uBAEzC;IACD,aAAa,EAAE,OAAO,CAAC;CACxB,kBAAwE,CAAC;AAI1E,wBAAgB,iBAAiB,IAAI,iBAAiB,CAKrD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/protocol-sdk",
-  "version": "0.11.3-COMMENTS.0",
+  "version": "0.11.3-COMMENTS.3",
   "repository": "https://github.com/ourzora/zora-protocol",
   "license": "MIT",
   "type": "module",
@@ -17,10 +17,10 @@
   },
   "dependencies": {
     "abitype": "^1.0.2",
-    "@zoralabs/protocol-deployments": "^0.3.5-COMMENTS.0"
+    "@zoralabs/protocol-deployments": "^0.3.5-COMMENTS.3"
   },
   "peerDependencies": {
-    "viem": "^2.13.2"
+    "viem": "^2.21.21"
   },
   "devDependencies": {
     "@lavamoat/preinstall-always-fail": "2.0.0",

package/src/comments/comments.test.ts

@@ -0,0 +1,343 @@
+import { describe, expect } from "vitest";
+import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
+import { base, zora, zoraSepolia } from "viem/chains";
+import {
+  commentsABI,
+  commentsAddress,
+  emptyCommentIdentifier,
+  PermitComment,
+  PermitSparkComment,
+  sparkValue,
+  CommentIdentifier,
+  permitSparkCommentTypedDataDefinition,
+  permitTimedSaleMintAndCommentTypedDataDefinition,
+  PermitTimedSaleMintAndComment,
+  callerAndCommenterAddress as callerAndCommenterAddresses,
+  callerAndCommenterABI,
+  zoraCreator1155ImplABI,
+} from "@zoralabs/protocol-deployments";
+import {
+  Address,
+  keccak256,
+  toBytes,
+  zeroAddress,
+  parseEther,
+  TransactionReceipt,
+  parseEventLogs,
+  hashTypedData,
+} from "viem";
+import { createCreatorClient } from "src/sdk";
+import { randomNewContract, waitForSuccess } from "src/test-utils";
+import { permitCommentTypedDataDefinition } from "@zoralabs/protocol-deployments";
+import { demoTokenMetadataURI } from "src/fixtures/contract-setup";
+
+const getCommentIdentifierFromReceipt = (
+  receipt: TransactionReceipt,
+): CommentIdentifier => {
+  const logs = parseEventLogs({
+    abi: commentsABI,
+    logs: receipt.logs,
+    eventName: "Commented",
+  });
+
+  if (logs.length === 0) {
+    throw new Error("No Commented event found in receipt");
+  }
+
+  return logs[0]!.args.commentIdentifier;
+};
+const randomNonce = () => keccak256(toBytes(Math.round(Math.random() * 1000)));
+const thirtySecondsFromNow =
+  BigInt(Math.round(new Date().getTime() / 1000)) + 30n;
+// todo: move this to protocol-deployments
+describe("comments", () => {
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 21297211,
+    anvilChainId: zora.id,
+  })(
+    "can sign and execute a cross-chain comment, and sign and execute a cross-chain spark comment",
+    async ({
+      viemClients: { publicClient, walletClient, chain, testClient },
+    }) => {
+      // Get the chain ID and set up addresses for different roles
+      const chainId = chain.id;
+      const [
+        collectorAddress,
+        creatorAddress,
+        executorAddress,
+        sparkerAddress,
+      ] = (await walletClient.getAddresses()!) as [
+        Address,
+        Address,
+        Address,
+        Address,
+      ];
+
+      // Create a creator client for interacting with the protocol
+      const creatorClient = createCreatorClient({
+        chainId,
+        publicClient,
+      });
+
+      // Step 1: Create a new 1155 contract and token
+      const { contractAddress, newTokenId, parameters, prepareMint } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+          account: creatorAddress,
+        });
+
+      // Deploy the new contract
+      const { request } = await publicClient.simulateContract(parameters);
+      await writeContractWithRetries({
+        request,
+        walletClient,
+        publicClient,
+      });
+
+      // Prepare to mint a token
+      const { parameters: collectParameters } = await prepareMint({
+        quantityToMint: 1n,
+        minterAccount: collectorAddress,
+      });
+
+      // Step 2: Mint an 1155 token on the new contract
+      const { request: mintRequest } =
+        await publicClient.simulateContract(collectParameters);
+      await writeContractWithRetries({
+        request: mintRequest,
+        walletClient,
+        publicClient,
+      });
+
+      // Set up cross-chain comment parameters
+      const sourceChainId = base.id; // The chain ID where the comment originates
+
+      const commentsAddressForChainId =
+        commentsAddress[chainId as keyof typeof commentsAddress];
+
+      // Step 3: Prepare a cross-chain comment
+      const permitComment: PermitComment = {
+        sourceChainId,
+        contractAddress,
+        destinationChainId: chainId,
+        tokenId: newTokenId,
+        commenter: collectorAddress,
+        text: "hello world",
+        deadline: thirtySecondsFromNow,
+        nonce: randomNonce(),
+        referrer: zeroAddress,
+        commenterSmartWallet: zeroAddress,
+        replyTo: emptyCommentIdentifier(),
+      };
+
+      // Generate typed data for signing
+      const typedData = permitCommentTypedDataDefinition(permitComment);
+
+      expect(typedData.domain!.chainId).toEqual(sourceChainId);
+      expect(typedData.account).toEqual(collectorAddress);
+      expect(typedData.domain!.verifyingContract).toEqual(
+        commentsAddressForChainId,
+      );
+      expect(typedData.domain!.verifyingContract).toEqual(
+        commentsAddressForChainId,
+      );
+
+      const hashed = await publicClient.readContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "hashPermitComment",
+        args: [permitComment],
+      });
+
+      expect(hashed).toEqual(hashTypedData(typedData));
+
+      // Ensure the commenter has enough balance for the spark value
+      await testClient.setBalance({
+        address: collectorAddress,
+        value: sparkValue(),
+      });
+
+      // Step 4: Sign the cross-chain comment
+      const signature = await walletClient.signTypedData(typedData);
+
+      // Ensure the executor has enough balance to execute the transaction
+      await testClient.setBalance({
+        address: executorAddress,
+        value: parseEther("1"),
+      });
+
+      // Step 5: Simulate and execute the cross-chain comment
+      const { request: commentRequest } = await publicClient.simulateContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "permitComment",
+        args: [permitComment, signature],
+        account: executorAddress,
+        value: sparkValue(),
+      });
+
+      const commentHash = await walletClient.writeContract(commentRequest);
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: commentHash,
+      });
+
+      expect(receipt.status).toBe("success");
+
+      // Extract the comment identifier from the transaction receipt
+      const commentIdentifier = getCommentIdentifierFromReceipt(receipt);
+
+      // Step 6: Prepare a spark (like) for the comment
+      const sparkComment: PermitSparkComment = {
+        sparksQuantity: 3n,
+        sparker: sparkerAddress,
+        deadline: thirtySecondsFromNow,
+        nonce: randomNonce(),
+        referrer: zeroAddress,
+        sourceChainId,
+        destinationChainId: chainId,
+        comment: commentIdentifier,
+      };
+
+      const sparkTypedData =
+        permitSparkCommentTypedDataDefinition(sparkComment);
+
+      // Step 7: Sign the spark comment
+      const sparkSignature = await walletClient.signTypedData(sparkTypedData);
+
+      // Step 8: Simulate and execute the spark comment
+      const { request: sparkRequest } = await publicClient.simulateContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "permitSparkComment",
+        args: [sparkComment, sparkSignature],
+        account: executorAddress,
+        value: sparkValue() * sparkComment.sparksQuantity,
+      });
+
+      const sparkHash = await walletClient.writeContract(sparkRequest);
+
+      await waitForSuccess(sparkHash, publicClient);
+
+      // Step 9: Verify the spark count
+      const sparkCount = await publicClient.readContract({
+        abi: commentsABI,
+        address: commentsAddressForChainId,
+        functionName: "commentSparksQuantity",
+        args: [commentIdentifier],
+      });
+
+      expect(sparkCount).toEqual(sparkComment.sparksQuantity);
+    },
+    40_000,
+  );
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 21297211,
+    anvilChainId: zora.id,
+  })(
+    "can sign and execute a cross-chain timed sale mint and comment",
+    async ({
+      viemClients: { publicClient, walletClient, chain, testClient },
+    }) => {
+      // Get the chain ID and set up addresses for different roles
+      const chainId = chain.id;
+      const [commenterAddress, executorAddress] =
+        (await walletClient.getAddresses()!) as [Address, Address, Address];
+
+      // Create a creator client for interacting with the protocol
+      const creatorClient = createCreatorClient({
+        chainId,
+        publicClient,
+      });
+
+      // Step 1: Create a new 1155 contract and token
+      const { contractAddress, newTokenId, parameters } =
+        await creatorClient.create1155({
+          contract: randomNewContract(),
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+          account: commenterAddress,
+        });
+
+      // Deploy the new contract
+      const { request } = await publicClient.simulateContract(parameters);
+      await writeContractWithRetries({
+        request,
+        walletClient,
+        publicClient,
+      });
+
+      // Step 2: Prepare the permit data for timed sale mint and comment
+      const thirtySecondsFromNow = BigInt(Math.floor(Date.now() / 1000) + 30);
+      const quantity = 3n;
+      const mintReferral = zeroAddress;
+      const comment = "This is a test comment for timed sale mint";
+
+      const permitTimedSaleMintAndComment: PermitTimedSaleMintAndComment = {
+        commenter: commenterAddress,
+        quantity,
+        collection: contractAddress,
+        tokenId: newTokenId,
+        mintReferral,
+        comment,
+        deadline: thirtySecondsFromNow,
+        nonce: randomNonce(),
+        sourceChainId: chainId,
+        destinationChainId: chainId,
+      };
+
+      // Step 3: Generate the typed data for signing
+      const typedData = permitTimedSaleMintAndCommentTypedDataDefinition(
+        permitTimedSaleMintAndComment,
+      );
+
+      // Step 4: Sign the typed data
+      const signature = await walletClient.signTypedData(typedData);
+
+      await testClient.setBalance({
+        address: executorAddress,
+        value: parseEther("1"),
+      });
+
+      // Step 5: Simulate and execute the permitTimedSaleMintAndComment function
+      const callerAndCommenterAddress =
+        callerAndCommenterAddresses[
+          chainId as keyof typeof callerAndCommenterAddresses
+        ];
+      const { request: permitRequest } = await publicClient.simulateContract({
+        abi: callerAndCommenterABI,
+        address: callerAndCommenterAddress,
+        functionName: "permitTimedSaleMintAndComment",
+        args: [permitTimedSaleMintAndComment, signature],
+        account: executorAddress,
+        value: quantity * parseEther("0.000111"),
+      });
+
+      const receipt = await writeContractWithRetries({
+        publicClient,
+        walletClient,
+        request: permitRequest,
+      });
+
+      // Step 6: Verify the comment was created
+      const commentIdentifier = getCommentIdentifierFromReceipt(receipt);
+      expect(commentIdentifier).toBeDefined();
+
+      // Step 7: Verify the token was minted
+      const balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [commenterAddress, newTokenId],
+      });
+
+      expect(balance).toEqual(quantity);
+    },
+    40_000, // Increased timeout to 30 seconds
+  );
+});

package/src/create/1155-create-helper.test.ts

@@ -16,16 +16,13 @@ import { forkUrls, makeAnvilTest, writeContractWithRetries } from "src/anvil";
 import { zora } from "viem/chains";
 import { AllowList } from "src/allow-list/types";
 import { createAllowList } from "src/allow-list/allow-list-client";
-import { NewContractParams } from "./types";
 import { SubgraphContractGetter } from "./contract-getter";
 import {
   DEFAULT_MINIMUM_MARKET_ETH,
   DEFAULT_MARKET_COUNTDOWN,
 } from "./minter-defaults";
-
-export const demoTokenMetadataURI =
-  "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u";
-export const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+import { randomNewContract } from "src/test-utils";
+import { demoTokenMetadataURI } from "src/fixtures/contract-setup";
 
 const anvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraMainnet,
@@ -56,13 +53,6 @@ const minterIsMinterOnToken = async ({
   });
 };
 
-function randomNewContract(): NewContractParams {
-  return {
-    name: `testContract-${Math.round(Math.random() * 1_000_000)}`,
-    uri: demoContractMetadataURI,
-  };
-}
-
 describe("create-helper", () => {
   anvilTest(
     "when no sales config is provided, it creates a new 1155 contract and token using the timed sale strategy",
@@ -101,7 +91,9 @@ describe("create-helper", () => {
         publicClient,
       });
       expect(receipt).not.toBeNull();
-      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+      expect(receipt.to?.toLowerCase()).to.equal(
+        "0x777777c338d93e2c7adf08d102d45ca7cc4ed021".toLowerCase(),
+      );
       expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(1n);
       expect(getContractAddressFromReceipt(receipt)).to.be.equal(
         contractAddress,
@@ -299,7 +291,10 @@ describe("create-helper", () => {
         walletClient,
         publicClient,
       });
-      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+
+      expect(receipt.to?.toLowerCase()).to.equal(
+        "0x777777c338d93e2c7adf08d102d45ca7cc4ed021".toLowerCase(),
+      );
       expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(newTokenId);
 
       expect(

package/src/create/1155-create-helper.ts

@@ -219,7 +219,7 @@ async function createNew1155ContractAndToken({
   });
 
   const contractAddress = await getDeterministicContractAddress({
-    account,
+    account: typeof account === "string" ? account : account.address,
     publicClient,
     setupActions: tokenSetupActions,
     chainId,
@@ -327,7 +327,7 @@ function prepareSetupActions({
     setupActions: tokenSetupActions,
   } = constructCreate1155TokenCalls({
     chainId: chainId,
-    ownerAddress: account,
+    ownerAddress: typeof account === "string" ? account : account.address,
     contractVersion,
     nextTokenId,
     ...token,

package/src/create/minter-defaults.ts

@@ -9,10 +9,9 @@ import {
   ConcreteSalesConfig,
   TimedSaleParamsType,
 } from "./types";
-
-// 200 mints worth of eth
-export const DEFAULT_MINIMUM_MARKET_ETH = 2220000000000000n;
-
+import { parseEther } from "viem";
+// 1111 mints worth of market reward eth - 0.0000111 eth * 1,111 = 0.0123321 eth
+export const DEFAULT_MINIMUM_MARKET_ETH = parseEther("0.0123321");
 // 24 hour countdown
 export const DEFAULT_MARKET_COUNTDOWN = BigInt(24 * 60 * 60);
 

package/src/create/types.ts

@@ -63,7 +63,7 @@ export type SalesConfigParamsType =
   | TimedSaleParamsType;
 
 export type CreateNew1155ParamsBase = {
-  account: Address;
+  account: Address | Account;
   getAdditionalSetupActions?: (args: { tokenId: bigint }) => Hex[];
   token: CreateNew1155TokenProps;
 };

package/src/fixtures/contract-setup.ts

@@ -1,13 +1,13 @@
 import { Address, Chain, PublicClient, WalletClient } from "viem";
 import { simulateAndWriteContractWithRetries } from "src/anvil";
 import { createCreatorClient } from "src/sdk";
-import {
-  demoContractMetadataURI,
-  demoTokenMetadataURI,
-} from "src/create/1155-create-helper.test";
 import { SubgraphMintGetter } from "src/mint/subgraph-mint-getter";
 import { SubgraphRewardsGetter } from "../rewards/subgraph-rewards-getter";
 
+export const demoTokenMetadataURI =
+  "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u";
+export const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
 export async function setupContractAndToken({
   chain,
   publicClient,

package/src/fixtures/secondary.ts

@@ -0,0 +1,69 @@
+import { Address, Account, PublicClient, TestClient, WalletClient } from "viem";
+import { CollectorClient } from "../sdk";
+import { simulateAndWriteContractWithRetries } from "../anvil";
+import { makeContractParameters } from "../utils";
+import {
+  zoraTimedSaleStrategyABI,
+  zoraTimedSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+
+export async function advanceToSaleAndAndLaunchMarket({
+  contractAddress,
+  tokenId,
+  testClient,
+  publicClient,
+  walletClient,
+  collectorClient,
+  chainId,
+  account,
+}: {
+  contractAddress: Address;
+  tokenId: bigint;
+  testClient: TestClient;
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+  collectorClient: CollectorClient;
+  chainId: number;
+  account: Address | Account;
+}) {
+  const saleInfo = await collectorClient.getSecondaryInfo({
+    contract: contractAddress,
+    tokenId,
+  });
+
+  if (!saleInfo) {
+    throw new Error("Sale not set");
+  }
+
+  if (!saleInfo.saleEnd) {
+    throw new Error("Sale end not set");
+  }
+
+  const saleEnd = saleInfo.saleEnd;
+
+  // advance to end of sale
+  await testClient.setNextBlockTimestamp({
+    timestamp: saleEnd,
+  });
+
+  await testClient.mine({
+    blocks: 1,
+  });
+
+  // advance to end of sale
+  // launch the market
+  await simulateAndWriteContractWithRetries({
+    parameters: makeContractParameters({
+      abi: zoraTimedSaleStrategyABI,
+      functionName: "launchMarket",
+      args: [contractAddress, tokenId],
+      address:
+        zoraTimedSaleStrategyAddress[
+          chainId as keyof typeof zoraTimedSaleStrategyAddress
+        ],
+      account: account,
+    }),
+    publicClient,
+    walletClient,
+  });
+}

package/src/mint/subgraph-mint-getter.ts

@@ -180,7 +180,7 @@ function getTargetStrategy({
   );
 
   const stillValidSalesStrategies = parsedStrategies.filter(
-    (strategy) => strategy.saleActive,
+    (strategy) => strategy.saleActive || strategy.secondaryMarketActive,
   );
 
   const saleStrategies = stillValidSalesStrategies.sort((a, b) =>

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

@@ -18,7 +18,7 @@ import {
 import { makeContractParameters } from "src/utils";
 import { mockRewardsQueryResults } from "src/fixtures/rewards-query-results";
 import { setupContractAndToken } from "src/fixtures/contract-setup";
-import { advanceToSaleAndAndLaunchMarket } from "src/secondary/secondary-client.test";
+import { advanceToSaleAndAndLaunchMarket } from "src/fixtures/secondary";
 
 describe("rewardsClient", () => {
   makeAnvilTest({
@@ -146,7 +146,7 @@ describe("rewardsClient", () => {
         value: parseEther("100"),
       });
 
-      const quantityToMint = 10_000n;
+      const quantityToMint = 1111n;
 
       mintGetter.subgraphQuerier.query = vi
         .fn<ISubgraphQuerier["query"]>()