@meshsdk/common 1.9.0-beta.55 → 1.9.0-beta.56

package/dist/index.cjs

@@ -52,6 +52,7 @@ __export(index_exports, {
   SUPPORTED_OGMIOS_LINKS: () => SUPPORTED_OGMIOS_LINKS,
   SUPPORTED_TOKENS: () => SUPPORTED_TOKENS,
   SUPPORTED_WALLETS: () => SUPPORTED_WALLETS,
+  TxTester: () => TxTester,
   UtxoSelection: () => UtxoSelection,
   assetClass: () => assetClass,
   assetName: () => assetName,
@@ -85,6 +86,7 @@ __export(index_exports, {
   isNetwork: () => isNetwork,
   jsonProofToPlutusData: () => jsonProofToPlutusData,
   keepRelevant: () => keepRelevant,
+  keySignedLogic: () => keySignedLogic,
   largestFirst: () => largestFirst,
   largestFirstMultiAsset: () => largestFirstMultiAsset,
   list: () => list,
@@ -140,11 +142,13 @@ __export(index_exports, {
   stringToHex: () => stringToHex,
   toBytes: () => toBytes,
   toUTF8: () => toUTF8,
+  tokenMintedLogic: () => tokenMintedLogic,
   tokenName: () => tokenName,
   tuple: () => tuple,
   txInToUtxo: () => txInToUtxo,
   txOutRef: () => txOutRef,
   unixTimeToEnclosingSlot: () => unixTimeToEnclosingSlot,
+  validityRangeFromObj: () => validityRangeFromObj,
   validityRangeToObj: () => validityRangeToObj,
   value: () => value,
   verificationKey: () => verificationKey
@@ -1049,6 +1053,16 @@ var validityRangeToObj = (validityRange) => {
     invalidHereafter: validityRange.invalidHereafter ?? null
   };
 };
+var validityRangeFromObj = (obj) => {
+  const validityRange = {};
+  if (obj.invalidBefore !== null && obj.invalidBefore !== void 0) {
+    validityRange.invalidBefore = Number(obj.invalidBefore);
+  }
+  if (obj.invalidHereafter !== null && obj.invalidHereafter !== void 0) {
+    validityRange.invalidHereafter = Number(obj.invalidHereafter);
+  }
+  return validityRange;
+};
 
 // src/data/mesh/constructors.ts
 var mConStr = (alternative, fields) => ({
@@ -1638,6 +1652,23 @@ var MeshValue = class _MeshValue {
   get = (unit) => {
     return this.value[unit] ? BigInt(this.value[unit]) : BigInt(0);
   };
+  /**
+   * Get all assets that belong to a specific policy ID
+   * @param policyId The policy ID to filter by
+   * @returns Array of assets that match the policy ID
+   */
+  getPolicyAssets = (policyId2) => {
+    const assets = [];
+    Object.entries(this.value).forEach(([unit, quantity]) => {
+      if (unit.startsWith(policyId2)) {
+        assets.push({
+          unit,
+          quantity: quantity.toString()
+        });
+      }
+    });
+    return assets;
+  };
   /**
    * Get all asset units
    * @returns The asset units
@@ -2058,6 +2089,473 @@ var UtxoSelection = class {
   }
 };
 
+// src/tx-tester/index.ts
+var TxTester = class {
+  txBody;
+  inputsEvaluating;
+  outputsEvaluating;
+  traces;
+  /**
+   * Create a new TxTester instance
+   * @param txBody The transaction builder body
+   */
+  constructor(txBody) {
+    this.txBody = { ...txBody };
+    this.inputsEvaluating = [];
+    this.outputsEvaluating = [];
+    this.traces = [];
+  }
+  /**
+   * Add a trace to the TxTester
+   * @param funcName The function name where the error occurred
+   * @param message The error message
+   */
+  addTrace(funcName, message) {
+    const msg = `[Error - ${funcName}]: ${message}`;
+    this.traces.push(msg);
+  }
+  /**
+   * Check if the transaction evaluation was successful
+   * @returns true if there are no errors, false otherwise
+   */
+  success() {
+    return this.traces.length === 0;
+  }
+  /**
+   * Get the error messages if any
+   * @returns A string representation of the errors or "No errors" if there are none
+   */
+  errors() {
+    if (this.traces.length > 0) {
+      return `${this.traces}`;
+    } else {
+      return "No errors";
+    }
+  }
+  /**
+   * Checks if the transaction is valid after a specified timestamp.
+   * @param requiredTimestamp The timestamp after which the transaction should be valid
+   * @returns The TxTester instance for chaining
+   */
+  validAfter = (requiredTimestamp) => {
+    const invalidBefore = this.txBody.validityRange?.invalidHereafter ? this.txBody.validityRange.invalidHereafter : 9999999999999;
+    const isValidAfter = this.txBody.validityRange?.invalidBefore ? this.txBody.validityRange.invalidBefore < requiredTimestamp : true;
+    if (!isValidAfter) {
+      this.addTrace(
+        "validAfter",
+        `tx invalid before ${invalidBefore}, with requiredTimestamp ${requiredTimestamp}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if the transaction is valid before a specified timestamp.
+   * @param requiredTimestamp The timestamp before which the transaction should be valid
+   * @returns The TxTester instance for chaining
+   */
+  validBefore = (requiredTimestamp) => {
+    const invalidHereafter = this.txBody.validityRange?.invalidBefore ? this.txBody.validityRange.invalidBefore : 0;
+    const isValidBefore = this.txBody.validityRange?.invalidHereafter ? this.txBody.validityRange.invalidHereafter > requiredTimestamp : true;
+    if (!isValidBefore) {
+      this.addTrace(
+        "validBefore",
+        `tx invalid after ${invalidHereafter}, with requiredTimestamp ${requiredTimestamp}`
+      );
+    }
+    return this;
+  };
+  // Extra Signatories Methods
+  /**
+   * Checks if a specific key is signed in the transaction.
+   * @param keyHash The key hash to check
+   * @returns The TxTester instance for chaining
+   */
+  keySigned = (keyHash) => {
+    const isKeySigned = keySignedLogic(this.txBody.requiredSignatures, keyHash);
+    if (!isKeySigned) {
+      this.addTrace("keySigned", `tx does not have key ${keyHash} signed`);
+    }
+    return this;
+  };
+  /**
+   * Checks if any one of the specified keys is signed in the transaction.
+   * @param keyHashes The array of key hashes to check
+   * @returns The TxTester instance for chaining
+   */
+  oneOfKeysSigned = (keyHashes) => {
+    const isOneOfKeysSigned = keyHashes.some(
+      (keyHash) => keySignedLogic(this.txBody.requiredSignatures, keyHash)
+    );
+    if (!isOneOfKeysSigned) {
+      this.addTrace(
+        "oneOfKeysSigned",
+        `tx does not have any of the keys signed: ${keyHashes.join(", ")}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if all specified keys are signed in the transaction.
+   * @param keyHashes The array of key hashes to check
+   * @returns The TxTester instance for chaining
+   */
+  allKeysSigned = (keyHashes) => {
+    const missingKeys = [];
+    const isAllKeysSigned = keyHashes.every((keyHash) => {
+      const isKeySigned = keySignedLogic(
+        this.txBody.requiredSignatures,
+        keyHash
+      );
+      if (!isKeySigned) {
+        missingKeys.push(keyHash);
+      }
+      return isKeySigned;
+    });
+    if (!isAllKeysSigned) {
+      this.addTrace(
+        "allKeysSigned",
+        `tx does not have all keys signed: ${missingKeys.join(", ")}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  tokenMinted = (policyId2, assetName2, quantity) => {
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    if (!isTokenMinted) {
+      this.addTrace(
+        "tokenMinted",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction and that it is the only mint.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  onlyTokenMinted = (policyId2, assetName2, quantity) => {
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    const isOnlyOneMint = this.txBody.mints?.length === 1;
+    if (!isTokenMinted) {
+      this.addTrace(
+        "onlyTokenMinted",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints`
+      );
+    }
+    if (!isOnlyOneMint) {
+      this.addTrace(
+        "onlyTokenMinted",
+        `Expected only one mint, but found ${this.txBody.mints?.length || 0} mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific token is minted in the transaction, ensuring that it is the only mint for the given policy ID.
+   * @param policyId The policy ID of the token
+   * @param assetName The asset name of the token
+   * @param quantity The quantity of the token
+   * @returns The TxTester instance for chaining
+   */
+  policyOnlyMintedToken = (policyId2, assetName2, quantity) => {
+    const filteredMints = this.txBody.mints?.filter((token) => {
+      return token.policyId === policyId2;
+    }) || [];
+    const isTokenMinted = tokenMintedLogic(
+      this.txBody.mints,
+      policyId2,
+      assetName2,
+      quantity
+    );
+    const isOnlyOneMint = filteredMints.length === 1;
+    if (!isOnlyOneMint) {
+      this.addTrace(
+        "policyOnlyMintedToken",
+        `Expected only one mint for policy_id: ${policyId2}, but found ${filteredMints.length} mints.`
+      );
+    }
+    if (!isTokenMinted) {
+      this.addTrace(
+        "policyOnlyMintedToken",
+        `Token with policy_id: ${policyId2}, asset_name: ${assetName2}, quantity: ${quantity} not found in mints.`
+      );
+    }
+    return this;
+  };
+  /**
+   * Checks if a specific policy ID is burned in the transaction, ensuring that it is the only minting (i.e. burning item).
+   * @param policyId The policy ID to check
+   * @returns true if the policy is the only burn, false otherwise
+   */
+  checkPolicyOnlyBurn = (policyId2) => {
+    const filteredMints = this.txBody.mints?.filter((token) => {
+      return token.policyId === policyId2 && token.mintValue.findIndex((m) => BigInt(m.amount) > 0) >= 0;
+    }) || [];
+    return filteredMints.length === 0;
+  };
+  /**
+   * Not apply filter to inputs
+   * @returns The TxTester instance for chaining
+   */
+  allInputs = () => {
+    this.inputsEvaluating = this.txBody.inputs?.slice() || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address
+   * @param address The address to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAt = (address) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter(
+      (input) => txInToUtxo(input.txIn).output.address === address
+    ) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by unit
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsWith = (unit) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const inputValue = MeshValue.fromAssets(
+        txInToUtxo(input.txIn).output.amount
+      );
+      const quantity = inputValue.get(unit);
+      return quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by policy ID
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsWithPolicy = (policyId2) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const inputValue = MeshValue.fromAssets(
+        txInToUtxo(input.txIn).output.amount
+      );
+      const assets = inputValue.getPolicyAssets(policyId2);
+      return assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address and policy ID
+   * @param address The address to filter by
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAtWithPolicy = (address, policyId2) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      const inputValue = MeshValue.fromAssets(utxo.output.amount);
+      const assets = inputValue.getPolicyAssets(policyId2);
+      return utxo.output.address === address && assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter inputs by address and unit
+   * @param address The address to filter by
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  inputsAtWith = (address, unit) => {
+    this.inputsEvaluating = this.txBody.inputs?.filter((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      const inputValue = MeshValue.fromAssets(utxo.output.amount);
+      const quantity = inputValue.get(unit);
+      return utxo.output.address === address && quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Check if inputs contain the expected value.
+   * *Reminder - It must be called after filtering methods for inputs*
+   * @param expectedValue The expected value
+   * @returns The TxTester instance for chaining
+   */
+  inputsValue = (expectedValue) => {
+    let value2 = new MeshValue();
+    this.inputsEvaluating.forEach((input) => {
+      const utxo = txInToUtxo(input.txIn);
+      value2.addAssets(utxo.output.amount);
+    });
+    const isValueCorrect = value2.eq(expectedValue);
+    if (!isValueCorrect) {
+      this.addTrace(
+        "inputsValue",
+        `inputs ${JSON.stringify(this.inputsEvaluating)} have value ${JSON.stringify(value2)}, expect ${JSON.stringify(expectedValue)}`
+      );
+    }
+    return this;
+  };
+  // /**
+  //  * Check if inputs contain a specific inline datum.
+  //  * *Reminder - It must be called after filtering methods for inputs*
+  //  * @param datumCbor The datum CBOR to check
+  //  * @returns The TxTester instance for chaining
+  //  */
+  // inputsInlineDatumExist = (datumCbor: string): this => {
+  //   const inputsWithInlineDatum = this.inputsEvaluating.filter((input) => {
+  //     const utxo = txInToUtxo(input.txIn);
+  //     return utxo.output.plutusData === datumCbor;
+  //   });
+  //   if (inputsWithInlineDatum.length === 0) {
+  //     this.addTrace(
+  //       "inputsInlineDatumExist",
+  //       `No inputs with inline datum matching: ${datumCbor}`,
+  //     );
+  //   }
+  //   return this;
+  // };
+  /**
+   * Not apply filter to outputs
+   * @returns The TxTester instance for chaining
+   */
+  allOutputs = () => {
+    this.outputsEvaluating = this.txBody.outputs?.slice() || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address
+   * @param address The address to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAt = (address) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => output.address === address) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by unit
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsWith = (unit) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const quantity = outputValue.get(unit);
+      return quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by policy ID
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsWithPolicy = (policyId2) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const assets = outputValue.getPolicyAssets(policyId2);
+      return assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address and policy ID
+   * @param address The address to filter by
+   * @param policyId The policy ID to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAtWithPolicy = (address, policyId2) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const assets = outputValue.getPolicyAssets(policyId2);
+      return output.address === address && assets.length > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Filter outputs by address and unit
+   * @param address The address to filter by
+   * @param unit The unit to filter by
+   * @returns The TxTester instance for chaining
+   */
+  outputsAtWith = (address, unit) => {
+    this.outputsEvaluating = this.txBody.outputs?.filter((output) => {
+      const outputValue = MeshValue.fromAssets(output.amount);
+      const quantity = outputValue.get(unit);
+      return output.address === address && quantity > 0;
+    }) || [];
+    return this;
+  };
+  /**
+   * Check if outputs contain the expected value.
+   * *Reminder - It must be called after filtering methods for outputs*
+   * @param expectedValue The expected value
+   * @returns The TxTester instance for chaining
+   */
+  outputsValue = (expectedValue) => {
+    let value2 = new MeshValue();
+    this.outputsEvaluating.forEach((output) => {
+      value2.addAssets(output.amount);
+    });
+    const isValueCorrect = value2.eq(expectedValue);
+    if (!isValueCorrect) {
+      this.addTrace(
+        "outputsValue",
+        `tx outputs ${JSON.stringify(this.outputsEvaluating)} have value ${JSON.stringify(value2)}, expected ${JSON.stringify(expectedValue)}`
+      );
+    }
+    return this;
+  };
+  /**
+   * Check if outputs contain a specific inline datum.
+   * *Reminder - It must be called after filtering methods for outputs*
+   * @param datumCbor The datum CBOR to check
+   * @returns The TxTester instance for chaining
+   */
+  outputsInlineDatumExist = (datumCbor) => {
+    const outputsWithInlineDatum = this.outputsEvaluating.filter((output) => {
+      if (output.datum && output.datum.type === "Inline") {
+        return output.datum.data.content === datumCbor;
+      }
+      return false;
+    });
+    if (outputsWithInlineDatum.length === 0) {
+      this.addTrace(
+        "outputs_inline_datum_exist",
+        `No outputs with inline datum matching: ${datumCbor}`
+      );
+    }
+    return this;
+  };
+};
+function keySignedLogic(requiredSignatures, keyHash) {
+  return requiredSignatures?.some((signatory) => signatory === keyHash) || false;
+}
+function tokenMintedLogic(mints, policyId2, assetName2, quantity) {
+  return mints?.some((token) => {
+    return token.policyId === policyId2 && token.mintValue.findIndex(
+      (m) => m.assetName === assetName2 && BigInt(m.amount) === BigInt(quantity)
+    ) >= 0;
+  }) || false;
+}
+
 // src/index.ts
 var import_bip39 = require("bip39");
 // Annotate the CommonJS export names for ESM import in node:
@@ -2084,6 +2582,7 @@ var import_bip39 = require("bip39");
   SUPPORTED_OGMIOS_LINKS,
   SUPPORTED_TOKENS,
   SUPPORTED_WALLETS,
+  TxTester,
   UtxoSelection,
   assetClass,
   assetName,
@@ -2117,6 +2616,7 @@ var import_bip39 = require("bip39");
   isNetwork,
   jsonProofToPlutusData,
   keepRelevant,
+  keySignedLogic,
   largestFirst,
   largestFirstMultiAsset,
   list,
@@ -2172,11 +2672,13 @@ var import_bip39 = require("bip39");
   stringToHex,
   toBytes,
   toUTF8,
+  tokenMintedLogic,
   tokenName,
   tuple,
   txInToUtxo,
   txOutRef,
   unixTimeToEnclosingSlot,
+  validityRangeFromObj,
   validityRangeToObj,
   value,
   verificationKey