@zoralabs/protocol-sdk 0.5.6 → 0.5.7-MINT.2

package/src/apis/chain-constants.ts

@@ -98,3 +98,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,5 @@ export * from "./mint/mint-api-client";
 export * from "./mint/mint-client";
 
 export * from "./create/1155-create-helper";
+
+export * from "./mints/mints-queries";

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);
+    });
+  });
+});

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);
+};