@toon-protocol/connector 2.6.1 → 3.3.0

package/dist/core/packet-handler.js

@@ -1,655 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PacketHandler = void 0;
-const tslib_1 = require("tslib");
-const shared_1 = require("@toon-protocol/shared");
-const logger_1 = require("../utils/logger");
-const btp_client_1 = require("../btp/btp-client");
-const types_1 = require("../settlement/types");
-const crypto = tslib_1.__importStar(require("crypto"));
-const local_delivery_client_1 = require("./local-delivery-client");
-const sha2_1 = require("@noble/hashes/sha2");
-const nip59_claim_wrapper_1 = require("../settlement/privacy/nip59-claim-wrapper");
-const EXPIRY_SAFETY_MARGIN_MS = 1000;
-class PacketHandler {
-    routingTable;
-    btpClientManager;
-    btpServer;
-    logger;
-    nodeId;
-    perPacketClaimService = null;
-    defaultTokenId = 'M2M';
-    accountManager;
-    settlementConfig;
-    localDeliveryClient = null;
-    localDeliveryHandler = null;
-    _nip59Wrapper = null;
-    _nodePrivateKey = null;
-    ilpMetrics = null;
-    constructor(routingTable, btpClientManager, nodeId, logger, btpServer = null, accountManager = null, settlementConfig = null) {
-        this.routingTable = routingTable;
-        this.btpClientManager = btpClientManager;
-        this.btpServer = btpServer;
-        this.nodeId = nodeId;
-        this.logger = logger;
-        this.accountManager = accountManager;
-        this.settlementConfig = settlementConfig;
-        if (this.isSettlementEnabled()) {
-            this.logger.info({
-                connectorFeePercentage: settlementConfig?.connectorFeePercentage,
-                tigerBeetleClusterId: settlementConfig?.tigerBeetleClusterId,
-            }, 'Settlement recording enabled');
-        }
-        else {
-            this.logger.info('Settlement recording disabled');
-        }
-    }
-    setBTPServer(btpServer) {
-        this.btpServer = btpServer;
-    }
-    setSettlement(accountManager, settlementConfig, defaultTokenId) {
-        this.accountManager = accountManager;
-        this.settlementConfig = settlementConfig;
-        if (defaultTokenId) {
-            this.defaultTokenId = defaultTokenId;
-        }
-        if (this.isSettlementEnabled()) {
-            this.logger.info({
-                event: 'settlement_enabled',
-                connectorFeePercentage: settlementConfig.connectorFeePercentage,
-                tigerBeetleClusterId: settlementConfig.tigerBeetleClusterId,
-            }, 'Settlement recording enabled via late initialization');
-        }
-    }
-    setPerPacketClaimService(service) {
-        this.perPacketClaimService = service;
-        this.logger.info('Per-packet claim service enabled');
-    }
-    setLocalDelivery(config) {
-        if (config.enabled) {
-            this.localDeliveryClient = new local_delivery_client_1.LocalDeliveryClient(config, this.logger);
-            this.logger.info({
-                event: 'local_delivery_enabled',
-                handlerUrl: config.handlerUrl,
-                timeout: config.timeout,
-            }, 'Local delivery forwarding enabled');
-        }
-        else {
-            this.localDeliveryClient = null;
-            this.logger.info('Local delivery forwarding disabled (using auto-fulfill stub)');
-        }
-    }
-    setLocalDeliveryHandler(handler) {
-        this.localDeliveryHandler = handler;
-        this.logger.info({ event: 'local_delivery_handler_set', hasHandler: handler !== null }, 'Local delivery function handler updated');
-    }
-    setNip59Wrapper(wrapper, nodePrivateKey) {
-        this._nip59Wrapper = wrapper;
-        this._nodePrivateKey = nodePrivateKey;
-    }
-    setIlpMetrics(metrics) {
-        this.ilpMetrics = metrics;
-        this.logger.info({ event: 'ilp_metrics_enabled' }, 'ILP observability metrics enabled');
-    }
-    _derivePreimageFromProtocolData(protocolData) {
-        if (!this._nip59Wrapper?.isEnabled() || !this._nodePrivateKey || !protocolData) {
-            return undefined;
-        }
-        const wrappedEntry = protocolData.find((p) => p.protocolName === 'claim-wrapped');
-        if (!wrappedEntry) {
-            return undefined;
-        }
-        try {
-            const wrappedClaim = (0, nip59_claim_wrapper_1.deserializeWrappedClaim)(wrappedEntry.data);
-            const result = this._nip59Wrapper.unwrapClaimWithPreimage(wrappedClaim, this._nodePrivateKey);
-            return result.fulfillmentPreimage;
-        }
-        catch (err) {
-            this.logger.warn({
-                event: 'preimage_derivation_failed',
-                error: err instanceof Error ? err.message : String(err),
-            }, 'Failed to derive preimage from wrapped claim');
-            return undefined;
-        }
-    }
-    isLocalDeliveryEnabled() {
-        return this.localDeliveryClient !== null && this.localDeliveryClient.isEnabled();
-    }
-    isSettlementEnabled() {
-        return this.accountManager !== null && this.settlementConfig?.enableSettlement === true;
-    }
-    generateTransferId(packetData, direction) {
-        const dataHash = crypto.createHash('sha256').update(packetData).digest();
-        const directionByte = direction === 'incoming' ? 0x01 : 0x02;
-        const nodeIdHash = Buffer.alloc(8);
-        let hash = 0;
-        for (let i = 0; i < this.nodeId.length; i++) {
-            hash = ((hash << 5) - hash + this.nodeId.charCodeAt(i)) | 0;
-        }
-        nodeIdHash.writeBigUInt64BE((BigInt(hash >>> 0) << 32n) | BigInt(hash >>> 0), 0);
-        const high = dataHash.readBigUInt64BE(0);
-        const low = dataHash.readBigUInt64BE(8);
-        const nodeIdValue = nodeIdHash.readBigUInt64BE(0);
-        const transferId = ((high ^ nodeIdValue) << 64n) | low;
-        return transferId ^ BigInt(directionByte);
-    }
-    calculateConnectorFee(amount, feePercentage) {
-        if (amount < 0n) {
-            throw new Error(`Invalid amount: ${amount} (must be >= 0)`);
-        }
-        if (feePercentage < 0) {
-            throw new Error(`Invalid fee percentage: ${feePercentage} (must be >= 0)`);
-        }
-        const basisPoints = Math.floor(feePercentage * 100);
-        const fee = (amount * BigInt(basisPoints)) / 10000n;
-        return fee;
-    }
-    async recordPacketTransfers(packet, fromPeerId, toPeerId, forwardedAmount, connectorFee, correlationId) {
-        if (!this.isSettlementEnabled()) {
-            return;
-        }
-        const packetId = crypto.createHash('sha256').update(packet.data).digest('hex').slice(0, 16);
-        this.logger.debug({
-            correlationId,
-            packetId,
-            fromPeerId,
-            toPeerId,
-            originalAmount: packet.amount.toString(),
-            forwardedAmount: forwardedAmount.toString(),
-            connectorFee: connectorFee.toString(),
-        }, 'Processing settlement for packet');
-        try {
-            const incomingTransferId = this.generateTransferId(packet.data, 'incoming');
-            const outgoingTransferId = this.generateTransferId(packet.data, 'outgoing');
-            await this.accountManager.recordPacketTransfers(fromPeerId, toPeerId, this.defaultTokenId, packet.amount, forwardedAmount, incomingTransferId, outgoingTransferId, types_1.AccountLedgerCodes.DEFAULT_LEDGER, 1);
-            this.logger.info({
-                correlationId,
-                packetId,
-                fromPeerId,
-                toPeerId,
-                originalAmount: packet.amount.toString(),
-                forwardedAmount: forwardedAmount.toString(),
-                connectorFee: connectorFee.toString(),
-            }, 'Settlement transfers recorded: incoming={originalAmount} from {fromPeerId}, outgoing={forwardedAmount} to {toPeerId}, fee={connectorFee}');
-        }
-        catch (error) {
-            this.logger.error({
-                correlationId,
-                error: error instanceof Error ? error.message : String(error),
-                packetId,
-                fromPeerId,
-                toPeerId,
-            }, 'Settlement recording failed: {error}, rejecting packet with T00_INTERNAL_ERROR');
-            throw error;
-        }
-    }
-    validatePacket(packet) {
-        if (packet.amount === undefined || !packet.destination || !packet.expiresAt || !packet.data) {
-            this.logger.error({
-                packetType: packet.type,
-                hasAmount: packet.amount !== undefined,
-                hasDestination: !!packet.destination,
-                hasExpiresAt: !!packet.expiresAt,
-                hasData: !!packet.data,
-                errorCode: shared_1.ILPErrorCode.F01_INVALID_PACKET,
-            }, 'Packet validation failed: missing required fields');
-            return {
-                isValid: false,
-                errorCode: shared_1.ILPErrorCode.F01_INVALID_PACKET,
-                errorMessage: 'Missing required packet fields',
-            };
-        }
-        if (!(0, shared_1.isValidILPAddress)(packet.destination)) {
-            this.logger.error({
-                destination: packet.destination,
-                errorCode: shared_1.ILPErrorCode.F01_INVALID_PACKET,
-            }, 'Packet validation failed: invalid ILP address format');
-            return {
-                isValid: false,
-                errorCode: shared_1.ILPErrorCode.F01_INVALID_PACKET,
-                errorMessage: `Invalid ILP address format: ${packet.destination}`,
-            };
-        }
-        const currentTime = new Date();
-        if (packet.expiresAt <= currentTime) {
-            this.logger.error({
-                expiresAt: packet.expiresAt.toISOString(),
-                currentTime: currentTime.toISOString(),
-                errorCode: shared_1.ILPErrorCode.R00_TRANSFER_TIMED_OUT,
-            }, 'Packet validation failed: packet has expired');
-            return {
-                isValid: false,
-                errorCode: shared_1.ILPErrorCode.R00_TRANSFER_TIMED_OUT,
-                errorMessage: 'Packet has expired',
-            };
-        }
-        return { isValid: true };
-    }
-    decrementExpiry(expiresAt, safetyMargin) {
-        const newExpiry = new Date(expiresAt.getTime() - safetyMargin);
-        const currentTime = new Date();
-        if (newExpiry <= currentTime) {
-            this.logger.debug({
-                originalExpiry: expiresAt.toISOString(),
-                decrementedExpiry: newExpiry.toISOString(),
-                currentTime: currentTime.toISOString(),
-                safetyMargin,
-            }, 'Expiry decrement would create past timestamp');
-            return null;
-        }
-        this.logger.debug({
-            originalExpiry: expiresAt.toISOString(),
-            newExpiry: newExpiry.toISOString(),
-            safetyMargin,
-        }, 'Decremented packet expiry');
-        return newExpiry;
-    }
-    generateReject(code, message, triggeredBy) {
-        this.logger.info({
-            errorCode: code,
-            message,
-            triggeredBy,
-        }, 'Generated reject packet');
-        return {
-            type: shared_1.PacketType.REJECT,
-            code,
-            triggeredBy,
-            message,
-            data: Buffer.alloc(0),
-        };
-    }
-    convertLocalDeliveryResponse(result) {
-        if (result.fulfill) {
-            return {
-                type: shared_1.PacketType.FULFILL,
-                data: result.fulfill.data ? Buffer.from(result.fulfill.data, 'base64') : Buffer.alloc(0),
-            };
-        }
-        else if (result.reject) {
-            return {
-                type: shared_1.PacketType.REJECT,
-                code: result.reject.code || shared_1.ILPErrorCode.F99_APPLICATION_ERROR,
-                triggeredBy: this.nodeId,
-                message: result.reject.message || 'Rejected by agent',
-                data: result.reject.data ? Buffer.from(result.reject.data, 'base64') : Buffer.alloc(0),
-            };
-        }
-        else {
-            return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, 'Invalid response from local delivery handler', this.nodeId);
-        }
-    }
-    async forwardToNextHop(packet, nextHop, correlationId, protocolData) {
-        this.logger.info({
-            correlationId,
-            event: 'btp_forward',
-            destination: packet.destination,
-            amount: packet.amount.toString(),
-            peerId: nextHop,
-        }, 'Forwarding packet to peer via BTP');
-        try {
-            let response;
-            const hasOutbound = this.btpClientManager.isConnected(nextHop);
-            const hasInbound = this.btpServer?.hasPeer(nextHop) ?? false;
-            if (hasOutbound) {
-                response = await this.btpClientManager.sendToPeer(nextHop, packet, protocolData);
-                this.logger.debug({ correlationId, peerId: nextHop }, 'Forwarded via outbound peer connection');
-            }
-            else if (hasInbound) {
-                this.logger.debug({ correlationId, peerId: nextHop }, 'No outbound connection, using incoming peer connection');
-                response = await this.btpServer.sendPacketToPeer(nextHop, packet, protocolData);
-                this.logger.debug({ correlationId, peerId: nextHop }, 'Forwarded via incoming peer connection');
-            }
-            else {
-                throw new btp_client_1.BTPConnectionError(`No active BTP connection to peer ${nextHop}`);
-            }
-            this.logger.info({
-                correlationId,
-                event: 'btp_forward_success',
-                peerId: nextHop,
-                responseType: response.type,
-            }, 'Received response from peer via BTP');
-            return response;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (error instanceof btp_client_1.BTPConnectionError) {
-                this.logger.error({
-                    correlationId,
-                    event: 'btp_connection_error',
-                    peerId: nextHop,
-                    error: errorMessage,
-                }, 'BTP connection failed');
-                return this.generateReject(shared_1.ILPErrorCode.T01_PEER_UNREACHABLE, `BTP connection to ${nextHop} failed: ${errorMessage}`, this.nodeId);
-            }
-            if (error instanceof btp_client_1.BTPAuthenticationError) {
-                this.logger.error({
-                    correlationId,
-                    event: 'btp_auth_error',
-                    peerId: nextHop,
-                    error: errorMessage,
-                }, 'BTP authentication failed');
-                return this.generateReject(shared_1.ILPErrorCode.T01_PEER_UNREACHABLE, `BTP authentication to ${nextHop} failed: ${errorMessage}`, this.nodeId);
-            }
-            if (errorMessage.includes('timeout')) {
-                this.logger.error({
-                    correlationId,
-                    event: 'btp_timeout',
-                    peerId: nextHop,
-                    error: errorMessage,
-                }, 'BTP packet send timeout');
-                return this.generateReject(shared_1.ILPErrorCode.R00_TRANSFER_TIMED_OUT, `BTP timeout to ${nextHop}: ${errorMessage}`, this.nodeId);
-            }
-            this.logger.error({
-                correlationId,
-                event: 'btp_forward_error',
-                peerId: nextHop,
-                error: errorMessage,
-            }, 'Unexpected error forwarding packet via BTP');
-            throw error;
-        }
-    }
-    async handlePreparePacket(packet, fromPeerId, incomingProtocolData) {
-        const correlationId = (0, logger_1.generateCorrelationId)();
-        const sourcePeerId = fromPeerId || 'unknown';
-        this.logger.info({
-            correlationId,
-            packetType: 'PREPARE',
-            destination: packet.destination,
-            amount: packet.amount.toString(),
-            fromPeerId: sourcePeerId,
-            timestamp: Date.now(),
-        }, 'Packet received');
-        this.ilpMetrics?.recordInbound(sourcePeerId, packet.data.byteLength);
-        const validation = this.validatePacket(packet);
-        if (!validation.isValid) {
-            this.logger.error({
-                correlationId,
-                packetType: 'REJECT',
-                destination: packet.destination,
-                errorCode: validation.errorCode,
-                reason: validation.errorMessage,
-                timestamp: Date.now(),
-            }, 'Packet rejected');
-            this.ilpMetrics?.recordPreRoutingReject('validation_failed');
-            return this.generateReject(validation.errorCode, validation.errorMessage, this.nodeId);
-        }
-        const nextHop = this.routingTable.getNextHop(packet.destination);
-        if (nextHop === null) {
-            this.logger.info({
-                correlationId,
-                destination: packet.destination,
-                selectedPeer: null,
-                reason: 'no route found',
-            }, 'Routing decision');
-            this.logger.error({
-                correlationId,
-                packetType: 'REJECT',
-                destination: packet.destination,
-                errorCode: shared_1.ILPErrorCode.F02_UNREACHABLE,
-                reason: 'no route found',
-                timestamp: Date.now(),
-            }, 'Packet rejected');
-            this.ilpMetrics?.recordPreRoutingReject('no_route');
-            return this.generateReject(shared_1.ILPErrorCode.F02_UNREACHABLE, `No route to destination: ${packet.destination}`, this.nodeId);
-        }
-        this.logger.info({
-            correlationId,
-            destination: packet.destination,
-            selectedPeer: nextHop,
-            reason: 'longest-prefix match',
-        }, 'Routing decision');
-        if (nextHop === this.nodeId || nextHop === 'local') {
-            this.logger.info({
-                correlationId,
-                destination: packet.destination,
-                reason: 'local delivery',
-            }, 'Delivering packet locally');
-            const preimage = this._derivePreimageFromProtocolData(incomingProtocolData);
-            if (this.localDeliveryHandler) {
-                const request = {
-                    destination: packet.destination,
-                    amount: packet.amount.toString(),
-                    expiresAt: packet.expiresAt.toISOString(),
-                    data: packet.data.toString('base64'),
-                    sourcePeer: sourcePeerId,
-                };
-                try {
-                    const result = await this.localDeliveryHandler(request, sourcePeerId);
-                    const response = this.convertLocalDeliveryResponse(result);
-                    if (response.type === shared_1.PacketType.FULFILL && preimage) {
-                        response.fulfillment = preimage;
-                    }
-                    return response;
-                }
-                catch (error) {
-                    return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, `Local delivery handler error: ${error instanceof Error ? error.message : String(error)}`, this.nodeId);
-                }
-            }
-            if (this.isLocalDeliveryEnabled() && this.localDeliveryClient) {
-                this.logger.debug({ correlationId, destination: packet.destination }, 'Forwarding to BLS for local delivery');
-                const response = await this.localDeliveryClient.deliver(packet, sourcePeerId);
-                if (response.type === shared_1.PacketType.FULFILL && preimage) {
-                    response.fulfillment = preimage;
-                }
-                this.logger.info({
-                    correlationId,
-                    event: 'packet_response',
-                    packetType: response.type,
-                    destination: packet.destination,
-                    timestamp: Date.now(),
-                }, response.type === shared_1.PacketType.FULFILL
-                    ? 'Packet fulfilled by BLS'
-                    : 'Packet rejected by BLS');
-                return response;
-            }
-            const fulfillPacket = {
-                type: shared_1.PacketType.FULFILL,
-                fulfillment: preimage,
-                data: Buffer.from('Local delivery - auto-fulfill stub'),
-            };
-            this.logger.info({
-                correlationId,
-                event: 'packet_response',
-                packetType: shared_1.PacketType.FULFILL,
-                destination: packet.destination,
-                timestamp: Date.now(),
-            }, 'Returning local fulfillment (auto-fulfill stub)');
-            return fulfillPacket;
-        }
-        const newExpiry = this.decrementExpiry(packet.expiresAt, EXPIRY_SAFETY_MARGIN_MS);
-        if (newExpiry === null) {
-            this.logger.error({
-                correlationId,
-                packetType: 'REJECT',
-                destination: packet.destination,
-                errorCode: shared_1.ILPErrorCode.R00_TRANSFER_TIMED_OUT,
-                expiresAt: packet.expiresAt.toISOString(),
-                reason: 'Insufficient time remaining for forwarding',
-                timestamp: Date.now(),
-            }, 'Packet rejected');
-            this.ilpMetrics?.recordPreRoutingReject('expiry_too_short');
-            return this.generateReject(shared_1.ILPErrorCode.R00_TRANSFER_TIMED_OUT, 'Insufficient time remaining for forwarding', this.nodeId);
-        }
-        let forwardingPacket;
-        const isLocalDelivery = nextHop === 'local';
-        if (this.isSettlementEnabled() && !isLocalDelivery) {
-            const connectorFee = this.calculateConnectorFee(packet.amount, this.settlementConfig?.connectorFeePercentage ?? 0.1);
-            const forwardedAmount = packet.amount - connectorFee;
-            this.logger.debug({
-                correlationId,
-                originalAmount: packet.amount.toString(),
-                connectorFee: connectorFee.toString(),
-                forwardedAmount: forwardedAmount.toString(),
-                feePercentage: this.settlementConfig?.connectorFeePercentage,
-            }, 'Calculated connector fee');
-            const fromPeerId = 'unknown';
-            const tokenId = this.defaultTokenId;
-            const creditLimitViolation = await this.accountManager.checkCreditLimit(fromPeerId, tokenId, packet.amount);
-            if (creditLimitViolation) {
-                this.logger.warn({
-                    correlationId,
-                    packetType: 'REJECT',
-                    destination: packet.destination,
-                    errorCode: shared_1.ILPErrorCode.T04_INSUFFICIENT_LIQUIDITY,
-                    fromPeerId: creditLimitViolation.peerId,
-                    currentBalance: creditLimitViolation.currentBalance.toString(),
-                    requestedAmount: creditLimitViolation.requestedAmount.toString(),
-                    creditLimit: creditLimitViolation.creditLimit.toString(),
-                    wouldExceedBy: creditLimitViolation.wouldExceedBy.toString(),
-                    reason: 'Credit limit exceeded',
-                    timestamp: Date.now(),
-                }, 'Packet rejected: credit limit exceeded');
-                this.ilpMetrics?.recordPreRoutingReject('credit_limit_exceeded');
-                return this.generateReject(shared_1.ILPErrorCode.T04_INSUFFICIENT_LIQUIDITY, `Credit limit exceeded: peer ${fromPeerId} would owe ${creditLimitViolation.wouldExceedBy} units over limit of ${creditLimitViolation.creditLimit}`, this.nodeId);
-            }
-            if (sourcePeerId !== 'unknown' && packet.amount > 0n && forwardedAmount > 0n) {
-                try {
-                    await this.recordPacketTransfers(packet, sourcePeerId, nextHop, forwardedAmount, connectorFee, correlationId);
-                }
-                catch (error) {
-                    this.logger.error({
-                        correlationId,
-                        packetType: 'REJECT',
-                        destination: packet.destination,
-                        errorCode: shared_1.ILPErrorCode.T00_INTERNAL_ERROR,
-                        error: error instanceof Error ? error.message : String(error),
-                        reason: 'Settlement recording failed',
-                        timestamp: Date.now(),
-                    }, 'Packet rejected due to settlement failure');
-                    this.ilpMetrics?.recordPreRoutingReject('settlement_recording_failed');
-                    return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, 'Settlement recording failed', this.nodeId);
-                }
-            }
-            else {
-                this.logger.debug({
-                    correlationId,
-                    sourcePeerId,
-                    reason: 'Skipping settlement for unknown peer',
-                }, 'Settlement skipped for unregistered peer');
-            }
-            forwardingPacket = {
-                ...packet,
-                expiresAt: newExpiry,
-                amount: forwardedAmount,
-            };
-        }
-        else {
-            forwardingPacket = {
-                ...packet,
-                expiresAt: newExpiry,
-            };
-        }
-        const perHopEnabled = this.localDeliveryClient?.isPerHopNotificationEnabled() ?? false;
-        if (perHopEnabled) {
-            if (this.localDeliveryHandler) {
-                const transitRequest = {
-                    destination: packet.destination,
-                    amount: packet.amount.toString(),
-                    expiresAt: packet.expiresAt.toISOString(),
-                    data: packet.data.toString('base64'),
-                    sourcePeer: sourcePeerId,
-                    isTransit: true,
-                };
-                this.localDeliveryHandler(transitRequest, sourcePeerId).catch((err) => {
-                    this.logger.debug({
-                        error: err instanceof Error ? err.message : String(err),
-                        destination: packet.destination,
-                    }, 'Per-hop notification failed (fire-and-forget, in-process)');
-                });
-            }
-            else if (this.isLocalDeliveryEnabled() && this.localDeliveryClient) {
-                this.localDeliveryClient
-                    .deliver(packet, sourcePeerId, { isTransit: true })
-                    .catch((err) => {
-                    this.logger.debug({
-                        error: err instanceof Error ? err.message : String(err),
-                        destination: packet.destination,
-                    }, 'Per-hop notification failed (fire-and-forget, HTTP)');
-                });
-            }
-        }
-        let claimProtocolData;
-        if (!isLocalDelivery && forwardingPacket.amount > 0n) {
-            if (!this.perPacketClaimService) {
-                this.logger.error({
-                    correlationId,
-                    peerId: nextHop,
-                    errorCode: shared_1.ILPErrorCode.T00_INTERNAL_ERROR,
-                }, 'Per-packet claim service not configured');
-                this.ilpMetrics?.recordPreRoutingReject('claim_generation_failed');
-                return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, 'Per-packet claim service not configured', this.nodeId);
-            }
-            try {
-                const result = await this.perPacketClaimService.generateClaimForPacket(nextHop, this.defaultTokenId, forwardingPacket.amount);
-                if (!result) {
-                    this.logger.error({
-                        correlationId,
-                        peerId: nextHop,
-                        errorCode: shared_1.ILPErrorCode.T00_INTERNAL_ERROR,
-                    }, 'No payment channel available for peer');
-                    this.ilpMetrics?.recordPreRoutingReject('claim_generation_failed');
-                    return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, 'No payment channel available for peer', this.nodeId);
-                }
-                claimProtocolData = [result.protocolData];
-                if (result.executionCondition &&
-                    (!forwardingPacket.executionCondition ||
-                        Buffer.from(forwardingPacket.executionCondition).every((b) => b === 0))) {
-                    forwardingPacket = { ...forwardingPacket, executionCondition: result.executionCondition };
-                }
-            }
-            catch (error) {
-                this.logger.error({
-                    correlationId,
-                    peerId: nextHop,
-                    error: error instanceof Error ? error.message : String(error),
-                    errorCode: shared_1.ILPErrorCode.T00_INTERNAL_ERROR,
-                }, 'Claim generation failed');
-                this.ilpMetrics?.recordPreRoutingReject('claim_generation_failed');
-                return this.generateReject(shared_1.ILPErrorCode.T00_INTERNAL_ERROR, 'Claim generation failed', this.nodeId);
-            }
-        }
-        let response = await this.forwardToNextHop(forwardingPacket, nextHop, correlationId, claimProtocolData);
-        if (response.type === shared_1.PacketType.FULFILL &&
-            forwardingPacket.executionCondition &&
-            !Buffer.from(forwardingPacket.executionCondition).every((b) => b === 0)) {
-            const fulfillmentBytes = response.fulfillment;
-            if (!fulfillmentBytes || Buffer.from(fulfillmentBytes).every((b) => b === 0)) {
-                this.logger.error({
-                    correlationId,
-                    event: 'fulfillment_missing',
-                    peerId: nextHop,
-                }, 'FULFILL missing fulfillment but execution condition is present');
-                response = this.generateReject(shared_1.ILPErrorCode.F99_APPLICATION_ERROR, 'Fulfillment does not match execution condition', this.nodeId);
-            }
-            else {
-                const expectedCondition = (0, sha2_1.sha256)(new Uint8Array(fulfillmentBytes));
-                if (!Buffer.from(expectedCondition).equals(Buffer.from(forwardingPacket.executionCondition))) {
-                    this.logger.error({
-                        correlationId,
-                        event: 'fulfillment_verification_failed',
-                        peerId: nextHop,
-                    }, 'Fulfillment does not match execution condition');
-                    response = this.generateReject(shared_1.ILPErrorCode.F99_APPLICATION_ERROR, 'Fulfillment does not match execution condition', this.nodeId);
-                }
-            }
-        }
-        const outBytes = forwardingPacket.data.byteLength;
-        if (response.type === shared_1.PacketType.FULFILL) {
-            this.ilpMetrics?.recordForwardFulfill(nextHop, outBytes);
-        }
-        else {
-            this.ilpMetrics?.recordForwardReject(nextHop, outBytes);
-        }
-        this.logger.info({
-            correlationId,
-            event: 'packet_response',
-            packetType: response.type,
-            destination: packet.destination,
-            code: response.type === shared_1.PacketType.REJECT ? response.code : undefined,
-            timestamp: Date.now(),
-        }, 'Returning packet response');
-        return response;
-    }
-}
-exports.PacketHandler = PacketHandler;
-//# sourceMappingURL=packet-handler.js.map