@toon-protocol/connector 3.3.1 → 3.3.3

package/dist/settlement/claim-receiver.js

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