@zoralabs/protocol-sdk 0.5.8-DEV.2 → 0.5.8

package/src/mints/mints-contracts.ts

@@ -1,19 +1,29 @@
 import {
   zoraMints1155Config,
+  zoraMintsManagerImplABI,
   zoraMintsManagerImplConfig,
+  mintsEthUnwrapperAndCallerConfig,
+  iUnwrapAndForwardActionABI,
 } from "@zoralabs/protocol-deployments";
 import { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
-import { MintArguments, PremintConfigV2 } from "src/premint/contract-types";
+import {
+  MintArguments as PremintMintArguments,
+  PremintConfigV2,
+} from "src/premint/contract-types";
 import { ContractCreationConfig } from "src/preminter";
 import {
   Account,
   Address,
+  ContractFunctionRevertedError,
   Hex,
   ReadContractParameters,
   SignTypedDataParameters,
   SimulateContractParameters,
   TypedData,
+  decodeErrorResult,
+  encodeAbiParameters,
   encodeFunctionData,
+  parseAbiParameters,
   zeroAddress,
 } from "viem";
 
@@ -49,6 +59,12 @@ const getPaidMintValue = (quantities: bigint[], pricePerMint?: bigint) => {
   return quantities.reduce((a, b) => a + b, 0n) * pricePerMint;
 };
 
+export const fixedPriceMinterMinterArguments = ({
+  mintRecipient,
+}: {
+  mintRecipient: Address;
+}) => encodeAbiParameters(parseAbiParameters("address"), [mintRecipient]);
+
 export const mintsBalanceOfAccountParams = ({
   account,
   chainId,
@@ -65,31 +81,16 @@ export const mintsBalanceOfAccountParams = ({
   args: [account],
 });
 
-export const accountNonceParams = ({
-  chainId,
-  account,
-}: {
-  chainId: keyof typeof zoraMints1155Config.address;
-  account: Address;
-}): ReadContractParameters<typeof zoraMints1155Config.abi, "nonces"> => ({
-  abi: zoraMints1155Config.abi,
-  address: zoraMints1155Config.address[chainId],
-  functionName: "nonces",
-  args: [account],
-});
-
 type CollectOnManagerParams = {
   tokenIds: bigint[];
   quantities: bigint[];
   zoraCreator1155Contract: Address;
   zoraCreator1155TokenId: bigint;
   minter: Address;
-  mintArguments: MintArguments;
+  mintArguments: CollectMintArguments;
 };
 
 export const encodeCollectOnManager = ({
-  tokenIds,
-  quantities,
   zoraCreator1155Contract,
   minter,
   zoraCreator1155TokenId,
@@ -99,8 +100,6 @@ export const encodeCollectOnManager = ({
     abi: zoraMintsManagerImplConfig.abi,
     functionName: "collect",
     args: [
-      tokenIds,
-      quantities,
       zoraCreator1155Contract,
       minter,
       zoraCreator1155TokenId,
@@ -134,7 +133,7 @@ export function collectWithMintsParams({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, "0x", call],
+    args: [tokenIds, quantities, call],
     value: getPaidMintValue(quantities, pricePerToken),
     account,
   };
@@ -154,20 +153,23 @@ export const collectWithMintsTypedDataDefinition = ({
   deadline: bigint;
   account: Account | Address;
 } & CollectOnManagerParams) => {
-  const call = encodeCollectOnManager({
+  const safeTransferData = encodeCollectOnManager({
     tokenIds,
     quantities,
     ...rest,
   });
 
-  return makePermitAndTypeData({
+  return makePermitTransferBatchAndTypeData({
     tokenIds,
     quantities,
     chainId,
     account,
     nonce,
     deadline,
-    call,
+    safeTransferData,
+    // will safe transfer to manager contract before doing the
+    // collect operation
+    to: zoraMintsManagerImplConfig.address[chainId],
   });
 };
 
@@ -185,31 +187,33 @@ export const collectPremintWithMintsTypedDataDefinition = ({
   deadline: bigint;
   account: Account | Address;
 } & PremintOnManagerParams) => {
-  const call = encodePremintOnManager({
-    tokenIds,
-    quantities,
+  const safeTransferData = encodePremintOnManager({
     ...rest,
   });
 
-  return makePermitAndTypeData({
+  return makePermitTransferBatchAndTypeData({
     tokenIds,
     quantities,
     chainId,
     account,
     nonce,
     deadline,
-    call,
+    safeTransferData,
+    // will safe transfer to manager contract before doing the
+    // collect operation
+    to: zoraMintsManagerImplConfig.address[chainId],
   });
 };
 
-function makePermitAndTypeData({
+function makePermitTransferBatchAndTypeData({
   tokenIds,
   quantities,
   chainId,
   account,
+  to,
   nonce,
   deadline,
-  call,
+  safeTransferData,
 }: {
   tokenIds: bigint[];
   quantities: bigint[];
@@ -217,20 +221,62 @@ function makePermitAndTypeData({
   nonce: bigint;
   deadline: bigint;
   account: Account | Address;
-  call: Hex;
+  to: Address;
+  safeTransferData: Hex;
 }) {
-  const permit: PermitTransferBatchToManager = {
+  const permit: PermitSafeTransferBatch = {
     owner: typeof account === "string" ? account : account.address,
+    to,
     tokenIds,
     quantities,
-    call,
     deadline,
-    safeTransferData: "0x",
+    nonce,
+    safeTransferData,
   };
 
-  const typedData = permitTypedDataDefinition({
+  const typedData = permitBatchTypedDataDefinition({
     chainId,
+    permit,
+    account,
+  });
+
+  return {
+    permit,
+    typedData,
+  };
+}
+
+function makePermitTransferTypeData({
+  tokenId,
+  quantity,
+  chainId,
+  account,
+  to,
+  nonce,
+  deadline,
+  safeTransferData,
+}: {
+  tokenId: bigint;
+  quantity: bigint;
+  chainId: keyof typeof zoraMints1155Config.address;
+  nonce: bigint;
+  deadline: bigint;
+  account: Account | Address;
+  to: Address;
+  safeTransferData: Hex;
+}) {
+  const permit: PermitSafeTransfer = {
+    owner: typeof account === "string" ? account : account.address,
+    to,
+    tokenId,
+    quantity,
+    deadline,
     nonce,
+    safeTransferData,
+  };
+
+  const typedData = permitTransferTypedDataDefinition({
+    chainId,
     permit,
     account,
   });
@@ -247,25 +293,21 @@ type PremintOnManagerParams = {
   contractCreationConfig: ContractCreationConfig;
   premintConfig: PremintConfigV2;
   premintSignature: Hex;
-  mintArguments: MintArguments;
+  mintArguments: PremintMintArguments;
   signerContract?: Address;
 };
 
 export const encodePremintOnManager = ({
-  tokenIds,
-  quantities,
   contractCreationConfig,
   premintConfig,
   premintSignature,
   mintArguments,
   signerContract = zeroAddress,
-}: PremintOnManagerParams) =>
+}: Omit<PremintOnManagerParams, "tokenIds" | "quantities">) =>
   encodeFunctionData({
     abi: zoraMintsManagerImplConfig.abi,
     functionName: "collectPremintV2",
     args: [
-      tokenIds,
-      quantities,
       contractCreationConfig,
       premintConfig,
       premintSignature,
@@ -290,8 +332,6 @@ export function collectPremintV2WithMintsParams({
   "transferBatchToManagerAndCall"
 > {
   const call = encodePremintOnManager({
-    tokenIds,
-    quantities,
     ...rest,
   });
 
@@ -299,18 +339,29 @@ export function collectPremintV2WithMintsParams({
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
     functionName: "transferBatchToManagerAndCall",
-    args: [tokenIds, quantities, "0x", call],
+    args: [tokenIds, quantities, call],
     value: getPaidMintValue(quantities, pricePerToken),
     account,
   };
 }
 
-export type PermitTransferBatchToManager = AbiParametersToPrimitiveTypes<
+export type PermitSafeTransferBatch = AbiParametersToPrimitiveTypes<
   ExtractAbiFunction<
     typeof zoraMints1155Config.abi,
-    "permitTransferBatchToManagerAndCall"
+    "permitSafeTransferBatch"
   >["inputs"]
 >[0];
+
+export type PermitSafeTransfer = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<
+    typeof zoraMints1155Config.abi,
+    "permitSafeTransfer"
+  >["inputs"]
+>[0];
+
+export type CollectMintArguments = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<typeof zoraMintsManagerImplConfig.abi, "collect">["inputs"]
+>[3];
 // export type PermitTransferBatchToManager = ExtractAbiFunction<
 
 function makeTypeData<
@@ -320,15 +371,13 @@ function makeTypeData<
   return args;
 }
 
-export function permitTypedDataDefinition({
+export function permitBatchTypedDataDefinition({
   permit,
   chainId,
-  nonce,
   account,
 }: {
-  permit: PermitTransferBatchToManager;
+  permit: PermitSafeTransferBatch;
   chainId: keyof typeof zoraMints1155Config.address;
-  nonce: bigint;
   account: Account | Address;
 }) {
   return makeTypeData({
@@ -339,6 +388,10 @@ export function permitTypedDataDefinition({
           name: "owner",
           type: "address",
         },
+        {
+          name: "to",
+          type: "address",
+        },
         {
           name: "tokenIds",
           type: "uint256[]",
@@ -352,7 +405,58 @@ export function permitTypedDataDefinition({
           type: "bytes",
         },
         {
-          name: "call",
+          name: "nonce",
+          type: "uint256",
+        },
+        {
+          name: "deadline",
+          type: "uint256",
+        },
+      ],
+    },
+    message: permit,
+    domain: {
+      chainId,
+      name: "Mints",
+      version: "1",
+      verifyingContract: zoraMints1155Config.address[chainId],
+    },
+    // signing account must be permit owner
+    account,
+  });
+}
+
+export function permitTransferTypedDataDefinition({
+  permit,
+  chainId,
+  account,
+}: {
+  permit: PermitSafeTransfer;
+  chainId: keyof typeof zoraMints1155Config.address;
+  account: Account | Address;
+}) {
+  return makeTypeData({
+    primaryType: "PermitSafeTransfer",
+    types: {
+      PermitSafeTransfer: [
+        {
+          name: "owner",
+          type: "address",
+        },
+        {
+          name: "to",
+          type: "address",
+        },
+        {
+          name: "tokenId",
+          type: "uint256",
+        },
+        {
+          name: "quantity",
+          type: "uint256",
+        },
+        {
+          name: "safeTransferData",
           type: "bytes",
         },
         {
@@ -365,15 +469,7 @@ export function permitTypedDataDefinition({
         },
       ],
     },
-    message: {
-      owner: permit.owner,
-      tokenIds: permit.tokenIds,
-      quantities: permit.quantities,
-      safeTransferData: permit.safeTransferData,
-      call: permit.call,
-      nonce,
-      deadline: permit.deadline,
-    },
+    message: permit,
     domain: {
       chainId,
       name: "Mints",
@@ -390,19 +486,170 @@ export const permitTransferBatchToManagerAndCallParams = ({
   chainId,
   signature,
 }: {
-  permit: PermitTransferBatchToManager;
+  permit: PermitSafeTransferBatch;
   chainId: keyof typeof zoraMints1155Config.address;
   signature: Hex;
 }) => {
   const result: SimulateContractParameters<
     typeof zoraMints1155Config.abi,
-    "permitTransferBatchToManagerAndCall"
+    "permitSafeTransferBatch"
   > = {
     abi: zoraMints1155Config.abi,
     address: zoraMints1155Config.address[chainId],
-    functionName: "permitTransferBatchToManagerAndCall",
+    functionName: "permitSafeTransferBatch",
     args: [permit, signature],
   };
 
   return result;
 };
+
+export const safeTransferAndUnwrapTypedDataDefinition = ({
+  chainId,
+  tokenId,
+  quantity,
+  from,
+  addressToCall,
+  functionToCall,
+  valueToSend,
+  deadline,
+  nonce,
+}: {
+  tokenId: bigint;
+  quantity: bigint;
+  chainId: keyof typeof zoraMints1155Config.address;
+  // mints will be transferred from this address,
+  // must match the callers address
+  from: Address | Account;
+  addressToCall: Address;
+  functionToCall: Hex;
+  valueToSend: bigint;
+  deadline: bigint;
+  nonce: bigint;
+}) => {
+  // this is the call that the wrapper will call
+  const callArgument = encodeFunctionData({
+    abi: iUnwrapAndForwardActionABI,
+    functionName: "callWithEth",
+    args: [addressToCall, functionToCall, valueToSend],
+  });
+
+  return makePermitTransferTypeData({
+    account: from,
+    chainId,
+    deadline,
+    tokenId,
+    quantity,
+    safeTransferData: callArgument,
+    to: mintsEthUnwrapperAndCallerConfig.address[chainId],
+    nonce,
+  });
+};
+
+export const safeTransferBatchAndUnwrapTypedDataDefinition = ({
+  chainId,
+  tokenIds,
+  quantities,
+  from,
+  addressToCall,
+  functionToCall,
+  valueToSend,
+  deadline,
+  nonce,
+}: {
+  tokenIds: bigint[];
+  quantities: bigint[];
+  chainId: keyof typeof zoraMints1155Config.address;
+  // mints will be transferred from this address,
+  // must match the callers address
+  from: Address | Account;
+  addressToCall: Address;
+  functionToCall: Hex;
+  valueToSend: bigint;
+  deadline: bigint;
+  nonce: bigint;
+}) => {
+  // this is the call that the wrapper will call
+  const callArgument = encodeFunctionData({
+    abi: iUnwrapAndForwardActionABI,
+    functionName: "callWithEth",
+    args: [addressToCall, functionToCall, valueToSend],
+  });
+
+  return makePermitTransferBatchAndTypeData({
+    account: from,
+    chainId,
+    deadline,
+    tokenIds,
+    quantities,
+    safeTransferData: callArgument,
+    to: mintsEthUnwrapperAndCallerConfig.address[chainId],
+    nonce,
+  });
+};
+
+export const safeTransferAndUnwrapEthParams = ({
+  chainId,
+  tokenIds,
+  quantities,
+  from,
+  addressToCall,
+  functionToCall,
+  valueToSend,
+}: {
+  tokenIds: bigint[];
+  quantities: bigint[];
+  chainId: keyof typeof zoraMints1155Config.address;
+  // mints will be transferred from this address,
+  // must match the callers address
+  from: Address | Account;
+  addressToCall: Address;
+  functionToCall: Hex;
+  valueToSend: bigint;
+}) => {
+  // this is the encoded calldata for the eth unwrapper to
+  // read and execute.
+  // for valueToSend, whatever is remaining will be refunded
+  // to the recipient.
+  const callArgument = encodeFunctionData({
+    abi: iUnwrapAndForwardActionABI,
+    functionName: "callWithEth",
+    args: [addressToCall, functionToCall, valueToSend],
+  });
+
+  const result: SimulateContractParameters<
+    typeof zoraMints1155Config.abi,
+    "safeBatchTransferFrom"
+  > = {
+    abi: zoraMints1155Config.abi,
+    functionName: "safeBatchTransferFrom",
+    address: zoraMints1155Config.address[chainId],
+    args: [
+      typeof from === "string" ? from : from.address,
+      // the mints will be transferred to this address, which
+      // will burn/redeem their eth value
+      mintsEthUnwrapperAndCallerConfig.address[chainId],
+      // token ids to transfer/burn/unwrap - must be eth based tokens
+      tokenIds,
+      // quantities to transfer/burn/unwrap
+      quantities,
+      // this is the safeTransferData - which gets forwarded to the eth transferrer
+      callArgument,
+    ],
+    // the account whos mints will be transferred from
+    account: from,
+  };
+
+  return result;
+};
+
+export function decodeCallFailedError(error: ContractFunctionRevertedError) {
+  if (error.data?.errorName !== "CallFailed")
+    throw new Error("Not a CallFailed error");
+
+  const internalErrorData = error.data?.args?.[0] as Hex;
+
+  return decodeErrorResult({
+    abi: zoraMintsManagerImplABI,
+    data: internalErrorData,
+  });
+}

package/src/mints/mints-queries.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import {
+  MintAccountBalance,
+  selectMintsToCollectWithFromQueryResult,
+  sumBalances,
+} from "./mints-queries";
+
+describe("MINTs queries", () => {
+  describe("selectMintsToCollectWithFromQueryResult", () => {
+    it("should return the optimum tokenIds and quantities to collect", async () => {
+      // account has 3 of token 1, 4 of token 2, 10 of token 3
+      // token 1 price is 2, token 2 price is 1, token 3 price is 3
+      // we want to collect 10 tokens
+      // we should return token 2 with 4 tokens, token 1 with 3 tokens, and token 3 with 3 tokens
+      const mintTokenBalances: MintAccountBalance[] = [
+        {
+          mintToken: {
+            id: "1",
+            pricePerToken: "2",
+          },
+          balance: "3",
+        },
+        {
+          mintToken: {
+            id: "2",
+            pricePerToken: "1",
+          },
+          balance: "4",
+        },
+        {
+          mintToken: {
+            id: "3",
+            pricePerToken: "3",
+          },
+          balance: "10",
+        },
+      ];
+
+      const result = selectMintsToCollectWithFromQueryResult(
+        mintTokenBalances,
+        10n,
+      );
+
+      const expectedResult = {
+        tokenIds: [2n, 1n, 3n],
+        quantities: [4n, 3n, 3n],
+      };
+
+      expect(result).toEqual(expectedResult);
+    });
+
+    it("should throw an error if not enough tokens to collect with", () => {
+      const mintTokenBalances: MintAccountBalance[] = [
+        {
+          mintToken: {
+            id: "1",
+            pricePerToken: "2",
+          },
+          balance: "3",
+        },
+        {
+          mintToken: {
+            id: "2",
+            pricePerToken: "1",
+          },
+          balance: "4",
+        },
+      ];
+      const quantityToCollect = 8n;
+
+      expect(() => {
+        selectMintsToCollectWithFromQueryResult(
+          mintTokenBalances,
+          quantityToCollect,
+        );
+      }).toThrowError("Not enough MINTs to collect with");
+    });
+  });
+
+  describe("sumBalances", () => {
+    it("should return the sum of the balances", async () => {
+      // account has 3 of token 1, 4 of token 2, 10 of token 3
+      // token 1 price is 2, token 2 price is 1, token 3 price is 3
+      // we want to collect 10 tokens
+      // we should return token 2 with 4 tokens, token 1 with 3 tokens, and token 3 with 3 tokens
+      const mintTokenBalances: Pick<MintAccountBalance, "balance">[] = [
+        {
+          balance: "3",
+        },
+        {
+          balance: "4",
+        },
+        {
+          balance: "10",
+        },
+      ];
+
+      const result = sumBalances(mintTokenBalances);
+
+      const expectedResult = 3n + 4n + 10n;
+
+      expect(result).toEqual(expectedResult);
+    });
+  });
+});