2169967530

Build Type

github

Committed by GitHub

Commit Message

Merge b735ab5fd into 0f9fbc54d

Pull Request Pull Request #104: Release v0.95.0

Run Details

700 of 715 branches covered (97.9%)

Branch coverage included in aggregate %.

1832 of 1945 new or added lines in 31 files covered. (94.19%)

36 existing lines in 8 files now uncovered.

10940 of 11110 relevant lines covered (98.47%)

101.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.28

/src/common/networks.ts

import {ChainId, type ChainIdTypeMap} from "@chainid";
import type {Token} from "@token";
import {Tokens}     from "@tokens";
import {SwapPools}  from "@swappools";

import type {ID, Distinct} from "@internal/types";

import {BridgeUtils} from "@bridge/bridgeutils";

import _ from "lodash";

export namespace Networks {
    type supportedTokenEdgeCase = {
        chainId: ChainId;
        token:   Token;
    }

    const tokenSupportChecks: supportedTokenEdgeCase[] = [
        {chainId: ChainId.ETH,       token: Tokens.WETH},
        {chainId: ChainId.ETH,       token: Tokens.NETH},
        {chainId: ChainId.AVALANCHE, token: Tokens.AVAX},
        {chainId: ChainId.AVALANCHE, token: Tokens.WAVAX},
        {chainId: ChainId.AVALANCHE, token: Tokens.AVWETH},
        {chainId: ChainId.MOONRIVER, token: Tokens.MOVR},
        {chainId: ChainId.MOONRIVER, token: Tokens.WMOVR},
        {chainId: ChainId.DFK,       token: Tokens.GAS_JEWEL},
        {chainId: ChainId.DFK,       token: Tokens.JEWEL},
    ];

    const checkWrappedToken = (chainId: ChainId, token: Token): boolean => {
        let check = tokenSupportChecks.find((check) =>
            check.chainId === chainId && check.token.isEqual(token)
        );
        
        return typeof check !== "undefined"
    }

    interface NetworkArgs {
        name:          string;
        chainId:       number;
        chainCurrency: string;
    }

    export class Network implements Distinct {
        readonly id:              ID;
        readonly name:            string;
        readonly chainCurrency:   string;
        readonly chainId:         ChainId;
        readonly tokens:          Token[];
        readonly tokenAddresses:  string[];

        constructor(args: NetworkArgs) {
            this.name          = args.name
            this.chainId       = args.chainId;
            this.chainCurrency = args.chainCurrency;

            this.tokens         = SwapPools.getAllSwappableTokensForNetwork(this.chainId);
            this.tokenAddresses = this.tokens.map((t) => t.address(this.chainId));

            this.id = Symbol(`${this.name}:${this.chainId}`);
        }

        /**
         * Returns true if the Bridge Zap contract for this network
         * is a L2BridgeZap contract.
         * Currently, Ethereum mainnet is the only network for which the
         * Bridge Zap contract is a NerveBridgeZap contract.
         */
        get zapIsL2BridgeZap(): boolean {
            return this.chainId !== ChainId.ETH && this.chainId !== ChainId.DFK
        }

        /**
         * Returns true if the passed token is available on this network.
         * @param {Token} token A {@link Token} object.
         */
        supportsToken(token: Token): boolean {
            let checkSymbol = token.symbol;

            const
                isEthish  = checkSymbol === "ETH" && (this.chainId === ChainId.ETH || BridgeUtils.isL2ETHChain(this.chainId)),
                isWrapped = checkWrappedToken(this.chainId, token);

            if (isEthish || isWrapped) {
                return true
            }

            let tokenAddr: string = token.address(this.chainId);

            return tokenAddr !== null
                ? this.tokenAddresses.includes(tokenAddr)
                : false
        }

        get bridgeableTokens(): Token[] {
            let tokens: Token[] = [];

            const chainGasToken = Tokens.gasTokenForChain(this.chainId);

            this.tokens.forEach(t => {
                if (!_.isNull(chainGasToken)) {
                    const gasWrapper = Tokens.gasTokenWrapper(chainGasToken);
                    if (gasWrapper.isEqual(t)) {
                        return
                    }
                }

                tokens.push(t);
            });

            return tokens
        }
    }

    export const ETH = new Network({
        name:          "Ethereum Mainnet",
        chainId:       ChainId.ETH,
        chainCurrency: "ETH"
    });

    export const OPTIMISM = new Network({
        name:          "Optimism",
        chainId:       ChainId.OPTIMISM,
        chainCurrency: "ETH"
    });

    export const CRONOS = new Network({
        name:          "Cronos",
        chainId:       ChainId.CRONOS,
        chainCurrency: "CRO"
    });

    export const BSC = new Network({
        name:          "Binance Smart Chain",
        chainId:       ChainId.BSC,
        chainCurrency: "BNB",
    });

    export const POLYGON = new Network({
        name:          "Polygon",
        chainId:       ChainId.POLYGON,
        chainCurrency: "MATIC",
    });

    export const FANTOM = new Network({
        name:          "Fantom",
        chainId:       ChainId.FANTOM,
        chainCurrency: "FTM",
    });

    export const BOBA = new Network({
       name:         "Boba Network",
       chainId:       ChainId.BOBA,
       chainCurrency: "ETH",
    });

    export const METIS = new Network({
        name:          "Metis",
        chainId:       ChainId.METIS,
        chainCurrency: "Metis",
    });

    export const MOONBEAM = new Network({
        name:          "Moonbeam",
        chainId:        ChainId.MOONBEAM,
        chainCurrency: "GLMR",
    });

    export const MOONRIVER = new Network({
        name:          "Moonriver",
        chainId:       ChainId.MOONRIVER,
        chainCurrency: "MOVR",
    });

    export const ARBITRUM = new Network({
        name:          "Arbitrum",
        chainId:       ChainId.ARBITRUM,
        chainCurrency: "ETH",
    });

    export const AVALANCHE = new Network({
        name:          "Avalanche C-Chain",
        chainId:       ChainId.AVALANCHE,
        chainCurrency: "AVAX",
    });

    export const DFK = new Network({
        name:          "DeFi Kingdoms",
        chainId:       ChainId.DFK,
        chainCurrency: "JEWEL"
    });

    export const AURORA = new Network({
        name:          "Aurora",
        chainId:       ChainId.AURORA,
        chainCurrency: "aETH",
    });

    export const HARMONY = new Network({
        name:          "Harmony",
        chainId:       ChainId.HARMONY,
        chainCurrency: "ONE",
    });

    const CHAINID_NETWORK_MAP: ChainIdTypeMap<Network> = {
        [ChainId.ETH]:        ETH,
        [ChainId.OPTIMISM]:   OPTIMISM,
        [ChainId.CRONOS]:     CRONOS,
        [ChainId.BSC]:        BSC,
        [ChainId.POLYGON]:    POLYGON,
        [ChainId.FANTOM]:     FANTOM,
        [ChainId.BOBA]:       BOBA,
        [ChainId.METIS]:      METIS,
        [ChainId.MOONBEAM]:   MOONBEAM,
        [ChainId.MOONRIVER]:  MOONRIVER,
        [ChainId.ARBITRUM]:   ARBITRUM,
        [ChainId.AVALANCHE]:  AVALANCHE,
        [ChainId.DFK]:        DFK,
        [ChainId.AURORA]:     AURORA,
        [ChainId.HARMONY]:    HARMONY,
    }

    export const networkName = (chainId: number): string => fromChainId(chainId).name

    export const fromChainId = (chainId: number): Network => CHAINID_NETWORK_MAP[chainId] ?? null

    /**
     * Returns true if the passed network supports the passed token.
     * @param {Network | number} network Either a {@link Network} instance, or the Chain ID of a supported network.
     * @param {Token} token A {@link Token} object.
     */
    export const networkSupportsToken = (network: Network | ChainId, token: Token): boolean =>
        (network instanceof Network
            ? network
            : fromChainId(network)
        ).supportsToken(token)

    export const supportedNetworks = (): Network[] => Object.values(CHAINID_NETWORK_MAP)
}

export const supportedNetworks = Networks.supportedNetworks;

1	import {ChainId, type ChainIdTypeMap} from "@chainid";	2✔
2	import type {Token} from "@token";	2✔
3	import {Tokens} from "@tokens";	2✔
4	import {SwapPools} from "@swappools";	2✔
5		2✔
6	import type {ID, Distinct} from "@internal/types";	2✔
7		2✔
8	import {BridgeUtils} from "@bridge/bridgeutils";	2✔
9		2✔
10	import _ from "lodash";	2✔
11		2✔
12	export namespace Networks {	12✔
13	type supportedTokenEdgeCase = {	12✔
14	chainId: ChainId;	12✔
15	token: Token;	12✔
16	}	12✔
17		12✔
18	const tokenSupportChecks: supportedTokenEdgeCase[] = [	12✔
19	{chainId: ChainId.ETH, token: Tokens.WETH},	12✔
20	{chainId: ChainId.ETH, token: Tokens.NETH},	12✔
21	{chainId: ChainId.AVALANCHE, token: Tokens.AVAX},	12✔
22	{chainId: ChainId.AVALANCHE, token: Tokens.WAVAX},	12✔
23	{chainId: ChainId.AVALANCHE, token: Tokens.AVWETH},	12✔
24	{chainId: ChainId.MOONRIVER, token: Tokens.MOVR},	12✔
25	{chainId: ChainId.MOONRIVER, token: Tokens.WMOVR},	12✔
26	{chainId: ChainId.DFK, token: Tokens.GAS_JEWEL},	12✔
27	{chainId: ChainId.DFK, token: Tokens.JEWEL},	12✔
28	];	12✔
29		12✔
30	const checkWrappedToken = (chainId: ChainId, token: Token): boolean => {	12✔
31	let check = tokenSupportChecks.find((check) =>	958✔
32	check.chainId === chainId && check.token.isEqual(token)	958✔
33	);	958✔
34		958✔
35	return typeof check !== "undefined"	958✔
36	}	958✔
37		12✔
38	interface NetworkArgs {	12✔
39	name: string;	12✔
40	chainId: number;	12✔
41	chainCurrency: string;	12✔
42	}	12✔
43		12✔
44	export class Network implements Distinct {	12✔
45	readonly id: ID;	12✔
46	readonly name: string;	12✔
47	readonly chainCurrency: string;	12✔
48	readonly chainId: ChainId;	12✔
49	readonly tokens: Token[];	12✔
50	readonly tokenAddresses: string[];	12✔
51		12✔
52	constructor(args: NetworkArgs) {	12✔
53	this.name = args.name	180✔
54	this.chainId = args.chainId;	180✔
55	this.chainCurrency = args.chainCurrency;	180✔
56		180✔
57	this.tokens = SwapPools.getAllSwappableTokensForNetwork(this.chainId);	180✔
58	this.tokenAddresses = this.tokens.map((t) => t.address(this.chainId));	180✔
59		180✔
60	this.id = Symbol(`${this.name}:${this.chainId}`);	180✔
61	}	180✔
62		12✔
63	/**	12✔
64	* Returns true if the Bridge Zap contract for this network	12✔
65	* is a L2BridgeZap contract.	12✔
66	* Currently, Ethereum mainnet is the only network for which the	12✔
67	* Bridge Zap contract is a NerveBridgeZap contract.	12✔
68	*/	12✔
69	get zapIsL2BridgeZap(): boolean {	12✔
NEW 70	return this.chainId !== ChainId.ETH && this.chainId !== ChainId.DFK	×
UNCOV 71	}	×
72		12✔
73	/**	12✔
74	* Returns true if the passed token is available on this network.	12✔
75	* @param {Token} token A {@link Token} object.	12✔
76	*/	12✔
77	supportsToken(token: Token): boolean {	12✔
78	let checkSymbol = token.symbol;	958✔
79		958✔
80	const	958✔
81	isEthish = checkSymbol === "ETH" && (this.chainId === ChainId.ETH \|\| BridgeUtils.isL2ETHChain(this.chainId)),	958✔
82	isWrapped = checkWrappedToken(this.chainId, token);	958✔
83		958✔
84	if (isEthish \|\| isWrapped) {	958✔
85	return true	194✔
86	}	194✔
87		764✔
88	let tokenAddr: string = token.address(this.chainId);	764✔
89		764✔
90	return tokenAddr !== null	764✔
91	? this.tokenAddresses.includes(tokenAddr)	941✔
92	: false	958✔
93	}	958✔
94		12✔
95	get bridgeableTokens(): Token[] {	12✔
96	let tokens: Token[] = [];	2✔
97		2✔
98	const chainGasToken = Tokens.gasTokenForChain(this.chainId);	2✔
99		2✔
100	this.tokens.forEach(t => {	2✔
101	if (!_.isNull(chainGasToken)) {	10✔
102	const gasWrapper = Tokens.gasTokenWrapper(chainGasToken);	10✔
103	if (gasWrapper.isEqual(t)) {	10✔
104	return	2✔
105	}	2✔
106	}	10✔
107		10✔
108	tokens.push(t);	10✔
109	});	2✔
110		2✔
111	return tokens	2✔
112	}	2✔
113	}	12✔
114		12✔
115	export const ETH = new Network({	12✔
116	name: "Ethereum Mainnet",	12✔
117	chainId: ChainId.ETH,	12✔
118	chainCurrency: "ETH"	12✔
119	});	12✔
120		12✔
121	export const OPTIMISM = new Network({	12✔
122	name: "Optimism",	12✔
123	chainId: ChainId.OPTIMISM,	12✔
124	chainCurrency: "ETH"	12✔
125	});	12✔
126		12✔
127	export const CRONOS = new Network({	12✔
128	name: "Cronos",	12✔
129	chainId: ChainId.CRONOS,	12✔
130	chainCurrency: "CRO"	12✔
131	});	12✔
132		12✔
133	export const BSC = new Network({	12✔
134	name: "Binance Smart Chain",	12✔
135	chainId: ChainId.BSC,	12✔
136	chainCurrency: "BNB",	12✔
137	});	12✔
138		12✔
139	export const POLYGON = new Network({	12✔
140	name: "Polygon",	12✔
141	chainId: ChainId.POLYGON,	12✔
142	chainCurrency: "MATIC",	12✔
143	});	12✔
144		12✔
145	export const FANTOM = new Network({	12✔
146	name: "Fantom",	12✔
147	chainId: ChainId.FANTOM,	12✔
148	chainCurrency: "FTM",	12✔
149	});	12✔
150		12✔
151	export const BOBA = new Network({	12✔
152	name: "Boba Network",	12✔
153	chainId: ChainId.BOBA,	12✔
154	chainCurrency: "ETH",	12✔
155	});	12✔
156		12✔
157	export const METIS = new Network({	12✔
158	name: "Metis",	12✔
159	chainId: ChainId.METIS,	12✔
160	chainCurrency: "Metis",	12✔
161	});	12✔
162		12✔
163	export const MOONBEAM = new Network({	12✔
164	name: "Moonbeam",	12✔
165	chainId: ChainId.MOONBEAM,	12✔
166	chainCurrency: "GLMR",	12✔
167	});	12✔
168		12✔
169	export const MOONRIVER = new Network({	12✔
170	name: "Moonriver",	12✔
171	chainId: ChainId.MOONRIVER,	12✔
172	chainCurrency: "MOVR",	12✔
173	});	12✔
174		12✔
175	export const ARBITRUM = new Network({	12✔
176	name: "Arbitrum",	12✔
177	chainId: ChainId.ARBITRUM,	12✔
178	chainCurrency: "ETH",	12✔
179	});	12✔
180		12✔
181	export const AVALANCHE = new Network({	12✔
182	name: "Avalanche C-Chain",	12✔
183	chainId: ChainId.AVALANCHE,	12✔
184	chainCurrency: "AVAX",	12✔
185	});	12✔
186		12✔
187	export const DFK = new Network({	12✔
188	name: "DeFi Kingdoms",	12✔
189	chainId: ChainId.DFK,	12✔
190	chainCurrency: "JEWEL"	12✔
191	});	12✔
192		12✔
193	export const AURORA = new Network({	12✔
194	name: "Aurora",	12✔
195	chainId: ChainId.AURORA,	12✔
196	chainCurrency: "aETH",	12✔
197	});	12✔
198		12✔
199	export const HARMONY = new Network({	12✔
200	name: "Harmony",	12✔
201	chainId: ChainId.HARMONY,	12✔
202	chainCurrency: "ONE",	12✔
203	});	12✔
204		12✔
205	const CHAINID_NETWORK_MAP: ChainIdTypeMap<Network> = {	12✔
206	[ChainId.ETH]: ETH,	12✔
207	[ChainId.OPTIMISM]: OPTIMISM,	12✔
208	[ChainId.CRONOS]: CRONOS,	12✔
209	[ChainId.BSC]: BSC,	12✔
210	[ChainId.POLYGON]: POLYGON,	12✔
211	[ChainId.FANTOM]: FANTOM,	12✔
212	[ChainId.BOBA]: BOBA,	12✔
213	[ChainId.METIS]: METIS,	12✔
214	[ChainId.MOONBEAM]: MOONBEAM,	12✔
215	[ChainId.MOONRIVER]: MOONRIVER,	12✔
216	[ChainId.ARBITRUM]: ARBITRUM,	12✔
217	[ChainId.AVALANCHE]: AVALANCHE,	12✔
218	[ChainId.DFK]: DFK,	12✔
219	[ChainId.AURORA]: AURORA,	12✔
220	[ChainId.HARMONY]: HARMONY,	12✔
221	}	12✔
222		12✔
223	export const networkName = (chainId: number): string => fromChainId(chainId).name	12✔
224		12✔
225	export const fromChainId = (chainId: number): Network => CHAINID_NETWORK_MAP[chainId] ?? null	12✔
226		12✔
227	/**	12✔
228	* Returns true if the passed network supports the passed token.	12✔
229	* @param {Network \| number} network Either a {@link Network} instance, or the Chain ID of a supported network.	12✔
230	* @param {Token} token A {@link Token} object.	12✔
231	*/	12✔
232	export const networkSupportsToken = (network: Network \| ChainId, token: Token): boolean =>	12✔
233	(network instanceof Network	12✔
234	? network	12✔
235	: fromChainId(network)	12✔
236	).supportsToken(token)	12✔
237		12✔
238	export const supportedNetworks = (): Network[] => Object.values(CHAINID_NETWORK_MAP)	12✔
239	}	12✔
240		2✔
241	export const supportedNetworks = Networks.supportedNetworks;	2✔

synapsecns / sdk / 2169967530

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous