@meshsdk/core-cst 1.6.0-alpha.11

package/src/utils/converter.ts

@@ -0,0 +1,371 @@
+import { Serialization } from "@cardano-sdk/core";
+import { Ed25519KeyHash } from "@cardano-sdk/crypto";
+import { HexBlob } from "@cardano-sdk/util";
+
+import {
+  Asset,
+  Data,
+  NativeScript,
+  PlutusScript,
+  Quantity,
+  toBytes,
+  Unit,
+  UTxO,
+} from "@meshsdk/common";
+
+import {
+  Address,
+  AssetId,
+  AssetName,
+  BaseAddress,
+  ConstrPlutusData,
+  NativeScript as CstNativeScript,
+  Datum,
+  EnterpriseAddress,
+  PlutusData,
+  PlutusList,
+  PlutusMap,
+  PlutusV1Script,
+  PlutusV2Script,
+  PlutusV3Script,
+  PolicyId,
+  RequireAllOf,
+  RequireAnyOf,
+  RequireNOf,
+  RequireSignature,
+  RequireTimeAfter,
+  RequireTimeBefore,
+  RewardAddress,
+  Script,
+  Slot,
+  TokenMap,
+  TransactionInput,
+  TransactionOutput,
+  TransactionUnspentOutput,
+  Value,
+} from "../types";
+import {
+  deserializeDataHash,
+  deserializePlutusData,
+  deserializePlutusScript,
+  deserializeScriptRef,
+  deserializeTxHash,
+} from "./deserializer";
+
+export const toAddress = (bech32: string): Address =>
+  Address.fromBech32(bech32);
+
+export const toBaseAddress = (bech32: string): BaseAddress | undefined => {
+  return BaseAddress.fromAddress(toAddress(bech32));
+};
+
+export const toEnterpriseAddress = (
+  bech32: string,
+): EnterpriseAddress | undefined => {
+  return EnterpriseAddress.fromAddress(toAddress(bech32));
+};
+
+export const toRewardAddress = (bech32: string): RewardAddress | undefined =>
+  RewardAddress.fromAddress(toAddress(bech32));
+
+export const fromTxUnspentOutput = (
+  txUnspentOutput: TransactionUnspentOutput,
+): UTxO => {
+  const dataHash = txUnspentOutput.output().datum()
+    ? txUnspentOutput.output().datum()?.toCbor().toString()
+    : undefined;
+
+  const scriptRef = txUnspentOutput.output().scriptRef()
+    ? txUnspentOutput.output().scriptRef()?.toCbor().toString()
+    : undefined;
+
+  const plutusData = txUnspentOutput.output().datum()?.asInlineData()
+    ? txUnspentOutput.output().datum()?.asInlineData()?.toCbor().toString()
+    : undefined;
+
+  return <UTxO>{
+    input: {
+      outputIndex: Number(txUnspentOutput.input().index()),
+      txHash: txUnspentOutput.input().transactionId(),
+    },
+    output: {
+      address: txUnspentOutput.output().address().toBech32(),
+      amount: fromValue(txUnspentOutput.output().amount()),
+      dataHash: dataHash, // todo not sure if correct
+      plutusData: plutusData, // todo not sure if correct
+      scriptRef: scriptRef, // todo not sure if correct
+    },
+  };
+};
+
+export const toTxUnspentOutput = (utxo: UTxO) => {
+  const txInput = new TransactionInput(
+    deserializeTxHash(utxo.input.txHash),
+    BigInt(utxo.input.outputIndex),
+  );
+
+  const txOutput = new TransactionOutput(
+    toAddress(utxo.output.address),
+    toValue(utxo.output.amount),
+  );
+
+  if (utxo.output.dataHash !== undefined) {
+    txOutput.setDatum(
+      Datum.fromCore(deserializeDataHash(utxo.output.dataHash)),
+    );
+  }
+
+  if (utxo.output.plutusData !== undefined) {
+    const plutusData = deserializePlutusData(utxo.output.plutusData);
+    const datum = new Serialization.Datum(undefined, plutusData);
+    txOutput.setDatum(datum);
+  }
+
+  if (utxo.output.scriptRef !== undefined) {
+    txOutput.setScriptRef(deserializeScriptRef(utxo.output.scriptRef));
+  }
+
+  return new TransactionUnspentOutput(txInput, txOutput);
+};
+
+export const addressToBech32 = (address: Address): string => {
+  return address.toBech32();
+};
+
+export const fromValue = (value: Value) => {
+  const assets: Asset[] = [
+    { unit: "lovelace", quantity: value.coin().toString() },
+  ];
+
+  const multiAsset = value.multiasset();
+  if (multiAsset !== undefined) {
+    const _assets = Array.from(multiAsset.keys());
+    for (let i = 0; i < _assets.length; i += 1) {
+      const assetId = _assets[i];
+      if (assetId !== undefined) {
+        const assetQuantity = multiAsset.get(assetId);
+        if (assetQuantity !== undefined) {
+          assets.push({
+            unit: assetId as Unit,
+            quantity: assetQuantity.toString() as Quantity,
+          });
+        }
+      }
+    }
+  }
+
+  return assets;
+};
+
+export const toScriptRef = (script: PlutusScript | NativeScript): Script => {
+  if ("code" in script) {
+    const plutusScript = deserializePlutusScript(script.code, script.version);
+    if (plutusScript instanceof PlutusV1Script)
+      return Script.newPlutusV1Script(plutusScript);
+    if (plutusScript instanceof PlutusV2Script)
+      return Script.newPlutusV2Script(plutusScript);
+    if (plutusScript instanceof PlutusV3Script)
+      return Script.newPlutusV3Script(plutusScript);
+  }
+  return Script.newNativeScript(toNativeScript(script as NativeScript));
+};
+
+export const fromScriptRef = (
+  scriptRef: string,
+): PlutusScript | NativeScript | undefined => {
+  const script = Script.fromCbor(HexBlob(scriptRef));
+
+  const plutusScriptCodeV3 = script.asPlutusV3()?.toCbor().toString();
+  if (plutusScriptCodeV3) {
+    return {
+      code: plutusScriptCodeV3,
+      version: "V3",
+    };
+  }
+
+  const plutusScriptCodeV2 = script.asPlutusV2()?.toCbor().toString();
+  if (plutusScriptCodeV2) {
+    return {
+      code: plutusScriptCodeV2,
+      version: "V2",
+    };
+  }
+
+  const plutusScriptCodeV1 = script.asPlutusV1()?.toCbor().toString();
+  if (plutusScriptCodeV1) {
+    return {
+      code: plutusScriptCodeV1,
+      version: "V1",
+    };
+  }
+
+  // TODO: implement from native script
+  const nativeScript = script.asNative();
+  if (!nativeScript) {
+    throw new Error("Invalid script");
+  }
+
+  return fromNativeScript(nativeScript);
+};
+
+export const fromNativeScript = (script: CstNativeScript) => {
+  const fromNativeScripts = (scripts: CstNativeScript[]) => {
+    const nativeScripts = new Array<NativeScript>();
+
+    for (let index = 0; index < scripts.length; index += 1) {
+      const script = scripts[index];
+      if (script) {
+        nativeScripts.push(fromNativeScript(script));
+      }
+    }
+
+    return nativeScripts;
+  };
+
+  switch (script.kind()) {
+    case RequireAllOf: {
+      const scriptAll = script.asScriptAll()!;
+      return <NativeScript>{
+        type: "all",
+        scripts: fromNativeScripts(scriptAll.nativeScripts()),
+      };
+    }
+    case RequireAnyOf: {
+      const scriptAny = script.asScriptAny()!;
+      return <NativeScript>{
+        type: "any",
+        scripts: fromNativeScripts(scriptAny.nativeScripts()),
+      };
+    }
+    case RequireNOf: {
+      const scriptNOfK = script.asScriptNOfK()!;
+      return <NativeScript>{
+        type: "atLeast",
+        required: scriptNOfK.required(),
+        scripts: fromNativeScripts(scriptNOfK.nativeScripts()),
+      };
+    }
+    case RequireTimeAfter: {
+      const timelockStart = script.asTimelockStart()!;
+      return <NativeScript>{
+        type: "after",
+        slot: timelockStart.slot().toString(),
+      };
+    }
+    case RequireTimeBefore: {
+      const timelockExpiry = script.asTimelockExpiry()!;
+      return <NativeScript>{
+        type: "before",
+        slot: timelockExpiry.slot().toString(),
+      };
+    }
+    case RequireSignature: {
+      const scriptPubkey = script.asScriptPubkey()!;
+      return <NativeScript>{
+        type: "sig",
+        keyHash: scriptPubkey.keyHash().toString(),
+      };
+    }
+    default:
+      throw new Error(`Script Kind: ${script.kind()}, is not supported`);
+  }
+};
+
+export const toNativeScript = (script: NativeScript) => {
+  const toNativeScripts = (scripts: NativeScript[]) => {
+    const nativeScripts: CstNativeScript[] = [];
+
+    scripts.forEach((script) => {
+      nativeScripts.push(toNativeScript(script));
+    });
+
+    return nativeScripts;
+  };
+
+  switch (script.type) {
+    case "all":
+      return CstNativeScript.newScriptAll(
+        new Serialization.ScriptAll(toNativeScripts(script.scripts)),
+      );
+    case "any":
+      return CstNativeScript.newScriptAny(
+        new Serialization.ScriptAny(toNativeScripts(script.scripts)),
+      );
+    case "atLeast":
+      return CstNativeScript.newScriptNOfK(
+        new Serialization.ScriptNOfK(
+          toNativeScripts(script.scripts),
+          script.required,
+        ),
+      );
+    case "after":
+      return CstNativeScript.newTimelockStart(
+        new Serialization.TimelockStart(Slot(parseInt(script.slot))),
+      );
+    case "before":
+      return CstNativeScript.newTimelockExpiry(
+        new Serialization.TimelockExpiry(Slot(parseInt(script.slot))),
+      );
+    case "sig":
+      return CstNativeScript.newScriptPubkey(
+        new Serialization.ScriptPubkey(
+          Ed25519KeyHash.fromBytes(toBytes(script.keyHash)).hex(),
+        ),
+      );
+  }
+};
+
+export const toPlutusData = (data: Data): PlutusData => {
+  const toPlutusList = (data: Data[]) => {
+    const plutusList = new PlutusList();
+    data.forEach((element) => {
+      plutusList.add(toPlutusData(element));
+    });
+    return plutusList;
+  };
+
+  switch (typeof data) {
+    case "string":
+      return PlutusData.newBytes(toBytes(data));
+    case "number":
+      return PlutusData.newInteger(BigInt(data));
+    case "bigint":
+      return PlutusData.newInteger(BigInt(data));
+    case "object":
+      if (data instanceof Array) {
+        const plutusList = toPlutusList(data);
+        return PlutusData.newList(plutusList);
+      } else if (data instanceof Map) {
+        const plutusMap = new PlutusMap();
+        data.forEach((value, key) => {
+          plutusMap.insert(toPlutusData(key), toPlutusData(value));
+        });
+        return PlutusData.newMap(plutusMap);
+      } else {
+        return PlutusData.newConstrPlutusData(
+          new ConstrPlutusData(
+            BigInt(data.alternative),
+            toPlutusList(data.fields),
+          ),
+        );
+      }
+  }
+};
+
+export const toValue = (assets: Asset[]) => {
+  const multiAsset: TokenMap = new Map();
+  assets
+    .filter((asset) => asset.unit !== "lovelace")
+    .forEach((asset) => {
+      multiAsset.set(AssetId(asset.unit), BigInt(asset.quantity));
+    });
+
+  const lovelace = assets.find((asset) => asset.unit === "lovelace");
+  const value = new Value(BigInt(lovelace ? lovelace.quantity : 0));
+
+  if (assets.length > 1 || !lovelace) {
+    value.setMultiasset(multiAsset);
+  }
+
+  return value;
+};

package/src/utils/deserializer.ts

@@ -0,0 +1,76 @@
+import { TxCBOR } from "@cardano-sdk/core";
+import { Ed25519KeyHashHex } from "@cardano-sdk/crypto";
+import { HexBlob } from "@cardano-sdk/util";
+
+import { LanguageVersion, toBytes } from "@meshsdk/common";
+
+import {
+  Address,
+  DatumHash,
+  Ed25519KeyHash,
+  NativeScript,
+  PlutusData,
+  PlutusV1Script,
+  PlutusV2Script,
+  PlutusV3Script,
+  Script,
+  ScriptHash,
+  Transaction,
+  TransactionId,
+  TransactionUnspentOutput,
+  Value,
+} from "../types";
+
+export const deserializeAddress = (address: string): Address => {
+  const _address = Address.fromString(address);
+  if (_address === null) throw new Error("Invalid address");
+  return _address;
+};
+
+export const deserializeEd25519KeyHash = (ed25519KeyHash: string) =>
+  Ed25519KeyHash.fromBytes(toBytes(ed25519KeyHash));
+
+export const deserializeDataHash = (dataHash: string): DatumHash =>
+  DatumHash.fromHexBlob(HexBlob(dataHash));
+
+export const deserializePlutusData = (plutusData: string): PlutusData =>
+  PlutusData.fromCbor(HexBlob(plutusData));
+
+export const deserializePlutusScript = (
+  plutusScript: string,
+  version: LanguageVersion,
+): PlutusV1Script | PlutusV2Script | PlutusV3Script => {
+  switch (version) {
+    case "V1":
+      return PlutusV1Script.fromCbor(HexBlob(plutusScript));
+    case "V2":
+      return PlutusV2Script.fromCbor(HexBlob(plutusScript));
+    case "V3":
+      return PlutusV3Script.fromCbor(HexBlob(plutusScript));
+    default:
+      throw new Error("Invalid Plutus script version");
+  }
+};
+
+export const deserializeNativeScript = (nativeScript: string): NativeScript =>
+  NativeScript.fromCbor(HexBlob(nativeScript));
+
+export const deserializeScriptHash = (scriptHash: string) =>
+  ScriptHash.fromEd25519KeyHashHex(Ed25519KeyHashHex(scriptHash));
+
+export const deserializeScriptRef = (scriptRef: string): Script =>
+  Script.fromCbor(HexBlob(scriptRef));
+
+export const deserializeTxUnspentOutput = (
+  txUnspentOutput: string,
+): TransactionUnspentOutput =>
+  TransactionUnspentOutput.fromCbor(HexBlob(txUnspentOutput));
+
+export const deserializeValue = (value: string): Value =>
+  Value.fromCbor(HexBlob(value));
+
+export const deserializeTx = (tx: string): Transaction =>
+  Transaction.fromCbor(TxCBOR(tx));
+
+export const deserializeTxHash = (txHash: string): TransactionId =>
+  TransactionId.fromHexBlob(HexBlob(txHash));

package/src/utils/encoding.ts

@@ -0,0 +1,12 @@
+import { HexBlob } from "@cardano-sdk/util";
+
+export const bytesToHex = (bytes: Uint8Array): HexBlob =>
+  Buffer.from(bytes).toString("hex") as HexBlob;
+
+export const hexToBytes = (hex: HexBlob): Uint8Array => Buffer.from(hex, "hex");
+
+export const utf8ToBytes = (str: string): Uint8Array =>
+  Buffer.from(str, "utf8");
+
+export const utf8ToHex = (str: string): HexBlob =>
+  Buffer.from(str, "utf8").toString("hex") as HexBlob;

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./builder";
+export * from "./converter";
+export * from "./deserializer";
+export * from "./value";

package/src/utils/script-data-hash.ts

@@ -0,0 +1,87 @@
+/* eslint-disable unicorn/number-literal-case */
+import { Cardano, Serialization } from "@cardano-sdk/core";
+import * as Crypto from "@cardano-sdk/crypto";
+import { Hash32ByteBase16 } from "@cardano-sdk/crypto";
+import { HexBlob } from "@cardano-sdk/util";
+
+const CBOR_EMPTY_LIST = new Uint8Array([0x80]);
+const CBOR_EMPTY_MAP = new Uint8Array([0xa0]);
+
+/**
+ * Encodes an array of CBOR-encodable objects into a CBOR format.
+ *
+ * Each object in the array is converted to its CBOR representation and then written into a
+ * CBOR array.
+ *
+ * @param items An array of objects that can be encoded into CBOR.
+ * @returns A `Uint8Array` containing the CBOR-encoded objects.
+ */
+const getCborEncodedArray = <T extends { toCbor: () => HexBlob }>(
+  items: T[],
+): Uint8Array => {
+  const writer = new Serialization.CborWriter();
+
+  writer.writeStartArray(items.length);
+
+  for (const item of items) {
+    writer.writeEncodedValue(Buffer.from(item.toCbor(), "hex"));
+  }
+
+  return writer.encode();
+};
+
+/**
+ * Computes the hash of script data in a transaction, including redeemers, datums, and cost models.
+ *
+ * This function takes arrays of redeemers and datums, along with cost models, and encodes
+ * them in a CBOR (Concise Binary Object Representation) format. The encoded data is then
+ * hashed using the Blake2b hashing algorithm to produce a 32-byte hash. This hash is
+ * representative of the script data in a transaction on the Cardano blockchain.
+ *
+ * @param costModels The cost models for script execution.
+ * @param redemeers The redeemers in the transaction. If not present or empty, the function may return undefined.
+ * @param datums The datums in the transaction.
+ * @returns The hashed script data, or undefined if no redeemers are provided.
+ */
+export const hashScriptData = (
+  costModels: Serialization.Costmdls,
+  redemeers?: Serialization.Redeemer[],
+  datums?: Serialization.PlutusData[],
+): Crypto.Hash32ByteBase16 | undefined => {
+  const writer = new Serialization.CborWriter();
+
+  if (datums && datums.length > 0 && (!redemeers || redemeers.length === 0)) {
+    /*
+     ; Note that in the case that a transaction includes datums but does not
+     ; include any redeemers, the script data format becomes (in hex):
+     ; [ 80 | datums | A0 ]
+     ; corresponding to a CBOR empty list and an empty map).
+    */
+    writer.writeEncodedValue(CBOR_EMPTY_LIST);
+    writer.writeEncodedValue(getCborEncodedArray(datums));
+    writer.writeEncodedValue(CBOR_EMPTY_MAP);
+  } else {
+    if (!redemeers || redemeers.length === 0) return undefined;
+    /*
+     ; script data format:
+     ; [ redeemers | datums | language views ]
+     ; The redeemers are exactly the data present in the transaction witness set.
+     ; Similarly for the datums, if present. If no datums are provided, the middle
+     ; field is an empty string.
+    */
+    writer.writeEncodedValue(getCborEncodedArray(redemeers));
+
+    if (datums && datums.length > 0)
+      writer.writeEncodedValue(getCborEncodedArray(datums));
+
+    writer.writeEncodedValue(
+      Buffer.from(costModels.languageViewsEncoding(), "hex"),
+    );
+  }
+
+  return Hash32ByteBase16.fromHexBlob(
+    HexBlob.fromBytes(
+      Crypto.blake2b(Crypto.blake2b.BYTES).update(writer.encode()).digest(),
+    ),
+  );
+};

package/src/utils/value.ts

@@ -0,0 +1,61 @@
+import { TokenMap, Value } from "../types";
+
+export function mergeValue(a: Value, b: Value): Value {
+  const ma = a.multiasset() ?? new Map();
+  b.multiasset()?.forEach((v, k) => {
+    const newVal = (ma.get(k) ?? 0n) + v;
+    if (newVal == 0n) {
+      ma.delete(k);
+    } else {
+      ma.set(k, newVal);
+    }
+  });
+  return new Value(
+    BigInt(a.coin()) + BigInt(b.coin()),
+    ma.size > 0 ? ma : undefined,
+  );
+}
+
+export function negateValue(v: Value): Value {
+  const entries = v.multiasset()?.entries();
+  const tokenMap: TokenMap = new Map();
+  if (entries) {
+    for (const entry of entries) {
+      tokenMap.set(entry[0], -entry[1]);
+    }
+  }
+  return new Value(-v.coin(), tokenMap);
+}
+
+export function subValue(a: Value, b: Value): Value {
+  return mergeValue(a, negateValue(b));
+}
+
+export function negatives(v: Value): Value {
+  const entries = v.multiasset()?.entries();
+  const coin = v.coin() < 0n ? v.coin() : 0n;
+  const tokenMap: TokenMap = new Map();
+  if (entries) {
+    for (const entry of entries) {
+      if (entry[1] < 0n) {
+        tokenMap.set(entry[0], entry[1]);
+      }
+    }
+  }
+  return new Value(coin, tokenMap);
+}
+
+export function assetTypes(v: Value): number {
+  let count = v.coin() == 0n ? 0 : 1;
+  const entries = v.multiasset();
+  if (entries) {
+    entries.forEach(() => {
+      count += 1;
+    });
+  }
+  return count;
+}
+
+export function empty(v: Value): boolean {
+  return assetTypes(v) == 0;
+}