@zoralabs/protocol-sdk 0.5.16 → 0.6.0

package/src/create/token-setup.ts

@@ -0,0 +1,379 @@
+import {
+  erc20MinterABI,
+  erc20MinterAddress as erc20MinterAddresses,
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyABI,
+  zoraCreatorFixedPriceSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+import { Address, encodeFunctionData, zeroAddress, Hex } from "viem";
+import * as semver from "semver";
+import {
+  ContractProps,
+  CreateNew1155TokenProps,
+  New1155Token,
+  SalesConfigParamsType,
+} from "./types";
+import { OPEN_EDITION_MINT_SIZE } from "src/constants";
+import { Concrete } from "src/utils";
+
+export const PERMISSION_BITS = {
+  MINTER: 2n ** 2n,
+};
+
+type SetupMintersProps = {
+  tokenId: bigint;
+  chainId: number;
+  fundsRecipient: Address;
+  salesConfig: Concrete<SalesConfigParamsType>;
+};
+
+// Sales end forever amount (uint64 max)
+
+const saleSettingsOrDefault = (
+  saleSettings?: SalesConfigParamsType,
+): Concrete<SalesConfigParamsType> => {
+  const SALE_END_FOREVER = 18446744073709551615n;
+
+  const DEFAULT_SALE_SETTINGS: Concrete<SalesConfigParamsType> = {
+    currency: zeroAddress,
+    // Free Mint
+    pricePerToken: 0n,
+    // Sale start time – defaults to beginning of unix time
+    saleStart: 0n,
+    // This is the end of uint64, plenty of time
+    saleEnd: SALE_END_FOREVER,
+    // 0 Here means no limit
+    maxTokensPerAddress: 0n,
+  };
+  return {
+    ...DEFAULT_SALE_SETTINGS,
+    ...saleSettings,
+  };
+};
+
+function applyNew1155Defaults(
+  props: CreateNew1155TokenProps,
+  ownerAddress: Address,
+): New1155Token {
+  const { payoutRecipient: fundsRecipient } = props;
+  const fundsRecipientOrOwner =
+    fundsRecipient && fundsRecipient !== zeroAddress
+      ? fundsRecipient
+      : ownerAddress;
+  return {
+    payoutRecipient: fundsRecipientOrOwner,
+    createReferral: props.createReferral || zeroAddress,
+    maxSupply:
+      typeof props.maxSupply === "undefined"
+        ? OPEN_EDITION_MINT_SIZE
+        : BigInt(props.maxSupply),
+    royaltyBPS: props.royaltyBPS || 1000,
+    salesConfig: saleSettingsOrDefault(props.salesConfig),
+    tokenMetadataURI: props.tokenMetadataURI,
+  };
+}
+
+type SetupErc20MinterProps = {
+  chainId: number;
+  tokenId: bigint;
+  fundsRecipient: Address;
+} & Concrete<SalesConfigParamsType>;
+
+function setupErc20Minter({
+  pricePerToken,
+  chainId,
+  tokenId: nextTokenId,
+  currency,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient,
+}: SetupErc20MinterProps): {
+  minter: Address;
+  setupActions: Hex[];
+} {
+  const erc20MinterAddress =
+    erc20MinterAddresses[chainId as keyof typeof erc20MinterAddresses];
+  if (!erc20MinterAddress)
+    throw new Error(`ERC20Minter not deployed on chainId ${chainId}`);
+
+  const erc20MinterApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [BigInt(nextTokenId), erc20MinterAddress, PERMISSION_BITS.MINTER],
+  });
+
+  const saleData = encodeFunctionData({
+    abi: erc20MinterABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        pricePerToken: pricePerToken,
+        fundsRecipient,
+        currency: currency,
+      },
+    ],
+  });
+
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), erc20MinterAddress, saleData],
+  });
+
+  return {
+    minter: erc20MinterAddress,
+    setupActions: [erc20MinterApproval, callSale],
+  };
+}
+
+type SetupFixedPriceMinterProps = {
+  fundsRecipient: Address;
+  tokenId: bigint;
+  chainId: number;
+} & Concrete<Omit<SalesConfigParamsType, "currency">>;
+
+function setupFixedPriceMinter({
+  pricePerToken: price,
+  tokenId: nextTokenId,
+  chainId,
+  saleStart,
+  saleEnd,
+  maxTokensPerAddress: mintLimit,
+  fundsRecipient,
+}: SetupFixedPriceMinterProps): { minter: Address; setupActions: Hex[] } {
+  const fixedPriceStrategyAddress =
+    zoraCreatorFixedPriceSaleStrategyAddress[
+      chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
+    ];
+  const fixedPriceApproval = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "addPermission",
+    args: [
+      BigInt(nextTokenId),
+      fixedPriceStrategyAddress,
+      PERMISSION_BITS.MINTER,
+    ],
+  });
+
+  const saleData = encodeFunctionData({
+    abi: zoraCreatorFixedPriceSaleStrategyABI,
+    functionName: "setSale",
+    args: [
+      BigInt(nextTokenId),
+      {
+        pricePerToken: price,
+        saleStart: saleStart || BigInt(0),
+        saleEnd: saleEnd || BigInt(0),
+        maxTokensPerAddress: BigInt(mintLimit || 0),
+        fundsRecipient,
+      },
+    ],
+  });
+
+  const callSale = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "callSale",
+    args: [BigInt(nextTokenId), fixedPriceStrategyAddress, saleData],
+  });
+
+  return {
+    minter: fixedPriceStrategyAddress,
+    setupActions: [fixedPriceApproval, callSale],
+  };
+}
+
+export function setupMinters({ salesConfig, ...rest }: SetupMintersProps): {
+  minter: Address;
+  setupActions: Hex[];
+} {
+  if (!salesConfig) throw new Error("No sales config for token");
+  const { currency: currencyAddress } = salesConfig;
+
+  if (currencyAddress === zeroAddress) {
+    return setupFixedPriceMinter({
+      ...salesConfig,
+      ...rest,
+    });
+  } else {
+    return setupErc20Minter({
+      ...salesConfig,
+      ...rest,
+    });
+  }
+}
+
+function buildSetupNewToken({
+  tokenURI,
+  maxSupply = OPEN_EDITION_MINT_SIZE,
+  createReferral = zeroAddress,
+  contractVersion,
+}: {
+  tokenURI: string;
+  maxSupply: bigint;
+  createReferral: Address;
+  contractVersion?: string;
+}): Hex {
+  // If we're adding a new token to an existing contract which doesn't support
+  // creator rewards, we won't have the 'setupNewTokenWithCreateReferral' method
+  // available, so we need to check for that and use the fallback method instead.
+  if (contractSupportsMintRewards(contractVersion, "ERC1155")) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "setupNewTokenWithCreateReferral",
+      args: [tokenURI, BigInt(maxSupply), createReferral],
+    });
+  }
+
+  if (createReferral !== zeroAddress) {
+    throw new Error(
+      "Contract does not support create referral, but one was provided",
+    );
+  }
+  return encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "setupNewToken",
+    args: [tokenURI, BigInt(maxSupply)],
+  });
+}
+
+function setupRoyaltyConfig({
+  royaltyBPS,
+  royaltyRecipient,
+  nextTokenId,
+}: {
+  royaltyBPS: number;
+  royaltyRecipient: Address;
+  nextTokenId: bigint;
+}) {
+  if (royaltyBPS > 0 && royaltyRecipient != zeroAddress) {
+    return encodeFunctionData({
+      abi: zoraCreator1155ImplABI,
+      functionName: "updateRoyaltiesForToken",
+      args: [
+        nextTokenId,
+        {
+          royaltyBPS,
+          royaltyRecipient,
+          royaltyMintSchedule: 0,
+        },
+      ],
+    });
+  }
+
+  return null;
+}
+
+function makeAdminMintCall({
+  ownerAddress,
+  mintQuantity,
+  nextTokenId,
+}: {
+  ownerAddress: Address;
+  mintQuantity?: number;
+  nextTokenId: bigint;
+}) {
+  if (!mintQuantity || mintQuantity <= 0 || !ownerAddress) {
+    return null;
+  }
+
+  return encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "adminMint",
+    args: [ownerAddress, nextTokenId, BigInt(mintQuantity), zeroAddress],
+  });
+}
+
+export function constructCreate1155TokenCalls(
+  props: CreateNew1155TokenProps &
+    ContractProps & {
+      ownerAddress: Address;
+      chainId: number;
+    },
+): {
+  setupActions: `0x${string}`[];
+  newToken: New1155Token;
+  minter: Address;
+} {
+  const {
+    chainId,
+    nextTokenId,
+    mintToCreatorCount,
+    ownerAddress,
+    contractVersion,
+  } = props;
+
+  const new1155TokenPropsWithDefaults = applyNew1155Defaults(
+    props,
+    ownerAddress,
+  );
+
+  const verifyTokenIdExpected = encodeFunctionData({
+    abi: zoraCreator1155ImplABI,
+    functionName: "assumeLastTokenIdMatches",
+    args: [nextTokenId - 1n],
+  });
+
+  const setupNewToken = buildSetupNewToken({
+    tokenURI: new1155TokenPropsWithDefaults.tokenMetadataURI,
+    maxSupply: new1155TokenPropsWithDefaults.maxSupply,
+    createReferral: new1155TokenPropsWithDefaults.createReferral,
+    contractVersion,
+  });
+
+  const royaltyConfig = setupRoyaltyConfig({
+    royaltyBPS: new1155TokenPropsWithDefaults.royaltyBPS,
+    royaltyRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    nextTokenId,
+  });
+
+  const { minter, setupActions: mintersSetup } = setupMinters({
+    tokenId: nextTokenId,
+    chainId,
+    fundsRecipient: new1155TokenPropsWithDefaults.payoutRecipient,
+    salesConfig: new1155TokenPropsWithDefaults.salesConfig,
+  });
+
+  const adminMintCall = makeAdminMintCall({
+    ownerAddress,
+    mintQuantity: mintToCreatorCount,
+    nextTokenId,
+  });
+
+  const setupActions = [
+    verifyTokenIdExpected,
+    setupNewToken,
+    ...mintersSetup,
+    royaltyConfig,
+    adminMintCall,
+  ].filter((item) => item !== null) as `0x${string}`[];
+
+  return {
+    setupActions,
+    minter,
+    newToken: new1155TokenPropsWithDefaults,
+  };
+}
+
+export const contractSupportsMintRewards = (
+  contractVersion?: string | null,
+  contractStandard?: "ERC721" | "ERC1155",
+) => {
+  if (!contractStandard || !contractVersion) {
+    return false;
+  }
+
+  // Try force-convert version format to semver format
+  const semVerContractVersion = semver.coerce(contractVersion)?.raw;
+  if (!semVerContractVersion) return false;
+
+  if (contractStandard === "ERC1155") {
+    return semver.gte(semVerContractVersion, "1.3.5");
+  } else {
+    return semver.gte(semVerContractVersion, "14.0.0");
+  }
+};

package/src/create/types.ts

@@ -0,0 +1,57 @@
+import { Concrete } from "src/utils";
+import { Address, Hex } from "viem";
+
+export type ContractType =
+  | {
+      name: string;
+      uri: string;
+      defaultAdmin?: Address;
+    }
+  | Address;
+
+export type SalesConfigParamsType = {
+  // defaults to 0
+  pricePerToken?: bigint;
+  // defaults to 0, in seconds
+  saleStart?: bigint;
+  // defaults to forever, in seconds
+  saleEnd?: bigint;
+  // 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 CreateNew1155Params = {
+  account: Address;
+  contract: ContractType;
+  getAdditionalSetupActions?: (args: {
+    tokenId: bigint;
+    contractAddress: Address;
+  }) => Hex[];
+  token: CreateNew1155TokenProps;
+};
+
+export interface CreateNew1155TokenProps {
+  maxSupply?: bigint | number;
+  tokenMetadataURI: string;
+  royaltyBPS?: number;
+  salesConfig?: SalesConfigParamsType;
+  createReferral?: Address;
+  mintToCreatorCount?: number;
+  payoutRecipient?: Address;
+}
+
+export interface ContractProps {
+  nextTokenId: bigint;
+  contractVersion: string;
+}
+
+export type New1155Token = {
+  payoutRecipient: Address;
+  createReferral: Address;
+  maxSupply: bigint;
+  royaltyBPS: number;
+  salesConfig: Concrete<SalesConfigParamsType>;
+  tokenMetadataURI: string;
+};

package/src/index.ts

@@ -8,7 +8,7 @@ export * from "./premint/premint-api-client";
 
 export * from "./premint/conversions";
 
-export * from "./mint/mint-api-client";
+export * from "./mint/subgraph-mint-getter";
 
 export * from "./mint/mint-client";
 
@@ -19,3 +19,13 @@ export * from "./mints/mints-queries";
 export * from "./mints/mints-contracts";
 
 export * from "./mints/mints-eth-unwrapper-and-caller";
+
+export {
+  type ContractCreationConfigWithOptionalAdditionalAdmins,
+  type ContractCreationConfigOrAddress,
+  type ContractCreationConfigAndAddress,
+} from "./premint/contract-types";
+
+export * from "./create/types";
+
+export * from "./sdk";

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

@@ -1,12 +1,13 @@
 import { describe, expect } from "vitest";
-import { Address, parseAbi, parseEther } from "viem";
+import { Address, erc20Abi, parseAbi, parseEther } from "viem";
 import { zora } from "viem/chains";
 import {
   zoraCreator1155ImplABI,
-  erc20MinterAddress,
+  erc20MinterAddress as erc20MinterAddresses,
 } from "@zoralabs/protocol-deployments";
-import { createMintClient } from "./mint-client";
 import { anvilTest, forkUrls, makeAnvilTest } from "src/anvil";
+import { createCollectorClient } from "src/sdk";
+import { requestErc20ApprovalForMint } from "./mint-client";
 
 const erc721ABI = parseAbi([
   "function balanceOf(address owner) public view returns (uint256)",
@@ -25,16 +26,18 @@ describe("mint-helper", () => {
       const targetContract: Address =
         "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
       const targetTokenId = 1n;
-      const minter = createMintClient({ chain: zora });
+      const collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
 
-      const params = await minter.makePrepareMintTokenParams({
+      const { parameters } = await collectorClient.mint({
         minterAccount: creatorAccount,
         tokenId: targetTokenId,
-        tokenAddress: targetContract,
-        mintArguments: {
-          mintToAddress: creatorAccount,
-          quantityToMint: 1,
-        },
+        tokenContract: targetContract,
+        mintType: "1155",
+        mintRecipient: creatorAccount,
+        quantityToMint: 1,
       });
 
       const oldBalance = await publicClient.readContract({
@@ -44,7 +47,7 @@ describe("mint-helper", () => {
         args: [creatorAccount, targetTokenId],
       });
 
-      const simulationResult = await publicClient.simulateContract(params);
+      const simulationResult = await publicClient.simulateContract(parameters);
 
       const hash = await walletClient.writeContract(simulationResult.request);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
@@ -64,6 +67,7 @@ describe("mint-helper", () => {
   makeAnvilTest({
     forkUrl: forkUrls.zoraMainnet,
     forkBlockNumber: 6133407,
+    anvilChainId: zora.id,
   })(
     "mints a new 721 token",
     async ({ viemClients }) => {
@@ -76,17 +80,17 @@ describe("mint-helper", () => {
 
       const targetContract: Address =
         "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
-      const targetTokenId = undefined;
-      const minter = createMintClient({ chain: zora });
+      const collectorClient = createCollectorClient({
+        chainId: zora.id,
+        publicClient,
+      });
 
-      const params = await minter.makePrepareMintTokenParams({
-        tokenId: targetTokenId,
-        tokenAddress: targetContract,
+      const { parameters } = await collectorClient.mint({
+        tokenContract: targetContract,
         minterAccount: creatorAccount,
-        mintArguments: {
-          mintToAddress: creatorAccount,
-          quantityToMint: 1,
-        },
+        mintRecipient: creatorAccount,
+        quantityToMint: 1,
+        mintType: "721",
       });
       const oldBalance = await publicClient.readContract({
         abi: erc721ABI,
@@ -95,7 +99,7 @@ describe("mint-helper", () => {
         args: [creatorAccount],
       });
 
-      const simulated = await publicClient.simulateContract(params);
+      const simulated = await publicClient.simulateContract(parameters);
 
       const hash = await walletClient.writeContract(simulated.request);
 
@@ -118,16 +122,17 @@ describe("mint-helper", () => {
   makeAnvilTest({
     forkUrl: forkUrls.zoraMainnet,
     forkBlockNumber: 14484183,
+    anvilChainId: zora.id,
   })(
     "mints an 1155 token with an ERC20 token",
     async ({ viemClients }) => {
-      const { testClient, walletClient, publicClient } = viemClients;
+      const { testClient, walletClient, publicClient, chain } = viemClients;
 
       const targetContract: Address =
         "0x689bc305456c38656856d12469aed282fbd89fe0";
       const targetTokenId = 16n;
 
-      const minter = createMintClient({ chain: zora });
+      const minter = createCollectorClient({ chainId: chain.id, publicClient });
 
       const mockCollector = "0xb6b701878a1f80197dF2c209D0BDd292EA73164D";
       await testClient.impersonateAccount({
@@ -137,12 +142,6 @@ describe("mint-helper", () => {
       const erc20Currency = "0xa6b280b42cb0b7c4a4f789ec6ccc3a7609a1bc39";
       const erc20PricePerToken = 1000000000000000000n;
 
-      const erc20Abi = parseAbi([
-        "function balanceOf(address) public view returns (uint256)",
-        "function approve(address spender, uint256 amount) public returns (bool)",
-        "function allowance(address owner, address spender) public view returns (uint256)",
-      ]);
-
       const beforeERC20Balance = await publicClient.readContract({
         abi: erc20Abi,
         address: erc20Currency,
@@ -150,35 +149,32 @@ describe("mint-helper", () => {
         args: [mockCollector],
       });
 
-      const { request } = await publicClient.simulateContract({
-        account: mockCollector,
-        address: erc20Currency,
-        abi: erc20Abi,
-        functionName: "approve",
-        args: [erc20MinterAddress[7777777], erc20PricePerToken],
-      });
+      const quantityToMint = 3n;
+
+      const quantityErc20 = erc20PricePerToken * BigInt(quantityToMint);
+
+      const { request } = await publicClient.simulateContract(
+        requestErc20ApprovalForMint({
+          erc20MinterAddress:
+            erc20MinterAddresses[chain.id as keyof typeof erc20MinterAddresses],
+          tokenAddress: erc20Currency,
+          account: mockCollector,
+          quantityErc20,
+        }),
+      );
       const approveHash = await walletClient.writeContract(request);
       const approveTxReciept = await publicClient.waitForTransactionReceipt({
         hash: approveHash,
       });
       expect(approveTxReciept).to.not.be.null;
 
-      const beforeAllowance = await publicClient.readContract({
-        abi: erc20Abi,
-        address: erc20Currency,
-        functionName: "allowance",
-        args: [mockCollector, erc20MinterAddress[7777777]],
-      });
-      expect(beforeAllowance).to.be.equal(erc20PricePerToken);
-
-      const params = await minter.makePrepareMintTokenParams({
+      const { parameters } = await minter.mint({
         minterAccount: mockCollector,
         tokenId: targetTokenId,
-        tokenAddress: targetContract,
-        mintArguments: {
-          mintToAddress: mockCollector,
-          quantityToMint: 1,
-        },
+        tokenContract: targetContract,
+        mintRecipient: mockCollector,
+        quantityToMint,
+        mintType: "1155",
       });
 
       const beforeCollector1155Balance = await publicClient.readContract({
@@ -189,27 +185,20 @@ describe("mint-helper", () => {
       });
       expect(beforeCollector1155Balance).to.be.equal(0n);
 
-      const simulationResult = await publicClient.simulateContract(params);
+      const simulationResult = await publicClient.simulateContract(parameters);
       const hash = await walletClient.writeContract(simulationResult.request);
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
       expect(receipt).to.not.be.null;
 
-      const afterAllowance = await publicClient.readContract({
-        abi: erc20Abi,
-        address: erc20Currency,
-        functionName: "allowance",
-        args: [mockCollector, erc20MinterAddress[7777777]],
-      });
-      expect(afterAllowance).to.be.equal(0n);
-
       const afterERC20Balance = await publicClient.readContract({
         abi: erc20Abi,
         address: erc20Currency,
         functionName: "balanceOf",
         args: [mockCollector],
       });
+
       expect(beforeERC20Balance - afterERC20Balance).to.be.equal(
-        erc20PricePerToken,
+        erc20PricePerToken * quantityToMint,
       );
 
       const afterCollector1155Balance = await publicClient.readContract({
@@ -218,7 +207,7 @@ describe("mint-helper", () => {
         functionName: "balanceOf",
         args: [mockCollector, targetTokenId],
       });
-      expect(afterCollector1155Balance).to.be.equal(1n);
+      expect(afterCollector1155Balance).to.be.equal(quantityToMint);
     },
     12 * 1000,
   );