@fleet-sdk/blockchain-providers 0.6.0 → 0.6.2

package/src/ergo-graphql/ergoGraphQLProvider.ts

@@ -12,18 +12,20 @@ import type {
 import {
   type Base58String,
   type BlockHeader,
-  ensureDefaults,
   type HexString,
+  type SignedTransaction,
+  ensureDefaults,
   isEmpty,
   isUndefined,
   NotSupportedError,
   orderBy,
-  type SignedTransaction,
   some,
   uniq,
-  uniqBy
+  uniqBy,
+  chunk
 } from "@fleet-sdk/common";
 import { ErgoAddress } from "@fleet-sdk/core";
+import { hex } from "@fleet-sdk/crypto";
 import type {
   BoxQuery,
   BoxWhere,
@@ -39,12 +41,11 @@ import type {
   UnconfirmedTransactionWhere
 } from "../types/blockchainProvider";
 import {
-  createGqlOperation,
   type GraphQLOperation,
   type GraphQLRequestOptions,
   type GraphQLSuccessResponse,
   type GraphQLVariables,
-  isRequestParam
+  createGqlOperation
 } from "../utils";
 import {
   ALL_BOXES_QUERY,
@@ -57,14 +58,9 @@ import {
   UNCONF_TX_QUERY
 } from "./queries";
 
-type GraphQLThrowableOptions = GraphQLRequestOptions & { throwOnNonNetworkErrors: true };
-type OP<R, V extends GraphQLVariables> = GraphQLOperation<GraphQLSuccessResponse<R>, V>;
-type BiMapper<T> = (value: string) => T;
+type SkipAndTake = { skip?: number; take?: number };
 
 export type GraphQLBoxWhere = BoxWhere & {
-  /** Base16-encoded BoxIds */
-  boxIds?: HexString[];
-
   /** Base16-encoded ErgoTrees */
   ergoTrees?: HexString[];
 
@@ -73,13 +69,11 @@ export type GraphQLBoxWhere = BoxWhere & {
 };
 
 export type GraphQLConfirmedTransactionWhere = ConfirmedTransactionWhere & {
-  transactionIds?: HexString[];
   addresses?: (Base58String | ErgoAddress)[];
   ergoTrees?: HexString[];
 };
 
 export type GraphQLUnconfirmedTransactionWhere = UnconfirmedTransactionWhere & {
-  transactionIds?: HexString[];
   addresses?: (Base58String | ErgoAddress)[];
   ergoTrees?: HexString[];
 };
@@ -87,7 +81,7 @@ export type GraphQLUnconfirmedTransactionWhere = UnconfirmedTransactionWhere & {
 export type GraphQLBoxQuery = BoxQuery<GraphQLBoxWhere>;
 export type ErgoGraphQLRequestOptions = Omit<
   GraphQLRequestOptions,
-  "throwOnNonNetworkError"
+  "throwOnNonNetworkErrors"
 >;
 
 type ConfirmedBoxesResponse = { boxes: GQLBox[] };
@@ -100,7 +94,15 @@ type CheckTransactionResponse = { checkTransaction: string };
 type TransactionSubmissionResponse = { submitTransaction: string };
 type SignedTxArgsResp = { signedTransaction: SignedTransaction };
 
+type GraphQLThrowableOptions = ErgoGraphQLRequestOptions & {
+  throwOnNonNetworkErrors: true;
+};
+
+type OP<R, V extends GraphQLVariables> = GraphQLOperation<GraphQLSuccessResponse<R>, V>;
+type BiMapper<T> = (value: string) => T;
+
 const PAGE_SIZE = 50;
+const MAX_ARGS = 20;
 
 export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   #options: GraphQLThrowableOptions;
@@ -116,15 +118,14 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   #getHeaders!: OP<BlockHeadersResponse, QueryBlockHeadersArgs>;
 
   constructor(url: string);
-  constructor(url: ErgoGraphQLRequestOptions);
+  constructor(options: ErgoGraphQLRequestOptions);
   constructor(optOrUrl: ErgoGraphQLRequestOptions | string) {
+    this.#biMapper = (value) => BigInt(value) as I;
     this.#options = {
       ...(isRequestParam(optOrUrl) ? optOrUrl : { url: optOrUrl }),
       throwOnNonNetworkErrors: true
     };
 
-    this.#biMapper = (value) => BigInt(value) as I;
-
     this.#getConfirmedBoxes = this.createOperation(CONF_BOXES_QUERY);
     this.#getUnconfirmedBoxes = this.createOperation(UNCONF_BOXES_QUERY);
     this.#getAllBoxes = this.createOperation(ALL_BOXES_QUERY);
@@ -137,10 +138,10 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
 
   #fetchBoxes(args: QueryBoxesArgs, inclConf: boolean, inclUnconf: boolean) {
     return inclConf && inclUnconf
-      ? this.#getAllBoxes(args, this.#options.url)
+      ? this.#getAllBoxes(args)
       : inclUnconf
-        ? this.#getUnconfirmedBoxes(args, this.#options.url)
-        : this.#getConfirmedBoxes(args, this.#options.url);
+        ? this.#getUnconfirmedBoxes(args)
+        : this.#getConfirmedBoxes(args);
   }
 
   setUrl(url: string): ErgoGraphQLProvider<I> {
@@ -153,63 +154,68 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
     return this as unknown as ErgoGraphQLProvider<M>;
   }
 
-  async *streamBoxes(query: GraphQLBoxQuery): AsyncGenerator<ChainProviderBox<I>[]> {
+  async *streamBoxes(
+    query: GraphQLBoxQuery & SkipAndTake
+  ): AsyncGenerator<ChainProviderBox<I>[]> {
     if (isEmpty(query.where)) {
       throw new Error("Cannot fetch unspent boxes without a where clause.");
     }
 
     const notBeingSpent = (box: GQLBox) => !box.beingSpent;
     const returnedBoxIds = new Set<string>();
-    const { where, from } = query;
-    const args = buildGqlBoxQueryArgs(where);
+    const { from, take } = query;
+    const pageSize = take ?? PAGE_SIZE;
+    const queries = buildGqlBoxQueries(query);
+    const isMempoolAware = from !== "blockchain";
 
-    let inclChain = from !== "mempool";
-    let inclPool = from !== "blockchain";
-    const isMempoolAware = inclPool;
+    for (const query of queries) {
+      let inclChain = from !== "mempool";
+      let inclPool = from !== "blockchain";
 
-    do {
-      const { data } = await this.#fetchBoxes(args, inclChain, inclPool);
-      let boxes: ChainProviderBox<I>[] = [];
+      while (inclChain || inclPool) {
+        const { data } = await this.#fetchBoxes(query, inclChain, inclPool);
+        let boxes: ChainProviderBox<I>[] = [];
 
-      if (inclChain && hasConfirmed(data)) {
-        if (some(data.boxes)) {
-          const confirmedBoxes = (
-            isMempoolAware ? data.boxes.filter(notBeingSpent) : data.boxes
-          ).map((b) => mapConfirmedBox(b, this.#biMapper));
+        if (inclChain && hasConfirmed(data)) {
+          if (some(data.boxes)) {
+            const confirmedBoxes = (
+              isMempoolAware ? data.boxes.filter(notBeingSpent) : data.boxes
+            ).map((b) => mapConfirmedBox(b, this.#biMapper));
 
-          boxes = boxes.concat(confirmedBoxes);
-        }
-
-        inclChain = data.boxes.length === PAGE_SIZE;
-      }
+            boxes = boxes.concat(confirmedBoxes);
+          }
 
-      if (isMempoolAware && hasMempool(data)) {
-        if (some(data.mempool.boxes)) {
-          const mempoolBoxes = data.mempool.boxes
-            .filter(notBeingSpent)
-            .map((b) => mapUnconfirmedBox(b, this.#biMapper));
-          boxes = boxes.concat(mempoolBoxes);
+          inclChain = data.boxes.length === pageSize;
         }
 
-        inclPool = data.mempool.boxes.length === PAGE_SIZE;
-      }
+        if (isMempoolAware && hasMempool(data)) {
+          if (some(data.mempool.boxes)) {
+            const mempoolBoxes = data.mempool.boxes
+              .filter(notBeingSpent)
+              .map((b) => mapUnconfirmedBox(b, this.#biMapper));
+            boxes = boxes.concat(mempoolBoxes);
+          }
 
-      if (some(boxes)) {
-        // boxes can be moved from the mempool to the blockchain while streaming,
-        // so we need to filter out boxes that have already been returned.
-        if (boxes.some((box) => returnedBoxIds.has(box.boxId))) {
-          boxes = boxes.filter((b) => !returnedBoxIds.has(b.boxId));
+          inclPool = data.mempool.boxes.length === pageSize;
         }
 
         if (some(boxes)) {
-          boxes = uniqBy(boxes, (box) => box.boxId);
-          for (const box of boxes) returnedBoxIds.add(box.boxId);
-          yield boxes;
+          // boxes can be moved from the mempool to the blockchain while streaming,
+          // so we need to filter out boxes that have already been returned.
+          if (boxes.some((box) => returnedBoxIds.has(box.boxId))) {
+            boxes = boxes.filter((b) => !returnedBoxIds.has(b.boxId));
+          }
+
+          if (some(boxes)) {
+            boxes = uniqBy(boxes, (box) => box.boxId);
+            for (const box of boxes) returnedBoxIds.add(box.boxId);
+            yield boxes;
+          }
         }
-      }
 
-      if (inclChain || inclPool) args.skip += PAGE_SIZE;
-    } while (inclChain || inclPool);
+        if (inclChain || inclPool) query.skip += pageSize;
+      }
+    }
   }
 
   async getBoxes(query: GraphQLBoxQuery): Promise<ChainProviderBox<I>[]> {
@@ -219,21 +225,24 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   }
 
   async *streamUnconfirmedTransactions(
-    query: TransactionQuery<GraphQLUnconfirmedTransactionWhere>
+    query: TransactionQuery<GraphQLUnconfirmedTransactionWhere> & SkipAndTake
   ): AsyncIterable<ChainProviderUnconfirmedTransaction<I>[]> {
-    const args = buildGqlUnconfirmedTxQueryArgs(query.where);
-
-    let keepFetching = true;
-    while (keepFetching) {
-      const response = await this.#getUnconfirmedTransactions(args);
-      if (some(response.data?.mempool?.transactions)) {
-        yield response.data.mempool.transactions.map((t) =>
-          mapUnconfirmedTransaction(t, this.#biMapper)
-        );
-      }
+    const pageSize = query.take ?? PAGE_SIZE;
+    const queries = buildGqlUnconfirmedTxQueries(query);
+
+    for (const query of queries) {
+      let keepFetching = true;
+      while (keepFetching) {
+        const response = await this.#getUnconfirmedTransactions(query);
+        if (some(response.data?.mempool?.transactions)) {
+          yield response.data.mempool.transactions.map((t) =>
+            mapUnconfirmedTransaction(t, this.#biMapper)
+          );
+        }
 
-      keepFetching = response.data?.mempool?.transactions?.length === PAGE_SIZE;
-      if (keepFetching) args.skip += PAGE_SIZE;
+        keepFetching = response.data?.mempool?.transactions?.length === pageSize;
+        if (keepFetching) query.skip += pageSize;
+      }
     }
   }
 
@@ -249,21 +258,24 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   }
 
   async *streamConfirmedTransactions(
-    query: TransactionQuery<GraphQLConfirmedTransactionWhere>
+    query: TransactionQuery<GraphQLConfirmedTransactionWhere> & SkipAndTake
   ): AsyncIterable<ChainProviderConfirmedTransaction<I>[]> {
-    const args = buildGqlConfirmedTxQueryArgs(query.where);
-
-    let keepFetching = true;
-    while (keepFetching) {
-      const response = await this.#getConfirmedTransactions(args);
-      if (some(response.data?.transactions)) {
-        yield response.data.transactions.map((t) =>
-          mapConfirmedTransaction(t, this.#biMapper)
-        );
-      }
+    const pageSize = query.take ?? PAGE_SIZE;
+    const queries = buildGqlConfirmedTxQueries(query);
+
+    for (const query of queries) {
+      let keepFetching = true;
+      while (keepFetching) {
+        const response = await this.#getConfirmedTransactions(query);
+        if (some(response.data?.transactions)) {
+          yield response.data.transactions.map((t) =>
+            mapConfirmedTransaction(t, this.#biMapper)
+          );
+        }
 
-      keepFetching = response.data?.transactions?.length === PAGE_SIZE;
-      if (keepFetching) args.skip += PAGE_SIZE;
+        keepFetching = response.data?.transactions?.length === pageSize;
+        if (keepFetching) query.skip += pageSize;
+      }
     }
   }
 
@@ -279,15 +291,15 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   }
 
   async getHeaders(query: HeaderQuery): Promise<BlockHeader[]> {
-    const response = await this.#getHeaders(query, this.#options.url);
+    const response = await this.#getHeaders(query);
 
     return (
-      response.data?.blockHeaders.map((header) => ({
-        ...header,
-        id: header.headerId,
-        timestamp: Number(header.timestamp),
-        nBits: Number(header.nBits),
-        votes: header.votes.join("")
+      response.data?.blockHeaders.map((h) => ({
+        ...h,
+        id: h.headerId,
+        timestamp: Number(h.timestamp),
+        nBits: Number(h.nBits),
+        votes: hex.encode(Uint8Array.from(h.votes))
       })) ?? []
     );
   }
@@ -306,10 +318,7 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
     signedTransaction: SignedTransaction
   ): Promise<TransactionEvaluationResult> {
     try {
-      const response = await this.#checkTransaction(
-        { signedTransaction },
-        this.#options.url
-      );
+      const response = await this.#checkTransaction({ signedTransaction });
       return { success: true, transactionId: response.data.checkTransaction };
     } catch (e) {
       return { success: false, message: (e as Error).message };
@@ -320,10 +329,7 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
     signedTransaction: SignedTransaction
   ): Promise<TransactionEvaluationResult> {
     try {
-      const response = await this.#sendTransaction(
-        { signedTransaction },
-        this.#options.url
-      );
+      const response = await this.#sendTransaction({ signedTransaction });
       return { success: true, transactionId: response.data.submitTransaction };
     } catch (e) {
       return { success: false, message: (e as Error).message };
@@ -335,58 +341,60 @@ export class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
   }
 }
 
-function buildGqlBoxQueryArgs(where: GraphQLBoxWhere) {
-  const args = {
-    spent: false,
-    boxIds: merge(where.boxIds, where.boxId),
-    ergoTrees: merge(where.ergoTrees, where.ergoTree),
-    ergoTreeTemplateHash: where.templateHash,
-    tokenId: where.tokenId,
-    skip: 0,
-    take: PAGE_SIZE
-  } satisfies QueryBoxesArgs;
-
-  const addresses = merge(where.addresses, where.address);
-  if (some(addresses)) {
-    const trees = addresses.map((address) =>
-      typeof address === "string"
-        ? ErgoAddress.decode(address).ergoTree
-        : address.ergoTree
-    );
-
-    args.ergoTrees = uniq(some(args.ergoTrees) ? args.ergoTrees.concat(trees) : trees);
-  }
+function buildGqlBoxQueries(query: GraphQLBoxQuery & SkipAndTake) {
+  const ergoTrees = uniq(
+    [
+      merge(query.where.ergoTrees, query.where.ergoTree) ?? [],
+      merge(query.where.addresses, query.where.address)?.map((a) =>
+        typeof a === "string" ? ErgoAddress.decode(a).ergoTree : a.ergoTree
+      ) ?? []
+    ].flat()
+  );
 
-  return args;
+  return chunk(ergoTrees, MAX_ARGS).map((chunk) => ({
+    spent: false,
+    boxIds: query.where.boxId ? [query.where.boxId] : undefined,
+    ergoTrees: chunk,
+    ergoTreeTemplateHash: query.where.templateHash,
+    tokenId: query.where.tokenId,
+    skip: query.skip ?? 0,
+    take: query.take ?? PAGE_SIZE
+  }));
 }
 
-function buildGqlUnconfirmedTxQueryArgs(where: GraphQLConfirmedTransactionWhere) {
+function buildGqlUnconfirmedTxQueries(
+  query: TransactionQuery<GraphQLUnconfirmedTransactionWhere> & SkipAndTake
+) {
   const addresses = uniq(
     [
-      merge(where.addresses, where.address)?.map((address): string =>
+      merge(query.where.addresses, query.where.address)?.map((address): string =>
         typeof address === "string" ? address : address.encode()
       ) ?? [],
-      merge(where.ergoTrees, where.ergoTree)?.map((tree) =>
+      merge(query.where.ergoTrees, query.where.ergoTree)?.map((tree) =>
         ErgoAddress.fromErgoTree(tree).encode()
       ) ?? []
     ].flat()
   );
 
-  return {
-    addresses: addresses.length ? addresses : undefined,
-    transactionIds: merge(where.transactionIds, where.transactionId),
-    skip: 0,
-    take: PAGE_SIZE
-  };
+  return chunk(addresses, MAX_ARGS).map((chunk) => ({
+    addresses: chunk.length ? chunk : undefined,
+    transactionIds: query.where.transactionId ? [query.where.transactionId] : undefined,
+    skip: query.skip ?? 0,
+    take: query.take ?? PAGE_SIZE
+  }));
 }
 
-function buildGqlConfirmedTxQueryArgs(where: GraphQLConfirmedTransactionWhere) {
-  return {
-    ...buildGqlUnconfirmedTxQueryArgs(where),
-    headerId: where.headerId,
-    minHeight: where.minHeight,
-    onlyRelevantOutputs: where.onlyRelevantOutputs
-  };
+function buildGqlConfirmedTxQueries(
+  query: TransactionQuery<GraphQLConfirmedTransactionWhere> & SkipAndTake
+) {
+  return buildGqlUnconfirmedTxQueries(
+    query as TransactionQuery<GraphQLUnconfirmedTransactionWhere>
+  ).map((q) => ({
+    ...q,
+    headerId: query.where.headerId,
+    minHeight: query.where.minHeight,
+    onlyRelevantOutputs: query.where.onlyRelevantOutputs
+  }));
 }
 
 function merge<T>(array?: T[], el?: T) {
@@ -481,3 +489,7 @@ function mapConfirmedTransaction<T>(
     confirmed: true
   };
 }
+
+export function isRequestParam(obj: unknown): obj is ErgoGraphQLRequestOptions {
+  return typeof obj === "object" && (obj as ErgoGraphQLRequestOptions).url !== undefined;
+}

package/src/index.ts

@@ -1 +1,4 @@
 export * from "./ergo-graphql/ergoGraphQLProvider";
+export * from "./types/blockchainProvider";
+export * from "./utils/networking";
+export * from "./utils/graphql";

package/src/utils/graphql.ts

@@ -9,7 +9,7 @@ import type { FallbackRetryOptions, ParserLike } from "./networking";
 import { request } from "./networking";
 
 const OP_NAME_REGEX = /(query|mutation)\s?([\w\-_]+)?/;
-export const DEFAULT_HEADERS = {
+const DEFAULT_HEADERS = {
   "content-type": "application/json; charset=utf-8",
   accept: "application/graphql-response+json, application/json"
 };
@@ -118,7 +118,3 @@ export function gql(query: TemplateStringsArray): string {
 export function getOpName(query: string): string | undefined {
   return OP_NAME_REGEX.exec(query)?.at(2);
 }
-
-export function isRequestParam(obj: unknown): obj is GraphQLRequestOptions {
-  return typeof obj === "object" && (obj as GraphQLRequestOptions).url !== undefined;
-}

package/src/utils/networking.ts

@@ -1,5 +1,4 @@
 import { some } from "@fleet-sdk/common";
-import { isEmpty } from "packages/common/src";
 
 export interface ParserLike {
   parse<T>(text: string): T;