@toon-protocol/connector 3.3.1 → 3.3.3

package/dist/core/packet-handler.js

@@ -0,0 +1,655 @@
+"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