@zoralabs/protocol-sdk 0.7.6 → 0.9.0

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

@@ -8,13 +8,23 @@ import type {
   Address,
   Hex,
   PublicClient,
-  SimulateContractParameters,
   TransactionReceipt,
 } from "viem";
 import { decodeEventLog } from "viem";
 import { makeContractParameters } from "src/utils";
-import { getContractInfo } from "./contract-setup";
-import { ContractType, CreateNew1155Params, New1155Token } from "./types";
+import {
+  getContractInfoExistingContract,
+  getDeterministicContractAddress,
+  new1155ContractVersion,
+} from "./contract-setup";
+import {
+  CreateNew1155ContractAndTokenReturn,
+  CreateNew1155ContractParams,
+  CreateNew1155ParamsBase,
+  CreateNew1155TokenParams,
+  CreateNew1155TokenReturn,
+  NewContractParams,
+} from "./types";
 import { constructCreate1155TokenCalls } from "./token-setup";
 
 // Default royalty bps
@@ -22,7 +32,7 @@ const ROYALTY_BPS_DEFAULT = 1000;
 
 export const getTokenIdFromCreateReceipt = (
   receipt: TransactionReceipt,
-): bigint | undefined => {
+): bigint => {
   for (const data of receipt.logs) {
     try {
       const decodedLog = decodeEventLog({
@@ -35,73 +45,84 @@ export const getTokenIdFromCreateReceipt = (
       }
     } catch (err: any) {}
   }
+
+  throw new Error(
+    "No event found in receipt that could be used to get tokenId",
+  );
+};
+
+export const getContractAddressFromReceipt = (
+  receipt: TransactionReceipt,
+): Address => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155FactoryImplABI,
+        eventName: "SetupNewContract",
+        ...data,
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewContract") {
+        return decodedLog.args.newContract;
+      }
+    } catch (err: any) {}
+  }
+
+  throw new Error(
+    "No event found in receipt that could be used to get contract address",
+  );
 };
 
-type CreateNew1155TokenReturn = {
-  parameters: SimulateContractParameters<
-    any,
-    any,
-    any,
-    any,
-    any,
-    Account | Address
-  >;
+type MakeContractParametersBase = {
+  account: Address | Account;
+
   tokenSetupActions: Hex[];
-  collectionAddress: Address;
-  newTokenId: bigint;
-  newToken: New1155Token;
-  minter: Address;
-  contractExists: boolean;
 };
 
-function makeCreateContractAndTokenCall({
-  contractExists,
-  contractAddress,
-  contract,
+export function makeCreateContractAndTokenCall({
   account,
+  contract,
   royaltyBPS,
-  tokenSetupActions,
   fundsRecipient,
+  tokenSetupActions,
+  chainId,
 }: {
-  contractExists: boolean;
-  contractAddress: Address;
-  contract: ContractType;
-  account: Address | Account;
+  chainId: number;
+  contract: NewContractParams;
   royaltyBPS?: number;
   fundsRecipient?: Address;
-  tokenSetupActions: Hex[];
-}) {
-  if (!contractAddress && typeof contract === "string") {
-    throw new Error("Invariant: contract cannot be missing and an address");
-  }
-
-  if (!contractExists) {
-    if (typeof contract === "string") {
-      throw new Error("Invariant: expected contract object");
-    }
-
-    const accountAddress =
-      typeof account === "string" ? account : account.address;
-    return makeContractParameters({
-      abi: zoraCreator1155FactoryImplABI,
-      functionName: "createContractDeterministic",
-      account,
-      address: zoraCreator1155FactoryImplAddress[999],
-      args: [
-        contract.uri,
-        contract.name,
-        {
-          // deprecated
-          royaltyMintSchedule: 0,
-          royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
-          royaltyRecipient: fundsRecipient || accountAddress,
-        },
-        contract.defaultAdmin || accountAddress,
-        tokenSetupActions,
+} & MakeContractParametersBase) {
+  const accountAddress =
+    typeof account === "string" ? account : account.address;
+  return makeContractParameters({
+    abi: zoraCreator1155FactoryImplABI,
+    functionName: "createContractDeterministic",
+    account,
+    address:
+      zoraCreator1155FactoryImplAddress[
+        chainId as keyof typeof zoraCreator1155FactoryImplAddress
       ],
-    });
-  }
+    args: [
+      contract.uri,
+      contract.name,
+      {
+        // deprecated
+        royaltyMintSchedule: 0,
+        royaltyBPS: royaltyBPS || ROYALTY_BPS_DEFAULT,
+        royaltyRecipient: fundsRecipient || accountAddress,
+      },
+      contract.defaultAdmin || accountAddress,
+      tokenSetupActions,
+    ],
+  });
+}
 
+function makeCreateTokenCall({
+  contractAddress,
+  account,
+  tokenSetupActions,
+}: {
+  contractAddress: Address;
+} & MakeContractParametersBase) {
   return makeContractParameters({
     abi: zoraCreator1155ImplABI,
     functionName: "multicall",
@@ -126,73 +147,166 @@ export class Create1155Client {
     this.publicClient = publicClient;
   }
 
-  async createNew1155Token(props: CreateNew1155Params) {
-    return createNew1155Token({
+  async createNew1155(
+    props: CreateNew1155ContractParams,
+  ): Promise<CreateNew1155ContractAndTokenReturn> {
+    return createNew1155ContractAndToken({
       ...props,
       publicClient: this.publicClient,
       chainId: this.chainId,
     });
   }
+
+  async createNew1155OnExistingContract({
+    contractAddress: contract,
+    account,
+    token,
+    getAdditionalSetupActions,
+  }: CreateNew1155TokenParams): Promise<CreateNew1155TokenReturn> {
+    return createNew1155Token({
+      contractAddress: contract,
+      account,
+      token,
+      getAdditionalSetupActions,
+      publicClient: this.publicClient,
+      chainId: this.chainId,
+    });
+  }
 }
 
-async function createNew1155Token({
+async function createNew1155ContractAndToken({
   contract,
   account,
+  chainId,
+  token,
+  publicClient,
+  getAdditionalSetupActions,
+}: CreateNew1155ContractParams & {
+  publicClient: Pick<PublicClient, "readContract">;
+  chainId: number;
+}): Promise<CreateNew1155ContractAndTokenReturn> {
+  const nextTokenId = 1n;
+  const contractVersion = new1155ContractVersion(chainId);
+
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions,
+  } = await prepareSetupActions({
+    chainId,
+    account,
+    contractVersion,
+    nextTokenId,
+    token,
+    getAdditionalSetupActions,
+  });
+
+  const request = makeCreateContractAndTokenCall({
+    contract,
+    account,
+    chainId,
+    tokenSetupActions,
+    fundsRecipient: token.payoutRecipient,
+    royaltyBPS: token.royaltyBPS,
+  });
+
+  const contractAddress = await getDeterministicContractAddress({
+    account,
+    publicClient,
+    setupActions: tokenSetupActions,
+    chainId,
+    contract,
+  });
+
+  return {
+    parameters: request,
+    tokenSetupActions,
+    newTokenId: nextTokenId,
+    newToken,
+    contractAddress: contractAddress,
+    contractVersion,
+    minter,
+  };
+}
+
+async function createNew1155Token({
+  contractAddress: contractAddress,
+  account,
   getAdditionalSetupActions,
-  token: tokenConfig,
+  token,
   publicClient,
   chainId,
-}: CreateNew1155Params & {
+}: CreateNew1155TokenParams & {
   publicClient: Pick<PublicClient, "readContract">;
   chainId: number;
 }): Promise<CreateNew1155TokenReturn> {
-  const { contractExists, contractAddress, nextTokenId, contractVersion } =
-    await getContractInfo({
+  const { nextTokenId, contractVersion } =
+    await getContractInfoExistingContract({
       publicClient,
-      chainId: chainId,
-      contract,
-      account,
+      contractAddress: contractAddress,
     });
 
   const {
     minter,
     newToken,
     setupActions: tokenSetupActions,
-  } = constructCreate1155TokenCalls({
-    chainId: chainId,
-    ownerAddress: account,
+  } = await prepareSetupActions({
+    chainId,
+    account,
     contractVersion,
     nextTokenId,
-    ...tokenConfig,
+    token,
+    getAdditionalSetupActions,
   });
 
-  const setupActions = getAdditionalSetupActions
-    ? [
-        ...getAdditionalSetupActions({
-          tokenId: nextTokenId,
-          contractAddress,
-        }),
-        ...tokenSetupActions,
-      ]
-    : tokenSetupActions;
-
-  const request = makeCreateContractAndTokenCall({
-    contractExists,
+  const request = makeCreateTokenCall({
     contractAddress,
-    contract,
     account,
-    tokenSetupActions: setupActions,
-    royaltyBPS: tokenConfig.royaltyBPS,
-    fundsRecipient: tokenConfig.payoutRecipient,
+    tokenSetupActions,
   });
 
   return {
     parameters: request,
     tokenSetupActions,
-    collectionAddress: contractAddress,
-    contractExists,
     newTokenId: nextTokenId,
     newToken,
+    contractVersion,
     minter,
   };
 }
+
+async function prepareSetupActions({
+  chainId,
+  account,
+  contractVersion,
+  nextTokenId,
+  token,
+  getAdditionalSetupActions,
+}: {
+  chainId: number;
+  contractVersion: string;
+  nextTokenId: bigint;
+} & CreateNew1155ParamsBase) {
+  const {
+    minter,
+    newToken,
+    setupActions: tokenSetupActions,
+  } = await constructCreate1155TokenCalls({
+    chainId: chainId,
+    ownerAddress: account,
+    contractVersion,
+    nextTokenId,
+    ...token,
+  });
+
+  const setupActions = getAdditionalSetupActions
+    ? [
+        ...getAdditionalSetupActions({
+          tokenId: nextTokenId,
+        }),
+        ...tokenSetupActions,
+      ]
+    : tokenSetupActions;
+
+  return { minter, newToken, setupActions };
+}

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,81 @@ 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;
+  contractName: 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",
+  });
+
+  const contractName = await publicClient.readContract({
+    address: contractAddress,
+    abi: zoraCreator1155ImplABI,
+    functionName: "name",
+  });
 
   return {
-    contractExists,
-    contractAddress,
     contractVersion,
+    contractName,
     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/minter-defaults.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect, assert } from "vitest";
+import { parseNameIntoSymbol } from "./minter-defaults";
+
+describe("parseNameIntoSymbol", () => {
+  it("removes spaces and vowels and converts to uppercase", () => {
+    const symbol = parseNameIntoSymbol("My 4 To *5 @-Name");
+
+    expect(symbol).toBe("$MY4T");
+  });
+  it("works with less than 4 characters", () => {
+    const symbol = parseNameIntoSymbol("M4y a");
+
+    expect(symbol).toBe("$M4Y");
+  });
+
+  it("works with no characters", () => {
+    assert.throws(() => {
+      parseNameIntoSymbol("AEIO U");
+    }, "Not enough valid characters to generate a symbol");
+  });
+});

package/src/create/minter-defaults.ts

@@ -0,0 +1,134 @@
+import { Concrete } from "src/utils";
+import {
+  SalesConfigParamsType,
+  AllowListParamType,
+  Erc20ParamsType,
+  FixedPriceParamsType,
+  SaleStartAndEnd,
+  MaxTokensPerAddress,
+  ConcreteSalesConfig,
+  TimedSaleParamsType,
+} from "./types";
+import { fetchTokenMetadata } from "src/ipfs/token-metadata";
+
+// Sales end forever amount (uint64 max)
+export const SALE_END_FOREVER = 18446744073709551615n;
+
+const DEFAULT_SALE_START_AND_END: Concrete<SaleStartAndEnd> = {
+  // Sale start time – defaults to beginning of unix time
+  saleStart: 0n,
+  // This is the end of uint64, plenty of time
+  saleEnd: SALE_END_FOREVER,
+};
+
+const DEFAULT_MAX_TOKENS_PER_ADDRESS: Concrete<MaxTokensPerAddress> = {
+  maxTokensPerAddress: 0n,
+};
+
+const erc20SaleSettingsWithDefaults = (
+  params: Erc20ParamsType,
+): Concrete<Erc20ParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  ...params,
+});
+
+const allowListWithDefaults = (
+  allowlist: AllowListParamType,
+): Concrete<AllowListParamType> => {
+  return {
+    ...DEFAULT_SALE_START_AND_END,
+    ...allowlist,
+  };
+};
+
+const fixedPriceSettingsWithDefaults = (
+  params: FixedPriceParamsType,
+): Concrete<FixedPriceParamsType> => ({
+  ...DEFAULT_SALE_START_AND_END,
+  ...DEFAULT_MAX_TOKENS_PER_ADDRESS,
+  type: "fixedPrice",
+  ...params,
+});
+
+export const parseNameIntoSymbol = (name: string) => {
+  if (name === "") {
+    throw new Error("Name must be provided to generate a symbol");
+  }
+  const result =
+    "$" +
+    name
+      // Remove all non-alphanumeric characters
+      .replace(/[^a-zA-Z0-9]/g, "")
+      // and leading dollar signs
+      .replace(/^\$+/, "")
+      .toUpperCase()
+      // Remove all vowels and spaces
+      .replace(/[AEIOU\s]/g, "")
+      // Strip down to 4 characters
+      .slice(0, 4);
+
+  if (result === "$") {
+    throw new Error("Not enough valid characters to generate a symbol");
+  }
+
+  return result;
+};
+
+async function fetchTokenNameFromMetadata(
+  tokenMetadataURI: string,
+): Promise<string> {
+  const tokenMetadata = await fetchTokenMetadata(tokenMetadataURI);
+
+  if (!tokenMetadata.name) {
+    throw new Error("No name found in token metadata");
+  }
+
+  return tokenMetadata.name;
+}
+const timedSaleSettingsWithDefaults = async (
+  params: TimedSaleParamsType,
+  tokenMetadataURI: string,
+): Promise<Concrete<TimedSaleParamsType>> => {
+  // If the name is not provided, try to fetch it from the metadata
+  const erc20Name =
+    params.erc20Name || (await fetchTokenNameFromMetadata(tokenMetadataURI));
+  const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
+
+  return {
+    type: "timed",
+    ...DEFAULT_SALE_START_AND_END,
+    erc20Name,
+    erc20Symbol: symbol,
+  };
+};
+
+const isAllowList = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is AllowListParamType => salesConfig.type === "allowlistMint";
+const isErc20 = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is Erc20ParamsType => salesConfig.type === "erc20Mint";
+const isFixedPrice = (
+  salesConfig: SalesConfigParamsType,
+): salesConfig is FixedPriceParamsType => {
+  return (salesConfig as FixedPriceParamsType).pricePerToken > 0n;
+};
+
+export const getSalesConfigWithDefaults = async (
+  salesConfig: SalesConfigParamsType | undefined,
+  tokenMetadataURI: string,
+): Promise<ConcreteSalesConfig> => {
+  if (!salesConfig) return timedSaleSettingsWithDefaults({}, tokenMetadataURI);
+  if (isAllowList(salesConfig)) {
+    return allowListWithDefaults(salesConfig);
+  }
+  if (isErc20(salesConfig)) {
+    return erc20SaleSettingsWithDefaults(salesConfig);
+  }
+  if (isFixedPrice(salesConfig)) {
+    return fixedPriceSettingsWithDefaults(salesConfig);
+  }
+
+  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+};