@fleet-sdk/blockchain-providers 0.5.0 → 0.6.1

package/dist/index.js

@@ -4,79 +4,187 @@ 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;
+  if (opt?.retry) {
+    const routes = common.some(opt.retry.fallbacks) ? [url, ...opt.retry.fallbacks] : [url];
+    const attempts = opt.retry.attempts;
+    response = await exponentialRetry(
+      (r) => fetch(resolveUrl(routes, attempts - r), opt.httpOptions),
+      opt.retry
+    );
+  } else {
+    response = await fetch(url, opt?.httpOptions);
+  }
+  return (opt?.parser || JSON).parse(await response.text());
+}
+function resolveUrl(routes, attempt) {
+  const route = routes[attempt % routes.length];
+  return typeof route === "string" ? route : buildURL(route.path, route.query, route.base).toString();
+}
+function buildURL(path, query, base) {
+  if (!base && !query) return path;
+  const url = new URL(path, base);
+  if (common.some(query)) {
+    for (const key in query) url.searchParams.append(key, String(query[key]));
+  }
+  return url.toString();
+}
+async function exponentialRetry(operation, { attempts, delay }) {
+  try {
+    return await operation(attempts);
+  } catch (e) {
+    if (attempts > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      return exponentialRetry(operation, { attempts: attempts - 1, delay: delay * 2 });
+    }
+    throw e;
+  }
+}
+
+// src/utils/graphql.ts
 var OP_NAME_REGEX = /(query|mutation)\s?([\w\-_]+)?/;
 var DEFAULT_HEADERS = {
   "content-type": "application/json; charset=utf-8",
   accept: "application/graphql-response+json, application/json"
 };
 function createGqlOperation(query, options) {
-  return async (variables) => {
-    const response = await (options.fetcher ?? fetch)(options.url, {
-      method: "POST",
-      headers: common.ensureDefaults(options.headers, DEFAULT_HEADERS),
-      credentials: options.credentials,
-      body: (options.parser ?? JSON).stringify({
-        operationName: getOpName(query),
-        query,
-        variables: variables ? common.clearUndefined(variables) : void 0
-      })
+  return async (variables, url) => {
+    url = url ?? options?.url;
+    if (!url) throw new Error("URL is required");
+    const response = await request(url, {
+      ...options,
+      httpOptions: {
+        ...options?.httpOptions,
+        method: "POST",
+        headers: common.ensureDefaults(options?.httpOptions?.headers, DEFAULT_HEADERS),
+        body: (options?.parser ?? JSON).stringify({
+          operationName: getOpName(query),
+          query,
+          variables: variables ? common.clearUndefined(variables) : void 0
+        })
+      }
     });
-    const rawData = await response.text();
-    const parsedData = (options.parser ?? JSON).parse(
-      rawData
-    );
-    if (options.throwOnNonNetworkErrors && common.some(parsedData.errors) && common.isEmpty(parsedData.data)) {
-      throw new common.BlockchainProviderError(parsedData.errors[0].message, {
-        cause: parsedData.errors
-      });
+    if (options?.throwOnNonNetworkErrors && common.some(response.errors) && common.isEmpty(response.data)) {
+      const msg = response.errors[0].message;
+      throw new common.BlockchainProviderError(msg, { cause: response.errors });
     }
-    return parsedData;
+    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 = [
-  "query boxes($spent: Boolean! $boxIds: [String!] $ergoTrees: [String!] $ergoTreeTemplateHash: String $tokenId: String $skip: Int $take: Int)",
+  "$boxIds: [String!] $ergoTrees: [String!] $ergoTreeTemplateHash: String $tokenId: String $skip: Int $take: Int",
   "boxIds: $boxIds ergoTrees: $ergoTrees ergoTreeTemplateHash: $ergoTreeTemplateHash tokenId: $tokenId skip: $skip take: $take",
-  "boxId transactionId index value creationHeight ergoTree assets { tokenId amount } additionalRegisters beingSpent"
+  "boxId transactionId index value creationHeight ergoTree assets { tokenId amount } additionalRegisters"
 ];
-var CONF_BOXES_QUERY = `${B[0]} { boxes(spent: $spent ${B[1]}) { ${B[2]} } }`;
-var UNCONF_BOXES_QUERY = `${B[0]} { mempool { boxes(${B[1]}) { ${B[2]} } } }`;
-var ALL_BOXES_QUERY = `${B[0]} { boxes(spent: $spent ${B[1]}) { ${B[2]} } mempool { boxes(${B[1]}) { ${B[2]} } } }`;
+var CONF_BOXES_QUERY = `query boxes($spent: Boolean! ${B[0]}) { boxes(spent: $spent ${B[1]}) { ${B[2]} beingSpent } }`;
+var UNCONF_BOXES_QUERY = `query boxes(${B[0]}) { mempool { boxes(${B[1]}) { ${B[2]} beingSpent } } }`;
+var ALL_BOXES_QUERY = `query boxes($spent: Boolean! ${B[0]}) { boxes(spent: $spent ${B[1]}) { ${B[2]} beingSpent } mempool { boxes(${B[1]}) { ${B[2]} beingSpent } } }`;
 var HEADERS_QUERY = "query blockHeaders($take: Int) { blockHeaders(take: $take) {headerId timestamp version adProofsRoot stateRoot transactionsRoot nBits extensionHash powSolutions height difficulty parentId votes } }";
 var CHECK_TX_MUTATION = "mutation checkTransaction($signedTransaction: SignedTransaction!) { checkTransaction(signedTransaction: $signedTransaction) }";
 var SEND_TX_MUTATION = "mutation submitTransaction($signedTransaction: SignedTransaction!) { submitTransaction(signedTransaction: $signedTransaction) }";
+var T = [
+  "$addresses: [String!], $transactionIds: [String!], $skip: Int, $take: Int",
+  "addresses: $addresses, transactionIds: $transactionIds, skip: $skip, take: $take",
+  `transactionId timestamp inputs { proofBytes extension index box { ${B[2]} } } dataInputs { boxId }`
+];
+var CONF_TX_QUERY = `query confirmedTransactions(${T[0]}  $relevantOnly: Boolean) { transactions(${T[1]}) { ${T[2]} outputs(relevantOnly: $relevantOnly) { ${B[2]} } inclusionHeight headerId index } }`;
+var UNCONF_TX_QUERY = `query unconfirmedTransactions(${T[0]}) { mempool { transactions(${T[1]}) { ${T[2]} outputs { ${B[2]} } } } }`;
 
 // src/ergo-graphql/ergoGraphQLProvider.ts
 var PAGE_SIZE = 50;
+var MAX_ARGS = 20;
 var ErgoGraphQLProvider = class {
   #options;
-  #getConfBoxes;
-  #getUnconfBoxes;
+  #biMapper;
+  #getConfirmedBoxes;
+  #getUnconfirmedBoxes;
   #getAllBoxes;
+  #getConfirmedTransactions;
+  #getUnconfirmedTransactions;
+  #checkTransaction;
+  #sendTransaction;
   #getHeaders;
-  #checkTx;
-  #sendTx;
   constructor(optOrUrl) {
+    this.#biMapper = (value) => BigInt(value);
     this.#options = {
       ...isRequestParam(optOrUrl) ? optOrUrl : { url: optOrUrl },
       throwOnNonNetworkErrors: true
     };
-    this.#getConfBoxes = this.createOperation(CONF_BOXES_QUERY);
-    this.#getUnconfBoxes = this.createOperation(UNCONF_BOXES_QUERY);
+    this.#getConfirmedBoxes = this.createOperation(CONF_BOXES_QUERY);
+    this.#getUnconfirmedBoxes = this.createOperation(UNCONF_BOXES_QUERY);
     this.#getAllBoxes = this.createOperation(ALL_BOXES_QUERY);
+    this.#getConfirmedTransactions = this.createOperation(CONF_TX_QUERY);
+    this.#getUnconfirmedTransactions = this.createOperation(UNCONF_TX_QUERY);
+    this.#checkTransaction = this.createOperation(CHECK_TX_MUTATION);
+    this.#sendTransaction = this.createOperation(SEND_TX_MUTATION);
     this.#getHeaders = this.createOperation(HEADERS_QUERY);
-    this.#checkTx = this.createOperation(CHECK_TX_MUTATION);
-    this.#sendTx = this.createOperation(SEND_TX_MUTATION);
   }
   #fetchBoxes(args, inclConf, inclUnconf) {
-    return inclConf && inclUnconf ? this.#getAllBoxes(args) : inclUnconf ? this.#getUnconfBoxes(args) : this.#getConfBoxes(args);
+    return inclConf && inclUnconf ? this.#getAllBoxes(args) : inclUnconf ? this.#getUnconfirmedBoxes(args) : this.#getConfirmedBoxes(args);
+  }
+  setUrl(url) {
+    this.#options.url = url;
+    return this;
+  }
+  setBigIntMapper(mapper) {
+    this.#biMapper = mapper;
+    return this;
   }
   async *streamBoxes(query) {
     if (common.isEmpty(query.where)) {
@@ -85,56 +193,101 @@ 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 response = await this.#fetchBoxes(args, inclChain, inclPool);
-      const { data } = response;
-      let boxes = [];
-      if (inclChain && hasConfirmed(data)) {
-        if (common.some(data.boxes)) {
-          const confirmedBoxes = (isMempoolAware ? data.boxes.filter(notBeingSpent) : data.boxes).map(asConfirmed(true));
-          boxes = boxes.concat(confirmedBoxes);
-        }
-        inclChain = data.boxes.length === PAGE_SIZE;
-      }
-      if (isMempoolAware && hasMempool(data)) {
-        if (common.some(data.mempool.boxes)) {
-          const mempoolBoxes = data.mempool.boxes.filter(notBeingSpent).map(asConfirmed(false));
-          boxes = boxes.concat(mempoolBoxes);
+    const queries = buildGqlBoxQueries(where);
+    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 === PAGE_SIZE;
         }
-        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 === PAGE_SIZE;
         }
         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 += PAGE_SIZE;
       }
-      if (inclChain || inclPool) args.skip += PAGE_SIZE;
-    } while (inclChain || inclPool);
+    }
   }
   async getBoxes(query) {
-    let boxes = [];
-    for await (const chunk of this.streamBoxes(query)) {
-      boxes = boxes.concat(chunk);
+    const boxes = [];
+    for await (const chunk2 of this.streamBoxes(query)) boxes.push(chunk2);
+    return common.orderBy(boxes.flat(), (box) => box.creationHeight);
+  }
+  async *streamUnconfirmedTransactions(query) {
+    const queries = buildGqlUnconfirmedTxQueries(query.where);
+    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 === PAGE_SIZE;
+        if (keepFetching) query2.skip += PAGE_SIZE;
+      }
+    }
+  }
+  async getUnconfirmedTransactions(query) {
+    const transactions = [];
+    for await (const chunk2 of this.streamUnconfirmedTransactions(query)) {
+      transactions.push(chunk2);
+    }
+    return transactions.flat();
+  }
+  async *streamConfirmedTransactions(query) {
+    const queries = buildGqlConfirmedTxQueries(query.where);
+    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 === PAGE_SIZE;
+        if (keepFetching) query2.skip += PAGE_SIZE;
+      }
+    }
+  }
+  async getConfirmedTransactions(query) {
+    const transactions = [];
+    for await (const chunk2 of this.streamConfirmedTransactions(query)) {
+      transactions.push(chunk2);
     }
-    return common.orderBy(boxes, (box) => box.creationHeight);
+    return transactions.flat();
   }
   async getHeaders(query) {
     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("")
+    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) {
@@ -144,7 +297,7 @@ var ErgoGraphQLProvider = class {
   }
   async checkTransaction(signedTransaction) {
     try {
-      const response = await this.#checkTx({ signedTransaction });
+      const response = await this.#checkTransaction({ signedTransaction });
       return { success: true, transactionId: response.data.checkTransaction };
     } catch (e) {
       return { success: false, message: e.message };
@@ -152,38 +305,60 @@ var ErgoGraphQLProvider = class {
   }
   async submitTransaction(signedTransaction) {
     try {
-      const response = await this.#sendTx({ signedTransaction });
+      const response = await this.#sendTransaction({ signedTransaction });
       return { success: true, transactionId: response.data.submitTransaction };
     } catch (e) {
       return { success: false, message: e.message };
     }
   }
   reduceTransaction() {
-    throw new common.NotSupportedError(
-      "Transaction reducing is not supported by ergo-graphql."
-    );
+    throw new common.NotSupportedError("Transaction reducing is not supported by ergo-graphql.");
   }
 };
-function buildGqlBoxQueryArgs(where) {
-  const args = {
+function buildGqlBoxQueries(where) {
+  const ergoTrees = common.uniq(
+    [
+      merge(where.ergoTrees, where.ergoTree) ?? [],
+      merge(where.addresses, 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),
+    boxIds: where.boxId ? [where.boxId] : void 0,
+    ergoTrees: chunk2,
     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.fromBase58(address).ergoTree : address.ergoTree
-    );
-    args.ergoTrees = common.uniq(
-      common.some(args.ergoTrees) ? args.ergoTrees.concat(trees) : trees
-    );
-  }
-  return args;
+  }));
+}
+function buildGqlUnconfirmedTxQueries(where) {
+  const addresses = common.uniq(
+    [
+      merge(where.addresses, where.address)?.map(
+        (address) => typeof address === "string" ? address : address.encode()
+      ) ?? [],
+      merge(where.ergoTrees, where.ergoTree)?.map(
+        (tree) => core.ErgoAddress.fromErgoTree(tree).encode()
+      ) ?? []
+    ].flat()
+  );
+  return common.chunk(addresses, MAX_ARGS).map((chunk2) => ({
+    addresses: chunk2.length ? chunk2 : void 0,
+    transactionIds: where.transactionId ? [where.transactionId] : void 0,
+    skip: 0,
+    take: PAGE_SIZE
+  }));
+}
+function buildGqlConfirmedTxQueries(where) {
+  return buildGqlUnconfirmedTxQueries(where).map((query) => ({
+    ...query,
+    headerId: where.headerId,
+    minHeight: where.minHeight,
+    onlyRelevantOutputs: where.onlyRelevantOutputs
+  }));
 }
 function merge(array, el) {
   if (common.isEmpty(array) && common.isUndefined(el)) return;
@@ -197,18 +372,87 @@ function hasMempool(data) {
 function hasConfirmed(data) {
   return !!data?.boxes;
 }
-function asConfirmed(confirmed) {
-  return (box) => ({
-    ...box,
-    value: BigInt(box.value),
-    assets: box.assets.map((asset) => ({
-      tokenId: asset.tokenId,
-      amount: BigInt(asset.amount)
+function mapConfirmedBox(box, mapper) {
+  const mapped = mapBox(box, mapper);
+  mapped.confirmed = true;
+  return mapped;
+}
+function mapUnconfirmedBox(box, mapper) {
+  const mapped = mapBox(box, mapper);
+  mapped.confirmed = false;
+  return mapped;
+}
+function mapBox(box, mapper) {
+  return {
+    boxId: box.boxId,
+    transactionId: box.transactionId,
+    value: mapper(box.value),
+    ergoTree: box.ergoTree,
+    assets: box.assets.map((t) => ({ tokenId: t.tokenId, amount: mapper(t.amount) })),
+    creationHeight: box.creationHeight,
+    additionalRegisters: box.additionalRegisters,
+    index: box.index
+  };
+}
+function mapUnconfirmedTransaction(tx, mapper) {
+  return {
+    transactionId: tx.transactionId,
+    timestamp: Number(tx.timestamp),
+    inputs: tx.inputs.map((i) => ({
+      spendingProof: {
+        // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+        extension: i.extension,
+        // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+        proofBytes: i.proofBytes
+      },
+      // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+      ...mapBox(i.box, mapper)
     })),
-    confirmed
-  });
+    dataInputs: tx.dataInputs.map((di) => ({ boxId: di.boxId })),
+    outputs: tx.outputs.map((b) => mapBox(b, mapper)),
+    confirmed: false
+  };
 }
+function mapConfirmedTransaction(tx, mapper) {
+  return {
+    transactionId: tx.transactionId,
+    timestamp: Number(tx.timestamp),
+    inputs: tx.inputs.map((i) => ({
+      spendingProof: {
+        // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+        extension: i.extension,
+        // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+        proofBytes: i.proofBytes
+      },
+      // biome-ignore lint/style/noNonNullAssertion: bad type declarations at '@ergo-graphql/type'
+      ...mapBox(i.box, mapper)
+    })),
+    dataInputs: tx.dataInputs.map((di) => ({ boxId: di.boxId })),
+    outputs: tx.outputs.map((b) => mapBox(b, mapper)),
+    height: tx.inclusionHeight,
+    headerId: tx.headerId,
+    index: tx.index,
+    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;
-//# sourceMappingURL=out.js.map
+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