@zoralabs/protocol-sdk 0.5.16 → 0.6.0

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

@@ -2,177 +2,24 @@ import {
   zoraCreator1155FactoryImplABI,
   zoraCreator1155FactoryImplAddress,
   zoraCreator1155ImplABI,
-  zoraCreatorFixedPriceSaleStrategyABI,
 } from "@zoralabs/protocol-deployments";
 import type {
   Account,
   Address,
   Hex,
+  PublicClient,
   SimulateContractParameters,
   TransactionReceipt,
 } from "viem";
-import { decodeEventLog, encodeFunctionData, zeroAddress } from "viem";
-import { OPEN_EDITION_MINT_SIZE } from "../constants";
-import {
-  makeSimulateContractParamaters,
-  ClientConfig,
-  PublicClient,
-  setupClient,
-} from "src/utils";
-
-// Sales end forever amount (uint64 max)
-const SALE_END_FOREVER = 18446744073709551615n;
+import { decodeEventLog } from "viem";
+import { makeContractParameters } from "src/utils";
+import { getContractInfo } from "./contract-setup";
+import { ContractType, CreateNew1155Params, New1155Token } from "./types";
+import { constructCreate1155TokenCalls } from "./token-setup";
 
 // Default royalty bps
 const ROYALTY_BPS_DEFAULT = 1000;
 
-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;
-  fundsRecipient?: Address;
-};
-
-export const DEFAULT_SALE_SETTINGS = {
-  fundsRecipient: 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,
-};
-
-// Hardcode the permission bit for the minter
-const PERMISSION_BIT_MINTER = 4n;
-
-type ContractType =
-  | {
-      name: string;
-      uri: string;
-      defaultAdmin?: Address;
-    }
-  | Address;
-
-type RoyaltySettingsType = {
-  royaltyBPS: number;
-  royaltyRecipient: Address;
-};
-
-export function create1155TokenSetupArgs({
-  nextTokenId,
-  // How many NFTs upon initialization to mint to the creator
-  mintToCreatorCount,
-  tokenMetadataURI,
-  // Fixed price minter address – required minter
-  fixedPriceMinterAddress,
-  // Address to use as the create referral, optional.
-  createReferral,
-  // Optional max supply of the token. Default unlimited
-  maxSupply,
-  // wallet sending the transaction
-  account,
-  salesConfig,
-  royaltySettings,
-}: {
-  maxSupply?: bigint | number;
-  createReferral?: Address;
-  nextTokenId: bigint;
-  mintToCreatorCount: bigint | number;
-  // wallet sending the transaction
-  account: Address;
-  tokenMetadataURI: string;
-  fixedPriceMinterAddress: Address;
-  salesConfig: SalesConfigParamsType;
-  royaltySettings?: RoyaltySettingsType;
-}) {
-  if (!maxSupply) {
-    maxSupply = OPEN_EDITION_MINT_SIZE;
-  }
-  maxSupply = BigInt(maxSupply);
-  mintToCreatorCount = BigInt(mintToCreatorCount);
-
-  const salesConfigWithDefaults = {
-    // Set static sales default.
-    ...DEFAULT_SALE_SETTINGS,
-    // Override with user settings.
-    ...salesConfig,
-  };
-
-  const setupActions = [
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
-      functionName: "assumeLastTokenIdMatches",
-      args: [nextTokenId - 1n],
-    }),
-    createReferral
-      ? encodeFunctionData({
-          abi: zoraCreator1155ImplABI,
-          functionName: "setupNewTokenWithCreateReferral",
-          args: [tokenMetadataURI, maxSupply, createReferral],
-        })
-      : encodeFunctionData({
-          abi: zoraCreator1155ImplABI,
-          functionName: "setupNewToken",
-          args: [tokenMetadataURI, maxSupply],
-        }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
-      functionName: "addPermission",
-      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER],
-    }),
-    encodeFunctionData({
-      abi: zoraCreator1155ImplABI,
-      functionName: "callSale",
-      args: [
-        nextTokenId,
-        fixedPriceMinterAddress,
-        encodeFunctionData({
-          abi: zoraCreatorFixedPriceSaleStrategyABI,
-          functionName: "setSale",
-          args: [nextTokenId, salesConfigWithDefaults],
-        }),
-      ],
-    }),
-  ];
-
-  if (mintToCreatorCount) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI,
-        functionName: "adminMint",
-        args: [account, nextTokenId, mintToCreatorCount, "0x"],
-      }),
-    );
-  }
-
-  if (royaltySettings) {
-    setupActions.push(
-      encodeFunctionData({
-        abi: zoraCreator1155ImplABI,
-        functionName: "updateRoyaltiesForToken",
-        args: [
-          nextTokenId,
-          {
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account,
-          },
-        ],
-      }),
-    );
-  }
-
-  return setupActions;
-}
-
 export const getTokenIdFromCreateReceipt = (
   receipt: TransactionReceipt,
 ): bigint | undefined => {
@@ -190,50 +37,8 @@ export const getTokenIdFromCreateReceipt = (
   }
 };
 
-async function getContractExists(
-  publicClient: PublicClient,
-  contract: ContractType,
-  // Account that is the creator of the contract
-  account: Address,
-) {
-  let contractAddress;
-  let contractExists = false;
-  if (typeof contract !== "string") {
-    contractAddress = await publicClient.readContract({
-      abi: zoraCreator1155FactoryImplABI,
-      // Since this address is deterministic we can hardcode a chain id safely here.
-      address: zoraCreator1155FactoryImplAddress[999],
-      functionName: "deterministicContractAddress",
-      args: [
-        account,
-        contract.uri,
-        contract.name,
-        contract.defaultAdmin || account,
-      ],
-    });
-
-    try {
-      await publicClient.readContract({
-        abi: zoraCreator1155ImplABI,
-        address: contractAddress,
-        functionName: "contractVersion",
-      });
-      contractExists = true;
-    } catch (e: any) {
-      // This logic branch is hit if the contract doesn't exist
-      //  falling back to contractExists to false.
-    }
-    return { contractAddress, contractExists };
-  }
-
-  return {
-    contractExists: true,
-    contractAddress: contract,
-  };
-}
-
 type CreateNew1155TokenReturn = {
-  request: SimulateContractParameters<
+  parameters: SimulateContractParameters<
     any,
     any,
     any,
@@ -242,125 +47,152 @@ type CreateNew1155TokenReturn = {
     Account | Address
   >;
   tokenSetupActions: Hex[];
-  contractAddress: Address;
+  collectionAddress: Address;
+  newTokenId: bigint;
+  newToken: New1155Token;
+  minter: Address;
   contractExists: boolean;
 };
 
-export function create1155CreatorClient(clientConfig: ClientConfig) {
-  const { publicClient } = setupClient(clientConfig);
-  async function createNew1155Token({
-    contract,
-    tokenMetadataURI,
-    mintToCreatorCount = 1,
-    salesConfig = {},
-    maxSupply,
-    account,
-    royaltySettings,
-    createReferral,
-    getAdditionalSetupActions,
-  }: {
-    account: Address;
-    maxSupply?: bigint | number;
-    royaltySettings?: RoyaltySettingsType;
-    royaltyBPS?: number;
-    contract: ContractType;
-    tokenMetadataURI: string;
-    mintToCreatorCount?: bigint | number;
-    salesConfig?: SalesConfigParamsType;
-    createReferral?: Address;
-    getAdditionalSetupActions?: (args: {
-      tokenId: bigint;
-      contractAddress: Address;
-    }) => Hex[];
-  }): Promise<CreateNew1155TokenReturn> {
-    // Check if contract exists either from metadata or the static address passed in.
-    // If a static address is passed in, this fails if that contract does not exist.
-    const { contractExists, contractAddress } = await getContractExists(
-      publicClient,
-      contract,
-      account,
-    );
-
-    // Assume the next token id is the first token available for a new contract.
-    let nextTokenId = 1n;
+function makeCreateContractAndTokenCall({
+  contractExists,
+  contractAddress,
+  contract,
+  account,
+  royaltyBPS,
+  tokenSetupActions,
+  fundsRecipient,
+}: {
+  contractExists: boolean;
+  contractAddress: Address;
+  contract: ContractType;
+  account: Address | Account;
+  royaltyBPS?: number;
+  fundsRecipient?: Address;
+  tokenSetupActions: Hex[];
+}) {
+  if (!contractAddress && typeof contract === "string") {
+    throw new Error("Invariant: contract cannot be missing and an address");
+  }
 
-    if (contractExists) {
-      nextTokenId = await publicClient.readContract({
-        abi: zoraCreator1155ImplABI,
-        functionName: "nextTokenId",
-        address: contractAddress,
-      });
+  if (!contractExists) {
+    if (typeof contract === "string") {
+      throw new Error("Invariant: expected contract object");
     }
 
-    // Get the fixed price minter to use within the new token to set the sales configuration.
-    const fixedPriceMinterAddress = await publicClient.readContract({
+    const accountAddress =
+      typeof account === "string" ? account : account.address;
+    return makeContractParameters({
       abi: zoraCreator1155FactoryImplABI,
+      functionName: "createContractDeterministic",
+      account,
       address: zoraCreator1155FactoryImplAddress[999],
-      functionName: "fixedPriceMinter",
+      args: [
+        contract.uri,
+        contract.name,
+        {
+          // deprecated
+          royaltyMintSchedule: 0,
+          royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+          royaltyRecipient: fundsRecipient || accountAddress,
+        },
+        contract.defaultAdmin || accountAddress,
+        tokenSetupActions,
+      ],
     });
+  }
+
+  return makeContractParameters({
+    abi: zoraCreator1155ImplABI,
+    functionName: "multicall",
+    account,
+    address: contractAddress,
+    args: [tokenSetupActions],
+  });
+}
+
+export class Create1155Client {
+  private readonly chainId: number;
+  private readonly publicClient: Pick<PublicClient, "readContract">;
 
-    let tokenSetupActions = create1155TokenSetupArgs({
-      tokenMetadataURI,
-      nextTokenId,
-      salesConfig,
-      maxSupply,
-      fixedPriceMinterAddress,
+  constructor({
+    chainId,
+    publicClient,
+  }: {
+    chainId: number;
+    publicClient: Pick<PublicClient, "readContract">;
+  }) {
+    this.chainId = chainId;
+    this.publicClient = publicClient;
+  }
+
+  async createNew1155Token(props: CreateNew1155Params) {
+    return createNew1155Token({
+      ...props,
+      publicClient: this.publicClient,
+      chainId: this.chainId,
+    });
+  }
+}
+
+async function createNew1155Token({
+  contract,
+  account,
+  getAdditionalSetupActions,
+  token: tokenConfig,
+  publicClient,
+  chainId,
+}: CreateNew1155Params & {
+  publicClient: Pick<PublicClient, "readContract">;
+  chainId: number;
+}): Promise<CreateNew1155TokenReturn> {
+  const { contractExists, contractAddress, nextTokenId, contractVersion } =
+    await getContractInfo({
+      publicClient,
+      chainId: chainId,
+      contract,
       account,
-      mintToCreatorCount,
-      royaltySettings,
-      createReferral,
     });
-    if (getAdditionalSetupActions) {
-      tokenSetupActions = [
-        ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
+
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions,
+  } = constructCreate1155TokenCalls({
+    chainId: chainId,
+    ownerAddress: account,
+    contractVersion,
+    nextTokenId,
+    ...tokenConfig,
+  });
+
+  const setupActions = getAdditionalSetupActions
+    ? [
+        ...getAdditionalSetupActions({
+          tokenId: nextTokenId,
+          contractAddress,
+        }),
         ...tokenSetupActions,
-      ];
-    }
+      ]
+    : tokenSetupActions;
 
-    if (!contractAddress && typeof contract === "string") {
-      throw new Error("Invariant: contract cannot be missing and an address");
-    }
-    if (!contractExists && typeof contract !== "string") {
-      const request = makeSimulateContractParamaters({
-        abi: zoraCreator1155FactoryImplABI,
-        functionName: "createContractDeterministic",
-        account,
-        address: zoraCreator1155FactoryImplAddress[999],
-        args: [
-          contract.uri,
-          contract.name,
-          {
-            // deprecated
-            royaltyMintSchedule: 0,
-            royaltyBPS: royaltySettings?.royaltyBPS || ROYALTY_BPS_DEFAULT,
-            royaltyRecipient: royaltySettings?.royaltyRecipient || account,
-          },
-          contract.defaultAdmin || account,
-          tokenSetupActions,
-        ],
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists,
-      };
-    } else if (contractExists) {
-      const request = makeSimulateContractParamaters({
-        abi: zoraCreator1155ImplABI,
-        functionName: "multicall",
-        account,
-        address: contractAddress,
-        args: [tokenSetupActions],
-      });
-      return {
-        request,
-        tokenSetupActions,
-        contractAddress,
-        contractExists,
-      };
-    }
-    throw new Error("Unsupported contract argument type");
-  }
-  return { createNew1155Token };
+  const request = makeCreateContractAndTokenCall({
+    contractExists,
+    contractAddress,
+    contract,
+    account,
+    tokenSetupActions: setupActions,
+    royaltyBPS: tokenConfig.royaltyBPS,
+    fundsRecipient: tokenConfig.payoutRecipient,
+  });
+
+  return {
+    parameters: request,
+    tokenSetupActions,
+    collectionAddress: contractAddress,
+    contractExists,
+    newTokenId: nextTokenId,
+    newToken,
+    minter,
+  };
 }

package/src/create/contract-setup.ts

@@ -0,0 +1,88 @@
+import { Address, PublicClient } from "viem";
+import { ContractType } from "./types";
+import {
+  contracts1155,
+  zoraCreator1155FactoryImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155ImplABI,
+} from "@zoralabs/protocol-deployments";
+
+type contracts1155Address = keyof typeof contracts1155.addresses;
+function new1155ContractVersion(chainId: number): string {
+  const address = contracts1155.addresses[chainId as contracts1155Address];
+  if (!address) {
+    throw new Error(`No contract address for chainId ${chainId}`);
+  }
+
+  return address.CONTRACT_1155_IMPL_VERSION;
+}
+
+export async function getContractInfo({
+  publicClient,
+  chainId,
+  contract,
+  account,
+}: {
+  publicClient: Pick<PublicClient, "readContract">;
+  chainId: number;
+  contract: ContractType;
+  // Account that is the creator of the contract
+  account: Address;
+}): Promise<{
+  contractExists: boolean;
+  contractAddress: Address;
+  contractVersion: string;
+  nextTokenId: bigint;
+}> {
+  // Check if contract exists either from metadata or the static address passed in.
+  // If a static address is passed in, this fails if that contract does not exist.
+  const contractAddress =
+    typeof contract === "string"
+      ? contract
+      : await publicClient.readContract({
+          abi: zoraCreator1155FactoryImplABI,
+          // Since this address is deterministic we can hardcode a chain id safely here.
+          address:
+            zoraCreator1155FactoryImplAddress[
+              chainId as keyof typeof zoraCreator1155FactoryImplAddress
+            ],
+          functionName: "deterministicContractAddress",
+          args: [
+            account,
+            contract.uri,
+            contract.name,
+            contract.defaultAdmin || account,
+          ],
+        });
+
+  let contractVersion: string;
+  let contractExists: boolean;
+  try {
+    contractVersion = await publicClient.readContract({
+      abi: zoraCreator1155ImplABI,
+      address: contractAddress,
+      functionName: "contractVersion",
+    });
+    contractExists = true;
+  } catch (e: any) {
+    // This logic branch is hit if the contract doesn't exist
+    //  falling back to contractExists to false.
+    contractVersion = new1155ContractVersion(chainId);
+    contractExists = false;
+  }
+
+  const nextTokenId = contractExists
+    ? await publicClient.readContract({
+        address: contractAddress,
+        abi: zoraCreator1155ImplABI,
+        functionName: "nextTokenId",
+      })
+    : 1n;
+
+  return {
+    contractExists,
+    contractAddress,
+    contractVersion,
+    nextTokenId,
+  };
+}