trac-msb 0.2.17 → 0.2.19

package/src/utils/deepEqualApplyPayload.js

@@ -0,0 +1,40 @@
+import b4a from 'b4a';
+import _ from 'lodash';
+
+export const isDeepEqualApplyPayload = (left, right) => {
+    if (left === right) return true;
+
+    const leftIsBuffer = b4a.isBuffer(left);
+    const rightIsBuffer = b4a.isBuffer(right);
+
+    if (leftIsBuffer || rightIsBuffer) {
+        return leftIsBuffer && rightIsBuffer && b4a.equals(left, right);
+    }
+
+    const leftIsArray = Array.isArray(left);
+    const rightIsArray = Array.isArray(right);
+
+    if (leftIsArray || rightIsArray) {
+        if (!leftIsArray || !rightIsArray) return false;
+        if (left.length !== right.length) return false;
+
+        for (let i = 0; i < left.length; i++) {
+            if (!isDeepEqualApplyPayload(left[i], right[i])) return false;
+        }
+        return true;
+    }
+
+    if (!_.isObject(left) || !_.isObject(right)) return false;
+
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+
+    if (leftKeys.length !== rightKeys.length) return false;
+
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(right, key)) return false;
+        if (!isDeepEqualApplyPayload(left[key], right[key])) return false;
+    }
+
+    return true;
+};

package/src/utils/errors.js

@@ -0,0 +1,20 @@
+export class ValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ValidationError";
+    }
+}
+
+export class BroadcastError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BroadcastError";
+    }
+}
+
+export class NotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "NotFoundError";
+    }
+}

package/src/utils/fileUtils.js

@@ -123,18 +123,26 @@ export async function getAllMigrationFiles(migrationDirectory = BALANCE_MIGRATED
     }
 }
 
-export async function ensureCoresStoreDir(config) {
+export async function ensureKeyPathDir(config) {
     try {
         // const storesDirectoryStats = await fs.promises.stat(config.storesDirectory);
         // if (!storesDirectoryStats.isDirectory()) {
         //     throw new Error(`Stores directory path is not a directory: ${config.storesDirectory}`);
         // }
-        await fs.promises.mkdir(config.storesFullPath, { recursive: true });
+        await fs.promises.mkdir(config.keyPairDirectoryPath, { recursive: true });
     } catch (err) {
         throw new Error(`Failed to ensure corestore directory: ${err.message}`);
     }
 }
 
+export function verifyWalletPath(config) {
+    try {
+        return fs.existsSync(config.keyPairPath)
+    } catch {
+        return false
+    }
+}
+
 export async function validateBalanceMigrationData(addresses) {
     const migrationFiles = await getAllMigrationFiles(BALANCE_MIGRATED_DIR);
     const addressSet = new Set(addresses.map(a => a.address));
@@ -206,10 +214,11 @@ export async function createWhitelistEntryFile(addresses, migrationNumber, migra
 }
 
 export default {
+    verifyWalletPath,
     readAddressesFromWhitelistFile,
     readBalanceMigrationFile,
     getAllMigrationFiles,
-    ensureCoresStoreDir,
+    ensureKeyPathDir,
     validateBalanceMigrationData,
     validateWhitelistMigrationData,
     getNextMigrationNumber,

package/src/utils/helpers.js

@@ -1,7 +1,8 @@
 import b4a from "b4a";
+import tracCryptoApi from "trac-crypto-api";
 import {bufferToAddress} from "../core/state/utils/address.js";
 import { EntryType } from "./constants.js";
-
+import { v7 as uuidv7 } from 'uuid';
 //TODO: change file name or split functions below into multiple files (Remember to update imports and tests accordingly)
 
 export function isHexString(string) {
@@ -95,3 +96,11 @@ export function isTransactionRecordPut(entry) {
     const is64 = entry.key.length === 64;
     return isPut && isHex && is64;
 }
+
+export function generateUUID() {
+    return uuidv7();
+}
+
+export function publicKeyToAddress(publicKey, config) {
+    return tracCryptoApi.address.encode(config.addressPrefix, b4a.isBuffer(publicKey) ? publicKey : b4a.from(publicKey, typeof publicKey === 'string' ? 'hex' : undefined));
+}

package/src/utils/logger.js

@@ -0,0 +1,25 @@
+export class Logger {
+    #config
+    constructor(config) {
+        this.#config = config;
+    }
+
+    info(message) {
+        console.log("i: " + message);
+    }
+
+    debug(message) {
+        if (this.#config.debug) {
+            console.debug("d: " + message);
+        }
+    }
+
+    error(message) {
+        console.error("e: " + message);
+    }
+
+    warn(message) {
+        console.warn("w: " + message);
+    }
+
+}

package/src/utils/migrationUtils.js

@@ -1,6 +1,6 @@
 
 import { isAddressValid } from '../core/state/utils/address.js';
-import PeerWallet from 'trac-wallet';
+import tracCryptoApi from 'trac-crypto-api';
 import b4a from 'b4a';
 import { ZERO_LICENSE } from '../core/state/utils/nodeEntry.js';
 
@@ -9,7 +9,7 @@ export async function validateAddressFromIncomingFile(stateInstance, config, add
         throw new Error(`Invalid address format: '${address}'. Please ensure all addresses are valid.`);
     }
 
-    const publicKey = PeerWallet.decodeBech32m(address);
+    const publicKey = tracCryptoApi.address.decode(address);
 
     if (!publicKey || publicKey.length !== 32) {
         throw new Error(`Invalid public key: '${address}'. Please ensure all addresses are valid.`);
@@ -32,4 +32,4 @@ export async function validateAddressFromIncomingFile(stateInstance, config, add
 
 export default {
     validateAddressFromIncomingFile
-};
+};

package/src/utils/normalizers.js

@@ -3,6 +3,7 @@ import { normalizeHex } from './helpers.js';
 import { addressToBuffer, bufferToAddress } from '../core/state/utils/address.js';
 import b4a from 'b4a';
 import { bufferToBigInt } from './amountSerialization.js'
+import {isBootstrapDeployment, isRoleAccess, isTransaction, isTransfer} from './applyOperations.js';
 
 /**
  * Normalizes the payload for a transfer operation.
@@ -199,3 +200,40 @@ export function normalizeBootstrapDeploymentOperation(payload, config) {
         bdo: normalizedBdo
     };
 }
+
+/**
+ * Normalizes an incoming partial operation message based on its operation type.
+ *
+ * @param {Object} message The raw incoming message.
+ * @param {object} config The environment configuration object.
+ * @returns {Object} Normalized payload.
+ * @throws {Error} If message is invalid or operation type is unsupported.
+ */
+export function normalizeMessageByOperationType(message, config) {
+    if (!message || typeof message !== 'object') {
+        throw new Error('Invalid message for normalization.');
+    }
+
+    const { type } = message;
+    if (!Number.isInteger(type) || type <= 0) {
+        throw new Error('Message type is missing or invalid.');
+    }
+
+    if (isRoleAccess(type)) {
+        return normalizeRoleAccessOperation(message, config);
+    }
+
+    if (isTransaction(type)) {
+        return normalizeTransactionOperation(message, config);
+    }
+
+    if (isBootstrapDeployment(type)) {
+        return normalizeBootstrapDeploymentOperation(message, config);
+    }
+
+    if (isTransfer(type)) {
+        return normalizeTransferOperation(message, config);
+    }
+
+    throw new Error(`Unsupported operation type for normalization: ${type}`);
+}