@zoralabs/protocol-sdk 0.5.7-MINT.3 → 0.5.7

package/src/apis/chain-constants.ts

@@ -1,14 +1,12 @@
 import {
+  arbitrum,
   base,
-  baseGoerli,
   foundry,
-  goerli,
   mainnet,
   optimism,
-  optimismGoerli,
+  sepolia,
   zora,
   zoraSepolia,
-  zoraTestnet,
 } from "viem/chains";
 import type { components } from "./generated/premint-api-types";
 import { parseEther } from "viem";
@@ -34,12 +32,12 @@ export const networkConfigByChain: Record<number, NetworkConfig> = {
     zoraBackendChainName: "ETHEREUM-MAINNET",
     subgraphUrl: getSubgraph("zora-create-mainnet", "stable"),
   },
-  [goerli.id]: {
-    chainId: goerli.id,
+  [sepolia.id]: {
+    chainId: sepolia.id,
     isTestnet: true,
-    zoraCollectPathChainName: "gor",
-    zoraBackendChainName: "ETHEREUM-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-goerli", "stable"),
+    zoraCollectPathChainName: "sep",
+    zoraBackendChainName: "ETHEREUM-SEPOLIA",
+    subgraphUrl: getSubgraph("zora-create-sepolia", "stable"),
   },
   [zora.id]: {
     chainId: zora.id,
@@ -48,13 +46,6 @@ export const networkConfigByChain: Record<number, NetworkConfig> = {
     zoraBackendChainName: "ZORA-MAINNET",
     subgraphUrl: getSubgraph("zora-create-zora-mainnet", "stable"),
   },
-  [zoraTestnet.id]: {
-    chainId: zoraTestnet.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "zgor",
-    zoraBackendChainName: "ZORA-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable"),
-  },
   [zoraSepolia.id]: {
     chainId: zoraSepolia.id,
     isTestnet: true,
@@ -69,12 +60,12 @@ export const networkConfigByChain: Record<number, NetworkConfig> = {
     zoraBackendChainName: "OPTIMISM-MAINNET",
     subgraphUrl: getSubgraph("zora-create-optimism", "stable"),
   },
-  [optimismGoerli.id]: {
-    chainId: optimismGoerli.id,
+  [arbitrum.id]: {
+    chainId: arbitrum.id,
     isTestnet: true,
-    zoraCollectPathChainName: "ogor",
-    zoraBackendChainName: "OPTIMISM-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-optimism-goerli", "stable"),
+    zoraCollectPathChainName: "arb",
+    zoraBackendChainName: "ARBITRUM-MAINNET",
+    subgraphUrl: getSubgraph("zora-create-arbitrum-one", "stable"),
   },
   [base.id]: {
     chainId: base.id,
@@ -83,13 +74,6 @@ export const networkConfigByChain: Record<number, NetworkConfig> = {
     zoraBackendChainName: "BASE-MAINNET",
     subgraphUrl: getSubgraph("zora-create-base-mainnet", "stable"),
   },
-  [baseGoerli.id]: {
-    chainId: baseGoerli.id,
-    isTestnet: true,
-    zoraCollectPathChainName: "bgor",
-    zoraBackendChainName: "BASE-GOERLI",
-    subgraphUrl: getSubgraph("zora-create-base-goerli", "stable"),
-  },
   [foundry.id]: {
     chainId: foundry.id,
     isTestnet: true,
@@ -98,13 +82,3 @@ export const networkConfigByChain: Record<number, NetworkConfig> = {
     subgraphUrl: getSubgraph("zora-create-zora-testnet", "stable"),
   },
 };
-
-export const getSubgraphUrl = (chainId: number): string => {
-  const networkConfig = networkConfigByChain[chainId];
-
-  if (!networkConfig) {
-    throw new Error(`Network not configured for chain id ${chainId}`);
-  }
-
-  return networkConfig.subgraphUrl;
-};

package/src/apis/generated/premint-api-types.ts

@@ -48,7 +48,9 @@ export interface components {
       | "ZORA-MAINNET"
       | "BASE-MAINNET"
       | "BASE-GOERLI"
-      | "PGN-MAINNET";
+      | "PGN-MAINNET"
+      | "ARBITRUM-MAINNET"
+      | "BLAST-MAINNET";
     /**
      * CollectionCreationConfig
      * @description ObjectBase extends Pydantic's BaseModel class to support extra functionality

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

@@ -0,0 +1,104 @@
+import { parseEther } from "viem";
+import { describe, expect } from "vitest";
+import {
+  create1155CreatorClient,
+  getTokenIdFromCreateReceipt,
+} from "./1155-create-helper";
+import { anvilTest } from "src/anvil";
+
+const demoTokenMetadataURI = "ipfs://DUMMY/token.json";
+const demoContractMetadataURI = "ipfs://DUMMY/contract.json";
+
+describe("create-helper", () => {
+  anvilTest(
+    "creates a new contract given arguments",
+    async ({ viemClients: { testClient, publicClient, walletClient } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAddress = addresses[0]!;
+      await testClient.setBalance({
+        address: creatorAddress,
+        value: parseEther("1"),
+      });
+      const creatorClient = create1155CreatorClient({
+        publicClient: publicClient,
+      });
+      const { request } = await creatorClient.createNew1155Token({
+        contract: {
+          name: "testContract",
+          uri: demoContractMetadataURI,
+        },
+        tokenMetadataURI: demoTokenMetadataURI,
+        account: creatorAddress,
+        mintToCreatorCount: 1,
+      });
+      const { request: simulationResponse } =
+        await publicClient.simulateContract(request);
+      const hash = await walletClient.writeContract(simulationResponse);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      expect(receipt).not.toBeNull();
+      expect(receipt.to).to.equal("0x777777c338d93e2c7adf08d102d45ca7cc4ed021");
+      expect(getTokenIdFromCreateReceipt(receipt)).to.be.equal(1n);
+    },
+    20 * 1000,
+  );
+  anvilTest(
+    "creates a new contract, than creates a new token on this existing contract",
+    async ({ viemClients: { publicClient, walletClient } }) => {
+      const addresses = await walletClient.getAddresses();
+      const creatorAccount = addresses[0]!;
+
+      const creatorClient = create1155CreatorClient({
+        publicClient: publicClient,
+      });
+
+      const { request, contractAddress, contractExists } =
+        await creatorClient.createNew1155Token({
+          contract: {
+            name: "testContract2",
+            uri: demoContractMetadataURI,
+          },
+          tokenMetadataURI: demoTokenMetadataURI,
+          account: creatorAccount,
+          mintToCreatorCount: 1,
+        });
+      expect(contractAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(contractExists).to.be.false;
+      const { request: simulateResponse } =
+        await publicClient.simulateContract(request);
+      const hash = await walletClient.writeContract(simulateResponse);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const firstTokenId = getTokenIdFromCreateReceipt(receipt);
+      expect(firstTokenId).to.be.equal(1n);
+      expect(receipt).not.toBeNull();
+
+      const newTokenOnExistingContract = await creatorClient.createNew1155Token(
+        {
+          contract: {
+            name: "testContract2",
+            uri: demoContractMetadataURI,
+          },
+          tokenMetadataURI: demoTokenMetadataURI,
+          account: creatorAccount,
+          mintToCreatorCount: 1,
+        },
+      );
+      expect(newTokenOnExistingContract.contractAddress).to.be.equal(
+        "0xb1A8928dF830C21eD682949Aa8A83C1C215194d3",
+      );
+      expect(newTokenOnExistingContract.contractExists).to.be.true;
+      const { request: simulateRequest } = await publicClient.simulateContract(
+        newTokenOnExistingContract.request,
+      );
+      const newHash = await walletClient.writeContract(simulateRequest);
+      const newReceipt = await publicClient.waitForTransactionReceipt({
+        hash: newHash,
+      });
+      const tokenId = getTokenIdFromCreateReceipt(newReceipt);
+      expect(tokenId).to.be.equal(2n);
+      expect(newReceipt).not.toBeNull();
+    },
+    20 * 1000,
+  );
+});

package/src/index.ts

@@ -13,5 +13,3 @@ export * from "./mint/mint-api-client";
 export * from "./mint/mint-client";
 
 export * from "./create/1155-create-helper";
-
-export * from "./mints/mints-queries";

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

@@ -0,0 +1,114 @@
+import { Address, parseAbi, parseEther } from "viem";
+import { zora } from "viem/chains";
+import { describe, expect } from "vitest";
+import { createMintClient } from "./mint-client";
+import { zoraCreator1155ImplABI } from "@zoralabs/protocol-deployments";
+import { anvilTest, forkUrls, makeAnvilTest } 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: Address =
+        "0xa2fea3537915dc6c7c7a97a82d1236041e6feb2e";
+      const targetTokenId = 1n;
+      const minter = createMintClient({ chain: zora });
+
+      const params = await minter.makePrepareMintTokenParams({
+        minterAccount: creatorAccount,
+        tokenId: targetTokenId,
+        tokenAddress: 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,
+  );
+
+  makeAnvilTest({
+    forkUrl: forkUrls.zoraMainnet,
+    forkBlockNumber: 6133407,
+  })(
+    "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: Address =
+        "0x7aae7e67515A2CbB8585C707Ca6db37BDd3EA839";
+      const targetTokenId = undefined;
+      const minter = createMintClient({ chain: zora });
+
+      const params = await minter.makePrepareMintTokenParams({
+        tokenId: targetTokenId,
+        tokenAddress: targetContract,
+        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(params);
+
+      const hash = await walletClient.writeContract(simulated.request);
+
+      const receipt = await publicClient.waitForTransactionReceipt({ 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,
+  );
+});

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

@@ -0,0 +1,239 @@
+import { foundry } from "viem/chains";
+import { describe, expect, vi } from "vitest";
+
+import { createPremintClient } from "./premint-client";
+import { anvilTest } from "src/anvil";
+import { PremintConfigVersion } from "./contract-types";
+import { getDefaultFixedPriceMinterAddress } from "./preminter";
+
+describe("ZoraCreator1155Premint - v1 signatures", () => {
+  anvilTest(
+    "can sign by default v1 on the forked premint contract",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain,
+        publicClient,
+      });
+
+      premintClient.apiClient.getNextUID = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getNextUID>>()
+        .mockResolvedValue(3);
+      premintClient.apiClient.postSignature = vi
+        .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
+        .mockResolvedValue({ ok: true });
+
+      await premintClient.createPremint({
+        walletClient,
+        creatorAccount: deployerAccount!,
+        checkSignature: true,
+        collection: {
+          contractAdmin: deployerAccount!,
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        tokenCreationConfig: {
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+        },
+      });
+
+      const expectedPostSignatureArgs: Parameters<
+        typeof premintClient.apiClient.postSignature
+      >[0] = {
+        collection: {
+          contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+          contractName: "Testing Contract",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfig: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
+            maxSupply: 18446744073709551615n,
+            maxTokensPerAddress: 0n,
+            mintDuration: 604800n,
+            mintStart: 0n,
+            pricePerToken: 0n,
+            royaltyBPS: 1000,
+            royaltyMintSchedule: 0,
+            royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 0,
+        },
+        premintConfigVersion: PremintConfigVersion.V1,
+        signature:
+          "0x70fc1d6e862c42f2b0e4a062f4eb973cc8692df58a24b71b4fe91ae7baa5a26d2c99b1b8ab61f64ff431bf30b0897877b11b7405542c90b89b041808f1561a6c1c",
+      };
+
+      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith(
+        expectedPostSignatureArgs,
+      );
+    },
+    20 * 1000,
+  );
+
+  anvilTest(
+    "can execute premint on network",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [deployerAccount] = await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain: foundry,
+        publicClient,
+      });
+
+      premintClient.apiClient.getSignature = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getSignature>>()
+        .mockResolvedValue({
+          collection: {
+            contractAdmin: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+            contractName: "Testing Contract",
+            contractURI:
+              "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+          },
+          premintConfig: {
+            deleted: false,
+            tokenConfig: {
+              fixedPriceMinter: getDefaultFixedPriceMinterAddress(chain.id),
+              maxSupply: 18446744073709551615n,
+              maxTokensPerAddress: 0n,
+              mintDuration: 604800n,
+              mintStart: 0n,
+              pricePerToken: 0n,
+              royaltyBPS: 1000,
+              royaltyMintSchedule: 0,
+              royaltyRecipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+              tokenURI:
+                "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+            },
+            uid: 3,
+            version: 0,
+          },
+          premintConfigVersion: PremintConfigVersion.V1,
+          signature:
+            "0x70fc1d6e862c42f2b0e4a062f4eb973cc8692df58a24b71b4fe91ae7baa5a26d2c99b1b8ab61f64ff431bf30b0897877b11b7405542c90b89b041808f1561a6c1c",
+        });
+
+      premintClient.apiClient.postSignature = vi.fn();
+
+      const simulateContractParameters = await premintClient.makeMintParameters(
+        {
+          minterAccount: deployerAccount!,
+          tokenContract: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+          uid: 3,
+          mintArguments: {
+            quantityToMint: 1,
+            mintComment: "",
+          },
+        },
+      );
+      const { request: simulateRequest } = await publicClient.simulateContract(
+        simulateContractParameters,
+      );
+      const hash = await walletClient.writeContract(simulateRequest);
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      const { premintedLog, urls } =
+        premintClient.getDataFromPremintReceipt(receipt);
+
+      expect(urls).toEqual({
+        explorer:
+          "https://undefined/token/0xf8dA7f53c283d898818af7FB9d98103F559bDac2/instance/1",
+        zoraCollect:
+          "https://testnet.zora.co/collect/zgor:0xf8dA7f53c283d898818af7FB9d98103F559bDac2/1",
+        zoraManage:
+          "https://testnet.zora.co/collect/zgor:0xf8dA7f53c283d898818af7FB9d98103F559bDac2/1",
+      });
+
+      expect(premintedLog).toEqual({
+        contractAddress: "0xf8dA7f53c283d898818af7FB9d98103F559bDac2",
+        createdNewContract: expect.any(Boolean),
+        minter: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+        quantityMinted: 1n,
+        tokenId: 1n,
+        uid: 3,
+      });
+    },
+    20 * 1000,
+  );
+});
+
+describe("ZoraCreator1155Premint - v2 signatures", () => {
+  anvilTest(
+    "can sign on the forked premint contract",
+    async ({ viemClients: { walletClient, publicClient, chain } }) => {
+      const [creatorAccount, createReferralAccount] =
+        await walletClient.getAddresses();
+      const premintClient = createPremintClient({
+        chain,
+        publicClient,
+      });
+
+      premintClient.apiClient.getNextUID = vi
+        .fn<any, ReturnType<typeof premintClient.apiClient.getNextUID>>()
+        .mockResolvedValue(3);
+      premintClient.apiClient.postSignature = vi
+        .fn<Parameters<typeof premintClient.apiClient.postSignature>>()
+        .mockResolvedValue({ ok: true });
+
+      await premintClient.createPremint({
+        walletClient,
+        creatorAccount: creatorAccount!,
+        checkSignature: true,
+        collection: {
+          contractAdmin: creatorAccount!,
+          contractName: "Testing Contract Premint V2",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfigVersion: PremintConfigVersion.V2,
+        tokenCreationConfig: {
+          tokenURI:
+            "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          createReferral: createReferralAccount,
+        },
+      });
+
+      const expectedPostSignatureArgs: Parameters<
+        typeof premintClient.apiClient.postSignature
+      >[0] = {
+        collection: {
+          contractAdmin: creatorAccount!,
+          contractName: "Testing Contract Premint V2",
+          contractURI:
+            "ipfs://bafkreiainxen4b4wz4ubylvbhons6rembxdet4a262nf2lziclqvv7au3e",
+        },
+        premintConfig: {
+          deleted: false,
+          tokenConfig: {
+            fixedPriceMinter: "0x04E2516A2c207E84a1839755675dfd8eF6302F0a",
+            maxSupply: 18446744073709551615n,
+            maxTokensPerAddress: 0n,
+            mintDuration: 604800n,
+            mintStart: 0n,
+            pricePerToken: 0n,
+            royaltyBPS: 1000,
+            payoutRecipient: creatorAccount!,
+            createReferral: createReferralAccount!,
+            tokenURI:
+              "ipfs://bafkreice23maski3x52tsfqgxstx3kbiifnt5jotg3a5ynvve53c4soi2u",
+          },
+          uid: 3,
+          version: 0,
+        },
+        premintConfigVersion: PremintConfigVersion.V2,
+        signature:
+          "0x8be7932b0b31bdb7fc9269b756e0d0c9514519f083d86576e23b73c033d8ed8440ea363bc8bba0ec5c30eb6bbdf796163a324201bc7520965037102518fb5e991c",
+      };
+
+      expect(premintClient.apiClient.postSignature).toHaveBeenCalledWith(
+        expectedPostSignatureArgs,
+      );
+    },
+    20 * 1000,
+  );
+});

package/src/premint/premint-client.ts

@@ -315,7 +315,7 @@ class PremintClient {
    * @returns premint url, uid, newContractAddress, and premint object
    */
   async createPremint<
-    T extends PremintConfigVersion = PremintConfigVersion.V1,
+    T extends PremintConfigVersion = PremintConfigVersion.V2,
   >({
     creatorAccount,
     collection,