@lucid-evolution/provider 0.2.6 → 0.4.0

package/dist/index.cjs

@@ -36,7 +36,6 @@ __export(index_exports, {
   KoiosError: () => KoiosError,
   Kupmios: () => Kupmios,
   KupmiosError: () => KupmiosError,
-  Maestro: () => Maestro,
   OgmiosJsonRpcError: () => OgmiosJsonRpcError,
   generateEmulatorAccount: () => generateEmulatorAccount,
   generateEmulatorAccountFromPrivateKey: () => generateEmulatorAccountFromPrivateKey,
@@ -135,7 +134,7 @@ var OgmiosJsonRpcError = class extends KupmiosError {
 var toKupmiosError = (cause, protocol, operation) => cause instanceof KupmiosError ? cause : new KupmiosError({ cause, protocol, operation });
 
 // src/core.ts
-var CML = __toESM(require("@anastasia-labs/cardano-multiplatform-lib-nodejs"), 1);
+var CML = __toESM(require("@lucid-evolution/cml"), 1);
 
 // src/blockfrost.ts
 var import_core_utils = require("@lucid-evolution/core-utils");
@@ -144,7 +143,7 @@ var import_utils2 = require("@lucid-evolution/utils");
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.2.6",
+  version: "0.4.0",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -170,14 +169,10 @@ var package_default = {
   keywords: [],
   author: "",
   license: "MIT",
-  browser: {
-    "@anastasia-labs/cardano-multiplatform-lib-nodejs": "@anastasia-labs/cardano-multiplatform-lib-browser"
-  },
   dependencies: {
-    "@anastasia-labs/cardano-multiplatform-lib-browser": "6.2.0-1",
-    "@anastasia-labs/cardano-multiplatform-lib-nodejs": "6.2.0-1",
     "@effect/platform": "^0.71.3",
     "@effect/schema": "^0.68.26",
+    "@lucid-evolution/cml": "workspace:*",
     "@lucid-evolution/core-types": "workspace:*",
     "@lucid-evolution/core-utils": "workspace:*",
     "@lucid-evolution/utils": "workspace:*",
@@ -1067,6 +1062,7 @@ var Kupmios = class {
   options;
   requestTimeoutMs;
   awaitTxTimeoutMs;
+  httpLayer;
   constructor(kupoUrl, ogmiosUrl, options = {}) {
     this.kupoUrl = kupoUrl;
     this.ogmiosUrl = ogmiosUrl;
@@ -1079,6 +1075,10 @@ var Kupmios = class {
       "awaitTxTimeoutMs",
       options.awaitTxTimeoutMs ?? DEFAULT_AWAIT_TX_TIMEOUT_MS
     );
+    this.httpLayer = options.fetchImpl === void 0 ? import_platform2.FetchHttpClient.layer : import_effect6.Layer.provide(
+      import_platform2.FetchHttpClient.layer,
+      import_effect6.Layer.succeed(import_platform2.FetchHttpClient.Fetch, options.fetchImpl)
+    );
   }
   async getProtocolParameters() {
     const data = {
@@ -1100,7 +1100,7 @@ var Kupmios = class {
         ),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/protocolParameters"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/protocolParameters"
@@ -1135,7 +1135,7 @@ var Kupmios = class {
         ),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/treasuryAndReserves"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/treasuryAndReserves"
@@ -1158,7 +1158,7 @@ var Kupmios = class {
         import_effect6.Effect.map(kupmiosUtxosToUtxos),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxos"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxos"
@@ -1177,7 +1177,7 @@ var Kupmios = class {
         import_effect6.Effect.map(kupmiosUtxosToUtxos),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithUnit"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithUnit"
@@ -1201,7 +1201,7 @@ var Kupmios = class {
         import_effect6.Effect.map(kupmiosUtxosToUtxos),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithPolicy"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithPolicy"
@@ -1217,7 +1217,7 @@ var Kupmios = class {
         import_effect6.Effect.map(kupmiosUtxosToUtxos),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxoByUnit"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxoByUnit"
@@ -1246,7 +1246,7 @@ var Kupmios = class {
       )
     );
     const utxos = await runProviderEffect(
-      (0, import_effect6.pipe)(program, import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)),
+      (0, import_effect6.pipe)(program, import_effect6.Effect.provide(this.httpLayer)),
       "kupo",
       "getUtxosByOutRef"
     );
@@ -1272,7 +1272,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+        import_effect6.Effect.provide(this.httpLayer),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/rewardAccountSummaries")
       ),
@@ -1296,7 +1296,7 @@ var Kupmios = class {
     const result = await runProviderEffect(
       (0, import_effect6.pipe)(
         makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+        import_effect6.Effect.provide(this.httpLayer),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         import_effect6.Effect.flatMap(import_effect6.Effect.fromNullable),
         catchProviderError("kupo", "getDatum")
@@ -1316,7 +1316,7 @@ var Kupmios = class {
         makeGet(pattern, schema, this.options.kupoHeader),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getTransactionStatus"),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer)
+        import_effect6.Effect.provide(this.httpLayer)
       ),
       "kupo",
       "getTransactionStatus",
@@ -1342,7 +1342,7 @@ var Kupmios = class {
     const result = await runProviderEffect(
       (0, import_effect6.pipe)(
         makeGet(pattern, schema, this.options.kupoHeader),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+        import_effect6.Effect.provide(this.httpLayer),
         import_effect6.Effect.repeat({
           schedule: import_effect6.Schedule.exponential(checkInterval),
           until: (result2) => result2.length > 0
@@ -1380,7 +1380,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+        import_effect6.Effect.provide(this.httpLayer),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "submitTransaction")
       ),
@@ -1413,7 +1413,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        import_effect6.Effect.provide(import_platform2.FetchHttpClient.layer),
+        import_effect6.Effect.provide(this.httpLayer),
         import_effect6.Effect.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "evaluateTransaction")
       ),
@@ -1519,10 +1519,206 @@ var kupmiosUtxosToUtxos = (utxos) => utxos.map((utxo) => ({
 }));
 
 // src/emulator.ts
-var import_utils5 = require("@lucid-evolution/utils");
 var import_utils6 = require("@lucid-evolution/utils");
+var import_utils7 = require("@lucid-evolution/utils");
 var import_core_utils2 = require("@lucid-evolution/core-utils");
 var import_wallet = require("@lucid-evolution/wallet");
+
+// src/internal/emulator-ledger.ts
+var import_utils5 = require("@lucid-evolution/utils");
+var isUnorderedKey = (key) => {
+  if (key === "__proto__") return true;
+  if (key.length > 10) return false;
+  const index = Number(key);
+  return Number.isInteger(index) && index < 2 ** 32 - 1 && String(index) === key;
+};
+var EmulatorLedger = class {
+  #record = {};
+  #exposed = false;
+  /** Record keys in record order; `undefined` marks a deleted slot. */
+  #keys = [];
+  /** Record entries, parallel to `#keys`. */
+  #entries = [];
+  #slots = /* @__PURE__ */ new Map();
+  #holes = 0;
+  /** Per slot, the address whose payment hash `#slotHashes` holds. */
+  #slotHashAddresses = [];
+  #slotHashes = [];
+  #paymentHashes = /* @__PURE__ */ new Map();
+  /** The record, for internal reads that do not let it escape. */
+  get record() {
+    return this.#record;
+  }
+  /** Returns the record to a caller, who may then change it at any time. */
+  expose() {
+    this.#dropMirror();
+    return this.#record;
+  }
+  /** Adopts a record supplied by a caller. */
+  replace(record) {
+    this.#record = record;
+    this.#dropMirror();
+  }
+  get(outRef) {
+    return this.#record[outRef];
+  }
+  set(outRef, entry) {
+    this.#record[outRef] = entry;
+    if (this.#exposed) return;
+    if (isUnorderedKey(outRef)) {
+      this.#dropMirror();
+      return;
+    }
+    const slot = this.#slots.get(outRef);
+    if (slot === void 0) {
+      this.#slots.set(outRef, this.#keys.length);
+      this.#keys.push(outRef);
+      this.#entries.push(entry);
+      this.#slotHashAddresses.push(void 0);
+      this.#slotHashes.push(void 0);
+    } else {
+      this.#entries[slot] = entry;
+    }
+  }
+  /**
+   * Moves the mempool into the record, then deletes every entry marked
+   * spent, as the emulator always has.
+   */
+  applyMempool(mempool) {
+    for (const [outRef, { utxo, spent }] of Object.entries(mempool)) {
+      this.set(outRef, { utxo, spent });
+    }
+    const record = this.#record;
+    if (this.#exposed) {
+      for (const [outRef, { spent }] of Object.entries(record)) {
+        if (spent) delete record[outRef];
+      }
+      return;
+    }
+    const keys = this.#keys;
+    const entries = this.#entries;
+    for (let slot = 0; slot < entries.length; slot++) {
+      const entry = entries[slot];
+      if (entry === void 0 || !entry.spent) continue;
+      const outRef = keys[slot];
+      delete record[outRef];
+      this.#slots.delete(outRef);
+      keys[slot] = void 0;
+      entries[slot] = void 0;
+      this.#holes++;
+    }
+    if (this.#holes > 64 && this.#holes * 2 > entries.length) this.#compact();
+  }
+  /**
+   * Unspent UTxOs at an address or payment credential, optionally holding
+   * `unit`, in record order.
+   */
+  utxosAt(addressOrCredential, unit) {
+    const utxos = [];
+    const entries = this.#inOrder();
+    if (typeof addressOrCredential === "string") {
+      for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        if (entry === void 0 && !this.#exposed) continue;
+        const { utxo, spent } = entry;
+        if (!spent && utxo.address === addressOrCredential && (unit === void 0 || utxo.assets[unit] > 0n)) {
+          utxos.push(utxo);
+        }
+      }
+      return utxos;
+    }
+    const hash = addressOrCredential.hash;
+    const hashAddresses = this.#slotHashAddresses;
+    const hashes = this.#slotHashes;
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry === void 0 && !this.#exposed) continue;
+      const { utxo, spent } = entry;
+      if (spent) continue;
+      const address = utxo.address;
+      let paymentHash;
+      if (this.#exposed) {
+        paymentHash = this.#paymentHashOf(address);
+      } else if (hashAddresses[i] === address) {
+        paymentHash = hashes[i];
+      } else {
+        paymentHash = this.#paymentHashOf(address);
+        hashAddresses[i] = address;
+        hashes[i] = paymentHash;
+      }
+      if (paymentHash === hash && (unit === void 0 || utxo.assets[unit] > 0n)) {
+        utxos.push(utxo);
+      }
+    }
+    return utxos;
+  }
+  /** Unspent UTxOs holding `unit`, in record order. */
+  utxosWithUnit(unit) {
+    const utxos = [];
+    const entries = this.#inOrder();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry === void 0 && !this.#exposed) continue;
+      const { utxo, spent } = entry;
+      if (!spent && utxo.assets[unit] > 0n) utxos.push(utxo);
+    }
+    return utxos;
+  }
+  /**
+   * The record's entries in record order. From the mirror, deleted slots
+   * are `undefined`; from an exposed record, every value is as stored, so a
+   * malformed entry fails a query just as a scan of the record would.
+   */
+  #inOrder() {
+    if (!this.#exposed) return this.#entries;
+    const record = this.#record;
+    const keys = Object.keys(record);
+    const entries = new Array(keys.length);
+    for (let i = 0; i < keys.length; i++) entries[i] = record[keys[i]];
+    return entries;
+  }
+  /** Payment credential hash of an address; parse errors propagate. */
+  #paymentHashOf(address) {
+    if (this.#paymentHashes.has(address))
+      return this.#paymentHashes.get(address);
+    const hash = (0, import_utils5.getAddressDetails)(address).paymentCredential?.hash;
+    this.#paymentHashes.set(address, hash);
+    return hash;
+  }
+  #compact() {
+    const keys = [];
+    const entries = [];
+    const hashAddresses = [];
+    const hashes = [];
+    this.#slots.clear();
+    for (let slot = 0; slot < this.#entries.length; slot++) {
+      const entry = this.#entries[slot];
+      if (entry === void 0) continue;
+      const outRef = this.#keys[slot];
+      this.#slots.set(outRef, keys.length);
+      keys.push(outRef);
+      entries.push(entry);
+      hashAddresses.push(this.#slotHashAddresses[slot]);
+      hashes.push(this.#slotHashes[slot]);
+    }
+    this.#keys = keys;
+    this.#entries = entries;
+    this.#slotHashAddresses = hashAddresses;
+    this.#slotHashes = hashes;
+    this.#holes = 0;
+  }
+  #dropMirror() {
+    this.#exposed = true;
+    this.#keys = [];
+    this.#entries = [];
+    this.#slots.clear();
+    this.#slotHashAddresses = [];
+    this.#slotHashes = [];
+    this.#holes = 0;
+  }
+};
+
+// src/emulator.ts
 var EMULATOR_PROVIDER_BRAND = Symbol.for(
   "@lucid-evolution/provider/Emulator"
 );
@@ -1545,7 +1741,7 @@ function generateEmulatorAccountFromPrivateKey(assets) {
   };
 }
 function generateEmulatorAccount(assets) {
-  const seedPhrase = (0, import_utils5.generateSeedPhrase)();
+  const seedPhrase = (0, import_utils6.generateSeedPhrase)();
   return {
     seedPhrase,
     address: (0, import_wallet.walletFromSeed)(seedPhrase, {
@@ -1560,7 +1756,13 @@ function generateEmulatorAccount(assets) {
 var DEFAULT_PROTOCOL_MAJOR_VERSION = 11;
 var Emulator = class {
   [EMULATOR_PROVIDER_BRAND] = true;
-  ledger;
+  #confirmed = new EmulatorLedger();
+  #ledgerProperty = Object.defineProperty(this, "ledger", {
+    configurable: true,
+    enumerable: true,
+    get: () => this.#confirmed.expose(),
+    set: (entries) => this.#confirmed.replace(entries)
+  });
   mempool = {};
   /**
    * Only stake key registrations/delegations and rewards are tracked.
@@ -1573,13 +1775,37 @@ var Emulator = class {
   protocolParameters;
   datumTable = {};
   treasury;
-  transactionHistory = {};
-  constructor(accounts, protocolParameters = import_utils5.PROTOCOL_PARAMETERS_DEFAULT, treasury = 0n) {
+  #history = {};
+  /** Whether a caller holds `transactionHistory`, and may edit it. */
+  #historyExposed = false;
+  #historyProperty = Object.defineProperty(this, "transactionHistory", {
+    configurable: true,
+    enumerable: true,
+    get: () => {
+      this.#historyExposed = true;
+      return this.#history;
+    },
+    set: (history) => {
+      this.#historyExposed = true;
+      this.#history = history;
+    }
+  });
+  /**
+   * Transactions submitted since the last block. While no caller holds
+   * `transactionHistory`, these are its only pending entries.
+   */
+  #pendingTxHashes = [];
+  /**
+   * Script hashes of reference scripts, keyed by type and CBOR. A plain Map
+   * keyed by long script text puts every script of the same length in one
+   * hash bucket; `ScriptCache` keys a fingerprint and is bounded.
+   */
+  #scriptRefHashes = new import_utils7.ScriptCache(4096, 64 * 1024 * 1024);
+  constructor(accounts, protocolParameters = import_utils6.PROTOCOL_PARAMETERS_DEFAULT, treasury = 0n) {
     const GENESIS_HASH = "00".repeat(32);
     this.blockHeight = 0;
     this.slot = 0;
     this.time = Date.now();
-    this.ledger = {};
     accounts.forEach(({ address, assets, outputData }, index) => {
       if ([outputData?.hash, outputData?.asHash, outputData?.inline].filter(
         (b) => b
@@ -1588,7 +1814,7 @@ var Emulator = class {
           "Not allowed to set hash, asHash and inline at the same time."
         );
       }
-      this.ledger[GENESIS_HASH + index] = {
+      this.#confirmed.set(GENESIS_HASH + index, {
         utxo: {
           txHash: GENESIS_HASH,
           outputIndex: index,
@@ -1601,7 +1827,7 @@ var Emulator = class {
           scriptRef: outputData?.scriptRef
         },
         spent: false
-      };
+      });
     });
     this.protocolParameters = protocolParameters;
     this.treasury = treasury;
@@ -1609,16 +1835,28 @@ var Emulator = class {
   now() {
     return this.time;
   }
+  /** Confirms every pending transaction in `transactionHistory`. */
   confirmPendingTransactions(blockHeight, slot) {
-    for (const [txHash, status] of Object.entries(this.transactionHistory)) {
-      if (status.status === "pending") {
-        this.transactionHistory[txHash] = {
-          status: "confirmed",
-          blockHeight,
-          slot
-        };
+    const history = this.#history;
+    if (this.#historyExposed) {
+      for (const [txHash, { status }] of Object.entries(history)) {
+        if (status === "pending") {
+          history[txHash] = { status: "confirmed", blockHeight, slot };
+        }
+      }
+    } else {
+      for (const txHash of this.#pendingTxHashes) {
+        if (history[txHash].status === "pending") {
+          history[txHash] = { status: "confirmed", blockHeight, slot };
+        }
       }
     }
+    this.#pendingTxHashes = [];
+  }
+  /** Moves the mempool into the ledger and drops spent entries. */
+  applyMempool() {
+    this.#confirmed.applyMempool(this.mempool);
+    this.mempool = {};
   }
   awaitSlot(length = 1) {
     this.slot += length;
@@ -1630,13 +1868,7 @@ var Emulator = class {
         currentHeight + 1,
         (currentHeight + 1) * 20
       );
-      for (const [outRef, { utxo, spent }] of Object.entries(this.mempool)) {
-        this.ledger[outRef] = { utxo, spent };
-      }
-      for (const [outRef, { spent }] of Object.entries(this.ledger)) {
-        if (spent) delete this.ledger[outRef];
-      }
-      this.mempool = {};
+      this.applyMempool();
     }
   }
   awaitBlock(height = 1) {
@@ -1648,27 +1880,10 @@ var Emulator = class {
     if (height > 0) {
       this.confirmPendingTransactions(previousHeight + 1, previousSlot + 20);
     }
-    for (const [outRef, { utxo, spent }] of Object.entries(this.mempool)) {
-      this.ledger[outRef] = { utxo, spent };
-    }
-    for (const [outRef, { spent }] of Object.entries(this.ledger)) {
-      if (spent) delete this.ledger[outRef];
-    }
-    this.mempool = {};
+    this.applyMempool();
   }
   getUtxos(addressOrCredential) {
-    const utxos = Object.values(this.ledger).flatMap(
-      ({ utxo, spent }) => {
-        if (spent) return [];
-        if (typeof addressOrCredential === "string") {
-          return addressOrCredential === utxo.address ? utxo : [];
-        } else {
-          const { paymentCredential } = (0, import_utils6.getAddressDetails)(utxo.address);
-          return paymentCredential?.hash === addressOrCredential.hash ? utxo : [];
-        }
-      }
-    );
-    return Promise.resolve(utxos);
+    return Promise.resolve(this.#confirmed.utxosAt(addressOrCredential));
   }
   getProtocolParameters() {
     return Promise.resolve(this.protocolParameters);
@@ -1680,31 +1895,18 @@ var Emulator = class {
     return Promise.resolve(this.datumTable[datumHash]);
   }
   getUtxosWithUnit(addressOrCredential, unit) {
-    const utxos = Object.values(this.ledger).flatMap(
-      ({ utxo, spent }) => {
-        if (spent) return [];
-        if (typeof addressOrCredential === "string") {
-          return addressOrCredential === utxo.address && utxo.assets[unit] > 0n ? utxo : [];
-        } else {
-          const { paymentCredential } = (0, import_utils6.getAddressDetails)(utxo.address);
-          return paymentCredential?.hash === addressOrCredential.hash && utxo.assets[unit] > 0n ? utxo : [];
-        }
-      }
-    );
-    return Promise.resolve(utxos);
+    return Promise.resolve(this.#confirmed.utxosAt(addressOrCredential, unit));
   }
   getUtxosByOutRef(outRefs) {
     return Promise.resolve(
       outRefs.flatMap((outRef) => {
-        const entry = this.ledger[outRef.txHash + outRef.outputIndex];
+        const entry = this.#confirmed.get(outRef.txHash + outRef.outputIndex);
         return entry && !entry.spent ? entry.utxo : [];
       })
     );
   }
   getUtxoByUnit(unit) {
-    const utxos = Object.values(this.ledger).flatMap(
-      ({ utxo, spent }) => !spent && utxo.assets[unit] > 0n ? utxo : []
-    );
+    const utxos = this.#confirmed.utxosWithUnit(unit);
     if (utxos.length > 1) {
       throw new Error("Unit needs to be an NFT or only held by one address.");
     }
@@ -1725,7 +1927,7 @@ var Emulator = class {
     });
   }
   awaitTx(txHash) {
-    if (this.transactionHistory[txHash]?.status === "pending") {
+    if (this.#history[txHash]?.status === "pending") {
       this.awaitBlock();
       return Promise.resolve(true);
     }
@@ -1737,7 +1939,7 @@ var Emulator = class {
         options.signal.reason instanceof Error ? options.signal.reason : new DOMException("The operation was aborted.", "AbortError")
       );
     }
-    const status = this.transactionHistory[txHash];
+    const status = this.#history[txHash];
     if (!status) return Promise.resolve({ status: "not_found", txHash });
     if (status.status === "pending") {
       return Promise.resolve({ status: "pending", txHash });
@@ -1775,10 +1977,14 @@ var Emulator = class {
     this.awaitBlock();
   }
   submitTx(tx) {
-    const desTx = CML.Transaction.from_cbor_hex(tx);
-    const body = desTx.body();
-    const witnesses = desTx.witness_set();
-    const datums = witnesses.plutus_datums();
+    return (0, import_core_utils2.withCMLScope)((own) => Promise.resolve(this.applyTx(tx, own)));
+  }
+  /** Validates `tx` and applies it to the mempool; returns its hash. */
+  applyTx(tx, own) {
+    const desTx = own(CML.Transaction.from_cbor_hex(tx));
+    const body = own(desTx.body());
+    const witnesses = own(desTx.witness_set());
+    const datums = own(witnesses.plutus_datums());
     const txHash = CML.hash_transaction(body).to_hex();
     const lowerBound = body.validity_interval_start() ? parseInt(body.validity_interval_start().toString()) : null;
     const upperBound = body.ttl() ? parseInt(body.ttl().toString()) : null;
@@ -1812,24 +2018,24 @@ var Emulator = class {
     const datumTable = (() => {
       const table = {};
       for (let i = 0; i < (datums?.len() || 0); i++) {
-        (0, import_core_utils2.withCMLScope)((own) => {
-          const datum = own(datums.get(i));
-          const datumHash = own(CML.hash_plutus_data(datum)).to_hex();
+        (0, import_core_utils2.withCMLScope)((own2) => {
+          const datum = own2(datums.get(i));
+          const datumHash = own2(CML.hash_plutus_data(datum)).to_hex();
           table[datumHash] = datum.to_cbor_hex();
         });
       }
       return table;
     })();
     const consumedHashes = /* @__PURE__ */ new Set();
-    const keyHashes = (0, import_core_utils2.withCMLScope)((own) => {
+    const keyHashList = (0, import_core_utils2.withCMLScope)((own2) => {
       const keyHashes2 = [];
-      const vkeyWitnesses = own(witnesses.vkeywitnesses());
+      const vkeyWitnesses = own2(witnesses.vkeywitnesses());
       for (let i = 0; i < (vkeyWitnesses?.len() || 0); i++) {
-        (0, import_core_utils2.withCMLScope)((own2) => {
-          const witness = own2(vkeyWitnesses.get(i));
-          const publicKey = own2(witness.vkey());
-          const keyHash = own2(publicKey.hash()).to_hex();
-          if (!publicKey.verify((0, import_core_utils2.fromHex)(txHash), own2(witness.ed25519_signature()))) {
+        (0, import_core_utils2.withCMLScope)((own3) => {
+          const witness = own3(vkeyWitnesses.get(i));
+          const publicKey = own3(witness.vkey());
+          const keyHash = own3(publicKey.hash()).to_hex();
+          if (!publicKey.verify((0, import_core_utils2.fromHex)(txHash), own3(witness.ed25519_signature()))) {
             throw new Error(`Invalid vkey witness. Key hash: ${keyHash}`);
           }
           keyHashes2.push(keyHash);
@@ -1837,19 +2043,20 @@ var Emulator = class {
       }
       return keyHashes2;
     });
-    const edKeyHashes = CML.Ed25519KeyHashList.new();
-    keyHashes.forEach(
+    const keyHashes = new Set(keyHashList);
+    const edKeyHashes = own(CML.Ed25519KeyHashList.new());
+    keyHashList.forEach(
       (keyHash) => (0, import_core_utils2.withCMLScope)(
-        (own) => edKeyHashes.add(own(CML.Ed25519KeyHash.from_hex(keyHash)))
+        (own2) => edKeyHashes.add(own2(CML.Ed25519KeyHash.from_hex(keyHash)))
       )
     );
-    const nativeHashes = (0, import_core_utils2.withCMLScope)((own) => {
+    const nativeHashList = (0, import_core_utils2.withCMLScope)((own2) => {
       const scriptHashes = [];
-      const nativeScripts = own(witnesses.native_scripts());
+      const nativeScripts = own2(witnesses.native_scripts());
       for (let i = 0; i < (nativeScripts?.len() || 0); i++) {
-        (0, import_core_utils2.withCMLScope)((own2) => {
-          const witness = own2(nativeScripts.get(i));
-          const scriptHash = own2(witness.hash()).to_hex();
+        (0, import_core_utils2.withCMLScope)((own3) => {
+          const witness = own3(nativeScripts.get(i));
+          const scriptHash = own3(witness.hash()).to_hex();
           if (!witness.verify(
             Number.isInteger(lowerBound) ? BigInt(lowerBound) : void 0,
             Number.isInteger(upperBound) ? BigInt(upperBound) : void 0,
@@ -1859,9 +2066,9 @@ var Emulator = class {
               `Invalid native script witness. Script hash: ${scriptHash}`
             );
           }
-          const requiredSigners = own2(witness.get_required_signers());
-          for (let j = 0; j < requiredSigners.len(); j++) {
-            const keyHash = own2(requiredSigners.get(j)).to_hex();
+          const requiredSigners2 = own3(witness.get_required_signers());
+          for (let j = 0; j < requiredSigners2.len(); j++) {
+            const keyHash = own3(requiredSigners2.get(j)).to_hex();
             consumedHashes.add(keyHash);
           }
           scriptHashes.push(scriptHash);
@@ -1869,18 +2076,18 @@ var Emulator = class {
       }
       return scriptHashes;
     });
-    edKeyHashes.free();
+    const nativeHashes = new Set(nativeHashList);
     const nativeHashesOptional = {};
-    const plutusHashesOptional = [];
+    const plutusHashesOptional = /* @__PURE__ */ new Set();
     const plutusV3Hashes = /* @__PURE__ */ new Set();
-    const plutusHashes = (0, import_core_utils2.withCMLScope)((own) => {
+    const plutusHashList = (0, import_core_utils2.withCMLScope)((own2) => {
       const scriptHashes = [];
       const collectHashes = (scripts, isPlutusV3 = false) => {
-        own(scripts);
+        own2(scripts);
         for (let i = 0; i < (scripts?.len() || 0); i++) {
-          (0, import_core_utils2.withCMLScope)((own2) => {
-            const script = own2(scripts.get(i));
-            const scriptHash = own2(script.hash()).to_hex();
+          (0, import_core_utils2.withCMLScope)((own3) => {
+            const script = own3(scripts.get(i));
+            const scriptHash = own3(script.hash()).to_hex();
             scriptHashes.push(scriptHash);
             if (isPlutusV3) plutusV3Hashes.add(scriptHash);
           });
@@ -1891,16 +2098,26 @@ var Emulator = class {
       collectHashes(witnesses.plutus_v3_scripts(), true);
       return scriptHashes;
     });
-    const inputs = body.inputs();
+    const plutusHashes = new Set(plutusHashList);
+    const collectScriptRef = (scriptRef) => {
+      const scriptHash = this.scriptRefHash(scriptRef);
+      if (scriptRef.type === "Native") {
+        nativeHashesOptional[scriptHash] = scriptRef.script;
+        return;
+      }
+      plutusHashesOptional.add(scriptHash);
+      if (scriptRef.type === "PlutusV3") plutusV3Hashes.add(scriptHash);
+    };
+    const inputs = own(body.inputs());
     const resolvedInputs = [];
     const inputOutRefs = /* @__PURE__ */ new Set();
     for (let i = 0; i < inputs.len(); i++) {
-      const outRef = (0, import_core_utils2.withCMLScope)((own) => {
-        const input = own(inputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = (0, import_core_utils2.withCMLScope)((own2) => {
+        const input = own2(inputs.get(i));
+        return own2(input.transaction_id()).to_hex() + input.index().toString();
       });
       inputOutRefs.add(outRef);
-      const entryLedger = this.ledger[outRef];
+      const entryLedger = this.#confirmed.get(outRef);
       const { entry, type } = !entryLedger ? { entry: this.mempool[outRef], type: "Mempool" } : { entry: entryLedger, type: "Ledger" };
       if (!entry || entry.spent) {
         throw new Error(
@@ -1912,52 +2129,18 @@ It does not exist or was already spent.`
         );
       }
       const scriptRef = entry.utxo.scriptRef;
-      if (scriptRef) {
-        switch (scriptRef.type) {
-          case "Native": {
-            const script = CML.NativeScript.from_cbor_bytes(
-              (0, import_core_utils2.fromHex)(scriptRef.script)
-            );
-            nativeHashesOptional[script.hash().to_hex()] = script;
-            break;
-          }
-          case "PlutusV1": {
-            const script = CML.PlutusScript.from_v1(
-              CML.PlutusV1Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV2": {
-            const script = CML.PlutusScript.from_v2(
-              CML.PlutusV2Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV3": {
-            const script = CML.PlutusScript.from_v3(
-              CML.PlutusV3Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            const scriptHash = script.hash().to_hex();
-            plutusHashesOptional.push(scriptHash);
-            plutusV3Hashes.add(scriptHash);
-            break;
-          }
-        }
-      }
+      if (scriptRef) collectScriptRef(scriptRef);
       if (entry.utxo.datumHash) consumedHashes.add(entry.utxo.datumHash);
       resolvedInputs.push({ entry, type });
     }
-    inputs.free();
-    const referenceInputs = body.reference_inputs();
+    const referenceInputs = own(body.reference_inputs());
     const nonDisjointRefInputs = [];
     for (let i = 0; i < (referenceInputs?.len() || 0); i++) {
-      const outRef = (0, import_core_utils2.withCMLScope)((own) => {
-        const input = own(referenceInputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = (0, import_core_utils2.withCMLScope)((own2) => {
+        const input = own2(referenceInputs.get(i));
+        return own2(input.transaction_id()).to_hex() + input.index().toString();
       });
-      const entry = this.ledger[outRef] || this.mempool[outRef];
+      const entry = this.#confirmed.get(outRef) || this.mempool[outRef];
       if (!entry || entry.spent) {
         throw new Error(
           `Could not read UTxO: ${JSON.stringify({
@@ -1973,44 +2156,11 @@ It does not exist or was already spent.`
         );
       }
       const scriptRef = entry.utxo.scriptRef;
-      if (scriptRef) {
-        switch (scriptRef.type) {
-          case "Native": {
-            const script = CML.NativeScript.from_cbor_bytes(
-              (0, import_core_utils2.fromHex)(scriptRef.script)
-            );
-            nativeHashesOptional[script.hash().to_hex()] = script;
-            break;
-          }
-          case "PlutusV1": {
-            const script = CML.PlutusScript.from_v1(
-              CML.PlutusV1Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV2": {
-            const script = CML.PlutusScript.from_v2(
-              CML.PlutusV2Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV3": {
-            const script = CML.PlutusScript.from_v3(
-              CML.PlutusV3Script.from_cbor_bytes((0, import_core_utils2.fromHex)(scriptRef.script))
-            );
-            const scriptHash = script.hash().to_hex();
-            plutusHashesOptional.push(scriptHash);
-            plutusV3Hashes.add(scriptHash);
-            break;
-          }
-        }
-      }
+      if (scriptRef) collectScriptRef(scriptRef);
       if (entry.utxo.datumHash) consumedHashes.add(entry.utxo.datumHash);
     }
-    referenceInputs?.free();
-    const redeemers = (() => {
+    const redeemerKey = (tag, index) => `${tag}:${index}`;
+    const redeemers = (0, import_core_utils2.withCMLScope)((own2) => {
       const tagMap = {
         0: "Spend",
         1: "Mint",
@@ -2019,35 +2169,33 @@ It does not exist or was already spent.`
         4: "Proposing",
         5: "Voting"
       };
-      const collected = [];
-      const redeemers2 = witnesses.redeemers();
-      const arrLegacyRedeemer = redeemers2?.as_arr_legacy_redeemer();
+      const collected = /* @__PURE__ */ new Set();
+      const redeemers2 = own2(witnesses.redeemers());
+      const arrLegacyRedeemer = own2(redeemers2?.as_arr_legacy_redeemer());
       if (arrLegacyRedeemer) {
         for (let i = 0; i < (arrLegacyRedeemer.len() || 0); i++) {
-          const redeemer = arrLegacyRedeemer.get(i);
-          collected.push({
-            tag: tagMap[redeemer.tag()],
-            index: Number(redeemer.index())
-          });
+          const redeemer = own2(arrLegacyRedeemer.get(i));
+          collected.add(
+            redeemerKey(tagMap[redeemer.tag()], Number(redeemer.index()))
+          );
         }
       }
-      const mapRedeemerKeyToRedeemerVal = redeemers2?.as_map_redeemer_key_to_redeemer_val();
+      const mapRedeemerKeyToRedeemerVal = own2(
+        redeemers2?.as_map_redeemer_key_to_redeemer_val()
+      );
       if (mapRedeemerKeyToRedeemerVal) {
-        const keys = mapRedeemerKeyToRedeemerVal.keys();
+        const keys = own2(mapRedeemerKeyToRedeemerVal.keys());
         for (let i = 0; i < (keys.len() || 0); i++) {
-          const key = keys.get(i);
-          collected.push({
-            tag: tagMap[key.tag()],
-            index: Number(key.index())
-          });
+          const key = own2(keys.get(i));
+          collected.add(redeemerKey(tagMap[key.tag()], Number(key.index())));
         }
       }
       return collected;
-    })();
+    });
     function checkAndConsumeHash(credential, tag, index) {
       switch (credential.type) {
         case "Key": {
-          if (!keyHashes.includes(credential.hash)) {
+          if (!keyHashes.has(credential.hash)) {
             throw new Error(
               `Missing vkey witness. Key hash: ${credential.hash}`
             );
@@ -2056,28 +2204,29 @@ It does not exist or was already spent.`
           break;
         }
         case "Script": {
-          if (nativeHashes.includes(credential.hash)) {
+          if (nativeHashes.has(credential.hash)) {
             consumedHashes.add(credential.hash);
             break;
           } else if (nativeHashesOptional[credential.hash]) {
-            if (!nativeHashesOptional[credential.hash].verify(
-              Number.isInteger(lowerBound) ? CML.BigInteger.from_str(
-                lowerBound.toString()
-              ).to_js_value() : void 0,
-              Number.isInteger(upperBound) ? CML.BigInteger.from_str(
-                upperBound.toString()
-              ).to_js_value() : void 0,
-              edKeyHashes
-            )) {
+            const valid = (0, import_core_utils2.withCMLScope)(
+              (own2) => own2(
+                CML.NativeScript.from_cbor_hex(
+                  nativeHashesOptional[credential.hash]
+                )
+              ).verify(
+                Number.isInteger(lowerBound) ? BigInt(lowerBound) : void 0,
+                Number.isInteger(upperBound) ? BigInt(upperBound) : void 0,
+                edKeyHashes
+              )
+            );
+            if (!valid) {
               throw new Error(
                 `Invalid native script witness. Script hash: ${credential.hash}`
               );
             }
             break;
-          } else if (plutusHashes.includes(credential.hash) || plutusHashesOptional.includes(credential.hash)) {
-            if (redeemers.find(
-              (redeemer) => redeemer.tag === tag && redeemer.index === index
-            )) {
+          } else if (plutusHashes.has(credential.hash) || plutusHashesOptional.has(credential.hash)) {
+            if (redeemers.has(redeemerKey(tag, index))) {
               consumedHashes.add(credential.hash);
               break;
             }
@@ -2088,13 +2237,14 @@ It does not exist or was already spent.`
         }
       }
     }
-    const collateralInputs = body.collateral_inputs();
+    const collateralInputs = own(body.collateral_inputs());
+    const collateralBalance = {};
     for (let i = 0; i < (collateralInputs?.len() || 0); i++) {
-      const outRef = (0, import_core_utils2.withCMLScope)((own) => {
-        const input = own(collateralInputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = (0, import_core_utils2.withCMLScope)((own2) => {
+        const input = own2(collateralInputs.get(i));
+        return own2(input.transaction_id()).to_hex() + input.index().toString();
       });
-      const entry = this.ledger[outRef] || this.mempool[outRef];
+      const entry = this.#confirmed.get(outRef) || this.mempool[outRef];
       if (!entry || entry.spent) {
         throw new Error(
           `Could not read UTxO: ${JSON.stringify({
@@ -2104,19 +2254,27 @@ It does not exist or was already spent.`
 It does not exist or was already spent.`
         );
       }
-      const { paymentCredential } = (0, import_utils6.getAddressDetails)(entry.utxo.address);
+      const { paymentCredential } = (0, import_utils7.getAddressDetails)(entry.utxo.address);
       if (paymentCredential?.type === "Script") {
         throw new Error("Collateral inputs can only contain vkeys.");
       }
       checkAndConsumeHash(paymentCredential, null, null);
+      for (const [unit, amount] of Object.entries(entry.utxo.assets)) {
+        collateralBalance[unit] = (collateralBalance[unit] ?? 0n) + amount;
+      }
+    }
+    if (redeemers.size > 0) {
+      this.checkCollateral(body, collateralBalance, own);
     }
-    collateralInputs?.free();
-    for (let i = 0; i < (body.required_signers()?.len() || 0); i++) {
-      const signer = body.required_signers().get(i);
+    const requiredSigners = own(body.required_signers());
+    for (let i = 0; i < (requiredSigners?.len() || 0); i++) {
+      const signer = own(requiredSigners.get(i));
       checkAndConsumeHash({ type: "Key", hash: signer.to_hex() }, null, null);
     }
-    for (let index = 0; index < (body.mint()?.keys().len() || 0); index++) {
-      const policyId = body.mint().keys().get(index).to_hex();
+    const mint = own(body.mint());
+    const policyIds = own(mint?.keys());
+    for (let index = 0; index < (policyIds?.len() || 0); index++) {
+      const policyId = own(policyIds.get(index)).to_hex();
       checkAndConsumeHash({ type: "Script", hash: policyId }, "Mint", index);
     }
     const withdrawalRequests = [];
@@ -2126,7 +2284,7 @@ It does not exist or was already spent.`
         body.withdrawals().get(rawAddress).toString()
       );
       const rewardAddress = rawAddress.to_address().to_bech32(void 0);
-      const { stakeCredential } = (0, import_utils6.getAddressDetails)(rewardAddress);
+      const { stakeCredential } = (0, import_utils7.getAddressDetails)(rewardAddress);
       checkAndConsumeHash(stakeCredential, "Reward", index);
       if (this.chain[rewardAddress]?.delegation.rewards !== withdrawal) {
         throw new Error(
@@ -2165,7 +2323,7 @@ It does not exist or was already spent.`
             CML.NetworkInfo.testnet().network_id(),
             registration.stake_credential()
           ).to_address().to_bech32(void 0);
-          const { stakeCredential } = (0, import_utils6.getAddressDetails)(rewardAddress);
+          const { stakeCredential } = (0, import_utils7.getAddressDetails)(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (this.chain[rewardAddress]?.registeredStake) {
             throw new Error(
@@ -2181,7 +2339,7 @@ It does not exist or was already spent.`
             CML.NetworkInfo.testnet().network_id(),
             deregistration.stake_credential()
           ).to_address().to_bech32(void 0);
-          const { stakeCredential } = (0, import_utils6.getAddressDetails)(rewardAddress);
+          const { stakeCredential } = (0, import_utils7.getAddressDetails)(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (!this.chain[rewardAddress]?.registeredStake) {
             throw new Error(
@@ -2198,7 +2356,7 @@ It does not exist or was already spent.`
             delegation.stake_credential()
           ).to_address().to_bech32(void 0);
           const poolId = delegation.pool().to_bech32("pool");
-          const { stakeCredential } = (0, import_utils6.getAddressDetails)(rewardAddress);
+          const { stakeCredential } = (0, import_utils7.getAddressDetails)(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (!this.chain[rewardAddress]?.registeredStake && !certRequests.find(
             (request) => request.type === "Registration" && request.rewardAddress === rewardAddress
@@ -2373,26 +2531,26 @@ It does not exist or was already spent.`
       }
     }
     resolvedInputs.forEach(({ entry: { utxo } }, index) => {
-      const { paymentCredential } = (0, import_utils6.getAddressDetails)(utxo.address);
+      const { paymentCredential } = (0, import_utils7.getAddressDetails)(utxo.address);
       checkAndConsumeHash(paymentCredential, "Spend", index);
     });
-    const outputs = (0, import_core_utils2.withCMLScope)((own) => {
+    const outputs = (0, import_core_utils2.withCMLScope)((own2) => {
       const collected = [];
-      const bodyOutputs = own(body.outputs());
+      const bodyOutputs = own2(body.outputs());
       for (let i = 0; i < bodyOutputs.len(); i++) {
-        const output = own(bodyOutputs.get(i));
-        const unspentOutput = own(
+        const output = own2(bodyOutputs.get(i));
+        const unspentOutput = own2(
           CML.TransactionUnspentOutput.new(
-            own(
+            own2(
               CML.TransactionInput.new(
-                own(CML.TransactionHash.from_hex(txHash)),
+                own2(CML.TransactionHash.from_hex(txHash)),
                 BigInt(i)
               )
             ),
             output
           )
         );
-        const utxo = (0, import_utils6.coreToUtxo)(unspentOutput);
+        const utxo = (0, import_utils7.coreToUtxo)(unspentOutput);
         if (utxo.datumHash) consumedHashes.add(utxo.datumHash);
         collected.push({
           utxo,
@@ -2401,13 +2559,13 @@ It does not exist or was already spent.`
       }
       return collected;
     });
-    const [extraKeyHash] = keyHashes.filter(
+    const [extraKeyHash] = keyHashList.filter(
       (keyHash) => !consumedHashes.has(keyHash)
     );
     if (extraKeyHash) {
       throw new Error(`Extraneous vkey witness. Key hash: ${extraKeyHash}`);
     }
-    const [extraNativeHash] = nativeHashes.filter(
+    const [extraNativeHash] = nativeHashList.filter(
       (scriptHash) => !consumedHashes.has(scriptHash)
     );
     if (extraNativeHash) {
@@ -2415,7 +2573,7 @@ It does not exist or was already spent.`
         `Extraneous native script. Script hash: ${extraNativeHash}`
       );
     }
-    const [extraPlutusHash] = plutusHashes.filter(
+    const [extraPlutusHash] = plutusHashList.filter(
       (scriptHash) => !consumedHashes.has(scriptHash)
     );
     if (extraPlutusHash) {
@@ -2446,11 +2604,8 @@ It does not exist or was already spent.`
         );
       }
     }
-    resolvedInputs.forEach(({ entry, type }) => {
-      const outRef = entry.utxo.txHash + entry.utxo.outputIndex;
+    resolvedInputs.forEach(({ entry }) => {
       entry.spent = true;
-      if (type === "Ledger") this.ledger[outRef] = entry;
-      else if (type === "Mempool") this.mempool[outRef] = entry;
     });
     withdrawalRequests.forEach(({ rewardAddress, withdrawal }) => {
       this.chain[rewardAddress].delegation.rewards -= withdrawal;
@@ -2490,9 +2645,115 @@ It does not exist or was already spent.`
     for (const [datumHash, datum] of Object.entries(datumTable)) {
       this.datumTable[datumHash] = datum;
     }
-    this.transactionHistory[txHash] = { status: "pending" };
-    (0, import_core_utils2.freeCML)(datums, witnesses, body, desTx);
-    return Promise.resolve(txHash);
+    this.#history[txHash] = { status: "pending" };
+    this.#pendingTxHashes.push(txHash);
+    return txHash;
+  }
+  /**
+   * The ledger's collateral rules for a transaction with redeemers: at least
+   * one and at most `maxCollateralInputs` collateral inputs, a balance (inputs
+   * minus the collateral return) of ADA only that covers
+   * `collateralPercentage` of the fee, a `total_collateral` field, when
+   * present, equal to that balance, and a collateral return holding at least
+   * its minimum ADA.
+   */
+  checkCollateral(body, collateralBalance, own) {
+    const inputCount = own(body.collateral_inputs())?.len() ?? 0;
+    if (inputCount === 0) {
+      throw new Error(
+        "NoCollateralInputs: a transaction that runs scripts needs collateral inputs."
+      );
+    }
+    const { maxCollateralInputs, collateralPercentage } = this.protocolParameters;
+    if (inputCount > maxCollateralInputs) {
+      throw new Error(
+        `TooManyCollateralInputs: ${inputCount} collateral inputs, but at most ${maxCollateralInputs} are allowed.`
+      );
+    }
+    const balance = { ...collateralBalance };
+    const collateralReturn = own(body.collateral_return());
+    if (collateralReturn) {
+      const minLovelace = CML.min_ada_required(
+        collateralReturn,
+        this.protocolParameters.coinsPerUtxoByte
+      );
+      const returnedLovelace = own(collateralReturn.amount()).coin();
+      if (returnedLovelace < minLovelace) {
+        throw new Error(
+          `BabbageOutputTooSmallUTxO: collateral return holds ${returnedLovelace} Lovelace, but needs at least ${minLovelace} Lovelace.`
+        );
+      }
+      const returned = (0, import_utils7.valueToAssets)(own(collateralReturn.amount()));
+      for (const [unit, amount] of Object.entries(returned)) {
+        balance[unit] = (balance[unit] ?? 0n) - amount;
+      }
+    }
+    const nonAda = Object.entries(balance).filter(
+      ([unit, amount]) => unit !== "lovelace" && amount !== 0n
+    );
+    if (nonAda.length > 0) {
+      throw new Error(
+        `CollateralContainsNonADA: collateral balance holds ${nonAda.map(([unit, amount]) => `${amount} ${unit}`).join(", ")}.`
+      );
+    }
+    const collateral = balance.lovelace ?? 0n;
+    const fee = body.fee();
+    if (collateral * 100n < fee * BigInt(collateralPercentage)) {
+      const required = (fee * BigInt(collateralPercentage) + 99n) / 100n;
+      throw new Error(
+        `InsufficientCollateral: collateral balance is ${collateral} Lovelace, but the fee of ${fee} requires ${required} Lovelace (${collateralPercentage}%).`
+      );
+    }
+    const totalCollateral = body.total_collateral();
+    if (totalCollateral !== void 0 && totalCollateral !== collateral) {
+      throw new Error(
+        `IncorrectTotalCollateralField: total collateral is ${totalCollateral} Lovelace, but the collateral balance is ${collateral} Lovelace.`
+      );
+    }
+  }
+  /** Hash of a reference script, computed once per distinct script. */
+  scriptRefHash(scriptRef) {
+    let scriptHash = this.#scriptRefHashes.get(
+      scriptRef.type,
+      scriptRef.script
+    );
+    if (scriptHash === void 0) {
+      scriptHash = (0, import_core_utils2.withCMLScope)((own) => {
+        const bytes = (0, import_core_utils2.fromHex)(scriptRef.script);
+        switch (scriptRef.type) {
+          case "Native":
+            return own(
+              own(CML.NativeScript.from_cbor_bytes(bytes)).hash()
+            ).to_hex();
+          case "PlutusV1":
+            return own(
+              own(
+                CML.PlutusScript.from_v1(
+                  own(CML.PlutusV1Script.from_cbor_bytes(bytes))
+                )
+              ).hash()
+            ).to_hex();
+          case "PlutusV2":
+            return own(
+              own(
+                CML.PlutusScript.from_v2(
+                  own(CML.PlutusV2Script.from_cbor_bytes(bytes))
+                )
+              ).hash()
+            ).to_hex();
+          case "PlutusV3":
+            return own(
+              own(
+                CML.PlutusScript.from_v3(
+                  own(CML.PlutusV3Script.from_cbor_bytes(bytes))
+                )
+              ).hash()
+            ).to_hex();
+        }
+      });
+      this.#scriptRefHashes.set(scriptRef.type, scriptRef.script, scriptHash);
+    }
+    return scriptHash;
   }
   async evaluateTx(tx, additionalUTxOs) {
     return (0, import_core_utils2.withCMLScope)((own) => {
@@ -2513,7 +2774,7 @@ It does not exist or was already spent.`
               steps: Number(exUnits.steps())
             },
             redeemer_index: Number(legacyRedeemer.index()),
-            redeemer_tag: (0, import_utils5.fromCMLRedeemerTag)(legacyRedeemer.tag())
+            redeemer_tag: (0, import_utils6.fromCMLRedeemerTag)(legacyRedeemer.tag())
           });
         }
         return evalRedeemers;
@@ -2534,7 +2795,7 @@ It does not exist or was already spent.`
                 steps: Number(exUnits.steps())
               },
               redeemer_index: Number(key.index()),
-              redeemer_tag: (0, import_utils5.fromCMLRedeemerTag)(key.tag())
+              redeemer_tag: (0, import_utils6.fromCMLRedeemerTag)(key.tag())
             });
           }
         }
@@ -2557,7 +2818,7 @@ It does not exist or was already spent.`
     }
     const totalBalances = {};
     const balances = {};
-    for (const { utxo } of Object.values(this.ledger)) {
+    for (const { utxo } of Object.values(this.#confirmed.record)) {
       for (const [unit, quantity] of Object.entries(utxo.assets)) {
         if (!balances[utxo.address]) {
           balances[utxo.address] = { [unit]: quantity };
@@ -2610,367 +2871,8 @@ ${"\u2581".repeat(60)}
   }
 };
 
-// src/maestro.ts
-var import_utils7 = require("@lucid-evolution/utils");
-var import_core_utils3 = 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-parameters`, {
-      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));
-    };
-    return {
-      protocolMajorVersion: result.version?.major,
-      protocolMinorVersion: result.version?.minor,
-      minFeeA: parseInt(result.min_fee_coefficient),
-      minFeeB: parseInt(result.min_fee_constant.ada.lovelace),
-      maxTxSize: parseInt(result.max_transaction_size.bytes),
-      maxValSize: parseInt(result.max_value_size.bytes),
-      keyDeposit: BigInt(result.stake_credential_deposit.ada.lovelace),
-      poolDeposit: BigInt(result.stake_pool_deposit.ada.lovelace),
-      drepDeposit: BigInt(result.delegate_representative_deposit.ada.lovelace),
-      govActionDeposit: BigInt(result.governance_action_deposit.ada.lovelace),
-      priceMem: decimalFromRationalString(
-        result.script_execution_prices.memory
-      ),
-      priceStep: decimalFromRationalString(result.script_execution_prices.cpu),
-      maxTxExMem: BigInt(result.max_execution_units_per_transaction.memory),
-      maxTxExSteps: BigInt(result.max_execution_units_per_transaction.cpu),
-      coinsPerUtxoByte: BigInt(result.min_utxo_deposit_coefficient),
-      collateralPercentage: parseInt(result.collateral_percentage),
-      maxCollateralInputs: parseInt(result.max_collateral_inputs),
-      minFeeRefScriptCostPerByte: parseInt(
-        result.min_fee_reference_scripts.base
-      ),
-      costModels: {
-        PlutusV1: result.plutus_cost_models.plutus_v1,
-        PlutusV2: result.plutus_cost_models.plutus_v2,
-        PlutusV3: result.plutus_cost_models.plutus_v3
-      }
-    };
-  }
-  async getTreasury() {
-    throw new Error(
-      "Maestro does not expose a current treasury query. Pass currentTreasuryValue explicitly to donateToTreasury."
-    );
-  }
-  async getUtxosInternal(addressOrCredential, unit) {
-    const queryPredicate = (() => {
-      if (typeof addressOrCredential === "string") {
-        return "/addresses/" + addressOrCredential;
-      }
-      let credentialBech32Query = "/addresses/cred/";
-      credentialBech32Query += addressOrCredential.type === "Key" ? CML.Ed25519KeyHash.from_hex(addressOrCredential.hash).to_bech32(
-        "addr_vkh"
-      ) : CML.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 getRewardAccount(rewardAddress) {
-    const response = await fetch(`${this.url}/accounts/${rewardAddress}`, {
-      headers: this.requireAmountsAsStrings(this.commonHeaders())
-    });
-    if (response.status === 404) {
-      return { registered: false, poolId: null, rewards: 0n };
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Could not fetch reward account from Maestro. Received status code: ${response.status}`
-      );
-    }
-    const timestampedResult = await response.json();
-    const result = timestampedResult.data;
-    return {
-      registered: result.registered,
-      poolId: result.delegated_pool || null,
-      rewards: BigInt(result.rewards_available)
-    };
-  }
-  async getDelegation(rewardAddress) {
-    const { poolId, rewards } = await this.getRewardAccount(rewardAddress);
-    return { poolId, rewards };
-  }
-  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 getTransactionStatus(txHash, options = {}) {
-    const response = await fetch(`${this.url}/txmanager/${txHash}/state`, {
-      headers: this.commonHeaders(),
-      signal: options.signal
-    });
-    if (response.status === 404) return { status: "not_found", txHash };
-    if (!response.ok) {
-      throw new Error(
-        `Could not fetch transaction status from Maestro. Received status code: ${response.status}`
-      );
-    }
-    const result = await response.json();
-    switch (result.status) {
-      case "pending":
-        return { status: "pending", txHash };
-      case "confirmed":
-        return {
-          status: "confirmed",
-          txHash,
-          confirmation: {
-            txHash,
-            confirmations: result.confirmations
-          }
-        };
-      case "failed":
-        return {
-          status: "failed",
-          txHash,
-          reason: result.reason ?? result.error
-        };
-      default:
-        throw new Error(
-          `Maestro returned an unknown transaction status: ${String(result.status)}`
-        );
-    }
-  }
-  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_utils3.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: toScriptRef2(result.reference_script)
-    };
-  }
-  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;
-  }
-  async evaluateTx(tx, additionalUTxOs) {
-    const additionalMaestroUTxOs = (additionalUTxOs || []).map((utxo) => ({
-      tx_hash: utxo.txHash,
-      index: utxo.outputIndex,
-      txout_cbor: (0, import_utils7.utxoToCore)(utxo).output().to_cbor_hex()
-    }));
-    const payload = {
-      cbor: tx,
-      additional_utxos: additionalMaestroUTxOs
-    };
-    const res = await fetch(`${this.url}/transactions/evaluate`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "api-key": this.apiKey
-      },
-      body: JSON.stringify(payload)
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      console.error("Response error:", JSON.stringify(res));
-      throw new Error(`Evaluate transaction failed: ${body}`);
-    }
-    const result = await res.json();
-    return result;
-  }
-};
-var toScriptRef2 = (reference_script) => {
-  if (reference_script && reference_script.bytes) {
-    switch (reference_script.type) {
-      case "native":
-        return (0, import_utils7.scriptFromNative)(reference_script.json);
-      case "plutusv1":
-        return {
-          type: "PlutusV1",
-          script: (0, import_utils7.applyDoubleCborEncoding)(reference_script.bytes)
-        };
-      case "plutusv2":
-        return {
-          type: "PlutusV2",
-          script: (0, import_utils7.applyDoubleCborEncoding)(reference_script.bytes)
-        };
-      case "plutusv3":
-        return {
-          type: "PlutusV3",
-          script: (0, import_utils7.applyDoubleCborEncoding)(reference_script.bytes)
-        };
-      default:
-        return void 0;
-    }
-  }
-};
-var lucid2 = package_default.version;
-
 // src/koios.ts
-var import_core_utils4 = require("@lucid-evolution/core-utils");
+var import_core_utils3 = require("@lucid-evolution/core-utils");
 var import_utils9 = require("@lucid-evolution/utils");
 
 // src/internal/koios.ts
@@ -3224,9 +3126,9 @@ var toUTxO = (koiosUTxO, address) => ({
   address,
   datumHash: koiosUTxO.inline_datum ? void 0 : koiosUTxO.datum_hash || void 0,
   datum: koiosUTxO.inline_datum ? koiosUTxO.inline_datum.bytes : void 0,
-  scriptRef: toScriptRef3(koiosUTxO.reference_script)
+  scriptRef: toScriptRef2(koiosUTxO.reference_script)
 });
-var toScriptRef3 = (reference_script) => {
+var toScriptRef2 = (reference_script) => {
   if (reference_script && reference_script.bytes && reference_script.type) {
     switch (reference_script.type) {
       case "plutusV1":
@@ -3555,7 +3457,7 @@ var Koios = class {
   }
   async submitTx(tx) {
     const url = `${this.baseUrl}/submittx`;
-    const body = (0, import_core_utils4.fromHex)(tx);
+    const body = (0, import_core_utils3.fromHex)(tx);
     const schema = TxHashSchema;
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
     const result = await (0, import_effect8.pipe)(
@@ -3608,7 +3510,6 @@ var Koios = class {
   KoiosError,
   Kupmios,
   KupmiosError,
-  Maestro,
   OgmiosJsonRpcError,
   generateEmulatorAccount,
   generateEmulatorAccountFromPrivateKey,