@lucid-evolution/utils 0.1.72 → 0.1.74

package/dist/index.cjs

@@ -177,6 +177,9 @@ var scriptFromCMLNative = (cmlNative) => {
   };
 };
 
+// src/address.ts
+var import_core_utils3 = require("@lucid-evolution/core-utils");
+
 // src/network.ts
 function networkToId(network) {
   switch (network) {
@@ -285,103 +288,131 @@ var import_cbor_x2 = require("cbor-x");
 var import_plutus_data = require("@harmoniclabs/plutus-data");
 function validatorToAddress(network, validator, stakeCredential) {
   const validatorHash = validatorToScriptHash(validator);
-  if (stakeCredential) {
-    return CML.BaseAddress.new(
-      networkToId(network),
-      CML.Credential.new_script(CML.ScriptHash.from_hex(validatorHash)),
-      stakeCredential.type === "Key" ? CML.Credential.new_pub_key(
-        CML.Ed25519KeyHash.from_hex(stakeCredential.hash)
-      ) : CML.Credential.new_script(
-        CML.ScriptHash.from_hex(stakeCredential.hash)
-      )
-    ).to_address().to_bech32(void 0);
-  } else {
-    return CML.EnterpriseAddress.new(
-      networkToId(network),
-      CML.Credential.new_script(CML.ScriptHash.from_hex(validatorHash))
-    ).to_address().to_bech32(void 0);
-  }
-}
-function validatorToScriptHash(validator) {
-  switch (validator.type) {
-    case "Native":
-      return CML.NativeScript.from_cbor_hex(validator.script).hash().to_hex();
-    case "PlutusV1":
-      return CML.PlutusScript.from_v1(
-        CML.PlutusV1Script.from_cbor_hex(
-          applyDoubleCborEncoding(validator.script)
-        )
-      ).hash().to_hex();
-    case "PlutusV2":
-      return CML.PlutusScript.from_v2(
-        CML.PlutusV2Script.from_cbor_hex(
-          applyDoubleCborEncoding(validator.script)
-        )
-      ).hash().to_hex();
-    case "PlutusV3":
-      return CML.PlutusScript.from_v3(
-        CML.PlutusV3Script.from_cbor_hex(
-          applyDoubleCborEncoding(validator.script)
+  return (0, import_core_utils2.withCMLScope)((own) => {
+    const paymentCredential = own(
+      CML.Credential.new_script(own(CML.ScriptHash.from_hex(validatorHash)))
+    );
+    if (stakeCredential) {
+      const stake = stakeCredential.type === "Key" ? own(
+        CML.Credential.new_pub_key(
+          own(CML.Ed25519KeyHash.from_hex(stakeCredential.hash))
         )
-      ).hash().to_hex();
-    default:
-      throw new Error("No variant matched");
-  }
-}
-function toScriptRef(script) {
-  switch (script.type) {
-    case "Native":
-      return CML.Script.new_native(
-        CML.NativeScript.from_cbor_hex(script.script)
-      );
-    case "PlutusV1":
-      return CML.Script.new_plutus_v1(
-        CML.PlutusV1Script.from_cbor_hex(
-          applyDoubleCborEncoding(script.script)
+      ) : own(
+        CML.Credential.new_script(
+          own(CML.ScriptHash.from_hex(stakeCredential.hash))
         )
       );
-    case "PlutusV2":
-      return CML.Script.new_plutus_v2(
-        CML.PlutusV2Script.from_cbor_hex(
-          applyDoubleCborEncoding(script.script)
-        )
+      const address2 = own(
+        CML.BaseAddress.new(networkToId(network), paymentCredential, stake)
       );
-    case "PlutusV3":
-      return CML.Script.new_plutus_v3(
-        CML.PlutusV3Script.from_cbor_hex(
-          applyDoubleCborEncoding(script.script)
-        )
-      );
-    default:
-      throw new Error("No variant matched.");
-  }
+      return own(address2.to_address()).to_bech32(void 0);
+    }
+    const address = own(
+      CML.EnterpriseAddress.new(networkToId(network), paymentCredential)
+    );
+    return own(address.to_address()).to_bech32(void 0);
+  });
+}
+function validatorToScriptHash(validator) {
+  return (0, import_core_utils2.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");
+    }
+  });
+}
+function toScriptRef(script) {
+  return (0, import_core_utils2.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) {
-  const kind = scriptRef.kind();
-  switch (kind) {
-    case 0:
-      return {
-        type: "Native",
-        script: scriptRef.as_native().to_cbor_hex()
-      };
-    case 1:
-      return {
-        type: "PlutusV1",
-        script: scriptRef.as_plutus_v1().to_cbor_hex()
-      };
-    case 2:
-      return {
-        type: "PlutusV2",
-        script: scriptRef.as_plutus_v2().to_cbor_hex()
-      };
-    case 3:
-      return {
-        type: "PlutusV3",
-        script: scriptRef.as_plutus_v3().to_cbor_hex()
-      };
-    default:
-      throw new Error("No variant matched.");
-  }
+  return (0, import_core_utils2.withCMLScope)((own) => {
+    const kind = scriptRef.kind();
+    switch (kind) {
+      case 0:
+        return {
+          type: "Native",
+          script: own(scriptRef.as_native()).to_cbor_hex()
+        };
+      case 1:
+        return {
+          type: "PlutusV1",
+          script: own(scriptRef.as_plutus_v1()).to_cbor_hex()
+        };
+      case 2:
+        return {
+          type: "PlutusV2",
+          script: own(scriptRef.as_plutus_v2()).to_cbor_hex()
+        };
+      case 3:
+        return {
+          type: "PlutusV3",
+          script: own(scriptRef.as_plutus_v3()).to_cbor_hex()
+        };
+      default:
+        throw new Error("No variant matched.");
+    }
+  });
 }
 function mintingPolicyToId(mintingPolicy) {
   return validatorToScriptHash(mintingPolicy);
@@ -417,139 +448,151 @@ function addressFromHexOrBech32(address) {
   }
 }
 function credentialToRewardAddress(network, stakeCredential) {
-  return CML.RewardAddress.new(
-    networkToId(network),
-    stakeCredential.type === "Key" ? CML.Credential.new_pub_key(
-      CML.Ed25519KeyHash.from_hex(stakeCredential.hash)
-    ) : CML.Credential.new_script(
-      CML.ScriptHash.from_hex(stakeCredential.hash)
-    )
-  ).to_address().to_bech32(void 0);
+  return (0, import_core_utils3.withCMLScope)((own) => {
+    const credential = stakeCredential.type === "Key" ? own(
+      CML.Credential.new_pub_key(
+        own(CML.Ed25519KeyHash.from_hex(stakeCredential.hash))
+      )
+    ) : own(
+      CML.Credential.new_script(
+        own(CML.ScriptHash.from_hex(stakeCredential.hash))
+      )
+    );
+    const rewardAddress = own(
+      CML.RewardAddress.new(networkToId(network), credential)
+    );
+    return own(rewardAddress.to_address()).to_bech32(void 0);
+  });
 }
 function validatorToRewardAddress(network, validator) {
   const validatorHash = validatorToScriptHash(validator);
-  return CML.RewardAddress.new(
-    networkToId(network),
-    CML.Credential.new_script(CML.ScriptHash.from_hex(validatorHash))
-  ).to_address().to_bech32(void 0);
+  return (0, import_core_utils3.withCMLScope)((own) => {
+    const credential = own(
+      CML.Credential.new_script(own(CML.ScriptHash.from_hex(validatorHash)))
+    );
+    const rewardAddress = own(
+      CML.RewardAddress.new(networkToId(network), credential)
+    );
+    return own(rewardAddress.to_address()).to_bech32(void 0);
+  });
 }
+var credentialDetails = (credential, own) => credential.kind() === 0 ? { type: "Key", hash: own(credential.as_pub_key()).to_hex() } : { type: "Script", hash: own(credential.as_script()).to_hex() };
+var addressDetails = (address) => ({
+  networkId: address.network_id(),
+  bech32: address.to_bech32(void 0),
+  hex: address.to_hex()
+});
 function getAddressDetails(address) {
   try {
-    const parsedAddress = CML.BaseAddress.from_address(
-      addressFromHexOrBech32(address)
-    );
-    const paymentCredential = parsedAddress.payment().kind() === 0 ? {
-      type: "Key",
-      hash: parsedAddress.payment().as_pub_key().to_hex()
-    } : {
-      type: "Script",
-      hash: parsedAddress.payment().as_script().to_hex()
-    };
-    const stakeCredential = parsedAddress.stake().kind() === 0 ? {
-      type: "Key",
-      hash: parsedAddress.stake().as_pub_key().to_hex()
-    } : {
-      type: "Script",
-      hash: parsedAddress.stake().as_script().to_hex()
-    };
-    return {
-      type: "Base",
-      networkId: parsedAddress.to_address().network_id(),
-      address: {
-        bech32: parsedAddress.to_address().to_bech32(void 0),
-        hex: parsedAddress.to_address().to_hex()
-      },
-      paymentCredential,
-      stakeCredential
-    };
+    return (0, import_core_utils3.withCMLScope)((own) => {
+      const parsedAddress = own(
+        CML.BaseAddress.from_address(own(addressFromHexOrBech32(address)))
+      );
+      const paymentCredential = credentialDetails(
+        own(parsedAddress.payment()),
+        own
+      );
+      const stakeCredential = credentialDetails(
+        own(parsedAddress.stake()),
+        own
+      );
+      const { networkId, ...details } = addressDetails(
+        own(parsedAddress.to_address())
+      );
+      return {
+        type: "Base",
+        networkId,
+        address: details,
+        paymentCredential,
+        stakeCredential
+      };
+    });
   } catch (_e) {
   }
   try {
-    const parsedAddress = CML.EnterpriseAddress.from_address(
-      addressFromHexOrBech32(address)
-    );
-    const paymentCredential = parsedAddress.payment().kind() === 0 ? {
-      type: "Key",
-      hash: parsedAddress.payment().as_pub_key().to_hex()
-    } : {
-      type: "Script",
-      hash: parsedAddress.payment().as_script().to_hex()
-    };
-    return {
-      type: "Enterprise",
-      networkId: parsedAddress.to_address().network_id(),
-      address: {
-        bech32: parsedAddress.to_address().to_bech32(void 0),
-        hex: parsedAddress.to_address().to_hex()
-      },
-      paymentCredential
-    };
+    return (0, import_core_utils3.withCMLScope)((own) => {
+      const parsedAddress = own(
+        CML.EnterpriseAddress.from_address(
+          own(addressFromHexOrBech32(address))
+        )
+      );
+      const paymentCredential = credentialDetails(
+        own(parsedAddress.payment()),
+        own
+      );
+      const { networkId, ...details } = addressDetails(
+        own(parsedAddress.to_address())
+      );
+      return {
+        type: "Enterprise",
+        networkId,
+        address: details,
+        paymentCredential
+      };
+    });
   } catch (_e) {
   }
   try {
-    const parsedAddress = CML.PointerAddress.from_address(
-      addressFromHexOrBech32(address)
-    );
-    const paymentCredential = parsedAddress?.payment().kind() === 0 ? {
-      type: "Key",
-      hash: parsedAddress.payment().as_pub_key().to_hex()
-    } : {
-      type: "Script",
-      hash: parsedAddress.payment().as_script().to_hex()
-    };
-    return {
-      type: "Pointer",
-      networkId: parsedAddress.to_address().network_id(),
-      address: {
-        bech32: parsedAddress.to_address().to_bech32(void 0),
-        hex: parsedAddress.to_address().to_hex()
-      },
-      paymentCredential
-    };
+    return (0, import_core_utils3.withCMLScope)((own) => {
+      const parsedAddress = own(
+        CML.PointerAddress.from_address(own(addressFromHexOrBech32(address)))
+      );
+      const paymentCredential = credentialDetails(
+        own(parsedAddress.payment()),
+        own
+      );
+      const { networkId, ...details } = addressDetails(
+        own(parsedAddress.to_address())
+      );
+      return {
+        type: "Pointer",
+        networkId,
+        address: details,
+        paymentCredential
+      };
+    });
   } catch (_e) {
   }
   try {
-    const parsedAddress = CML.RewardAddress.from_address(
-      addressFromHexOrBech32(address)
-    );
-    const stakeCredential = parsedAddress.payment().kind() === 0 ? {
-      type: "Key",
-      hash: parsedAddress.payment().as_pub_key().to_hex()
-    } : {
-      type: "Script",
-      hash: parsedAddress.payment().as_script().to_hex()
-    };
-    return {
-      type: "Reward",
-      networkId: parsedAddress.to_address().network_id(),
-      address: {
-        bech32: parsedAddress.to_address().to_bech32(void 0),
-        hex: parsedAddress.to_address().to_hex()
-      },
-      stakeCredential
-    };
+    return (0, import_core_utils3.withCMLScope)((own) => {
+      const parsedAddress = own(
+        CML.RewardAddress.from_address(own(addressFromHexOrBech32(address)))
+      );
+      const stakeCredential = credentialDetails(
+        own(parsedAddress.payment()),
+        own
+      );
+      const { networkId, ...details } = addressDetails(
+        own(parsedAddress.to_address())
+      );
+      return { type: "Reward", networkId, address: details, stakeCredential };
+    });
   } catch (_e) {
   }
   try {
-    const parsedAddress = ((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.");
+    return (0, import_core_utils3.withCMLScope)((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()
         }
-      }
-    })(address);
-    return {
-      type: "Byron",
-      networkId: parsedAddress.content().network_id(),
-      address: {
-        bech32: "",
-        hex: parsedAddress.to_address().to_hex()
-      }
-    };
+      };
+    });
   } catch (_e) {
   }
   throw new Error("No address type matched for: " + address);
@@ -1326,7 +1369,7 @@ function toPublicKey(privateKey) {
 }
 
 // src/label.ts
-var import_core_utils3 = require("@lucid-evolution/core-utils");
+var import_core_utils4 = require("@lucid-evolution/core-utils");
 var import_crc8 = require("@lucid-evolution/crc8");
 function toLabel(num) {
   if (num < 0 || num > 65535) {
@@ -1347,7 +1390,7 @@ function fromLabel(label) {
   return check === checksum(numHex) ? num : null;
 }
 function checksum(num) {
-  return (0, import_crc8.crc8)((0, import_core_utils3.fromHex)(num)).toString(16).padStart(2, "0");
+  return (0, import_crc8.crc8)((0, import_core_utils4.fromHex)(num)).toString(16).padStart(2, "0");
 }
 
 // src/time.ts
@@ -1359,50 +1402,60 @@ function slotToUnixTime(network, slot) {
   return (0, import_plutus2.slotToBeginUnixTime)(slot, import_plutus2.SLOT_CONFIG_NETWORK[network]);
 }
 
+// src/utxo.ts
+var import_core_utils6 = require("@lucid-evolution/core-utils");
+
 // src/value.ts
-var import_core_utils4 = require("@lucid-evolution/core-utils");
+var import_core_utils5 = require("@lucid-evolution/core-utils");
 var import_effect = require("effect");
 function valueToAssets(value) {
   const assets = {};
   assets["lovelace"] = value.coin();
   if (value.has_multiassets()) {
-    const ma = value.multi_asset();
-    const multiAssets = ma.keys();
-    for (let j = 0; j < multiAssets.len(); j++) {
-      const policy = multiAssets.get(j);
-      const policyAssets = ma.get_assets(policy);
-      const assetNames = policyAssets.keys();
-      for (let k = 0; k < assetNames.len(); k++) {
-        const policyAsset = assetNames.get(k);
-        const quantity = policyAssets.get(policyAsset);
-        const unit = policy.to_hex() + policyAsset.to_js_value();
-        assets[unit] = quantity;
+    (0, import_core_utils5.withCMLScope)((own) => {
+      const ma = own(value.multi_asset());
+      const multiAssets = own(ma.keys());
+      for (let j = 0; j < multiAssets.len(); j++) {
+        const policy = own(multiAssets.get(j));
+        const policyAssets = own(ma.get_assets(policy));
+        const assetNames = own(policyAssets.keys());
+        for (let k = 0; k < assetNames.len(); k++) {
+          const policyAsset = own(assetNames.get(k));
+          const quantity = policyAssets.get(policyAsset);
+          const unit = policy.to_hex() + policyAsset.to_js_value();
+          assets[unit] = quantity;
+        }
       }
-    }
+    });
   }
   return assets;
 }
 function assetsToValue(assets) {
-  const multiAsset = CML.MultiAsset.new();
-  const lovelace = assets["lovelace"] ? BigInt(assets["lovelace"]) : 0n;
-  const units = Object.keys(assets);
-  const policies = Array.from(
-    new Set(
-      units.filter((unit) => unit !== "lovelace").map((unit) => unit.slice(0, 56))
-    )
-  );
-  for (const policy of policies) {
-    const policyUnits = units.filter((unit) => unit.slice(0, 56) === policy);
-    const assetsValue = CML.MapAssetNameToCoin.new();
-    for (const unit of policyUnits) {
-      assetsValue.insert(
-        CML.AssetName.from_hex(unit.slice(56)),
-        BigInt(assets[unit])
+  return (0, import_core_utils5.withCMLScope)((own) => {
+    const multiAsset = own(CML.MultiAsset.new());
+    const lovelace = assets["lovelace"] ? BigInt(assets["lovelace"]) : 0n;
+    const units = Object.keys(assets);
+    const policies = Array.from(
+      new Set(
+        units.filter((unit) => unit !== "lovelace").map((unit) => unit.slice(0, 56))
+      )
+    );
+    for (const policy of policies) {
+      const policyUnits = units.filter((unit) => unit.slice(0, 56) === policy);
+      const assetsValue = own(CML.MapAssetNameToCoin.new());
+      for (const unit of policyUnits) {
+        assetsValue.insert(
+          own(CML.AssetName.from_hex(unit.slice(56))),
+          BigInt(assets[unit])
+        );
+      }
+      multiAsset.insert_assets(
+        own(CML.ScriptHash.from_hex(policy)),
+        assetsValue
       );
     }
-    multiAsset.insert_assets(CML.ScriptHash.from_hex(policy), assetsValue);
-  }
-  return CML.Value.new(lovelace, multiAsset);
+    return CML.Value.new(lovelace, multiAsset);
+  });
 }
 function fromUnit(unit) {
   const policyId = unit.slice(0, 56);
@@ -1441,10 +1494,10 @@ function addAssets(...assets) {
   }, {});
 }
 async function getUniqueTokenName(utxo) {
-  const id = (0, import_core_utils4.fromHex)(utxo.txHash);
+  const id = (0, import_core_utils5.fromHex)(utxo.txHash);
   const data = new Uint8Array([utxo.outputIndex, ...id]);
   const hash = new Uint8Array(await crypto.subtle.digest("SHA3-256", data));
-  return (0, import_core_utils4.toHex)(hash);
+  return (0, import_core_utils5.toHex)(hash);
 }
 var sortCanonical = (assets) => (0, import_effect.pipe)(
   Object.entries(assets).sort(([aUnit], [bUnit]) => {
@@ -1465,23 +1518,23 @@ var sortCanonical = (assets) => (0, import_effect.pipe)(
 );
 
 // src/utxo.ts
-var utxoToTransactionOutput = (utxo) => {
-  return buildOutput(utxo).with_value(assetsToValue(utxo.assets)).build().output();
-};
-var utxoToTransactionInput = (utxo) => {
-  return CML.TransactionInput.new(
-    CML.TransactionHash.from_hex(utxo.txHash),
+var utxoToTransactionOutput = (utxo) => (0, import_core_utils6.withCMLScope)((own) => {
+  const value = own(assetsToValue(utxo.assets));
+  const builder = own(buildOutput(utxo, own).with_value(value));
+  return own(builder.build()).output();
+});
+var utxoToTransactionInput = (utxo) => (0, import_core_utils6.withCMLScope)(
+  (own) => CML.TransactionInput.new(
+    own(CML.TransactionHash.from_hex(utxo.txHash)),
     BigInt(utxo.outputIndex)
-  );
-};
-var utxoToCore = (utxo) => {
-  const out = utxoToTransactionOutput(utxo);
-  const utxoCore = CML.TransactionUnspentOutput.new(
-    utxoToTransactionInput(utxo),
-    out
-  );
-  return utxoCore;
-};
+  )
+);
+var utxoToCore = (utxo) => (0, import_core_utils6.withCMLScope)(
+  (own) => CML.TransactionUnspentOutput.new(
+    own(utxoToTransactionInput(utxo)),
+    own(utxoToTransactionOutput(utxo))
+  )
+);
 function utxosToCores(utxos) {
   const result = [];
   for (const utxo of utxos) {
@@ -1490,11 +1543,10 @@ function utxosToCores(utxos) {
   return result;
 }
 function coreToUtxo(coreUtxo) {
-  const utxo = {
-    ...coreToOutRef(coreUtxo.input()),
-    ...coreToTxOutput(coreUtxo.output())
-  };
-  return utxo;
+  return (0, import_core_utils6.withCMLScope)((own) => ({
+    ...coreToOutRef(own(coreUtxo.input())),
+    ...coreToTxOutput(own(coreUtxo.output()))
+  }));
 }
 function coresToUtxos(utxos) {
   const result = [];
@@ -1504,10 +1556,10 @@ function coresToUtxos(utxos) {
   return result;
 }
 function coreToOutRef(input) {
-  return {
-    txHash: input.transaction_id().to_hex(),
+  return (0, import_core_utils6.withCMLScope)((own) => ({
+    txHash: own(input.transaction_id()).to_hex(),
     outputIndex: parseInt(input.index().toString())
-  };
+  }));
 }
 function coresToOutRefs(inputs) {
   const result = [];
@@ -1517,13 +1569,17 @@ function coresToOutRefs(inputs) {
   return result;
 }
 function coreToTxOutput(output) {
-  return {
-    assets: valueToAssets(output.amount()),
-    address: output.address().to_bech32(void 0),
-    datumHash: output.datum()?.as_hash()?.to_hex(),
-    datum: output.datum()?.as_datum()?.to_cbor_hex(),
-    scriptRef: output.script_ref() && fromScriptRef(output.script_ref())
-  };
+  return (0, import_core_utils6.withCMLScope)((own) => {
+    const datum = own(output.datum());
+    const scriptRef = own(output.script_ref());
+    return {
+      assets: valueToAssets(own(output.amount())),
+      address: own(output.address()).to_bech32(void 0),
+      datumHash: own(datum?.as_hash())?.to_hex(),
+      datum: own(datum?.as_datum())?.to_cbor_hex(),
+      scriptRef: scriptRef && fromScriptRef(scriptRef)
+    };
+  });
 }
 function coresToTxOutputs(outputs) {
   let result = [];
@@ -1608,25 +1664,36 @@ function getInputIndices(indexInputs, allInputs, sorted = false) {
     else return [];
   });
 }
-var calculateMinLovelaceFromUTxO = (coinsPerUtxoByte, utxo) => buildOutput(utxo).with_asset_and_min_required_coin(
-  assetsToValue(utxo.assets).multi_asset(),
-  coinsPerUtxoByte
-).build().output().amount().coin();
-var buildOutput = (utxo) => {
-  const builder = CML.TransactionOutputBuilder.new().with_address(
-    CML.Address.from_bech32(utxo.address)
+var calculateMinLovelaceFromUTxO = (coinsPerUtxoByte, utxo) => (0, import_core_utils6.withCMLScope)((own) => {
+  const value = own(assetsToValue(utxo.assets));
+  const builder = own(
+    buildOutput(utxo, own).with_asset_and_min_required_coin(
+      own(value.multi_asset()),
+      coinsPerUtxoByte
+    )
+  );
+  const output = own(own(builder.build()).output());
+  return own(output.amount()).coin();
+});
+var buildOutput = (utxo, own) => {
+  const address = own(CML.Address.from_bech32(utxo.address));
+  const addressed = own(
+    own(CML.TransactionOutputBuilder.new()).with_address(address)
   );
-  return utxo.scriptRef ? buildDatum(utxo, builder).with_reference_script(toScriptRef(utxo.scriptRef)).next() : buildDatum(utxo, builder).next();
+  const builder = buildDatum(utxo, addressed, own);
+  if (!utxo.scriptRef) return own(builder.next());
+  const scriptRef = own(toScriptRef(utxo.scriptRef));
+  return own(own(builder.with_reference_script(scriptRef)).next());
 };
-var buildDatum = (utxo, builder) => {
-  if (utxo.datumHash && utxo.datum)
-    return builder.with_communication_data(
-      CML.PlutusData.from_cbor_hex(utxo.datum)
-    );
-  if (utxo.datum)
-    return builder.with_data(
-      CML.DatumOption.new_datum(CML.PlutusData.from_cbor_hex(utxo.datum))
-    );
+var buildDatum = (utxo, builder, own) => {
+  if (utxo.datumHash && utxo.datum) {
+    const datum = own(CML.PlutusData.from_cbor_hex(utxo.datum));
+    return own(builder.with_communication_data(datum));
+  }
+  if (utxo.datum) {
+    const datum = own(CML.PlutusData.from_cbor_hex(utxo.datum));
+    return own(builder.with_data(own(CML.DatumOption.new_datum(datum))));
+  }
   return builder;
 };