@lucid-evolution/utils 0.1.75 → 0.2.0

package/dist/index.js

@@ -2,7 +2,7 @@
 import * as S from "@effect/schema/Schema";
 
 // src/core.ts
-import * as CML from "@anastasia-labs/cardano-multiplatform-lib-nodejs";
+import * as CML from "@lucid-evolution/cml";
 
 // src/native.ts
 var toCMLNativeScript = (native) => {
@@ -104,7 +104,107 @@ function networkToId(network) {
 // src/cbor.ts
 import { fromHex, toHex } from "@lucid-evolution/core-utils";
 import { decode, encode } from "cbor-x";
+
+// src/script-cache.ts
+var SHORT_SCRIPT_LENGTH = 1024;
+var SAMPLE_COUNT = 32;
+var SAMPLE_WIDTH = 16;
+var TAIL_WIDTH = 512;
+var MAX_CHAIN = 4;
+var fingerprint = (namespace, script) => {
+  const length = script.length;
+  if (length <= SHORT_SCRIPT_LENGTH) return namespace + ":" + script;
+  const stride = Math.floor((length - TAIL_WIDTH) / SAMPLE_COUNT);
+  let key = namespace + ":" + length + ":";
+  for (let offset = 0; offset < SAMPLE_COUNT; offset++) {
+    const start = offset * stride;
+    key += script.slice(start, start + SAMPLE_WIDTH);
+  }
+  return key + script.slice(length - TAIL_WIDTH);
+};
+var ScriptCache = class {
+  /**
+   * @param capacity maximum number of entries
+   * @param maxWeight maximum total weight, see `weigh`
+   * @param weigh approximate retained bytes of an entry besides its key
+   */
+  constructor(capacity, maxWeight, weigh = () => 0) {
+    this.capacity = capacity;
+    this.maxWeight = maxWeight;
+    this.weigh = weigh;
+  }
+  buckets = /* @__PURE__ */ new Map();
+  /** Insertion order, for first-in first-out eviction. */
+  order = /* @__PURE__ */ new Set();
+  totalWeight = 0;
+  get size() {
+    return this.order.size;
+  }
+  get(namespace, script) {
+    const bucket = this.buckets.get(fingerprint(namespace, script));
+    if (bucket === void 0) return void 0;
+    for (const entry of bucket) {
+      if (entry.script === script) return entry.value;
+    }
+    return void 0;
+  }
+  set(namespace, script, value) {
+    const weight = script.length + this.weigh(value);
+    if (weight > this.maxWeight) return;
+    const key = fingerprint(namespace, script);
+    const previous = this.buckets.get(key);
+    if (previous !== void 0) {
+      const existing = previous.find((entry2) => entry2.script === script);
+      if (existing !== void 0) this.remove(existing);
+      if (previous.length >= MAX_CHAIN) this.remove(previous[0]);
+    }
+    const entry = { key, script, value, weight };
+    const bucket = this.buckets.get(key);
+    if (bucket === void 0) this.buckets.set(key, [entry]);
+    else bucket.push(entry);
+    this.order.add(entry);
+    this.totalWeight += weight;
+    while (this.order.size > this.capacity || this.totalWeight > this.maxWeight) {
+      this.remove(this.order.values().next().value);
+    }
+  }
+  clear() {
+    this.buckets.clear();
+    this.order.clear();
+    this.totalWeight = 0;
+  }
+  remove(entry) {
+    const bucket = this.buckets.get(entry.key);
+    if (bucket !== void 0) {
+      const index = bucket.indexOf(entry);
+      if (index !== -1) bucket.splice(index, 1);
+      if (bucket.length === 0) this.buckets.delete(entry.key);
+    }
+    if (this.order.delete(entry)) this.totalWeight -= entry.weight;
+  }
+  /**
+   * Returns the cached value, or computes, stores and returns it. A `compute`
+   * that throws stores nothing.
+   */
+  getOrCompute(namespace, script, compute) {
+    const cached = this.get(namespace, script);
+    if (cached !== void 0) return cached;
+    const value = compute();
+    this.set(namespace, script, value);
+    return value;
+  }
+};
+
+// src/cbor.ts
 var applyDoubleCborEncoding = (script) => {
+  if (typeof script !== "string") return decodingDoubleCborEncoding(script);
+  const cached = doubleCborCache.get("", script);
+  if (cached !== void 0) return cached;
+  const encoded = doubleCborEncoding(script);
+  doubleCborCache.set("", script, encoded);
+  return encoded;
+};
+var decodingDoubleCborEncoding = (script) => {
   try {
     decode(decode(fromHex(script)));
     return script;
@@ -117,6 +217,75 @@ var applyDoubleCborEncoding = (script) => {
     }
   }
 };
+var doubleCborEncoding = (script) => {
+  const layers = bytestringLayers(script);
+  switch (layers) {
+    case 2:
+      return script;
+    case 1:
+      return bytestringHeaderHex(script.length / 2) + script.toLowerCase();
+    case 0: {
+      const inner = bytestringHeaderHex(script.length / 2);
+      const innerLength = script.length / 2 + inner.length / 2;
+      return bytestringHeaderHex(innerLength) + inner + script.toLowerCase();
+    }
+    default:
+      return decodingDoubleCborEncoding(script);
+  }
+};
+var doubleCborCache = new ScriptCache(
+  4096,
+  64 * 1024 * 1024,
+  // Overcounts a script that is already double encoded, whose result is the
+  // key itself.
+  (encoded) => encoded.length
+);
+var NON_HEX = /[^0-9a-fA-F]/;
+var hexByte = (hex, index) => parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+var itemHeader = (hex, offset, end) => {
+  if (offset >= end) return void 0;
+  const token = hexByte(hex, offset);
+  const major = token >> 5;
+  if (major > 2) return void 0;
+  const info = token & 31;
+  let argument;
+  let headerLength;
+  if (info < 24) {
+    argument = info;
+    headerLength = 1;
+  } else if (info <= 26) {
+    headerLength = 1 + (1 << info - 24);
+    if (offset + headerLength > end) return void 0;
+    argument = 0;
+    for (let index = offset + 1; index < offset + headerLength; index++) {
+      argument = argument * 256 + hexByte(hex, index);
+    }
+  } else {
+    return void 0;
+  }
+  const payload = major === 2 ? argument : 0;
+  return { major, span: headerLength + payload, headerLength };
+};
+var bytestringLayers = (script) => {
+  if (script.length === 0 || script.length % 2 !== 0) return void 0;
+  if (NON_HEX.test(script)) return void 0;
+  const length = script.length / 2;
+  const outer = itemHeader(script, 0, length);
+  if (outer === void 0) return void 0;
+  if (outer.span !== length) return 0;
+  if (outer.major !== 2) return 1;
+  if (outer.headerLength === length) return void 0;
+  const inner = itemHeader(script, outer.headerLength, length);
+  if (inner === void 0) return void 0;
+  return inner.span === length - outer.headerLength ? 2 : 1;
+};
+var bytestringHeaderHex = (length) => {
+  if (length < 24) return byteHex(64 + length);
+  if (length < 256) return "58" + byteHex(length);
+  if (length < 65536) return "59" + length.toString(16).padStart(4, "0");
+  return "5a" + length.toString(16).padStart(8, "0");
+};
+var byteHex = (byte) => byte.toString(16).padStart(2, "0");
 var applySingleCborEncoding = (script) => {
   try {
     decode(decode(fromHex(script)));
@@ -225,77 +394,165 @@ function validatorToAddress(network, validator, stakeCredential) {
   });
 }
 function validatorToScriptHash(validator) {
-  return withCMLScope((own) => {
-    switch (validator.type) {
-      case "Native":
-        return own(
-          own(CML.NativeScript.from_cbor_hex(validator.script)).hash()
-        ).to_hex();
-      case "PlutusV1": {
-        const script = own(
-          CML.PlutusV1Script.from_cbor_hex(
-            applyDoubleCborEncoding(validator.script)
-          )
-        );
-        return own(own(CML.PlutusScript.from_v1(script)).hash()).to_hex();
-      }
-      case "PlutusV2": {
-        const script = own(
-          CML.PlutusV2Script.from_cbor_hex(
-            applyDoubleCborEncoding(validator.script)
-          )
-        );
-        return own(own(CML.PlutusScript.from_v2(script)).hash()).to_hex();
-      }
-      case "PlutusV3": {
-        const script = own(
-          CML.PlutusV3Script.from_cbor_hex(
-            applyDoubleCborEncoding(validator.script)
-          )
-        );
-        return own(own(CML.PlutusScript.from_v3(script)).hash()).to_hex();
-      }
-      default:
-        throw new Error("No variant matched");
-    }
-  });
+  const info = tryScriptInfo(validator);
+  return info === void 0 ? decodingValidatorToScriptHash(validator) : info.hash;
+}
+function scriptCborBytes(script) {
+  return scriptInfo(script).bytes.slice();
 }
 function toScriptRef(script) {
+  const info = tryScriptInfo(script);
+  if (info === void 0) return decodingToScriptRef(script);
+  const { bytes } = info;
   return withCMLScope((own) => {
     switch (script.type) {
       case "Native":
         return CML.Script.new_native(
-          own(CML.NativeScript.from_cbor_hex(script.script))
+          own(CML.NativeScript.from_cbor_bytes(bytes))
         );
       case "PlutusV1":
         return CML.Script.new_plutus_v1(
-          own(
-            CML.PlutusV1Script.from_cbor_hex(
-              applyDoubleCborEncoding(script.script)
-            )
-          )
+          own(CML.PlutusV1Script.from_cbor_bytes(bytes))
         );
       case "PlutusV2":
         return CML.Script.new_plutus_v2(
-          own(
-            CML.PlutusV2Script.from_cbor_hex(
-              applyDoubleCborEncoding(script.script)
-            )
-          )
+          own(CML.PlutusV2Script.from_cbor_bytes(bytes))
         );
       case "PlutusV3":
         return CML.Script.new_plutus_v3(
-          own(
-            CML.PlutusV3Script.from_cbor_hex(
-              applyDoubleCborEncoding(script.script)
-            )
-          )
+          own(CML.PlutusV3Script.from_cbor_bytes(bytes))
         );
       default:
         throw new Error("No variant matched.");
     }
   });
 }
+var scriptInfoCache = new ScriptCache(
+  4096,
+  64 * 1024 * 1024,
+  (info) => info.bytes.length + info.hash.length
+);
+var scriptInfo = (script) => scriptInfoCache.getOrCompute(
+  script.type,
+  script.script,
+  () => computeScriptInfo(script)
+);
+var tryScriptInfo = (script) => {
+  try {
+    if (typeof script.script !== "string") return void 0;
+    return scriptInfo(script);
+  } catch {
+    return void 0;
+  }
+};
+var computeScriptInfo = ({ type, script }) => withCMLScope((own) => {
+  switch (type) {
+    case "Native": {
+      const bytes = fromHex2(script);
+      const hash = own(
+        own(CML.NativeScript.from_cbor_bytes(bytes)).hash()
+      ).to_hex();
+      return { hash, bytes };
+    }
+    case "PlutusV1": {
+      const bytes = fromHex2(applyDoubleCborEncoding(script));
+      const plutus = own(
+        CML.PlutusScript.from_v1(
+          own(CML.PlutusV1Script.from_cbor_bytes(bytes))
+        )
+      );
+      return { hash: own(plutus.hash()).to_hex(), bytes };
+    }
+    case "PlutusV2": {
+      const bytes = fromHex2(applyDoubleCborEncoding(script));
+      const plutus = own(
+        CML.PlutusScript.from_v2(
+          own(CML.PlutusV2Script.from_cbor_bytes(bytes))
+        )
+      );
+      return { hash: own(plutus.hash()).to_hex(), bytes };
+    }
+    case "PlutusV3": {
+      const bytes = fromHex2(applyDoubleCborEncoding(script));
+      const plutus = own(
+        CML.PlutusScript.from_v3(
+          own(CML.PlutusV3Script.from_cbor_bytes(bytes))
+        )
+      );
+      return { hash: own(plutus.hash()).to_hex(), bytes };
+    }
+    default:
+      throw new Error("No variant matched");
+  }
+});
+var decodingValidatorToScriptHash = (validator) => withCMLScope((own) => {
+  switch (validator.type) {
+    case "Native":
+      return own(
+        own(CML.NativeScript.from_cbor_hex(validator.script)).hash()
+      ).to_hex();
+    case "PlutusV1": {
+      const script = own(
+        CML.PlutusV1Script.from_cbor_hex(
+          applyDoubleCborEncoding(validator.script)
+        )
+      );
+      return own(own(CML.PlutusScript.from_v1(script)).hash()).to_hex();
+    }
+    case "PlutusV2": {
+      const script = own(
+        CML.PlutusV2Script.from_cbor_hex(
+          applyDoubleCborEncoding(validator.script)
+        )
+      );
+      return own(own(CML.PlutusScript.from_v2(script)).hash()).to_hex();
+    }
+    case "PlutusV3": {
+      const script = own(
+        CML.PlutusV3Script.from_cbor_hex(
+          applyDoubleCborEncoding(validator.script)
+        )
+      );
+      return own(own(CML.PlutusScript.from_v3(script)).hash()).to_hex();
+    }
+    default:
+      throw new Error("No variant matched");
+  }
+});
+var decodingToScriptRef = (script) => withCMLScope((own) => {
+  switch (script.type) {
+    case "Native":
+      return CML.Script.new_native(
+        own(CML.NativeScript.from_cbor_hex(script.script))
+      );
+    case "PlutusV1":
+      return CML.Script.new_plutus_v1(
+        own(
+          CML.PlutusV1Script.from_cbor_hex(
+            applyDoubleCborEncoding(script.script)
+          )
+        )
+      );
+    case "PlutusV2":
+      return CML.Script.new_plutus_v2(
+        own(
+          CML.PlutusV2Script.from_cbor_hex(
+            applyDoubleCborEncoding(script.script)
+          )
+        )
+      );
+    case "PlutusV3":
+      return CML.Script.new_plutus_v3(
+        own(
+          CML.PlutusV3Script.from_cbor_hex(
+            applyDoubleCborEncoding(script.script)
+          )
+        )
+      );
+    default:
+      throw new Error("No variant matched.");
+  }
+});
 function fromScriptRef(scriptRef) {
   return withCMLScope((own) => {
     const kind = scriptRef.kind();
@@ -393,12 +650,24 @@ var addressDetails = (address) => ({
   bech32: address.to_bech32(void 0),
   hex: address.to_hex()
 });
-function getAddressDetails(address) {
+var HEX_PATTERN = /^[0-9a-fA-F]*$/;
+var parseShelleyAddress = (address) => {
+  if (HEX_PATTERN.test(address)) {
+    try {
+      return CML.Address.from_hex(address);
+    } catch (_e) {
+    }
+  }
   try {
-    return withCMLScope2((own) => {
-      const parsedAddress = own(
-        CML.BaseAddress.from_address(own(addressFromHexOrBech32(address)))
-      );
+    return CML.Address.from_bech32(address);
+  } catch (_e) {
+    return void 0;
+  }
+};
+var shelleyAddressDetails = (address, own) => {
+  switch (address.kind()) {
+    case CML.AddressKind.Base: {
+      const parsedAddress = own(CML.BaseAddress.from_address(address));
       const paymentCredential = credentialDetails(
         own(parsedAddress.payment()),
         own
@@ -417,16 +686,9 @@ function getAddressDetails(address) {
         paymentCredential,
         stakeCredential
       };
-    });
-  } catch (_e) {
-  }
-  try {
-    return withCMLScope2((own) => {
-      const parsedAddress = own(
-        CML.EnterpriseAddress.from_address(
-          own(addressFromHexOrBech32(address))
-        )
-      );
+    }
+    case CML.AddressKind.Enterprise: {
+      const parsedAddress = own(CML.EnterpriseAddress.from_address(address));
       const paymentCredential = credentialDetails(
         own(parsedAddress.payment()),
         own
@@ -440,14 +702,9 @@ function getAddressDetails(address) {
         address: details,
         paymentCredential
       };
-    });
-  } catch (_e) {
-  }
-  try {
-    return withCMLScope2((own) => {
-      const parsedAddress = own(
-        CML.PointerAddress.from_address(own(addressFromHexOrBech32(address)))
-      );
+    }
+    case CML.AddressKind.Ptr: {
+      const parsedAddress = own(CML.PointerAddress.from_address(address));
       const paymentCredential = credentialDetails(
         own(parsedAddress.payment()),
         own
@@ -461,14 +718,9 @@ function getAddressDetails(address) {
         address: details,
         paymentCredential
       };
-    });
-  } catch (_e) {
-  }
-  try {
-    return withCMLScope2((own) => {
-      const parsedAddress = own(
-        CML.RewardAddress.from_address(own(addressFromHexOrBech32(address)))
-      );
+    }
+    case CML.AddressKind.Reward: {
+      const parsedAddress = own(CML.RewardAddress.from_address(address));
       const stakeCredential = credentialDetails(
         own(parsedAddress.payment()),
         own
@@ -477,36 +729,83 @@ function getAddressDetails(address) {
         own(parsedAddress.to_address())
       );
       return { type: "Reward", networkId, address: details, stakeCredential };
+    }
+    default:
+      return void 0;
+  }
+};
+var byronAddressDetails = (address) => withCMLScope2((own) => {
+  const parsedAddress = own(
+    ((address2) => {
+      if (HEX_PATTERN.test(address2)) {
+        try {
+          return CML.ByronAddress.from_cbor_hex(address2);
+        } catch (_e) {
+        }
+      }
+      try {
+        return CML.ByronAddress.from_base58(address2);
+      } catch (_e) {
+        return void 0;
+      }
+    })(address)
+  );
+  if (!parsedAddress) return void 0;
+  return {
+    type: "Byron",
+    networkId: own(parsedAddress.content()).network_id(),
+    address: {
+      bech32: "",
+      hex: own(parsedAddress.to_address()).to_hex()
+    }
+  };
+});
+var parseAddressDetails = (address) => {
+  try {
+    const details = withCMLScope2((own) => {
+      const parsedAddress = own(parseShelleyAddress(address));
+      return parsedAddress && shelleyAddressDetails(parsedAddress, own);
     });
+    if (details) return details;
   } catch (_e) {
   }
   try {
-    return withCMLScope2((own) => {
-      const parsedAddress = own(
-        ((address2) => {
-          try {
-            return CML.ByronAddress.from_cbor_hex(address2);
-          } catch (_e) {
-            try {
-              return CML.ByronAddress.from_base58(address2);
-            } catch (_e2) {
-              throw new Error("Could not deserialize address.");
-            }
-          }
-        })(address)
-      );
-      return {
-        type: "Byron",
-        networkId: own(parsedAddress.content()).network_id(),
-        address: {
-          bech32: "",
-          hex: own(parsedAddress.to_address()).to_hex()
-        }
-      };
-    });
+    const details = byronAddressDetails(address);
+    if (details) return details;
   } catch (_e) {
   }
   throw new Error("No address type matched for: " + address);
+};
+var ADDRESS_DETAILS_CACHE_CAPACITY = 1e4;
+var addressDetailsCache = /* @__PURE__ */ new Map();
+var copyCredential = (credential) => ({
+  type: credential.type,
+  hash: credential.hash
+});
+var copyAddressDetails = (details) => {
+  const copy = {
+    type: details.type,
+    networkId: details.networkId,
+    address: { bech32: details.address.bech32, hex: details.address.hex }
+  };
+  if (details.paymentCredential) {
+    copy.paymentCredential = copyCredential(details.paymentCredential);
+  }
+  if (details.stakeCredential) {
+    copy.stakeCredential = copyCredential(details.stakeCredential);
+  }
+  return copy;
+};
+function getAddressDetails(address) {
+  let details = addressDetailsCache.get(address);
+  if (!details) {
+    details = parseAddressDetails(address);
+    if (addressDetailsCache.size >= ADDRESS_DETAILS_CACHE_CAPACITY) {
+      addressDetailsCache.delete(addressDetailsCache.keys().next().value);
+    }
+    addressDetailsCache.set(address, details);
+  }
+  return copyAddressDetails(details);
 }
 
 // src/cost_model.ts
@@ -1438,9 +1737,13 @@ var sortCanonical = (assets) => pipe(
 
 // src/utxo.ts
 var utxoToTransactionOutput = (utxo) => withCMLScope4((own) => {
+  const address = own(CML.Address.from_bech32(utxo.address));
   const value = own(assetsToValue(utxo.assets));
-  const builder = own(buildOutput(utxo, own).with_value(value));
-  return own(builder.build()).output();
+  const datum = utxo.datum ? own(CML.PlutusData.from_cbor_hex(utxo.datum)) : void 0;
+  const datumHash = datum && utxo.datumHash ? own(CML.hash_plutus_data(datum)) : void 0;
+  const scriptRef = utxo.scriptRef ? toScriptRef(utxo.scriptRef) : void 0;
+  const datumOption = datumHash ? CML.DatumOption.new_hash(datumHash) : datum ? CML.DatumOption.new_datum(datum) : void 0;
+  return CML.TransactionOutput.new(address, value, datumOption, scriptRef);
 });
 var utxoToTransactionInput = (utxo) => withCMLScope4(
   (own) => CML.TransactionInput.new(
@@ -1663,6 +1966,7 @@ var fromCMLRedeemerTag = (tag) => {
 export {
   CBOREncodingLevel,
   PROTOCOL_PARAMETERS_DEFAULT,
+  ScriptCache,
   addAssets,
   addressFromHexOrBech32,
   applyDoubleCborEncoding,
@@ -1697,6 +2001,7 @@ export {
   networkToId,
   parseCMLNative,
   paymentCredentialOf,
+  scriptCborBytes,
   scriptFromCMLNative,
   scriptFromNative,
   scriptHashToCredential,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucid-evolution/utils",
-  "version": "0.1.75",
+  "version": "0.2.0",
   "description": "",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -22,12 +22,9 @@
   "author": "",
   "license": "MIT",
   "browser": {
-    "@anastasia-labs/cardano-multiplatform-lib-nodejs": "@anastasia-labs/cardano-multiplatform-lib-browser",
     "@emurgo/cardano-serialization-lib-nodejs": "@emurgo/cardano-serialization-lib-browser"
   },
   "dependencies": {
-    "@anastasia-labs/cardano-multiplatform-lib-browser": "6.2.0-1",
-    "@anastasia-labs/cardano-multiplatform-lib-nodejs": "6.2.0-1",
     "@cardano-sdk/core": "^0.46.10",
     "@effect/schema": "^0.68.16",
     "@harmoniclabs/plutus-data": "^1.2.4",
@@ -35,11 +32,12 @@
     "bip39": "^3.1.0",
     "cbor-x": "^1.6.0",
     "effect": "^3.10.4",
-    "@lucid-evolution/core-types": "0.3.0",
-    "@lucid-evolution/core-utils": "0.1.17",
     "@lucid-evolution/crc8": "0.1.8",
-    "@lucid-evolution/plutus": "0.1.36",
-    "@lucid-evolution/uplc": "0.2.24"
+    "@lucid-evolution/core-utils": "0.2.0",
+    "@lucid-evolution/core-types": "0.5.0",
+    "@lucid-evolution/cml": "0.1.0",
+    "@lucid-evolution/plutus": "0.2.0",
+    "@lucid-evolution/uplc": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.12.8",