@fleet-sdk/blockchain-providers 0.6.0 → 0.6.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @fleet-sdk/blockchain-providers
 
+## 0.6.2
+
+### Patch Changes
+
+- 401268b: Support `take` and `skip` params in `ErgoGraphQLProvider#stream*()` methods
+
+## 0.6.1
+
+### Patch Changes
+
+- 208ac8e: Fix `Header#votes` encoding
+- a3d2a62: Export `BlockChainProviders` types
+- 506dfc4: [`ErgoGraphQLProvider`] Query Addresses/ErgoTrees by chunks of 20
+- 6245bc9: Export `request` and `createGqlOperation` utility functions
+- Updated dependencies [ece573c]
+  - @fleet-sdk/core@0.6.1
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -302,10 +302,27 @@ type URLLike = string | Route;
 type FallbackRetryOptions = {
     fallbacks?: URLLike[];
 } & RetryOptions;
+type FetchOptions = {
+    parser?: ParserLike;
+    base?: string;
+    query?: Record<string, unknown>;
+    retry?: FallbackRetryOptions;
+    httpOptions?: RequestInit;
+};
+declare function request<T>(path: string, opt?: Partial<FetchOptions>): Promise<T>;
 type RetryOptions = {
     attempts: number;
     delay: number;
 };
+/**
+ * Retries an asynchronous operation a specified number of times with a delay
+ * growing exponentially between each attempt.
+ * @param operation - The asynchronous operation to retry.
+ * @param options - The retry options.
+ * @returns A promise that resolves to the result of the operation, or undefined
+ * if all attempts fail.
+ */
+declare function exponentialRetry<T>(operation: (remainingAttempts: number) => Promise<T>, { attempts, delay }: RetryOptions): Promise<T>;
 
 type GraphQLVariables = Record<string, unknown> | null;
 interface GraphQLError {
@@ -321,6 +338,7 @@ interface GraphQLErrorResponse {
 }
 type GraphQLResponse<T = unknown> = GraphQLSuccessResponse<T> | GraphQLErrorResponse;
 type GraphQLOperation<R extends GraphQLResponse, V extends GraphQLVariables> = (variables?: V, url?: string) => Promise<R>;
+type GraphQLRequiredUrlOperation<R extends GraphQLResponse, V extends GraphQLVariables> = (variables: V | undefined, url: string) => Promise<R>;
 interface GraphQLRequestOptions {
     url?: string;
     parser?: ParserLike;
@@ -328,39 +346,52 @@ interface GraphQLRequestOptions {
     throwOnNonNetworkErrors?: boolean;
     httpOptions?: Omit<RequestInit, "body" | "method">;
 }
-
-type BiMapper<T> = (value: string) => T;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions & {
+    throwOnNonNetworkErrors: true;
+}): GraphQLOperation<GraphQLSuccessResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options?: GraphQLRequestOptions & {
+    url: undefined;
+}): GraphQLRequiredUrlOperation<GraphQLResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions & {
+    url: undefined;
+    throwOnNonNetworkErrors: true;
+}): GraphQLRequiredUrlOperation<GraphQLSuccessResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions): GraphQLOperation<GraphQLResponse<R>, V>;
+declare function gql(query: TemplateStringsArray): string;
+declare function getOpName(query: string): string | undefined;
+
+type SkipAndTake = {
+    skip?: number;
+    take?: number;
+};
 type GraphQLBoxWhere = BoxWhere & {
-    /** Base16-encoded BoxIds */
-    boxIds?: HexString[];
     /** Base16-encoded ErgoTrees */
     ergoTrees?: HexString[];
     /** Base58-encoded addresses or `ErgoAddress` objects */
     addresses?: (Base58String | ErgoAddress)[];
 };
 type GraphQLConfirmedTransactionWhere = ConfirmedTransactionWhere & {
-    transactionIds?: HexString[];
     addresses?: (Base58String | ErgoAddress)[];
     ergoTrees?: HexString[];
 };
 type GraphQLUnconfirmedTransactionWhere = UnconfirmedTransactionWhere & {
-    transactionIds?: HexString[];
     addresses?: (Base58String | ErgoAddress)[];
     ergoTrees?: HexString[];
 };
 type GraphQLBoxQuery = BoxQuery<GraphQLBoxWhere>;
-type ErgoGraphQLRequestOptions = Omit<GraphQLRequestOptions, "throwOnNonNetworkError">;
+type ErgoGraphQLRequestOptions = Omit<GraphQLRequestOptions, "throwOnNonNetworkErrors">;
+type BiMapper<T> = (value: string) => T;
 declare class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
     #private;
     constructor(url: string);
-    constructor(url: ErgoGraphQLRequestOptions);
+    constructor(options: ErgoGraphQLRequestOptions);
     setUrl(url: string): ErgoGraphQLProvider<I>;
     setBigIntMapper<M>(mapper: BiMapper<M>): ErgoGraphQLProvider<M>;
-    streamBoxes(query: GraphQLBoxQuery): AsyncGenerator<ChainProviderBox<I>[]>;
+    streamBoxes(query: GraphQLBoxQuery & SkipAndTake): AsyncGenerator<ChainProviderBox<I>[]>;
     getBoxes(query: GraphQLBoxQuery): Promise<ChainProviderBox<I>[]>;
-    streamUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere>): AsyncIterable<ChainProviderUnconfirmedTransaction<I>[]>;
+    streamUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere> & SkipAndTake): AsyncIterable<ChainProviderUnconfirmedTransaction<I>[]>;
     getUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere>): Promise<ChainProviderUnconfirmedTransaction<I>[]>;
-    streamConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere>): AsyncIterable<ChainProviderConfirmedTransaction<I>[]>;
+    streamConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere> & SkipAndTake): AsyncIterable<ChainProviderConfirmedTransaction<I>[]>;
     getConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere>): Promise<ChainProviderConfirmedTransaction<I>[]>;
     getHeaders(query: HeaderQuery): Promise<BlockHeader[]>;
     createOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options?: Partial<ErgoGraphQLRequestOptions>): GraphQLOperation<GraphQLSuccessResponse<R>, V>;
@@ -368,5 +399,6 @@ declare class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I>
     submitTransaction(signedTransaction: SignedTransaction): Promise<TransactionEvaluationResult>;
     reduceTransaction(): Promise<TransactionReductionResult>;
 }
+declare function isRequestParam(obj: unknown): obj is ErgoGraphQLRequestOptions;
 
-export { ErgoGraphQLProvider, type ErgoGraphQLRequestOptions, type GraphQLBoxQuery, type GraphQLBoxWhere, type GraphQLConfirmedTransactionWhere, type GraphQLUnconfirmedTransactionWhere };
+export { type BoxQuery, type BoxSource, type BoxWhere, type ChainProviderBox, type ChainProviderConfirmedTransaction, type ChainProviderUnconfirmedTransaction, type ConfirmedTransactionWhere, ErgoGraphQLProvider, type ErgoGraphQLRequestOptions, type FallbackRetryOptions, type FetchOptions, type GraphQLBoxQuery, type GraphQLBoxWhere, type GraphQLConfirmedTransactionWhere, type GraphQLError, type GraphQLErrorResponse, type GraphQLOperation, type GraphQLRequestOptions, type GraphQLRequiredUrlOperation, type GraphQLResponse, type GraphQLSuccessResponse, type GraphQLUnconfirmedTransactionWhere, type GraphQLVariables, type HeaderQuery, type IBlockchainProvider, type ParserLike, type RetryOptions, type Route, type TransactionEvaluationError, type TransactionEvaluationResult, type TransactionEvaluationSuccess, type TransactionQuery, type TransactionReductionResult, type TransactionReductionSuccess, type URLLike, type UnconfirmedTransactionWhere, createGqlOperation, exponentialRetry, getOpName, gql, isRequestParam, request };

package/dist/index.d.ts

@@ -302,10 +302,27 @@ type URLLike = string | Route;
 type FallbackRetryOptions = {
     fallbacks?: URLLike[];
 } & RetryOptions;
+type FetchOptions = {
+    parser?: ParserLike;
+    base?: string;
+    query?: Record<string, unknown>;
+    retry?: FallbackRetryOptions;
+    httpOptions?: RequestInit;
+};
+declare function request<T>(path: string, opt?: Partial<FetchOptions>): Promise<T>;
 type RetryOptions = {
     attempts: number;
     delay: number;
 };
+/**
+ * Retries an asynchronous operation a specified number of times with a delay
+ * growing exponentially between each attempt.
+ * @param operation - The asynchronous operation to retry.
+ * @param options - The retry options.
+ * @returns A promise that resolves to the result of the operation, or undefined
+ * if all attempts fail.
+ */
+declare function exponentialRetry<T>(operation: (remainingAttempts: number) => Promise<T>, { attempts, delay }: RetryOptions): Promise<T>;
 
 type GraphQLVariables = Record<string, unknown> | null;
 interface GraphQLError {
@@ -321,6 +338,7 @@ interface GraphQLErrorResponse {
 }
 type GraphQLResponse<T = unknown> = GraphQLSuccessResponse<T> | GraphQLErrorResponse;
 type GraphQLOperation<R extends GraphQLResponse, V extends GraphQLVariables> = (variables?: V, url?: string) => Promise<R>;
+type GraphQLRequiredUrlOperation<R extends GraphQLResponse, V extends GraphQLVariables> = (variables: V | undefined, url: string) => Promise<R>;
 interface GraphQLRequestOptions {
     url?: string;
     parser?: ParserLike;
@@ -328,39 +346,52 @@ interface GraphQLRequestOptions {
     throwOnNonNetworkErrors?: boolean;
     httpOptions?: Omit<RequestInit, "body" | "method">;
 }
-
-type BiMapper<T> = (value: string) => T;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions & {
+    throwOnNonNetworkErrors: true;
+}): GraphQLOperation<GraphQLSuccessResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options?: GraphQLRequestOptions & {
+    url: undefined;
+}): GraphQLRequiredUrlOperation<GraphQLResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions & {
+    url: undefined;
+    throwOnNonNetworkErrors: true;
+}): GraphQLRequiredUrlOperation<GraphQLSuccessResponse<R>, V>;
+declare function createGqlOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options: GraphQLRequestOptions): GraphQLOperation<GraphQLResponse<R>, V>;
+declare function gql(query: TemplateStringsArray): string;
+declare function getOpName(query: string): string | undefined;
+
+type SkipAndTake = {
+    skip?: number;
+    take?: number;
+};
 type GraphQLBoxWhere = BoxWhere & {
-    /** Base16-encoded BoxIds */
-    boxIds?: HexString[];
     /** Base16-encoded ErgoTrees */
     ergoTrees?: HexString[];
     /** Base58-encoded addresses or `ErgoAddress` objects */
     addresses?: (Base58String | ErgoAddress)[];
 };
 type GraphQLConfirmedTransactionWhere = ConfirmedTransactionWhere & {
-    transactionIds?: HexString[];
     addresses?: (Base58String | ErgoAddress)[];
     ergoTrees?: HexString[];
 };
 type GraphQLUnconfirmedTransactionWhere = UnconfirmedTransactionWhere & {
-    transactionIds?: HexString[];
     addresses?: (Base58String | ErgoAddress)[];
     ergoTrees?: HexString[];
 };
 type GraphQLBoxQuery = BoxQuery<GraphQLBoxWhere>;
-type ErgoGraphQLRequestOptions = Omit<GraphQLRequestOptions, "throwOnNonNetworkError">;
+type ErgoGraphQLRequestOptions = Omit<GraphQLRequestOptions, "throwOnNonNetworkErrors">;
+type BiMapper<T> = (value: string) => T;
 declare class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I> {
     #private;
     constructor(url: string);
-    constructor(url: ErgoGraphQLRequestOptions);
+    constructor(options: ErgoGraphQLRequestOptions);
     setUrl(url: string): ErgoGraphQLProvider<I>;
     setBigIntMapper<M>(mapper: BiMapper<M>): ErgoGraphQLProvider<M>;
-    streamBoxes(query: GraphQLBoxQuery): AsyncGenerator<ChainProviderBox<I>[]>;
+    streamBoxes(query: GraphQLBoxQuery & SkipAndTake): AsyncGenerator<ChainProviderBox<I>[]>;
     getBoxes(query: GraphQLBoxQuery): Promise<ChainProviderBox<I>[]>;
-    streamUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere>): AsyncIterable<ChainProviderUnconfirmedTransaction<I>[]>;
+    streamUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere> & SkipAndTake): AsyncIterable<ChainProviderUnconfirmedTransaction<I>[]>;
     getUnconfirmedTransactions(query: TransactionQuery<GraphQLUnconfirmedTransactionWhere>): Promise<ChainProviderUnconfirmedTransaction<I>[]>;
-    streamConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere>): AsyncIterable<ChainProviderConfirmedTransaction<I>[]>;
+    streamConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere> & SkipAndTake): AsyncIterable<ChainProviderConfirmedTransaction<I>[]>;
     getConfirmedTransactions(query: TransactionQuery<GraphQLConfirmedTransactionWhere>): Promise<ChainProviderConfirmedTransaction<I>[]>;
     getHeaders(query: HeaderQuery): Promise<BlockHeader[]>;
     createOperation<R, V extends GraphQLVariables = GraphQLVariables>(query: string, options?: Partial<ErgoGraphQLRequestOptions>): GraphQLOperation<GraphQLSuccessResponse<R>, V>;
@@ -368,5 +399,6 @@ declare class ErgoGraphQLProvider<I = bigint> implements IBlockchainProvider<I>
     submitTransaction(signedTransaction: SignedTransaction): Promise<TransactionEvaluationResult>;
     reduceTransaction(): Promise<TransactionReductionResult>;
 }
+declare function isRequestParam(obj: unknown): obj is ErgoGraphQLRequestOptions;
 
-export { ErgoGraphQLProvider, type ErgoGraphQLRequestOptions, type GraphQLBoxQuery, type GraphQLBoxWhere, type GraphQLConfirmedTransactionWhere, type GraphQLUnconfirmedTransactionWhere };
+export { type BoxQuery, type BoxSource, type BoxWhere, type ChainProviderBox, type ChainProviderConfirmedTransaction, type ChainProviderUnconfirmedTransaction, type ConfirmedTransactionWhere, ErgoGraphQLProvider, type ErgoGraphQLRequestOptions, type FallbackRetryOptions, type FetchOptions, type GraphQLBoxQuery, type GraphQLBoxWhere, type GraphQLConfirmedTransactionWhere, type GraphQLError, type GraphQLErrorResponse, type GraphQLOperation, type GraphQLRequestOptions, type GraphQLRequiredUrlOperation, type GraphQLResponse, type GraphQLSuccessResponse, type GraphQLUnconfirmedTransactionWhere, type GraphQLVariables, type HeaderQuery, type IBlockchainProvider, type ParserLike, type RetryOptions, type Route, type TransactionEvaluationError, type TransactionEvaluationResult, type TransactionEvaluationSuccess, type TransactionQuery, type TransactionReductionResult, type TransactionReductionSuccess, type URLLike, type UnconfirmedTransactionWhere, createGqlOperation, exponentialRetry, getOpName, gql, isRequestParam, request };

package/dist/index.js

@@ -4,6 +4,52 @@ var common = require('@fleet-sdk/common');
 var core = require('@fleet-sdk/core');
 
 // src/ergo-graphql/ergoGraphQLProvider.ts
+new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+var HEXES = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var HexChar = {
+  ZERO: 48,
+  // 0
+  NINE: 57,
+  // 9
+  A_UP: 65,
+  // A
+  F_UP: 70,
+  // F
+  A_LO: 97,
+  // a
+  F_LO: 102
+  // f
+};
+function bytesToHex(bytes2) {
+  common.assertInstanceOf(bytes2, Uint8Array);
+  let hex3 = "";
+  for (let i = 0, len = bytes2.length; i < len; i++) {
+    hex3 += HEXES[bytes2[i]];
+  }
+  return hex3;
+}
+function hexToBytes(hex3) {
+  common.assertTypeOf(hex3, "string");
+  common.assert(hex3.length % 2 === 0, "Invalid hex padding.");
+  const len = hex3.length / 2;
+  const bytes2 = new Uint8Array(len);
+  for (let i = 0, j = 0; i < len; i++) {
+    const n1 = charCodeToBase16(hex3.charCodeAt(j++));
+    const n2 = charCodeToBase16(hex3.charCodeAt(j++));
+    bytes2[i] = n1 * 16 + n2;
+  }
+  return bytes2;
+}
+function charCodeToBase16(char) {
+  if (char >= HexChar.ZERO && char <= HexChar.NINE) return char - HexChar.ZERO;
+  if (char >= HexChar.A_UP && char <= HexChar.F_UP) return char - (HexChar.A_UP - 10);
+  if (char >= HexChar.A_LO && char <= HexChar.F_LO) return char - (HexChar.A_LO - 10);
+  throw new Error("Invalid byte sequence.");
+}
+var hex2 = {
+  encode: bytesToHex,
+  decode: hexToBytes
+};
 async function request(path, opt) {
   const url = buildURL(path, opt?.query, opt?.base);
   let response;
@@ -73,12 +119,12 @@ function createGqlOperation(query, options) {
     return response;
   };
 }
+function gql(query) {
+  return query[0];
+}
 function getOpName(query) {
   return OP_NAME_REGEX.exec(query)?.at(2);
 }
-function isRequestParam(obj) {
-  return typeof obj === "object" && obj.url !== void 0;
-}
 
 // src/ergo-graphql/queries.ts
 var B = [
@@ -102,6 +148,7 @@ var UNCONF_TX_QUERY = `query unconfirmedTransactions(${T[0]}) { mempool { transa
 
 // src/ergo-graphql/ergoGraphQLProvider.ts
 var PAGE_SIZE = 50;
+var MAX_ARGS = 20;
 var ErgoGraphQLProvider = class {
   #options;
   #biMapper;
@@ -114,11 +161,11 @@ var ErgoGraphQLProvider = class {
   #sendTransaction;
   #getHeaders;
   constructor(optOrUrl) {
+    this.#biMapper = (value) => BigInt(value);
     this.#options = {
       ...isRequestParam(optOrUrl) ? optOrUrl : { url: optOrUrl },
       throwOnNonNetworkErrors: true
     };
-    this.#biMapper = (value) => BigInt(value);
     this.#getConfirmedBoxes = this.createOperation(CONF_BOXES_QUERY);
     this.#getUnconfirmedBoxes = this.createOperation(UNCONF_BOXES_QUERY);
     this.#getAllBoxes = this.createOperation(ALL_BOXES_QUERY);
@@ -129,7 +176,7 @@ var ErgoGraphQLProvider = class {
     this.#getHeaders = this.createOperation(HEADERS_QUERY);
   }
   #fetchBoxes(args, inclConf, inclUnconf) {
-    return inclConf && inclUnconf ? this.#getAllBoxes(args, this.#options.url) : inclUnconf ? this.#getUnconfirmedBoxes(args, this.#options.url) : this.#getConfirmedBoxes(args, this.#options.url);
+    return inclConf && inclUnconf ? this.#getAllBoxes(args) : inclUnconf ? this.#getUnconfirmedBoxes(args) : this.#getConfirmedBoxes(args);
   }
   setUrl(url) {
     this.#options.url = url;
@@ -145,96 +192,105 @@ var ErgoGraphQLProvider = class {
     }
     const notBeingSpent = (box) => !box.beingSpent;
     const returnedBoxIds = /* @__PURE__ */ new Set();
-    const { where, from } = query;
-    const args = buildGqlBoxQueryArgs(where);
-    let inclChain = from !== "mempool";
-    let inclPool = from !== "blockchain";
-    const isMempoolAware = inclPool;
-    do {
-      const { data } = await this.#fetchBoxes(args, inclChain, inclPool);
-      let boxes = [];
-      if (inclChain && hasConfirmed(data)) {
-        if (common.some(data.boxes)) {
-          const confirmedBoxes = (isMempoolAware ? data.boxes.filter(notBeingSpent) : data.boxes).map((b) => mapConfirmedBox(b, this.#biMapper));
-          boxes = boxes.concat(confirmedBoxes);
+    const { from, take } = query;
+    const pageSize = take ?? PAGE_SIZE;
+    const queries = buildGqlBoxQueries(query);
+    const isMempoolAware = from !== "blockchain";
+    for (const query2 of queries) {
+      let inclChain = from !== "mempool";
+      let inclPool = from !== "blockchain";
+      while (inclChain || inclPool) {
+        const { data } = await this.#fetchBoxes(query2, inclChain, inclPool);
+        let boxes = [];
+        if (inclChain && hasConfirmed(data)) {
+          if (common.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 === pageSize;
         }
-        inclChain = data.boxes.length === PAGE_SIZE;
-      }
-      if (isMempoolAware && hasMempool(data)) {
-        if (common.some(data.mempool.boxes)) {
-          const mempoolBoxes = data.mempool.boxes.filter(notBeingSpent).map((b) => mapUnconfirmedBox(b, this.#biMapper));
-          boxes = boxes.concat(mempoolBoxes);
-        }
-        inclPool = data.mempool.boxes.length === PAGE_SIZE;
-      }
-      if (common.some(boxes)) {
-        if (boxes.some((box) => returnedBoxIds.has(box.boxId))) {
-          boxes = boxes.filter((b) => !returnedBoxIds.has(b.boxId));
+        if (isMempoolAware && hasMempool(data)) {
+          if (common.some(data.mempool.boxes)) {
+            const mempoolBoxes = data.mempool.boxes.filter(notBeingSpent).map((b) => mapUnconfirmedBox(b, this.#biMapper));
+            boxes = boxes.concat(mempoolBoxes);
+          }
+          inclPool = data.mempool.boxes.length === pageSize;
         }
         if (common.some(boxes)) {
-          boxes = common.uniqBy(boxes, (box) => box.boxId);
-          for (const box of boxes) returnedBoxIds.add(box.boxId);
-          yield boxes;
+          if (boxes.some((box) => returnedBoxIds.has(box.boxId))) {
+            boxes = boxes.filter((b) => !returnedBoxIds.has(b.boxId));
+          }
+          if (common.some(boxes)) {
+            boxes = common.uniqBy(boxes, (box) => box.boxId);
+            for (const box of boxes) returnedBoxIds.add(box.boxId);
+            yield boxes;
+          }
         }
+        if (inclChain || inclPool) query2.skip += pageSize;
       }
-      if (inclChain || inclPool) args.skip += PAGE_SIZE;
-    } while (inclChain || inclPool);
+    }
   }
   async getBoxes(query) {
     const boxes = [];
-    for await (const chunk of this.streamBoxes(query)) boxes.push(chunk);
+    for await (const chunk2 of this.streamBoxes(query)) boxes.push(chunk2);
     return common.orderBy(boxes.flat(), (box) => box.creationHeight);
   }
   async *streamUnconfirmedTransactions(query) {
-    const args = buildGqlUnconfirmedTxQueryArgs(query.where);
-    let keepFetching = true;
-    while (keepFetching) {
-      const response = await this.#getUnconfirmedTransactions(args);
-      if (common.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 query2 of queries) {
+      let keepFetching = true;
+      while (keepFetching) {
+        const response = await this.#getUnconfirmedTransactions(query2);
+        if (common.some(response.data?.mempool?.transactions)) {
+          yield response.data.mempool.transactions.map(
+            (t) => mapUnconfirmedTransaction(t, this.#biMapper)
+          );
+        }
+        keepFetching = response.data?.mempool?.transactions?.length === pageSize;
+        if (keepFetching) query2.skip += pageSize;
       }
-      keepFetching = response.data?.mempool?.transactions?.length === PAGE_SIZE;
-      if (keepFetching) args.skip += PAGE_SIZE;
     }
   }
   async getUnconfirmedTransactions(query) {
     const transactions = [];
-    for await (const chunk of this.streamUnconfirmedTransactions(query)) {
-      transactions.push(chunk);
+    for await (const chunk2 of this.streamUnconfirmedTransactions(query)) {
+      transactions.push(chunk2);
     }
     return transactions.flat();
   }
   async *streamConfirmedTransactions(query) {
-    const args = buildGqlConfirmedTxQueryArgs(query.where);
-    let keepFetching = true;
-    while (keepFetching) {
-      const response = await this.#getConfirmedTransactions(args);
-      if (common.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 query2 of queries) {
+      let keepFetching = true;
+      while (keepFetching) {
+        const response = await this.#getConfirmedTransactions(query2);
+        if (common.some(response.data?.transactions)) {
+          yield response.data.transactions.map(
+            (t) => mapConfirmedTransaction(t, this.#biMapper)
+          );
+        }
+        keepFetching = response.data?.transactions?.length === pageSize;
+        if (keepFetching) query2.skip += pageSize;
       }
-      keepFetching = response.data?.transactions?.length === PAGE_SIZE;
-      if (keepFetching) args.skip += PAGE_SIZE;
     }
   }
   async getConfirmedTransactions(query) {
     const transactions = [];
-    for await (const chunk of this.streamConfirmedTransactions(query)) {
-      transactions.push(chunk);
+    for await (const chunk2 of this.streamConfirmedTransactions(query)) {
+      transactions.push(chunk2);
     }
     return transactions.flat();
   }
   async getHeaders(query) {
-    const response = await this.#getHeaders(query, this.#options.url);
-    return response.data?.blockHeaders.map((header) => ({
-      ...header,
-      id: header.headerId,
-      timestamp: Number(header.timestamp),
-      nBits: Number(header.nBits),
-      votes: header.votes.join("")
+    const response = await this.#getHeaders(query);
+    return response.data?.blockHeaders.map((h) => ({
+      ...h,
+      id: h.headerId,
+      timestamp: Number(h.timestamp),
+      nBits: Number(h.nBits),
+      votes: hex2.encode(Uint8Array.from(h.votes))
     })) ?? [];
   }
   createOperation(query, options) {
@@ -244,10 +300,7 @@ var ErgoGraphQLProvider = class {
   }
   async checkTransaction(signedTransaction) {
     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.message };
@@ -255,10 +308,7 @@ var ErgoGraphQLProvider = class {
   }
   async submitTransaction(signedTransaction) {
     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.message };
@@ -268,50 +318,52 @@ var ErgoGraphQLProvider = class {
     throw new common.NotSupportedError("Transaction reducing is not supported by ergo-graphql.");
   }
 };
-function buildGqlBoxQueryArgs(where) {
-  const args = {
+function buildGqlBoxQueries(query) {
+  const ergoTrees = common.uniq(
+    [
+      merge(query.where.ergoTrees, query.where.ergoTree) ?? [],
+      merge(query.where.addresses, query.where.address)?.map(
+        (a) => typeof a === "string" ? core.ErgoAddress.decode(a).ergoTree : a.ergoTree
+      ) ?? []
+    ].flat()
+  );
+  return common.chunk(ergoTrees, MAX_ARGS).map((chunk2) => ({
     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
-  };
-  const addresses = merge(where.addresses, where.address);
-  if (common.some(addresses)) {
-    const trees = addresses.map(
-      (address) => typeof address === "string" ? core.ErgoAddress.decode(address).ergoTree : address.ergoTree
-    );
-    args.ergoTrees = common.uniq(common.some(args.ergoTrees) ? args.ergoTrees.concat(trees) : trees);
-  }
-  return args;
+    boxIds: query.where.boxId ? [query.where.boxId] : void 0,
+    ergoTrees: chunk2,
+    ergoTreeTemplateHash: query.where.templateHash,
+    tokenId: query.where.tokenId,
+    skip: query.skip ?? 0,
+    take: query.take ?? PAGE_SIZE
+  }));
 }
-function buildGqlUnconfirmedTxQueryArgs(where) {
+function buildGqlUnconfirmedTxQueries(query) {
   const addresses = common.uniq(
     [
-      merge(where.addresses, where.address)?.map(
+      merge(query.where.addresses, query.where.address)?.map(
         (address) => typeof address === "string" ? address : address.encode()
       ) ?? [],
-      merge(where.ergoTrees, where.ergoTree)?.map(
+      merge(query.where.ergoTrees, query.where.ergoTree)?.map(
         (tree) => core.ErgoAddress.fromErgoTree(tree).encode()
       ) ?? []
     ].flat()
   );
-  return {
-    addresses: addresses.length ? addresses : void 0,
-    transactionIds: merge(where.transactionIds, where.transactionId),
-    skip: 0,
-    take: PAGE_SIZE
-  };
+  return common.chunk(addresses, MAX_ARGS).map((chunk2) => ({
+    addresses: chunk2.length ? chunk2 : void 0,
+    transactionIds: query.where.transactionId ? [query.where.transactionId] : void 0,
+    skip: query.skip ?? 0,
+    take: query.take ?? PAGE_SIZE
+  }));
 }
-function buildGqlConfirmedTxQueryArgs(where) {
-  return {
-    ...buildGqlUnconfirmedTxQueryArgs(where),
-    headerId: where.headerId,
-    minHeight: where.minHeight,
-    onlyRelevantOutputs: where.onlyRelevantOutputs
-  };
+function buildGqlConfirmedTxQueries(query) {
+  return buildGqlUnconfirmedTxQueries(
+    query
+  ).map((q) => ({
+    ...q,
+    headerId: query.where.headerId,
+    minHeight: query.where.minHeight,
+    onlyRelevantOutputs: query.where.onlyRelevantOutputs
+  }));
 }
 function merge(array, el) {
   if (common.isEmpty(array) && common.isUndefined(el)) return;
@@ -388,7 +440,24 @@ function mapConfirmedTransaction(tx, mapper) {
     confirmed: true
   };
 }
+function isRequestParam(obj) {
+  return typeof obj === "object" && obj.url !== void 0;
+}
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 
 exports.ErgoGraphQLProvider = ErgoGraphQLProvider;
+exports.createGqlOperation = createGqlOperation;
+exports.exponentialRetry = exponentialRetry;
+exports.getOpName = getOpName;
+exports.gql = gql;
+exports.isRequestParam = isRequestParam;
+exports.request = request;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map