@zoralabs/protocol-sdk 0.9.1 → 0.9.3

package/src/create/minter-defaults.ts

@@ -9,7 +9,6 @@ import {
   ConcreteSalesConfig,
   TimedSaleParamsType,
 } from "./types";
-import { fetchTokenMetadata } from "src/ipfs/token-metadata";
 
 // Sales end forever amount (uint64 max)
 export const SALE_END_FOREVER = 18446744073709551615n;
@@ -75,30 +74,19 @@ export const parseNameIntoSymbol = (name: string) => {
   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,
+  contractName: 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 erc20Name = params.erc20Name || contractName;
   const symbol = params.erc20Symbol || parseNameIntoSymbol(erc20Name);
 
   return {
     type: "timed",
     ...DEFAULT_SALE_START_AND_END,
-    erc20Name,
+    ...params,
+    erc20Name: erc20Name,
     erc20Symbol: symbol,
   };
 };
@@ -112,14 +100,17 @@ const isErc20 = (
 const isFixedPrice = (
   salesConfig: SalesConfigParamsType,
 ): salesConfig is FixedPriceParamsType => {
-  return (salesConfig as FixedPriceParamsType).pricePerToken > 0n;
+  return (
+    salesConfig.type === "fixedPrice" ||
+    (salesConfig as FixedPriceParamsType).pricePerToken > 0n
+  );
 };
 
 export const getSalesConfigWithDefaults = async (
   salesConfig: SalesConfigParamsType | undefined,
-  tokenMetadataURI: string,
+  contractName: string,
 ): Promise<ConcreteSalesConfig> => {
-  if (!salesConfig) return timedSaleSettingsWithDefaults({}, tokenMetadataURI);
+  if (!salesConfig) return timedSaleSettingsWithDefaults({}, contractName);
   if (isAllowList(salesConfig)) {
     return allowListWithDefaults(salesConfig);
   }
@@ -130,5 +121,5 @@ export const getSalesConfigWithDefaults = async (
     return fixedPriceSettingsWithDefaults(salesConfig);
   }
 
-  return timedSaleSettingsWithDefaults(salesConfig, tokenMetadataURI);
+  return timedSaleSettingsWithDefaults(salesConfig, contractName);
 };

package/src/create/subgraph-queries.ts

@@ -0,0 +1,35 @@
+import { ISubgraphQuery } from "src/apis/subgraph-querier";
+import { Address } from "viem";
+
+export function buildContractInfoQuery({
+  contractAddress,
+}: {
+  contractAddress: Address;
+}): ISubgraphQuery<{
+  name: string;
+  contractVersion: string;
+  mintFeePerQuantity: string;
+  tokens: {
+    tokenId: Address;
+  }[];
+}> {
+  return {
+    query: `
+    query ($contractAddress: Bytes!) {
+      zoraCreateContract(id: $contractAddress) {
+        contractVersion
+        name
+        mintFeePerQuantity
+        tokens(first: 1, orderBy: tokenId, orderDirection: desc) {
+          tokenId
+        }
+      }
+    }
+    `,
+    variables: {
+      contractAddress: contractAddress.toLowerCase(),
+    },
+    parseResponseData: (responseData: any | undefined) =>
+      responseData.zoraCreateContract,
+  };
+}

package/src/create/token-setup.ts

@@ -9,6 +9,7 @@ import { setupMinters } from "./minter-setup";
 async function applyNew1155Defaults(
   props: CreateNew1155TokenProps,
   ownerAddress: Address,
+  contractName: string,
 ): Promise<New1155Token> {
   const { payoutRecipient: fundsRecipient } = props;
   const fundsRecipientOrOwner =
@@ -26,7 +27,7 @@ async function applyNew1155Defaults(
     tokenMetadataURI: props.tokenMetadataURI,
     salesConfig: await getSalesConfigWithDefaults(
       props.salesConfig,
-      props.tokenMetadataURI,
+      contractName,
     ),
   };
 }
@@ -117,6 +118,8 @@ export async function constructCreate1155TokenCalls(
     ContractProps & {
       ownerAddress: Address;
       chainId: number;
+    } & {
+      contractName: string;
     },
 ): Promise<{
   setupActions: `0x${string}`[];
@@ -134,6 +137,7 @@ export async function constructCreate1155TokenCalls(
   const new1155TokenPropsWithDefaults = await applyNew1155Defaults(
     props,
     ownerAddress,
+    props.contractName,
   );
 
   const verifyTokenIdExpected = encodeFunctionData({

package/src/create/types.ts

@@ -29,7 +29,7 @@ export type FixedPriceParamsType = SaleStartAndEnd &
 
 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.
+  // Name of the erc20z token to create for the secondary sale.  If not provided, uses the contract name
   erc20Name?: string;
   // Symbol of the erc20z token to create for the secondary sale.  If not provided, extracts it from the name.
   erc20Symbol?: string;

package/src/mint/subgraph-mint-getter.ts

@@ -1,6 +1,10 @@
 import { Address } from "viem";
 import { httpClient as defaultHttpClient } from "../apis/http-api-base";
-import { ISubgraphQuerier, SubgraphQuerier } from "../apis/subgraph-querier";
+import {
+  ISubgraphQuerier,
+  ISubgraphQuery,
+  SubgraphQuerier,
+} from "../apis/subgraph-querier";
 import { NetworkConfig, networkConfigByChain } from "src/apis/chain-constants";
 import { GenericTokenIdTypes } from "src/types";
 import {
@@ -14,7 +18,6 @@ import {
   buildContractTokensQuery,
   buildNftTokenSalesQuery,
   buildPremintsOfContractQuery,
-  ISubgraphQuery,
   SalesStrategyResult,
   TokenQueryResult,
 } from "./subgraph-queries";

package/src/mint/subgraph-queries.ts

@@ -1,3 +1,4 @@
+import { ISubgraphQuery } from "src/apis/subgraph-querier";
 import { GenericTokenIdTypes } from "src/types";
 import { Address } from "viem";
 
@@ -189,13 +190,6 @@ query ($contract: Bytes!) {
       responseData?.zoraCreateTokens,
   };
 }
-
-export type ISubgraphQuery<T> = {
-  query: string;
-  variables: Record<string, any>;
-  parseResponseData: (data: any | undefined) => T | undefined;
-};
-
 export function buildPremintsOfContractQuery({
   tokenAddress,
 }: {

package/src/retries.ts

@@ -0,0 +1,49 @@
+async function wait(delayMs: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+const retryInternal = async <T>({
+  tryFn,
+  maxTries = 3,
+  atTry,
+  linearBackoffMS = 200,
+  shouldRetryOnError = () => true,
+}: {
+  tryFn: () => T;
+  maxTries?: number;
+  atTry: number;
+  linearBackoffMS?: number;
+  shouldRetryOnError?: (err: any) => boolean;
+}): Promise<T> => {
+  try {
+    return await tryFn();
+  } catch (err: any) {
+    if (shouldRetryOnError(err)) {
+      if (atTry <= maxTries) {
+        await wait(atTry * linearBackoffMS);
+        return await retryInternal({
+          tryFn,
+          maxTries,
+          atTry: atTry + 1,
+          linearBackoffMS,
+          shouldRetryOnError,
+        });
+      }
+    }
+    throw err;
+  }
+};
+
+export const retriesGeneric = async <T>(params: {
+  tryFn: () => T;
+  maxTries?: number;
+  linearBackoffMS?: number;
+  shouldRetryOnError?: (err: any) => boolean;
+}) => {
+  return retryInternal({
+    ...params,
+    atTry: 1,
+  });
+};

package/src/sdk.ts

@@ -8,6 +8,10 @@ import { ClientConfig } from "./utils";
 import { IPremintAPI, PremintAPIClient } from "./premint/premint-api-client";
 import { SubgraphMintGetter } from "./mint/subgraph-mint-getter";
 import { IOnchainMintGetter } from "./mint/types";
+import {
+  IContractGetter,
+  SubgraphContractGetter,
+} from "./create/contract-getter";
 
 export type CreatorClient = {
   createPremint: PremintClient["createPremint"];
@@ -29,6 +33,7 @@ export type CollectorClient = {
 export type CreatorClientConfig = ClientConfig & {
   /** API for submitting and getting premints.  Defaults to the Zora Premint API */
   premintApi?: IPremintAPI;
+  contractGetter?: IContractGetter;
 };
 
 /**
@@ -50,6 +55,9 @@ export function createCreatorClient(
   const create1155CreatorClient = new Create1155Client({
     chainId: clientConfig.chainId,
     publicClient: clientConfig.publicClient,
+    contractGetter:
+      clientConfig.contractGetter ||
+      new SubgraphContractGetter(clientConfig.chainId),
   });
 
   return {

package/test-integration/create-multiple-tokens-on-contract.ts

@@ -0,0 +1,104 @@
+import { createCreatorClient } from "src";
+import {
+  Address,
+  Chain,
+  LocalAccount,
+  createPublicClient,
+  createWalletClient,
+  http,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { zoraSepolia } from "viem/chains";
+
+const publicClient = createPublicClient({
+  chain: zoraSepolia as Chain,
+  transport: http(),
+});
+
+const walletClient = createWalletClient({
+  chain: zoraSepolia,
+  transport: http(),
+});
+
+const creatorClient = createCreatorClient({
+  chainId: zoraSepolia.id,
+  publicClient,
+});
+
+export const createMultipleTokensOnContract = async ({
+  creatorAccount,
+}: {
+  creatorAccount: LocalAccount;
+}) => {
+  console.log({ address: creatorAccount.address });
+  const { contractAddress, parameters } = await creatorClient.create1155({
+    account: creatorAccount.address,
+    contract: {
+      name: "testContractD",
+      uri: "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+    },
+    token: {
+      tokenMetadataURI:
+        "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+    },
+  });
+  console.log("creating contract and token");
+
+  const { request: requestA } = await publicClient.simulateContract(parameters);
+
+  const hashA = await walletClient.writeContract({
+    ...requestA,
+    account: creatorAccount,
+  });
+
+  const receiptA = await publicClient.waitForTransactionReceipt({
+    hash: hashA,
+  });
+
+  if (receiptA.status !== "success") {
+    throw new Error("create new contract failed");
+  }
+
+  console.log("creating new token on contract");
+
+  const { parameters: parametersB } =
+    await creatorClient.create1155OnExistingContract({
+      account: creatorAccount.address,
+      contractAddress,
+      token: {
+        tokenMetadataURI:
+          "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+      },
+    });
+
+  const { request: requestB } =
+    await publicClient.simulateContract(parametersB);
+
+  const hashB = await walletClient.writeContract({
+    ...requestB,
+    account: creatorAccount,
+  });
+
+  const receiptB = await publicClient.waitForTransactionReceipt({
+    hash: hashB,
+  });
+
+  if (receiptB.status !== "success") {
+    throw new Error("create token on contract failed");
+  }
+
+  console.log("created multiple tokens on contract");
+};
+
+const setupTestContracts = async () => {
+  const creatorAccount = privateKeyToAccount(
+    process.env.VITE_PRIVATE_KEY! as Address,
+  );
+
+  // create 2 premints on a contract
+  await createMultipleTokensOnContract({
+    creatorAccount,
+  });
+};
+
+setupTestContracts();