@toon-protocol/connector 2.6.1 → 3.3.0

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

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