@toon-protocol/connector 1.7.1

package/dist/settlement/payment-channel-sdk.js

@@ -0,0 +1,677 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentChannelSDK = exports.ChallengeNotExpiredError = void 0;
+const eip712_helper_1 = require("./eip712-helper");
+const key_manager_signer_1 = require("../security/key-manager-signer");
+const optional_require_1 = require("../utils/optional-require");
+const REGISTRY_ABI = [
+    'function createTokenNetwork(address token) external returns (address)',
+    'function getTokenNetwork(address token) external view returns (address)',
+    'event TokenNetworkCreated(address indexed token, address indexed tokenNetwork)',
+];
+const TOKEN_NETWORK_ABI = [
+    'function openChannel(address participant2, uint256 settlementTimeout) external returns (bytes32)',
+    'function setTotalDeposit(bytes32 channelId, address participant, uint256 totalDeposit) external',
+    'function closeChannel(bytes32 channelId) external',
+    'function claimFromChannel(bytes32 channelId, tuple(bytes32 channelId, uint256 nonce, uint256 transferredAmount, uint256 lockedAmount, bytes32 locksRoot) balanceProof, bytes signature) external',
+    'function settleChannel(bytes32 channelId) external',
+    'function channels(bytes32) external view returns (uint256 settlementTimeout, uint8 state, uint256 closedAt, uint256 openedAt, address participant1, address participant2)',
+    'function participants(bytes32, address) external view returns (uint256 deposit, uint256 nonce, uint256 transferredAmount)',
+    'function claimedAmounts(bytes32, address) external view returns (uint256)',
+    'event ChannelOpened(bytes32 indexed channelId, address indexed participant1, address indexed participant2, uint256 settlementTimeout)',
+    'event ChannelClosed(bytes32 indexed channelId, address indexed closingParticipant)',
+    'event ChannelSettled(bytes32 indexed channelId, uint256 participant1Amount, uint256 participant2Amount)',
+    'event ChannelClaimed(bytes32 indexed channelId, address indexed claimant, uint256 claimedAmount, uint256 totalClaimed)',
+];
+const ERC20_ABI = [
+    'function approve(address spender, uint256 amount) external returns (bool)',
+    'function allowance(address owner, address spender) external view returns (uint256)',
+    'function symbol() external view returns (string)',
+];
+class ChallengeNotExpiredError extends Error {
+    channelId;
+    closedAt;
+    settlementTimeout;
+    constructor(message, channelId, closedAt, settlementTimeout) {
+        super(message);
+        this.channelId = channelId;
+        this.closedAt = closedAt;
+        this.settlementTimeout = settlementTimeout;
+        this.name = 'ChallengeNotExpiredError';
+    }
+}
+exports.ChallengeNotExpiredError = ChallengeNotExpiredError;
+class PaymentChannelSDK {
+    provider;
+    signer = null;
+    keyManager;
+    evmKeyId;
+    registryAddress;
+    registryContract = null;
+    tokenNetworkCache;
+    channelStateCache;
+    logger;
+    eventListeners;
+    _initPromise = null;
+    constructor(provider, keyManager, evmKeyId, registryAddress, logger) {
+        this.provider = provider;
+        this.keyManager = keyManager;
+        this.evmKeyId = evmKeyId;
+        this.registryAddress = registryAddress;
+        this.tokenNetworkCache = new Map();
+        this.channelStateCache = new Map();
+        this.logger = logger;
+        this.eventListeners = new Map();
+    }
+    async _ensureInitialized() {
+        if (this.signer && this.registryContract) {
+            const ethersModule = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+            return {
+                signer: this.signer,
+                registryContract: this.registryContract,
+                ethers: ethersModule.ethers,
+            };
+        }
+        if (!this._initPromise) {
+            this._initPromise = (async () => {
+                const { ethers: ethersNs } = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+                this.signer = await (0, key_manager_signer_1.createKeyManagerSigner)(this.keyManager, this.evmKeyId, this.provider);
+                this.registryContract = new ethersNs.Contract(this.registryAddress, REGISTRY_ABI, this.signer);
+            })();
+        }
+        await this._initPromise;
+        const ethersModule = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+        return {
+            signer: this.signer,
+            registryContract: this.registryContract,
+            ethers: ethersModule.ethers,
+        };
+    }
+    static fromConnectionPool(pool, keyManager, evmKeyId, registryAddress, logger) {
+        const provider = pool.getProvider();
+        if (!provider) {
+            throw new Error('No healthy EVM RPC connection available in pool');
+        }
+        logger.info('Creating PaymentChannelSDK from connection pool');
+        return new PaymentChannelSDK(provider, keyManager, evmKeyId, registryAddress, logger);
+    }
+    async getTokenNetworkContract(tokenAddress) {
+        if (this.tokenNetworkCache.has(tokenAddress)) {
+            return this.tokenNetworkCache.get(tokenAddress);
+        }
+        const { signer, registryContract, ethers } = await this._ensureInitialized();
+        const networkAddress = await registryContract.getTokenNetwork(tokenAddress);
+        if (networkAddress === ethers.ZeroAddress) {
+            throw new Error(`No TokenNetwork found for token ${tokenAddress}`);
+        }
+        const tokenNetwork = new ethers.Contract(networkAddress, TOKEN_NETWORK_ABI, signer);
+        this.tokenNetworkCache.set(tokenAddress, tokenNetwork);
+        this.logger.debug('TokenNetwork contract cached', { tokenAddress, networkAddress });
+        return tokenNetwork;
+    }
+    async getTokenNetworkAddress(tokenAddress) {
+        const contract = await this.getTokenNetworkContract(tokenAddress);
+        return await contract.getAddress();
+    }
+    async getChainId() {
+        const network = await this.provider.getNetwork();
+        return Number(network.chainId);
+    }
+    async getTokenSymbol(tokenAddress) {
+        const { ethers } = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+        const erc20 = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+        const symbol = await erc20.symbol();
+        return symbol;
+    }
+    async getSignerAddress() {
+        const { signer } = await this._ensureInitialized();
+        return await signer.getAddress();
+    }
+    async openChannel(participant2, tokenAddress, settlementTimeout, initialDeposit) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        this.logger.info('Opening payment channel', {
+            participant2,
+            tokenAddress,
+            settlementTimeout,
+            initialDeposit: initialDeposit.toString(),
+        });
+        const tx = await tokenNetwork.openChannel(participant2, settlementTimeout);
+        const receipt = await tx.wait();
+        const channelOpenedEvent = receipt.logs
+            .map((log) => {
+            try {
+                return tokenNetwork.interface.parseLog({
+                    topics: log.topics,
+                    data: log.data,
+                });
+            }
+            catch {
+                return null;
+            }
+        })
+            .find((parsed) => parsed?.name === 'ChannelOpened');
+        if (!channelOpenedEvent) {
+            throw new Error('ChannelOpened event not found in transaction receipt');
+        }
+        const channelId = channelOpenedEvent.args[0];
+        const [participant1, participant2Addr] = [
+            channelOpenedEvent.args[1],
+            channelOpenedEvent.args[2],
+        ];
+        const participants = [participant1, participant2Addr];
+        this.channelStateCache.set(channelId, {
+            channelId,
+            participants,
+            myDeposit: 0n,
+            theirDeposit: 0n,
+            myNonce: 0,
+            theirNonce: 0,
+            myTransferred: 0n,
+            theirTransferred: 0n,
+            status: 'opened',
+            settlementTimeout,
+            openedAt: Date.now() / 1000,
+        });
+        const txHash = receipt.hash;
+        this.logger.info('Channel opened successfully', {
+            channelId,
+            participant1,
+            participant2: participant2Addr,
+            txHash,
+        });
+        if (initialDeposit > 0n) {
+            await this.deposit(channelId, tokenAddress, initialDeposit);
+        }
+        return { channelId, txHash };
+    }
+    async deposit(channelId, tokenAddress, amount) {
+        const { signer, ethers } = await this._ensureInitialized();
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const myAddress = await signer.getAddress();
+        const state = await this.getChannelState(channelId, tokenAddress);
+        const newTotalDeposit = state.myDeposit + amount;
+        this.logger.info('Depositing to channel', {
+            channelId,
+            amount: amount.toString(),
+            newTotalDeposit: newTotalDeposit.toString(),
+        });
+        const token = new ethers.Contract(tokenAddress, ERC20_ABI, signer);
+        const tokenNetworkAddress = await tokenNetwork.getAddress();
+        const currentAllowance = (await token.allowance(myAddress, tokenNetworkAddress));
+        if (currentAllowance < newTotalDeposit) {
+            const maxApproval = ethers.MaxUint256;
+            this.logger.info('Approving max token allowance for TokenNetwork', {
+                channelId,
+                currentAllowance: currentAllowance.toString(),
+                requiredAmount: newTotalDeposit.toString(),
+                approvalAmount: 'max uint256',
+                tokenNetworkAddress,
+            });
+            let approveTx;
+            let retries = 0;
+            const maxRetries = 3;
+            while (retries < maxRetries) {
+                try {
+                    const currentNonce = await this.provider.getTransactionCount(myAddress, 'pending');
+                    this.logger.debug('Sending approve transaction', {
+                        channelId,
+                        nonce: currentNonce,
+                        attempt: retries + 1,
+                    });
+                    approveTx = await token.approve(tokenNetworkAddress, maxApproval, {
+                        nonce: currentNonce,
+                    });
+                    break;
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.code === 'NONCE_EXPIRED' && retries < maxRetries - 1) {
+                        this.logger.warn('Nonce error on approve, retrying with fresh nonce', {
+                            channelId,
+                            attempt: retries + 1,
+                            error: err.message,
+                        });
+                        retries++;
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            if (!approveTx) {
+                throw new Error('Failed to send approve transaction after retries');
+            }
+            await approveTx.wait();
+            this.logger.debug('Token approval confirmed', {
+                channelId,
+                approvedAmount: 'max uint256',
+                txHash: approveTx.hash,
+            });
+        }
+        else {
+            this.logger.debug('Sufficient token allowance already exists', {
+                channelId,
+                currentAllowance: currentAllowance.toString(),
+                requiredAmount: newTotalDeposit.toString(),
+            });
+        }
+        let depositTx;
+        let depositRetries = 0;
+        const maxDepositRetries = 3;
+        while (depositRetries < maxDepositRetries) {
+            try {
+                const currentNonce = await this.provider.getTransactionCount(myAddress, 'pending');
+                this.logger.debug('Sending setTotalDeposit transaction', {
+                    channelId,
+                    nonce: currentNonce,
+                    attempt: depositRetries + 1,
+                });
+                depositTx = await tokenNetwork.setTotalDeposit(channelId, myAddress, newTotalDeposit, {
+                    nonce: currentNonce,
+                });
+                break;
+            }
+            catch (error) {
+                const err = error;
+                if (err.code === 'NONCE_EXPIRED' && depositRetries < maxDepositRetries - 1) {
+                    this.logger.warn('Nonce error on setTotalDeposit, retrying', {
+                        channelId,
+                        attempt: depositRetries + 1,
+                        error: err.message,
+                    });
+                    depositRetries++;
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        if (!depositTx) {
+            throw new Error('Failed to send setTotalDeposit transaction after retries');
+        }
+        await depositTx.wait();
+        if (this.channelStateCache.has(channelId)) {
+            const cached = this.channelStateCache.get(channelId);
+            cached.myDeposit = newTotalDeposit;
+            this.channelStateCache.set(channelId, cached);
+        }
+        this.logger.info('Deposit completed', {
+            channelId,
+            newTotalDeposit: newTotalDeposit.toString(),
+        });
+    }
+    async signBalanceProof(channelId, nonce, transferredAmount, lockedAmount = 0n, locksRoot) {
+        const { ethers } = await this._ensureInitialized();
+        const resolvedLocksRoot = locksRoot ?? ethers.ZeroHash;
+        let tokenNetworkAddress;
+        for (const [, contract] of this.tokenNetworkCache) {
+            try {
+                const channelData = await contract.channels(channelId);
+                if (channelData.state !== 0) {
+                    tokenNetworkAddress = await contract.getAddress();
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!tokenNetworkAddress) {
+            throw new Error(`Cannot determine TokenNetwork for channel ${channelId}`);
+        }
+        const network = await this.provider.getNetwork();
+        const chainId = network.chainId;
+        const domain = (0, eip712_helper_1.getDomainSeparator)(chainId, tokenNetworkAddress);
+        const types = (0, eip712_helper_1.getBalanceProofTypes)();
+        const balanceProof = {
+            channelId,
+            nonce,
+            transferredAmount,
+            lockedAmount,
+            locksRoot: resolvedLocksRoot,
+        };
+        const hash = ethers.TypedDataEncoder.hash(domain, types, balanceProof);
+        const signatureBuffer = await this.keyManager.sign(Buffer.from(hash.slice(2), 'hex'), this.evmKeyId);
+        const signature = '0x' + signatureBuffer.toString('hex');
+        this.logger.debug('Balance proof signed', {
+            channelId,
+            nonce,
+            transferredAmount: transferredAmount.toString(),
+        });
+        return signature;
+    }
+    async verifyBalanceProof(balanceProof, signature, expectedSigner) {
+        try {
+            const { ethers } = await this._ensureInitialized();
+            let tokenNetworkAddress;
+            for (const [, contract] of this.tokenNetworkCache) {
+                try {
+                    const channelData = await contract.channels(balanceProof.channelId);
+                    if (channelData.state !== 0) {
+                        tokenNetworkAddress = await contract.getAddress();
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!tokenNetworkAddress) {
+                this.logger.warn('Cannot determine TokenNetwork for balance proof verification', {
+                    channelId: balanceProof.channelId,
+                });
+                return false;
+            }
+            const network = await this.provider.getNetwork();
+            const chainId = network.chainId;
+            const domain = (0, eip712_helper_1.getDomainSeparator)(chainId, tokenNetworkAddress);
+            const types = (0, eip712_helper_1.getBalanceProofTypes)();
+            const recoveredSigner = ethers.verifyTypedData(domain, types, balanceProof, signature);
+            const isValid = recoveredSigner.toLowerCase() === expectedSigner.toLowerCase();
+            if (!isValid) {
+                this.logger.warn('Balance proof verification failed', {
+                    balanceProof,
+                    expectedSigner,
+                    recoveredSigner,
+                });
+            }
+            return isValid;
+        }
+        catch (error) {
+            this.logger.error('Balance proof verification error', { balanceProof, error });
+            return false;
+        }
+    }
+    async closeChannel(channelId, tokenAddress) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const state = await this.getChannelState(channelId, tokenAddress);
+        if (state.status !== 'opened') {
+            throw new Error(`Cannot close channel in status: ${state.status}`);
+        }
+        this.logger.info('Closing channel (starting grace period)', { channelId });
+        const tx = await tokenNetwork.closeChannel(channelId);
+        const receipt = await tx.wait();
+        if (this.channelStateCache.has(channelId)) {
+            const cached = this.channelStateCache.get(channelId);
+            cached.status = 'closed';
+            const block = await this.provider.getBlock(receipt.blockNumber);
+            cached.closedAt = block.timestamp;
+            this.channelStateCache.set(channelId, cached);
+        }
+        this.logger.info('Channel closed, grace period started', { channelId, txHash: receipt.hash });
+    }
+    async claimFromChannel(channelId, tokenAddress, balanceProof, signature) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const state = await this.getChannelState(channelId, tokenAddress);
+        if (state.status !== 'opened' && state.status !== 'closed') {
+            throw new Error(`Cannot claim from channel in status: ${state.status}`);
+        }
+        this.logger.info('Claiming from channel', {
+            channelId,
+            nonce: balanceProof.nonce,
+            transferredAmount: balanceProof.transferredAmount.toString(),
+        });
+        const tx = await tokenNetwork.claimFromChannel(channelId, balanceProof, signature);
+        const receipt = await tx.wait();
+        this.channelStateCache.delete(channelId);
+        this.logger.info('Claim from channel completed', { channelId, txHash: receipt.hash });
+    }
+    async getClaimedAmount(channelId, tokenAddress, participant) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const claimed = await tokenNetwork.claimedAmounts(channelId, participant);
+        return claimed;
+    }
+    async settleChannel(channelId, tokenAddress) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const state = await this.getChannelState(channelId, tokenAddress);
+        if (state.status !== 'closed') {
+            throw new Error(`Cannot settle channel in status: ${state.status}`);
+        }
+        if (!state.closedAt) {
+            throw new Error('Channel closedAt timestamp is missing');
+        }
+        const latestBlock = await this.provider.getBlock('latest');
+        const now = latestBlock.timestamp;
+        const expiresAt = state.closedAt + state.settlementTimeout;
+        if (now < expiresAt) {
+            throw new ChallengeNotExpiredError(`Challenge period not expired. Expires at ${new Date(expiresAt * 1000).toISOString()}`, channelId, state.closedAt, state.settlementTimeout);
+        }
+        this.logger.info('Settling channel', { channelId });
+        const tx = await tokenNetwork.settleChannel(channelId);
+        const receipt = await tx.wait();
+        if (this.channelStateCache.has(channelId)) {
+            const cached = this.channelStateCache.get(channelId);
+            cached.status = 'settled';
+            this.channelStateCache.set(channelId, cached);
+        }
+        this.logger.info('Channel settled', { channelId, txHash: receipt.hash });
+    }
+    async getChannelState(channelId, tokenAddress) {
+        if (this.channelStateCache.has(channelId)) {
+            return this.channelStateCache.get(channelId);
+        }
+        const { signer } = await this._ensureInitialized();
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const myAddress = await signer.getAddress();
+        const channelData = await tokenNetwork.channels(channelId);
+        const [settlementTimeout, stateEnum, closedAt, openedAt, participant1, participant2] = [
+            channelData.settlementTimeout,
+            channelData.state,
+            channelData.closedAt,
+            channelData.openedAt,
+            channelData.participant1,
+            channelData.participant2,
+        ];
+        const stateMap = {
+            0: 'settled',
+            1: 'opened',
+            2: 'closed',
+            3: 'settled',
+        };
+        const status = stateMap[stateEnum] || 'settled';
+        const myParticipantData = await tokenNetwork.participants(channelId, myAddress);
+        const counterparty = participant1.toLowerCase() === myAddress.toLowerCase() ? participant2 : participant1;
+        const theirParticipantData = await tokenNetwork.participants(channelId, counterparty);
+        const state = {
+            channelId,
+            participants: [participant1, participant2],
+            myDeposit: myParticipantData.deposit,
+            theirDeposit: theirParticipantData.deposit,
+            myNonce: Number(myParticipantData.nonce),
+            theirNonce: Number(theirParticipantData.nonce),
+            myTransferred: myParticipantData.transferredAmount,
+            theirTransferred: theirParticipantData.transferredAmount,
+            status,
+            settlementTimeout: Number(settlementTimeout),
+            closedAt: closedAt > 0 ? Number(closedAt) : undefined,
+            openedAt: Number(openedAt),
+        };
+        this.channelStateCache.set(channelId, state);
+        return state;
+    }
+    async getChannelStateByNetwork(channelId, tokenNetworkAddress) {
+        const { ethers } = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+        const tokenNetwork = new ethers.Contract(tokenNetworkAddress, TOKEN_NETWORK_ABI, this.provider);
+        try {
+            const channelData = await tokenNetwork.channels(channelId);
+            const stateEnum = Number(channelData.state);
+            return {
+                exists: stateEnum !== 0,
+                state: stateEnum,
+                participant1: channelData.participant1,
+                participant2: channelData.participant2,
+                settlementTimeout: Number(channelData.settlementTimeout),
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to query channel state by network', {
+                channelId,
+                tokenNetworkAddress,
+                error,
+            });
+            throw error;
+        }
+    }
+    async verifyBalanceProofWithDomain(balanceProof, signature, expectedSigner, chainId, tokenNetworkAddress) {
+        try {
+            const { ethers } = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+            const domain = (0, eip712_helper_1.getDomainSeparator)(chainId, tokenNetworkAddress);
+            const types = (0, eip712_helper_1.getBalanceProofTypes)();
+            const recoveredSigner = ethers.verifyTypedData(domain, types, balanceProof, signature);
+            const isValid = recoveredSigner.toLowerCase() === expectedSigner.toLowerCase();
+            if (!isValid) {
+                this.logger.warn('Balance proof verification with explicit domain failed', {
+                    channelId: balanceProof.channelId,
+                    expectedSigner,
+                    recoveredSigner,
+                    chainId,
+                    tokenNetworkAddress,
+                });
+            }
+            return isValid;
+        }
+        catch (error) {
+            this.logger.error('Balance proof verification with explicit domain error', {
+                channelId: balanceProof.channelId,
+                chainId,
+                tokenNetworkAddress,
+                error,
+            });
+            return false;
+        }
+    }
+    async getMyChannels(tokenAddress) {
+        const { signer } = await this._ensureInitialized();
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const myAddress = await signer.getAddress();
+        const filter = tokenNetwork.filters.ChannelOpened();
+        const events = await tokenNetwork.queryFilter(filter);
+        const myChannels = events
+            .filter((event) => {
+            const eventLog = event;
+            const participant1 = eventLog.args[1];
+            const participant2 = eventLog.args[2];
+            return (participant1.toLowerCase() === myAddress.toLowerCase() ||
+                participant2.toLowerCase() === myAddress.toLowerCase());
+        })
+            .map((event) => {
+            const eventLog = event;
+            return eventLog.args[0];
+        });
+        return myChannels;
+    }
+    async onChannelOpened(tokenAddress, callback) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const listener = (channelId, participant1, participant2, settlementTimeout) => {
+            const event = {
+                type: 'ChannelOpened',
+                channelId,
+                participant1,
+                participant2,
+                settlementTimeout: Number(settlementTimeout),
+            };
+            this.channelStateCache.set(channelId, {
+                channelId,
+                participants: [participant1, participant2],
+                myDeposit: 0n,
+                theirDeposit: 0n,
+                myNonce: 0,
+                theirNonce: 0,
+                myTransferred: 0n,
+                theirTransferred: 0n,
+                status: 'opened',
+                settlementTimeout: Number(settlementTimeout),
+                openedAt: Date.now() / 1000,
+            });
+            callback(event);
+        };
+        tokenNetwork.on('ChannelOpened', listener);
+        const key = `${tokenAddress}:ChannelOpened`;
+        if (!this.eventListeners.has(key)) {
+            this.eventListeners.set(key, []);
+        }
+        this.eventListeners.get(key).push(listener);
+    }
+    async onChannelClosed(tokenAddress, callback) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const listener = (channelId, closingParticipant, nonce, balanceHash) => {
+            const event = {
+                type: 'ChannelClosed',
+                channelId,
+                closingParticipant,
+                nonce: Number(nonce),
+                balanceHash,
+            };
+            if (this.channelStateCache.has(channelId)) {
+                const cached = this.channelStateCache.get(channelId);
+                cached.status = 'closed';
+                cached.closedAt = Date.now() / 1000;
+                this.channelStateCache.set(channelId, cached);
+            }
+            callback(event);
+        };
+        tokenNetwork.on('ChannelClosed', listener);
+        const key = `${tokenAddress}:ChannelClosed`;
+        if (!this.eventListeners.has(key)) {
+            this.eventListeners.set(key, []);
+        }
+        this.eventListeners.get(key).push(listener);
+    }
+    async onChannelSettled(tokenAddress, callback) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const listener = (channelId, participant1Amount, participant2Amount) => {
+            const event = {
+                type: 'ChannelSettled',
+                channelId,
+                participant1Amount,
+                participant2Amount,
+            };
+            if (this.channelStateCache.has(channelId)) {
+                const cached = this.channelStateCache.get(channelId);
+                cached.status = 'settled';
+                this.channelStateCache.set(channelId, cached);
+            }
+            callback(event);
+        };
+        tokenNetwork.on('ChannelSettled', listener);
+        const key = `${tokenAddress}:ChannelSettled`;
+        if (!this.eventListeners.has(key)) {
+            this.eventListeners.set(key, []);
+        }
+        this.eventListeners.get(key).push(listener);
+    }
+    async onChannelCooperativeSettled(tokenAddress, callback) {
+        const tokenNetwork = await this.getTokenNetworkContract(tokenAddress);
+        const listener = (channelId, participant1Amount, participant2Amount) => {
+            const event = {
+                type: 'ChannelCooperativeSettled',
+                channelId,
+                participant1Amount,
+                participant2Amount,
+            };
+            if (this.channelStateCache.has(channelId)) {
+                const cached = this.channelStateCache.get(channelId);
+                cached.status = 'settled';
+                this.channelStateCache.set(channelId, cached);
+            }
+            callback(event);
+        };
+        tokenNetwork.on('ChannelCooperativeSettled', listener);
+        const key = `${tokenAddress}:ChannelCooperativeSettled`;
+        if (!this.eventListeners.has(key)) {
+            this.eventListeners.set(key, []);
+        }
+        this.eventListeners.get(key).push(listener);
+    }
+    removeAllListeners() {
+        for (const [, contract] of this.tokenNetworkCache) {
+            contract.removeAllListeners();
+        }
+        this.eventListeners.clear();
+        this.logger.debug('All event listeners removed');
+    }
+}
+exports.PaymentChannelSDK = PaymentChannelSDK;
+//# sourceMappingURL=payment-channel-sdk.js.map