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

package/dist/mints/mints-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mints-contracts.d.ts","sourceRoot":"","sources":["../../src/mints/mints-contracts.ts"],"names":[],"mappings":"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"}

package/dist/mints/mints-queries.d.ts

@@ -0,0 +1,59 @@
+import { Address } from "viem";
+type CollectQueryResult = {
+    tokenIds: bigint[];
+    quantities: bigint[];
+};
+export declare const getMintsAccountBalanceWithPriceQuery: (account: Address) => {
+    query: string;
+    variables: {
+        account: `0x${string}`;
+    };
+};
+export type MintAccountBalance = {
+    balance: string;
+    mintToken: {
+        id: string;
+        pricePerToken: string;
+    };
+};
+export type MintAccountBalancesQueryResult = {
+    mintTokenBalances: MintAccountBalance[];
+};
+/**
+ * Given the result of a mint token balances query, selects the best MINTs to use to collect with that will satisfy the quantity,
+ * by selecting the lowest priced MINTs first. Throws an error if not enough mints to collect with.
+ */
+export declare const selectMintsToCollectWithFromQueryResult: (mintAccountBalances: MintAccountBalance[], quantityToCollect: bigint) => {
+    tokenIds: bigint[];
+    quantities: bigint[];
+};
+/**
+ * Given an array of mint account balances, sums the balances.
+ * @param mintAccountBalances
+ * @returns Total balance
+ */
+export declare const sumBalances: (mintAccountBalances: Pick<MintAccountBalance, "balance">[]) => bigint;
+/***
+ * Given an account and quantity of MINTs to use to collect with, queries for MINTs
+ * owned by an account, and selects the best MINTs to use to collect with that will satisfy that quantity.
+ * @param account Account to query for MINTs
+ * @param chainId
+ * @param quantityToCollect How many MINTs to use to collect with
+ * @returns
+ */
+export declare const getMINTsToCollectWith: ({ account, chainId, quantityToCollect, }: {
+    account: Address;
+    chainId: number;
+    quantityToCollect: bigint;
+}) => Promise<CollectQueryResult>;
+/***
+ * Given an account, queries for MINTs owned by an account, and sums the balances.
+ * @param account Account to query for MINTs
+ * @returns Total MINTs balance of account
+ */
+export declare const getMINTsBalance: ({ chainId, account, }: {
+    account: Address;
+    chainId: number;
+}) => Promise<bigint>;
+export {};
+//# sourceMappingURL=mints-queries.d.ts.map

package/dist/mints/mints-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mints-queries.d.ts","sourceRoot":"","sources":["../../src/mints/mints-queries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,oCAAoC,YAAa,OAAO;;;;;CAiBpE,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,iBAAiB,EAAE,kBAAkB,EAAE,CAAC;CACzC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uCAAuC,wBAC7B,kBAAkB,EAAE,qBACtB,MAAM;;;CAyC1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,WAAW,wBACD,KAAK,kBAAkB,EAAE,SAAS,CAAC,EAAE,WAK3D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB;aAKvB,OAAO;aACP,MAAM;uBACI,MAAM;MACvB,QAAQ,kBAAkB,CAe7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe;aAIjB,OAAO;aACP,MAAM;qBAahB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoralabs/protocol-sdk",
-  "version": "0.5.7",
+  "version": "0.5.8-DEV.2",
   "repository": "https://github.com/ourzora/zora-protocol",
   "license": "MIT",
   "type": "module",
@@ -25,18 +25,19 @@
     "lint": "prettier --check 'src/**/*.ts' 'test-integration/**/*.ts'"
   },
   "dependencies": {
-    "@zoralabs/protocol-deployments": "*",
-    "abitype": "^0.10.3",
-    "vite": "4.5.0"
+    "@zoralabs/protocol-deployments": "0.1.5-DEV.4",
+    "abitype": "^0.10.3"
   },
   "peerDependencies": {
-    "viem": "^1.19.15"
+    "viem": "^1.19.15",
+    "graphql-request": "^6.1.0"
   },
   "devDependencies": {
     "@lavamoat/preinstall-always-fail": "2.0.0",
-    "zoralabs-tsconfig": "*",
+    "graphql-prettier": "^1.0.6",
     "typescript": "^5.2.2",
     "vite": "^4.5.0",
-    "vitest": "^0.34.6"
+    "vitest": "^0.34.6",
+    "zoralabs-tsconfig": "*"
   }
 }

package/src/apis/chain-constants.ts

@@ -82,3 +82,13 @@ 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/index.ts

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

package/src/mints/mints-contracts.ts

@@ -0,0 +1,408 @@
+import {
+  zoraMints1155Config,
+  zoraMintsManagerImplConfig,
+} from "@zoralabs/protocol-deployments";
+import { AbiParametersToPrimitiveTypes, ExtractAbiFunction } from "abitype";
+import { MintArguments, PremintConfigV2 } from "src/premint/contract-types";
+import { ContractCreationConfig } from "src/preminter";
+import {
+  Account,
+  Address,
+  Hex,
+  ReadContractParameters,
+  SignTypedDataParameters,
+  SimulateContractParameters,
+  TypedData,
+  encodeFunctionData,
+  zeroAddress,
+} from "viem";
+
+export function mintWithEthParams({
+  quantity,
+  recipient,
+  chainId,
+  pricePerMint,
+  account,
+}: {
+  quantity: bigint;
+  recipient: Address;
+  chainId: keyof typeof zoraMints1155Config.address;
+  pricePerMint: bigint;
+  account: Address | Account;
+}): SimulateContractParameters<
+  typeof zoraMintsManagerImplConfig.abi,
+  "mintWithEth"
+> {
+  return {
+    abi: zoraMintsManagerImplConfig.abi,
+    address: zoraMintsManagerImplConfig.address[chainId],
+    functionName: "mintWithEth",
+    args: [quantity, recipient],
+    value: pricePerMint * quantity,
+    account,
+  };
+}
+
+const getPaidMintValue = (quantities: bigint[], pricePerMint?: bigint) => {
+  if (!pricePerMint || pricePerMint === 0n) return;
+
+  return quantities.reduce((a, b) => a + b, 0n) * pricePerMint;
+};
+
+export const mintsBalanceOfAccountParams = ({
+  account,
+  chainId,
+}: {
+  account: Address;
+  chainId: keyof typeof zoraMints1155Config.address;
+}): ReadContractParameters<
+  typeof zoraMints1155Config.abi,
+  "balanceOfAccount"
+> => ({
+  abi: zoraMints1155Config.abi,
+  address: zoraMints1155Config.address[chainId],
+  functionName: "balanceOfAccount",
+  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;
+};
+
+export const encodeCollectOnManager = ({
+  tokenIds,
+  quantities,
+  zoraCreator1155Contract,
+  minter,
+  zoraCreator1155TokenId,
+  mintArguments,
+}: CollectOnManagerParams) =>
+  encodeFunctionData({
+    abi: zoraMintsManagerImplConfig.abi,
+    functionName: "collect",
+    args: [
+      tokenIds,
+      quantities,
+      zoraCreator1155Contract,
+      minter,
+      zoraCreator1155TokenId,
+      mintArguments,
+    ],
+  });
+
+export function collectWithMintsParams({
+  tokenIds,
+  quantities,
+  chainId,
+  pricePerToken,
+  account,
+  ...rest
+}: {
+  paidMintValue?: bigint;
+  chainId: keyof typeof zoraMints1155Config.address;
+  pricePerToken?: bigint;
+  account: Address | Account;
+} & CollectOnManagerParams): SimulateContractParameters<
+  typeof zoraMints1155Config.abi,
+  "transferBatchToManagerAndCall"
+> {
+  const call = encodeCollectOnManager({
+    tokenIds,
+    quantities,
+    ...rest,
+  });
+
+  return {
+    abi: zoraMints1155Config.abi,
+    address: zoraMints1155Config.address[chainId],
+    functionName: "transferBatchToManagerAndCall",
+    args: [tokenIds, quantities, "0x", call],
+    value: getPaidMintValue(quantities, pricePerToken),
+    account,
+  };
+}
+
+export const collectWithMintsTypedDataDefinition = ({
+  tokenIds,
+  quantities,
+  chainId,
+  account,
+  nonce,
+  deadline,
+  ...rest
+}: {
+  chainId: keyof typeof zoraMints1155Config.address;
+  nonce: bigint;
+  deadline: bigint;
+  account: Account | Address;
+} & CollectOnManagerParams) => {
+  const call = encodeCollectOnManager({
+    tokenIds,
+    quantities,
+    ...rest,
+  });
+
+  return makePermitAndTypeData({
+    tokenIds,
+    quantities,
+    chainId,
+    account,
+    nonce,
+    deadline,
+    call,
+  });
+};
+
+export const collectPremintWithMintsTypedDataDefinition = ({
+  tokenIds,
+  quantities,
+  chainId,
+  account,
+  nonce,
+  deadline,
+  ...rest
+}: {
+  chainId: keyof typeof zoraMints1155Config.address;
+  nonce: bigint;
+  deadline: bigint;
+  account: Account | Address;
+} & PremintOnManagerParams) => {
+  const call = encodePremintOnManager({
+    tokenIds,
+    quantities,
+    ...rest,
+  });
+
+  return makePermitAndTypeData({
+    tokenIds,
+    quantities,
+    chainId,
+    account,
+    nonce,
+    deadline,
+    call,
+  });
+};
+
+function makePermitAndTypeData({
+  tokenIds,
+  quantities,
+  chainId,
+  account,
+  nonce,
+  deadline,
+  call,
+}: {
+  tokenIds: bigint[];
+  quantities: bigint[];
+  chainId: keyof typeof zoraMints1155Config.address;
+  nonce: bigint;
+  deadline: bigint;
+  account: Account | Address;
+  call: Hex;
+}) {
+  const permit: PermitTransferBatchToManager = {
+    owner: typeof account === "string" ? account : account.address,
+    tokenIds,
+    quantities,
+    call,
+    deadline,
+    safeTransferData: "0x",
+  };
+
+  const typedData = permitTypedDataDefinition({
+    chainId,
+    nonce,
+    permit,
+    account,
+  });
+
+  return {
+    permit,
+    typedData,
+  };
+}
+
+type PremintOnManagerParams = {
+  tokenIds: bigint[];
+  quantities: bigint[];
+  contractCreationConfig: ContractCreationConfig;
+  premintConfig: PremintConfigV2;
+  premintSignature: Hex;
+  mintArguments: MintArguments;
+  signerContract?: Address;
+};
+
+export const encodePremintOnManager = ({
+  tokenIds,
+  quantities,
+  contractCreationConfig,
+  premintConfig,
+  premintSignature,
+  mintArguments,
+  signerContract = zeroAddress,
+}: PremintOnManagerParams) =>
+  encodeFunctionData({
+    abi: zoraMintsManagerImplConfig.abi,
+    functionName: "collectPremintV2",
+    args: [
+      tokenIds,
+      quantities,
+      contractCreationConfig,
+      premintConfig,
+      premintSignature,
+      mintArguments,
+      signerContract,
+    ],
+  });
+
+export function collectPremintV2WithMintsParams({
+  tokenIds,
+  quantities,
+  pricePerToken,
+  account,
+  chainId,
+  ...rest
+}: {
+  pricePerToken?: bigint;
+  chainId: keyof typeof zoraMints1155Config.address;
+  account: Address | Account;
+} & PremintOnManagerParams): SimulateContractParameters<
+  typeof zoraMints1155Config.abi,
+  "transferBatchToManagerAndCall"
+> {
+  const call = encodePremintOnManager({
+    tokenIds,
+    quantities,
+    ...rest,
+  });
+
+  return {
+    abi: zoraMints1155Config.abi,
+    address: zoraMints1155Config.address[chainId],
+    functionName: "transferBatchToManagerAndCall",
+    args: [tokenIds, quantities, "0x", call],
+    value: getPaidMintValue(quantities, pricePerToken),
+    account,
+  };
+}
+
+export type PermitTransferBatchToManager = AbiParametersToPrimitiveTypes<
+  ExtractAbiFunction<
+    typeof zoraMints1155Config.abi,
+    "permitTransferBatchToManagerAndCall"
+  >["inputs"]
+>[0];
+// export type PermitTransferBatchToManager = ExtractAbiFunction<
+
+function makeTypeData<
+  const TTypedData extends TypedData | { [key: string]: unknown },
+  TPrimaryType extends string,
+>(args: SignTypedDataParameters<TTypedData, TPrimaryType>) {
+  return args;
+}
+
+export function permitTypedDataDefinition({
+  permit,
+  chainId,
+  nonce,
+  account,
+}: {
+  permit: PermitTransferBatchToManager;
+  chainId: keyof typeof zoraMints1155Config.address;
+  nonce: bigint;
+  account: Account | Address;
+}) {
+  return makeTypeData({
+    primaryType: "Permit",
+    types: {
+      Permit: [
+        {
+          name: "owner",
+          type: "address",
+        },
+        {
+          name: "tokenIds",
+          type: "uint256[]",
+        },
+        {
+          name: "quantities",
+          type: "uint256[]",
+        },
+        {
+          name: "safeTransferData",
+          type: "bytes",
+        },
+        {
+          name: "call",
+          type: "bytes",
+        },
+        {
+          name: "nonce",
+          type: "uint256",
+        },
+        {
+          name: "deadline",
+          type: "uint256",
+        },
+      ],
+    },
+    message: {
+      owner: permit.owner,
+      tokenIds: permit.tokenIds,
+      quantities: permit.quantities,
+      safeTransferData: permit.safeTransferData,
+      call: permit.call,
+      nonce,
+      deadline: permit.deadline,
+    },
+    domain: {
+      chainId,
+      name: "Mints",
+      version: "1",
+      verifyingContract: zoraMints1155Config.address[chainId],
+    },
+    // signing account must be permit owner
+    account,
+  });
+}
+
+export const permitTransferBatchToManagerAndCallParams = ({
+  permit,
+  chainId,
+  signature,
+}: {
+  permit: PermitTransferBatchToManager;
+  chainId: keyof typeof zoraMints1155Config.address;
+  signature: Hex;
+}) => {
+  const result: SimulateContractParameters<
+    typeof zoraMints1155Config.abi,
+    "permitTransferBatchToManagerAndCall"
+  > = {
+    abi: zoraMints1155Config.abi,
+    address: zoraMints1155Config.address[chainId],
+    functionName: "permitTransferBatchToManagerAndCall",
+    args: [permit, signature],
+  };
+
+  return result;
+};

package/src/mints/mints-queries.ts

@@ -0,0 +1,159 @@
+import { getSubgraphUrl } from "src/apis/chain-constants";
+import { Address } from "viem";
+import { request, gql } from "graphql-request";
+
+type CollectQueryResult = {
+  tokenIds: bigint[];
+  quantities: bigint[];
+};
+
+export const getMintsAccountBalanceWithPriceQuery = (account: Address) => {
+  const query = gql`
+    query GetMintAccountBalances($account: String!) {
+      mintAccountBalances(where: { account: $account }) {
+        balance
+        mintToken {
+          id
+          pricePerToken
+        }
+      }
+    }
+  `;
+
+  return {
+    query,
+    variables: { account },
+  };
+};
+
+export type MintAccountBalance = {
+  balance: string;
+  mintToken: {
+    id: string;
+    pricePerToken: string;
+  };
+};
+
+export type MintAccountBalancesQueryResult = {
+  mintTokenBalances: MintAccountBalance[];
+};
+
+/**
+ * Given the result of a mint token balances query, selects the best MINTs to use to collect with that will satisfy the quantity,
+ * by selecting the lowest priced MINTs first. Throws an error if not enough mints to collect with.
+ */
+export const selectMintsToCollectWithFromQueryResult = (
+  mintAccountBalances: MintAccountBalance[],
+  quantityToCollect: bigint,
+) => {
+  const parsed = mintAccountBalances.map((r) => {
+    return {
+      tokenId: BigInt(r.mintToken.id),
+      quantity: BigInt(r.balance),
+      pricePerToken: BigInt(r.mintToken.pricePerToken),
+    };
+  });
+
+  // now we want to find the best tokens to collect with, sorted by lowest price ascending
+  // given its a bigint, lets not do a straight subtraction but sort based on result of comparison gt/lt:
+  const sorted = parsed.sort((a, b) => {
+    if (a.pricePerToken < b.pricePerToken) {
+      return -1;
+    }
+    return 1;
+  });
+
+  // we need to get array of tokenIds and quantities to collect with:
+  let remainingQuantity = quantityToCollect;
+  const tokenIds: bigint[] = [];
+  const quantities: bigint[] = [];
+
+  while (remainingQuantity > 0) {
+    const next = sorted.shift();
+    if (!next) {
+      throw new Error("Not enough MINTs to collect with");
+    }
+
+    const quantityToUse =
+      remainingQuantity > next.quantity ? next.quantity : remainingQuantity;
+    tokenIds.push(next.tokenId);
+    quantities.push(quantityToUse);
+    remainingQuantity -= quantityToUse;
+  }
+
+  return {
+    tokenIds,
+    quantities,
+  };
+};
+
+/**
+ * Given an array of mint account balances, sums the balances.
+ * @param mintAccountBalances
+ * @returns Total balance
+ */
+export const sumBalances = (
+  mintAccountBalances: Pick<MintAccountBalance, "balance">[],
+) => {
+  return mintAccountBalances.reduce((acc, curr) => {
+    return acc + BigInt(curr.balance);
+  }, BigInt(0));
+};
+
+/***
+ * Given an account and quantity of MINTs to use to collect with, queries for MINTs
+ * owned by an account, and selects the best MINTs to use to collect with that will satisfy that quantity.
+ * @param account Account to query for MINTs
+ * @param chainId
+ * @param quantityToCollect How many MINTs to use to collect with
+ * @returns
+ */
+export const getMINTsToCollectWith = async ({
+  account,
+  chainId,
+  quantityToCollect,
+}: {
+  account: Address;
+  chainId: number;
+  quantityToCollect: bigint;
+}): Promise<CollectQueryResult> => {
+  const subgraphUrl = getSubgraphUrl(chainId);
+
+  const { query, variables } = getMintsAccountBalanceWithPriceQuery(account);
+
+  const result = await request<MintAccountBalancesQueryResult>(
+    subgraphUrl,
+    query,
+    variables,
+  );
+
+  return selectMintsToCollectWithFromQueryResult(
+    result.mintTokenBalances,
+    quantityToCollect,
+  );
+};
+
+/***
+ * Given an account, queries for MINTs owned by an account, and sums the balances.
+ * @param account Account to query for MINTs
+ * @returns Total MINTs balance of account
+ */
+export const getMINTsBalance = async ({
+  chainId,
+  account,
+}: {
+  account: Address;
+  chainId: number;
+}) => {
+  const subgraphUrl = getSubgraphUrl(chainId);
+
+  const { query, variables } = getMintsAccountBalanceWithPriceQuery(account);
+
+  const result = await request<MintAccountBalancesQueryResult>(
+    subgraphUrl,
+    query,
+    variables,
+  );
+
+  return sumBalances(result.mintTokenBalances);
+};