Revert bigint changes

package.json

@@ -32,7 +32,7 @@
   "license": "ISC",
   "homepage": "https://unicitynetwork.github.io/state-transition-sdk/",
   "dependencies": {
-    "@unicitylabs/commons": "2.4.0-rc.d7fa010"
+    "@unicitylabs/commons": "2.4.0-rc.24d6a7c"
   },
   "devDependencies": {
     "@babel/preset-env": "7.27.2",

src/StateTransitionClient.ts

@@ -1,7 +1,9 @@
-import { Authenticator } from '@unicitylabs/commons/lib/api/Authenticator.js';
 import { InclusionProof, InclusionProofVerificationStatus } from '@unicitylabs/commons/lib/api/InclusionProof.js';
 import { RequestId } from '@unicitylabs/commons/lib/api/RequestId.js';
-import { SubmitCommitmentStatus } from '@unicitylabs/commons/lib/api/SubmitCommitmentResponse.js';
+import {
+  SubmitCommitmentResponse,
+  SubmitCommitmentStatus,
+} from '@unicitylabs/commons/lib/api/SubmitCommitmentResponse.js';
 import { HashAlgorithm } from '@unicitylabs/commons/lib/hash/HashAlgorithm.js';
 import { SigningService } from '@unicitylabs/commons/lib/signing/SigningService.js';
 import { HexConverter } from '@unicitylabs/commons/lib/util/HexConverter.js';
@@ -57,17 +59,28 @@ export class StateTransitionClient {
   public async submitMintTransaction<T extends MintTransactionData<ISerializable | null>>(
     transactionData: T,
   ): Promise<Commitment<T>> {
-    return this.sendTransaction(
+    const commitment = await Commitment.create(
       transactionData,
       await SigningService.createFromSecret(MINTER_SECRET, transactionData.tokenId.bytes),
     );
+
+    const result = await this.client.submitTransaction(
+      commitment.requestId,
+      commitment.transactionData.hash,
+      commitment.authenticator,
+    );
+
+    if (result.status !== SubmitCommitmentStatus.SUCCESS) {
+      throw new Error(`Could not submit transaction: ${result.status}`);
+    }
+
+    return commitment;
   }
 
   /**
    * Submit a state transition for an existing token.
    *
-   * @param transactionData Data describing the transition
-   * @param signingService   Signing service for the current owner
+   * @param {Commitment} commitment Commitment containing the request information
    * @returns Commitment ready for inclusion proof retrieval
    * @throws Error if ownership verification fails or aggregator rejects
    *
@@ -76,15 +89,16 @@ export class StateTransitionClient {
    * const commitment = await client.submitTransaction(data, signingService);
    * ```
    */
-  public async submitTransaction(
-    transactionData: TransactionData,
-    signingService: SigningService,
-  ): Promise<Commitment<TransactionData>> {
-    if (!(await transactionData.sourceState.unlockPredicate.isOwner(signingService.publicKey))) {
-      throw new Error('Failed to unlock token');
+  public submitCommitment(commitment: Commitment<TransactionData>): Promise<SubmitCommitmentResponse> {
+    if (!commitment.transactionData.sourceState.unlockPredicate.isOwner(commitment.authenticator.publicKey)) {
+      throw new Error('Ownership verification failed: Authenticator does not match source state predicate.');
     }
 
-    return this.sendTransaction(transactionData, signingService);
+    return this.client.submitTransaction(
+      commitment.requestId,
+      commitment.transactionData.hash,
+      commitment.authenticator,
+    );
   }
 
   /**
@@ -104,7 +118,7 @@ export class StateTransitionClient {
     { requestId, transactionData }: Commitment<T>,
     inclusionProof: InclusionProof,
   ): Promise<Transaction<T>> {
-    const status = await inclusionProof.verify(requestId.toBigInt());
+    const status = await inclusionProof.verify(requestId);
     if (status != InclusionProofVerificationStatus.OK) {
       throw new Error('Inclusion proof verification failed.');
     }
@@ -180,7 +194,7 @@ export class StateTransitionClient {
     const requestId = await RequestId.create(publicKey, token.state.hash);
     const inclusionProof = await this.client.getInclusionProof(requestId);
     // TODO: Check ownership?
-    return inclusionProof.verify(requestId.toBigInt());
+    return inclusionProof.verify(requestId);
   }
 
   /**
@@ -196,24 +210,4 @@ export class StateTransitionClient {
   ): Promise<InclusionProof> {
     return this.client.getInclusionProof(commitment.requestId);
   }
-
-  private async sendTransaction<TD extends TransactionData | MintTransactionData<ISerializable | null>>(
-    transactionData: TD,
-    signingService: SigningService,
-  ): Promise<Commitment<TD>> {
-    const requestId = await RequestId.create(signingService.publicKey, transactionData.sourceState.hash);
-
-    const authenticator = await Authenticator.create(
-      signingService,
-      transactionData.hash,
-      transactionData.sourceState.hash,
-    );
-    const result = await this.client.submitTransaction(requestId, transactionData.hash, authenticator);
-
-    if (result.status !== SubmitCommitmentStatus.SUCCESS) {
-      throw new Error(`Could not submit transaction: ${result.status}`);
-    }
-
-    return new Commitment(requestId, transactionData, authenticator);
-  }
 }

src/predicate/DefaultPredicate.ts

@@ -99,7 +99,7 @@ export abstract class DefaultPredicate implements IPredicate {
       CborEncoder.encodeTextString(this.type),
       CborEncoder.encodeByteString(this.publicKey),
       CborEncoder.encodeTextString(this.algorithm),
-      CborEncoder.encodeTextString(HashAlgorithm[this.hashAlgorithm]),
+      CborEncoder.encodeUnsignedInteger(this.hashAlgorithm),
       CborEncoder.encodeByteString(this.nonce),
     ]);
   }
@@ -129,7 +129,7 @@ export abstract class DefaultPredicate implements IPredicate {
 
     // Verify inclusion proof path.
     const requestId = await RequestId.create(this.publicKey, transaction.data.sourceState.hash);
-    const status = await transaction.inclusionProof.verify(requestId.toBigInt());
+    const status = await transaction.inclusionProof.verify(requestId);
     return status === InclusionProofVerificationStatus.OK;
   }
 

src/predicate/MaskedPredicate.ts

@@ -110,8 +110,8 @@ export class MaskedPredicate extends DefaultPredicate {
       throw new Error(`Invalid predicate type: expected ${PredicateType.MASKED}, got ${type}`);
     }
 
-    const hashAlgorithm = CborDecoder.readTextString(data[3]) as unknown as HashAlgorithm;
-    if (!HashAlgorithm[hashAlgorithm]) {
+    const hashAlgorithm = Number(CborDecoder.readUnsignedInteger(data[3]));
+    if (HashAlgorithm[hashAlgorithm] == null) {
       throw new Error(`Invalid hash algorithm: ${hashAlgorithm}`);
     }
 

src/predicate/UnmaskedPredicate.ts

@@ -107,8 +107,8 @@ export class UnmaskedPredicate extends DefaultPredicate {
       throw new Error(`Invalid predicate type: expected ${PredicateType.UNMASKED}, got ${type}`);
     }
 
-    const hashAlgorithm = CborDecoder.readTextString(data[3]) as unknown as HashAlgorithm;
-    if (!HashAlgorithm[hashAlgorithm]) {
+    const hashAlgorithm = Number(CborDecoder.readUnsignedInteger(data[3]));
+    if (HashAlgorithm[hashAlgorithm] == null) {
       throw new Error(`Invalid hash algorithm: ${hashAlgorithm}`);
     }
 

src/serializer/cbor/token/TokenCborSerializer.ts

@@ -0,0 +1,89 @@
+import { CborDecoder } from '@unicitylabs/commons/lib/cbor/CborDecoder.js';
+import { CborEncoder } from '@unicitylabs/commons/lib/cbor/CborEncoder.js';
+
+import { TokenStateCborSerializer } from './TokenStateCborSerializer.js';
+import { ISerializable } from '../../../ISerializable.js';
+import { IPredicateFactory } from '../../../predicate/IPredicateFactory.js';
+import { Token, TOKEN_VERSION } from '../../../token/Token.js';
+import { MintTransactionData } from '../../../transaction/MintTransactionData.js';
+import { Transaction } from '../../../transaction/Transaction.js';
+import { TransactionData } from '../../../transaction/TransactionData.js';
+import { ITokenSerializer } from '../../token/ITokenSerializer.js';
+import { MintTransactionCborSerializer } from '../transaction/MintTransactionCborSerializer.js';
+import { TransactionCborSerializer } from '../transaction/TransactionCborSerializer.js';
+
+/**
+ * A serializer for {@link Token} objects using CBOR encoding.
+ * Handles serialization and deserialization of tokens, including their transactions and state.
+ */
+export class TokenCborSerializer implements ITokenSerializer {
+  private readonly mintTransactionSerializer: MintTransactionCborSerializer;
+  private readonly transactionSerializer: TransactionCborSerializer;
+  private stateSerializer: TokenStateCborSerializer;
+
+  /**
+   * Constructs a new `TokenCborSerializer` instance.
+   *
+   * @param {IPredicateFactory} predicateFactory - A factory for creating predicates used in token serialization.
+   */
+  public constructor(private readonly predicateFactory: IPredicateFactory) {
+    this.mintTransactionSerializer = new MintTransactionCborSerializer(this);
+    this.transactionSerializer = new TransactionCborSerializer(predicateFactory);
+    this.stateSerializer = new TokenStateCborSerializer(predicateFactory);
+  }
+
+  /**
+   * Serializes a `Token` object into a CBOR-encoded byte array.
+   *
+   * @param {Token<Transaction<MintTransactionData<ISerializable | null>>>} token - The token to serialize.
+   * @returns {Uint8Array} The CBOR-encoded representation of the token.
+   */
+  public static serialize(token: Token<Transaction<MintTransactionData<ISerializable | null>>>): Uint8Array {
+    return CborEncoder.encodeArray([
+      CborEncoder.encodeTextString(token.version),
+      MintTransactionCborSerializer.serialize(token.genesis),
+      CborEncoder.encodeArray(
+        token.transactions.map((transaction) => TransactionCborSerializer.serialize(transaction)),
+      ),
+      TokenStateCborSerializer.serialize(token.state),
+      CborEncoder.encodeArray(token.nametagTokens.map((token) => token.toCBOR())),
+    ]);
+  }
+
+  /**
+   * Deserializes a CBOR-encoded `Uint8Array` into a `Token` object.
+   *
+   * @param {Uint8Array} bytes - The CBOR-encoded data to deserialize.
+   * @returns {Promise<Token<Transaction<MintTransactionData<ISerializable | null>>>>}
+   *          A promise that resolves to the deserialized `Token` object.
+   * @throws {Error} If the token version does not match the expected version.
+   */
+  public async deserialize(bytes: Uint8Array): Promise<Token<Transaction<MintTransactionData<ISerializable | null>>>> {
+    const data = CborDecoder.readArray(bytes);
+    const tokenVersion = CborDecoder.readTextString(data[0]);
+    if (tokenVersion !== TOKEN_VERSION) {
+      throw new Error(`Cannot parse token. Version mismatch: ${tokenVersion} !== ${TOKEN_VERSION}`);
+    }
+
+    const mintTransaction = await this.mintTransactionSerializer.deserialize(data[1]);
+    const transactions: Transaction<TransactionData>[] = [];
+    for (const transaction of CborDecoder.readArray(data[2])) {
+      transactions.push(
+        await this.transactionSerializer.deserialize(
+          mintTransaction.data.tokenId,
+          mintTransaction.data.tokenType,
+          transaction,
+        ),
+      );
+    }
+
+    // TODO: Add nametag tokens
+    return new Token(
+      await this.stateSerializer.deserialize(mintTransaction.data.tokenId, mintTransaction.data.tokenType, data[3]),
+      mintTransaction,
+      transactions,
+      [],
+      tokenVersion,
+    );
+  }
+}

src/serializer/cbor/token/TokenStateCborSerializer.ts

@@ -0,0 +1,49 @@
+import { CborDecoder } from '@unicitylabs/commons/lib/cbor/CborDecoder.js';
+import { CborEncoder } from '@unicitylabs/commons/lib/cbor/CborEncoder.js';
+
+import { IPredicateFactory } from '../../../predicate/IPredicateFactory.js';
+import { TokenId } from '../../../token/TokenId.js';
+import { TokenState } from '../../../token/TokenState.js';
+import { TokenType } from '../../../token/TokenType.js';
+
+/**
+ * A serializer for {@link TokenState} objects using CBOR encoding.
+ * Handles serialization and deserialization of token states.
+ */
+export class TokenStateCborSerializer {
+  /**
+   * Constructs a new `TokenStateCborSerializer` instance.
+   *
+   * @param {IPredicateFactory} predicateFactory - A factory for creating predicates used in token state deserialization.
+   */
+  public constructor(private readonly predicateFactory: IPredicateFactory) {}
+
+  /**
+   * Serializes a `TokenState` object into a CBOR-encoded byte array.
+   *
+   * @param {TokenState} state - The token state to serialize.
+   * @returns {Uint8Array} The CBOR-encoded representation of the token state.
+   */
+  public static serialize(state: TokenState): Uint8Array {
+    return CborEncoder.encodeArray([
+      state.unlockPredicate.toCBOR(),
+      CborEncoder.encodeOptional(state.data, CborEncoder.encodeByteString),
+    ]);
+  }
+
+  /**
+   * Deserializes a CBOR-encoded `Uint8Array` into a `TokenState` object.
+   *
+   * @param {TokenId} tokenId - The ID of the token associated with the state.
+   * @param {TokenType} tokenType - The type of the token associated with the state.
+   * @param {Uint8Array} bytes - The CBOR-encoded data to deserialize.
+   * @returns {Promise<TokenState>} A promise that resolves to the deserialized `TokenState` object.
+   */
+  public async deserialize(tokenId: TokenId, tokenType: TokenType, bytes: Uint8Array): Promise<TokenState> {
+    const data = CborDecoder.readArray(bytes);
+    return TokenState.create(
+      await this.predicateFactory.create(tokenId, tokenType, data[0]),
+      CborDecoder.readOptional(data[1], CborDecoder.readByteString),
+    );
+  }
+}