@zoralabs/protocol-sdk 0.12.2 → 0.13.0

package/src/premint/preminter.test.ts

@@ -24,11 +24,7 @@ import {
   encodePremintConfig,
 } from "@zoralabs/protocol-deployments";
 
-import {
-  isValidSignature,
-  getPremintExecutorAddress,
-  getPremintMintCosts,
-} from "./preminter";
+import { getPremintExecutorAddress, getPremintMintCosts } from "./preminter";
 import { AnvilViemClientsTest, forkUrls, makeAnvilTest } from "src/anvil";
 import { privateKeyToAccount } from "viem/accounts";
 
@@ -177,159 +173,6 @@ const zoraSepoliaAnvilTest = makeAnvilTest({
 });
 
 describe("ZoraCreator1155Preminter", () => {
-  zoraSepoliaAnvilTest(
-    "can sign on the forked premint contract",
-    async ({ viemClients }) => {
-      const {
-        fixedPriceMinterAddress,
-        accounts: { creatorAccount },
-      } = await setupContracts({ viemClients });
-      const premintConfig = defaultPremintConfigV1({
-        fixedPriceMinter: fixedPriceMinterAddress,
-        creatorAccount,
-      });
-      const contractConfig = defaultContractConfig({
-        contractAdmin: creatorAccount,
-      });
-
-      const preminterAddress = getPremintExecutorAddress();
-
-      const contractAddress = await viemClients.publicClient.readContract({
-        abi: preminterAbi,
-        address: preminterAddress,
-        functionName: "getContractWithAdditionalAdminsAddress",
-        args: [contractConfig],
-      });
-
-      const signedMessage = await viemClients.walletClient.signTypedData({
-        ...premintTypedDataDefinition({
-          verifyingContract: contractAddress,
-          chainId: viemClients.chain.id,
-          premintConfig,
-          premintConfigVersion: PremintConfigVersion.V1,
-        }),
-        account: creatorAccount,
-      });
-
-      console.log({
-        creatorAccount,
-        signedMessage,
-        contractConfig,
-        premintConfig,
-        contractAddress,
-      });
-    },
-    20 * 1000,
-  );
-  zoraSepoliaAnvilTest(
-    "can sign and recover a v1 premint config signature",
-    async ({ viemClients }) => {
-      const {
-        fixedPriceMinterAddress,
-        accounts: { creatorAccount },
-      } = await setupContracts({ viemClients });
-
-      const premintConfig = defaultPremintConfigV1({
-        fixedPriceMinter: fixedPriceMinterAddress,
-        creatorAccount,
-      });
-      const contractConfig = defaultContractConfig({
-        contractAdmin: creatorAccount,
-      });
-
-      const tokenContract = await viemClients.publicClient.readContract({
-        abi: preminterAbi,
-        address: PREMINTER_ADDRESS,
-        functionName: "getContractWithAdditionalAdminsAddress",
-        args: [contractConfig],
-      });
-
-      // sign message containing contract and token creation config and uid
-      const signedMessage = await viemClients.walletClient.signTypedData({
-        ...premintTypedDataDefinition({
-          verifyingContract: tokenContract,
-          // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: viemClients.chain.id,
-          premintConfig,
-          premintConfigVersion: PremintConfigVersion.V1,
-        }),
-        account: creatorAccount,
-      });
-
-      // recover and verify address is correct
-      const { recoveredAddress, isAuthorized } = await isValidSignature({
-        collection: contractConfig,
-        collectionAddress: tokenContract,
-        chainId: viemClients.publicClient.chain!.id,
-        premintConfig,
-        premintConfigVersion: PremintConfigVersion.V1,
-        publicClient: viemClients.publicClient,
-        signature: signedMessage,
-      });
-
-      expect(recoveredAddress).to.equal(creatorAccount);
-      expect(isAuthorized).toBe(true);
-
-      expect(recoveredAddress).to.equal(creatorAccount);
-    },
-
-    20 * 1000,
-  );
-  zoraSepoliaAnvilTest(
-    "can sign and recover a v2 premint config signature",
-    async ({ viemClients }) => {
-      const {
-        fixedPriceMinterAddress,
-        accounts: { creatorAccount },
-      } = await setupContracts({ viemClients });
-
-      const premintConfig = defaultPremintConfigV2({
-        creatorAccount,
-        fixedPriceMinter: fixedPriceMinterAddress,
-        createReferral: creatorAccount,
-      });
-      const contractConfig = defaultContractConfig({
-        contractAdmin: creatorAccount,
-      });
-
-      const tokenContract = await viemClients.publicClient.readContract({
-        abi: preminterAbi,
-        address: PREMINTER_ADDRESS,
-        functionName: "getContractWithAdditionalAdminsAddress",
-        args: [contractConfig],
-      });
-
-      // sign message containing contract and token creation config and uid
-      const signedMessage = await viemClients.walletClient.signTypedData({
-        ...premintTypedDataDefinition({
-          verifyingContract: tokenContract,
-          // we need to sign here for the anvil chain, cause thats where it is run on
-          chainId: viemClients.chain.id,
-          premintConfig,
-          premintConfigVersion: PremintConfigVersion.V2,
-        }),
-        account: creatorAccount,
-      });
-
-      // recover and verify address is correct
-      const { recoveredAddress, isAuthorized } = await isValidSignature({
-        collection: contractConfig,
-        collectionAddress: tokenContract,
-        chainId: viemClients.publicClient.chain!.id,
-        premintConfig,
-        premintConfigVersion: PremintConfigVersion.V2,
-        publicClient: viemClients.publicClient,
-        signature: signedMessage,
-      });
-
-      expect(recoveredAddress).to.equal(creatorAccount);
-      expect(isAuthorized).toBe(true);
-
-      expect(recoveredAddress).to.equal(creatorAccount);
-    },
-
-    20 * 1000,
-  );
   zoraSepoliaAnvilTest(
     "can sign and mint multiple tokens",
     async ({ viemClients }) => {

package/src/premint/preminter.ts

@@ -1,37 +1,13 @@
 import { Address } from "abitype";
 import {
   zoraCreator1155PremintExecutorImplABI as preminterAbi,
-  zoraCreator1155ImplABI,
   zoraCreator1155PremintExecutorImplABI,
   zoraCreator1155PremintExecutorImplAddress,
-  zoraCreatorFixedPriceSaleStrategyAddress,
-  premintTypedDataDefinition,
   ContractCreationConfig,
-  PremintConfigForVersion,
-} from "@zoralabs/protocol-deployments";
-import {
-  recoverTypedDataAddress,
-  Hex,
-  zeroAddress,
-  hashDomain,
-  keccak256,
-  concat,
-  recoverAddress,
-  GetEventArgs,
-  parseEther,
-  Account,
-} from "viem";
-import {
-  PremintConfig,
-  PremintConfigV1,
-  PremintConfigV2,
-  PremintConfigVersion,
-  PremintConfigWithVersion,
-  TokenCreationConfig,
 } from "@zoralabs/protocol-deployments";
+import { zeroAddress, parseEther, Account } from "viem";
 import { PublicClient } from "src/utils";
 import {
-  ContractCreationConfigAndAddress,
   ContractCreationConfigOrAddress,
   ContractCreationConfigWithOptionalAdditionalAdmins,
 } from "./contract-types";
@@ -42,11 +18,6 @@ import { MintCosts } from "src/mint/types";
 export const getPremintExecutorAddress = () =>
   zoraCreator1155PremintExecutorImplAddress[999] as Address;
 
-export type IsValidSignatureReturn = {
-  isAuthorized: boolean;
-  recoveredAddress?: Address;
-};
-
 export async function isAuthorizedToCreatePremint({
   contractAdmin = zeroAddress,
   additionalAdmins = [],
@@ -74,203 +45,6 @@ export async function isAuthorizedToCreatePremint({
   });
 }
 
-export async function recoverPremintSigner<T extends PremintConfigVersion>({
-  signature,
-  ...rest
-}: {
-  signature: Hex;
-  chainId: number;
-  verifyingContract: Address;
-} & PremintConfigWithVersion<T>): Promise<Address> {
-  return await recoverTypedDataAddress({
-    ...premintTypedDataDefinition(rest),
-    signature,
-  });
-}
-
-export async function tryRecoverPremintSigner(
-  params: Parameters<typeof recoverPremintSigner>[0],
-) {
-  try {
-    return await recoverPremintSigner(params);
-  } catch (error) {
-    console.error(error);
-    return undefined;
-  }
-}
-
-/**
- * Recovers the address from a typed data signature and then checks if the recovered address is authorized to create a premint
- *
- * @param params validationProperties
- * @param params.typedData typed data definition for premint config
- * @param params.signature signature to validate
- * @param params.publicClient public rpc read-only client
- * @param params.premintConfigContractAdmin the original contractAdmin on the ContractCreationConfig for the premint; this is usually the original creator of the premint
- * @param params.tokenContract the address of the 1155 contract
- * @returns
- */
-export async function isValidSignature<T extends PremintConfigVersion>({
-  signature,
-  publicClient,
-  collection,
-  collectionAddress,
-  chainId,
-  ...premintConfigAndVersion
-}: {
-  signature: Hex;
-  chainId: number;
-  publicClient: PublicClient;
-} & PremintConfigWithVersion<T> &
-  ContractCreationConfigAndAddress): Promise<IsValidSignatureReturn> {
-  const recoveredAddress = await tryRecoverPremintSigner({
-    ...premintConfigAndVersion,
-    signature,
-    verifyingContract: collectionAddress,
-    chainId,
-  });
-
-  if (!recoverAddress) {
-    return {
-      isAuthorized: false,
-    };
-  }
-
-  const isAuthorized = await isAuthorizedToCreatePremint({
-    signer: recoveredAddress!,
-    additionalAdmins: collection?.additionalAdmins,
-    contractAdmin: collection?.contractAdmin,
-    collectionAddress: collectionAddress,
-    publicClient,
-  });
-
-  return {
-    isAuthorized,
-    recoveredAddress,
-  };
-}
-
-/**
- * Converts a premint config from v1 to v2
- *
- * @param premintConfig premint config to convert
- * @param createReferral address that referred the creator, that will receive create referral rewards for the created token
- */
-export function migratePremintConfigToV2({
-  premintConfig,
-  createReferral = zeroAddress,
-}: {
-  premintConfig: PremintConfigV1;
-  createReferral: Address;
-}): PremintConfigV2 {
-  return {
-    ...premintConfig,
-    tokenConfig: {
-      tokenURI: premintConfig.tokenConfig.tokenURI,
-      maxSupply: premintConfig.tokenConfig.maxSupply,
-      maxTokensPerAddress: premintConfig.tokenConfig.maxTokensPerAddress,
-      pricePerToken: premintConfig.tokenConfig.pricePerToken,
-      mintStart: premintConfig.tokenConfig.mintStart,
-      mintDuration: premintConfig.tokenConfig.mintDuration,
-      payoutRecipient: premintConfig.tokenConfig.royaltyRecipient,
-      royaltyBPS: premintConfig.tokenConfig.royaltyBPS,
-      fixedPriceMinter: premintConfig.tokenConfig.fixedPriceMinter,
-      createReferral,
-    },
-  };
-}
-
-export type CreatorAttributionEventParams = GetEventArgs<
-  typeof zoraCreator1155ImplABI,
-  "CreatorAttribution",
-  { EnableUnion: false }
->;
-
-/**
- * Recovers the address from a CreatorAttribution event emitted from a ZoraCreator1155 contract
- * Useful for verifying that the creator of a token is the one who signed a premint for its creation.
- * 
-
- * @param creatorAttribution parameters from the CreatorAttribution event
- * @param chainId the chain id of the current chain
- * @param tokenContract the address of the 1155 contract
- * @returns the address of the signer
- */
-export const recoverCreatorFromCreatorAttribution = async ({
-  creatorAttribution: { version, domainName, structHash, signature },
-  chainId,
-  tokenContract,
-}: {
-  creatorAttribution: CreatorAttributionEventParams;
-  tokenContract: Address;
-  chainId: number;
-}) => {
-  // hash the eip712 domain based on the parameters emitted from the event:
-  const hashedDomain = hashDomain({
-    domain: {
-      chainId,
-      name: domainName,
-      verifyingContract: tokenContract,
-      version,
-    },
-    types: {
-      EIP712Domain: [
-        { name: "name", type: "string" },
-        { name: "version", type: "string" },
-        {
-          name: "chainId",
-          type: "uint256",
-        },
-        {
-          name: "verifyingContract",
-          type: "address",
-        },
-      ],
-    },
-  });
-
-  // re-build the eip-712 typed data hash, consisting of the hashed domain and the structHash emitted from the event:
-  const parts: Hex[] = ["0x1901", hashedDomain, structHash!];
-
-  const hashedTypedData = keccak256(concat(parts));
-
-  return await recoverAddress({
-    hash: hashedTypedData,
-    signature: signature!,
-  });
-};
-
-export const supportedPremintVersions = async ({
-  tokenContract,
-  publicClient,
-}: {
-  tokenContract: Address;
-  publicClient: PublicClient;
-}): Promise<PremintConfigVersion[]> => {
-  return (await publicClient.readContract({
-    abi: preminterAbi,
-    address: getPremintExecutorAddress(),
-    functionName: "supportedPremintSignatureVersions",
-    args: [tokenContract],
-  })) as PremintConfigVersion[];
-};
-/**
- * Checks if the 1155 contract at that address supports the given version of the premint config.
- */
-export const supportsPremintVersion = async ({
-  version,
-  tokenContract,
-  publicClient,
-}: {
-  version: PremintConfigVersion;
-  tokenContract: Address;
-  publicClient: PublicClient;
-}): Promise<boolean> => {
-  return (
-    await supportedPremintVersions({ tokenContract, publicClient })
-  ).includes(version);
-};
-
 export async function getPremintCollectionAddress({
   publicClient,
   contract: collection,
@@ -295,45 +69,6 @@ export async function getPremintCollectionAddress({
   return collectionAddress;
 }
 
-export function applyUpdateToPremint({
-  uid,
-  version,
-  tokenConfig,
-  tokenConfigUpdates,
-}: {
-  tokenConfig: TokenCreationConfig;
-  tokenConfigUpdates: Partial<TokenCreationConfig>;
-} & Pick<PremintConfig, "uid" | "version">): PremintConfig {
-  const updatedTokenConfig: TokenCreationConfig = {
-    ...tokenConfig,
-    ...tokenConfigUpdates,
-  } as const;
-
-  const result = {
-    deleted: false,
-    uid,
-    version: version + 1,
-    tokenConfig: updatedTokenConfig,
-  } as PremintConfig;
-
-  return result;
-}
-
-export function makeNewPremint<T extends PremintConfigVersion>({
-  tokenConfig,
-  uid,
-}: {
-  tokenConfig: PremintConfigForVersion<T>["tokenConfig"];
-  uid: number;
-}): PremintConfigForVersion<T> {
-  return {
-    deleted: false,
-    uid,
-    version: 0,
-    tokenConfig,
-  } as PremintConfigForVersion<T>;
-}
-
 export async function getPremintMintFee({
   tokenContract,
   publicClient,
@@ -380,7 +115,7 @@ export async function getPremintMintCosts({
     totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt,
   };
 }
-export async function getPremintPricePerToken({
+async function getPremintPricePerToken({
   collection,
   uid,
   premintGetter,
@@ -434,12 +169,6 @@ export function makeMintRewardsRecipient({
   return [mintReferral, platformReferral];
 }
 
-export function getDefaultFixedPriceMinterAddress(chainId: number): Address {
-  return zoraCreatorFixedPriceSaleStrategyAddress[
-    chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
-  ]!;
-}
-
 export const emptyContractCreationConfig = (): ContractCreationConfig => ({
   contractAdmin: zeroAddress,
   contractURI: "",

package/src/sdk.ts

@@ -20,8 +20,6 @@ import {
 import { SecondaryClient } from "./secondary/secondary-client";
 
 export type CreatorClient = {
-  createPremint: PremintClient["createPremint"];
-  updatePremint: PremintClient["updatePremint"];
   deletePremint: PremintClient["deletePremint"];
   create1155: Create1155Client["createNew1155"];
   create1155OnExistingContract: Create1155Client["createNew1155OnExistingContract"];
@@ -82,8 +80,6 @@ export function createCreatorClient(
   });
 
   return {
-    createPremint: (p) => premintClient.createPremint(p),
-    updatePremint: (p) => premintClient.updatePremint(p),
     deletePremint: (p) => premintClient.deletePremint(p),
     create1155: (p) => create1155CreatorClient.createNew1155(p),
     create1155OnExistingContract: (p) =>