Fix predicate creation issues

Author: martti007

src/predicate/embedded/MaskedPredicate.ts

@@ -5,10 +5,8 @@ import { HashAlgorithm } from '../../hash/HashAlgorithm.js';
 import { CborDeserializer } from '../../serializer/cbor/CborDeserializer.js';
 import { CborError } from '../../serializer/cbor/CborError.js';
 import { SigningService } from '../../sign/SigningService.js';
-import { Token } from '../../token/Token.js';
 import { TokenId } from '../../token/TokenId.js';
 import { TokenType } from '../../token/TokenType.js';
-import { MintTransaction } from '../../transaction/MintTransaction.js';
 
 /**
  * Predicate for masked address transaction.
@@ -34,41 +32,24 @@ export class MaskedPredicate extends DefaultPredicate {
   }
 
   /**
-   * Create masked predicate from token and signing service.
+   * Create masked predicate.
    *
-   * @param {Token} token        token
+   * @param {TokenId} tokenId        token id
+   * @param {TokenType} tokenType        token type
    * @param {SigningService} signingService signing service
    * @param {HashAlgorithm} hashAlgorithm  hash algorithm
    * @param {Uint8Array} nonce          predicate nonce
-   * @return predicate
    */
-  public static createFromToken(
-    token: Token,
-    signingService: SigningService,
-    hashAlgorithm: HashAlgorithm,
-    nonce: Uint8Array,
-  ): MaskedPredicate {
-    return MaskedPredicate.createFromMintTransaction(token.genesis, signingService, hashAlgorithm, nonce);
-  }
-
-  /**
-   * Create masked predicate from mint transaction and signing service.
-   *
-   * @param {MintTransaction} transaction        mint transaction
-   * @param {SigningService} signingService signing service
-   * @param {HashAlgorithm} hashAlgorithm  hash algorithm
-   * @param {Uint8Array} nonce          predicate nonce
-   * @return predicate
-   */
-  public static createFromMintTransaction(
-    transaction: MintTransaction,
+  public static create(
+    tokenId: TokenId,
+    tokenType: TokenType,
     signingService: SigningService,
     hashAlgorithm: HashAlgorithm,
     nonce: Uint8Array,
   ): MaskedPredicate {
     return new MaskedPredicate(
-      transaction.data.tokenId,
-      transaction.data.tokenType,
+      tokenId,
+      tokenType,
       signingService.publicKey,
       signingService.algorithm,
       hashAlgorithm,

src/predicate/embedded/UnmaskedPredicate.ts

@@ -39,37 +39,30 @@ export class UnmaskedPredicate extends DefaultPredicate {
   /**
    * Create unmasked predicate.
    *
-   * @param {Token} token        token
+   * @param {TokenId} tokenId        token id
+   * @param {TokenType} tokenType        token type
+   * @param {MintTransaction | TransferTransaction} transaction        transaction
    * @param {SigningService} signingService signing service
    * @param {HashAlgorithm} hashAlgorithm  hash algorithm
    */
-  public static createFromToken(
-    token: Token,
+  public static async create(
+    tokenId: TokenId,
+    tokenType: TokenType,
+    transaction: MintTransaction | TransferTransaction,
     signingService: SigningService,
     hashAlgorithm: HashAlgorithm,
   ): Promise<UnmaskedPredicate> {
-    return UnmaskedPredicate.create(token.id, token.type, token.latestTransaction, signingService, hashAlgorithm);
-  }
+    const nonce = await signingService.sign(
+      await new DataHasher(HashAlgorithm.SHA256).update(transaction.data.salt).digest(),
+    );
 
-  /**
-   * Create unmasked predicate from mint transaction.
-   *
-   * @param {MintTransaction} transaction        mint transaction
-   * @param {SigningService} signingService signing service
-   * @param {HashAlgorithm} hashAlgorithm  hash algorithm
-   * @return predicate
-   */
-  public static createFromMintTransaction(
-    transaction: MintTransaction,
-    signingService: SigningService,
-    hashAlgorithm: HashAlgorithm,
-  ): Promise<UnmaskedPredicate> {
-    return UnmaskedPredicate.create(
-      transaction.data.tokenId,
-      transaction.data.tokenType,
-      transaction,
-      signingService,
+    return new UnmaskedPredicate(
+      tokenId,
+      tokenType,
+      signingService.publicKey,
+      signingService.algorithm,
       hashAlgorithm,
+      nonce.bytes,
     );
   }
 
@@ -97,36 +90,6 @@ export class UnmaskedPredicate extends DefaultPredicate {
     );
   }
 
-  /**
-   * Create unmasked predicate.
-   *
-   * @param {TokenId} tokenId        token id
-   * @param {TokenType} tokenType        token type
-   * @param {MintTransaction | TransferTransaction} transaction        transaction
-   * @param {SigningService} signingService signing service
-   * @param {HashAlgorithm} hashAlgorithm  hash algorithm
-   */
-  private static async create(
-    tokenId: TokenId,
-    tokenType: TokenType,
-    transaction: MintTransaction | TransferTransaction,
-    signingService: SigningService,
-    hashAlgorithm: HashAlgorithm,
-  ): Promise<UnmaskedPredicate> {
-    const nonce = await signingService.sign(
-      await new DataHasher(HashAlgorithm.SHA256).update(transaction.data.salt).digest(),
-    );
-
-    return new UnmaskedPredicate(
-      tokenId,
-      tokenType,
-      signingService.publicKey,
-      signingService.algorithm,
-      hashAlgorithm,
-      nonce.bytes,
-    );
-  }
-
   /**
    * Verify token state for current transaction.
    *

src/transaction/MintTransaction.ts

@@ -88,7 +88,10 @@ export class MintTransaction extends Transaction<MintTransactionData> {
       await StateId.create(signingService.publicKey, this.data.sourceState),
     );
     if (inclusionProofVerificationResult !== InclusionProofVerificationStatus.OK) {
-      return new VerificationResult(VerificationResultCode.FAIL, 'Inclusion proof verification failed.');
+      return new VerificationResult(
+        VerificationResultCode.FAIL,
+        `Inclusion proof verification failed with status ${inclusionProofVerificationResult}.`,
+      );
     }
 
     return new VerificationResult(VerificationResultCode.OK);

tests/MintTokenUtils.ts

@@ -92,7 +92,13 @@ export async function mintToken(
     trustBase,
     mintReasonFactory,
     new TokenState(
-      MaskedPredicate.createFromMintTransaction(transaction, signingService, HashAlgorithm.SHA256, data.nonce),
+      MaskedPredicate.create(
+        transaction.data.tokenId,
+        transaction.data.tokenType,
+        signingService,
+        HashAlgorithm.SHA256,
+        data.nonce,
+      ),
       data.data,
     ),
     transaction,

tests/functional/token/TokenUsageExampleTest.ts

@@ -49,7 +49,7 @@ describe('Transition', function () {
     const signingService = await SigningService.createFromSecret(new Uint8Array(32), data.nonce);
 
     const nonce = crypto.getRandomValues(new Uint8Array(32));
-    const predicate = MaskedPredicate.createFromToken(token, signingService, HashAlgorithm.SHA256, nonce);
+    const predicate = MaskedPredicate.create(token.id, token.type, signingService, HashAlgorithm.SHA256, nonce);
     const reference = await predicate.getReference();
     const transaction = await sendToken(
       trustBase,
@@ -83,7 +83,7 @@ describe('Transition', function () {
         trustBase,
         mintReasonFactory,
         new TokenState(
-          MaskedPredicate.createFromToken(token, signingService, HashAlgorithm.SHA256, new Uint8Array(30)),
+          MaskedPredicate.create(token.id, token.type, signingService, HashAlgorithm.SHA256, new Uint8Array(30)),
           new TextEncoder().encode('test data'),
         ),
         transaction,

tests/token/CommonTestFlow.ts

@@ -76,7 +76,13 @@ export async function testTransferFlow(trustBase: RootTrustBase, client: StateTr
   const bobTokenState = "Bob's custom data"; // Bob gives this custom data to the Alice to use in the transfer
   const bobNonce = crypto.getRandomValues(new Uint8Array(32));
   const bobSigningService = await SigningService.createFromSecret(bobSecret, bobNonce);
-  const bobPredicate = MaskedPredicate.createFromToken(aliceToken, bobSigningService, HashAlgorithm.SHA256, bobNonce);
+  const bobPredicate = MaskedPredicate.create(
+    aliceToken.id,
+    aliceToken.type,
+    bobSigningService,
+    HashAlgorithm.SHA256,
+    bobNonce,
+  );
 
   const bobAddress = await bobPredicate.getReference().then((reference) => reference.toAddress());
 
@@ -151,7 +157,13 @@ export async function testTransferFlow(trustBase: RootTrustBase, client: StateTr
   const carolTransaction = await TransferTransaction.fromJSON(txToCarol.toJSON());
 
   // now Carol can create an UnmaskedPredicate knowing token information
-  const carolPredicate = await UnmaskedPredicate.createFromToken(carolToken, carolSigningService, HashAlgorithm.SHA256);
+  const carolPredicate = await UnmaskedPredicate.create(
+    carolToken.id,
+    carolToken.type,
+    carolTransaction,
+    carolSigningService,
+    HashAlgorithm.SHA256,
+  );
 
   // Finish the transaction with the Carol predicate
   expect(carolTransaction.data.recipientDataHash).toBeNull();
@@ -181,7 +193,13 @@ export async function testOfflineTransferFlow(trustBase: RootTrustBase, client:
   // Recipient prepares the info for the transfer
   const nonce = crypto.getRandomValues(new Uint8Array(32));
   const bobSigningService = await SigningService.createFromSecret(bobSecret, nonce);
-  const recipientPredicate = MaskedPredicate.createFromToken(token, bobSigningService, HashAlgorithm.SHA256, nonce);
+  const recipientPredicate = MaskedPredicate.create(
+    token.id,
+    token.type,
+    bobSigningService,
+    HashAlgorithm.SHA256,
+    nonce,
+  );
 
   const receivingAddress = await recipientPredicate.getReference().then((reference) => reference.toAddress());
 
@@ -344,8 +362,9 @@ export async function testSplitFlowAfterTransfer(
 
   const importedTransaction = await TransferTransaction.fromJSON(JSON.parse(JSON.stringify(sendTokenTx.toJSON())));
 
-  const maskedPredicate = MaskedPredicate.createFromToken(
-    receiverImportedToken,
+  const maskedPredicate = MaskedPredicate.create(
+    receiverImportedToken.id,
+    receiverImportedToken.type,
     recipientSigningService,
     HashAlgorithm.SHA256,
     receiverNonce,
@@ -459,8 +478,9 @@ async function splitToken(
         trustBase,
         mintReasonFactory,
         new TokenState(
-          MaskedPredicate.createFromMintTransaction(
-            transaction,
+          MaskedPredicate.create(
+            transaction.data.tokenId,
+            transaction.data.tokenType,
             await SigningService.createFromSecret(ownerSecret, nonce),
             HashAlgorithm.SHA256,
             nonce,