feat(core): added transaction body serialization classes

Author: AngelCastilloB

packages/core/src/Serialization/TransactionBody/Datum.ts

@@ -0,0 +1,45 @@
+import * as Cardano from '../../Cardano';
+import { InvalidStateError } from '@cardano-sdk/util';
+import { PlutusData } from '../PlutusData';
+
+export enum DatumKind {
+  dataHash,
+  inlineData
+}
+
+export class Datum {
+  #datumKind: DatumKind;
+  #dataHash: Cardano.DatumHash | undefined;
+  #inlineData: PlutusData | undefined;
+
+  constructor(dataHash?: Cardano.DatumHash, inlineData?: PlutusData) {
+    if (dataHash && inlineData) throw new InvalidStateError('Datum can only be DataHash or PlutusData but not both');
+    if (!dataHash && !inlineData) throw new InvalidStateError('Datum must be either DataHash or PlutusData');
+
+    if (dataHash) this.#datumKind = DatumKind.dataHash;
+    if (inlineData) this.#datumKind = DatumKind.inlineData;
+
+    this.#dataHash = dataHash;
+    this.#inlineData = inlineData;
+  }
+
+  kind(): DatumKind {
+    return this.#datumKind;
+  }
+
+  asDataHash(): Cardano.DatumHash | undefined {
+    return this.#dataHash;
+  }
+
+  asInlineData(): PlutusData | undefined {
+    return this.#inlineData;
+  }
+
+  static newDataHash(dataHash: Cardano.DatumHash): Datum {
+    return new Datum(dataHash);
+  }
+
+  static newInlineData(inlineData: PlutusData): Datum {
+    return new Datum(undefined, inlineData);
+  }
+}

packages/core/src/Serialization/TransactionBody/TransactionBody.ts

@@ -0,0 +1,40 @@
+import * as Cardano from '../../Cardano';
+import * as Crypto from '@cardano-sdk/crypto';
+import { Certificate } from '../Certificates';
+import { TransactionInput } from './TransactionInput';
+import { TransactionOutput } from './TransactionOutput';
+import { Update } from '../Update';
+
+export class TransactionBody {
+  constructor(inputs: Array<TransactionInput>, outputs: Array<TransactionOutput>, fee: bigint, ttl?: bigint);
+  inputs(): Array<TransactionInput>;
+  outputs(): Array<TransactionOutput>;
+  fee(): bigint;
+  ttl(): bigint | undefined;
+  set_certs(certs: Array<Certificate>): void;
+  certs(): Array<Certificate> | undefined;
+  set_withdrawals(withdrawals: Map<Cardano.RewardAccount, Cardano.Lovelace>): void;
+  withdrawals(): Map<Cardano.RewardAccount, Cardano.Lovelace> | undefined;
+  set_update(update: Update): void;
+  update(): Update | undefined;
+  set_auxiliary_data_hash(auxiliary_data_hash: Crypto.Hash32ByteBase16): void;
+  auxiliary_data_hash(): Crypto.Hash32ByteBase16 | undefined;
+  set_validity_start_interval(validity_start_interval: bigint): void;
+  validity_start_interval(): bigint | undefined;
+  set_mint(mint: Map<Crypto.Hash32ByteBase16 /* Script Hash */, Cardano.TokenMap>): void;
+  mint(): Map<Crypto.Hash32ByteBase16 /* Script Hash */, Cardano.TokenMap> | undefined;
+  set_script_data_hash(script_data_hash: Crypto.Hash32ByteBase16): void;
+  script_data_hash(): Crypto.Hash32ByteBase16 | undefined;
+  set_collateral(collateral: Array<TransactionInput>): void;
+  collateral(): Array<TransactionInput> | undefined;
+  set_required_signers(required_signers: Array<Crypto.Ed25519KeyHashHex>): void;
+  required_signers(): Array<Crypto.Ed25519KeyHashHex> | undefined;
+  set_network_id(network_id: Cardano.NetworkId): void;
+  network_id(): Cardano.NetworkId | undefined;
+  set_collateral_return(collateral_return: TransactionOutput): void;
+  collateral_return(): TransactionOutput | undefined;
+  set_total_collateral(total_collateral: bigint): void;
+  total_collateral(): bigint | undefined;
+  set_reference_inputs(reference_inputs: Array<TransactionInput>): void;
+  reference_inputs(): Array<TransactionInput> | undefined;
+}

packages/core/src/Serialization/TransactionBody/TransactionInput.ts

@@ -0,0 +1,19 @@
+import * as Cardano from '../../Cardano';
+
+export class TransactionInput {
+  #id: Cardano.TransactionId;
+  #index: bigint;
+
+  constructor(id: Cardano.TransactionId, index: bigint) {
+    this.#id = id;
+    this.#index = index;
+  }
+
+  transactionId(): Cardano.TransactionId {
+    return this.#id;
+  }
+
+  index(): bigint {
+    return this.#index;
+  }
+}

packages/core/src/Serialization/TransactionBody/TransactionOutput.ts

@@ -0,0 +1,52 @@
+import * as Cardano from '../../Cardano';
+import { Datum } from './Datum';
+import { Script } from '../Scripts';
+import { Value } from './Value';
+
+/**
+ * A TransactionOutput object includes the address which represents a public key
+ * hash or a script hash that can unlock the output, and the funds that are held
+ * inside.
+ */
+export class TransactionOutput {
+  #address: Cardano.Address;
+  #amount: Value;
+  #datum: Datum | undefined;
+  #scriptRef: Script | undefined;
+
+  constructor(address: Cardano.Address, amount: Value) {
+    this.#address = address;
+    this.#amount = amount;
+  }
+
+  address(): Cardano.Address {
+    return this.#address;
+  }
+
+  amount(): Value {
+    return this.#amount;
+  }
+
+  datum(): Datum | undefined {
+    return this.#datum;
+  }
+
+  setDatum(data: Datum): void {
+    this.#datum = data;
+  }
+
+  /**
+   * The key idea is to use reference inputs and modified outputs which carry actual scripts ("reference scripts"), and
+   * allow such reference scripts to satisfy the script witnessing requirement for a transaction.
+   *
+   * This means that the transaction which uses the script will not need to provide it at all, so long as it referenced
+   * an output which contained the script.
+   */
+  scriptRef(): Script | undefined {
+    return this.#scriptRef;
+  }
+
+  setScriptRef(script: Script): void {
+    this.#scriptRef = script;
+  }
+}

packages/core/src/Serialization/TransactionBody/Value.ts

@@ -0,0 +1,69 @@
+import { Lovelace, TokenMap } from '../../Cardano/types/Value';
+
+/**
+ * A Value object encapsulates the quantity of assets of different types,
+ * including ADA (Cardano's native cryptocurrency) expressed in lovelace,
+ * where 1 ADA = 1,000,000 lovelace, and other native tokens. Each key in the
+ * tokens object is a unique identifier for an asset, and the corresponding
+ * value is the quantity of that asset.
+ */
+export class Value {
+  #coin = 0n;
+  #multiasset: TokenMap | undefined = undefined;
+
+  /**
+   * Initializes a nre instance of the Value class.
+   *
+   * @param coin  Amount of lovelace represented by this Value.
+   * @param multiasset The collection of native assets represented by this Value.
+   */
+  constructor(coin: Lovelace, multiasset?: TokenMap) {
+    this.#coin = coin;
+    this.#multiasset = multiasset;
+  }
+
+  /**
+   * Gets the coin amount included in this Value.
+   *
+   * @returns The coin amount of this value in lovelace,
+   * where 1 ADA = 1,000,000 lovelace.
+   */
+  coin(): Lovelace {
+    return this.#coin;
+  }
+
+  /**
+   * Sets the coin amount to be included in this Value.
+   *
+   * @param coin The coin amount of this value in lovelace,
+   * where 1 ADA = 1,000,000 lovelace.
+   */
+  setCoin(coin: Lovelace): void {
+    this.#coin = coin;
+  }
+
+  /**
+   * Gets the assets included in this Value.
+   *
+   * Each key in the tokens object is a unique identifier for an asset,
+   * and the corresponding value is the quantity of that asset.
+   *
+   * The asset identifiers for native tokens are constructed
+   * as the hash of the policy script under which they were minted,
+   * concatenated with a name for the token.
+   *
+   * @returns A mapping of asset identifiers to their quantities.
+   */
+  multiasset(): TokenMap | undefined {
+    return this.#multiasset;
+  }
+
+  /**
+   * Sets the assets included in this Value.
+   *
+   * @param multiasset A mapping of asset identifiers to their quantities.
+   */
+  setMultiasset(multiasset: TokenMap): void {
+    this.#multiasset = multiasset;
+  }
+}

packages/core/src/Serialization/TransactionBody/index.ts

@@ -0,0 +1,5 @@
+export * from './Datum';
+export * from './TransactionBody';
+export * from './TransactionInput';
+export * from './TransactionOutput';
+export * from './Value';

packages/core/src/Serialization/index.ts

@@ -5,3 +5,4 @@ export * from './PlutusData';
 export * from './CBOR';
 export * from './Certificates';
 export * from './Update';
+export * from './TransactionBody';