Merge pull request #74 from unicitynetwork/issue-73

Change sum tree hashing to match new spec

Author: b3y0urs3lf

package-lock.json

@@ -37,19 +37,19 @@
     "uuid": "13.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "7.28.3",
-    "@babel/preset-typescript": "7.27.1",
-    "@eslint/js": "9.37.0",
+    "@babel/preset-env": "7.28.5",
+    "@babel/preset-typescript": "7.28.5",
+    "@eslint/js": "9.39.1",
     "@types/jest": "30.0.0",
     "babel-jest": "30.2.0",
-    "eslint": "9.37.0",
+    "eslint": "9.39.1",
     "eslint-config-prettier": "10.1.8",
     "eslint-plugin-import": "2.32.0",
     "eslint-plugin-prettier": "5.5.4",
-    "globals": "16.4.0",
+    "globals": "16.5.0",
     "jest": "30.2.0",
-    "testcontainers": "11.7.1",
+    "testcontainers": "11.8.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.46.1"
+    "typescript-eslint": "8.46.4"
   }
 }

package.json

@@ -4,13 +4,15 @@ import { RequestId } from './api/RequestId.js';
 import { SubmitCommitmentResponse } from './api/SubmitCommitmentResponse.js';
 import { RootTrustBase } from './bft/RootTrustBase.js';
 import { PredicateEngineService } from './predicate/PredicateEngineService.js';
+import { MintSigningService } from './sign/MintSigningService.js';
 import { Token } from './token/Token.js';
+import { TokenId } from './token/TokenId.js';
 import { TokenState } from './token/TokenState.js';
 import { Commitment } from './transaction/Commitment.js';
 import { IMintTransactionReason } from './transaction/IMintTransactionReason.js';
 import { InclusionProofVerificationStatus } from './transaction/InclusionProof.js';
 import { MintCommitment } from './transaction/MintCommitment.js';
-import { MintTransactionData } from './transaction/MintTransactionData.js';
+import { MintTransactionState } from './transaction/MintTransactionState.js';
 import { TransferTransaction } from './transaction/TransferTransaction.js';
 import { TransferTransactionData } from './transaction/TransferTransactionData.js';
 
@@ -71,11 +73,11 @@ export class StateTransitionClient {
    * Finalizes a transaction by updating the token state based on the provided transaction data and
    * nametags.
    *
-   * @param trustBase   The root trust base for inclusion proof verification.
-   * @param token       The token to be updated.
-   * @param state       The current state of the token.
-   * @param transaction The transaction containing transfer data.
-   * @param nametags    A list of tokens used as nametags in the transaction.
+   * @param {RootTrustBase} trustBase   The root trust base for inclusion proof verification.
+   * @param {Token} token       The token to be updated.
+   * @param {TokenState} state       The current state of the token.
+   * @param {TransferTransaction} transaction The transaction containing transfer data.
+   * @param {Token} nametags    A list of tokens used as nametags in the transaction.
    * @return The updated token after applying the transaction.
    */
   public finalizeTransaction<R extends IMintTransactionReason>(
@@ -89,34 +91,70 @@ export class StateTransitionClient {
   }
 
   /**
-   * Retrieves the inclusion proof for a token and verifies its status against the provided public
-   * key and trust base.
+   * Retrieves the inclusion proof for a given commitment.
    *
-   * @param token     The token for which to retrieve the inclusion proof.
-   * @param publicKey The public key associated with the token.
-   * @param trustBase The root trust base for verification.
-   * @return inclusion proof verification status.
+   * @param {RequestId} requestId The request ID of inclusion proof to retrieve.
+   * @return inclusion proof response from the aggregator.
    */
-  public async getTokenStatus(
+  public getInclusionProof(requestId: RequestId): Promise<InclusionProofResponse> {
+    return this.client.getInclusionProof(requestId);
+  }
+
+  /**
+   * Check if state is already spent for given request id.
+   *
+   * @param {RootTrustBase} trustBase root trust base
+   * @param {RequestId} requestId request id
+   * @return true if state is spent, false otherwise.
+   */
+  public async isStateSpent(trustBase: RootTrustBase, requestId: RequestId): Promise<boolean> {
+    const response = await this.getInclusionProof(requestId);
+    const result = await response.inclusionProof.verify(trustBase, requestId);
+    switch (result) {
+      case InclusionProofVerificationStatus.OK:
+        return true;
+      case InclusionProofVerificationStatus.PATH_NOT_INCLUDED:
+        return false;
+      default:
+        throw new Error(`Inclusion proof verification failed with status ${result}`);
+    }
+  }
+
+  /**
+   * Check if token state is already spent.
+   * @param {RootTrustBase} trustBase trustBase
+   * @param {Token} token token
+   * @param {Uint8Array} publicKey public key
+   * @return true if token state is spent, false otherwise
+   */
+  public async isTokenStateSpent(
     trustBase: RootTrustBase,
     token: Token<IMintTransactionReason>,
     publicKey: Uint8Array,
-  ): Promise<InclusionProofVerificationStatus> {
-    const requestId = await RequestId.create(publicKey, await token.state.calculateHash());
-    return this.client
-      .getInclusionProof(requestId)
-      .then((response) => response.inclusionProof.verify(trustBase, requestId));
+  ): Promise<boolean> {
+    const pk = new Uint8Array(publicKey);
+    const predicate = await PredicateEngineService.createPredicate(token.state.predicate);
+    if (!(await predicate.isOwner(pk))) {
+      throw new Error('Given key is not owner of the token.');
+    }
+
+    return this.isStateSpent(trustBase, await RequestId.create(pk, await token.state.calculateHash()));
   }
 
   /**
-   * Retrieves the inclusion proof for a given commitment.
+   * Check if token id is already minted.
    *
-   * @param commitment The commitment for which to retrieve the inclusion proof.
-   * @return inclusion proof response from the aggregator.
+   * @param {RootTrustBase} trustBase root trust base
+   * @param {TokenId} tokenId   token id
+   * @return true if token id is spent, false otherwise.
    */
-  public getInclusionProof(
-    commitment: Commitment<TransferTransactionData | MintTransactionData<IMintTransactionReason>>,
-  ): Promise<InclusionProofResponse> {
-    return this.client.getInclusionProof(commitment.requestId);
+  public async isMinted(trustBase: RootTrustBase, tokenId: TokenId): Promise<boolean> {
+    return this.isStateSpent(
+      trustBase,
+      await RequestId.create(
+        await MintSigningService.create(tokenId).then((signingService) => signingService.publicKey),
+        await MintTransactionState.create(tokenId),
+      ),
+    );
   }
 }

src/StateTransitionClient.ts

@@ -1,4 +1,4 @@
-import { LeafBranch } from './LeafBranch.js';
-import { NodeBranch } from './NodeBranch.js';
+import { FinalizedLeafBranch } from './FinalizedLeafBranch.js';
+import { FinalizedNodeBranch } from './FinalizedNodeBranch.js';
 
-export type Branch = NodeBranch | LeafBranch;
+export type Branch = FinalizedNodeBranch | FinalizedLeafBranch;

src/mtree/plain/LeafInBranchError.ts src/mtree/LeafInBranchError.tssrc/mtree/plain/LeafInBranchError.ts renamed to src/mtree/LeafInBranchError.ts

@@ -2,25 +2,27 @@ import { DataHash } from '../../hash/DataHash.js';
 import { HexConverter } from '../../util/HexConverter.js';
 import { dedent } from '../../util/StringUtils.js';
 
-export class LeafBranch {
+export class FinalizedLeafBranch {
   public constructor(
     public readonly path: bigint,
-    private readonly _value: Uint8Array,
+    private readonly _data: Uint8Array,
     public readonly hash: DataHash,
-  ) {}
+  ) {
+    this._data = new Uint8Array(_data);
+  }
 
-  public get value(): Uint8Array {
-    return new Uint8Array(this._value);
+  public get data(): Uint8Array {
+    return new Uint8Array(this._data);
   }
 
-  public finalize(): Promise<LeafBranch> {
+  public finalize(): Promise<FinalizedLeafBranch> {
     return Promise.resolve(this);
   }
 
   public toString(): string {
     return dedent`
       Leaf[${this.path.toString(2)}]
-        Value: ${HexConverter.encode(this._value)}
+        Data: ${HexConverter.encode(this._data)}
         Hash: ${this.hash.toString()}`;
   }
 }

src/mtree/plain/LeafOutOfBoundsError.ts src/mtree/LeafOutOfBoundsError.tssrc/mtree/plain/LeafOutOfBoundsError.ts renamed to src/mtree/LeafOutOfBoundsError.ts

@@ -2,15 +2,15 @@ import { Branch } from './Branch.js';
 import { DataHash } from '../../hash/DataHash.js';
 import { dedent } from '../../util/StringUtils.js';
 
-export class NodeBranch {
+export class FinalizedNodeBranch {
   public constructor(
     public readonly path: bigint,
     public readonly left: Branch,
     public readonly right: Branch,
     public readonly hash: DataHash,
   ) {}
 
-  public finalize(): Promise<NodeBranch> {
+  public finalize(): Promise<FinalizedNodeBranch> {
     return Promise.resolve(this);
   }
 

src/mtree/plain/PathVerificationResult.ts src/mtree/PathVerificationResult.tssrc/mtree/plain/PathVerificationResult.ts renamed to src/mtree/PathVerificationResult.ts

@@ -1,4 +1,4 @@
-import { LeafBranch } from './LeafBranch.js';
+import { FinalizedLeafBranch } from './FinalizedLeafBranch.js';
 import { IDataHasher } from '../../hash/IDataHasher.js';
 import { IDataHasherFactory } from '../../hash/IDataHasherFactory.js';
 import { CborSerializer } from '../../serializer/cbor/CborSerializer.js';
@@ -7,19 +7,25 @@ import { BigintConverter } from '../../util/BigintConverter.js';
 export class PendingLeafBranch {
   public constructor(
     public readonly path: bigint,
-    public readonly value: Uint8Array,
-  ) {}
+    private readonly _data: Uint8Array,
+  ) {
+    this._data = new Uint8Array(_data);
+  }
+
+  public get data(): Uint8Array {
+    return new Uint8Array(this._data);
+  }
 
-  public async finalize(factory: IDataHasherFactory<IDataHasher>): Promise<LeafBranch> {
+  public async finalize(factory: IDataHasherFactory<IDataHasher>): Promise<FinalizedLeafBranch> {
     const hash = await factory
       .create()
       .update(
         CborSerializer.encodeArray(
           CborSerializer.encodeByteString(BigintConverter.encode(this.path)),
-          CborSerializer.encodeByteString(this.value),
+          CborSerializer.encodeByteString(this._data),
         ),
       )
       .digest();
-    return new LeafBranch(this.path, this.value, hash);
+    return new FinalizedLeafBranch(this.path, this._data, hash);
   }
 }