@zoralabs/protocol-sdk 0.5.16 → 0.6.0

package/src/premint/preminter.test.ts

@@ -1,4 +1,10 @@
-import { Address, zeroAddress } from "viem";
+import {
+  Address,
+  hashTypedData,
+  keccak256,
+  stringToBytes,
+  zeroAddress,
+} from "viem";
 import { zoraSepolia } from "viem/chains";
 import { describe, expect } from "vitest";
 import { parseEther } from "viem";
@@ -24,6 +30,20 @@ import {
   getPremintMintCosts,
 } from "./preminter";
 import { AnvilViemClientsTest, forkUrls, makeAnvilTest } from "src/anvil";
+import { privateKeyToAccount } from "viem/accounts";
+
+const erc1271Abi = [
+  {
+    type: "function",
+    name: "isValidSignature",
+    inputs: [
+      { name: "_hash", type: "bytes32", internalType: "bytes32" },
+      { name: "_signature", type: "bytes", internalType: "bytes" },
+    ],
+    outputs: [{ name: "", type: "bytes4", internalType: "bytes4" }],
+    stateMutability: "view",
+  },
+] as const;
 
 // create token and contract creation config:
 export const defaultContractConfig = ({
@@ -152,7 +172,7 @@ async function setupContracts({
 
 const zoraSepoliaAnvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraSepolia,
-  forkBlockNumber: 8948974,
+  forkBlockNumber: 9467979,
   anvilChainId: zoraSepolia.id,
 });
 
@@ -239,6 +259,7 @@ describe("ZoraCreator1155Preminter", () => {
       // recover and verify address is correct
       const { recoveredAddress, isAuthorized } = await isValidSignature({
         collection: contractConfig,
+        collectionAddress: tokenContract,
         chainId: viemClients.publicClient.chain!.id,
         premintConfig,
         premintConfigVersion: PremintConfigVersion.V1,
@@ -293,6 +314,7 @@ describe("ZoraCreator1155Preminter", () => {
       // recover and verify address is correct
       const { recoveredAddress, isAuthorized } = await isValidSignature({
         collection: contractConfig,
+        collectionAddress: tokenContract,
         chainId: viemClients.publicClient.chain!.id,
         premintConfig,
         premintConfigVersion: PremintConfigVersion.V2,
@@ -356,7 +378,7 @@ describe("ZoraCreator1155Preminter", () => {
           tokenContract: contractAddress,
           tokenPrice: premintConfig1.tokenConfig.pricePerToken,
         })
-      ).totalCost;
+      ).totalCostEth;
 
       await viemClients.testClient.setBalance({
         address: collectorAccount,
@@ -465,7 +487,7 @@ describe("ZoraCreator1155Preminter", () => {
           tokenContract: contractAddress,
           tokenPrice: premintConfig2.tokenConfig.pricePerToken,
         })
-      ).totalCost;
+      ).totalCostEth;
 
       const simulationResult = await viemClients.publicClient.simulateContract({
         abi: preminterAbi,
@@ -524,6 +546,135 @@ describe("ZoraCreator1155Preminter", () => {
     },
     40 * 1000,
   ),
+    zoraSepoliaAnvilTest(
+      "can sign a premint from an smart contract account and mint tokens against that premint",
+      async ({ viemClients }) => {
+        const {
+          fixedPriceMinterAddress,
+          accounts: { collectorAccount },
+        } = await setupContracts({ viemClients });
+
+        // this test shows how to create a premint that is signed by an EOA, but the premint
+        // contract admin will be a smart wallet owned by the EOA.
+        // contract admin is set as the smart wallet.  Smart wallet owner is the EOA.
+        // EOA signs the premint.
+        // When calling `premint` smart wallets address must be passed as an argument
+
+        // this was an AA contract that was deployed that has has the owner below as the
+        // valid signer. See https://sepolia.explorer.zora.energy/address/0x74F5fAf983d54FEd6D937654Aa4FD258534F2d4B?tab=contract
+        // it was deployed via the script `packages/1155-deployments/script/DeploySimpleAA.s.sol`
+        const smartWalletAddress = "0x74F5fAf983d54FEd6D937654Aa4FD258534F2d4B";
+        const ownerAddress = "0x7c8999dC9a822c1f0Df42023113EDB4FDd543266";
+        const ownerPrivateKey =
+          "0x02016836a56b71f0d02689e69e326f4f4c1b9057164ef592671cf0d37c8040c0";
+
+        const ownerAccount = privateKeyToAccount(ownerPrivateKey);
+
+        const premintConfig = defaultPremintConfigV2({
+          fixedPriceMinter: fixedPriceMinterAddress,
+          // we set the creator to the AA contract
+          creatorAccount: smartWalletAddress,
+        });
+
+        expect(ownerAccount.address).toBe(ownerAddress);
+
+        const contractConfig = defaultContractConfig({
+          // for the contract config, we set the smart wallet as the admin
+          contractAdmin: smartWalletAddress,
+        });
+
+        let contractAddress = await viemClients.publicClient.readContract({
+          abi: preminterAbi,
+          address: PREMINTER_ADDRESS,
+          functionName: "getContractWithAdditionalAdminsAddress",
+          args: [contractConfig],
+        });
+
+        const typedData = premintTypedDataDefinition({
+          verifyingContract: contractAddress,
+          // we need to sign here for the anvil chain, cause thats where it is run on
+          chainId: viemClients.chain.id,
+          premintConfig: premintConfig,
+          premintConfigVersion: PremintConfigVersion.V2,
+        });
+
+        // have creator sign the message to create the contract
+        // and the token
+        const signedMessage = await viemClients.walletClient.signTypedData({
+          ...typedData,
+          account: ownerAccount,
+        });
+
+        // sanity check - validate the signature on the smart wallet contract
+        const result = await viemClients.publicClient.readContract({
+          abi: erc1271Abi,
+          address: smartWalletAddress,
+          functionName: "isValidSignature",
+          args: [hashTypedData(typedData), signedMessage],
+        });
+
+        // if is a valid signature, signature should return `bytes4(keccak256("isValidSignature(bytes32,bytes)"))`
+        const expectedMagicValue = keccak256(
+          stringToBytes("isValidSignature(bytes32,bytes)"),
+        ).slice(0, 10);
+
+        expect(result).toBe(expectedMagicValue);
+
+        const quantityToMint = 2n;
+
+        const valueToSend = (
+          await getPremintMintCosts({
+            publicClient: viemClients.publicClient,
+            quantityToMint,
+            tokenContract: contractAddress,
+            tokenPrice: premintConfig.tokenConfig.pricePerToken,
+          })
+        ).totalCostEth;
+
+        await viemClients.testClient.setBalance({
+          address: collectorAccount,
+          value: parseEther("10"),
+        });
+
+        const mintArguments: PremintMintArguments = {
+          mintComment: "",
+          mintRecipient: collectorAccount,
+          mintRewardsRecipients: [],
+        };
+
+        const firstMinter = collectorAccount;
+
+        // now have the collector execute the first signed message;
+        // it should create the contract, the token,
+        // and min the quantity to mint tokens to the collector
+        // the signature along with contract + token creation
+        // parameters are required to call this function
+        await viemClients.publicClient.simulateContract({
+          abi: preminterAbi,
+          functionName: "premint",
+          account: collectorAccount,
+          chain: viemClients.chain,
+          address: PREMINTER_ADDRESS,
+          args: [
+            contractConfig,
+            zeroAddress,
+            encodePremintConfig({
+              premintConfig: premintConfig,
+              premintConfigVersion: PremintConfigVersion.V2,
+            }),
+            signedMessage,
+            quantityToMint,
+            mintArguments,
+            firstMinter,
+            // we must specify the smart wallet address in the call, so that the 1155 contract
+            // knows to have the smart wallet validate the signature
+            smartWalletAddress,
+          ],
+          value: valueToSend,
+        });
+      },
+      40 * 1000,
+    ),
     zoraSepoliaAnvilTest(
       "can have collaborators create premints that can be executed on existing contracts",
       async ({ viemClients }) => {
@@ -600,7 +751,7 @@ describe("ZoraCreator1155Preminter", () => {
             tokenContract: contractAddress,
             tokenPrice: premintConfig.tokenConfig.pricePerToken,
           })
-        ).totalCost;
+        ).totalCostEth;
 
         const mintArguments: PremintMintArguments = {
           mintComment: "",

package/src/premint/preminter.ts

@@ -6,6 +6,8 @@ import {
   zoraCreator1155PremintExecutorImplAddress,
   zoraCreatorFixedPriceSaleStrategyAddress,
   premintTypedDataDefinition,
+  ContractCreationConfig,
+  PremintConfigForVersion,
 } from "@zoralabs/protocol-deployments";
 import {
   recoverTypedDataAddress,
@@ -17,11 +19,10 @@ import {
   recoverAddress,
   GetEventArgs,
   parseEther,
+  Account,
 } from "viem";
 import {
-  ContractCreationConfig,
   PremintConfig,
-  PremintConfigForTokenCreationConfig,
   PremintConfigV1,
   PremintConfigV2,
   PremintConfigVersion,
@@ -30,6 +31,13 @@ import {
 } from "@zoralabs/protocol-deployments";
 import { MintCosts } from "src/mint/mint-client";
 import { PublicClient } from "src/utils";
+import {
+  ContractCreationConfigAndAddress,
+  ContractCreationConfigOrAddress,
+  ContractCreationConfigWithOptionalAdditionalAdmins,
+} from "./contract-types";
+import { IPremintGetter } from "./premint-api-client";
+import { isPremintConfigV1, isPremintConfigV2 } from "./conversions";
 
 export const getPremintExecutorAddress = () =>
   zoraCreator1155PremintExecutorImplAddress[999] as Address;
@@ -40,28 +48,28 @@ export type IsValidSignatureReturn = {
 };
 
 export async function isAuthorizedToCreatePremint({
-  collection,
+  contractAdmin = zeroAddress,
+  additionalAdmins = [],
   collectionAddress,
   publicClient,
   signer,
 }: {
-  collection: ContractCreationConfig;
+  contractAdmin?: Address;
+  additionalAdmins?: Address[];
   collectionAddress: Address;
   publicClient: PublicClient;
-  signer: Address;
+  signer: Address | Account;
 }) {
-  if (collection.additionalAdmins.length > 0)
-    throw new Error("additionalAdmins not supported yet.");
   // otherwize, we must assume the newer version of premint executor is deployed, so we call that.
   return await publicClient.readContract({
     abi: preminterAbi,
     address: getPremintExecutorAddress(),
     functionName: "isAuthorizedToCreatePremintWithAdditionalAdmins",
     args: [
-      signer,
-      collection.contractAdmin,
+      typeof signer === "string" ? signer : signer.address,
+      contractAdmin,
       collectionAddress,
-      collection.additionalAdmins,
+      additionalAdmins,
     ],
   });
 }
@@ -106,22 +114,19 @@ export async function isValidSignature<T extends PremintConfigVersion>({
   signature,
   publicClient,
   collection,
+  collectionAddress,
   chainId,
   ...premintConfigAndVersion
 }: {
-  collection: ContractCreationConfig;
   signature: Hex;
   chainId: number;
   publicClient: PublicClient;
-} & PremintConfigWithVersion<T>): Promise<IsValidSignatureReturn> {
-  const tokenContract = await getPremintCollectionAddress({
-    collection,
-    publicClient,
-  });
+} & PremintConfigWithVersion<T> &
+  ContractCreationConfigAndAddress): Promise<IsValidSignatureReturn> {
   const recoveredAddress = await tryRecoverPremintSigner({
     ...premintConfigAndVersion,
     signature,
-    verifyingContract: tokenContract,
+    verifyingContract: collectionAddress,
     chainId,
   });
 
@@ -133,8 +138,9 @@ export async function isValidSignature<T extends PremintConfigVersion>({
 
   const isAuthorized = await isAuthorizedToCreatePremint({
     signer: recoveredAddress!,
-    collection,
-    collectionAddress: tokenContract,
+    additionalAdmins: collection?.additionalAdmins,
+    contractAdmin: collection?.contractAdmin,
+    collectionAddress: collectionAddress,
     publicClient,
   });
 
@@ -240,13 +246,13 @@ export const supportedPremintVersions = async ({
 }: {
   tokenContract: Address;
   publicClient: PublicClient;
-}): Promise<readonly string[]> => {
-  return await publicClient.readContract({
+}): 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.
@@ -266,18 +272,27 @@ export const supportsPremintVersion = async ({
 };
 
 export async function getPremintCollectionAddress({
-  collection,
   publicClient,
+  contract: collection,
+  contractAddress: collectionAddress,
 }: {
-  collection: ContractCreationConfig;
   publicClient: PublicClient;
-}): Promise<Address> {
-  return publicClient.readContract({
-    address: getPremintExecutorAddress(),
-    abi: zoraCreator1155PremintExecutorImplABI,
-    functionName: "getContractAddress",
-    args: [collection],
-  });
+} & ContractCreationConfigOrAddress): Promise<Address> {
+  if (typeof collection !== "undefined") {
+    return publicClient.readContract({
+      address: getPremintExecutorAddress(),
+      abi: zoraCreator1155PremintExecutorImplABI,
+      functionName: "getContractWithAdditionalAdminsAddress",
+      args: [
+        {
+          ...collection,
+          additionalAdmins: collection.additionalAdmins || [],
+        },
+      ],
+    });
+  }
+
+  return collectionAddress;
 }
 
 export function applyUpdateToPremint({
@@ -304,19 +319,19 @@ export function applyUpdateToPremint({
   return result;
 }
 
-export function makeNewPremint<T extends TokenCreationConfig>({
+export function makeNewPremint<T extends PremintConfigVersion>({
   tokenConfig,
   uid,
 }: {
-  tokenConfig: T;
+  tokenConfig: PremintConfigForVersion<T>["tokenConfig"];
   uid: number;
-}): PremintConfigForTokenCreationConfig<T> {
+}): PremintConfigForVersion<T> {
   return {
     deleted: false,
     uid,
     version: 0,
     tokenConfig,
-  } as PremintConfigForTokenCreationConfig<T>;
+  } as PremintConfigForVersion<T>;
 }
 
 export async function getPremintMintFee({
@@ -342,26 +357,74 @@ export async function getPremintMintFee({
   }
 }
 
+type GetMintCostsParams = {
+  tokenContract: Address;
+  tokenPrice: bigint;
+  quantityToMint: bigint | number;
+  publicClient: PublicClient;
+};
+
 export async function getPremintMintCosts({
   publicClient,
   tokenContract,
   tokenPrice,
   quantityToMint,
-}: {
-  tokenContract: Address;
-  tokenPrice: bigint;
-  quantityToMint: bigint;
-  publicClient: PublicClient;
-}): Promise<MintCosts> {
+}: GetMintCostsParams): Promise<MintCosts> {
   const mintFee = await getPremintMintFee({ tokenContract, publicClient });
 
+  const quantityToMintBigInt = BigInt(quantityToMint);
+
   return {
-    mintFee: mintFee * quantityToMint,
-    tokenPurchaseCost: tokenPrice * quantityToMint,
-    totalCost: (mintFee + tokenPrice) * quantityToMint,
+    mintFee: mintFee * quantityToMintBigInt,
+    totalPurchaseCost: tokenPrice * quantityToMintBigInt,
+    totalCostEth: (mintFee + tokenPrice) * quantityToMintBigInt,
   };
 }
 
+export async function getPremintPricePerToken({
+  collection,
+  uid,
+  premintGetter,
+}: {
+  collection: Address;
+  uid: number;
+  premintGetter: IPremintGetter;
+}) {
+  const premintConfigWithVersion = await premintGetter.getSignature({
+    collectionAddress: collection,
+    uid,
+  });
+
+  if (
+    isPremintConfigV1(premintConfigWithVersion) ||
+    isPremintConfigV2(premintConfigWithVersion)
+  ) {
+    return premintConfigWithVersion.premintConfig.tokenConfig.pricePerToken;
+  }
+
+  throw new Error("Premint version not supported to get price");
+}
+
+export async function getPremintMintCostsWithUnknownTokenPrice({
+  premintGetter,
+  uid,
+  ...rest
+}: Omit<GetMintCostsParams, "tokenPrice"> & {
+  premintGetter: IPremintGetter;
+  uid: number;
+}) {
+  const pricePerToken = await getPremintPricePerToken({
+    uid,
+    premintGetter,
+    collection: rest.tokenContract,
+  });
+
+  return await getPremintMintCosts({
+    ...rest,
+    tokenPrice: pricePerToken,
+  });
+}
+
 export function makeMintRewardsRecipient({
   mintReferral = zeroAddress,
   platformReferral = zeroAddress,
@@ -377,3 +440,41 @@ export function getDefaultFixedPriceMinterAddress(chainId: number): Address {
     chainId as keyof typeof zoraCreatorFixedPriceSaleStrategyAddress
   ]!;
 }
+
+export const emptyContractCreationConfig = (): ContractCreationConfig => ({
+  contractAdmin: zeroAddress,
+  contractURI: "",
+  contractName: "",
+  additionalAdmins: [],
+});
+
+export function defaultAdditionalAdmins(
+  collection: ContractCreationConfigWithOptionalAdditionalAdmins,
+): ContractCreationConfig {
+  return {
+    ...collection,
+    additionalAdmins: collection.additionalAdmins || [],
+  };
+}
+
+export const toContractCreationConfigOrAddress = ({
+  collection,
+  collectionAddress,
+}: {
+  collection?: ContractCreationConfigWithOptionalAdditionalAdmins;
+  collectionAddress?: Address;
+}) => {
+  if (typeof collection !== "undefined") {
+    return {
+      contract: collection,
+    };
+  }
+
+  if (typeof collectionAddress !== "undefined") {
+    return {
+      contractAddress: collectionAddress,
+    };
+  }
+
+  throw new Error("Must provide either a collection or a collection address");
+};

package/src/sdk.ts

@@ -0,0 +1,98 @@
+import {
+  PremintClient,
+  getDataFromPremintReceipt,
+} from "./premint/premint-client";
+import { Create1155Client } from "./create/1155-create-helper";
+import { MintClient } from "./mint/mint-client";
+import { ClientConfig } from "./utils";
+import { IPremintAPI, PremintAPIClient } from "./premint/premint-api-client";
+import { SubgraphMintGetter } from "./mint/subgraph-mint-getter";
+import { IMintGetter } from "./mint/types";
+
+export type CreatorClient = {
+  createPremint: PremintClient["createPremint"];
+  updatePremint: PremintClient["updatePremint"];
+  deletePremint: PremintClient["deletePremint"];
+  create1155: Create1155Client["createNew1155Token"];
+};
+
+export type CollectorClient = {
+  getPremint: PremintClient["getPremint"];
+  getCollectDataFromPremintReceipt: PremintClient["getDataFromPremintReceipt"];
+  mint: MintClient["mint"];
+  getMintCosts: MintClient["getMintCosts"];
+};
+
+export type CreatorClientConfig = ClientConfig & {
+  /** API for submitting and getting premints.  Defaults to the Zora Premint API */
+  premintApi?: IPremintAPI;
+};
+
+/**
+ * Builds the sdk for creating/managing 1155 contracts and tokens
+ *
+ * @param clientConfig - Configuration for the client {@link CreatorClientConfig}
+ * @returns CreatorClient {@link CreatorClient}
+ * */
+export function createCreatorClient(
+  clientConfig: CreatorClientConfig,
+): CreatorClient {
+  const premintClient = new PremintClient({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+    premintApi:
+      clientConfig.premintApi || new PremintAPIClient(clientConfig.chainId),
+  });
+
+  const create1155CreatorClient = new Create1155Client({
+    chainId: clientConfig.chainId,
+    publicClient: clientConfig.publicClient,
+  });
+
+  return {
+    createPremint: (p) => premintClient.createPremint(p),
+    updatePremint: (p) => premintClient.updatePremint(p),
+    deletePremint: (p) => premintClient.deletePremint(p),
+    create1155: (p) => create1155CreatorClient.createNew1155Token(p),
+  };
+}
+
+export type CollectorClientConfig = ClientConfig & {
+  /** API for getting premints.  Defaults to the Zora Premint API */
+  premintGetter?: IPremintAPI;
+  /** API for getting onchain mints.  Defaults to the Zora Creator Subgraph */
+  mintGetter?: IMintGetter;
+};
+
+/**
+ * Builds the sdk for collecting Premints, 1155, and 721 tokens.
+ *
+ * @param clientConfig - Configuration for the client {@link CollectorClientConfig}
+ * @returns CollectorClient {@link CollectorClient}
+ */
+export function createCollectorClient(
+  params: CollectorClientConfig,
+): CollectorClient {
+  const premintGetterToUse =
+    params.premintGetter || new PremintAPIClient(params.chainId);
+  const mintGetterToUse =
+    params.mintGetter || new SubgraphMintGetter(params.chainId);
+  const mintClient = new MintClient({
+    chainId: params.chainId,
+    publicClient: params.publicClient,
+    premintGetter: premintGetterToUse,
+    mintGetter: mintGetterToUse,
+  });
+
+  return {
+    getPremint: (p) =>
+      premintGetterToUse.getSignature({
+        collectionAddress: p.address,
+        uid: p.uid,
+      }),
+    getCollectDataFromPremintReceipt: (p) =>
+      getDataFromPremintReceipt(p, params.chainId),
+    mint: (p) => mintClient.mint(p),
+    getMintCosts: (p) => mintClient.getMintCosts(p),
+  };
+}

package/src/utils.ts

@@ -7,23 +7,14 @@ import {
   ContractFunctionName,
   PublicClient as BasePublicClient,
   SimulateContractParameters,
-  Transport,
-  createPublicClient,
-  http,
+  AbiStateMutability,
 } from "viem";
-import {
-  IHttpClient,
-  httpClient as defaultHttpClient,
-} from "./apis/http-api-base";
 
-export const makeSimulateContractParamaters = <
+export const makeContractParameters = <
   const abi extends Abi | readonly unknown[],
-  functionName extends ContractFunctionName<abi, "nonpayable" | "payable">,
-  args extends ContractFunctionArgs<
-    abi,
-    "nonpayable" | "payable",
-    functionName
-  >,
+  stateMutabiliy extends AbiStateMutability,
+  functionName extends ContractFunctionName<abi, stateMutabiliy>,
+  args extends ContractFunctionArgs<abi, stateMutabiliy, functionName>,
   chainOverride extends Chain | undefined,
   accountOverride extends Account | Address | undefined = undefined,
 >(
@@ -37,19 +28,35 @@ export const makeSimulateContractParamaters = <
   >,
 ) => args;
 
-export type PublicClient = BasePublicClient<Transport, Chain>;
+export type PublicClient = Pick<BasePublicClient, "readContract">;
 
 export type ClientConfig = {
-  chain: Chain;
-  publicClient?: PublicClient;
-  httpClient?: IHttpClient;
+  /** The chain that the client is to run on. */
+  chainId: number;
+  /** Optional public client for the chain.  If not provide, it is created. */
+  publicClient: PublicClient;
 };
 
-export function setupClient({ chain, httpClient, publicClient }: ClientConfig) {
+export function setupClient({ chainId, publicClient }: ClientConfig) {
   return {
-    chain,
-    httpClient: httpClient || defaultHttpClient,
-    publicClient:
-      publicClient || createPublicClient({ chain, transport: http() }),
+    chainId,
+    publicClient,
   };
 }
+
+export function mintRecipientOrAccount({
+  mintRecipient,
+  minterAccount,
+}: {
+  mintRecipient?: Address;
+  minterAccount: Address | Account;
+}): Address {
+  return (
+    mintRecipient ||
+    (typeof minterAccount === "string" ? minterAccount : minterAccount.address)
+  );
+}
+
+export type Concrete<Type> = {
+  [Property in keyof Type]-?: Type[Property];
+};