Merge pull request #47 from Bako-Labs/p2/feat/coder-utils

FEAT: adds utils to encoding operations

Author: guimroque

.changeset/bakosafe-encoding-utils.md

@@ -0,0 +1,5 @@
+---
+'bakosafe': minor
+---
+
+feat(coders): add comprehensive encoding utilities and vault signature support

.gitignore

@@ -7,4 +7,5 @@
 .turbo
 .local/
 local/
-packages/sway/.fuels
+packages/sway/.fuels
+.context

packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bakosafe",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "author": "Bako Labs",
   "description": "A signature validation package built based on sway in the fuel network",
   "main": "dist/index.js",

packages/sdk/src/modules/coders/CoderUtils.ts

@@ -0,0 +1,46 @@
+import { EncodingService, SignatureService } from './services';
+import type { SigLoose } from './services';
+import { DEFAULT_PREDICATE_VERSION } from '../../sway/predicates/predicateFinder';
+
+/**
+ * Centralized class for common encoding operations, such as signature serialization and transaction ID encoding.
+ *
+ * @example
+ * ```ts
+ * // Encode a wallet signature
+ * const encodedSignature = CoderUtils.encodeSignature(wallet.address, signature);
+ *
+ * // Encode a transaction ID
+ * const encodedTxId = CoderUtils.encodeTxId(txId, 'v1');
+ * ```
+ */
+export class CoderUtils {
+  /**
+   * Encodes a signature for use with Bako predicates based on wallet type and predicate version.
+   *
+   * @param walletAddress - The wallet address associated with the signature.
+   * @param signature - The raw or structured signature data.
+   * @param predicateVersion - (Optional) Predicate version used for encoding.
+   * Defaults to {@link DEFAULT_PREDICATE_VERSION}.
+   * @returns The encoded signature as a string.
+   */
+  static encodeSignature(
+    walletAddress: string,
+    signature: SigLoose,
+    predicateVersion: string = DEFAULT_PREDICATE_VERSION,
+  ): string {
+    return SignatureService.encode(walletAddress, signature, predicateVersion);
+  }
+
+  /**
+   * Encodes a transaction ID based on the predicate version requirements.
+   *
+   * @param txId - The transaction ID to encode.
+   * @param version - The version identifier for encoding.
+   * @returns The encoded transaction ID as a `Uint8Array` or `string`,
+   * depending on the encoding strategy.
+   */
+  static encodeTxId(txId: string, version: string): Uint8Array | string {
+    return EncodingService.encodeTxId(txId, version);
+  }
+}

packages/sdk/src/modules/coders/README.md

@@ -9,12 +9,13 @@ coders/
 ├── Coder.ts                       # Main encoding class
 ├── types.ts                       # Type definitions
 ├── factory/                       # Factory pattern implementations
-│   ├── CoderFactory.ts           # Creates configured instances
+│   ├── CoderFactory.ts            # Creates configured instances (internal)
 │   └── index.ts
 ├── services/                      # Encoding services
-│   ├── SignatureService.ts       # Signature encoding logic
-│   ├── EncodingService.ts        # Transaction ID encoding
+│   ├── SignatureService.ts        # Signature encoding logic
+│   ├── EncodingService.ts         # Transaction ID encoding
 │   └── index.ts
+├── CoderUtils.ts                  # Centralizes common encoding operations
 ├── index.ts                       # Main exports
 └── README.md                      # This file
 ```

packages/sdk/src/modules/coders/index.ts

@@ -17,15 +17,15 @@
 
 export * from './coder';
 export * from './types';
-export * from './factory';
 export * from './services';
+export { CoderUtils } from './CoderUtils';
 
 // Backward compatibility - deprecated exports
 import { CoderFactory } from './factory';
 import { SignatureService, EncodingService } from './services';
 
 /**
- * @deprecated Use CoderFactory.createFullCoder() instead
+ * @deprecated Use CoderUtils.encodeSignature() instead
  *
  * This export is maintained for backward compatibility but should not
  * be used in new code. Use the factory pattern instead for better
@@ -34,7 +34,7 @@ import { SignatureService, EncodingService } from './services';
 export const bakoCoder = CoderFactory.createFullCoder();
 
 /**
- * @deprecated Use SignatureService.encode() instead
+ * @deprecated Use CoderUtils.encodeSignature() instead
  *
  * This export is maintained for backward compatibility but should not
  * be used in new code. Use the SignatureService class directly for
@@ -43,7 +43,7 @@ export const bakoCoder = CoderFactory.createFullCoder();
 export const encodeSignature = SignatureService.encode;
 
 /**
- * @deprecated Use EncodingService.encodeTxId() instead
+ * @deprecated Use CoderUtils.encodeTxId() instead
  *
  * This export is maintained for backward compatibility but should not
  * be used in new code. Use the EncodingService class directly for

packages/sdk/src/modules/coders/services/EncodingService.ts

@@ -1,27 +1,18 @@
 import { arrayify } from 'fuels';
 import { stringToHex } from 'viem';
 import { BYTE_VERSION_LIST, BytesVersion } from '../types';
-import { getTxIdEncoded } from '..';
 import { ENCODING_VERSIONS } from '../utils/versionsByEncode';
 
 /**
  * Service class for encoding operations related to transaction IDs and general encoding tasks.
  */
 export class EncodingService {
-  /**
-   * Set of predicate versions for efficient lookup of byte-encoding requirements.
-   */
-  private static readonly BYTE_VERSION_SET = new Set<string>(
-    BYTE_VERSION_LIST as readonly string[],
-  );
-
-
   /**
    * Encodes a transaction ID based on the predicate version requirements.
    */
   static encodeTxId(txId: string, version: string): Uint8Array | string {
     switch (true) {
-      case EncodingService.BYTE_VERSION_SET.has(version):
+      case this.requiresByteEncoding(version):
         return arrayify(txId.startsWith('0x') ? txId : `0x${txId}`);
       default:
         return txId.startsWith('0x')
@@ -33,8 +24,8 @@ export class EncodingService {
   /**
    * Encodes a transaction ID for BakoSafe predicates
    */
-  static bakosafeEncode = (txId: string, version: string) => {
-    return this.encodeTxId(txId, version) as string;
+  static bakosafeEncode = (txId: string) => {
+    return txId.startsWith('0x') ? txId.slice(2) : txId;
   };
 
   /**
@@ -45,15 +36,15 @@ export class EncodingService {
   };
 
   /**
- * Determines the encoding function for a given version
- */
+   * Determines the encoding function for a given version
+   */
   static determineEncodingFunction(version: string): (txId: string) => string {
     if (ENCODING_VERSIONS.with0xPrefix.includes(version)) {
       return this.connectorEncode;
     }
 
     if (ENCODING_VERSIONS.without0xPrefix.includes(version)) {
-      return (txId: string) => this.bakosafeEncode(txId, version);
+      return (txId: string) => this.bakosafeEncode(txId);
     }
 
     throw new Error(`Unsupported version: ${version}`);
@@ -71,7 +62,7 @@ export class EncodingService {
    * Checks if a predicate version requires byte array encoding.
    */
   static requiresByteEncoding(version: string): version is BytesVersion {
-    return EncodingService.BYTE_VERSION_SET.has(version);
+    return ENCODING_VERSIONS.with0xPrefix.includes(version);
   }
 
   /**
@@ -80,4 +71,4 @@ export class EncodingService {
   static getByteVersions(): readonly string[] {
     return BYTE_VERSION_LIST;
   }
-}
+}

packages/sdk/src/modules/coders/services/SignatureService.ts

@@ -17,7 +17,7 @@ import { CoderFactory } from '../factory';
 /**
  * Flexible signature type that accepts BytesLike data, signature objects, or WebAuthn inputs.
  */
-type SigLoose = BytesLike | { signature: BytesLike } | WebAuthnInput;
+export type SigLoose = BytesLike | { signature: BytesLike } | WebAuthnInput;
 
 /**
  * Classification result for different signature types with their corresponding data.

packages/sdk/src/modules/vault/Vault.ts

@@ -37,7 +37,7 @@ import {
 } from './services';
 import { VaultConfigurationFactory } from './factory';
 import { Asset } from './assets';
-import { EncodingService } from '../coders';
+import { EncodingService, SignatureService, type SigLoose } from '../coders';
 
 import partition from 'lodash.partition';
 
@@ -303,6 +303,17 @@ export class Vault extends Predicate<[]> {
     throw new Error('Use a VaultProvider to consume this method');
   }
 
+  /**
+   * Encodes a signature according to the vault version.
+   *
+   * @param walletAddress - Address of the signer who produced the signature.
+   * @param signature - The raw or structured signature.
+   * @returns Encoded signature string compatible with the vault version.
+   */
+  public encodeSignature(walletAddress: string, signature: SigLoose) {
+    return SignatureService.encode(walletAddress, signature, this.version);
+  }
+
   /**
    * Recovers a `Vault` instance from a predicate address.
    *
@@ -387,6 +398,7 @@ export class Vault extends Predicate<[]> {
   async transaction(params: VaultTransaction): Promise<{
     tx: TransactionRequest;
     hashTxId: string;
+    encodedTxId: string;
   }> {
     const { assets } = params;
     const assetsWithAddressType = await Promise.all(