@lucid-evolution/utils 0.0.1

package/dist/index.js

@@ -0,0 +1,1080 @@
+// src/native.ts
+import * as CML from "@dcspark/cardano-multiplatform-lib-nodejs";
+var toNativeScript = (native) => {
+  switch (native.type) {
+    case "sig":
+      return CML.NativeScript.new_script_pubkey(
+        CML.Ed25519KeyHash.from_hex(native.keyHash)
+      );
+    case "before":
+      return CML.NativeScript.new_script_invalid_hereafter(BigInt(native.slot));
+    case "after":
+      return CML.NativeScript.new_script_invalid_before(BigInt(native.slot));
+    case "all": {
+      const nativeList = CML.NativeScriptList.new();
+      native.scripts.map((script) => nativeList.add(toNativeScript(script)));
+      return CML.NativeScript.new_script_all(nativeList);
+    }
+    case "any": {
+      const nativeList = CML.NativeScriptList.new();
+      native.scripts.map((script) => nativeList.add(toNativeScript(script)));
+      return CML.NativeScript.new_script_any(nativeList);
+    }
+    case "atLeast": {
+      const nativeList = CML.NativeScriptList.new();
+      native.scripts.map((script) => nativeList.add(toNativeScript(script)));
+      return CML.NativeScript.new_script_n_of_k(
+        BigInt(native.required),
+        nativeList
+      );
+    }
+  }
+};
+var nativeJSFromJson = (native) => {
+  return {
+    type: "Native",
+    script: toNativeScript(native).to_cbor_hex()
+  };
+};
+
+// src/address.ts
+import * as CML3 from "@dcspark/cardano-multiplatform-lib-nodejs";
+
+// src/network.ts
+function networkToId(network) {
+  switch (network) {
+    case "Preview":
+      return 0;
+    case "Preprod":
+      return 0;
+    case "Custom":
+      return 0;
+    case "Mainnet":
+      return 1;
+    default:
+      throw new Error("Network not found");
+  }
+}
+
+// src/scripts.ts
+import * as CML2 from "@dcspark/cardano-multiplatform-lib-nodejs";
+
+// src/cbor.ts
+import { applyDoubleCborEncoding } from "lucid-cardano";
+
+// src/scripts.ts
+function validatorToAddress(network, validator, stakeCredential) {
+  const validatorHash = validatorToScriptHash(validator);
+  if (stakeCredential) {
+    return CML2.BaseAddress.new(
+      networkToId(network),
+      CML2.Credential.new_script(CML2.ScriptHash.from_hex(validatorHash)),
+      stakeCredential.type === "Key" ? CML2.Credential.new_pub_key(
+        CML2.Ed25519KeyHash.from_hex(stakeCredential.hash)
+      ) : CML2.Credential.new_script(
+        CML2.ScriptHash.from_hex(stakeCredential.hash)
+      )
+    ).to_address().to_bech32(void 0);
+  } else {
+    return CML2.EnterpriseAddress.new(
+      networkToId(network),
+      CML2.Credential.new_script(CML2.ScriptHash.from_hex(validatorHash))
+    ).to_address().to_bech32(void 0);
+  }
+}
+function validatorToScriptHash(validator) {
+  switch (validator.type) {
+    case "Native":
+      return CML2.NativeScript.from_cbor_hex(validator.script).hash().to_hex();
+    case "PlutusV1":
+      return CML2.PlutusScript.from_v1(
+        CML2.PlutusV1Script.from_cbor_hex(
+          applyDoubleCborEncoding(validator.script)
+        )
+      ).hash().to_hex();
+    case "PlutusV2":
+      return CML2.PlutusScript.from_v2(
+        CML2.PlutusV2Script.from_cbor_hex(
+          applyDoubleCborEncoding(validator.script)
+        )
+      ).hash().to_hex();
+    default:
+      throw new Error("No variant matched");
+  }
+}
+function toScriptRef(script) {
+  switch (script.type) {
+    case "Native":
+      return CML2.Script.new_native(
+        CML2.NativeScript.from_cbor_hex(script.script)
+      );
+    case "PlutusV1":
+      return CML2.Script.new_plutus_v1(
+        CML2.PlutusV1Script.from_cbor_hex(
+          applyDoubleCborEncoding(script.script)
+        )
+      );
+    case "PlutusV2":
+      return CML2.Script.new_plutus_v2(
+        CML2.PlutusV2Script.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()
+      };
+    default:
+      throw new Error("No variant matched.");
+  }
+}
+function mintingPolicyToId(mintingPolicy) {
+  return validatorToScriptHash(mintingPolicy);
+}
+function nativeFromJson(nativeScript) {
+  return nativeJSFromJson(nativeScript);
+}
+function nativeScriptFromJson(nativeScript) {
+  return {
+    type: "Native",
+    script: CML2.NativeScript.from_json(
+      JSON.stringify(nativeScript)
+    ).to_cbor_hex()
+  };
+}
+
+// src/address.ts
+function addressFromHexOrBech32(address) {
+  try {
+    return CML3.Address.from_hex(address);
+  } catch (_e) {
+    try {
+      return CML3.Address.from_bech32(address);
+    } catch (_e2) {
+      throw new Error("Could not deserialize address.");
+    }
+  }
+}
+function credentialToRewardAddress(network, stakeCredential) {
+  return CML3.RewardAddress.new(
+    networkToId(network),
+    stakeCredential.type === "Key" ? CML3.Credential.new_pub_key(
+      CML3.Ed25519KeyHash.from_hex(stakeCredential.hash)
+    ) : CML3.Credential.new_script(
+      CML3.ScriptHash.from_hex(stakeCredential.hash)
+    )
+  ).to_address().to_bech32(void 0);
+}
+function validatorToRewardAddress(network, validator) {
+  const validatorHash = validatorToScriptHash(validator);
+  return CML3.RewardAddress.new(
+    networkToId(network),
+    CML3.Credential.new_script(CML3.ScriptHash.from_hex(validatorHash))
+  ).to_address().to_bech32(void 0);
+}
+function getAddressDetails(address) {
+  try {
+    const parsedAddress = CML3.BaseAddress.from_address(
+      CML3.Address.from_bech32(address)
+    );
+    const paymentCredential = parsedAddress.payment().kind() === 0 ? {
+      type: "Key",
+      // hash: toHex(
+      //   parsedAddress.payment_cred().to_keyhash()!.to_bytes(),
+      // ),
+      hash: parsedAddress.payment().as_pub_key().to_hex()
+    } : {
+      type: "Script",
+      // hash: toHex(
+      //   parsedAddress.payment_cred().to_scripthash()!.to_bytes(),
+      // ),
+      hash: parsedAddress.payment().as_script().to_hex()
+    };
+    const stakeCredential = parsedAddress.stake().kind() === 0 ? (
+      // parsedAddress.stake_cred().kind() === 0
+      {
+        type: "Key",
+        hash: parsedAddress.stake().as_pub_key().to_hex()
+        // hash: toHex(parsedAddress.stake_cred().to_keyhash()!.to_bytes()),
+      }
+    ) : {
+      type: "Script",
+      // hash: toHex(parsedAddress.stake_cred().to_scripthash()!.to_bytes()),
+      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: toHex(parsedAddress.to_address().to_bytes()),
+        hex: parsedAddress.to_address().to_hex()
+      },
+      paymentCredential,
+      stakeCredential
+    };
+  } catch (_e) {
+  }
+  try {
+    const parsedAddress = CML3.EnterpriseAddress.from_address(
+      CML3.Address.from_bech32(address)
+    );
+    const paymentCredential = parsedAddress.payment().kind() === 0 ? {
+      type: "Key",
+      // hash: toHex(parsedAddress.payment_cred().to_keyhash()!.to_bytes()),
+      hash: parsedAddress.payment().as_pub_key().to_hex()
+    } : {
+      type: "Script",
+      hash: (
+        // parsedAddress.payment_cred().to_scripthash()!.to_bytes()
+        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
+    };
+  } catch (_e) {
+  }
+  try {
+    const parsedAddress = CML3.PointerAddress.from_address(
+      CML3.Address.from_bech32(address)
+    );
+    const paymentCredential = parsedAddress?.payment().kind() === 0 ? {
+      type: "Key",
+      // hash: toHex(parsedAddress.payment_cred().to_keyhash()!.to_bytes()),
+      hash: parsedAddress.payment().as_pub_key().to_hex()
+    } : {
+      type: "Script",
+      // hash: toHex( parsedAddress.payment_cred().to_scripthash()!.to_bytes()),
+      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: toHex(parsedAddress.to_address().to_bytes()),
+        hex: parsedAddress.to_address().to_hex()
+      },
+      paymentCredential
+    };
+  } catch (_e) {
+  }
+  try {
+    const parsedAddress = CML3.RewardAddress.from_address(
+      CML3.Address.from_bech32(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: toHex(parsedAddress.to_address().to_bytes()),
+        hex: parsedAddress.to_address().to_hex()
+      },
+      stakeCredential
+    };
+  } catch (_e) {
+  }
+  try {
+    const parsedAddress = ((address2) => {
+      try {
+        return CML3.ByronAddress.from_cbor_hex(address2);
+      } catch (_e) {
+        try {
+          return CML3.ByronAddress.from_base58(address2);
+        } catch (_e2) {
+          throw new Error("Could not deserialize address.");
+        }
+      }
+    })(address);
+    return {
+      type: "Byron",
+      networkId: parsedAddress.content().network_id(),
+      address: {
+        bech32: "",
+        // hex: toHex(parsedAddress.to_address().to_bytes()),
+        hex: parsedAddress.to_address().to_hex()
+      }
+    };
+  } catch (_e) {
+  }
+  throw new Error("No address type matched for: " + address);
+}
+
+// src/cost_model.ts
+import * as CML4 from "@dcspark/cardano-multiplatform-lib-nodejs";
+function createCostModels(costModels) {
+  const costmdls = CML4.CostModels.new();
+  const costmdlV1 = CML4.IntList.new();
+  Object.values(costModels.PlutusV2).forEach((cost) => {
+    costmdlV1.add(CML4.Int.new(BigInt(cost)));
+  });
+  costmdls.set_plutus_v1(costmdlV1);
+  const costmdlV2 = CML4.IntList.new();
+  Object.values(costModels.PlutusV2).forEach((cost) => {
+    costmdlV2.add(CML4.Int.new(BigInt(cost)));
+  });
+  costmdls.set_plutus_v2(costmdlV2);
+  return costmdls;
+}
+var PROTOCOL_PARAMETERS_DEFAULT = {
+  minFeeA: 44,
+  minFeeB: 155381,
+  maxTxSize: 16384,
+  maxValSize: 5e3,
+  keyDeposit: 2000000n,
+  poolDeposit: 500000000n,
+  priceMem: 0.0577,
+  priceStep: 721e-7,
+  maxTxExMem: 14000000n,
+  maxTxExSteps: 10000000000n,
+  coinsPerUtxoByte: 4310n,
+  collateralPercentage: 150,
+  maxCollateralInputs: 3,
+  costModels: {
+    PlutusV1: {
+      "addInteger-cpu-arguments-intercept": 205665,
+      "addInteger-cpu-arguments-slope": 812,
+      "addInteger-memory-arguments-intercept": 1,
+      "addInteger-memory-arguments-slope": 1,
+      "appendByteString-cpu-arguments-intercept": 1e3,
+      "appendByteString-cpu-arguments-slope": 571,
+      "appendByteString-memory-arguments-intercept": 0,
+      "appendByteString-memory-arguments-slope": 1,
+      "appendString-cpu-arguments-intercept": 1e3,
+      "appendString-cpu-arguments-slope": 24177,
+      "appendString-memory-arguments-intercept": 4,
+      "appendString-memory-arguments-slope": 1,
+      "bData-cpu-arguments": 1e3,
+      "bData-memory-arguments": 32,
+      "blake2b_256-cpu-arguments-intercept": 117366,
+      "blake2b_256-cpu-arguments-slope": 10475,
+      "blake2b_256-memory-arguments": 4,
+      "cekApplyCost-exBudgetCPU": 23e3,
+      "cekApplyCost-exBudgetMemory": 100,
+      "cekBuiltinCost-exBudgetCPU": 23e3,
+      "cekBuiltinCost-exBudgetMemory": 100,
+      "cekConstCost-exBudgetCPU": 23e3,
+      "cekConstCost-exBudgetMemory": 100,
+      "cekDelayCost-exBudgetCPU": 23e3,
+      "cekDelayCost-exBudgetMemory": 100,
+      "cekForceCost-exBudgetCPU": 23e3,
+      "cekForceCost-exBudgetMemory": 100,
+      "cekLamCost-exBudgetCPU": 23e3,
+      "cekLamCost-exBudgetMemory": 100,
+      "cekStartupCost-exBudgetCPU": 100,
+      "cekStartupCost-exBudgetMemory": 100,
+      "cekVarCost-exBudgetCPU": 23e3,
+      "cekVarCost-exBudgetMemory": 100,
+      "chooseData-cpu-arguments": 19537,
+      "chooseData-memory-arguments": 32,
+      "chooseList-cpu-arguments": 175354,
+      "chooseList-memory-arguments": 32,
+      "chooseUnit-cpu-arguments": 46417,
+      "chooseUnit-memory-arguments": 4,
+      "consByteString-cpu-arguments-intercept": 221973,
+      "consByteString-cpu-arguments-slope": 511,
+      "consByteString-memory-arguments-intercept": 0,
+      "consByteString-memory-arguments-slope": 1,
+      "constrData-cpu-arguments": 89141,
+      "constrData-memory-arguments": 32,
+      "decodeUtf8-cpu-arguments-intercept": 497525,
+      "decodeUtf8-cpu-arguments-slope": 14068,
+      "decodeUtf8-memory-arguments-intercept": 4,
+      "decodeUtf8-memory-arguments-slope": 2,
+      "divideInteger-cpu-arguments-constant": 196500,
+      "divideInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "divideInteger-cpu-arguments-model-arguments-slope": 220,
+      "divideInteger-memory-arguments-intercept": 0,
+      "divideInteger-memory-arguments-minimum": 1,
+      "divideInteger-memory-arguments-slope": 1,
+      "encodeUtf8-cpu-arguments-intercept": 1e3,
+      "encodeUtf8-cpu-arguments-slope": 28662,
+      "encodeUtf8-memory-arguments-intercept": 4,
+      "encodeUtf8-memory-arguments-slope": 2,
+      "equalsByteString-cpu-arguments-constant": 245e3,
+      "equalsByteString-cpu-arguments-intercept": 216773,
+      "equalsByteString-cpu-arguments-slope": 62,
+      "equalsByteString-memory-arguments": 1,
+      "equalsData-cpu-arguments-intercept": 1060367,
+      "equalsData-cpu-arguments-slope": 12586,
+      "equalsData-memory-arguments": 1,
+      "equalsInteger-cpu-arguments-intercept": 208512,
+      "equalsInteger-cpu-arguments-slope": 421,
+      "equalsInteger-memory-arguments": 1,
+      "equalsString-cpu-arguments-constant": 187e3,
+      "equalsString-cpu-arguments-intercept": 1e3,
+      "equalsString-cpu-arguments-slope": 52998,
+      "equalsString-memory-arguments": 1,
+      "fstPair-cpu-arguments": 80436,
+      "fstPair-memory-arguments": 32,
+      "headList-cpu-arguments": 43249,
+      "headList-memory-arguments": 32,
+      "iData-cpu-arguments": 1e3,
+      "iData-memory-arguments": 32,
+      "ifThenElse-cpu-arguments": 80556,
+      "ifThenElse-memory-arguments": 1,
+      "indexByteString-cpu-arguments": 57667,
+      "indexByteString-memory-arguments": 4,
+      "lengthOfByteString-cpu-arguments": 1e3,
+      "lengthOfByteString-memory-arguments": 10,
+      "lessThanByteString-cpu-arguments-intercept": 197145,
+      "lessThanByteString-cpu-arguments-slope": 156,
+      "lessThanByteString-memory-arguments": 1,
+      "lessThanEqualsByteString-cpu-arguments-intercept": 197145,
+      "lessThanEqualsByteString-cpu-arguments-slope": 156,
+      "lessThanEqualsByteString-memory-arguments": 1,
+      "lessThanEqualsInteger-cpu-arguments-intercept": 204924,
+      "lessThanEqualsInteger-cpu-arguments-slope": 473,
+      "lessThanEqualsInteger-memory-arguments": 1,
+      "lessThanInteger-cpu-arguments-intercept": 208896,
+      "lessThanInteger-cpu-arguments-slope": 511,
+      "lessThanInteger-memory-arguments": 1,
+      "listData-cpu-arguments": 52467,
+      "listData-memory-arguments": 32,
+      "mapData-cpu-arguments": 64832,
+      "mapData-memory-arguments": 32,
+      "mkCons-cpu-arguments": 65493,
+      "mkCons-memory-arguments": 32,
+      "mkNilData-cpu-arguments": 22558,
+      "mkNilData-memory-arguments": 32,
+      "mkNilPairData-cpu-arguments": 16563,
+      "mkNilPairData-memory-arguments": 32,
+      "mkPairData-cpu-arguments": 76511,
+      "mkPairData-memory-arguments": 32,
+      "modInteger-cpu-arguments-constant": 196500,
+      "modInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "modInteger-cpu-arguments-model-arguments-slope": 220,
+      "modInteger-memory-arguments-intercept": 0,
+      "modInteger-memory-arguments-minimum": 1,
+      "modInteger-memory-arguments-slope": 1,
+      "multiplyInteger-cpu-arguments-intercept": 69522,
+      "multiplyInteger-cpu-arguments-slope": 11687,
+      "multiplyInteger-memory-arguments-intercept": 0,
+      "multiplyInteger-memory-arguments-slope": 1,
+      "nullList-cpu-arguments": 60091,
+      "nullList-memory-arguments": 32,
+      "quotientInteger-cpu-arguments-constant": 196500,
+      "quotientInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "quotientInteger-cpu-arguments-model-arguments-slope": 220,
+      "quotientInteger-memory-arguments-intercept": 0,
+      "quotientInteger-memory-arguments-minimum": 1,
+      "quotientInteger-memory-arguments-slope": 1,
+      "remainderInteger-cpu-arguments-constant": 196500,
+      "remainderInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "remainderInteger-cpu-arguments-model-arguments-slope": 220,
+      "remainderInteger-memory-arguments-intercept": 0,
+      "remainderInteger-memory-arguments-minimum": 1,
+      "remainderInteger-memory-arguments-slope": 1,
+      "sha2_256-cpu-arguments-intercept": 806990,
+      "sha2_256-cpu-arguments-slope": 30482,
+      "sha2_256-memory-arguments": 4,
+      "sha3_256-cpu-arguments-intercept": 1927926,
+      "sha3_256-cpu-arguments-slope": 82523,
+      "sha3_256-memory-arguments": 4,
+      "sliceByteString-cpu-arguments-intercept": 265318,
+      "sliceByteString-cpu-arguments-slope": 0,
+      "sliceByteString-memory-arguments-intercept": 4,
+      "sliceByteString-memory-arguments-slope": 0,
+      "sndPair-cpu-arguments": 85931,
+      "sndPair-memory-arguments": 32,
+      "subtractInteger-cpu-arguments-intercept": 205665,
+      "subtractInteger-cpu-arguments-slope": 812,
+      "subtractInteger-memory-arguments-intercept": 1,
+      "subtractInteger-memory-arguments-slope": 1,
+      "tailList-cpu-arguments": 41182,
+      "tailList-memory-arguments": 32,
+      "trace-cpu-arguments": 212342,
+      "trace-memory-arguments": 32,
+      "unBData-cpu-arguments": 31220,
+      "unBData-memory-arguments": 32,
+      "unConstrData-cpu-arguments": 32696,
+      "unConstrData-memory-arguments": 32,
+      "unIData-cpu-arguments": 43357,
+      "unIData-memory-arguments": 32,
+      "unListData-cpu-arguments": 32247,
+      "unListData-memory-arguments": 32,
+      "unMapData-cpu-arguments": 38314,
+      "unMapData-memory-arguments": 32,
+      "verifyEd25519Signature-cpu-arguments-intercept": 9462713,
+      "verifyEd25519Signature-cpu-arguments-slope": 1021,
+      "verifyEd25519Signature-memory-arguments": 10
+    },
+    PlutusV2: {
+      "addInteger-cpu-arguments-intercept": 205665,
+      "addInteger-cpu-arguments-slope": 812,
+      "addInteger-memory-arguments-intercept": 1,
+      "addInteger-memory-arguments-slope": 1,
+      "appendByteString-cpu-arguments-intercept": 1e3,
+      "appendByteString-cpu-arguments-slope": 571,
+      "appendByteString-memory-arguments-intercept": 0,
+      "appendByteString-memory-arguments-slope": 1,
+      "appendString-cpu-arguments-intercept": 1e3,
+      "appendString-cpu-arguments-slope": 24177,
+      "appendString-memory-arguments-intercept": 4,
+      "appendString-memory-arguments-slope": 1,
+      "bData-cpu-arguments": 1e3,
+      "bData-memory-arguments": 32,
+      "blake2b_256-cpu-arguments-intercept": 117366,
+      "blake2b_256-cpu-arguments-slope": 10475,
+      "blake2b_256-memory-arguments": 4,
+      "cekApplyCost-exBudgetCPU": 23e3,
+      "cekApplyCost-exBudgetMemory": 100,
+      "cekBuiltinCost-exBudgetCPU": 23e3,
+      "cekBuiltinCost-exBudgetMemory": 100,
+      "cekConstCost-exBudgetCPU": 23e3,
+      "cekConstCost-exBudgetMemory": 100,
+      "cekDelayCost-exBudgetCPU": 23e3,
+      "cekDelayCost-exBudgetMemory": 100,
+      "cekForceCost-exBudgetCPU": 23e3,
+      "cekForceCost-exBudgetMemory": 100,
+      "cekLamCost-exBudgetCPU": 23e3,
+      "cekLamCost-exBudgetMemory": 100,
+      "cekStartupCost-exBudgetCPU": 100,
+      "cekStartupCost-exBudgetMemory": 100,
+      "cekVarCost-exBudgetCPU": 23e3,
+      "cekVarCost-exBudgetMemory": 100,
+      "chooseData-cpu-arguments": 19537,
+      "chooseData-memory-arguments": 32,
+      "chooseList-cpu-arguments": 175354,
+      "chooseList-memory-arguments": 32,
+      "chooseUnit-cpu-arguments": 46417,
+      "chooseUnit-memory-arguments": 4,
+      "consByteString-cpu-arguments-intercept": 221973,
+      "consByteString-cpu-arguments-slope": 511,
+      "consByteString-memory-arguments-intercept": 0,
+      "consByteString-memory-arguments-slope": 1,
+      "constrData-cpu-arguments": 89141,
+      "constrData-memory-arguments": 32,
+      "decodeUtf8-cpu-arguments-intercept": 497525,
+      "decodeUtf8-cpu-arguments-slope": 14068,
+      "decodeUtf8-memory-arguments-intercept": 4,
+      "decodeUtf8-memory-arguments-slope": 2,
+      "divideInteger-cpu-arguments-constant": 196500,
+      "divideInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "divideInteger-cpu-arguments-model-arguments-slope": 220,
+      "divideInteger-memory-arguments-intercept": 0,
+      "divideInteger-memory-arguments-minimum": 1,
+      "divideInteger-memory-arguments-slope": 1,
+      "encodeUtf8-cpu-arguments-intercept": 1e3,
+      "encodeUtf8-cpu-arguments-slope": 28662,
+      "encodeUtf8-memory-arguments-intercept": 4,
+      "encodeUtf8-memory-arguments-slope": 2,
+      "equalsByteString-cpu-arguments-constant": 245e3,
+      "equalsByteString-cpu-arguments-intercept": 216773,
+      "equalsByteString-cpu-arguments-slope": 62,
+      "equalsByteString-memory-arguments": 1,
+      "equalsData-cpu-arguments-intercept": 1060367,
+      "equalsData-cpu-arguments-slope": 12586,
+      "equalsData-memory-arguments": 1,
+      "equalsInteger-cpu-arguments-intercept": 208512,
+      "equalsInteger-cpu-arguments-slope": 421,
+      "equalsInteger-memory-arguments": 1,
+      "equalsString-cpu-arguments-constant": 187e3,
+      "equalsString-cpu-arguments-intercept": 1e3,
+      "equalsString-cpu-arguments-slope": 52998,
+      "equalsString-memory-arguments": 1,
+      "fstPair-cpu-arguments": 80436,
+      "fstPair-memory-arguments": 32,
+      "headList-cpu-arguments": 43249,
+      "headList-memory-arguments": 32,
+      "iData-cpu-arguments": 1e3,
+      "iData-memory-arguments": 32,
+      "ifThenElse-cpu-arguments": 80556,
+      "ifThenElse-memory-arguments": 1,
+      "indexByteString-cpu-arguments": 57667,
+      "indexByteString-memory-arguments": 4,
+      "lengthOfByteString-cpu-arguments": 1e3,
+      "lengthOfByteString-memory-arguments": 10,
+      "lessThanByteString-cpu-arguments-intercept": 197145,
+      "lessThanByteString-cpu-arguments-slope": 156,
+      "lessThanByteString-memory-arguments": 1,
+      "lessThanEqualsByteString-cpu-arguments-intercept": 197145,
+      "lessThanEqualsByteString-cpu-arguments-slope": 156,
+      "lessThanEqualsByteString-memory-arguments": 1,
+      "lessThanEqualsInteger-cpu-arguments-intercept": 204924,
+      "lessThanEqualsInteger-cpu-arguments-slope": 473,
+      "lessThanEqualsInteger-memory-arguments": 1,
+      "lessThanInteger-cpu-arguments-intercept": 208896,
+      "lessThanInteger-cpu-arguments-slope": 511,
+      "lessThanInteger-memory-arguments": 1,
+      "listData-cpu-arguments": 52467,
+      "listData-memory-arguments": 32,
+      "mapData-cpu-arguments": 64832,
+      "mapData-memory-arguments": 32,
+      "mkCons-cpu-arguments": 65493,
+      "mkCons-memory-arguments": 32,
+      "mkNilData-cpu-arguments": 22558,
+      "mkNilData-memory-arguments": 32,
+      "mkNilPairData-cpu-arguments": 16563,
+      "mkNilPairData-memory-arguments": 32,
+      "mkPairData-cpu-arguments": 76511,
+      "mkPairData-memory-arguments": 32,
+      "modInteger-cpu-arguments-constant": 196500,
+      "modInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "modInteger-cpu-arguments-model-arguments-slope": 220,
+      "modInteger-memory-arguments-intercept": 0,
+      "modInteger-memory-arguments-minimum": 1,
+      "modInteger-memory-arguments-slope": 1,
+      "multiplyInteger-cpu-arguments-intercept": 69522,
+      "multiplyInteger-cpu-arguments-slope": 11687,
+      "multiplyInteger-memory-arguments-intercept": 0,
+      "multiplyInteger-memory-arguments-slope": 1,
+      "nullList-cpu-arguments": 60091,
+      "nullList-memory-arguments": 32,
+      "quotientInteger-cpu-arguments-constant": 196500,
+      "quotientInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "quotientInteger-cpu-arguments-model-arguments-slope": 220,
+      "quotientInteger-memory-arguments-intercept": 0,
+      "quotientInteger-memory-arguments-minimum": 1,
+      "quotientInteger-memory-arguments-slope": 1,
+      "remainderInteger-cpu-arguments-constant": 196500,
+      "remainderInteger-cpu-arguments-model-arguments-intercept": 453240,
+      "remainderInteger-cpu-arguments-model-arguments-slope": 220,
+      "remainderInteger-memory-arguments-intercept": 0,
+      "remainderInteger-memory-arguments-minimum": 1,
+      "remainderInteger-memory-arguments-slope": 1,
+      "serialiseData-cpu-arguments-intercept": 1159724,
+      "serialiseData-cpu-arguments-slope": 392670,
+      "serialiseData-memory-arguments-intercept": 0,
+      "serialiseData-memory-arguments-slope": 2,
+      "sha2_256-cpu-arguments-intercept": 806990,
+      "sha2_256-cpu-arguments-slope": 30482,
+      "sha2_256-memory-arguments": 4,
+      "sha3_256-cpu-arguments-intercept": 1927926,
+      "sha3_256-cpu-arguments-slope": 82523,
+      "sha3_256-memory-arguments": 4,
+      "sliceByteString-cpu-arguments-intercept": 265318,
+      "sliceByteString-cpu-arguments-slope": 0,
+      "sliceByteString-memory-arguments-intercept": 4,
+      "sliceByteString-memory-arguments-slope": 0,
+      "sndPair-cpu-arguments": 85931,
+      "sndPair-memory-arguments": 32,
+      "subtractInteger-cpu-arguments-intercept": 205665,
+      "subtractInteger-cpu-arguments-slope": 812,
+      "subtractInteger-memory-arguments-intercept": 1,
+      "subtractInteger-memory-arguments-slope": 1,
+      "tailList-cpu-arguments": 41182,
+      "tailList-memory-arguments": 32,
+      "trace-cpu-arguments": 212342,
+      "trace-memory-arguments": 32,
+      "unBData-cpu-arguments": 31220,
+      "unBData-memory-arguments": 32,
+      "unConstrData-cpu-arguments": 32696,
+      "unConstrData-memory-arguments": 32,
+      "unIData-cpu-arguments": 43357,
+      "unIData-memory-arguments": 32,
+      "unListData-cpu-arguments": 32247,
+      "unListData-memory-arguments": 32,
+      "unMapData-cpu-arguments": 38314,
+      "unMapData-memory-arguments": 32,
+      "verifyEcdsaSecp256k1Signature-cpu-arguments": 35892428,
+      "verifyEcdsaSecp256k1Signature-memory-arguments": 10,
+      "verifyEd25519Signature-cpu-arguments-intercept": 57996947,
+      "verifyEd25519Signature-cpu-arguments-slope": 18975,
+      "verifyEd25519Signature-memory-arguments": 10,
+      "verifySchnorrSecp256k1Signature-cpu-arguments-intercept": 38887044,
+      "verifySchnorrSecp256k1Signature-cpu-arguments-slope": 32947,
+      "verifySchnorrSecp256k1Signature-memory-arguments": 10
+    }
+  }
+};
+
+// src/credential.ts
+import * as CML5 from "@dcspark/cardano-multiplatform-lib-nodejs";
+function credentialToAddress(network, paymentCredential, stakeCredential) {
+  if (stakeCredential) {
+    return CML5.BaseAddress.new(
+      networkToId(network),
+      paymentCredential.type === "Key" ? CML5.Credential.new_pub_key(
+        CML5.Ed25519KeyHash.from_hex(paymentCredential.hash)
+      ) : CML5.Credential.new_script(
+        CML5.ScriptHash.from_hex(paymentCredential.hash)
+      ),
+      stakeCredential.type === "Key" ? CML5.Credential.new_pub_key(
+        CML5.Ed25519KeyHash.from_hex(stakeCredential.hash)
+      ) : CML5.Credential.new_script(
+        CML5.ScriptHash.from_hex(stakeCredential.hash)
+      )
+    ).to_address().to_bech32(void 0);
+  } else {
+    return CML5.EnterpriseAddress.new(
+      networkToId(network),
+      paymentCredential.type === "Key" ? CML5.Credential.new_pub_key(
+        CML5.Ed25519KeyHash.from_hex(paymentCredential.hash)
+      ) : CML5.Credential.new_script(
+        CML5.ScriptHash.from_hex(paymentCredential.hash)
+      )
+    ).to_address().to_bech32(void 0);
+  }
+}
+function scriptHashToCredential(scriptHash) {
+  return {
+    type: "Script",
+    hash: scriptHash
+  };
+}
+function keyHashToCredential(keyHash) {
+  return {
+    type: "Key",
+    hash: keyHash
+  };
+}
+function paymentCredentialOf(address) {
+  const { paymentCredential } = getAddressDetails(address);
+  if (!paymentCredential) {
+    throw new Error(
+      "The specified address does not contain a payment credential."
+    );
+  }
+  return paymentCredential;
+}
+function stakeCredentialOf(rewardAddress) {
+  const { stakeCredential } = getAddressDetails(rewardAddress);
+  if (!stakeCredential) {
+    throw new Error(
+      "The specified address does not contain a stake credential."
+    );
+  }
+  return stakeCredential;
+}
+
+// src/datum.ts
+import * as CML6 from "@dcspark/cardano-multiplatform-lib-nodejs";
+function datumToHash(datum) {
+  return CML6.hash_plutus_data(CML6.PlutusData.from_cbor_hex(datum)).to_hex();
+}
+
+// src/keys.ts
+import { generateMnemonic } from "@lucid-evolution/bip39";
+import * as CML7 from "@dcspark/cardano-multiplatform-lib-nodejs";
+function generatePrivateKey() {
+  return CML7.PrivateKey.generate_ed25519().to_bech32();
+}
+function generateSeedPhrase() {
+  return generateMnemonic(256);
+}
+function toPublicKey(privateKey) {
+  return CML7.PrivateKey.from_bech32(privateKey).to_public().to_bech32();
+}
+
+// src/label.ts
+import { fromHex } from "@lucid-evolution/core-utils";
+import { crc8 } from "@lucid-evolution/crc8";
+function toLabel(num) {
+  if (num < 0 || num > 65535) {
+    throw new Error(
+      `Label ${num} out of range: min label 1 - max label 65535.`
+    );
+  }
+  const numHex = num.toString(16).padStart(4, "0");
+  return "0" + numHex + checksum(numHex) + "0";
+}
+function fromLabel(label) {
+  if (label.length !== 8 || !(label[0] === "0" && label[7] === "0")) {
+    return null;
+  }
+  const numHex = label.slice(1, 5);
+  const num = parseInt(numHex, 16);
+  const check = label.slice(5, 7);
+  return check === checksum(numHex) ? num : null;
+}
+function checksum(num) {
+  return crc8(fromHex(num)).toString(16).padStart(2, "0");
+}
+
+// src/time.ts
+import {
+  SLOT_CONFIG_NETWORK,
+  slotToBeginUnixTime,
+  unixTimeToEnclosingSlot
+} from "@lucid-evolution/plutus";
+function unixTimeToSlot(network, unixTime) {
+  return unixTimeToEnclosingSlot(unixTime, SLOT_CONFIG_NETWORK[network]);
+}
+function slotToUnixTime(network, slot) {
+  return slotToBeginUnixTime(slot, SLOT_CONFIG_NETWORK[network]);
+}
+
+// src/utxo.ts
+import * as CML9 from "@dcspark/cardano-multiplatform-lib-nodejs";
+
+// src/value.ts
+import { toText } from "@lucid-evolution/core-utils";
+import * as CML8 from "@dcspark/cardano-multiplatform-lib-nodejs";
+function valueToAssets(value) {
+  const assets = {};
+  assets["lovelace"] = value.coin();
+  const ma = value.multi_asset();
+  if (ma) {
+    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_cbor_hex();
+        assets[unit] = quantity;
+      }
+    }
+  }
+  return assets;
+}
+function assetsToValue(assets) {
+  const multiAsset = CML8.MultiAsset.new();
+  const lovelace = assets["lovelace"];
+  const units = Object.keys(assets);
+  const policies = Array.from(
+    new Set(
+      units.filter((unit) => unit !== "lovelace").map((unit) => unit.slice(0, 56))
+    )
+  );
+  policies.forEach((policy) => {
+    const policyUnits = units.filter((unit) => unit.slice(0, 56) === policy);
+    const assetsValue = CML8.MapAssetNameToCoin.new();
+    policyUnits.forEach((unit) => {
+      assetsValue.insert(
+        CML8.AssetName.from_str(toText(unit.slice(56))),
+        BigInt(assets[unit])
+      );
+    });
+    multiAsset.insert_assets(CML8.ScriptHash.from_hex(policy), assetsValue);
+  });
+  return CML8.Value.new(lovelace, multiAsset);
+}
+function fromUnit(unit) {
+  const policyId = unit.slice(0, 56);
+  const assetName = unit.slice(56) || null;
+  const label = fromLabel(unit.slice(56, 64));
+  const name = (() => {
+    const hexName = Number.isInteger(label) ? unit.slice(64) : unit.slice(56);
+    return hexName || null;
+  })();
+  return { policyId, assetName, name, label };
+}
+function toUnit(policyId, name, label) {
+  const hexLabel = Number.isInteger(label) ? toLabel(label) : "";
+  const n = name ? name : "";
+  if ((n + hexLabel).length > 64) {
+    throw new Error("Asset name size exceeds 32 bytes.");
+  }
+  if (policyId.length !== 56) {
+    throw new Error(`Policy id invalid: ${policyId}.`);
+  }
+  return policyId + hexLabel + n;
+}
+function addAssets(...assets) {
+  return assets.reduce((a, b) => {
+    for (const k in b) {
+      if (Object.hasOwn(b, k)) {
+        a[k] = (a[k] || 0n) + b[k];
+      }
+    }
+    return a;
+  }, {});
+}
+
+// src/utxo.ts
+var utxoToTransactionOutput = (utxo) => {
+  const address = (() => {
+    try {
+      return CML9.Address.from_bech32(utxo.address);
+    } catch (_e) {
+      return CML9.ByronAddress.from_base58(utxo.address).to_address();
+    }
+  })();
+  const datumOption = (() => {
+    if (utxo.datumHash) {
+      return CML9.DatumOption.new_hash(CML9.DatumHash.from_hex(utxo.datumHash));
+    }
+    if (!utxo.datumHash && utxo.datum) {
+      return CML9.DatumOption.new_datum(
+        CML9.PlutusData.from_cbor_hex(utxo.datum)
+      );
+    }
+  })();
+  const scriptRef = (() => {
+    if (utxo.scriptRef) {
+      return toScriptRef(utxo.scriptRef);
+    }
+  })();
+  return CML9.TransactionOutput.new(
+    address,
+    assetsToValue(utxo.assets),
+    datumOption,
+    scriptRef
+  );
+};
+var utxoToTransactionInput = (utxo) => {
+  return CML9.TransactionInput.new(
+    CML9.TransactionHash.from_hex(utxo.txHash),
+    BigInt(utxo.outputIndex)
+  );
+};
+function utxoToCore(utxo) {
+  const address = (() => {
+    try {
+      return CML9.Address.from_bech32(utxo.address);
+    } catch (_e) {
+      return CML9.ByronAddress.from_base58(utxo.address).to_address();
+    }
+  })();
+  const datumOption = (() => {
+    if (utxo.datumHash) {
+      return CML9.DatumOption.new_hash(CML9.DatumHash.from_hex(utxo.datumHash));
+    }
+    if (!utxo.datumHash && utxo.datum) {
+      return CML9.DatumOption.new_datum(
+        CML9.PlutusData.from_cbor_hex(utxo.datum)
+      );
+    }
+  })();
+  const scriptRef = (() => {
+    if (utxo.scriptRef) {
+      return toScriptRef(utxo.scriptRef);
+    }
+  })();
+  const output = CML9.TransactionOutput.new(
+    address,
+    assetsToValue(utxo.assets),
+    datumOption,
+    scriptRef
+  );
+  return CML9.TransactionUnspentOutput.new(
+    CML9.TransactionInput.new(
+      CML9.TransactionHash.from_hex(utxo.txHash),
+      BigInt(utxo.outputIndex)
+    ),
+    output
+  );
+}
+function utxosToCores(utxos) {
+  const result = [];
+  utxos.map(utxoToCore).forEach((utxo) => result.push(utxo));
+  return result;
+}
+function coreToUtxo(coreUtxo) {
+  return {
+    ...coreToOutRef(CML9.TransactionInput.from_cbor_hex(coreUtxo.to_cbor_hex())),
+    ...coreToTxOutput(
+      CML9.TransactionOutput.from_cbor_hex(coreUtxo.to_cbor_hex())
+    )
+  };
+}
+function coresToUtxos(utxos) {
+  const result = [];
+  for (let i = 0; i < utxos.length; i++) {
+    result.push(coreToUtxo(utxos[i]));
+  }
+  return result;
+}
+function coreToOutRef(input) {
+  return {
+    txHash: input.transaction_id().to_hex(),
+    outputIndex: parseInt(input.index().toString())
+  };
+}
+function coresToOutRefs(inputs) {
+  const result = [];
+  for (let i = 0; i < inputs.length; i++) {
+    result.push(coreToOutRef(inputs[i]));
+  }
+  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())
+  };
+}
+function coresToTxOutputs(outputs) {
+  const result = [];
+  for (let i = 0; i < outputs.length; i++) {
+    result.push(coreToTxOutput(outputs[i]));
+  }
+  return result;
+}
+export {
+  PROTOCOL_PARAMETERS_DEFAULT,
+  addAssets,
+  addressFromHexOrBech32,
+  applyDoubleCborEncoding,
+  assetsToValue,
+  coreToOutRef,
+  coreToTxOutput,
+  coreToUtxo,
+  coresToOutRefs,
+  coresToTxOutputs,
+  coresToUtxos,
+  createCostModels,
+  credentialToAddress,
+  credentialToRewardAddress,
+  datumToHash,
+  fromLabel,
+  fromScriptRef,
+  fromUnit,
+  generatePrivateKey,
+  generateSeedPhrase,
+  getAddressDetails,
+  keyHashToCredential,
+  mintingPolicyToId,
+  nativeFromJson,
+  nativeJSFromJson,
+  nativeScriptFromJson,
+  networkToId,
+  paymentCredentialOf,
+  scriptHashToCredential,
+  slotToUnixTime,
+  stakeCredentialOf,
+  toLabel,
+  toNativeScript,
+  toPublicKey,
+  toScriptRef,
+  toUnit,
+  unixTimeToSlot,
+  utxoToCore,
+  utxoToTransactionInput,
+  utxoToTransactionOutput,
+  utxosToCores,
+  validatorToAddress,
+  validatorToRewardAddress,
+  validatorToScriptHash,
+  valueToAssets
+};