@zoralabs/protocol-sdk 0.5.15 → 0.5.17

package/src/premint/preminter.test.ts

@@ -1,4 +1,11 @@
-import { Address, zeroAddress } from "viem";
+import {
+  Address,
+  Hex,
+  hashTypedData,
+  keccak256,
+  stringToBytes,
+  zeroAddress,
+} from "viem";
 import { zoraSepolia } from "viem/chains";
 import { describe, expect } from "vitest";
 import { parseEther } from "viem";
@@ -24,6 +31,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 +173,7 @@ async function setupContracts({
 
 const zoraSepoliaAnvilTest = makeAnvilTest({
   forkUrl: forkUrls.zoraSepolia,
-  forkBlockNumber: 8948974,
+  forkBlockNumber: 9467979,
   anvilChainId: zoraSepolia.id,
 });
 
@@ -239,6 +260,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 +315,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,
@@ -524,6 +547,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,
+          })
+        ).totalCost;
+
+        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 }) => {

package/src/premint/preminter.ts

@@ -6,11 +6,12 @@ import {
   zoraCreator1155PremintExecutorImplAddress,
   zoraCreatorFixedPriceSaleStrategyAddress,
   premintTypedDataDefinition,
+  ContractCreationConfig,
+  PremintConfigForVersion,
 } from "@zoralabs/protocol-deployments";
 import {
   recoverTypedDataAddress,
   Hex,
-  PublicClient,
   zeroAddress,
   hashDomain,
   keccak256,
@@ -18,11 +19,10 @@ import {
   recoverAddress,
   GetEventArgs,
   parseEther,
+  Account,
 } from "viem";
 import {
-  ContractCreationConfig,
   PremintConfig,
-  PremintConfigForTokenCreationConfig,
   PremintConfigV1,
   PremintConfigV2,
   PremintConfigVersion,
@@ -30,6 +30,12 @@ import {
   TokenCreationConfig,
 } from "@zoralabs/protocol-deployments";
 import { MintCosts } from "src/mint/mint-client";
+import { PublicClient } from "src/utils";
+import {
+  ContractCreationConfigAndAddress,
+  ContractCreationConfigOrAddress,
+  ContractCreationConfigWithOptionalAdditionalAdmins,
+} from "./contract-types";
 
 export const getPremintExecutorAddress = () =>
   zoraCreator1155PremintExecutorImplAddress[999] as Address;
@@ -40,28 +46,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 +112,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 +136,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 +244,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 +270,27 @@ export const supportsPremintVersion = async ({
 };
 
 export async function getPremintCollectionAddress({
-  collection,
   publicClient,
+  collection,
+  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 +317,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({
@@ -377,3 +390,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 {
+      collection,
+    };
+  }
+
+  if (typeof collectionAddress !== "undefined") {
+    return {
+      collectionAddress,
+    };
+  }
+
+  throw new Error("Must provide either a collection or a collection address");
+};

package/src/utils.ts

@@ -5,8 +5,16 @@ import {
   Chain,
   ContractFunctionArgs,
   ContractFunctionName,
+  PublicClient as BasePublicClient,
   SimulateContractParameters,
+  Transport,
+  createPublicClient,
+  http,
 } from "viem";
+import {
+  IHttpClient,
+  httpClient as defaultHttpClient,
+} from "./apis/http-api-base";
 
 export const makeSimulateContractParamaters = <
   const abi extends Abi | readonly unknown[],
@@ -28,3 +36,20 @@ export const makeSimulateContractParamaters = <
     accountOverride
   >,
 ) => args;
+
+export type PublicClient = BasePublicClient<Transport, Chain>;
+
+export type ClientConfig = {
+  chain: Chain;
+  publicClient?: PublicClient;
+  httpClient?: IHttpClient;
+};
+
+export function setupClient({ chain, httpClient, publicClient }: ClientConfig) {
+  return {
+    chain,
+    httpClient: httpClient || defaultHttpClient,
+    publicClient:
+      publicClient || createPublicClient({ chain, transport: http() }),
+  };
+}

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

@@ -47,7 +47,7 @@ tests.forEach(({ anvilTest, chain }) => {
             const { uid, verifyingContract } =
               await premintClient.createPremint({
                 walletClient,
-                creatorAccount: creatorAccount!,
+                payoutRecipient: creatorAccount!,
                 checkSignature: true,
                 collection: {
                   contractAdmin: creatorAccount!,
@@ -104,7 +104,7 @@ tests.forEach(({ anvilTest, chain }) => {
             const { uid, verifyingContract } =
               await premintClient.createPremint({
                 walletClient,
-                creatorAccount: creatorAccount!,
+                payoutRecipient: creatorAccount!,
                 checkSignature: true,
                 collection: {
                   contractAdmin: creatorAccount!,