@zoralabs/protocol-sdk 0.8.0 → 0.9.1

package/src/create/types.ts

@@ -1,3 +1,4 @@
+import { AsyncPrepareMint } from "src/mint/types";
 import { Concrete } from "src/utils";
 import { Account, Address, Hex, SimulateContractParameters } from "viem";
 
@@ -7,19 +8,54 @@ export type NewContractParams = {
   defaultAdmin?: Address;
 };
 
-export type SalesConfigParamsType = {
-  // defaults to 0
-  pricePerToken?: bigint;
+export type SaleStartAndEnd = {
   // defaults to 0, in seconds
   saleStart?: bigint;
   // defaults to forever, in seconds
   saleEnd?: bigint;
+};
+
+export type MaxTokensPerAddress = {
   // max tokens that can be minted per address
   maxTokensPerAddress?: bigint;
-  // if an erc20 mint, the erc20 address.  Leave null for eth mints
-  currency?: Address;
 };
 
+export type FixedPriceParamsType = SaleStartAndEnd &
+  MaxTokensPerAddress & {
+    type?: "fixedPrice";
+    // the price per token, if it is a priced mint
+    pricePerToken: bigint;
+  };
+
+export type TimedSaleParamsType = SaleStartAndEnd & {
+  type?: "timed";
+  // Name of the erc20z token to create for the secondary sale.  If not provided, fetches the metadata from the tokenMetadataURI and uses the name from it.
+  erc20Name?: string;
+  // Symbol of the erc20z token to create for the secondary sale.  If not provided, extracts it from the name.
+  erc20Symbol?: string;
+};
+
+export type Erc20ParamsType = SaleStartAndEnd &
+  MaxTokensPerAddress & {
+    type: "erc20Mint";
+    // if the erc20 address of the token to mint against
+    currency: Address;
+    // price in currency per token
+    pricePerToken: bigint;
+  };
+
+export type AllowListParamType = SaleStartAndEnd & {
+  type: "allowlistMint";
+  // the merkle root of the allowlist
+  presaleMerkleRoot: `0x${string}`;
+};
+
+export type SalesConfigParamsType =
+  | AllowListParamType
+  | Erc20ParamsType
+  | FixedPriceParamsType
+  | TimedSaleParamsType;
+
 export type CreateNew1155ParamsBase = {
   account: Address;
   getAdditionalSetupActions?: (args: { tokenId: bigint }) => Hex[];
@@ -34,28 +70,40 @@ export type CreateNew1155TokenParams = CreateNew1155ParamsBase & {
   contractAddress: Address;
 };
 
-export interface CreateNew1155TokenProps {
+export type AllowlistData = {
+  saleStart?: bigint;
+  saleEnd?: bigint;
+  presaleMerkleRoot: `0x${string}`;
+};
+
+export type CreateNew1155TokenProps = {
   maxSupply?: bigint | number;
   tokenMetadataURI: string;
   royaltyBPS?: number;
-  salesConfig?: SalesConfigParamsType;
   createReferral?: Address;
   mintToCreatorCount?: number;
   payoutRecipient?: Address;
-}
+  salesConfig?: SalesConfigParamsType;
+};
 
 export interface ContractProps {
   nextTokenId: bigint;
   contractVersion: string;
 }
 
+export type ConcreteSalesConfig =
+  | Concrete<FixedPriceParamsType>
+  | Concrete<Erc20ParamsType>
+  | Concrete<AllowListParamType>
+  | Concrete<TimedSaleParamsType>;
+
 export type New1155Token = {
   payoutRecipient: Address;
   createReferral: Address;
   maxSupply: bigint;
   royaltyBPS: number;
-  salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
+  salesConfig: ConcreteSalesConfig;
 };
 
 export type CreateNew1155TokenReturn = {
@@ -72,6 +120,7 @@ export type CreateNew1155TokenReturn = {
   newToken: New1155Token;
   minter: Address;
   contractVersion: string;
+  prepareMint: AsyncPrepareMint;
 };
 
 export type CreateNew1155ContractAndTokenReturn = {

package/src/create/update.ts

@@ -0,0 +1,93 @@
+import {
+  zoraCreator1155ImplABI,
+  zoraCreatorMerkleMinterStrategyABI,
+  zoraCreatorMerkleMinterStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+import { Address, PublicClient, WalletClient, encodeFunctionData } from "viem";
+
+function constructCallData({
+  tokenId,
+  saleEnd,
+  saleStart,
+  merkleRoot,
+  fundsRecipient,
+}: {
+  mintLimit?: string;
+  tokenId: bigint;
+  saleEnd: bigint;
+  saleStart: bigint;
+  merkleRoot: `0x${string}`;
+  fundsRecipient: Address;
+}) {
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorMerkleMinterStrategyABI,
+    functionName: "setSale",
+    args: [
+      tokenId,
+      {
+        presaleStart: saleStart,
+        presaleEnd: saleEnd,
+        fundsRecipient,
+        merkleRoot,
+      },
+    ],
+  });
+
+  return saleData;
+}
+
+export async function updateAllowListOnContract({
+  contractAddress: collectionAddress,
+  tokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  merkleRoot,
+  fundsRecipient,
+  tokenAdmin,
+  publicClient,
+  walletClient,
+}: {
+  contractAddress: Address;
+  tokenId: bigint;
+  chainId: number;
+  address: Address;
+  saleStart: bigint;
+  saleEnd: bigint;
+  merkleRoot: `0x${string}`;
+  fundsRecipient: Address;
+  tokenAdmin: Address;
+  publicClient: PublicClient;
+  walletClient: WalletClient;
+}) {
+  const saleData = constructCallData({
+    fundsRecipient,
+    merkleRoot,
+    saleEnd,
+    saleStart,
+    tokenId,
+  });
+
+  const merkleSaleStrategyAddress =
+    zoraCreatorMerkleMinterStrategyAddress[
+      chainId as keyof typeof zoraCreatorMerkleMinterStrategyAddress
+    ];
+
+  const { request } = await publicClient.simulateContract({
+    abi: zoraCreator1155ImplABI,
+    address: collectionAddress,
+    functionName: "callSale",
+    args: [tokenId, merkleSaleStrategyAddress, saleData],
+    account: tokenAdmin,
+  });
+
+  const hash = await walletClient.writeContract(request);
+
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash,
+  });
+
+  if (receipt.status !== "success") {
+    throw new Error("Transaction failed");
+  }
+}

package/src/index.ts

@@ -29,3 +29,7 @@ export * from "./create/types";
 export * from "./sdk";
 
 export * from "./ipfs";
+
+export { createAllowList } from "./allow-list/allow-list-client";
+
+export * from "./allow-list/types";

package/src/ipfs/token-metadata.ts

@@ -97,3 +97,21 @@ export const makeMediaTokenMetadata = async ({
     attributes,
   };
 };
+
+export async function fetchTokenMetadata(tokenMetadataURI: string) {
+  const fetchableUrl = getFetchableUrl(tokenMetadataURI);
+
+  if (!fetchableUrl) {
+    throw new Error(`Invalid token metadata URI: ${tokenMetadataURI}`);
+  }
+
+  const json = (await (await fetch(fetchableUrl)).json()) as
+    | TokenMetadataJson
+    | undefined;
+
+  if (!json) {
+    throw new Error(`Failed to fetch metadata from ${fetchableUrl}`);
+  }
+
+  return json;
+}

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

@@ -1,9 +1,22 @@
-import { describe, expect } from "vitest";
-import { Address, erc20Abi, parseAbi, parseEther } from "viem";
+import { describe, expect, vi } from "vitest";
+import { Address, erc20Abi, parseAbi, parseEther, zeroAddress } from "viem";
 import { zora, zoraSepolia } from "viem/chains";
-import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import {
+  zoraCreator1155ImplABI,
+  zoraTimedSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
 import { forkUrls, makeAnvilTest } from "src/anvil";
-import { createCollectorClient } from "src/sdk";
+import { createCollectorClient, createCreatorClient } from "src/sdk";
+import { getAllowListEntry } from "src/allow-list/allow-list-client";
+import {
+  demoContractMetadataURI,
+  demoTokenMetadataURI,
+} from "src/create/1155-create-helper.test";
+import { SubgraphMintGetter } from "./subgraph-mint-getter";
+import { new1155ContractVersion } from "src/create/contract-setup";
+import { SALE_END_FOREVER } from "src/create/minter-defaults";
+import { ISubgraphQuerier } from "src/apis/subgraph-querier";
+import { TokenQueryResult } from "./subgraph-queries";
 
 const erc721ABI = parseAbi([
   "function balanceOf(address owner) public view returns (uint256)",
@@ -239,25 +252,216 @@ describe("mint-helper", () => {
 
   makeAnvilTest({
     forkUrl: forkUrls.zoraSepolia,
-    forkBlockNumber: 10294670,
+    forkBlockNumber: 10970943,
     anvilChainId: zoraSepolia.id,
+  })("can mint allowlist tokens", async ({ viemClients }) => {
+    const { publicClient, chain, testClient, walletClient } = viemClients;
+
+    const collectorClient = createCollectorClient({
+      chainId: chain.id,
+      publicClient,
+    });
+
+    const targetContract = "0x440cF6a9f12b2f05Ec4Cee8eE0F317B0eC0c2eCD";
+
+    const tokenId = 1n;
+
+    const allowListUser = "0xf69fEc6d858c77e969509843852178bd24CAd2B6";
+    const merkleRoot =
+      "4d08ab87f97dda8811b4bb32a16a175db65e4c140797c993679a3d58aaadc791";
+
+    const allowListEntryResult = await getAllowListEntry({
+      address: allowListUser,
+      merkleRoot,
+    });
+
+    const { prepareMint } = await collectorClient.getToken({
+      mintType: "1155",
+      tokenContract: targetContract,
+      tokenId,
+    });
+
+    const minter = (await walletClient.getAddresses())[0]!;
+
+    await testClient.setBalance({
+      address: minter,
+      value: parseEther("10"),
+    });
+
+    const quantityToMint = allowListEntryResult.allowListEntry!.maxCanMint;
+
+    const { parameters } = prepareMint({
+      minterAccount: minter,
+      quantityToMint,
+      mintRecipient: allowListUser,
+      allowListEntry: allowListEntryResult.allowListEntry,
+    });
+
+    const { request } = await publicClient.simulateContract(parameters);
+    const hash = await walletClient.writeContract(request);
+
+    await publicClient.waitForTransactionReceipt({ hash });
+
+    const balance = await publicClient.readContract({
+      abi: zoraCreator1155ImplABI,
+      functionName: "balanceOf",
+      address: targetContract,
+      args: [allowListUser, tokenId],
+    });
+
+    expect(balance).toBe(BigInt(quantityToMint));
+  }),
+    makeAnvilTest({
+      forkUrl: forkUrls.zoraSepolia,
+      forkBlockNumber: 10294670,
+      anvilChainId: zoraSepolia.id,
+    })(
+      "gets onchain and premint mintables",
+      async ({ viemClients }) => {
+        const { publicClient, chain } = viemClients;
+
+        const targetContract: Address =
+          "0xa33e4228843092bb0f2fcbb2eb237bcefc1046b3";
+
+        const minter = createCollectorClient({
+          chainId: chain.id,
+          publicClient,
+        });
+
+        const { tokens: mintables, contract } =
+          await minter.getTokensOfContract({
+            tokenContract: targetContract,
+          });
+
+        expect(mintables.length).toBe(4);
+        expect(contract).toBeDefined();
+      },
+      12 * 1000,
+    );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 18145203,
+    anvilChainId: zora.id,
   })(
-    "gets onchain and premint mintables",
+    "can mint a zora timed sale strategy mint",
     async ({ viemClients }) => {
-      const { publicClient, chain } = viemClients;
+      const { publicClient, chain, walletClient } = viemClients;
 
-      const targetContract: Address =
-        "0xa33e4228843092bb0f2fcbb2eb237bcefc1046b3";
+      const creator = (await walletClient.getAddresses())[0]!;
 
-      const minter = createCollectorClient({ chainId: chain.id, publicClient });
+      const creatorClient = createCreatorClient({
+        chainId: chain.id,
+        publicClient,
+      });
 
-      const { tokens: mintables, contract } = await minter.getTokensOfContract({
-        tokenContract: targetContract,
+      const { parameters, contractAddress, newTokenId } =
+        await creatorClient.create1155({
+          account: creator,
+          contract: {
+            name: "Test Timed Sale",
+            uri: demoContractMetadataURI,
+            defaultAdmin: creator,
+          },
+          token: {
+            tokenMetadataURI: demoTokenMetadataURI,
+          },
+        });
+
+      const { request: createRequest } =
+        await publicClient.simulateContract(parameters);
+      const createHash = await walletClient.writeContract(createRequest);
+      const createReceipt = await publicClient.waitForTransactionReceipt({
+        hash: createHash,
+      });
+      expect(createReceipt.status).toBe("success");
+
+      const zoraCreateToken: TokenQueryResult = {
+        contract: {
+          address: contractAddress,
+          contractVersion: new1155ContractVersion(chain.id),
+          // not used:
+          mintFeePerQuantity: "0",
+          name: "",
+          contractURI: "",
+          salesStrategies: [],
+        },
+        creator: creator,
+        maxSupply: "1000",
+        tokenStandard: "ERC1155",
+        totalMinted: "0",
+        uri: "",
+        tokenId: newTokenId.toString(),
+        salesStrategies: [
+          {
+            type: "ZORA_TIMED",
+            zoraTimedMinter: {
+              address:
+                zoraTimedSaleStrategyAddress[
+                  chain.id as keyof typeof zoraTimedSaleStrategyAddress
+                ],
+              mintFee: "111000000000000",
+              saleEnd: SALE_END_FOREVER.toString(),
+              saleStart: "0",
+              erc20Z: {
+                // not needed
+                id: zeroAddress,
+                // note needed
+                pool: zeroAddress,
+              },
+              secondaryActivated: false,
+            },
+          },
+        ],
+      };
+
+      const mockQuery = vi.fn<ISubgraphQuerier["query"]>().mockResolvedValue({
+        zoraCreateToken,
+      });
+
+      const mintGetter = new SubgraphMintGetter(chain.id);
+      mintGetter.subgraphQuerier.query = mockQuery;
+
+      const collectorClient = createCollectorClient({
+        chainId: chain.id,
+        publicClient,
+        mintGetter,
+      });
+
+      const collector = (await walletClient.getAddresses())[1]!;
+
+      const { prepareMint } = await collectorClient.getToken({
+        mintType: "1155",
+        tokenContract: contractAddress,
+        tokenId: newTokenId,
+      });
+
+      const quantityToMint = 10n;
+
+      const { parameters: mintParameters, costs } = prepareMint({
+        minterAccount: collector,
+        quantityToMint,
       });
 
-      expect(mintables.length).toBe(4);
-      expect(contract).toBeDefined();
+      expect(costs.totalCostEth).toBe(quantityToMint * parseEther("0.000111"));
+
+      const { request: mintRequest } =
+        await publicClient.simulateContract(mintParameters);
+      const mintHash = await walletClient.writeContract(mintRequest);
+      const mintReceipt = await publicClient.waitForTransactionReceipt({
+        hash: mintHash,
+      });
+      expect(mintReceipt.status).toBe("success");
+
+      const balance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: contractAddress,
+        functionName: "balanceOf",
+        args: [collector, newTokenId],
+      });
+
+      expect(balance).toBe(quantityToMint);
     },
-    12 * 1000,
+    20_000,
   );
 });

package/src/mint/mint-client.ts

@@ -1,4 +1,4 @@
-import { Address, Account, SimulateContractParameters } from "viem";
+import { Address } from "viem";
 import { IPublicClient } from "src/types";
 import {
   GetMintParameters,
@@ -7,16 +7,9 @@ import {
   PrepareMintReturn,
   SaleType,
 } from "./types";
-import {
-  MakeMintParametersArguments,
-  Make1155MintArguments,
-  Make721MintArguments,
-  GetMintCostsParameters,
-  is1155Mint,
-} from "./types";
+import { MakeMintParametersArguments, GetMintCostsParameters } from "./types";
 import { IPremintGetter } from "src/premint/premint-api-client";
 
-import { makeOnchainMintCall } from "./mint-transactions";
 import { getMint, getMintCosts, getMintsOfContract } from "./mint-queries";
 
 class MintError extends Error {}
@@ -139,28 +132,3 @@ async function mint({
     mintReferral: parameters.mintReferral,
   });
 }
-
-export async function collectOnchain({
-  chainId,
-  mintGetter,
-  ...parameters
-}: (Make1155MintArguments | Make721MintArguments) & {
-  mintGetter: IOnchainMintGetter;
-  chainId: number;
-}): Promise<
-  SimulateContractParameters<any, any, any, any, any, Account | Address>
-> {
-  const { tokenContract: tokenContract, preferredSaleType: saleType } =
-    parameters;
-  const tokenId = is1155Mint(parameters) ? parameters.tokenId : undefined;
-  const salesConfigAndTokenInfo = await mintGetter.getMintable({
-    tokenId,
-    tokenAddress: tokenContract,
-    preferredSaleType: saleType,
-  });
-
-  return makeOnchainMintCall({
-    mintParams: parameters,
-    token: salesConfigAndTokenInfo,
-  });
-}

package/src/mint/mint-queries.ts

@@ -27,6 +27,8 @@ import {
 import { makeOnchainMintCall, parseMintCosts } from "./mint-transactions";
 import { buildPremintMintCall } from "src/premint/premint-client";
 import { IPublicClient } from "src/types";
+import { AllowListEntry } from "src/allow-list/types";
+import { Concrete } from "src/utils";
 
 export async function getMint({
   params,
@@ -42,10 +44,12 @@ export async function getMint({
   const { tokenContract } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : undefined;
+    const blockTime = (await publicClient.getBlock()).timestamp;
     const result = await mintGetter.getMintable({
       tokenId,
       tokenAddress: tokenContract,
       preferredSaleType: params.preferredSaleType,
+      blockTime: blockTime,
     });
 
     return toMintableReturn(result);
@@ -129,11 +133,13 @@ export async function getMintsOfContract({
 
 export async function getMintCosts({
   params,
+  allowListEntry,
   mintGetter,
   premintGetter,
   publicClient,
 }: {
   params: GetMintCostsParameters;
+  allowListEntry?: Pick<AllowListEntry, "price">;
   mintGetter: IOnchainMintGetter;
   premintGetter: IPremintGetter;
   publicClient: IPublicClient;
@@ -141,15 +147,21 @@ export async function getMintCosts({
   const { quantityMinted: quantityToMint, collection } = params;
   if (isOnChainMint(params)) {
     const tokenId = is1155Mint(params) ? params.tokenId : undefined;
+    const blockTime = (await publicClient.getBlock()).timestamp;
     const salesConfigAndTokenInfo = await mintGetter.getMintable({
       tokenId,
       tokenAddress: collection,
+      blockTime,
     });
 
+    if (!salesConfigAndTokenInfo.salesConfig) {
+      throw new Error("No valid sales config found for token");
+    }
+
     return parseMintCosts({
-      mintFeePerQuantity: salesConfigAndTokenInfo.mintFeePerQuantity,
       salesConfig: salesConfigAndTokenInfo.salesConfig,
       quantityToMint: BigInt(quantityToMint),
+      allowListEntry,
     });
   }
 
@@ -226,7 +238,6 @@ function parsePremint({
     return {
       creator: premint.signer,
       maxSupply: premint.premint.premintConfig.tokenConfig.maxSupply,
-      mintFeePerQuantity: mintFee,
       mintType: "premint",
       uid: premint.premint.premintConfig.uid,
       contract: {
@@ -242,6 +253,7 @@ function parsePremint({
           premint.premint.premintConfig.tokenConfig.maxTokensPerAddress,
         pricePerToken: premint.premint.premintConfig.tokenConfig.pricePerToken,
         saleType: "premint",
+        mintFeePerQuantity: mintFee,
       },
     };
   }
@@ -249,17 +261,26 @@ function parsePremint({
   throw new Error("Invalid premint config version");
 }
 
-const makeOnchainPrepareMint =
+export const makeOnchainPrepareMint =
   (result: OnchainSalesConfigAndTokenInfo): PrepareMint =>
-  (params: MintParametersBase) => ({
-    parameters: makeOnchainMintCall({ token: result, mintParams: params }),
-    erc20Approval: getRequiredErc20Approvals(params, result),
-    costs: parseMintCosts({
-      salesConfig: result.salesConfig,
-      quantityToMint: BigInt(params.quantityToMint),
-      mintFeePerQuantity: result.mintFeePerQuantity,
-    }),
-  });
+  (params: MintParametersBase) => {
+    if (!result.salesConfig) {
+      throw new Error("No valid sales config found for token");
+    }
+
+    return {
+      parameters: makeOnchainMintCall({
+        token: result as Concrete<OnchainSalesConfigAndTokenInfo>,
+        mintParams: params,
+      }),
+      erc20Approval: getRequiredErc20Approvals(params, result.salesConfig),
+      costs: parseMintCosts({
+        salesConfig: result.salesConfig,
+        quantityToMint: BigInt(params.quantityToMint),
+        allowListEntry: params.allowListEntry,
+      }),
+    };
+  };
 
 function toMintableReturn(
   result: OnchainSalesConfigAndTokenInfo,
@@ -283,9 +304,9 @@ const makePremintPrepareMint =
       premint,
     }),
     costs: parseMintCosts({
-      mintFeePerQuantity: mintFee,
       quantityToMint: BigInt(params.quantityToMint),
       salesConfig: mintable.salesConfig,
+      allowListEntry: params.allowListEntry,
     }),
   });
 
@@ -306,15 +327,15 @@ function toPremintMintReturn({
     prepareMint: makePremintPrepareMint(mintable, mintFee, premint),
   };
 }
-function getRequiredErc20Approvals(
+export function getRequiredErc20Approvals(
   params: MintParametersBase,
-  result: OnchainSalesConfigAndTokenInfo,
+  salesConfig: OnchainSalesConfigAndTokenInfo["salesConfig"],
 ): Erc20Approval | undefined {
-  if (result.salesConfig.saleType !== "erc20") return undefined;
+  if (salesConfig?.saleType !== "erc20") return undefined;
 
   return {
-    quantity: result.salesConfig.pricePerToken * BigInt(params.quantityToMint),
-    approveTo: result.salesConfig.address,
-    erc20: result.salesConfig.currency,
+    quantity: salesConfig.pricePerToken * BigInt(params.quantityToMint),
+    approveTo: salesConfig.address,
+    erc20: salesConfig.currency,
   };
 }