@toon-protocol/connector 2.0.0 → 2.2.0

package/dist/settlement/claim-receiver.js

@@ -4,26 +4,33 @@ 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;
-    evmChannelSDK;
+    chainProviderRegistry;
     logger;
     channelManager;
     peerIdToAddressMap;
-    constructor(db, evmChannelSDK, logger, channelManager, peerIdToAddressMap) {
+    _nip59Wrapper;
+    _nodePrivateKey;
+    constructor(db, chainProviderRegistry, logger, channelManager, peerIdToAddressMap, _nip59Wrapper, _nodePrivateKey) {
         super();
         this.db = db;
-        this.evmChannelSDK = evmChannelSDK;
+        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) => {
@@ -34,10 +41,32 @@ class ClaimReceiver extends events_1.EventEmitter {
                 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 {
@@ -46,21 +75,54 @@ class ClaimReceiver extends events_1.EventEmitter {
             const messageId = claimMessage.messageId;
             const blockchain = claimMessage.blockchain;
             childLogger.info({ messageId, blockchain }, 'Received claim message');
-            if (!(0, btp_claim_types_1.isEVMClaim)(claimMessage)) {
-                throw new Error(`Unsupported blockchain type: ${blockchain}. Only EVM is supported.`);
+            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.verifyEVMClaim(claimMessage, peerId);
+            const verificationResult = await this.verifyClaim(claimMessage, peerId, provider);
             if (verificationResult.valid) {
                 this._persistReceivedClaim(peerId, claimMessage, true);
                 childLogger.info({ messageId }, 'Claim verified and stored');
-                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');
+                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 {
@@ -72,114 +134,63 @@ class ClaimReceiver extends events_1.EventEmitter {
             childLogger.error({ error }, 'Failed to parse claim message');
         }
     }
-    async verifyEVMClaim(claim, peerId) {
-        try {
-            const balanceProof = {
-                channelId: claim.channelId,
-                nonce: claim.nonce,
-                transferredAmount: BigInt(claim.transferredAmount),
-                lockedAmount: BigInt(claim.lockedAmount),
-                locksRoot: claim.locksRoot,
-            };
-            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 this.evmChannelSDK.getChannelStateByNetwork(claim.channelId, claim.tokenNetworkAddress);
-                }
-                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.exists) {
-                    this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress }, exports.ERRORS.CHANNEL_NOT_FOUND);
-                    return {
-                        valid: false,
-                        messageId: claim.messageId,
-                        error: exports.ERRORS.CHANNEL_NOT_FOUND,
-                    };
-                }
-                if (channelState.state !== 1) {
-                    this.logger.warn({ channelId: claim.channelId, signerAddress: claim.signerAddress }, exports.ERRORS.CHANNEL_NOT_OPENED);
-                    return {
-                        valid: false,
-                        messageId: claim.messageId,
-                        error: exports.ERRORS.CHANNEL_NOT_OPENED,
-                    };
-                }
-                const signerLower = claim.signerAddress.toLowerCase();
-                if (signerLower !== channelState.participant1.toLowerCase() &&
-                    signerLower !== channelState.participant2.toLowerCase()) {
-                    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,
-                    participant1: channelState.participant1,
-                    participant2: channelState.participant2,
-                    state: channelState.state,
-                }, 'On-chain channel verified successfully');
-                const sigValid = await this.evmChannelSDK.verifyBalanceProofWithDomain(balanceProof, claim.signature, claim.signerAddress, claim.chainId, claim.tokenNetworkAddress);
-                if (!sigValid) {
-                    return {
-                        valid: false,
-                        messageId: claim.messageId,
-                        error: 'Invalid EIP-712 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');
+    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);
                 }
             }
-            else {
-                const isValid = await this.evmChannelSDK.verifyBalanceProof(balanceProof, claim.signature, claim.signerAddress);
-                if (!isValid) {
-                    return {
-                        valid: false,
-                        messageId: claim.messageId,
-                        error: 'Invalid EIP-712 signature',
-                    };
+            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);
                 }
             }
-            const latestClaim = await this.getLatestVerifiedClaim(peerId, 'evm', 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',
-                    };
+            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);
                 }
             }
-            return { valid: true, messageId: claim.messageId };
+            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 {
@@ -189,9 +200,315 @@ class ClaimReceiver extends events_1.EventEmitter {
             };
         }
     }
+    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 {
-            const channelId = claim.channelId;
+            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,