@toon-protocol/connector 2.6.1 → 3.3.1

package/dist/settlement/claim-receiver.js

@@ -1,707 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaimReceiver = exports.ERRORS = void 0;
-const events_1 = require("events");
-const btp_types_1 = require("../btp/btp-types");
-const btp_claim_types_1 = require("../btp/btp-claim-types");
-const nip59_claim_wrapper_1 = require("./privacy/nip59-claim-wrapper");
-exports.ERRORS = {
-    MISSING_SELF_DESCRIBING_FIELDS: 'Missing self-describing fields for unknown channel (chainId, tokenNetworkAddress, tokenAddress required)',
-    CHANNEL_NOT_FOUND: 'Channel does not exist on-chain',
-    CHANNEL_NOT_OPENED: 'Channel not in opened state',
-    SIGNER_NOT_PARTICIPANT: 'Signer is not a channel participant',
-    ON_CHAIN_VERIFICATION_FAILED: 'On-chain channel verification failed',
-    INVALID_SIGNATURE: 'Invalid balance proof signature',
-    NO_PROVIDER_REGISTERED: 'No provider registered for blockchain:',
-};
-class ClaimReceiver extends events_1.EventEmitter {
-    db;
-    chainProviderRegistry;
-    logger;
-    channelManager;
-    peerIdToAddressMap;
-    _nip59Wrapper;
-    _nodePrivateKey;
-    constructor(db, chainProviderRegistry, logger, channelManager, peerIdToAddressMap, _nip59Wrapper, _nodePrivateKey) {
-        super();
-        this.db = db;
-        this.chainProviderRegistry = chainProviderRegistry;
-        this.logger = logger;
-        this.channelManager = channelManager;
-        this.peerIdToAddressMap = peerIdToAddressMap;
-        this._nip59Wrapper = _nip59Wrapper;
-        this._nodePrivateKey = _nodePrivateKey;
-    }
-    registerWithBTPServer(btpServer) {
-        btpServer.onMessage(async (peerId, message) => {
-            if (!(0, btp_types_1.isBTPData)(message)) {
-                return;
-            }
-            for (const protocolData of message.data.protocolData) {
-                if (protocolData.protocolName === 'payment-channel-claim') {
-                    await this.handleClaimMessage(peerId, protocolData);
-                }
-                else if (protocolData.protocolName === nip59_claim_wrapper_1.BTP_WRAPPED_CLAIM_PROTOCOL.NAME &&
-                    this._nip59Wrapper &&
-                    this._nodePrivateKey) {
-                    await this.handleWrappedClaimMessage(peerId, protocolData);
-                }
-            }
-        });
-        this.logger.info('ClaimReceiver registered with BTP server');
-    }
-    async handleWrappedClaimMessage(peerId, protocolData) {
-        const childLogger = this.logger.child({ peerId, protocol: 'claim-receiver-nip59' });
-        try {
-            const wrappedClaim = (0, nip59_claim_wrapper_1.deserializeWrappedClaim)(protocolData.data);
-            const claimMessage = this._nip59Wrapper.unwrapClaim(wrappedClaim, this._nodePrivateKey);
-            childLogger.debug({ messageId: claimMessage.messageId }, 'NIP-59 claim unwrapped successfully');
-            const plaintextData = {
-                protocolName: 'payment-channel-claim',
-                contentType: 1,
-                data: Buffer.from(JSON.stringify(claimMessage), 'utf8'),
-            };
-            await this.handleClaimMessage(peerId, plaintextData);
-        }
-        catch (error) {
-            childLogger.warn({ error: error instanceof Error ? error.message : String(error) }, 'Failed to unwrap NIP-59 claim');
-        }
-    }
-    async handleClaimMessage(peerId, protocolData) {
-        const childLogger = this.logger.child({ peerId, protocol: 'claim-receiver' });
-        try {
-            const claimMessage = JSON.parse(protocolData.data.toString('utf8'));
-            (0, btp_claim_types_1.validateClaimMessage)(claimMessage);
-            const messageId = claimMessage.messageId;
-            const blockchain = claimMessage.blockchain;
-            childLogger.info({ messageId, blockchain }, 'Received claim message');
-            const provider = this.resolveProvider(claimMessage);
-            if (!provider) {
-                const errorMsg = `${exports.ERRORS.NO_PROVIDER_REGISTERED} ${blockchain}`;
-                childLogger.warn({ messageId, blockchain }, errorMsg);
-                this._persistReceivedClaim(peerId, claimMessage, false);
-                return;
-            }
-            const verificationResult = await this.verifyClaim(claimMessage, peerId, provider);
-            if (verificationResult.valid) {
-                this._persistReceivedClaim(peerId, claimMessage, true);
-                childLogger.info({ messageId }, 'Claim verified and stored');
-                try {
-                    if ((0, btp_claim_types_1.isEVMClaim)(claimMessage)) {
-                        const event = {
-                            peerId,
-                            channelId: claimMessage.channelId,
-                            cumulativeAmount: BigInt(claimMessage.transferredAmount),
-                        };
-                        this.emit('CLAIM_RECEIVED', event);
-                        childLogger.debug({ channelId: event.channelId, cumulativeAmount: event.cumulativeAmount.toString() }, 'CLAIM_RECEIVED event emitted');
-                    }
-                    else if ((0, btp_claim_types_1.isSolanaClaim)(claimMessage)) {
-                        const event = {
-                            peerId,
-                            channelId: claimMessage.channelAccount,
-                            cumulativeAmount: BigInt(claimMessage.transferredAmount),
-                        };
-                        this.emit('CLAIM_RECEIVED', event);
-                        childLogger.debug({
-                            channelAccount: event.channelId,
-                            cumulativeAmount: event.cumulativeAmount.toString(),
-                        }, 'CLAIM_RECEIVED event emitted (Solana)');
-                    }
-                    else if ((0, btp_claim_types_1.isMinaClaim)(claimMessage)) {
-                        const event = {
-                            peerId,
-                            channelId: claimMessage.zkAppAddress,
-                            cumulativeAmount: BigInt(0),
-                        };
-                        this.emit('CLAIM_RECEIVED', event);
-                        childLogger.debug({ zkAppAddress: event.channelId }, 'CLAIM_RECEIVED event emitted (Mina)');
-                    }
-                }
-                catch (eventError) {
-                    childLogger.warn({
-                        messageId: claimMessage.messageId,
-                        error: eventError instanceof Error ? eventError.message : String(eventError),
-                    }, 'Failed to emit CLAIM_RECEIVED event (invalid transferredAmount for BigInt conversion)');
-                }
-            }
-            else {
-                this._persistReceivedClaim(peerId, claimMessage, false);
-                childLogger.warn({ messageId, error: verificationResult.error }, 'Claim verification failed');
-            }
-        }
-        catch (error) {
-            childLogger.error({ error }, 'Failed to parse claim message');
-        }
-    }
-    resolveProvider(claim) {
-        if ((0, btp_claim_types_1.isEVMClaim)(claim)) {
-            if (this.channelManager) {
-                const knownChannel = this.channelManager.getChannelById(claim.channelId);
-                if (knownChannel && knownChannel.chain) {
-                    return this.chainProviderRegistry.getProvider(claim.blockchain, knownChannel.chain);
-                }
-            }
-            if (claim.chainId !== undefined) {
-                const chainKey = `${claim.blockchain}:${claim.chainId}`;
-                return this.chainProviderRegistry.getProvider(claim.blockchain, chainKey);
-            }
-        }
-        if ((0, btp_claim_types_1.isSolanaClaim)(claim)) {
-            if (this.channelManager) {
-                const knownChannel = this.channelManager.getChannelById(claim.channelAccount);
-                if (knownChannel && knownChannel.chain) {
-                    return this.chainProviderRegistry.getProvider(claim.blockchain, knownChannel.chain);
-                }
-            }
-            if (claim.cluster !== undefined) {
-                const chainKey = `${claim.blockchain}:${claim.cluster}`;
-                return this.chainProviderRegistry.getProvider(claim.blockchain, chainKey);
-            }
-        }
-        if ((0, btp_claim_types_1.isMinaClaim)(claim)) {
-            if (this.channelManager) {
-                const knownChannel = this.channelManager.getChannelById(claim.zkAppAddress);
-                if (knownChannel && knownChannel.chain) {
-                    return this.chainProviderRegistry.getProvider(claim.blockchain, knownChannel.chain);
-                }
-            }
-            if (claim.network !== undefined) {
-                const chainKey = `${claim.blockchain}:${claim.network}`;
-                return this.chainProviderRegistry.getProvider(claim.blockchain, chainKey);
-            }
-        }
-        const allProviders = this.chainProviderRegistry.getAllProviders();
-        return allProviders.find((p) => p.chainType === claim.blockchain);
-    }
-    async verifyClaim(claim, peerId, provider) {
-        try {
-            if ((0, btp_claim_types_1.isEVMClaim)(claim)) {
-                return await this.verifyEVMClaim(claim, peerId, provider);
-            }
-            if ((0, btp_claim_types_1.isSolanaClaim)(claim)) {
-                return await this.verifySolanaClaim(claim, peerId, provider);
-            }
-            if ((0, btp_claim_types_1.isMinaClaim)(claim)) {
-                return await this.verifyMinaClaim(claim, peerId, provider);
-            }
-            const _exhaustiveCheck = claim;
-            return {
-                valid: false,
-                messageId: _exhaustiveCheck.messageId,
-                error: `Verification not supported for blockchain: ${_exhaustiveCheck.blockchain}`,
-            };
-        }
-        catch (error) {
-            return {
-                valid: false,
-                messageId: claim.messageId,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    }
-    async verifyEVMClaim(claim, peerId, provider) {
-        this.logger.debug({ channelId: claim.channelId }, 'Checking channel existence in metadata');
-        const knownChannel = this.channelManager?.getChannelById(claim.channelId);
-        if (!knownChannel && this.channelManager) {
-            this.logger.info({ channelId: claim.channelId }, 'Unknown channel detected, starting on-chain verification');
-            if (claim.chainId === undefined || !claim.tokenNetworkAddress || !claim.tokenAddress) {
-                this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress }, exports.ERRORS.MISSING_SELF_DESCRIBING_FIELDS);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.MISSING_SELF_DESCRIBING_FIELDS,
-                };
-            }
-            let channelState;
-            try {
-                channelState = await provider.getChannelState(claim.channelId);
-            }
-            catch (error) {
-                this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress, error }, exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED,
-                };
-            }
-            if (channelState.status !== 'opened') {
-                const errorMsg = channelState.status === 'settled' || channelState.status === 'closed'
-                    ? exports.ERRORS.CHANNEL_NOT_OPENED
-                    : exports.ERRORS.CHANNEL_NOT_FOUND;
-                this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress }, errorMsg);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: errorMsg,
-                };
-            }
-            const signerLower = claim.signerAddress.toLowerCase();
-            if (!channelState.participants.some((p) => p.toLowerCase() === signerLower)) {
-                this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress }, exports.ERRORS.SIGNER_NOT_PARTICIPANT);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.SIGNER_NOT_PARTICIPANT,
-                };
-            }
-            this.logger.info({
-                channelId: claim.channelId,
-                participants: channelState.participants,
-                status: channelState.status,
-            }, 'On-chain channel verified successfully');
-            const verifyParams = this.buildVerifyParams(claim);
-            const sigValid = await provider.verifyBalanceProof(verifyParams);
-            if (!sigValid) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-            this.channelManager.registerExternalChannel({
-                channelId: claim.channelId,
-                peerId,
-                tokenAddress: claim.tokenAddress,
-                tokenNetworkAddress: claim.tokenNetworkAddress,
-                chainId: claim.chainId,
-                status: 'open',
-            });
-            this.logger.info({ channelId: claim.channelId, peerId }, 'External channel registered');
-            if (this.peerIdToAddressMap && !this.peerIdToAddressMap.has(peerId)) {
-                this.peerIdToAddressMap.set(peerId, claim.signerAddress);
-                this.logger.info({ peerId, signerAddress: claim.signerAddress }, 'Peer EVM address registered from self-describing claim');
-            }
-        }
-        else {
-            const verifyParams = this.buildVerifyParams(claim);
-            const isValid = await provider.verifyBalanceProof(verifyParams);
-            if (!isValid) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-        }
-        const latestClaim = await this.getLatestVerifiedClaim(peerId, claim.blockchain, claim.channelId);
-        if (latestClaim && (0, btp_claim_types_1.isEVMClaim)(latestClaim)) {
-            if (claim.nonce <= latestClaim.nonce) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: 'Nonce not monotonically increasing',
-                };
-            }
-        }
-        return { valid: true, messageId: claim.messageId };
-    }
-    buildVerifyParams(claim) {
-        return {
-            channelId: claim.channelId,
-            nonce: claim.nonce,
-            transferredAmount: claim.transferredAmount,
-            lockedAmount: claim.lockedAmount,
-            locksRoot: claim.locksRoot,
-            signature: claim.signature,
-            signerAddress: claim.signerAddress,
-        };
-    }
-    async verifySolanaClaim(claim, peerId, provider) {
-        this.logger.debug({ channelAccount: claim.channelAccount }, 'Verifying Solana claim');
-        const knownChannel = this.channelManager?.getChannelById(claim.channelAccount);
-        if (!knownChannel && this.channelManager) {
-            this.logger.info({ channelAccount: claim.channelAccount }, 'Unknown Solana channel detected, starting on-chain verification');
-            let channelState;
-            try {
-                channelState = await provider.getChannelState(claim.channelAccount);
-            }
-            catch (error) {
-                this.logger.warn({
-                    channelAccount: claim.channelAccount,
-                    signerPublicKey: claim.signerPublicKey,
-                    error,
-                }, exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED,
-                };
-            }
-            if (channelState.status !== 'opened' && channelState.status !== 'closed') {
-                const errorMsg = channelState.status === 'settled' ? exports.ERRORS.CHANNEL_NOT_OPENED : exports.ERRORS.CHANNEL_NOT_FOUND;
-                this.logger.warn({ channelAccount: claim.channelAccount, status: channelState.status }, errorMsg);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: errorMsg,
-                };
-            }
-            if (!channelState.participants.includes(claim.signerPublicKey)) {
-                this.logger.warn({
-                    channelAccount: claim.channelAccount,
-                    signerPublicKey: claim.signerPublicKey,
-                }, exports.ERRORS.SIGNER_NOT_PARTICIPANT);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.SIGNER_NOT_PARTICIPANT,
-                };
-            }
-            this.logger.info({
-                channelAccount: claim.channelAccount,
-                participants: channelState.participants,
-                status: channelState.status,
-            }, 'On-chain Solana channel verified successfully');
-            const verifyParams = this.buildSolanaVerifyParams(claim);
-            const sigValid = await provider.verifyBalanceProof(verifyParams);
-            if (!sigValid) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-            this.channelManager.registerExternalChannel({
-                channelId: claim.channelAccount,
-                peerId,
-                tokenAddress: claim.programId,
-                status: 'open',
-                chain: `solana:${claim.cluster ?? 'devnet'}`,
-            });
-            this.logger.info({ channelAccount: claim.channelAccount, peerId }, 'External Solana channel registered');
-            if (this.peerIdToAddressMap && !this.peerIdToAddressMap.has(peerId)) {
-                this.peerIdToAddressMap.set(peerId, claim.signerPublicKey);
-                this.logger.info({ peerId, signerPublicKey: claim.signerPublicKey }, 'Peer Solana address registered from self-describing claim');
-            }
-        }
-        else {
-            const verifyParams = this.buildSolanaVerifyParams(claim);
-            const isValid = await provider.verifyBalanceProof(verifyParams);
-            if (!isValid) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-        }
-        const latestClaim = await this.getLatestVerifiedClaim(peerId, claim.blockchain, claim.channelAccount);
-        if (latestClaim && (0, btp_claim_types_1.isSolanaClaim)(latestClaim)) {
-            if (claim.nonce <= latestClaim.nonce) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: 'Nonce not monotonically increasing',
-                };
-            }
-        }
-        return { valid: true, messageId: claim.messageId };
-    }
-    buildSolanaVerifyParams(claim) {
-        return {
-            channelId: claim.channelAccount,
-            nonce: claim.nonce,
-            transferredAmount: claim.transferredAmount,
-            lockedAmount: '0',
-            locksRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-            signature: claim.signature,
-            signerAddress: claim.signerPublicKey,
-        };
-    }
-    async verifyMinaClaim(claim, peerId, provider) {
-        this.logger.debug({
-            event: 'mina_claim_received',
-            messageId: claim.messageId,
-            zkAppAddress: claim.zkAppAddress,
-        }, 'Verifying Mina claim');
-        const knownChannel = this.channelManager?.getChannelById(claim.zkAppAddress);
-        if (!knownChannel && this.channelManager) {
-            this.logger.info({ zkAppAddress: claim.zkAppAddress }, 'Unknown Mina channel detected, starting on-chain verification');
-            let channelState;
-            try {
-                channelState = await provider.getChannelState(claim.zkAppAddress);
-            }
-            catch (error) {
-                this.logger.warn({ event: 'mina_claim_verification_failed', messageId: claim.messageId, error }, exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.ON_CHAIN_VERIFICATION_FAILED,
-                };
-            }
-            if (channelState.status !== 'opened' && channelState.status !== 'closed') {
-                const errorMsg = channelState.status === 'settled' ? exports.ERRORS.CHANNEL_NOT_OPENED : exports.ERRORS.CHANNEL_NOT_FOUND;
-                this.logger.warn({ zkAppAddress: claim.zkAppAddress, status: channelState.status }, errorMsg);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: errorMsg,
-                };
-            }
-            this.logger.info({
-                zkAppAddress: claim.zkAppAddress,
-                participants: channelState.participants,
-                status: channelState.status,
-            }, 'On-chain Mina channel verified successfully');
-            const verifyParams = this.buildMinaVerifyParams(claim);
-            const proofValid = await provider.verifyBalanceProof(verifyParams);
-            if (!proofValid) {
-                this.logger.warn({ event: 'mina_claim_verification_failed', messageId: claim.messageId }, exports.ERRORS.INVALID_SIGNATURE);
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-            this.channelManager.registerExternalChannel({
-                channelId: claim.zkAppAddress,
-                peerId,
-                tokenAddress: claim.tokenId,
-                status: 'open',
-                chain: `mina:${claim.network ?? 'devnet'}`,
-            });
-            this.logger.info({ zkAppAddress: claim.zkAppAddress, peerId }, 'External Mina channel registered');
-        }
-        else {
-            const verifyParams = this.buildMinaVerifyParams(claim);
-            const isValid = await provider.verifyBalanceProof(verifyParams);
-            if (!isValid) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: exports.ERRORS.INVALID_SIGNATURE,
-                };
-            }
-        }
-        const latestClaim = await this.getLatestVerifiedClaim(peerId, claim.blockchain, claim.zkAppAddress);
-        if (latestClaim && (0, btp_claim_types_1.isMinaClaim)(latestClaim)) {
-            if (claim.nonce <= latestClaim.nonce) {
-                return {
-                    valid: false,
-                    messageId: claim.messageId,
-                    error: 'Nonce not monotonically increasing',
-                };
-            }
-        }
-        return { valid: true, messageId: claim.messageId };
-    }
-    buildMinaVerifyParams(claim) {
-        return {
-            channelId: claim.zkAppAddress,
-            nonce: claim.nonce,
-            transferredAmount: claim.balanceCommitment,
-            lockedAmount: '0',
-            locksRoot: '0x' + '0'.repeat(64),
-            signature: claim.proof,
-            signerAddress: claim.zkAppAddress,
-        };
-    }
-    _persistReceivedClaim(peerId, claim, verified) {
-        try {
-            let channelId = '';
-            if ((0, btp_claim_types_1.isEVMClaim)(claim)) {
-                channelId = claim.channelId;
-            }
-            else if ((0, btp_claim_types_1.isSolanaClaim)(claim)) {
-                channelId = claim.channelAccount;
-            }
-            else if ((0, btp_claim_types_1.isMinaClaim)(claim)) {
-                channelId = claim.zkAppAddress;
-            }
-            const stmt = this.db.prepare(`
-        INSERT INTO received_claims (
-          message_id,
-          peer_id,
-          blockchain,
-          channel_id,
-          claim_data,
-          verified,
-          received_at,
-          redeemed_at,
-          redemption_tx_hash
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-            stmt.run(claim.messageId, peerId, claim.blockchain, channelId, JSON.stringify(claim), verified ? 1 : 0, Date.now(), null, null);
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('UNIQUE constraint failed')) {
-                this.logger.warn({ messageId: claim.messageId }, 'Duplicate claim message ignored (idempotency)');
-            }
-            else {
-                this.logger.error({ error }, 'Failed to persist claim to database');
-            }
-        }
-    }
-    async getLatestVerifiedClaim(peerId, blockchain, channelId) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT claim_data
-        FROM received_claims
-        WHERE peer_id = ?
-          AND blockchain = ?
-          AND channel_id = ?
-          AND verified = 1
-          AND redeemed_at IS NULL
-        ORDER BY received_at DESC
-        LIMIT 1
-      `);
-            const row = stmt.get(peerId, blockchain, channelId);
-            if (!row) {
-                return null;
-            }
-            return JSON.parse(row.claim_data);
-        }
-        catch (error) {
-            this.logger.error({ error }, 'Failed to query latest verified claim');
-            return null;
-        }
-    }
-    async getRecentClaims(limit = 50) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT message_id, peer_id, blockchain, channel_id, claim_data, received_at
-        FROM received_claims
-        WHERE verified = 1
-        ORDER BY received_at DESC
-        LIMIT ?
-      `);
-            const rows = stmt.all(limit);
-            return rows.map((row) => ({
-                messageId: row.message_id,
-                peerId: row.peer_id,
-                blockchain: row.blockchain,
-                channelId: row.channel_id,
-                claimData: JSON.parse(row.claim_data),
-                receivedAt: row.received_at,
-            }));
-        }
-        catch (error) {
-            this.logger.error({ error }, 'Failed to query recent claims');
-            return [];
-        }
-    }
-    async getLastClaimAt(peerId, blockchain) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT MAX(received_at) AS last_at
-        FROM received_claims
-        WHERE peer_id = ? AND blockchain = ? AND verified = 1
-      `);
-            const row = stmt.get(peerId, blockchain);
-            return row?.last_at ?? null;
-        }
-        catch (error) {
-            this.logger.error({ error, peerId, blockchain }, 'Failed to query last claim timestamp');
-            return null;
-        }
-    }
-    async getCumulativeInboundByAsset(peerId) {
-        const out = new Map();
-        try {
-            const stmt = this.db.prepare(`
-        SELECT blockchain, channel_id, claim_data, received_at
-        FROM received_claims
-        WHERE peer_id = ? AND verified = 1
-      `);
-            const rows = stmt.all(peerId);
-            const latestByChannel = new Map();
-            for (const row of rows) {
-                let claim;
-                try {
-                    claim = JSON.parse(row.claim_data);
-                }
-                catch {
-                    continue;
-                }
-                let tokenAddress = '';
-                let amount = 0n;
-                let nonce = 0;
-                if ((0, btp_claim_types_1.isEVMClaim)(claim)) {
-                    tokenAddress = claim.tokenAddress ?? '';
-                    try {
-                        amount = BigInt(claim.transferredAmount ?? '0');
-                    }
-                    catch {
-                        amount = 0n;
-                    }
-                    nonce = claim.nonce ?? 0;
-                }
-                else if ((0, btp_claim_types_1.isSolanaClaim)(claim)) {
-                    tokenAddress = claim.programId;
-                    try {
-                        amount = BigInt(claim.transferredAmount ?? '0');
-                    }
-                    catch {
-                        amount = 0n;
-                    }
-                    nonce = claim.nonce ?? 0;
-                }
-                else if ((0, btp_claim_types_1.isMinaClaim)(claim)) {
-                    tokenAddress = claim.tokenId ?? '';
-                    amount = 0n;
-                    nonce = claim.nonce ?? 0;
-                }
-                if (!tokenAddress)
-                    continue;
-                const key = `${row.blockchain}:${row.channel_id}`;
-                const existing = latestByChannel.get(key);
-                if (!existing || nonce > existing.nonce) {
-                    latestByChannel.set(key, {
-                        blockchain: row.blockchain,
-                        tokenAddress,
-                        amount,
-                        nonce,
-                        receivedAt: row.received_at,
-                    });
-                }
-            }
-            for (const entry of latestByChannel.values()) {
-                const assetKey = `${entry.blockchain}:${entry.tokenAddress}`;
-                const bucket = out.get(assetKey);
-                if (bucket) {
-                    bucket.total += entry.amount;
-                    if (entry.receivedAt > bucket.lastAt)
-                        bucket.lastAt = entry.receivedAt;
-                }
-                else {
-                    out.set(assetKey, {
-                        blockchain: entry.blockchain,
-                        tokenAddress: entry.tokenAddress,
-                        total: entry.amount,
-                        lastAt: entry.receivedAt,
-                    });
-                }
-            }
-        }
-        catch (error) {
-            this.logger.error({ error, peerId }, 'Failed to compute cumulative inbound claims');
-        }
-        return out;
-    }
-    async getLatestVerifiedClaimForChannel(peerId, channelId) {
-        try {
-            const stmt = this.db.prepare(`
-        SELECT claim_data
-        FROM received_claims
-        WHERE peer_id = ?
-          AND channel_id = ?
-          AND verified = 1
-          AND redeemed_at IS NULL
-        ORDER BY received_at DESC
-        LIMIT 1
-      `);
-            const row = stmt.get(peerId, channelId);
-            if (!row) {
-                return null;
-            }
-            return JSON.parse(row.claim_data);
-        }
-        catch (error) {
-            this.logger.error({ error }, 'Failed to query latest verified claim for channel');
-            return null;
-        }
-    }
-}
-exports.ClaimReceiver = ClaimReceiver;
-//# sourceMappingURL=claim-receiver.js.map