@meshsdk/core-csl 1.8.13 → 1.9.0-beta-38

package/dist/index.js

@@ -5,7 +5,7 @@ import {
 } from "@meshsdk/common";
 
 // src/deser/csl.ts
-import * as csl from "@sidan-lab/sidan-csl-rs-nodejs";
+import * as csl from "@sidan-lab/whisky-js-nodejs";
 
 // src/deser/constants.ts
 var LANGUAGE_VERSIONS = {
@@ -23,10 +23,10 @@ var POLICY_ID_LENGTH = 56;
 
 // src/deser/converter.ts
 import JSONbig from "json-bigint";
-var toAddress = (bech322) => csl.Address.from_bech32(bech322);
-var toBaseAddress = (bech322) => csl.BaseAddress.from_address(toAddress(bech322));
-var toEnterpriseAddress = (bech322) => csl.EnterpriseAddress.from_address(toAddress(bech322));
-var toRewardAddress = (bech322) => csl.RewardAddress.from_address(toAddress(bech322));
+var toAddress = (bech32) => csl.Address.from_bech32(bech32);
+var toBaseAddress = (bech32) => csl.BaseAddress.from_address(toAddress(bech32));
+var toEnterpriseAddress = (bech32) => csl.EnterpriseAddress.from_address(toAddress(bech32));
+var toRewardAddress = (bech32) => csl.RewardAddress.from_address(toAddress(bech32));
 var fromBytes = (bytes) => Buffer.from(bytes).toString("hex");
 var toBytes = (hex) => {
   if (hex.length % 2 === 0 && /^[0-9A-F]*$/i.test(hex))
@@ -101,7 +101,7 @@ var castDataToPlutusData = ({
     return csl.PlutusData.from_hex(content);
   }
   return csl.PlutusData.from_json(
-    content,
+    castRawDataToJsonString(content),
     csl.PlutusDatumSchema.DetailedSchema
   );
 };
@@ -140,6 +140,29 @@ var toNativeScript = (script) => {
       );
   }
 };
+var toCslValue = (assets) => {
+  let cslValue = void 0;
+  let multiAsset = csl.MultiAsset.new();
+  for (const asset of assets) {
+    if (asset.unit === "lovelace" || asset.unit === "") {
+      cslValue = csl.Value.new(csl.BigNum.from_str(asset.quantity));
+    } else {
+      const policyId = csl.ScriptHash.from_hex(asset.unit.slice(0, 56));
+      const assetName = csl.AssetName.new(
+        Buffer.from(asset.unit.slice(56), "hex")
+      );
+      const quantity = csl.BigNum.from_str(asset.quantity);
+      multiAsset.set_asset(policyId, assetName, quantity);
+    }
+  }
+  if (cslValue !== void 0) {
+    cslValue.set_multiasset(multiAsset);
+  } else {
+    cslValue = csl.Value.new(csl.BigNum.from_str("0"));
+    cslValue.set_multiasset(multiAsset);
+  }
+  return cslValue;
+};
 
 // src/deser/deserializer.ts
 var deserializeAddress = (address) => csl.Address.from_bytes(toBytes(address));
@@ -167,14 +190,14 @@ var deserializeValue = (value) => csl.Value.from_bytes(toBytes(value));
 import {
   mnemonicToEntropy
 } from "@meshsdk/common";
-var resolveStakeKeyHash = (bech322) => {
+var resolveStakeKeyHash = (bech32) => {
   try {
     const stakeKeyHash = [
-      toBaseAddress(bech322)?.stake_cred().to_keyhash(),
-      toRewardAddress(bech322)?.payment_cred().to_keyhash()
+      toBaseAddress(bech32)?.stake_cred().to_keyhash(),
+      toRewardAddress(bech32)?.payment_cred().to_keyhash()
     ].find((kh) => kh !== void 0);
     if (stakeKeyHash !== void 0) return stakeKeyHash.to_hex();
-    throw new Error(`Couldn't resolve stake key hash from address: ${bech322}`);
+    throw new Error(`Couldn't resolve stake key hash from address: ${bech32}`);
   } catch (error) {
     throw new Error(`An error occurred during resolveStakeKeyHash: ${error}.`);
   }
@@ -214,9 +237,9 @@ var resolveNativeScriptHash = (script) => {
 var resolveScriptHashDRepId = (scriptHash) => {
   return csl.DRep.new_script_hash(
     csl.ScriptHash.from_hex(scriptHash)
-  ).to_bech32();
+  ).to_bech32(true);
 };
-var resolveRewardAddress = (bech322) => {
+var resolveRewardAddress = (bech32) => {
   const buildRewardAddress = (networkId, stakeKeyHash) => {
     return csl.RewardAddress.new(
       networkId,
@@ -224,18 +247,21 @@ var resolveRewardAddress = (bech322) => {
     );
   };
   try {
-    const address = toAddress(bech322);
-    const baseAddress = toBaseAddress(bech322);
+    const address = toAddress(bech32);
+    const baseAddress = toBaseAddress(bech32);
     const stakeKeyHash = baseAddress?.stake_cred().to_keyhash();
     if (stakeKeyHash !== void 0)
       return buildRewardAddress(address.network_id(), stakeKeyHash).to_address().to_bech32();
-    throw new Error(`Couldn't resolve reward address from address: ${bech322}`);
+    throw new Error(`Couldn't resolve reward address from address: ${bech32}`);
   } catch (error) {
     throw new Error(`An error occurred during resolveRewardAddress: ${error}.`);
   }
 };
-var resolveDataHash = (data) => {
-  const plutusData = toPlutusData(data);
+var resolveDataHash = (rawData, type = "Mesh") => {
+  const plutusData = castDataToPlutusData({
+    content: rawData,
+    type
+  });
   const dataHash = csl.hash_plutus_data(plutusData);
   return dataHash.to_hex();
 };
@@ -248,8 +274,8 @@ var serializePoolId = (hash) => {
 var resolveScriptRef = (script) => {
   return toScriptRef(script).to_hex();
 };
-var resolveEd25519KeyHash = (bech322) => {
-  return csl.Ed25519KeyHash.from_bech32(bech322).to_hex();
+var resolveEd25519KeyHash = (bech32) => {
+  return csl.Ed25519KeyHash.from_bech32(bech32).to_hex();
 };
 
 // src/utils/scripts.ts
@@ -274,14 +300,14 @@ var serialzeAddress = (deserializedAddress, networkId = 0) => {
   const addressObj = isPaymentScript ? scriptAddress(paymentHash, stakeHash, isStakeScript) : pubKeyAddress(paymentHash, stakeHash, isStakeScript);
   return serializeAddressObj(addressObj, networkId);
 };
-var addrBech32ToHex = (bech322) => {
-  const hexAddress = csl.Address.from_bech32(bech322).to_hex();
+var addrBech32ToPlutusDataHex = (bech32) => {
+  const hexAddress = csl.Address.from_bech32(bech32).to_hex();
   const cslAddress = csl.Address.from_hex(hexAddress);
   const hex = csl.PlutusData.from_address(cslAddress).to_hex();
   return hex;
 };
-var addrBech32ToObj = (bech322) => {
-  const hexAddress = csl.Address.from_bech32(bech322).to_hex();
+var addrBech32ToPlutusDataObj = (bech32) => {
+  const hexAddress = csl.Address.from_bech32(bech32).to_hex();
   const cslAddress = csl.Address.from_hex(hexAddress);
   const json = JSON.parse(csl.PlutusData.from_address(cslAddress).to_json(1));
   return json;
@@ -380,6 +406,9 @@ var keyHashToRewardAddress = (keyHashHex, network = 1) => {
   return rewardAddress;
 };
 
+// src/utils/transaction.ts
+import { js_get_tx_outs_utxo } from "@sidan-lab/whisky-js-nodejs";
+
 // src/wasm.ts
 var parseWasmResult = (result) => {
   if (result.get_status() !== "success") {
@@ -407,13 +436,16 @@ var signTransaction = (txHex, signingKeys) => {
   const result = csl.js_sign_transaction(txHex, cslSigningKeys);
   return parseWasmResult(result);
 };
-var evaluateTransaction = (txHex, resolvedUtxos, network, slotConfig) => {
+var evaluateTransaction = (txHex, resolvedUtxos, chainedTxs, network, slotConfig) => {
   const additionalTxs = csl.JsVecString.new();
+  for (const tx of chainedTxs) {
+    additionalTxs.add(tx);
+  }
   const mappedUtxos = csl.JsVecString.new();
   for (const utxo of resolvedUtxos) {
     mappedUtxos.add(JSON.stringify(utxo));
   }
-  const result = csl.evaluate_tx_scripts_js(
+  const result = csl.js_evaluate_tx_scripts(
     txHex,
     mappedUtxos,
     additionalTxs,
@@ -478,7 +510,7 @@ var getTransactionInputs = (txHex) => {
     const input = cslInputs.get(i);
     inputs.push({
       txHash: input.transaction_id().to_hex(),
-      index: input.index()
+      outputIndex: input.index()
     });
   }
   const cslCollaterals = body.collateral();
@@ -487,7 +519,7 @@ var getTransactionInputs = (txHex) => {
       const collateral = cslCollaterals.get(i);
       inputs.push({
         txHash: collateral.transaction_id().to_hex(),
-        index: collateral.index()
+        outputIndex: collateral.index()
       });
     }
   }
@@ -497,20 +529,25 @@ var getTransactionInputs = (txHex) => {
       const refInput = cslRefInputs.get(i);
       inputs.push({
         txHash: refInput.transaction_id().to_hex(),
-        index: refInput.index()
+        outputIndex: refInput.index()
       });
     }
   }
   return inputs;
 };
+var getTransactionOutputs = (txHex) => {
+  const outputs = js_get_tx_outs_utxo(txHex).get_data();
+  const utxos = JSON.parse(outputs);
+  return utxos;
+};
 
 // src/utils/aiken.ts
 var applyParamsToScript = (rawScript, params, type = "Mesh") => {
   const cslParams = csl.JsVecString.new();
-  let paramType = csl.BuilderDataType.CBOR;
+  let paramType = "cbor";
   switch (type) {
     case "JSON":
-      paramType = csl.BuilderDataType.JSON;
+      paramType = "json";
       params.forEach((param) => {
         if (typeof param === "object") {
           cslParams.add(JSON.stringify(param));
@@ -537,68 +574,17 @@ var applyCborEncoding = (rawScript) => {
   return csl.js_apply_params_to_script(
     rawScript,
     csl.JsVecString.new(),
-    csl.BuilderDataType.CBOR
+    "cbor"
   );
 };
 
 // src/utils/drep.ts
-import base32 from "base32-encoding";
-import { bech32 } from "bech32";
 var getDRepIds = (dRepId) => {
+  const cslDrep = csl.DRep.from_bech32(dRepId);
   let result = {
-    cip105: "",
-    cip129: ""
+    cip105: cslDrep.to_bech32(false),
+    cip129: cslDrep.to_bech32(true)
   };
-  if (dRepId.length === 58) {
-    result.cip129 = dRepId;
-    const { prefix, words } = bech32.decode(dRepId);
-    if (prefix !== "drep") {
-      throw new Error("Malformed CIP129 DRepId");
-    }
-    const bytes = base32.decode(new Uint8Array(words));
-    if (bytes[0] === 34) {
-      result.cip105 = csl.DRep.new_key_hash(
-        csl.Ed25519KeyHash.from_hex(bytes.subarray(1).toString("hex"))
-      ).to_bech32();
-    } else if (bytes[0] === 35) {
-      result.cip105 = csl.DRep.new_script_hash(
-        csl.ScriptHash.from_hex(bytes.subarray(1).toString("hex"))
-      ).to_bech32();
-    } else {
-      throw new Error("Malformed CIP129 DRepId");
-    }
-  } else {
-    result.cip105 = dRepId;
-    try {
-      const cslDRep = csl.DRep.from_bech32(dRepId);
-      if (cslDRep.kind() === csl.DRepKind.KeyHash) {
-        let rawBytes = cslDRep.to_key_hash()?.to_bytes();
-        if (!rawBytes) {
-          throw new Error("Malformed key hash in DRepId");
-        }
-        let rawBytesWithPrefix = new Uint8Array(rawBytes.length + 1);
-        rawBytesWithPrefix.set([34]);
-        rawBytesWithPrefix.set(rawBytes, 1);
-        let base32RawBytes = base32.encode(rawBytesWithPrefix);
-        result.cip129 = bech32.encode("drep", base32RawBytes);
-      } else if (cslDRep.kind() === csl.DRepKind.ScriptHash) {
-        let rawBytes = cslDRep.to_script_hash()?.to_bytes();
-        if (!rawBytes) {
-          throw new Error("Malformed script hash in DRepId");
-        }
-        let rawBytesWithPrefix = new Uint8Array(rawBytes.length + 1);
-        rawBytesWithPrefix.set([35]);
-        rawBytesWithPrefix.set(rawBytes, 1);
-        let base32RawBytes = base32.encode(rawBytesWithPrefix);
-        result.cip129 = bech32.encode("drep", base32RawBytes);
-      } else {
-        throw new Error("Can only calculate DRepIds for script/key DReps");
-      }
-    } catch (e) {
-      console.error(e);
-      throw new Error("Malformed DRepId");
-    }
-  }
   return result;
 };
 
@@ -610,7 +596,9 @@ import {
 } from "@meshsdk/common";
 
 // src/core/adaptor/index.ts
-import { validityRangeToObj } from "@meshsdk/common";
+import {
+  validityRangeToObj
+} from "@meshsdk/common";
 
 // src/core/adaptor/data.ts
 var builderDataToCbor = ({ type, content }) => {
@@ -857,6 +845,41 @@ var relayToObj = (relay) => {
   }
 };
 
+// src/core/adaptor/metadata.ts
+import JSONbig2 from "json-bigint";
+var txMetadataToObj = (metadata) => {
+  const result = [];
+  metadata.forEach((value, key) => {
+    result.push({
+      tag: key.toString(),
+      metadata: JSONbig2.stringify(metadatumToObj(value))
+    });
+  });
+  return result;
+};
+var metadatumToObj = (metadatum) => {
+  if (typeof metadatum === "number" || typeof metadatum === "string") {
+    return metadatum;
+  } else if (typeof metadatum === "bigint") {
+    return metadatum.toString();
+  } else if (metadatum instanceof Uint8Array) {
+    return uint8ArrayToHex(metadatum);
+  } else if (metadatum instanceof Map) {
+    const result = {};
+    metadatum.forEach((value, key) => {
+      result[metadatumToObj(key)] = metadatumToObj(value);
+    });
+    return result;
+  } else if (Array.isArray(metadatum)) {
+    return metadatum.map(metadatumToObj);
+  } else {
+    throw new Error("metadatumToObj: Unsupported Metadatum type");
+  }
+};
+var uint8ArrayToHex = (bytes) => {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+
 // src/core/adaptor/mint.ts
 var mintItemToObj = (mintItem) => {
   switch (mintItem.type) {
@@ -939,41 +962,6 @@ var outputToObj = (output) => {
   };
 };
 
-// src/core/adaptor/metadata.ts
-import JSONbig2 from "json-bigint";
-var txMetadataToObj = (metadata) => {
-  const result = [];
-  metadata.forEach((value, key) => {
-    result.push({
-      tag: key.toString(),
-      metadata: JSONbig2.stringify(metadatumToObj(value))
-    });
-  });
-  return result;
-};
-var metadatumToObj = (metadatum) => {
-  if (typeof metadatum === "number" || typeof metadatum === "string") {
-    return metadatum;
-  } else if (typeof metadatum === "bigint") {
-    return metadatum.toString();
-  } else if (metadatum instanceof Uint8Array) {
-    return uint8ArrayToHex(metadatum);
-  } else if (metadatum instanceof Map) {
-    const result = {};
-    metadatum.forEach((value, key) => {
-      result[metadatumToObj(key)] = metadatumToObj(value);
-    });
-    return result;
-  } else if (Array.isArray(metadatum)) {
-    return metadatum.map(metadatumToObj);
-  } else {
-    throw new Error("metadatumToObj: Unsupported Metadatum type");
-  }
-};
-var uint8ArrayToHex = (bytes) => {
-  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-};
-
 // src/core/adaptor/txIn.ts
 var txInToObj = (txIn) => {
   switch (txIn.type) {
@@ -1258,13 +1246,28 @@ var meshTxBuilderBodyToObj = ({
   fee,
   network
 }) => {
+  let mintsObj = [];
+  mints.forEach((mint) => {
+    mint.mintValue.forEach((mintValue) => {
+      mintsObj.push(
+        mintItemToObj({
+          type: mint.type,
+          policyId: mint.policyId,
+          assetName: mintValue.assetName,
+          amount: mintValue.amount,
+          scriptSource: mint.scriptSource,
+          redeemer: mint.redeemer
+        })
+      );
+    });
+  });
   return {
     inputs: inputs.map(txInToObj),
     outputs: outputs.map(outputToObj),
     collaterals: collaterals.map(collateralTxInToObj),
     requiredSignatures,
     referenceInputs,
-    mints: mints.map((mint) => mintItemToObj(mint)),
+    mints: mintsObj,
     changeAddress,
     metadata: txMetadataToObj(metadata),
     validityRange: validityRangeToObj(validityRange),
@@ -1278,23 +1281,21 @@ var meshTxBuilderBodyToObj = ({
 };
 
 // src/core/serializer.ts
+var VKEY_PUBKEY_SIZE_BYTES = 32;
+var VKEY_SIGNATURE_SIZE_BYTES = 64;
+var CHAIN_CODE_SIZE_BYTES = 32;
 var CSLSerializer = class {
   /**
    * Set to true to enable verbose logging for the txBodyJson prior going into build
    */
-  verbose;
   protocolParams;
   meshTxBuilderBody = emptyTxBuilderBody();
-  constructor(protocolParams, verbose = false) {
+  constructor(protocolParams) {
     this.protocolParams = protocolParams || DEFAULT_PROTOCOL_PARAMETERS;
-    this.verbose = verbose;
   }
   serializeTxBody(txBody, protocolParams) {
     const txBodyJson = JSONbig3.stringify(meshTxBuilderBodyToObj(txBody));
     const params = JSONbig3.stringify(protocolParams || this.protocolParams);
-    if (this.verbose) {
-      console.log("txBodyJson", txBodyJson);
-    }
     const txBuildResult = csl.js_serialize_tx_body(txBodyJson, params);
     if (txBuildResult.get_status() !== "success") {
       throw new Error(`txBuildResult error: ${txBuildResult.get_error()}`);
@@ -1321,8 +1322,8 @@ var CSLSerializer = class {
   }
   deserializer = {
     key: {
-      deserializeAddress: function(bech322) {
-        return deserializeBech32Address(bech322);
+      deserializeAddress: function(bech32) {
+        return deserializeBech32Address(bech32);
       }
     },
     script: {
@@ -1348,17 +1349,17 @@ var CSLSerializer = class {
   };
   resolver = {
     keys: {
-      resolveStakeKeyHash: function(bech322) {
-        return rewardAddressToKeyHash(bech322) || deserializeBech32Address(bech322).stakeCredentialHash;
+      resolveStakeKeyHash: function(bech32) {
+        return rewardAddressToKeyHash(bech32) || deserializeBech32Address(bech32).stakeCredentialHash;
       },
       resolvePrivateKey: function(words) {
         return resolvePrivateKey(words);
       },
-      resolveRewardAddress: function(bech322) {
-        return resolveRewardAddress(bech322);
+      resolveRewardAddress: function(bech32) {
+        return resolveRewardAddress(bech32);
       },
-      resolveEd25519KeyHash: function(bech322) {
-        return resolveEd25519KeyHash(bech322);
+      resolveEd25519KeyHash: function(bech32) {
+        return resolveEd25519KeyHash(bech32);
       }
     },
     tx: {
@@ -1367,8 +1368,8 @@ var CSLSerializer = class {
       }
     },
     data: {
-      resolveDataHash: function(data) {
-        return resolveDataHash(data);
+      resolveDataHash: function(rawData, type = "Mesh") {
+        return resolveDataHash(rawData, type);
       }
     },
     script: {
@@ -1377,6 +1378,125 @@ var CSLSerializer = class {
       }
     }
   };
+  serializeOutput(output) {
+    let cslOutputBuilder = csl.TransactionOutputBuilder.new().with_address(
+      csl.Address.from_bech32(output.address)
+    );
+    if (output.datum?.type === "Hash") {
+      cslOutputBuilder.with_data_hash(
+        csl.hash_plutus_data(castDataToPlutusData(output.datum.data))
+      );
+    } else if (output.datum?.type === "Inline") {
+      cslOutputBuilder.with_plutus_data(
+        castDataToPlutusData(output.datum.data)
+      );
+    } else if (output.datum?.type === "Embedded") {
+      throw new Error("Embedded datum not supported");
+    }
+    if (output.referenceScript) {
+      switch (output.referenceScript.version) {
+        case "V1": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v1()
+              )
+            )
+          );
+          break;
+        }
+        case "V2": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v2()
+              )
+            )
+          );
+          break;
+        }
+        case "V3": {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_plutus_script(
+              csl.PlutusScript.from_hex_with_version(
+                output.referenceScript.code,
+                csl.Language.new_plutus_v3()
+              )
+            )
+          );
+          break;
+        }
+        default: {
+          cslOutputBuilder.with_script_ref(
+            csl.ScriptRef.new_native_script(
+              csl.NativeScript.from_hex(output.referenceScript.code)
+            )
+          );
+          break;
+        }
+      }
+    }
+    return cslOutputBuilder.next().with_value(toCslValue(output.amount)).build().to_hex();
+  }
+  serializeTxBodyWithMockSignatures(txBuilderBody, protocolParams) {
+    const txHex = this.serializeTxBody(txBuilderBody, protocolParams);
+    const cslTx = csl.Transaction.from_hex(txHex);
+    const mockWitnessSet = cslTx.witness_set();
+    const mockVkeyWitnesses = mockWitnessSet.vkeys() ?? csl.Vkeywitnesses.new();
+    const mockBootstrapWitnesses = mockWitnessSet.bootstraps() ?? csl.BootstrapWitnesses.new();
+    for (let i = 0; i < txBuilderBody.expectedNumberKeyWitnesses; i++) {
+      const numberInHex = this.numberToIntegerHex(i);
+      const mockVkey = csl.Vkey.new(
+        csl.PublicKey.from_hex(this.mockPubkey(numberInHex))
+      );
+      const mockSignature = csl.Ed25519Signature.from_hex(
+        this.mockSignature(numberInHex)
+      );
+      mockVkeyWitnesses.add(csl.Vkeywitness.new(mockVkey, mockSignature));
+    }
+    this.meshTxBuilderBody.expectedByronAddressWitnesses.forEach(
+      (bootstrapWitness, i) => {
+        const address = csl.ByronAddress.from_base58(bootstrapWitness);
+        const numberInHex = this.numberToIntegerHex(i);
+        const pubKeyHex = this.mockPubkey(numberInHex);
+        const mockVkey = csl.Vkey.new(csl.PublicKey.from_hex(pubKeyHex));
+        const signature = this.mockSignature(numberInHex);
+        const chainCode = this.mockChainCode(numberInHex);
+        mockBootstrapWitnesses.add(
+          csl.BootstrapWitness.new(
+            mockVkey,
+            csl.Ed25519Signature.from_hex(signature),
+            Buffer.from(chainCode, "hex"),
+            address.attributes()
+          )
+        );
+      }
+    );
+    mockWitnessSet.set_vkeys(mockVkeyWitnesses);
+    mockWitnessSet.set_bootstraps(mockBootstrapWitnesses);
+    return csl.Transaction.new(
+      cslTx.body(),
+      mockWitnessSet,
+      cslTx.auxiliary_data()
+    ).to_hex();
+  }
+  serializeValue(value) {
+    return toCslValue(value).to_hex();
+  }
+  mockPubkey(numberInHex) {
+    return "0".repeat(VKEY_PUBKEY_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  }
+  mockSignature(numberInHex) {
+    return "0".repeat(VKEY_SIGNATURE_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  }
+  mockChainCode = (numberInHex) => {
+    return "0".repeat(CHAIN_CODE_SIZE_BYTES * 2 - numberInHex.length).concat(numberInHex);
+  };
+  numberToIntegerHex = (number) => {
+    return BigInt(number).toString(16);
+  };
 };
 
 // src/offline-providers/offline-evaluator.ts
@@ -1418,36 +1538,47 @@ var OfflineEvaluator = class {
    *   - budget: Memory units and CPU steps required
    * @throws Error if any required UTXOs cannot be resolved or if script evaluation fails
    */
-  async evaluateTx(tx) {
-    const inputsToResolve = getTransactionInputs(tx);
+  async evaluateTx(tx, additionalUtxos, additionalTxs) {
+    const foundUtxos = /* @__PURE__ */ new Set();
+    for (const utxo of additionalUtxos) {
+      foundUtxos.add(`${utxo.input.txHash}:${utxo.input.outputIndex}`);
+    }
+    for (const tx2 of additionalTxs) {
+      const outputs = getTransactionOutputs(tx2);
+      for (const output of outputs) {
+        foundUtxos.add(`${output.input.txHash}:${output.input.outputIndex}`);
+      }
+    }
+    const inputsToResolve = getTransactionInputs(tx).filter(
+      (input) => !foundUtxos.has(`${input.txHash}:${input.outputIndex}`)
+    );
     const txHashesSet = new Set(inputsToResolve.map((input) => input.txHash));
-    const resolvedUTXOs = [];
     for (const txHash of txHashesSet) {
       const utxos = await this.fetcher.fetchUTxOs(txHash);
       for (const utxo of utxos) {
         if (utxo) {
           if (inputsToResolve.find(
-            (input) => input.txHash === txHash && input.index === utxo.input.outputIndex
+            (input) => input.txHash === txHash && input.outputIndex === utxo.input.outputIndex
           )) {
-            resolvedUTXOs.push(utxo);
+            additionalUtxos.push(utxo);
+            foundUtxos.add(`${utxo.input.txHash}:${utxo.input.outputIndex}`);
           }
         }
       }
     }
     const missing = inputsToResolve.filter(
-      (input) => !resolvedUTXOs.find(
-        (utxo) => utxo.input.txHash === input.txHash && utxo.input.outputIndex === input.index
-      )
+      (input) => !foundUtxos.has(`${input.txHash}:${input.outputIndex}`)
     );
     if (missing.length > 0) {
-      const missingList = missing.map((m) => `${m.txHash}:${m.index}`).join(", ");
+      const missingList = missing.map((m) => `${m.txHash}:${m.outputIndex}`).join(", ");
       throw new Error(
         `Can't resolve these UTXOs to execute plutus scripts: ${missingList}`
       );
     }
     return evaluateTransaction(
       tx,
-      resolvedUTXOs,
+      additionalUtxos,
+      additionalTxs,
       this.network,
       this.slotConfig
     );
@@ -1459,8 +1590,8 @@ export {
   OfflineEvaluator,
   POLICY_ID_LENGTH,
   REDEEMER_TAGS,
-  addrBech32ToHex,
-  addrBech32ToObj,
+  addrBech32ToPlutusDataHex,
+  addrBech32ToPlutusDataObj,
   applyCborEncoding,
   applyParamsToScript,
   baseAddressToStakeAddress,
@@ -1496,6 +1627,7 @@ export {
   fromUTF8,
   getDRepIds,
   getTransactionInputs,
+  getTransactionOutputs,
   getV2ScriptHash,
   keyHashToRewardAddress,
   meshTxBuilderBodyToObj,
@@ -1539,6 +1671,7 @@ export {
   toAddress,
   toBaseAddress,
   toBytes,
+  toCslValue,
   toEnterpriseAddress,
   toLovelace,
   toNativeScript,