Payment module

src/api/CertificationData.ts

@@ -89,27 +89,29 @@ export class CertificationData {
   public static async fromMintTransaction(transaction: MintTransaction): Promise<CertificationData> {
     const signingService = await MintSigningService.create(transaction.tokenId);
 
-    const sourceStateHash = await transaction.calculateStateHash();
     const transactionHash = await transaction.calculateTransactionHash();
 
     const signatureDataHash = await new DataHasher(HashAlgorithm.SHA256)
-      .update(CborSerializer.encodeArray(sourceStateHash.toCBOR(), transactionHash.toCBOR()))
+      .update(CborSerializer.encodeArray(transaction.sourceStateHash.toCBOR(), transactionHash.toCBOR()))
       .digest();
     const unlockScript = await signingService.sign(signatureDataHash);
 
-    return CertificationData.create(transaction.lockScript, sourceStateHash, transactionHash, unlockScript.encode());
+    return CertificationData.create(
+      transaction.lockScript,
+      transaction.sourceStateHash,
+      transactionHash,
+      unlockScript.encode(),
+    );
   }
 
   public static async fromTransferTransaction(
     transaction: TransferTransaction,
     unlockScript: Uint8Array,
   ): Promise<CertificationData> {
     unlockScript = new Uint8Array(unlockScript);
-
-    const sourceStateHash = await transaction.calculateStateHash();
     const transactionHash = await transaction.calculateTransactionHash();
 
-    return CertificationData.create(transaction.lockScript, sourceStateHash, transactionHash, unlockScript);
+    return CertificationData.create(transaction.lockScript, transaction.sourceStateHash, transactionHash, unlockScript);
   }
 
   /**

src/api/StateId.ts

@@ -43,8 +43,8 @@ export class StateId {
     return new StateId(DataHash.fromJSON(data));
   }
 
-  public static async fromTransaction(transaction: ITransaction): Promise<StateId> {
-    return StateId.create(transaction.lockScript, await transaction.calculateStateHash());
+  public static fromTransaction(transaction: ITransaction): Promise<StateId> {
+    return StateId.create(transaction.lockScript, transaction.sourceStateHash);
   }
 
   /**

src/payment/IPaymentData.ts

@@ -0,0 +1,7 @@
+import { PaymentAssetCollection } from './asset/PaymentAssetCollection.js';
+
+export interface IPaymentData {
+  readonly assets: PaymentAssetCollection;
+
+  toCBOR(): Promise<Uint8Array>;
+}

src/payment/ISplitPaymentData.ts

@@ -0,0 +1,6 @@
+import { IPaymentData } from './IPaymentData.js';
+import { SplitReason } from './SplitReason.js';
+
+export interface ISplitPaymentData extends IPaymentData {
+  readonly reason: SplitReason;
+}

src/payment/SplitReason.ts

@@ -0,0 +1,41 @@
+import { SplitReasonProof } from './SplitReasonProof.js';
+import { CborDeserializer } from '../serialization/cbor/CborDeserializer.js';
+import { CborSerializer } from '../serialization/cbor/CborSerializer.js';
+import { Token } from '../transaction/Token.js';
+
+export class SplitReason {
+  private constructor(
+    public readonly token: Token,
+    private readonly _proofs: SplitReasonProof[],
+  ) {
+    this._proofs = _proofs.slice();
+  }
+
+  public get proofs(): SplitReasonProof[] {
+    return this._proofs.slice();
+  }
+
+  public static create(token: Token, proofs: SplitReasonProof[]): SplitReason {
+    if (proofs.length === 0) {
+      throw new Error('proofs cannot be empty.');
+    }
+
+    return new SplitReason(token, proofs);
+  }
+
+  public static async fromCBOR(bytes: Uint8Array): Promise<SplitReason> {
+    const data = CborDeserializer.decodeArray(bytes);
+
+    return new SplitReason(
+      await Token.fromCBOR(data[0]),
+      CborDeserializer.decodeArray(data[1]).map((proof) => SplitReasonProof.fromCBOR(proof)),
+    );
+  }
+
+  public toCBOR(): Uint8Array {
+    return CborSerializer.encodeArray(
+      this.token.toCBOR(),
+      CborSerializer.encodeArray(...this._proofs.map((proof) => proof.toCBOR())),
+    );
+  }
+}

src/payment/SplitReasonProof.ts

@@ -0,0 +1,41 @@
+import { AssetId } from './asset/AssetId.js';
+import { CborDeserializer } from '../serialization/cbor/CborDeserializer.js';
+import { CborSerializer } from '../serialization/cbor/CborSerializer.js';
+import { SparseMerkleTreePath } from '../smt/plain/SparseMerkleTreePath.js';
+import { SparseMerkleSumTreePath } from '../smt/sum/SparseMerkleSumTreePath.js';
+
+export class SplitReasonProof {
+  private constructor(
+    public readonly assetId: AssetId,
+    public readonly aggregationPath: SparseMerkleTreePath,
+    public readonly coinTreePath: SparseMerkleSumTreePath,
+  ) {}
+
+  public static create(
+    assetId: AssetId,
+    aggregationPath: SparseMerkleTreePath,
+    coinTreePath: SparseMerkleSumTreePath,
+  ): SplitReasonProof {
+    return new SplitReasonProof(assetId, aggregationPath, coinTreePath);
+  }
+
+  /**
+   * Create split mint reason from CBOR bytes.
+   *
+   * @param bytes CBOR bytes
+   * @return split mint reason proof
+   */
+  public static fromCBOR(bytes: Uint8Array): SplitReasonProof {
+    const data = CborDeserializer.decodeArray(bytes);
+
+    return new SplitReasonProof(
+      AssetId.fromCBOR(data[0]),
+      SparseMerkleTreePath.fromCBOR(data[1]),
+      SparseMerkleSumTreePath.fromCBOR(data[2]),
+    );
+  }
+
+  public toCBOR(): Uint8Array {
+    return CborSerializer.encodeArray(this.assetId.toCBOR(), this.aggregationPath.toCBOR(), this.coinTreePath.toCBOR());
+  }
+}