@zoralabs/protocol-sdk 0.2.0

package/src/mint/mint-client.ts

@@ -0,0 +1,218 @@
+import {
+  Address,
+  Chain,
+  PublicClient,
+  encodeAbiParameters,
+  parseAbi,
+  parseAbiParameters,
+  zeroAddress,
+} from "viem";
+import { ClientBase } from "../apis/client-base";
+import { MintAPIClient, MintableGetTokenResponse } from "./mint-api-client";
+import { SimulateContractParameters } from "viem";
+import {
+  zoraCreator1155ImplABI,
+  zoraCreatorFixedPriceSaleStrategyAddress,
+} from "@zoralabs/protocol-deployments";
+
+class MintError extends Error {}
+class MintInactiveError extends Error {}
+
+export const Errors = {
+  MintError,
+  MintInactiveError,
+};
+
+type MintArguments = {
+  quantityToMint: number;
+  mintComment?: string;
+  mintReferral?: Address;
+  mintToAddress: Address;
+};
+
+type MintParameters = {
+  mintArguments: MintArguments;
+  publicClient: PublicClient;
+  mintable: MintableGetTokenResponse;
+  sender: Address;
+};
+
+const zora721Abi = parseAbi([
+  "function mintWithRewards(address recipient, uint256 quantity, string calldata comment, address mintReferral) external payable",
+  "function zoraFeeForAmount(uint256 amount) public view returns (address, uint256)",
+] as const);
+
+export class MintClient extends ClientBase {
+  apiClient: typeof MintAPIClient;
+
+  constructor(chain: Chain, apiClient?: typeof MintAPIClient) {
+    super(chain);
+
+    if (!apiClient) {
+      apiClient = MintAPIClient;
+    }
+    this.apiClient = apiClient;
+  }
+
+  async getMintable({
+    tokenContract,
+    tokenId,
+  }: {
+    tokenContract: Address;
+    tokenId?: bigint | number | string;
+  }) {
+    return this.apiClient.getMintable(
+      {
+        chain_name: this.network.zoraBackendChainName,
+        collection_address: tokenContract,
+      },
+      { token_id: tokenId?.toString() },
+    );
+  }
+
+  async makePrepareMintTokenParams({
+    publicClient,
+    minterAccount,
+    mintable,
+    mintArguments,
+  }: {
+    publicClient: PublicClient;
+    mintable: MintableGetTokenResponse;
+    minterAccount: Address;
+    mintArguments: MintArguments;
+  }): Promise<{simulateContractParameters: SimulateContractParameters}> {
+    if (!mintable) {
+      throw new MintError("No mintable found");
+    }
+
+    if (!mintable.is_active) {
+      throw new MintInactiveError("Minting token is inactive");
+    }
+
+    if (!mintable.mint_context) {
+      throw new MintError("No minting context data from zora API");
+    }
+
+    if (
+      !["zora_create", "zora_create_1155"].includes(
+        mintable.mint_context?.mint_context_type!,
+      )
+    ) {
+      throw new MintError(
+        `Mintable type ${mintable.mint_context.mint_context_type} is currently unsupported.`,
+      );
+    }
+
+    const thisPublicClient = this.getPublicClient(publicClient);
+
+    if (mintable.mint_context.mint_context_type === "zora_create_1155") {
+      return {
+        simulateContractParameters: await this.prepareMintZora1155({
+          publicClient: thisPublicClient,
+          mintArguments,
+          sender: minterAccount,
+          mintable,
+        }),
+      };
+    }
+    if (mintable.mint_context.mint_context_type === "zora_create") {
+      return {
+        simulateContractParameters: await this.prepareMintZora721({
+          publicClient: thisPublicClient,
+          mintArguments,
+          sender: minterAccount,
+          mintable,
+        }),
+      };
+    }
+
+    throw new Error("Mintable type not found or recognized.");
+  }
+
+  private async prepareMintZora1155({
+    mintable,
+    sender,
+    publicClient,
+    mintArguments,
+  }: MintParameters) {
+    const mintQuantity = BigInt(mintArguments.quantityToMint);
+
+    const address = mintable.collection.address as Address;
+
+    const mintFee = await publicClient.readContract({
+      abi: zoraCreator1155ImplABI,
+      functionName: "mintFee",
+      address,
+    });
+
+    const tokenFixedPriceMinter = await this.apiClient.getSalesConfigFixedPrice(
+      {
+        contractAddress: mintable.contract_address,
+        tokenId: mintable.token_id!,
+        subgraphUrl: this.network.subgraphUrl,
+      },
+    );
+
+    const result: SimulateContractParameters<
+      typeof zoraCreator1155ImplABI,
+      "mintWithRewards"
+    > = {
+      abi: zoraCreator1155ImplABI,
+      functionName: "mintWithRewards",
+      account: sender,
+      value: (mintFee + BigInt(mintable.cost.native_price.raw)) * mintQuantity,
+      address,
+      /* args: minter, tokenId, quantity, minterArguments, mintReferral */
+      args: [
+        (tokenFixedPriceMinter ||
+          zoraCreatorFixedPriceSaleStrategyAddress[999]) as Address,
+        BigInt(mintable.token_id!),
+        mintQuantity,
+        encodeAbiParameters(parseAbiParameters("address, string"), [
+          mintArguments.mintToAddress,
+          mintArguments.mintComment || "",
+        ]),
+        mintArguments.mintReferral || zeroAddress,
+      ],
+    };
+
+    return result;
+  }
+
+  private async prepareMintZora721({
+    mintable,
+    publicClient,
+    sender,
+    mintArguments,
+  }: MintParameters) {
+    const [_, mintFee] = await publicClient.readContract({
+      abi: zora721Abi,
+      address: mintable.contract_address as Address,
+      functionName: "zoraFeeForAmount",
+      args: [BigInt(mintArguments.quantityToMint)],
+    });
+
+    const result: SimulateContractParameters<
+      typeof zora721Abi,
+      "mintWithRewards"
+    > = {
+      abi: zora721Abi,
+      address: mintable.contract_address as Address,
+      account: sender,
+      functionName: "mintWithRewards",
+      value:
+        mintFee +
+        BigInt(mintable.cost.native_price.raw) *
+          BigInt(mintArguments.quantityToMint),
+      /* args: mint recipient, quantity to mint, mint comment, mintReferral */
+      args: [
+        mintArguments.mintToAddress,
+        BigInt(mintArguments.quantityToMint),
+        mintArguments.mintComment || "",
+        mintArguments.mintReferral || zeroAddress,
+      ],
+    };
+
+    return result;
+  }
+}

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

@@ -0,0 +1,57 @@
+import { post, retries, get } from "../apis/http-api-base";
+import { components, paths } from "../apis/generated/premint-api-types";
+import { ZORA_API_BASE } from "../constants";
+
+type SignaturePostType = paths["/signature"]["post"];
+type PremintSignatureRequestBody =
+  SignaturePostType["requestBody"]["content"]["application/json"];
+export type PremintSignatureResponse =
+  SignaturePostType["responses"][200]["content"]["application/json"];
+
+type PremintNextUIDGetType =
+  paths["/signature/{chain_name}/{collection_address}/next_uid"]["get"];
+type PremintNextUIDGetPathParameters =
+  PremintNextUIDGetType["parameters"]["path"];
+export type PremintNextUIDGetResponse =
+  PremintNextUIDGetType["responses"][200]["content"]["application/json"];
+
+type SignaturePremintGetType =
+  paths["/signature/{chain_name}/{collection_address}/{uid}"]["get"];
+type PremintSignatureGetPathParameters =
+  SignaturePremintGetType["parameters"]["path"];
+export type PremintSignatureGetResponse =
+  SignaturePremintGetType["responses"][200]["content"]["application/json"];
+
+export type BackendChainNames = components["schemas"]["ChainName"];
+
+const postSignature = async (
+  data: PremintSignatureRequestBody,
+): Promise<PremintSignatureResponse> =>
+  retries(() =>
+    post<PremintSignatureResponse>(`${ZORA_API_BASE}premint/signature`, data),
+  );
+
+const getNextUID = async (
+  path: PremintNextUIDGetPathParameters,
+): Promise<PremintNextUIDGetResponse> =>
+  retries(() =>
+    get<PremintNextUIDGetResponse>(
+      `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/next_uid`,
+    ),
+  );
+
+const getSignature = async (
+  path: PremintSignatureGetPathParameters,
+): Promise<PremintSignatureGetResponse> =>
+  retries(() =>
+    get<PremintSignatureGetResponse>(
+      `${ZORA_API_BASE}premint/signature/${path.chain_name}/${path.collection_address}/${path.uid}`,
+    ),
+  );
+
+export const PremintAPIClient = {
+  postSignature,
+  getSignature,
+  getNextUID,
+};
+export { ZORA_API_BASE };

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

@@ -0,0 +1,196 @@
+import { foundry } from "viem/chains";
+import { describe, expect, vi } from "vitest";
+import { PremintClient } from "./premint-client";
+import { anvilTest } from "src/anvil";
+import { BackendChainNamesLookup } from "src/apis/chain-constants";
+
+describe("ZoraCreator1155Premint", () => {
+  anvilTest(
+    "can sign on the forked premint contract",
+    async ({ viemClients: { walletClient, publicClient } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = new PremintClient(foundry);
+
+      premintClient.apiClient.getNextUID = vi
+        .fn()
+        .mockResolvedValue({ next_uid: 3 });
+      premintClient.apiClient.postSignature = vi
+        .fn()
+        .mockResolvedValue({ ok: true });
+
+      await premintClient.createPremint({
+        walletClient,
+        publicClient,
+        account: deployerAccount!,
+        checkSignature: true,
+        collection: {
+          contractAdmin: deployerAccount!,
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        token: {
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+        },
+      });
+
+      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith({
+        chain_name: BackendChainNamesLookup.ZORA_GOERLI,
+        collection: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premint: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+            maxSupply: "18446744073709551615",
+            maxTokensPerAddress: "0",
+            mintDuration: "604800",
+            mintStart: "0",
+            pricePerToken: "0",
+            royaltyBPS: 1000,
+            royaltyMintSchedule: 0,
+            royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 1,
+        },
+        signature:
+          "0x588d19641de9ba1dade4d2bb5387c8dc96f4a990fef69787534b60caead759e6334975a6be10a796da948cd7d1d4f5580b3f84d49d9fa4e0b41c97759507975a1c",
+      });
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "can validate premint on network",
+    async ({ viemClients: { publicClient } }) => {
+      const premintClient = new PremintClient(foundry);
+
+      const premintData = {
+        collection: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premint: {
+          uid: 3,
+          version: 1,
+          deleted: false,
+          tokenConfig: {
+            maxSupply: "18446744073709551615",
+            maxTokensPerAddress: "0",
+            pricePerToken: "0",
+            mintDuration: "604800",
+            mintStart: "0",
+            royaltyMintSchedule: 0,
+            royaltyBPS: 1000,
+            fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+            royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+        },
+        chain_name: "ZORA-TESTNET",
+        signature:
+          "0x588d19641de9ba1dade4d2bb5387c8dc96f4a990fef69787534b60caead759e6334975a6be10a796da948cd7d1d4f5580b3f84d49d9fa4e0b41c97759507975a1c",
+      } as const;
+
+      const signatureValid = await premintClient.isValidSignature({
+        // @ts-ignore: Fix enum type
+        data: premintData,
+        publicClient,
+      });
+      expect(signatureValid.isValid).toBe(true);
+    },
+  );
+
+  anvilTest(
+    "can execute premint on network",
+    async ({ viemClients: { walletClient, publicClient } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = new PremintClient(foundry);
+
+      premintClient.apiClient.getSignature = vi.fn().mockResolvedValue({
+        chain_name: "ZORA-TESTNET",
+        collection: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premint: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+            maxSupply: "18446744073709551615",
+            maxTokensPerAddress: "0",
+            mintDuration: "604800",
+            mintStart: "0",
+            pricePerToken: "0",
+            royaltyBPS: 1000,
+            royaltyMintSchedule: 0,
+            royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 1,
+        },
+        signature:
+          "0x588d19641de9ba1dade4d2bb5387c8dc96f4a990fef69787534b60caead759e6334975a6be10a796da948cd7d1d4f5580b3f84d49d9fa4e0b41c97759507975a1c",
+      });
+      premintClient.apiClient.postSignature = vi.fn();
+
+      const premint = await premintClient.executePremintWithWallet({
+        data: await premintClient.getPremintData({
+          address: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+          uid: 3,
+        }),
+        account: deployerAccount,
+        walletClient,
+        publicClient,
+        mintArguments: {
+          quantityToMint: 1,
+          mintComment: "",
+        },
+      });
+
+      expect(premint.premintedLog).toEqual({
+        contractAddress: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+        contractConfig: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        createdNewContract: expect.any(Boolean),
+        minter: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        quantityMinted: 1n,
+        tokenConfig: {
+          fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+          maxSupply: 18446744073709551615n,
+          maxTokensPerAddress: 0n,
+          mintDuration: 604800n,
+          mintStart: 0n,
+          pricePerToken: 0n,
+          royaltyBPS: 1000,
+          royaltyMintSchedule: 0,
+          royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+        },
+        tokenId: 1n,
+        uid: 3,
+      });
+    },
+    20 * 1000,
+  );
+});