bridge.ts

import { BridgeInfo } from "./configure";
import { Chain, ChainManager } from "./chain";
import {
    LnBridgeContract,
    LnDefaultBridgeContract,
    LnOppositeBridgeContract,
    Lnv3BridgeContract,
} from "./contract";
import { Log } from "./log";
import { Messager } from "./messager";

export class BridgeEndpoint {
    public chain: Chain;
    public bridgeContract: LnBridgeContract;
    public daoOnChain: string;
    public operatorOnChain: string;
    constructor(address: string, type: string, chain: Chain) {
        this.chain = chain;
        this.daoOnChain = "";
        this.operatorOnChain = "";
        if (type === 'default') {
            this.bridgeContract = new LnDefaultBridgeContract(address, chain.wallet);
        } else if (type === 'opposite') {
            this.bridgeContract = new LnOppositeBridgeContract(address, chain.wallet);
        } else { // lnv3
            this.bridgeContract = new Lnv3BridgeContract(address, chain.wallet);
        }
    }

    get address(): string {
        return this.bridgeContract.address;
    }

    async checkDao(): Promise<boolean> {
        if (!this.daoOnChain) {
            this.daoOnChain = await this.bridgeContract.dao();
        }
        return this.daoOnChain === this.chain.dao;
    }

    async checkOperator(): Promise<boolean> {
        if (!this.operatorOnChain) {
            this.operatorOnChain = await this.bridgeContract.operator();
        }
        return this.operatorOnChain === this.chain.operator;
    }

    async checkProxyAdmin(): Promise<boolean> {
        return await this.chain.checkProxyAdmin(this.address);
    }

    async checkTokenInfo(symbol: string, remoteEndpoint: BridgeEndpoint): Promise<boolean> {
        const srcToken = this.chain.tokens.get(symbol);
        const dstToken = remoteEndpoint.chain.tokens.get(symbol);
        if (srcToken === undefined || dstToken === undefined) {
            return false;
        }
        return await this.bridgeContract.tokenRegistered(
            remoteEndpoint.chain.id,
            srcToken!.address,
            dstToken!.address,
            srcToken!.decimals,
            dstToken!.decimals
        );
    }
}

export class Bridge {
    public name: string;
    public type: string;
    public messager: string;
    public sourceBridge: BridgeEndpoint;
    public targetBridge: BridgeEndpoint;
    public symbols: string[] | undefined;

    constructor(bridgeInfo: BridgeInfo, fromEndpoint: BridgeEndpoint, toEndpoint: BridgeEndpoint) {
        this.name = bridgeInfo.name;
        this.type = bridgeInfo.type;
        this.messager = bridgeInfo.messager;
        this.sourceBridge = fromEndpoint;
        this.targetBridge = toEndpoint;
        this.symbols = bridgeInfo.tokens;
    }

    getSourceMessagerFromConfigure(): Messager | undefined {
        return this.sourceBridge.chain.messagers.get(this.messager);
    }

    getTargetMessagerFromConfigure(): Messager | undefined {
        return this.targetBridge.chain.messagers.get(this.messager);
    }

    async getSourceMessagerFromChain(): Promise<string> {
        const remoteChainId = this.targetBridge.chain.id;
        const messagerService = await this.sourceBridge.bridgeContract.messager(remoteChainId);
        return (this.type === 'default' ? messagerService.sendService : messagerService.receiveService).toLowerCase();
    }

    async getTargetMessagerFromChain(): Promise<string> {
        const remoteChainId = this.sourceBridge.chain.id;
        const messagerService = await this.targetBridge.bridgeContract.messager(remoteChainId);
        return (this.type === 'default' ? messagerService.receiveService : messagerService.sendService).toLowerCase();
    }

    async checkSourceConnectTarget(): Promise<boolean> {
        const srcMessager = this.getSourceMessagerFromConfigure();
        const dstMessager = this.getTargetMessagerFromConfigure();
        if (srcMessager === undefined || dstMessager === undefined) {
            return false;
        }
        return await srcMessager!.isConnected(this.targetBridge.chain, dstMessager!.address());
    }

    async checkTargetConnectSource(): Promise<boolean> {
        const srcMessager = this.getSourceMessagerFromConfigure();
        const dstMessager = this.getTargetMessagerFromConfigure();
        if (srcMessager === undefined || dstMessager === undefined) {
            return false;
        }
        return await dstMessager!.isConnected(this.sourceBridge.chain, srcMessager!.address());
    }

    async checkSourceAppConnectTarget(): Promise<boolean> {
        const srcMessager = this.getSourceMessagerFromConfigure();
        const dstMessager = this.getTargetMessagerFromConfigure();
        if (srcMessager === undefined || dstMessager === undefined) {
            return false;
        }
        if (this.type === 'default') {
            return await srcMessager!.remoteAppIsReceiver(this.targetBridge.chain.id, this.sourceBridge.address, this.targetBridge.address);
        } else {
            return await srcMessager!.remoteAppIsSender(this.targetBridge.chain.id, this.sourceBridge.address, this.targetBridge.address);
        }
    }

    async checkTargetAppConnectSource(): Promise<boolean> {
        const srcMessager = this.getSourceMessagerFromConfigure();
        const dstMessager = this.getTargetMessagerFromConfigure();
        if (srcMessager === undefined || dstMessager === undefined) {
            return false;
        }
        if (this.type === 'default') {
            return await dstMessager!.remoteAppIsSender(this.sourceBridge.chain.id, this.targetBridge.address, this.sourceBridge.address);
        } else {
            return await dstMessager!.remoteAppIsReceiver(this.sourceBridge.chain.id, this.targetBridge.address, this.sourceBridge.address);
        }
    }
}

// for lnv3Bridge: all endpoint should be connected for each other
export class BridgeManager {
    public log: Log;
    public bridges: Map<string, Bridge> = new Map<string, Bridge>();
    public v3bridges: Map<string, Bridge> = new Map<string, Bridge>();
    // address + chain = key
    public bridgeEndpointCache: Map<string, BridgeEndpoint> = new Map<string, BridgeEndpoint>();
    constructor(bridgeInfos: BridgeInfo[], v3BridgeInfos: BridgeInfo[], chainManager: ChainManager) {
        this.log = new Log();
        for (const bridgeInfo of bridgeInfos) {
            const fromChain = chainManager.chains.get(bridgeInfo.from);
            const toChain = chainManager.chains.get(bridgeInfo.to);
            if (fromChain === undefined || toChain === undefined) {
                this.log.error(`[${bridgeInfo.name}] bridge's chain not configured`);
                continue;
            }
            const fromEndpoint = this.newBridgeEndpoint(bridgeInfo.fromAddress, bridgeInfo.type, fromChain);
            const toEndpoint = this.newBridgeEndpoint(bridgeInfo.toAddress, bridgeInfo.type, toChain);
            this.bridges.set(bridgeInfo.name, new Bridge(bridgeInfo, fromEndpoint, toEndpoint));
        }
        for (const bridgeInfo of v3BridgeInfos) {
            const fromChain = chainManager.chains.get(bridgeInfo.from);
            const toChain = chainManager.chains.get(bridgeInfo.to);
            if (fromChain === undefined || toChain === undefined) {
                this.log.error(`[${bridgeInfo.name}] bridge's chain not configured`);
                continue;
            }
            const fromEndpoint = this.newBridgeEndpoint(bridgeInfo.fromAddress, bridgeInfo.type, fromChain);
            const toEndpoint = this.newBridgeEndpoint(bridgeInfo.toAddress, bridgeInfo.type, toChain);
            this.v3bridges.set(bridgeInfo.name, new Bridge(bridgeInfo, fromEndpoint, toEndpoint));
        }
    }
    newBridgeEndpoint(address: string, type: string, chain: Chain): BridgeEndpoint {
        const key = chain.name + ":" + address;
        let endpoint = this.bridgeEndpointCache.get(key);
        if (!endpoint) {
            endpoint = new BridgeEndpoint(address, type, chain);
            this.bridgeEndpointCache.set(key, endpoint);
        }
        return endpoint;
    }
    // check dao
    async checkBridgeDao(version: string): Promise<void> {
        const bridges = version === 'v2' ? Array.from(this.bridges.values()) : Array.from(this.v3bridges.values());
        const count = this.bridges.size * 2;
        var index = 1;
        await this.log.progress2("waiting for check bridge dao", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[Math.floor(index / 2)];
            draw(index++, count, `[${bridge.name}]check source bridge: ${bridge.sourceBridge.address} dao: ${bridge.sourceBridge.chain.dao}`, '');
            let result = await bridge.sourceBridge.checkDao();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]source bridge's dao invalid`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check target bridge ${bridge.targetBridge.address} dao: ${bridge.targetBridge.chain.dao}`, '');
            result = await bridge.targetBridge.checkDao();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]target bridge's dao invalid`);
                return false;
            }
            return index < count;
        });
    }

    // check operator
    async checkBridgeOperator(): Promise<void> {
        const bridges = Array.from(this.bridges.values());
        const count = this.bridges.size * 2;
        var index = 1;
        await this.log.progress2("waiting for check bridge operator", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[Math.floor(index / 2)];
            draw(index++, count, `[${bridge.name}]check source bridge: ${bridge.sourceBridge.address} operator: ${bridge.sourceBridge.chain.operator}`, '');
            let result = await bridge.sourceBridge.checkOperator();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]source bridge's operator invalid`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check target bridge: ${bridge.targetBridge.address} operator: ${bridge.targetBridge.chain.operator}`, '');
            result = await bridge.targetBridge.checkOperator();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]target bridge's operator invalid`);
                return false;
            }
            return index < count;
        });
    }

    // check proxy admin
    async checkProxyAdmin(version: string): Promise<void> {
        const bridges = version === 'v2' ? Array.from(this.bridges.values()) : Array.from(this.v3bridges.values());
        const count = this.bridges.size * 2;
        var index = 1;
        await this.log.progress2("waiting for check bridge's proxyAdmin", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[Math.floor(index / 2)];
            draw(index++, count, `[${bridge.name}]check source bridge:${bridge.sourceBridge.address} proxyAdmin: ${bridge.sourceBridge.chain.proxyAdmin.address}`, '');
            let result = await bridge.sourceBridge.checkProxyAdmin();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]source bridge's proxyAmin invalid`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check target bridge:${bridge.targetBridge.address} proxyAdmin: ${bridge.targetBridge.chain.proxyAdmin.address}`, '');
            result = await bridge.targetBridge.checkProxyAdmin();
            if (!result) {
                draw(index, count, '', `[${bridge.name}]target bridge's proxyAmin invalid`);
                return false;
            }
            return index < count;
        });
    }

    // check messager service
    async checkMessagerService(): Promise<void> {
        const bridges = Array.from(this.bridges.values());
        const countEachTime = 6;
        const count = this.bridges.size * countEachTime;
        var index = 1;
        await this.log.progress2("waiting for check bridge's message service", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[Math.floor(index / countEachTime)];
            // check
            draw(index++, count, `[${bridge.name}]check source messager setting`, '');
            const sourceMessagerAddress = await bridge.getSourceMessagerFromChain();
            const sourceMessager = bridge.getSourceMessagerFromConfigure();
            if (sourceMessagerAddress !== sourceMessager?.address()) {
                draw(index, count, 'check source messager', `[${bridge.name}]source address not matched, ${sourceMessagerAddress} != ${sourceMessager?.address()}`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check target messager setting`, '');
            const targetMessagerAddress = await bridge.getTargetMessagerFromChain();
            const targetMessager = bridge.getTargetMessagerFromConfigure();
            if (targetMessagerAddress !== targetMessager?.address()) {
                draw(index, count, 'check target messager', `[${bridge.name}]target address not matched, ${targetMessagerAddress} != ${targetMessager?.address()}`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check messager connection source->target`, '');
            const srcConnected = await bridge.checkSourceConnectTarget();
            if (!srcConnected) {
                draw(index, count, 'check connect source->target', `[${bridge.name}]source not connected`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check messager connection target->source`, '');
            const dstConnected = await bridge.checkTargetConnectSource();
            if (!dstConnected) {
                draw(index, count, 'check connect target->source', `[${bridge.name}]target not connected`);
                return false;
            }
            // check app connection
            draw(index++, count, `[${bridge.name}]check app connection source->target`, '');
            const srcAppConnected = await bridge.checkSourceAppConnectTarget();
            if (!srcAppConnected) {
                draw(index, count, 'check app connect source->target', `[${bridge.name}]source app not connected`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check app connection target->source`, '');
            const dstAppConnected = await bridge.checkTargetAppConnectSource();
            if (!dstAppConnected) {
                draw(index, count, 'check app connect target->source', `[${bridge.name}]target app not connected`);
                return false;
            }
            return index < count;
        });
    }

    // check messager service
    async checkv3MessagerService(): Promise<void> {
        const bridges = Array.from(this.v3bridges.values());
        const countEachTime = 6;
        const count = this.v3bridges.size * countEachTime;
        var index = 1;
        await this.log.progress2("waiting for check bridge's message service", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[Math.floor(index / countEachTime)];
            // check
            draw(index++, count, `[${bridge.name}]check source messager setting`, '');
            const sourceMessagerAddress = await bridge.getSourceMessagerFromChain();
            const sourceMessager = bridge.getSourceMessagerFromConfigure();
            if (sourceMessagerAddress !== sourceMessager?.address()) {
                draw(index, count, 'check source messager', `[${bridge.name}]source address not matched, ${sourceMessagerAddress} != ${sourceMessager?.address()}`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check target messager setting`, '');
            const targetMessagerAddress = await bridge.getTargetMessagerFromChain();
            const targetMessager = bridge.getTargetMessagerFromConfigure();
            if (targetMessagerAddress !== targetMessager?.address()) {
                draw(index, count, 'check target messager', `[${bridge.name}]target address not matched, ${targetMessagerAddress} != ${targetMessager?.address()}`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check messager connection source->target`, '');
            const srcConnected = await bridge.checkSourceConnectTarget();
            if (!srcConnected) {
                draw(index, count, 'check connect source->target', `[${bridge.name}]source not connected`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check messager connection target->source`, '');
            const dstConnected = await bridge.checkTargetConnectSource();
            if (!dstConnected) {
                draw(index, count, 'check connect target->source', `[${bridge.name}]target not connected`);
                return false;
            }
            // check app connection
            draw(index++, count, `[${bridge.name}]check app connection source->target`, '');
            const srcAppConnected = await bridge.checkSourceAppConnectTarget();
            if (!srcAppConnected) {
                draw(index, count, 'check app connect source->target', `[${bridge.name}]source app not connected`);
                return false;
            }
            draw(index++, count, `[${bridge.name}]check app connection target->source`, '');
            const dstAppConnected = await bridge.checkTargetAppConnectSource();
            if (!dstAppConnected) {
                draw(index, count, 'check app connect target->source', `[${bridge.name}]target app not connected`);
                return false;
            }
            return index < count;
        });
    }

    // check token register info 
    // get all token symbols to check
    async checkv3TokenRegisterInfos(): Promise<void> {
        const bridges = Array.from(this.v3bridges.values());
        const count = bridges.reduce((sum, current) => sum + current.symbols!.length, 0);
        var index = 1;
        var bridgeIndex = 0;
        await this.log.progress2("waiting for check bridge's token register info", async (
            draw: (current: number, total: number, msg: string, err: string)=>void
        )=>{ 
            const bridge = bridges[bridgeIndex++];
            for (const symbol of bridge.symbols!) {
                draw(index++, count, `[${bridge.name}]check app bridge token ${symbol} register info`, '');
                const tokenRegistered = await bridge.sourceBridge.checkTokenInfo(symbol, bridge.targetBridge);
                if (!tokenRegistered) {
                    draw(index, count, 'check app bridge token', `[${bridge.name}-${symbol}] register invalid`);
                    return false;
                }
            }
            return index < count;
        });
    }
}