trac-msb 0.2.7 → 0.2.9

package/src/core/state/utils/address.js

@@ -1,7 +1,13 @@
 import b4a from 'b4a';
+import { address as addressApi } from 'trac-crypto-api';
 
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-import { TRAC_ADDRESS_SIZE } from '../../../utils/constants.js';
+const boolSafe = condition => {
+    try {
+        return condition()
+    } catch (_ignored) {
+        return false
+    }
+}
 
 /**
  * Checks if a given address is a valid TRAC bech32m address.
@@ -9,31 +15,28 @@ import { TRAC_ADDRESS_SIZE } from '../../../utils/constants.js';
  * So, it is possible that even if an address is considered valid,
  * it may not be a real address on the network.
  * @param {string | Buffer} address - The address to validate.
- * @param {string} [prefix] - The HRP of the bech32m address. Default is Trac Network mainnet prefix
+ * @param {string} hrp - The HRP of the bech32m address.
  * @returns {boolean} True if the address is valid, false otherwise.
  */
-export function isAddressValid(address, prefix = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
+export function isAddressValid(address, hrp) {
     if (b4a.isBuffer(address)) {
         address = address.toString('ascii');
     }
-    const bech32Chars = /^[qpzry9x8gf2tvdw0s3jn54khce6mua7l]+$/;
-    if (typeof address === 'string' &&
-        address.length === TRAC_ADDRESS_SIZE &&
-        address.startsWith(prefix + '1') &&
-        bech32Chars.test(address.slice(prefix.length + 1))) {
-        return true;
-    }
-    return false;
+
+    return boolSafe(() => 
+        addressApi.size(hrp) === address.length && address.startsWith(`${hrp}1`) && addressApi.isValid(address)
+    );
 }
 
 
 /**
  * Converts a valid bech32m address string to a buffer.
  * @param {string} bech32mAddress - The bech32m address to convert.
+ * @param {string} hrp - The HRP of the bech32m address.
  * @returns {Buffer} The buffer representation of the address, or an empty buffer if invalid.
  */
 // TODO: Check if a try-catch is really necessary here
-export function addressToBuffer(bech32mAddress, hrp = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
+export function addressToBuffer(bech32mAddress, hrp) {
     try {
         if (!isAddressValid(bech32mAddress, hrp)) {
             return b4a.alloc(0);
@@ -48,10 +51,11 @@ export function addressToBuffer(bech32mAddress, hrp = TRAC_NETWORK_MSB_MAINNET_P
 /**
  * Converts a buffer to a bech32m address string if valid.
  * @param {Buffer} dataBuffer - The buffer to convert.
+ * @param {string} hrp - The HRP of the bech32m address.
  * @returns {string|null} The address string if valid, otherwise null.
  */
 // TODO: Do we really need to try-catch here? Maybe we should only validate the input buffer.
-export function bufferToAddress(dataBuffer, hrp = TRAC_NETWORK_MSB_MAINNET_PREFIX) {
+export function bufferToAddress(dataBuffer, hrp) {
     try {
         const address = dataBuffer.toString('ascii');
         if (!isAddressValid(address, hrp)) return null;
@@ -66,6 +70,4 @@ export default {
     isAddressValid,
     addressToBuffer,
     bufferToAddress,
-    TRAC_ADDRESS_SIZE,
-    TRAC_NETWORK_MSB_MAINNET_PREFIX
 };

package/src/core/state/utils/adminEntry.js

@@ -1,11 +1,9 @@
 import b4a from 'b4a';
 
 import { bufferToAddress, isAddressValid } from './address.js';
-import {TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-import { WRITER_BYTE_LENGTH, TRAC_ADDRESS_SIZE} from '../../../utils/constants.js';
+import { WRITER_BYTE_LENGTH } from '../../../utils/constants.js';
 import { isBufferValid } from '../../../utils/buffer.js';
-
-const ADMIN_ENTRY_SIZE = TRAC_ADDRESS_SIZE + WRITER_BYTE_LENGTH;
+import { address as addressApi } from 'trac-crypto-api';
 
 /**
  * Encodes an admin entry as a buffer containing the TRAC address and writing key.
@@ -15,17 +13,18 @@ const ADMIN_ENTRY_SIZE = TRAC_ADDRESS_SIZE + WRITER_BYTE_LENGTH;
  *
  * @param {Buffer} address - The admin address.
  * @param {Buffer} wk - The admin's writing key buffer (must be 32 bytes).
+ * @param {string} addressHrp - The HRP of the bech32m address.
  * @returns {Buffer} The encoded admin entry buffer, or an empty buffer if input is invalid.
  */
-export function encode(address, wk) {
+export function encode(address, wk, addressHrp) {
     try {
-        if (!isAddressValid(address, TRAC_NETWORK_MSB_MAINNET_PREFIX) ||
+        if (!isAddressValid(address, addressHrp) ||
             !isBufferValid(wk, WRITER_BYTE_LENGTH)) {
             throw new Error('Invalid address or writing key buffer');
         }
-        const adminEntry = b4a.alloc(TRAC_ADDRESS_SIZE + WRITER_BYTE_LENGTH);
+        const adminEntry = b4a.alloc(address.length + WRITER_BYTE_LENGTH);
         b4a.copy(address, adminEntry, 0);
-        b4a.copy(wk, adminEntry, TRAC_ADDRESS_SIZE);
+        b4a.copy(wk, adminEntry, address.length);
         return adminEntry;
     } catch (error) {
         console.error('Error when encoding admin entry:', error);
@@ -40,19 +39,21 @@ export function encode(address, wk) {
  * Where TRAC_ADDRESS is a bech32m-encoded address without the HRP and separator.
  *
  * @param {Buffer} adminEntry - The encoded admin entry buffer.
+ * @param {string} addressHrp - The HRP of the bech32m address.
  * @returns {Object | null} An object with:
  *   - address: String containing the TRAC address.
  *   - wk: Buffer containing the writing key.
  */
-export function decode(adminEntry) {
-    if (!isBufferValid(adminEntry, ADMIN_ENTRY_SIZE)) {
-        return null;
-    }
-
+export function decode(adminEntry, addressHrp) {
     try {
-        const addressPart = adminEntry.subarray(0, TRAC_ADDRESS_SIZE);
-        const address = bufferToAddress(addressPart, TRAC_NETWORK_MSB_MAINNET_PREFIX);
-        const wk = adminEntry.subarray(TRAC_ADDRESS_SIZE);
+        const addressLength = addressApi.size(addressHrp)
+        if (!isBufferValid(adminEntry, addressLength + WRITER_BYTE_LENGTH)) {
+            return null;
+        }
+
+        const addressPart = adminEntry.subarray(0, addressLength);
+        const address = bufferToAddress(addressPart, addressHrp);
+        const wk = adminEntry.subarray(addressLength);
         return { address, wk };
     }
     catch (error) {

package/src/core/state/utils/deploymentEntry.js

@@ -1,34 +1,33 @@
 import b4a from 'b4a';
 
-import { bufferToAddress, isAddressValid } from './address.js';
-import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
-import { BOOTSTRAP_BYTE_LENGTH, HASH_BYTE_LENGTH, TRAC_ADDRESS_SIZE } from '../../../utils/constants.js';
+import { isAddressValid } from './address.js';
+import { HASH_BYTE_LENGTH } from '../../../utils/constants.js';
 import { isBufferValid } from '../../../utils/buffer.js';
 
-
 /**
  * Encodes a transaction entry into a buffer containing the TX hash and TRAC address.
  *
  * Buffer format:
- *   [TX_HASH(32)][TRAC_ADDRESS(TRAC_ADDRESS_SIZE)]
+ *   [TX_HASH(32)][TRAC_ADDRESS(addressLength)]
  *
  * - TX_HASH: Transaction hash buffer (must be exactly HASH_BYTE_LENGTH bytes).
  * - TRAC_ADDRESS: A bech32m-encoded address (without HRP and separator).
  *
  * @param {Buffer} txHash - Transaction hash buffer.
  * @param {Buffer} address - The account address that initiated the deployment.
+ * @param {string} hrp - The HRP of the bech32m address.
  * @returns {Buffer} A buffer containing the encoded transaction entry, or an empty buffer if input is invalid.
  */
 
-export function encode(txHash, address) {
+export function encode(txHash, address, hrp) {
     try {
         if (!isBufferValid(txHash, HASH_BYTE_LENGTH) ||
-            !isAddressValid(address, TRAC_NETWORK_MSB_MAINNET_PREFIX)) {
+            !isAddressValid(address, hrp)) {
             console.error('Invalid txHash or address buffer');
             return b4a.alloc(0);
         }
 
-        const entry = b4a.alloc(HASH_BYTE_LENGTH + TRAC_ADDRESS_SIZE);
+        const entry = b4a.alloc(HASH_BYTE_LENGTH + address.length);
 
         b4a.copy(txHash, entry, 0);
         b4a.copy(address, entry, HASH_BYTE_LENGTH);
@@ -44,32 +43,33 @@ export function encode(txHash, address) {
  * Decodes a transaction entry buffer into its TX hash and TRAC address.
  *
  * Buffer format:
- *   [TX_HASH(32)][TRAC_ADDRESS(TRAC_ADDRESS_SIZE)]
+ *   [TX_HASH(32)][TRAC_ADDRESS(addressLength)]
  *
  * - TX_HASH: Transaction hash buffer.
  * - TRAC_ADDRESS: A bech32m-encoded address (without HRP and separator).
  *
  * @param {Buffer} entry - The encoded transaction entry buffer.
+ * @param {number} addressLength - The length of the address of the network.
  * @returns {{ txHash: Buffer, address: Buffer }} An object containing:
  *          - txHash: The transaction hash buffer.
  *          - address: The TRAC address buffer.
  *          or null if the input is invalid.
  */
-export function decode(entry) {
+export function decode(entry, addressLength) {
     try {
-        if (!isBufferValid(entry, HASH_BYTE_LENGTH + TRAC_ADDRESS_SIZE)) {
+        if (!isBufferValid(entry, HASH_BYTE_LENGTH + addressLength)) {
             console.error('Invalid transaction entry buffer');
-            return b4a.alloc(0);
+            return null;
         }
 
         const txHash = entry.subarray(0, HASH_BYTE_LENGTH);
-        const address = entry.subarray(HASH_BYTE_LENGTH, HASH_BYTE_LENGTH + TRAC_ADDRESS_SIZE);
+        const address = entry.subarray(HASH_BYTE_LENGTH, HASH_BYTE_LENGTH + addressLength);
 
         return { txHash, address };
     } catch (error) {
         console.error('Error decoding transaction entry:', error);
-        return b4a.alloc(0);
+        return null;
     }
 }
 
-export default { encode, decode };
+export default { encode, decode };

package/src/core/state/utils/transaction.js

@@ -1,15 +1,6 @@
 import b4a from 'b4a';
+import { NONCE_BYTE_LENGTH, WRITER_BYTE_LENGTH } from '../../../utils/constants.js';
 
-import { HASH_BYTE_LENGTH, NONCE_BYTE_LENGTH, WRITER_BYTE_LENGTH, TRAC_ADDRESS_SIZE } from '../../../utils/constants.js';
-import { blake3Hash } from '../../../utils/crypto.js';
-import {safeWriteUInt32BE} from "../../../utils/buffer.js";
-
-/**
- * Total size of a transaction buffer in bytes.
- * Format: bootstrap + validator_address + msb_bootstrap + local_address + local_writer_key + content_hash + nonce
- * @type {number}
- */
-export const TRANSACTION_TOTAL_SIZE = 3 * WRITER_BYTE_LENGTH + 2 * TRAC_ADDRESS_SIZE + HASH_BYTE_LENGTH + NONCE_BYTE_LENGTH;
 export const BOOTSTRAP_DEPLOYMENT_SIZE = WRITER_BYTE_LENGTH + NONCE_BYTE_LENGTH + 4; // 4 bytes for OperationType because it is a UInt32BE
 export const MAXIMUM_OPERATION_PAYLOAD_SIZE = 4096; // Maximum size of a transaction buffer in bytes
 
@@ -27,92 +18,9 @@ export const Status = Object.freeze({
     IGNORE: 2
 });
 
-// TODO: This function receives too many arguments. It would be better to encapsulate them in an object.
-/**
- * Generates a transaction buffer and returns its double BLAKE-3 hash.
- * @param {Buffer} bootstrap - The bootstrap buffer.
- * @param {Buffer} msb_bootstrap - The MSB bootstrap buffer.
- * @param {Buffer} validator_address - The validator address buffer.
- * @param {Buffer} local_writer_key - The local writer key buffer.
- * @param {Buffer} local_address - The local address buffer.
- * @param {Buffer} content_hash - The content hash buffer.
- * @param {Buffer} nonce - The nonce buffer.
- * @returns {Promise<Buffer>} The double BLAKE-3 hash of the transaction buffer, or an empty buffer on error.
- */
-export async function generateTxBuffer(bootstrap, msb_bootstrap, validator_address, local_writer_key, local_address, content_hash, nonce) {
-    try {
-        const tx = b4a.allocUnsafe(TRANSACTION_TOTAL_SIZE);
-        let offset = 0;
-
-        bootstrap.copy(tx, offset);
-        offset += bootstrap.length;
-
-        msb_bootstrap.copy(tx, offset);
-        offset += msb_bootstrap.length;
-
-        validator_address.copy(tx, offset);
-        offset += validator_address.length;
-
-        local_writer_key.copy(tx, offset);
-        offset += local_writer_key.length;
-
-        local_address.copy(tx, offset);
-        offset += local_address.length;
-
-        content_hash.copy(tx, offset);
-        offset += content_hash.length;
-
-        nonce.copy(tx, offset);
-        return await blake3Hash(tx)
-    } catch (error) {
-        console.error('Error in generateTxBuffer:', error);
-        return b4a.alloc(0);
-    }
-}
-
-/**
- * Generates a transaction buffer for bootstrap deployment and returns its BLAKE-3 hash.
- * The buffer consists of three parts concatenated in the following order:
- * 1. bootstrap (32 bytes) - The bootstrap identifier
- * 2. incoming_nonce (32 bytes) - Nonce from the requesting node
- * 3. operationType (4 bytes) - UInt32BE representing the operation type
- *
- * Total size: BOOTSTRAP_DEPLOYMENT_SIZE (68 bytes)
- *
- * @param {Buffer} bootstrap - The bootstrap identifier buffer (32 bytes)
- * @param {Buffer} incoming_nonce - The nonce from the requesting node (32 bytes)
- * @param {number} operationType - The operation type (should be OperationType.BOOTSTRAP_DEPLOYMENT)
- * @returns {Promise<Buffer>} The BLAKE-3 hash of the transaction buffer, or an empty buffer on error
- */
-export async function generateBootstrapDeploymentTxBuffer(bootstrap, incoming_nonce, operationType) {
-    try {
-
-        const opTypeBuffer = safeWriteUInt32BE(operationType, 0);
-        if (opTypeBuffer.length !== 4) {
-            return b4a.alloc(0);
-        }
-        const tx = b4a.alloc(BOOTSTRAP_DEPLOYMENT_SIZE);
-        let offset = 0;
-
-        bootstrap.copy(tx, offset);
-        offset += bootstrap.length;
-
-        incoming_nonce.copy(tx, offset);
-        offset += incoming_nonce.length;
-
-        opTypeBuffer.copy(tx, offset);
-
-        return await blake3Hash(tx)
-    } catch (error) {
-        console.error('Error in generateBootstrapDeploymentTxBuffer:', error);
-        return b4a.alloc(0);
-    }
-}
-
 export default {
-    generateTxBuffer,
-    generateBootstrapDeploymentTxBuffer,
-    TRANSACTION_TOTAL_SIZE,
+    Status,
+    BOOTSTRAP_DEPLOYMENT_SIZE,
     MAXIMUM_OPERATION_PAYLOAD_SIZE,
     FEE
 };