@lucid-evolution/provider 0.0.1

package/dist/index.cjs

@@ -0,0 +1,838 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Blockfrost: () => Blockfrost,
+  Kupmios: () => Kupmios,
+  Maestro: () => Maestro,
+  datumJsonToCbor: () => datumJsonToCbor
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/blockfrost.ts
+var CML = __toESM(require("@dcspark/cardano-multiplatform-lib-nodejs"), 1);
+var import_core_utils = require("@lucid-evolution/core-utils");
+var import_utils = require("@lucid-evolution/utils");
+
+// package.json
+var package_default = {
+  name: "@anastasia-labs/provider",
+  version: "0.0.1",
+  description: "",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  type: "module",
+  files: [
+    "dist"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup-node src/index.ts --format esm,cjs --dts --clean",
+    clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  keywords: [],
+  author: "",
+  license: "MIT",
+  devDependencies: {
+    "@anastasia-labs/core-types": "workspace:*",
+    "@anastasia-labs/core-utils": "workspace:*",
+    "@anastasia-labs/utils": "workspace:*",
+    "@dcspark/cardano-multiplatform-lib-nodejs": "^5.1.0",
+    "@types/node": "^20.11.24",
+    tsup: "^8.0.2",
+    typescript: "^5.3.3"
+  }
+};
+
+// src/blockfrost.ts
+var Blockfrost = class {
+  url;
+  projectId;
+  constructor(url, projectId) {
+    this.url = url;
+    this.projectId = projectId || "";
+  }
+  async getProtocolParameters() {
+    const result = await fetch(`${this.url}/epochs/latest/parameters`, {
+      headers: { project_id: this.projectId, lucid }
+    }).then((res) => res.json());
+    return {
+      minFeeA: parseInt(result.min_fee_a),
+      minFeeB: parseInt(result.min_fee_b),
+      maxTxSize: parseInt(result.max_tx_size),
+      maxValSize: parseInt(result.max_val_size),
+      keyDeposit: BigInt(result.key_deposit),
+      poolDeposit: BigInt(result.pool_deposit),
+      priceMem: parseFloat(result.price_mem),
+      priceStep: parseFloat(result.price_step),
+      maxTxExMem: BigInt(result.max_tx_ex_mem),
+      maxTxExSteps: BigInt(result.max_tx_ex_steps),
+      coinsPerUtxoByte: BigInt(result.coins_per_utxo_size),
+      collateralPercentage: parseInt(result.collateral_percent),
+      maxCollateralInputs: parseInt(result.max_collateral_inputs),
+      costModels: result.cost_models
+    };
+  }
+  async getUtxos(addressOrCredential) {
+    const queryPredicate = (() => {
+      if (typeof addressOrCredential === "string")
+        return addressOrCredential;
+      const credentialBech32 = addressOrCredential.type === "Key" ? CML.Ed25519KeyHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_vkh"
+      ) : CML.ScriptHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_vkh"
+      );
+      return credentialBech32;
+    })();
+    let result = [];
+    let page = 1;
+    while (true) {
+      const pageResult = await fetch(
+        `${this.url}/addresses/${queryPredicate}/utxos?page=${page}`,
+        { headers: { project_id: this.projectId, lucid } }
+      ).then((res) => res.json());
+      if (pageResult.error) {
+        if (pageResult.status_code === 404) {
+          return [];
+        } else {
+          throw new Error("Could not fetch UTxOs from Blockfrost. Try again.");
+        }
+      }
+      result = result.concat(pageResult);
+      if (pageResult.length <= 0)
+        break;
+      page++;
+    }
+    return this.blockfrostUtxosToUtxos(result);
+  }
+  async getUtxosWithUnit(addressOrCredential, unit) {
+    const queryPredicate = (() => {
+      if (typeof addressOrCredential === "string")
+        return addressOrCredential;
+      const credentialBech32 = addressOrCredential.type === "Key" ? CML.Ed25519KeyHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_vkh"
+      ) : CML.ScriptHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_vkh"
+      );
+      return credentialBech32;
+    })();
+    let result = [];
+    let page = 1;
+    while (true) {
+      const pageResult = await fetch(
+        `${this.url}/addresses/${queryPredicate}/utxos/${unit}?page=${page}`,
+        { headers: { project_id: this.projectId, lucid } }
+      ).then((res) => res.json());
+      if (pageResult.error) {
+        if (pageResult.status_code === 404) {
+          return [];
+        } else {
+          throw new Error("Could not fetch UTxOs from Blockfrost. Try again.");
+        }
+      }
+      result = result.concat(pageResult);
+      if (pageResult.length <= 0)
+        break;
+      page++;
+    }
+    return this.blockfrostUtxosToUtxos(result);
+  }
+  async getUtxoByUnit(unit) {
+    const addresses = await fetch(
+      `${this.url}/assets/${unit}/addresses?count=2`,
+      { headers: { project_id: this.projectId, lucid } }
+    ).then((res) => res.json());
+    if (!addresses || addresses.error) {
+      throw new Error("Unit not found.");
+    }
+    if (addresses.length > 1) {
+      throw new Error("Unit needs to be an NFT or only held by one address.");
+    }
+    const address = addresses[0].address;
+    const utxos = await this.getUtxosWithUnit(address, unit);
+    if (utxos.length > 1) {
+      throw new Error("Unit needs to be an NFT or only held by one address.");
+    }
+    return utxos[0];
+  }
+  async getUtxosByOutRef(outRefs) {
+    const queryHashes = [...new Set(outRefs.map((outRef) => outRef.txHash))];
+    const utxos = await Promise.all(
+      queryHashes.map(async (txHash) => {
+        const result = await fetch(`${this.url}/txs/${txHash}/utxos`, {
+          headers: { project_id: this.projectId, lucid }
+        }).then((res) => res.json());
+        if (!result || result.error) {
+          return [];
+        }
+        const utxosResult = result.outputs.map(
+          (r) => ({
+            ...r,
+            tx_hash: txHash
+          })
+        );
+        return this.blockfrostUtxosToUtxos(utxosResult);
+      })
+    );
+    return utxos.reduce((acc, utxos2) => acc.concat(utxos2), []).filter(
+      (utxo) => outRefs.some(
+        (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
+      )
+    );
+  }
+  async getDelegation(rewardAddress) {
+    const result = await fetch(`${this.url}/accounts/${rewardAddress}`, {
+      headers: { project_id: this.projectId, lucid }
+    }).then((res) => res.json());
+    if (!result || result.error) {
+      return { poolId: null, rewards: 0n };
+    }
+    return {
+      poolId: result.pool_id || null,
+      rewards: BigInt(result.withdrawable_amount)
+    };
+  }
+  async getDatum(datumHash) {
+    const datum = await fetch(`${this.url}/scripts/datum/${datumHash}/cbor`, {
+      headers: { project_id: this.projectId, lucid }
+    }).then((res) => res.json()).then((res) => res.cbor);
+    if (!datum || datum.error) {
+      throw new Error(`No datum found for datum hash: ${datumHash}`);
+    }
+    return datum;
+  }
+  awaitTx(txHash, checkInterval = 3e3) {
+    return new Promise((res) => {
+      const confirmation = setInterval(async () => {
+        const isConfirmed = await fetch(`${this.url}/txs/${txHash}`, {
+          headers: { project_id: this.projectId, lucid }
+        }).then((res2) => res2.json());
+        if (isConfirmed && !isConfirmed.error) {
+          clearInterval(confirmation);
+          await new Promise((res2) => setTimeout(() => res2(1), 1e3));
+          return res(true);
+        }
+      }, checkInterval);
+    });
+  }
+  async submitTx(tx) {
+    const result = await fetch(`${this.url}/tx/submit`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/cbor",
+        project_id: this.projectId,
+        lucid
+      },
+      body: (0, import_core_utils.fromHex)(tx)
+    }).then((res) => res.json());
+    if (!result || result.error) {
+      if (result?.status_code === 400)
+        throw new Error(result.message);
+      else
+        throw new Error("Could not submit transaction.");
+    }
+    return result;
+  }
+  async blockfrostUtxosToUtxos(result) {
+    return await Promise.all(
+      result.map(async (r) => ({
+        txHash: r.tx_hash,
+        outputIndex: r.output_index,
+        assets: Object.fromEntries(
+          r.amount.map(({ unit, quantity }) => [unit, BigInt(quantity)])
+        ),
+        address: r.address,
+        datumHash: !r.inline_datum && r.data_hash || void 0,
+        datum: r.inline_datum || void 0,
+        scriptRef: r.reference_script_hash ? await (async () => {
+          const { type } = await fetch(
+            `${this.url}/scripts/${r.reference_script_hash}`,
+            {
+              headers: { project_id: this.projectId, lucid }
+            }
+          ).then((res) => res.json());
+          if (type === "Native" || type === "native") {
+            throw new Error("Native script ref not implemented!");
+          }
+          const { cbor: script } = await fetch(
+            `${this.url}/scripts/${r.reference_script_hash}/cbor`,
+            { headers: { project_id: this.projectId, lucid } }
+          ).then((res) => res.json());
+          return {
+            type: type === "plutusV1" ? "PlutusV1" : "PlutusV2",
+            script: (0, import_utils.applyDoubleCborEncoding)(script)
+          };
+        })() : void 0
+      }))
+    );
+  }
+};
+function datumJsonToCbor(json) {
+  const convert = (json2) => {
+    if (!isNaN(json2.int)) {
+      return CML.PlutusData.new_integer(
+        CML.BigInteger.from_str(json2.int.toString())
+      );
+    } else if (json2.bytes || !isNaN(Number(json2.bytes))) {
+      return CML.PlutusData.new_bytes((0, import_core_utils.fromHex)(json2.bytes));
+    } else if (json2.map) {
+      const m = CML.PlutusMap.new();
+      json2.map.forEach(({ k, v }) => {
+        m.set(convert(k), convert(v));
+      });
+      return CML.PlutusData.new_map(m);
+    } else if (json2.list) {
+      const l = CML.PlutusDataList.new();
+      json2.list.forEach((v) => {
+        l.add(convert(v));
+      });
+      return CML.PlutusData.new_list(l);
+    } else if (!isNaN(json2.constructor)) {
+      const l = CML.PlutusDataList.new();
+      json2.fields.forEach((v) => {
+        l.add(convert(v));
+      });
+      return CML.PlutusData.new_constr_plutus_data(
+        CML.ConstrPlutusData.new(
+          CML.BigInteger.from_str(json2.constructor.toString()).as_u64(),
+          l
+        )
+      );
+    }
+    throw new Error("Unsupported type");
+  };
+  return convert(json).to_cbor_hex();
+}
+var lucid = package_default.version;
+
+// src/kupmios.ts
+var import_utils2 = require("@lucid-evolution/utils");
+var CML2 = __toESM(require("@dcspark/cardano-multiplatform-lib-nodejs"), 1);
+var Kupmios = class {
+  kupoUrl;
+  ogmiosUrl;
+  /**
+   * @param kupoUrl: http(s)://localhost:1442
+   * @param ogmiosUrl: ws(s)://localhost:1337
+   */
+  constructor(kupoUrl, ogmiosUrl) {
+    this.kupoUrl = kupoUrl;
+    this.ogmiosUrl = ogmiosUrl;
+  }
+  async getProtocolParameters() {
+    const client = await this.ogmiosWsp("Query", {
+      query: "currentProtocolParameters"
+    });
+    return new Promise((res, rej) => {
+      client.addEventListener(
+        "message",
+        (msg) => {
+          try {
+            const { result } = JSON.parse(msg.data);
+            const costModels = {};
+            Object.keys(result.costModels).forEach((v) => {
+              const version = v.split(":")[1].toUpperCase();
+              const plutusVersion = "Plutus" + version;
+              costModels[plutusVersion] = result.costModels[v];
+            });
+            const [memNum, memDenom] = result.prices.memory.split("/");
+            const [stepsNum, stepsDenom] = result.prices.steps.split("/");
+            res({
+              minFeeA: parseInt(result.minFeeCoefficient),
+              minFeeB: parseInt(result.minFeeConstant),
+              maxTxSize: parseInt(result.maxTxSize),
+              maxValSize: parseInt(result.maxValueSize),
+              keyDeposit: BigInt(result.stakeKeyDeposit),
+              poolDeposit: BigInt(result.poolDeposit),
+              priceMem: parseInt(memNum) / parseInt(memDenom),
+              priceStep: parseInt(stepsNum) / parseInt(stepsDenom),
+              maxTxExMem: BigInt(result.maxExecutionUnitsPerTransaction.memory),
+              maxTxExSteps: BigInt(
+                result.maxExecutionUnitsPerTransaction.steps
+              ),
+              coinsPerUtxoByte: BigInt(result.coinsPerUtxoByte),
+              collateralPercentage: parseInt(result.collateralPercentage),
+              maxCollateralInputs: parseInt(result.maxCollateralInputs),
+              costModels
+            });
+            client.close();
+          } catch (e) {
+            rej(e);
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  async getUtxos(addressOrCredential) {
+    const isAddress = typeof addressOrCredential === "string";
+    const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
+    const result = await fetch(
+      `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent`
+    ).then((res) => res.json());
+    return this.kupmiosUtxosToUtxos(result);
+  }
+  async getUtxosWithUnit(addressOrCredential, unit) {
+    const isAddress = typeof addressOrCredential === "string";
+    const queryPredicate = isAddress ? addressOrCredential : addressOrCredential.hash;
+    const { policyId, assetName } = (0, import_utils2.fromUnit)(unit);
+    const result = await fetch(
+      `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&policy_id=${policyId}${assetName ? `&asset_name=${assetName}` : ""}`
+    ).then((res) => res.json());
+    return this.kupmiosUtxosToUtxos(result);
+  }
+  async getUtxoByUnit(unit) {
+    const { policyId, assetName } = (0, import_utils2.fromUnit)(unit);
+    const result = await fetch(
+      `${this.kupoUrl}/matches/${policyId}.${assetName ? `${assetName}` : "*"}?unspent`
+    ).then((res) => res.json());
+    const utxos = await this.kupmiosUtxosToUtxos(result);
+    if (utxos.length > 1) {
+      throw new Error("Unit needs to be an NFT or only held by one address.");
+    }
+    return utxos[0];
+  }
+  async getUtxosByOutRef(outRefs) {
+    const queryHashes = [...new Set(outRefs.map((outRef) => outRef.txHash))];
+    const utxos = await Promise.all(
+      queryHashes.map(async (txHash) => {
+        const result = await fetch(
+          `${this.kupoUrl}/matches/*@${txHash}?unspent`
+        ).then((res) => res.json());
+        return this.kupmiosUtxosToUtxos(result);
+      })
+    );
+    return utxos.reduce((acc, utxos2) => acc.concat(utxos2), []).filter(
+      (utxo) => outRefs.some(
+        (outRef) => utxo.txHash === outRef.txHash && utxo.outputIndex === outRef.outputIndex
+      )
+    );
+  }
+  async getDelegation(rewardAddress) {
+    const client = await this.ogmiosWsp("Query", {
+      query: { delegationsAndRewards: [rewardAddress] }
+    });
+    return new Promise((res, rej) => {
+      client.addEventListener(
+        "message",
+        (msg) => {
+          try {
+            const { result } = JSON.parse(msg.data);
+            const delegation = result ? Object.values(result)[0] : {};
+            res({
+              poolId: delegation?.delegate || null,
+              rewards: BigInt(delegation?.rewards || 0)
+            });
+            client.close();
+          } catch (e) {
+            rej(e);
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  async getDatum(datumHash) {
+    const result = await fetch(`${this.kupoUrl}/datums/${datumHash}`).then(
+      (res) => res.json()
+    );
+    if (!result || !result.datum) {
+      throw new Error(`No datum found for datum hash: ${datumHash}`);
+    }
+    return result.datum;
+  }
+  awaitTx(txHash, checkInterval = 3e3) {
+    return new Promise((res) => {
+      const confirmation = setInterval(async () => {
+        const isConfirmed = await fetch(
+          `${this.kupoUrl}/matches/*@${txHash}?unspent`
+        ).then((res2) => res2.json());
+        if (isConfirmed && isConfirmed.length > 0) {
+          clearInterval(confirmation);
+          await new Promise((res2) => setTimeout(() => res2(1), 1e3));
+          return res(true);
+        }
+      }, checkInterval);
+    });
+  }
+  async submitTx(tx) {
+    const client = await this.ogmiosWsp("SubmitTx", {
+      submit: tx
+    });
+    return new Promise((res, rej) => {
+      client.addEventListener(
+        "message",
+        (msg) => {
+          try {
+            const { result } = JSON.parse(msg.data);
+            if (result.SubmitSuccess)
+              res(result.SubmitSuccess.txId);
+            else
+              rej(result.SubmitFail);
+            client.close();
+          } catch (e) {
+            rej(e);
+          }
+        },
+        { once: true }
+      );
+    });
+  }
+  kupmiosUtxosToUtxos(utxos) {
+    return Promise.all(
+      utxos.map(async (utxo) => {
+        return {
+          txHash: utxo.transaction_id,
+          outputIndex: parseInt(utxo.output_index),
+          address: utxo.address,
+          assets: (() => {
+            const a = { lovelace: BigInt(utxo.value.coins) };
+            Object.keys(utxo.value.assets).forEach((unit) => {
+              a[unit.replace(".", "")] = BigInt(utxo.value.assets[unit]);
+            });
+            return a;
+          })(),
+          datumHash: utxo?.datum_type === "hash" ? utxo.datum_hash : null,
+          datum: utxo?.datum_type === "inline" ? await this.getDatum(utxo.datum_hash) : null,
+          scriptRef: utxo.script_hash && await (async () => {
+            const { script, language } = await fetch(
+              `${this.kupoUrl}/scripts/${utxo.script_hash}`
+            ).then((res) => res.json());
+            if (language === "native") {
+              return { type: "Native", script };
+            } else if (language === "plutus:v1") {
+              return {
+                type: "PlutusV1",
+                script: CML2.PlutusV1Script.from_cbor_hex(script).to_cbor_hex()
+              };
+            } else if (language === "plutus:v2") {
+              return {
+                type: "PlutusV2",
+                script: CML2.PlutusV2Script.from_cbor_hex(script).to_cbor_hex()
+              };
+            }
+          })()
+        };
+      })
+    );
+  }
+  async ogmiosWsp(methodname, args) {
+    const client = new WebSocket(this.ogmiosUrl);
+    await new Promise((res) => {
+      client.addEventListener("open", () => res(1), { once: true });
+    });
+    client.send(
+      JSON.stringify({
+        type: "jsonwsp/request",
+        version: "1.0",
+        servicename: "ogmios",
+        methodname,
+        args
+      })
+    );
+    return client;
+  }
+};
+
+// src/maestro.ts
+var CML3 = __toESM(require("@dcspark/cardano-multiplatform-lib-nodejs"), 1);
+var import_utils3 = require("@lucid-evolution/utils");
+var import_core_utils2 = require("@lucid-evolution/core-utils");
+var Maestro = class {
+  url;
+  apiKey;
+  turboSubmit;
+  constructor({ network, apiKey, turboSubmit = false }) {
+    this.url = `https://${network}.gomaestro-api.org/v1`;
+    this.apiKey = apiKey;
+    this.turboSubmit = turboSubmit;
+  }
+  async getProtocolParameters() {
+    const timestampedResult = await fetch(`${this.url}/protocol-params`, {
+      headers: this.commonHeaders()
+    }).then((res) => res.json());
+    const result = timestampedResult.data;
+    const decimalFromRationalString = (str) => {
+      const forwardSlashIndex = str.indexOf("/");
+      return parseInt(str.slice(0, forwardSlashIndex)) / parseInt(str.slice(forwardSlashIndex + 1));
+    };
+    const renameKeysAndSort = (obj, newKeys) => {
+      const entries = Object.keys(obj).sort().map((key) => {
+        const newKey = newKeys[key] || key;
+        return {
+          [newKey]: Object.fromEntries(
+            Object.entries(obj[key]).sort(
+              ([k, _v], [k2, _v2]) => k.localeCompare(k2)
+            )
+          )
+        };
+      });
+      return Object.assign({}, ...entries);
+    };
+    return {
+      minFeeA: parseInt(result.min_fee_coefficient),
+      minFeeB: parseInt(result.min_fee_constant),
+      maxTxSize: parseInt(result.max_tx_size),
+      maxValSize: parseInt(result.max_value_size),
+      keyDeposit: BigInt(result.stake_key_deposit),
+      poolDeposit: BigInt(result.pool_deposit),
+      priceMem: decimalFromRationalString(result.prices.memory),
+      priceStep: decimalFromRationalString(result.prices.steps),
+      maxTxExMem: BigInt(result.max_execution_units_per_transaction.memory),
+      maxTxExSteps: BigInt(result.max_execution_units_per_transaction.steps),
+      coinsPerUtxoByte: BigInt(result.coins_per_utxo_byte),
+      collateralPercentage: parseInt(result.collateral_percentage),
+      maxCollateralInputs: parseInt(result.max_collateral_inputs),
+      costModels: renameKeysAndSort(result.cost_models, {
+        "plutus:v1": "PlutusV1",
+        "plutus:v2": "PlutusV2"
+      })
+    };
+  }
+  async getUtxosInternal(addressOrCredential, unit) {
+    const queryPredicate = (() => {
+      if (typeof addressOrCredential === "string") {
+        return "/addresses/" + addressOrCredential;
+      }
+      let credentialBech32Query = "/addresses/cred/";
+      credentialBech32Query += addressOrCredential.type === "Key" ? CML3.Ed25519KeyHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_vkh"
+      ) : CML3.ScriptHash.from_hex(addressOrCredential.hash).to_bech32(
+        "addr_shared_vkh"
+      );
+      return credentialBech32Query;
+    })();
+    const qparams = new URLSearchParams({
+      count: "100",
+      ...unit && { asset: unit }
+    });
+    const result = await this.getAllPagesData(
+      async (qry) => await fetch(qry, {
+        headers: this.requireAmountsAsStrings(this.commonHeaders())
+      }),
+      `${this.url}${queryPredicate}/utxos`,
+      qparams,
+      "Location: getUtxosInternal. Error: Could not fetch UTxOs from Maestro"
+    );
+    return result.map(this.maestroUtxoToUtxo);
+  }
+  getUtxos(addressOrCredential) {
+    return this.getUtxosInternal(addressOrCredential);
+  }
+  getUtxosWithUnit(addressOrCredential, unit) {
+    return this.getUtxosInternal(addressOrCredential, unit);
+  }
+  async getUtxoByUnit(unit) {
+    const timestampedAddressesResponse = await fetch(
+      `${this.url}/assets/${unit}/addresses?count=2`,
+      { headers: this.commonHeaders() }
+    );
+    const timestampedAddresses = await timestampedAddressesResponse.json();
+    if (!timestampedAddressesResponse.ok) {
+      if (timestampedAddresses.message) {
+        throw new Error(timestampedAddresses.message);
+      }
+      throw new Error(
+        "Location: getUtxoByUnit. Error: Couldn't perform query. Received status code: " + timestampedAddressesResponse.status
+      );
+    }
+    const addressesWithAmount = timestampedAddresses.data;
+    if (addressesWithAmount.length === 0) {
+      throw new Error("Location: getUtxoByUnit. Error: Unit not found.");
+    }
+    if (addressesWithAmount.length > 1) {
+      throw new Error(
+        "Location: getUtxoByUnit. Error: Unit needs to be an NFT or only held by one address."
+      );
+    }
+    const address = addressesWithAmount[0].address;
+    const utxos = await this.getUtxosWithUnit(address, unit);
+    if (utxos.length > 1) {
+      throw new Error(
+        "Location: getUtxoByUnit. Error: Unit needs to be an NFT or only held by one address."
+      );
+    }
+    return utxos[0];
+  }
+  async getUtxosByOutRef(outRefs) {
+    const qry = `${this.url}/transactions/outputs`;
+    const body = JSON.stringify(
+      outRefs.map(({ txHash, outputIndex }) => `${txHash}#${outputIndex}`)
+    );
+    const utxos = await this.getAllPagesData(
+      async (qry2) => await fetch(qry2, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.requireAmountsAsStrings(this.commonHeaders())
+        },
+        body
+      }),
+      qry,
+      new URLSearchParams({}),
+      "Location: getUtxosByOutRef. Error: Could not fetch UTxOs by references from Maestro"
+    );
+    return utxos.map(this.maestroUtxoToUtxo);
+  }
+  async getDelegation(rewardAddress) {
+    const timestampedResultResponse = await fetch(
+      `${this.url}/accounts/${rewardAddress}`,
+      { headers: this.commonHeaders() }
+    );
+    if (!timestampedResultResponse.ok) {
+      return { poolId: null, rewards: 0n };
+    }
+    const timestampedResult = await timestampedResultResponse.json();
+    const result = timestampedResult.data;
+    return {
+      poolId: result.delegated_pool || null,
+      rewards: BigInt(result.rewards_available)
+    };
+  }
+  async getDatum(datumHash) {
+    const timestampedResultResponse = await fetch(
+      `${this.url}/datums/${datumHash}`,
+      {
+        headers: this.commonHeaders()
+      }
+    );
+    if (!timestampedResultResponse.ok) {
+      if (timestampedResultResponse.status === 404) {
+        throw new Error(`No datum found for datum hash: ${datumHash}`);
+      } else {
+        throw new Error(
+          "Location: getDatum. Error: Couldn't successfully perform query. Received status code: " + timestampedResultResponse.status
+        );
+      }
+    }
+    const timestampedResult = await timestampedResultResponse.json();
+    return timestampedResult.data.bytes;
+  }
+  awaitTx(txHash, checkInterval = 3e3) {
+    return new Promise((res) => {
+      const confirmation = setInterval(async () => {
+        const isConfirmedResponse = await fetch(
+          `${this.url}/transactions/${txHash}/cbor`,
+          {
+            headers: this.commonHeaders()
+          }
+        );
+        if (isConfirmedResponse.ok) {
+          await isConfirmedResponse.json();
+          clearInterval(confirmation);
+          await new Promise((res2) => setTimeout(() => res2(1), 1e3));
+          return res(true);
+        }
+      }, checkInterval);
+    });
+  }
+  async submitTx(tx) {
+    let queryUrl = `${this.url}/txmanager`;
+    queryUrl += this.turboSubmit ? "/turbosubmit" : "";
+    const response = await fetch(queryUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/cbor",
+        Accept: "text/plain",
+        ...this.commonHeaders()
+      },
+      body: (0, import_core_utils2.fromHex)(tx)
+    });
+    const result = await response.text();
+    if (!response.ok) {
+      if (response.status === 400)
+        throw new Error(result);
+      else {
+        throw new Error(
+          "Could not submit transaction. Received status code: " + response.status
+        );
+      }
+    }
+    return result;
+  }
+  commonHeaders() {
+    return { "api-key": this.apiKey, lucid: lucid2 };
+  }
+  requireAmountsAsStrings(obj) {
+    return { ...obj, "amounts-as-strings": "true" };
+  }
+  maestroUtxoToUtxo(result) {
+    return {
+      txHash: result.tx_hash,
+      outputIndex: result.index,
+      assets: (() => {
+        const a = {};
+        result.assets.forEach((am) => {
+          a[am.unit] = BigInt(am.amount);
+        });
+        return a;
+      })(),
+      address: result.address,
+      datumHash: result.datum ? result.datum.type == "inline" ? void 0 : result.datum.hash : void 0,
+      datum: result.datum?.bytes,
+      scriptRef: result.reference_script ? result.reference_script.type == "native" ? void 0 : {
+        type: result.reference_script.type == "plutusv1" ? "PlutusV1" : "PlutusV2",
+        script: (0, import_utils3.applyDoubleCborEncoding)(result.reference_script.bytes)
+      } : void 0
+    };
+  }
+  async getAllPagesData(getResponse, qry, paramsGiven, errorMsg) {
+    let nextCursor = null;
+    let result = [];
+    while (true) {
+      if (nextCursor !== null) {
+        paramsGiven.set("cursor", nextCursor);
+      }
+      const response = await getResponse(`${qry}?` + paramsGiven);
+      const pageResult = await response.json();
+      if (!response.ok) {
+        throw new Error(
+          `${errorMsg}. Received status code: ${response.status}`
+        );
+      }
+      nextCursor = pageResult.next_cursor;
+      result = result.concat(pageResult.data);
+      if (nextCursor == null)
+        break;
+    }
+    return result;
+  }
+};
+var lucid2 = package_default.version;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Blockfrost,
+  Kupmios,
+  Maestro,
+  datumJsonToCbor
+});