@zoralabs/protocol-sdk 0.2.0

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

@@ -0,0 +1,342 @@
+import {
+  zoraCreator1155FactoryImplABI,
+  zoraCreator1155FactoryImplAddress,
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyABI,
+} from "@zoralabs/protocol-deployments";
+import type {
+  Address,
+  Hex,
+  PublicClient,
+  TransactionReceipt,
+  WalletClient,
+} from "viem";
+import { decodeEventLog, encodeFunctionData, zeroAddress } from "viem";
+import { OPEN_EDITION_MINT_SIZE } from "../constants";
+
+// Sales end forever amount (uint64 max)
+const SALE_END_FOREVER = 18446744073709551615n;
+
+// 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 = 2n ** 2n;
+
+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: "addPermission",
+      args: [0n, fixedPriceMinterAddress, PERMISSION_BIT_MINTER],
+    }),
+    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: "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 => {
+  for (const data of receipt.logs) {
+    try {
+      const decodedLog = decodeEventLog({
+        abi: zoraCreator1155ImplABI,
+        eventName: "SetupNewToken",
+        ...data,
+      });
+      if (decodedLog && decodedLog.eventName === "SetupNewToken") {
+        return decodedLog.args.tokenId;
+      }
+    } catch (err: any) {}
+  }
+};
+
+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,
+  };
+}
+
+// Create new 1155 token
+export async function createNew1155Token({
+  publicClient,
+  contract,
+  tokenMetadataURI,
+  mintToCreatorCount = 1,
+  salesConfig = {},
+  maxSupply,
+  account,
+  royaltySettings,
+  getAdditionalSetupActions,
+}: {
+  publicClient: PublicClient;
+  account: Address;
+  maxSupply?: bigint | number;
+  royaltySettings?: RoyaltySettingsType;
+  royaltyBPS?: number;
+  contract: ContractType;
+  tokenMetadataURI: string;
+  mintToCreatorCount?: bigint | number;
+  salesConfig?: SalesConfigParamsType;
+  getAdditionalSetupActions?: (args: {
+    tokenId: bigint;
+    contractAddress: Address;
+  }) => Hex[];
+}) {
+  // 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;
+
+  if (contractExists) {
+    nextTokenId = await publicClient.readContract({
+      abi: zoraCreator1155ImplABI,
+      functionName: "nextTokenId",
+      address: contractAddress,
+    });
+  }
+
+  // Get the fixed price minter to use within the new token to set the sales configuration.
+  const fixedPriceMinterAddress = await publicClient.readContract({
+    abi: zoraCreator1155FactoryImplABI,
+    address: zoraCreator1155FactoryImplAddress[999],
+    functionName: "fixedPriceMinter",
+  });
+
+  let tokenSetupActions = create1155TokenSetupArgs({
+    tokenMetadataURI,
+    nextTokenId,
+    salesConfig,
+    maxSupply,
+    fixedPriceMinterAddress,
+    account,
+    mintToCreatorCount,
+    royaltySettings,
+  });
+  if (getAdditionalSetupActions) {
+    tokenSetupActions = [
+      ...getAdditionalSetupActions({ tokenId: nextTokenId, contractAddress }),
+      ...tokenSetupActions,
+    ];
+  }
+
+  if (!contractAddress && typeof contract === "string") {
+    throw new Error("Invariant: contract cannot be missing and an address");
+  }
+  if (!contractExists && typeof contract !== "string") {
+    const { request } = await publicClient.simulateContract({
+      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 {
+      send: (walletClient: WalletClient) => walletClient.writeContract(request),
+      tokenSetupActions,
+      contractAddress,
+      contractExists,
+    };
+  } else if (contractExists) {
+    const { request } = await publicClient.simulateContract({
+      abi: zoraCreator1155ImplABI,
+      functionName: "multicall",
+      account,
+      address: contractAddress,
+      args: [tokenSetupActions],
+    });
+    return {
+      send: (walletClient: WalletClient) => walletClient.writeContract(request),
+      tokenSetupActions,
+      contractAddress,
+      contractExists,
+    };
+  }
+  throw new Error("Unsupported contract argument type");
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./premint/premint-client";
+
+export * from "./premint/preminter";
+
+export * from "./premint/premint-api-client";
+
+export * from "./mint/mint-api-client";
+
+export * from "./create/1155-create-helper";

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

@@ -0,0 +1,52 @@
+import { retries, get, post } from "../apis/http-api-base";
+import { paths } from "../apis/generated/discover-api-types";
+import { ZORA_API_BASE } from "../constants";
+
+export type MintableGetToken =
+  paths["/mintables/{chain_name}/{collection_address}"];
+type MintableGetTokenPathParameters =
+  MintableGetToken["get"]["parameters"]["path"];
+type MintableGetTokenGetQueryParameters =
+  MintableGetToken["get"]["parameters"]["query"];
+export type MintableGetTokenResponse =
+  MintableGetToken["get"]["responses"][200]["content"]["application/json"];
+
+function encodeQueryParameters(params: Record<string, string>) {
+  return new URLSearchParams(params).toString();
+}
+
+const getMintable = async (
+  path: MintableGetTokenPathParameters,
+  query: MintableGetTokenGetQueryParameters,
+): Promise<MintableGetTokenResponse> =>
+  retries(() => {
+    return get<MintableGetTokenResponse>(
+      `${ZORA_API_BASE}discover/mintables/${path.chain_name}/${
+        path.collection_address
+      }${query?.token_id ? `?${encodeQueryParameters(query)}` : ""}`,
+    );
+  });
+
+export const getSalesConfigFixedPrice = async ({
+  contractAddress,
+  tokenId,
+  subgraphUrl,
+}: {
+  contractAddress: string;
+  tokenId: string;
+  subgraphUrl: string;
+}): Promise<undefined | string> =>
+  retries(async () => {
+    const response = await post<any>(subgraphUrl, {
+      query:
+        "query($id: ID!) {\n  zoraCreateToken(id: $id) {\n    id\n    salesStrategies{\n      fixedPrice {\n        address\n      }\n    }\n  }\n}",
+      variables: { id: `${contractAddress.toLowerCase()}-${tokenId}` },
+    });
+    return response.zoraCreateToken?.salesStrategies?.find(() => true)
+      ?.fixedPriceMinterAddress;
+  });
+
+export const MintAPIClient = {
+  getMintable,
+  getSalesConfigFixedPrice,
+};

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

@@ -0,0 +1,117 @@
+import { parseAbi, parseEther } from "viem";
+import { zora } from "viem/chains";
+import { describe, expect } from "vitest";
+import { MintClient } from "./mint-client";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { anvilTest } from "src/anvil";
+
+const erc721ABI = parseAbi([
+  "function balanceOf(address owner) public view returns (uint256)",
+] as const);
+
+describe("mint-helper", () => {
+  anvilTest(
+    "mints a new 1155 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+      const targetContract = "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
+      const targetTokenId = 1n;
+      const minter = new MintClient(zora);
+
+      const { simulateContractParameters: params } =
+        await minter.makePrepareMintTokenParams({
+          publicClient,
+          minterAccount: creatorAccount,
+          mintable: await minter.getMintable({
+            tokenId: targetTokenId,
+            tokenContract: targetContract,
+          }),
+          mintArguments: {
+            mintToAddress: creatorAccount,
+            quantityToMint: 1,
+          },
+        });
+
+      const oldBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+
+      const simulationResult = await publicClient.simulateContract(params);
+
+      const hash = await walletClient.writeContract(simulationResult.request);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const newBalance = await publicClient.readContract({
+        abi: zoraCreator1155ImplABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount, targetTokenId],
+      });
+      expect(receipt).to.not.be.null;
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(1n);
+    },
+    12 * 1000,
+  );
+
+  anvilTest(
+    "mints a new 721 token",
+    async ({ viemClients }) => {
+      const { testClient, walletClient, publicClient } = viemClients;
+      const creatorAccount = (await walletClient.getAddresses())[0]!;
+      await testClient.setBalance({
+        address: creatorAccount,
+        value: parseEther("2000"),
+      });
+
+      const targetContract = "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
+      const targetTokenId = undefined;
+      const minter = new MintClient(zora);
+
+      const { simulateContractParameters: prepared } =
+        await minter.makePrepareMintTokenParams({
+          mintable: await minter.getMintable({
+            tokenContract: targetContract,
+            tokenId: targetTokenId,
+          }),
+          publicClient,
+          minterAccount: creatorAccount,
+          mintArguments: {
+            mintToAddress: creatorAccount,
+            quantityToMint: 1,
+          },
+        });
+      const oldBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      const simulated = await publicClient.simulateContract(prepared);
+
+      const hash = await walletClient.writeContract(simulated.request);
+
+      const receipt = await publicClient.getTransactionReceipt({ hash });
+      expect(receipt).not.to.be.null;
+
+      const newBalance = await publicClient.readContract({
+        abi: erc721ABI,
+        address: targetContract,
+        functionName: "balanceOf",
+        args: [creatorAccount],
+      });
+
+      expect(oldBalance).to.be.equal(0n);
+      expect(newBalance).to.be.equal(1n);
+    },
+    12 * 1000,
+  );
+});