@lucid-evolution/provider 0.2.6 → 0.3.0

package/dist/index.js

@@ -101,7 +101,7 @@ import {
 // package.json
 var package_default = {
   name: "@lucid-evolution/provider",
-  version: "0.2.6",
+  version: "0.3.0",
   description: "",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -562,7 +562,15 @@ var lucid = package_default.version;
 // src/kupmios.ts
 import { applyDoubleCborEncoding as applyDoubleCborEncoding2, fromUnit as fromUnit2 } from "@lucid-evolution/utils";
 import { Schema as S3 } from "effect";
-import { Cause, Effect as Effect2, Exit, pipe as pipe3, Array as _Array, Schedule } from "effect";
+import {
+  Cause,
+  Effect as Effect2,
+  Exit,
+  Layer,
+  pipe as pipe3,
+  Array as _Array,
+  Schedule
+} from "effect";
 
 // src/internal/ogmios.ts
 import { Schema as S } from "effect";
@@ -1029,6 +1037,7 @@ var Kupmios = class {
   options;
   requestTimeoutMs;
   awaitTxTimeoutMs;
+  httpLayer;
   constructor(kupoUrl, ogmiosUrl, options = {}) {
     this.kupoUrl = kupoUrl;
     this.ogmiosUrl = ogmiosUrl;
@@ -1041,6 +1050,10 @@ var Kupmios = class {
       "awaitTxTimeoutMs",
       options.awaitTxTimeoutMs ?? DEFAULT_AWAIT_TX_TIMEOUT_MS
     );
+    this.httpLayer = options.fetchImpl === void 0 ? FetchHttpClient.layer : Layer.provide(
+      FetchHttpClient.layer,
+      Layer.succeed(FetchHttpClient.Fetch, options.fetchImpl)
+    );
   }
   async getProtocolParameters() {
     const data = {
@@ -1062,7 +1075,7 @@ var Kupmios = class {
         ),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/protocolParameters"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/protocolParameters"
@@ -1097,7 +1110,7 @@ var Kupmios = class {
         ),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/treasuryAndReserves"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "ogmios",
       "queryLedgerState/treasuryAndReserves"
@@ -1120,7 +1133,7 @@ var Kupmios = class {
         Effect2.map(kupmiosUtxosToUtxos),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxos"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxos"
@@ -1139,7 +1152,7 @@ var Kupmios = class {
         Effect2.map(kupmiosUtxosToUtxos),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithUnit"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithUnit"
@@ -1163,7 +1176,7 @@ var Kupmios = class {
         Effect2.map(kupmiosUtxosToUtxos),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxosWithPolicy"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxosWithPolicy"
@@ -1179,7 +1192,7 @@ var Kupmios = class {
         Effect2.map(kupmiosUtxosToUtxos),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getUtxoByUnit"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getUtxoByUnit"
@@ -1208,7 +1221,7 @@ var Kupmios = class {
       )
     );
     const utxos = await runProviderEffect(
-      pipe3(program, Effect2.provide(FetchHttpClient.layer)),
+      pipe3(program, Effect2.provide(this.httpLayer)),
       "kupo",
       "getUtxosByOutRef"
     );
@@ -1234,7 +1247,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        Effect2.provide(FetchHttpClient.layer),
+        Effect2.provide(this.httpLayer),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "queryLedgerState/rewardAccountSummaries")
       ),
@@ -1258,7 +1271,7 @@ var Kupmios = class {
     const result = await runProviderEffect(
       pipe3(
         makeGet(pattern, schema, this.options.kupoHeader),
-        Effect2.provide(FetchHttpClient.layer),
+        Effect2.provide(this.httpLayer),
         Effect2.timeout(this.requestTimeoutMs),
         Effect2.flatMap(Effect2.fromNullable),
         catchProviderError("kupo", "getDatum")
@@ -1278,7 +1291,7 @@ var Kupmios = class {
         makeGet(pattern, schema, this.options.kupoHeader),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("kupo", "getTransactionStatus"),
-        Effect2.provide(FetchHttpClient.layer)
+        Effect2.provide(this.httpLayer)
       ),
       "kupo",
       "getTransactionStatus",
@@ -1304,7 +1317,7 @@ var Kupmios = class {
     const result = await runProviderEffect(
       pipe3(
         makeGet(pattern, schema, this.options.kupoHeader),
-        Effect2.provide(FetchHttpClient.layer),
+        Effect2.provide(this.httpLayer),
         Effect2.repeat({
           schedule: Schedule.exponential(checkInterval),
           until: (result2) => result2.length > 0
@@ -1342,7 +1355,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        Effect2.provide(FetchHttpClient.layer),
+        Effect2.provide(this.httpLayer),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "submitTransaction")
       ),
@@ -1375,7 +1388,7 @@ var Kupmios = class {
           schema,
           this.options.ogmiosHeader
         ),
-        Effect2.provide(FetchHttpClient.layer),
+        Effect2.provide(this.httpLayer),
         Effect2.timeout(this.requestTimeoutMs),
         catchProviderError("ogmios", "evaluateTransaction")
       ),
@@ -1486,9 +1499,210 @@ import {
   generateSeedPhrase,
   PROTOCOL_PARAMETERS_DEFAULT
 } from "@lucid-evolution/utils";
-import { coreToUtxo, getAddressDetails } from "@lucid-evolution/utils";
-import { freeCML, fromHex as fromHex2, withCMLScope } from "@lucid-evolution/core-utils";
+import {
+  coreToUtxo,
+  getAddressDetails as getAddressDetails2,
+  ScriptCache,
+  valueToAssets
+} from "@lucid-evolution/utils";
+import { fromHex as fromHex2, withCMLScope } from "@lucid-evolution/core-utils";
 import { walletFromSeed } from "@lucid-evolution/wallet";
+
+// src/internal/emulator-ledger.ts
+import { getAddressDetails } from "@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 = 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"
 );
@@ -1526,7 +1740,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.
@@ -1539,13 +1759,37 @@ var Emulator = class {
   protocolParameters;
   datumTable = {};
   treasury;
-  transactionHistory = {};
+  #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 ScriptCache(4096, 64 * 1024 * 1024);
   constructor(accounts, protocolParameters = 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
@@ -1554,7 +1798,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,
@@ -1567,7 +1811,7 @@ var Emulator = class {
           scriptRef: outputData?.scriptRef
         },
         spent: false
-      };
+      });
     });
     this.protocolParameters = protocolParameters;
     this.treasury = treasury;
@@ -1575,16 +1819,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;
@@ -1596,13 +1852,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) {
@@ -1614,27 +1864,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 } = 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);
@@ -1646,31 +1879,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 } = 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.");
     }
@@ -1691,7 +1911,7 @@ var Emulator = class {
     });
   }
   awaitTx(txHash) {
-    if (this.transactionHistory[txHash]?.status === "pending") {
+    if (this.#history[txHash]?.status === "pending") {
       this.awaitBlock();
       return Promise.resolve(true);
     }
@@ -1703,7 +1923,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 });
@@ -1741,10 +1961,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 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;
@@ -1778,24 +2002,24 @@ var Emulator = class {
     const datumTable = (() => {
       const table = {};
       for (let i = 0; i < (datums?.len() || 0); i++) {
-        withCMLScope((own) => {
-          const datum = own(datums.get(i));
-          const datumHash = own(CML.hash_plutus_data(datum)).to_hex();
+        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 = withCMLScope((own) => {
+    const keyHashList = withCMLScope((own2) => {
       const keyHashes2 = [];
-      const vkeyWitnesses = own(witnesses.vkeywitnesses());
+      const vkeyWitnesses = own2(witnesses.vkeywitnesses());
       for (let i = 0; i < (vkeyWitnesses?.len() || 0); i++) {
-        withCMLScope((own2) => {
-          const witness = own2(vkeyWitnesses.get(i));
-          const publicKey = own2(witness.vkey());
-          const keyHash = own2(publicKey.hash()).to_hex();
-          if (!publicKey.verify(fromHex2(txHash), own2(witness.ed25519_signature()))) {
+        withCMLScope((own3) => {
+          const witness = own3(vkeyWitnesses.get(i));
+          const publicKey = own3(witness.vkey());
+          const keyHash = own3(publicKey.hash()).to_hex();
+          if (!publicKey.verify(fromHex2(txHash), own3(witness.ed25519_signature()))) {
             throw new Error(`Invalid vkey witness. Key hash: ${keyHash}`);
           }
           keyHashes2.push(keyHash);
@@ -1803,19 +2027,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) => withCMLScope(
-        (own) => edKeyHashes.add(own(CML.Ed25519KeyHash.from_hex(keyHash)))
+        (own2) => edKeyHashes.add(own2(CML.Ed25519KeyHash.from_hex(keyHash)))
       )
     );
-    const nativeHashes = withCMLScope((own) => {
+    const nativeHashList = 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++) {
-        withCMLScope((own2) => {
-          const witness = own2(nativeScripts.get(i));
-          const scriptHash = own2(witness.hash()).to_hex();
+        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,
@@ -1825,9 +2050,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);
@@ -1835,18 +2060,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 = withCMLScope((own) => {
+    const plutusHashList = withCMLScope((own2) => {
       const scriptHashes = [];
       const collectHashes = (scripts, isPlutusV3 = false) => {
-        own(scripts);
+        own2(scripts);
         for (let i = 0; i < (scripts?.len() || 0); i++) {
-          withCMLScope((own2) => {
-            const script = own2(scripts.get(i));
-            const scriptHash = own2(script.hash()).to_hex();
+          withCMLScope((own3) => {
+            const script = own3(scripts.get(i));
+            const scriptHash = own3(script.hash()).to_hex();
             scriptHashes.push(scriptHash);
             if (isPlutusV3) plutusV3Hashes.add(scriptHash);
           });
@@ -1857,16 +2082,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 = withCMLScope((own) => {
-        const input = own(inputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = 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(
@@ -1878,52 +2113,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(
-              fromHex2(scriptRef.script)
-            );
-            nativeHashesOptional[script.hash().to_hex()] = script;
-            break;
-          }
-          case "PlutusV1": {
-            const script = CML.PlutusScript.from_v1(
-              CML.PlutusV1Script.from_cbor_bytes(fromHex2(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV2": {
-            const script = CML.PlutusScript.from_v2(
-              CML.PlutusV2Script.from_cbor_bytes(fromHex2(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV3": {
-            const script = CML.PlutusScript.from_v3(
-              CML.PlutusV3Script.from_cbor_bytes(fromHex2(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 = withCMLScope((own) => {
-        const input = own(referenceInputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = 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({
@@ -1939,44 +2140,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(
-              fromHex2(scriptRef.script)
-            );
-            nativeHashesOptional[script.hash().to_hex()] = script;
-            break;
-          }
-          case "PlutusV1": {
-            const script = CML.PlutusScript.from_v1(
-              CML.PlutusV1Script.from_cbor_bytes(fromHex2(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV2": {
-            const script = CML.PlutusScript.from_v2(
-              CML.PlutusV2Script.from_cbor_bytes(fromHex2(scriptRef.script))
-            );
-            plutusHashesOptional.push(script.hash().to_hex());
-            break;
-          }
-          case "PlutusV3": {
-            const script = CML.PlutusScript.from_v3(
-              CML.PlutusV3Script.from_cbor_bytes(fromHex2(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 = withCMLScope((own2) => {
       const tagMap = {
         0: "Spend",
         1: "Mint",
@@ -1985,35 +2153,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}`
             );
@@ -2022,28 +2188,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 = 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;
             }
@@ -2054,13 +2221,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 = withCMLScope((own) => {
-        const input = own(collateralInputs.get(i));
-        return own(input.transaction_id()).to_hex() + input.index().toString();
+      const outRef = 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({
@@ -2070,19 +2238,27 @@ It does not exist or was already spent.`
 It does not exist or was already spent.`
         );
       }
-      const { paymentCredential } = getAddressDetails(entry.utxo.address);
+      const { paymentCredential } = getAddressDetails2(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;
+      }
     }
-    collateralInputs?.free();
-    for (let i = 0; i < (body.required_signers()?.len() || 0); i++) {
-      const signer = body.required_signers().get(i);
+    if (redeemers.size > 0) {
+      this.checkCollateral(body, collateralBalance, own);
+    }
+    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 = [];
@@ -2092,7 +2268,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 } = getAddressDetails(rewardAddress);
+      const { stakeCredential } = getAddressDetails2(rewardAddress);
       checkAndConsumeHash(stakeCredential, "Reward", index);
       if (this.chain[rewardAddress]?.delegation.rewards !== withdrawal) {
         throw new Error(
@@ -2131,7 +2307,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 } = getAddressDetails(rewardAddress);
+          const { stakeCredential } = getAddressDetails2(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (this.chain[rewardAddress]?.registeredStake) {
             throw new Error(
@@ -2147,7 +2323,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 } = getAddressDetails(rewardAddress);
+          const { stakeCredential } = getAddressDetails2(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (!this.chain[rewardAddress]?.registeredStake) {
             throw new Error(
@@ -2164,7 +2340,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 } = getAddressDetails(rewardAddress);
+          const { stakeCredential } = getAddressDetails2(rewardAddress);
           checkAndConsumeHash(stakeCredential, "Cert", index);
           if (!this.chain[rewardAddress]?.registeredStake && !certRequests.find(
             (request) => request.type === "Registration" && request.rewardAddress === rewardAddress
@@ -2339,19 +2515,19 @@ It does not exist or was already spent.`
       }
     }
     resolvedInputs.forEach(({ entry: { utxo } }, index) => {
-      const { paymentCredential } = getAddressDetails(utxo.address);
+      const { paymentCredential } = getAddressDetails2(utxo.address);
       checkAndConsumeHash(paymentCredential, "Spend", index);
     });
-    const outputs = withCMLScope((own) => {
+    const outputs = 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)
               )
             ),
@@ -2367,13 +2543,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) {
@@ -2381,7 +2557,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) {
@@ -2412,11 +2588,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;
@@ -2456,9 +2629,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" };
-    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 = 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 = withCMLScope((own) => {
+        const bytes = fromHex2(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 withCMLScope((own) => {
@@ -2523,7 +2802,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 };
@@ -2576,377 +2855,14 @@ ${"\u2581".repeat(60)}
   }
 };
 
-// src/maestro.ts
-import {
-  applyDoubleCborEncoding as applyDoubleCborEncoding3,
-  scriptFromNative as scriptFromNative2,
-  utxoToCore
-} from "@lucid-evolution/utils";
-import { fromHex as fromHex3 } from "@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: fromHex3(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: 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 scriptFromNative2(reference_script.json);
-      case "plutusv1":
-        return {
-          type: "PlutusV1",
-          script: applyDoubleCborEncoding3(reference_script.bytes)
-        };
-      case "plutusv2":
-        return {
-          type: "PlutusV2",
-          script: applyDoubleCborEncoding3(reference_script.bytes)
-        };
-      case "plutusv3":
-        return {
-          type: "PlutusV3",
-          script: applyDoubleCborEncoding3(reference_script.bytes)
-        };
-      default:
-        return void 0;
-    }
-  }
-};
-var lucid2 = package_default.version;
-
 // src/koios.ts
-import { fromHex as fromHex4 } from "@lucid-evolution/core-utils";
+import { fromHex as fromHex3 } from "@lucid-evolution/core-utils";
 import { fromUnit as fromUnit3 } from "@lucid-evolution/utils";
 
 // src/internal/koios.ts
 import { FetchHttpClient as FetchHttpClient2 } from "@effect/platform";
 import { Effect as Effect3, pipe as pipe4, Schema as S4 } from "effect";
-import { applyDoubleCborEncoding as applyDoubleCborEncoding4 } from "@lucid-evolution/utils";
+import { applyDoubleCborEncoding as applyDoubleCborEncoding3 } from "@lucid-evolution/utils";
 var ProtocolParametersSchema2 = S4.Struct({
   pvt_motion_no_confidence: S4.Number,
   pvt_committee_normal: S4.Number,
@@ -3194,25 +3110,25 @@ 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":
         return {
           type: "PlutusV1",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
+          script: applyDoubleCborEncoding3(reference_script.bytes)
         };
       case "plutusV2":
         return {
           type: "PlutusV2",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
+          script: applyDoubleCborEncoding3(reference_script.bytes)
         };
       case "plutusV3":
         return {
           type: "PlutusV3",
-          script: applyDoubleCborEncoding4(reference_script.bytes)
+          script: applyDoubleCborEncoding3(reference_script.bytes)
         };
       default:
         return void 0;
@@ -3525,7 +3441,7 @@ var Koios = class {
   }
   async submitTx(tx) {
     const url = `${this.baseUrl}/submittx`;
-    const body = fromHex4(tx);
+    const body = fromHex3(tx);
     const schema = TxHashSchema;
     const bearerToken = this.token ? { Authorization: `Bearer ${this.token}` } : void 0;
     const result = await pipe5(
@@ -3577,7 +3493,6 @@ export {
   KoiosError,
   Kupmios,
   KupmiosError,
-  Maestro,
   OgmiosJsonRpcError,
   generateEmulatorAccount,
   generateEmulatorAccountFromPrivateKey,