In questo listato var CONFIG = {
    ORDER_SIDE: 'BID',
    SIZE: 1,
    MAX_OPERATIONS: 8,
    LEVELS: { BID: 6, ASK: 6 },
    SECONDS: 5,
    TICK: 1,
    MONITORING_MODE: 'MONITORA_yourlevel'
};

var separator = "---------------------------------------------------\r\n";
var lastBidPrice, lastBidQuantity, lastAskPrice, lastAskQuantity;

var BookStateManager = (function() {
    var cachedBookState = null;

    return {
        getBookState: function(book) {
            var newState = this.createBookState(book);
            if (this.hasBookStateChanged(newState)) {
                cachedBookState = newState;
                StateManager.updateLastValues(newState);
            }
            return cachedBookState;
        },

        hasBookStateChanged: function(newState) {
            if (!cachedBookState) return true;
            var sides = BookUtils.SIDES;
            for (var sideKey in sides) {
                if (sides.hasOwnProperty(sideKey)) {
                    if (this.isSideChanged(sides[sideKey], newState)) {
                        return true;
                    }
                }
            }
            return false;
        },

        isSideChanged: function(side, newState) {
            var maxLevel = CONFIG.LEVELS[side];
            var cachedPrices = cachedBookState.book[side].Prices;
            var cachedQuantities = cachedBookState.book[side].Quantities;
            var newPrices = newState.book[side].Prices;
            var newQuantities = newState.book[side].Quantities;

            for (var level = 0; level <= maxLevel; level++) {
                if (cachedPrices[level] !== newPrices[level] ||
                    cachedQuantities[level] !== newQuantities[level]) {
                    return true;
                }
            }
            return false;
        },

        createBookState: function(book) {
            var sides = [BookUtils.SIDES.BID, BookUtils.SIDES.ASK];
            var types = ['Price', 'Quantity'];
            var state = { book: book };

            for (var i = 0; i < sides.length; i++) {
                var side = sides[i];
                for (var j = 0; j < types.length; j++) {
                    var type = types[j];
                    var key = side.toLowerCase() + type;
                    state[key] = BookUtils.getData(book, side, CONFIG.LEVELS[side], type);
                }
            }
            return state;
        }
    };
})();

var BookUtils = (function(BookStateManager) {
    return {
        KEYS: ['bidPrice', 'bidQuantity', 'askPrice', 'askQuantity'],
        SIDES: { BID: 'BID', ASK: 'ASK' },
        TYPES: { PRICE: 'Price', QUANTITY: 'Quantity' },

        getData: function(book, side, level, type) {
            return book && book[side] && book[side][type + 's'] ? book[side][type + 's'][level] : undefined;
        },

        hasBookStateChanged: function(newState) {
            return BookStateManager.hasBookStateChanged(newState);
        },

        isSideChanged: function(side, newState) {
            return BookStateManager.isSideChanged(side, newState);
        },

        createBookState: function(book) {
            return BookStateManager.createBookState(book);
        },

        getBookState: function(book) {
            return BookStateManager.getBookState(book);
        }
    };
})(BookStateManager);

var OrderUtils = {
    execOrder: function(side, stock, price, size) {
        return (side === 'BID') ? OrderManager.Buy(stock, price, size) : OrderManager.Sell(stock, price, size);
    },
    updateOrderContext: function(order, side, price) {
        UserContext.order.current = order;
        UserContext.prices[side].oldLevel = price;
        return order;
    },
    processOrModOrder: function(side, stock, price) {
        var currentOrder = UserContext.order.current;
        return currentOrder 
            ? (currentOrder.Price === price ? currentOrder : this.updateOrderContext(OrderManager.Modify(currentOrder.OrderCode, price), side, price))
            : this.updateOrderContext(this.execOrder(side, stock, price, CONFIG.SIZE), side, price);
    },
    deleteOrder: function(orderCode) {
        return OrderManager.Delete(orderCode);
    }
};

var logger = {
    messages: {
        'Initialization Complete': "Inizializzazione completata:\nBid Price 0: {bidPrice}\nAsk Price 0: {askPrice}\n",
        'Order Action': 'Ordine {action}: {orderCode}\n',
        'Order Deleted': 'Ordine cancellato: {orderCode}\n',
        'LevelChange': "Livello da {lastLevel} all'attuale livello {priceLevel}\n",
        'PriceChange': "Prezzo da {previousPrice} all'attuale prezzo {currentPrice}\nOra: {currentTime}\r\n" + separator,
        'message': "{message}\r\n" + separator
    },
    formatMessage: function(template, data) {
        return template.replace(/{(\w+)}/g, function(match, key) {
            return typeof data[key] !== 'undefined' ? data[key] : match;
        });
    },
    formatState: function(bookState) {
        var book = UserContext.book;
        return separator +
            "Bid Price \tBid Quant.\tAsk Price \tAsk Quant.\r\n" +
            separator +
            book.BID.Prices[0] + "\t\t" + book.BID.Quantities[0] +
            "\t\t" + book.ASK.Prices[0] + "\t\t" + book.ASK.Quantities[0] + "\r\n" +
            separator +
            "Numero Operazione: " + UserContext.status.numOperazione + "\r\n" +
            separator;
    },
    log: function(type, data, includeFormattedState) {
        includeFormattedState = includeFormattedState !== false; 
var template = this.messages[type];
if (!template) return;
var message = separator + this.formatMessage(template, data || {});
if (includeFormattedState && (type === 'Initialization Complete' || type === 'LevelChange')) {
    message += this.formatState(BookUtils.getBookState(UserContext.book));
}
Log(message);
    }
};

var Helper = {
    priceDirection: function(targetPrice, oldPrice) {
        return logger.priceDirection(targetPrice, oldPrice);
    }
};

function mapBookData(originalBook) {
    var levels = CONFIG.LEVELS;
    var BID = originalBook.Bid;
    var ASK = originalBook.Ask;

    function mapSide(sideData, maxLevel) {
        if (!sideData || typeof sideData.Price !== 'function') {
            return { Prices: [], Quantities: [] };
        }
        var Prices = [], Quantities = [];
        for (var level = 0; level <= maxLevel; level++) {
            Prices[level] = sideData.Price(level);
            Quantities[level] = sideData.Quantity(level);
        }
        return { Prices: Prices, Quantities: Quantities };
    }

    return {
        BID: mapSide(BID, levels.BID),
        ASK: mapSide(ASK, levels.ASK)
    };
}

function calculateTick(bidPrices, askPrices) {
    var MINIMUM_TICK = 0.005;
    var DECIMAL_PLACES = 3;
    
    if (!bidPrices || !askPrices || !bidPrices.length || !askPrices.length) {
        logger.log('message', { message: 'Tick calcolato: 0' });
        return 0;
    }

    var minDifference = Infinity;
    var len = Math.min(bidPrices.length, askPrices.length);

    for (var i = 0; i < len - 1; i++) {
        minDifference = Math.min(
            minDifference,
            Math.abs(bidPrices[i] - bidPrices[i + 1]),
            Math.abs(askPrices[i] - askPrices[i + 1])
        );
    }

    if (minDifference === Infinity || minDifference === 0) {
        logger.log('message', { message: 'Tick calcolato: 0' });
        return 0;
    }

     var tick = parseFloat(
        (Math.floor(minDifference / MINIMUM_TICK) * MINIMUM_TICK)
        .toFixed(DECIMAL_PLACES)
    );
    logger.log('message', { message: 'Tick calcolato: ' + tick });
     return tick;
}

function addLevels(logParts, side, book) {
for (var level = 0, len = CONFIG.LEVELS[side] + 1; level < len; level++) {
    logParts.push("Level " + level + ": Price = " + book[side].Prices[level] + ", Quantity = " + book[side].Quantities[level] + "\n");
  }
}

function collectBookLogParts(book) {
    var logParts = [separator, "BID:\n"];
    addLevels(logParts, 'BID', book);
    logParts.push(separator, "ASK:\n");
    addLevels(logParts, 'ASK', book);
    var tick = calculateTick(book.BID.Prices, book.ASK.Prices);
    logParts.push(separator);
    logParts.push("Tick: " + tick + "\n");
    logParts.push(separator);
    return logParts;
}

function logFullBook() {
    var book = UserContext.book;
    var logParts = collectBookLogParts(book);
    logger.log('message', { message: logParts.join('') }, false); // Utilizza logger invece di Log
}

var StateManager = {
    updateLastValues: function(state) {
        lastBidPrice = state.bidPrice;
        lastBidQuantity = state.bidQuantity;
        lastAskPrice = state.askPrice;
        lastAskQuantity = state.askQuantity;
    }
};

function getTargetPriceLevel(side) {
    return (CONFIG.MONITORING_MODE === 'MONITORA_1Level' ? 0 : CONFIG.LEVELS[side] - 1);
}

function initializePrices(prices, levels) {
    return {
        BID: { current: prices.BID[0], oldLevel: prices.BID[levels.BID] },
        ASK: { current: prices.ASK[0], oldLevel: prices.ASK[levels.ASK] }
    };
}

function setupTradeContext() {
    var originalBook = mapBookData(Book(ps));
    var isMonitorOneLevel = (CONFIG.MONITORING_MODE === 'MONITORA_1Level');
    var sideLevels = {
        BID: isMonitorOneLevel ? 0 : CONFIG.LEVELS.BID - 1,
        ASK: isMonitorOneLevel ? 0 : CONFIG.LEVELS.ASK - 1
    };
    var pricesBID = originalBook.BID.Prices;
    var pricesASK = originalBook.ASK.Prices;

    UserContext = {
        book: originalBook,
        order: { current: null },
        status: { run: true, secondCount: 0, numOperazione: 0 },
        prices: initializePrices({ BID: pricesBID, ASK: pricesASK }, sideLevels),
        targetPriceLevels: sideLevels
    };
    
    var execOrder = OrderUtils.execOrder;
    var updateOrderContext = OrderUtils.updateOrderContext;
    var getData = BookUtils.getData;
    var initialPrice = getData(originalBook, CONFIG.ORDER_SIDE, sideLevels[CONFIG.ORDER_SIDE], 'Price');
    var initialOrder = updateOrderContext(
        execOrder(CONFIG.ORDER_SIDE, stock, initialPrice, CONFIG.SIZE),
        CONFIG.ORDER_SIDE,
        initialPrice
    );

    logger.log('Initialization Complete', { bidPrice: UserContext.prices.BID.current, askPrice: UserContext.prices.ASK.current }, true);
    logger.log('Order Action', { action: 'inserito', orderCode: initialOrder.OrderCode }, false);
    logFullBook();

    manageCycle();  
}

function manageCycle() {
    var status = UserContext.status;
    if (checkOps() || status.secondCount < CONFIG.SECONDS) return;
    var bookData = Book(ps);
    UserContext.book = mapBookData(bookData);
    priceUpdate(CONFIG.ORDER_SIDE, UserContext.book, status);
    status.secondCount = 0;
}

function priceUpdate(side, book, status) {
    var prices = UserContext.prices[side];
    var targetPriceLevel = UserContext.targetPriceLevels[side];
    var targetPrice = book[side].Prices[targetPriceLevel];
    var oldPrice = prices.oldLevel;
    var maxLevel = CONFIG.LEVELS[side];

	if (targetPrice === oldPrice) return;
    var newOrder = OrderUtils.processOrModOrder(side, ps, targetPrice);

	if (!newOrder) return;
    prices.current = targetPrice;
    var direction = logger.priceDirection(targetPrice, oldPrice);
    var levelDifference = maxLevel + direction;
    logger.log('LevelChange', { lastLevel: levelDifference, priceLevel: targetPriceLevel }, true);
    status.secondCount = 0;
    status.numOperazione++;
}

function checkOps() {
    var status = UserContext.status;
    if (status.numOperazione < CONFIG.MAX_OPERATIONS) {
        return false;
    }
    var currentOrder = UserContext.order.current;
    if (currentOrder) {
        OrderUtils.deleteOrder(currentOrder.OrderCode);
        logger.log('Order Deleted', { orderCode: currentOrder.OrderCode });
        status.run = false;
        return true;
    }
    return false;
}

var eventHandlers = {};
eventHandlers[TSEventType.Price] = function(ctx) {
    var price = Val(ps, "LAST");
    if (ctx.lastPrice === price) return;
    logger.log('PriceChange', {
        previousPrice: ctx.lastPrice,
        currentPrice: price,
        currentTime: Now().ToString("HH:mm:ss.ff")
    });
    ctx.lastPrice = price;
};
eventHandlers[TSEventType.Time] = function(ctx) {
    ctx.status.secondCount++;
    manageCycle();
};

function handleEvent(context, type) {
    eventHandlers[type] && eventHandlers[type](context);
}

function marketEvent(Book, mapBookData, handleEvent, UserContext, SystemContext) {
    return function() {
        if (!UserContext.status.run) return;
        var originalBook = Book(ps);
        var mappedBook = mapBookData(originalBook);
        UserContext.book = mappedBook;
        handleEvent(UserContext, SystemContext.EventType);
    };
}

if (SystemContext.IsFirst) {
    setupTradeContext();
}

var marketEventInstance = marketEvent(Book, mapBookData, handleEvent, UserContext, SystemContext);
marketEventInstance();   L'istruzione     priceDirection: function(targetPrice, oldPrice) {
        return logger.priceDirection(targetPrice, oldPrice);
    } e' doppia e ripetuta. Puoi riscrivere il codice intero togliendola ?