@zoralabs/protocol-sdk 0.7.6 → 0.8.0

package/src/create/contract-setup.ts

@@ -1,14 +1,15 @@
-import { Address, PublicClient } from "viem";
-import { ContractType } from "./types";
+import { Address, Hex, PublicClient } from "viem";
 import {
   contracts1155,
   zoraCreator1155FactoryImplABI,
   zoraCreator1155FactoryImplAddress,
   zoraCreator1155ImplABI,
 } from "@zoralabs/protocol-deployments";
+import { NewContractParams } from "./types";
 
 type contracts1155Address = keyof typeof contracts1155.addresses;
-function new1155ContractVersion(chainId: number): string {
+export function new1155ContractVersion(chainId: number): string {
+  // todo: get from subgraph
   const address = contracts1155.addresses[chainId as contracts1155Address];
   if (!address) {
     throw new Error(`No contract address for chainId ${chainId}`);
@@ -17,72 +18,73 @@ function new1155ContractVersion(chainId: number): string {
   return address.CONTRACT_1155_IMPL_VERSION;
 }
 
-export async function getContractInfo({
+export async function getContractInfoExistingContract({
   publicClient,
-  chainId,
-  contract,
-  account,
+  contractAddress,
 }: {
   publicClient: Pick<PublicClient, "readContract">;
-  chainId: number;
-  contract: ContractType;
+  contractAddress: Address;
   // 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;
+    throw new Error(`Contract does not exist at ${contractAddress}`);
   }
 
-  const nextTokenId = contractExists
-    ? await publicClient.readContract({
-        address: contractAddress,
-        abi: zoraCreator1155ImplABI,
-        functionName: "nextTokenId",
-      })
-    : 1n;
+  const nextTokenId = await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI,
+    functionName: "nextTokenId",
+  });
 
   return {
-    contractExists,
-    contractAddress,
     contractVersion,
     nextTokenId,
   };
 }
+
+export async function getDeterministicContractAddress({
+  publicClient,
+  account,
+  setupActions,
+  contract,
+  chainId,
+}: {
+  account: Address;
+  publicClient: Pick<PublicClient, "readContract">;
+  setupActions: Hex[];
+  contract: NewContractParams;
+  chainId: number;
+  // Account that is the creator of the contract
+}): Promise<Address> {
+  const contractAddress = await publicClient.readContract({
+    abi: zoraCreator1155FactoryImplABI,
+    address:
+      zoraCreator1155FactoryImplAddress[
+        chainId as keyof typeof zoraCreator1155FactoryImplAddress
+      ],
+    functionName: "deterministicContractAddressWithSetupActions",
+    args: [
+      account,
+      contract.uri,
+      contract.name,
+      contract.defaultAdmin || account,
+      setupActions,
+    ],
+  });
+
+  return contractAddress;
+}

package/src/create/types.ts

@@ -1,13 +1,11 @@
 import { Concrete } from "src/utils";
-import { Address, Hex } from "viem";
+import { Account, Address, Hex, SimulateContractParameters } from "viem";
 
-export type ContractType =
-  | {
-      name: string;
-      uri: string;
-      defaultAdmin?: Address;
-    }
-  | Address;
+export type NewContractParams = {
+  name: string;
+  uri: string;
+  defaultAdmin?: Address;
+};
 
 export type SalesConfigParamsType = {
   // defaults to 0
@@ -22,16 +20,20 @@ export type SalesConfigParamsType = {
   currency?: Address;
 };
 
-export type CreateNew1155Params = {
+export type CreateNew1155ParamsBase = {
   account: Address;
-  contract: ContractType;
-  getAdditionalSetupActions?: (args: {
-    tokenId: bigint;
-    contractAddress: Address;
-  }) => Hex[];
+  getAdditionalSetupActions?: (args: { tokenId: bigint }) => Hex[];
   token: CreateNew1155TokenProps;
 };
 
+export type CreateNew1155ContractParams = CreateNew1155ParamsBase & {
+  contract: NewContractParams;
+};
+
+export type CreateNew1155TokenParams = CreateNew1155ParamsBase & {
+  contractAddress: Address;
+};
+
 export interface CreateNew1155TokenProps {
   maxSupply?: bigint | number;
   tokenMetadataURI: string;
@@ -55,3 +57,23 @@ export type New1155Token = {
   salesConfig: Concrete<SalesConfigParamsType>;
   tokenMetadataURI: string;
 };
+
+export type CreateNew1155TokenReturn = {
+  parameters: SimulateContractParameters<
+    any,
+    any,
+    any,
+    any,
+    any,
+    Account | Address
+  >;
+  tokenSetupActions: Hex[];
+  newTokenId: bigint;
+  newToken: New1155Token;
+  minter: Address;
+  contractVersion: string;
+};
+
+export type CreateNew1155ContractAndTokenReturn = {
+  contractAddress: Address;
+} & CreateNew1155TokenReturn;

package/src/sdk.ts

@@ -13,7 +13,8 @@ export type CreatorClient = {
   createPremint: PremintClient["createPremint"];
   updatePremint: PremintClient["updatePremint"];
   deletePremint: PremintClient["deletePremint"];
-  create1155: Create1155Client["createNew1155Token"];
+  create1155: Create1155Client["createNew1155"];
+  create1155OnExistingContract: Create1155Client["createNew1155OnExistingContract"];
 };
 
 export type CollectorClient = {
@@ -55,7 +56,9 @@ export function createCreatorClient(
     createPremint: (p) => premintClient.createPremint(p),
     updatePremint: (p) => premintClient.updatePremint(p),
     deletePremint: (p) => premintClient.deletePremint(p),
-    create1155: (p) => create1155CreatorClient.createNew1155Token(p),
+    create1155: (p) => create1155CreatorClient.createNew1155(p),
+    create1155OnExistingContract: (p) =>
+      create1155CreatorClient.createNew1155OnExistingContract(p),
   };
 }