2052179033

Build # 2052179033

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/synapsecns/sdk/commit/<a class=hub.com/synapsecns/sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/synapsecns/sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa9e0">2aa111b15<a href="https://github.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa9e0">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/synapsecns/sdk/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/synapsecns/sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa9e0&quot;&gt;2aa111b15&lt;/a&gt;&lt;a href=&quot;https://github.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa9e0&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd&lt;/a&gt;91aaa9e0">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/synapsecns/sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/synapsecns/sdk/commit/<a class="double-link" href="https://github.com/synapsecns/sdk/commit/11d2f921e47bf39db05a27b0aedd94616c87723d">11d2f921e</a><a href="https://github.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa9e0">&amp;quot;&amp;gt;11d2f921e&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;11d2f921e&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/synapsecns/sdk/commit/2aa111b15d8d5587fb5e28211d3b66cd91aaa&lt;/a&gt;9e0&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/synapsecns/sdk/commit/<a class="double-link" href="https://github.com/synapsecns/sdk/commit/4347af71c">4347af71c">4347af71c</a>

Pull Request Pull Request #99: Implement DFK mainnet

Run Details

541 of 560 branches covered (96.61%)

Branch coverage included in aggregate %.

223 of 324 new or added lines in 12 files covered. (68.83%)

13485 of 13610 relevant lines covered (99.08%)

59.17 hits per line

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

97.4

/src/bridge/bridgeutils.ts

import {Slippages} from "./slippages";

import {Tokens} from "@tokens";
import {ChainId}   from "@chainid";
import {SwapPools} from "@swappools";

import type {Token} from "@token";
import type {GenericZapBridgeContract, L2BridgeZapContract} from "@contracts";

import {Zero}      from "@ethersproject/constants";
import {BigNumber} from "@ethersproject/bignumber";
import {tokenSwitch} from "@internal/index";


export namespace BridgeUtils {
    export const L2_ETH_CHAINS: number[] = [
        ChainId.OPTIMISM,
        ChainId.FANTOM,
        ChainId.BOBA,
        ChainId.METIS,
        ChainId.MOONBEAM,
        ChainId.ARBITRUM,
        ChainId.AVALANCHE,
        ChainId.HARMONY,
    ];

    export const GAS_TOKEN_CHAINS: number[] = [
        ChainId.ETH,
        ChainId.OPTIMISM,
        ChainId.BOBA,
        ChainId.ARBITRUM,
        ChainId.AVALANCHE,
        ChainId.DFK
    ];

    export const isL2ETHChain          = (chainId: number): boolean => L2_ETH_CHAINS.includes(chainId);
    export const chainSupportsGasToken = (chainId: number): boolean => GAS_TOKEN_CHAINS.includes(chainId);

    interface DepositIfChainArgs {
        chainId:        number;
        tokens:         Token[];
        depositEth:     boolean;
        redeemChainIds: number[];
    }

    export const DepositIfChainTokens: DepositIfChainArgs[] = [
        {chainId: ChainId.FANTOM,    tokens: [Tokens.JUMP],   redeemChainIds: [ChainId.BSC],  depositEth: false},
        {chainId: ChainId.POLYGON,   tokens: [Tokens.NFD],    redeemChainIds: [],  depositEth: false},
        {chainId: ChainId.MOONRIVER, tokens: [Tokens.SOLAR],  redeemChainIds: [],  depositEth: false},
        {
            chainId:        ChainId.AVALANCHE,
            tokens:         [Tokens.AVAX, Tokens.WAVAX, Tokens.SYN_AVAX],
            redeemChainIds: [ChainId.MOONBEAM, ChainId.DFK],
            depositEth:     true
        },
        {chainId: ChainId.MOONRIVER, tokens: [Tokens.MOVR, Tokens.WMOVR], redeemChainIds: [ChainId.MOONBEAM], depositEth: true},
        {
            chainId:         ChainId.HARMONY,
            tokens:         [Tokens.XJEWEL],
            redeemChainIds: [ChainId.DFK],
            depositEth:      false,
        },
    ]

    interface BridgeTxArgs {
        slippageCustom:            string;
        slippageSelected:          string;
        infiniteApproval:          boolean;
        transactionDeadline:       number;
        bridgeTransactionDeadline: number;
    }

    export function getBridgeTxArgs(): BridgeTxArgs {
        return {
            slippageCustom:            null,
            slippageSelected:          Slippages.OneTenth,
            infiniteApproval:          true,
            transactionDeadline:       getTimeMinutesFromNow(10),
            bridgeTransactionDeadline: getTimeMinutesFromNow(60*24)
        }
    }

    interface BridgeSlippages {
        slippageSelected:                      string;
        transactionDeadline:                   number;
        bridgeTransactionDeadline:             number;
        minToSwapOrigin:                       BigNumber;
        minToSwapDest:                         BigNumber;
        minToSwapDestFromOrigin:               BigNumber;
        minToSwapOriginMediumSlippage:         BigNumber;
        minToSwapDestMediumSlippage:           BigNumber;
        minToSwapDestFromOriginMediumSlippage: BigNumber;
        minToSwapOriginHighSlippage:           BigNumber;
        minToSwapDestHighSlippage:             BigNumber;
        minToSwapDestFromOriginHighSlippage:   BigNumber;
    }

    export function getSlippages(amountFrom: BigNumber, amountTo: BigNumber): BridgeSlippages {
        const {
            slippageSelected,
            transactionDeadline,
            bridgeTransactionDeadline
        } = getBridgeTxArgs();

        const
            selectedGasArgs = slippageSelected,
            twoTenthGasArgs = Slippages.TwoTenth,
            quarterGasArgs  = Slippages.Quarter;

        const
            minToSwapOrigin         = Slippages.subtractSlippage(amountFrom, selectedGasArgs),
            minToSwapDest           = Slippages.subtractSlippage(amountTo, selectedGasArgs),
            minToSwapDestFromOrigin = Slippages.subtractSlippage(minToSwapDest, selectedGasArgs);

        const
            minToSwapOriginMediumSlippage         = Slippages.subtractSlippage(amountFrom, twoTenthGasArgs),
            minToSwapDestMediumSlippage           = Slippages.subtractSlippage(amountTo, twoTenthGasArgs),
            minToSwapDestFromOriginMediumSlippage = Slippages.subtractSlippage(minToSwapDestMediumSlippage, twoTenthGasArgs);

        const
            minToSwapOriginHighSlippage         = Slippages.subtractSlippage(amountFrom, quarterGasArgs),
            minToSwapDestHighSlippage           = Slippages.subtractSlippage(amountTo, quarterGasArgs),
            minToSwapDestFromOriginHighSlippage = Slippages.subtractSlippage(minToSwapDestHighSlippage, quarterGasArgs);

        return {
            slippageSelected,
            transactionDeadline,
            bridgeTransactionDeadline,
            minToSwapOrigin,
            minToSwapDest,
            minToSwapDestFromOrigin,
            minToSwapOriginMediumSlippage,
            minToSwapDestMediumSlippage,
            minToSwapDestFromOriginMediumSlippage,
            minToSwapOriginHighSlippage,
            minToSwapDestHighSlippage,
            minToSwapDestFromOriginHighSlippage,
        }
    }

    export const subBigNumSafe = (a: BigNumber, b: BigNumber): BigNumber => a.gt(b) ? a.sub(b) : Zero

    export const getTimeMinutesFromNow = (minutesFromNow: number): number =>
        Math.round((new Date().getTime() / 1000) + 60 * minutesFromNow)

    export interface BridgeTxParams {
        addressTo: string,
        chainIdTo: number,
        amountFrom: BigNumber,
    }

    export const makeEasyParams = (
        args: BridgeTxParams,
        chainId: number,
        t: Token
    ): [string, number, string, BigNumber] =>
        [args.addressTo, args.chainIdTo, t.address(chainId), args.amountFrom]

    export const makeEasySubParams = (
        args:    BridgeTxParams,
        chainId: number,
        t:       Token
    ): [string, number, string] => {
        let x = makeEasyParams(args, chainId, t);
        return [x[0], x[1], x[2]]
    }

    export const depositETHParams = (args: BridgeTxParams): [string, number, BigNumber] =>
        [args.addressTo, args.chainIdTo, args.amountFrom];

    export async function calculateSwapL2Zap(
        zapBridge:         GenericZapBridgeContract,
        intermediateToken: string,
        tokenIndexFrom:    number,
        tokenIndexTo:      number,
        amount:           BigNumber
    ): Promise<BigNumber> {
        return (zapBridge as L2BridgeZapContract).calculateSwap(
            intermediateToken,
            tokenIndexFrom,
            tokenIndexTo,
            amount
        )
    }

    export const isETHLikeToken = (t: Token): boolean =>
        [Tokens.WETH_E.id, Tokens.ONE_ETH.id, Tokens.FTM_ETH.id, Tokens.METIS_ETH.id].includes(t.id)

    export const overrides = (value: BigNumber): any => ({value})

    /**
     * Switch t1 with t3 is t1 is t2
     * @param {Token} t1 token being checked
     * @param {Token} t2 token to check t1 against
     * @param {Token} t3 token to return instead of t1 if t1 equals t2
     */
    const checkReplaceToken = (t1: Token, t2: Token, t3: Token): Token => t1.isEqual(t2) ? t3 : t1;
    export const checkReplaceTokens = (
        check:   Token,
        replace: Token
    ): ((t1: Token, t2: Token) => [Token, Token]) =>
        (t1: Token, t2: Token) => [
            checkReplaceToken(t1, check, replace),
            checkReplaceToken(t2, check, replace)
        ];

    function findSymbol(t1: Token, t2: Token, chainId: number): boolean {
        let compare: Token = t2;
        switch (tokenSwitch(t2)) {
            case Tokens.WETH_E:
                compare = Tokens.AVWETH;
                break;
            case Tokens.WETH:
                compare = Tokens.WETH;
                break;
            case Tokens.WJEWEL:
                if (chainId === ChainId.HARMONY) {
                    compare = Tokens.SYN_JEWEL;
                } else {
                    compare = t2.underlyingToken;
                }
                break;
            default:
                if (t2.isWrapperToken && t2.underlyingToken) {
                    compare = t2.underlyingToken;
                }
                break;
        }

        return t1.isEqual(compare);
    }

    export function makeTokenArgs(chainId: number, t: Token): [Token[], number] {
        let
            toks: Token[] = SwapPools.bridgeSwappableMap[chainId].swappableSwapGroups[t.swapType].poolTokens,
            idx  = toks.findIndex((tok: Token) => findSymbol(tok, t, chainId));

        return [toks, idx]
    }
}

1	import {Slippages} from "./slippages";	2✔
2		2✔
3	import {Tokens} from "@tokens";	2✔
4	import {ChainId} from "@chainid";	2✔
5	import {SwapPools} from "@swappools";	2✔
6		2✔
7	import type {Token} from "@token";	2✔
8	import type {GenericZapBridgeContract, L2BridgeZapContract} from "@contracts";	2✔
9		2✔
10	import {Zero} from "@ethersproject/constants";	2✔
11	import {BigNumber} from "@ethersproject/bignumber";	2✔
12	import {tokenSwitch} from "@internal/index";	2✔
13		2✔
14		2✔
15	export namespace BridgeUtils {	14✔
16	export const L2_ETH_CHAINS: number[] = [	14✔
17	ChainId.OPTIMISM,	14✔
18	ChainId.FANTOM,	14✔
19	ChainId.BOBA,	14✔
20	ChainId.METIS,	14✔
21	ChainId.MOONBEAM,	14✔
22	ChainId.ARBITRUM,	14✔
23	ChainId.AVALANCHE,	14✔
24	ChainId.HARMONY,	14✔
25	];	14✔
26		14✔
27	export const GAS_TOKEN_CHAINS: number[] = [	14✔
28	ChainId.ETH,	14✔
29	ChainId.OPTIMISM,	14✔
30	ChainId.BOBA,	14✔
31	ChainId.ARBITRUM,	14✔
32	ChainId.AVALANCHE,	14✔
33	ChainId.DFK	14✔
34	];	14✔
35		14✔
36	export const isL2ETHChain = (chainId: number): boolean => L2_ETH_CHAINS.includes(chainId);	14✔
37	export const chainSupportsGasToken = (chainId: number): boolean => GAS_TOKEN_CHAINS.includes(chainId);	14✔
38		14✔
39	interface DepositIfChainArgs {	14✔
40	chainId: number;	14✔
41	tokens: Token[];	14✔
42	depositEth: boolean;	14✔
43	redeemChainIds: number[];	14✔
44	}	14✔
45		14✔
46	export const DepositIfChainTokens: DepositIfChainArgs[] = [	14✔
47	{chainId: ChainId.FANTOM, tokens: [Tokens.JUMP], redeemChainIds: [ChainId.BSC], depositEth: false},	14✔
48	{chainId: ChainId.POLYGON, tokens: [Tokens.NFD], redeemChainIds: [], depositEth: false},	14✔
49	{chainId: ChainId.MOONRIVER, tokens: [Tokens.SOLAR], redeemChainIds: [], depositEth: false},	14✔
50	{	14✔
51	chainId: ChainId.AVALANCHE,	14✔
52	tokens: [Tokens.AVAX, Tokens.WAVAX, Tokens.SYN_AVAX],	14✔
53	redeemChainIds: [ChainId.MOONBEAM, ChainId.DFK],	14✔
54	depositEth: true	14✔
55	},	14✔
56	{chainId: ChainId.MOONRIVER, tokens: [Tokens.MOVR, Tokens.WMOVR], redeemChainIds: [ChainId.MOONBEAM], depositEth: true},	14✔
57	{	14✔
58	chainId: ChainId.HARMONY,	14✔
59	tokens: [Tokens.XJEWEL],	14✔
60	redeemChainIds: [ChainId.DFK],	14✔
61	depositEth: false,	14✔
62	},	14✔
63	]	14✔
64		14✔
65	interface BridgeTxArgs {	14✔
66	slippageCustom: string;	14✔
67	slippageSelected: string;	14✔
68	infiniteApproval: boolean;	14✔
69	transactionDeadline: number;	14✔
70	bridgeTransactionDeadline: number;	14✔
71	}	14✔
72		14✔
73	export function getBridgeTxArgs(): BridgeTxArgs {	14✔
74	return {	244✔
75	slippageCustom: null,	244✔
76	slippageSelected: Slippages.OneTenth,	244✔
77	infiniteApproval: true,	244✔
78	transactionDeadline: getTimeMinutesFromNow(10),	244✔
79	bridgeTransactionDeadline: getTimeMinutesFromNow(60*24)	244✔
80	}	244✔
81	}	244✔
82		14✔
83	interface BridgeSlippages {	14✔
84	slippageSelected: string;	14✔
85	transactionDeadline: number;	14✔
86	bridgeTransactionDeadline: number;	14✔
87	minToSwapOrigin: BigNumber;	14✔
88	minToSwapDest: BigNumber;	14✔
89	minToSwapDestFromOrigin: BigNumber;	14✔
90	minToSwapOriginMediumSlippage: BigNumber;	14✔
91	minToSwapDestMediumSlippage: BigNumber;	14✔
92	minToSwapDestFromOriginMediumSlippage: BigNumber;	14✔
93	minToSwapOriginHighSlippage: BigNumber;	14✔
94	minToSwapDestHighSlippage: BigNumber;	14✔
95	minToSwapDestFromOriginHighSlippage: BigNumber;	14✔
96	}	14✔
97		14✔
98	export function getSlippages(amountFrom: BigNumber, amountTo: BigNumber): BridgeSlippages {	14✔
99	const {	244✔
100	slippageSelected,	244✔
101	transactionDeadline,	244✔
102	bridgeTransactionDeadline	244✔
103	} = getBridgeTxArgs();	244✔
104		244✔
105	const	244✔
106	selectedGasArgs = slippageSelected,	244✔
107	twoTenthGasArgs = Slippages.TwoTenth,	244✔
108	quarterGasArgs = Slippages.Quarter;	244✔
109		244✔
110	const	244✔
111	minToSwapOrigin = Slippages.subtractSlippage(amountFrom, selectedGasArgs),	244✔
112	minToSwapDest = Slippages.subtractSlippage(amountTo, selectedGasArgs),	244✔
113	minToSwapDestFromOrigin = Slippages.subtractSlippage(minToSwapDest, selectedGasArgs);	244✔
114		244✔
115	const	244✔
116	minToSwapOriginMediumSlippage = Slippages.subtractSlippage(amountFrom, twoTenthGasArgs),	244✔
117	minToSwapDestMediumSlippage = Slippages.subtractSlippage(amountTo, twoTenthGasArgs),	244✔
118	minToSwapDestFromOriginMediumSlippage = Slippages.subtractSlippage(minToSwapDestMediumSlippage, twoTenthGasArgs);	244✔
119		244✔
120	const	244✔
121	minToSwapOriginHighSlippage = Slippages.subtractSlippage(amountFrom, quarterGasArgs),	244✔
122	minToSwapDestHighSlippage = Slippages.subtractSlippage(amountTo, quarterGasArgs),	244✔
123	minToSwapDestFromOriginHighSlippage = Slippages.subtractSlippage(minToSwapDestHighSlippage, quarterGasArgs);	244✔
124		244✔
125	return {	244✔
126	slippageSelected,	244✔
127	transactionDeadline,	244✔
128	bridgeTransactionDeadline,	244✔
129	minToSwapOrigin,	244✔
130	minToSwapDest,	244✔
131	minToSwapDestFromOrigin,	244✔
132	minToSwapOriginMediumSlippage,	244✔
133	minToSwapDestMediumSlippage,	244✔
134	minToSwapDestFromOriginMediumSlippage,	244✔
135	minToSwapOriginHighSlippage,	244✔
136	minToSwapDestHighSlippage,	244✔
137	minToSwapDestFromOriginHighSlippage,	244✔
138	}	244✔
139	}	244✔
140		14✔
141	export const subBigNumSafe = (a: BigNumber, b: BigNumber): BigNumber => a.gt(b) ? a.sub(b) : Zero	14✔
142		14✔
143	export const getTimeMinutesFromNow = (minutesFromNow: number): number =>	14✔
144	Math.round((new Date().getTime() / 1000) + 60 * minutesFromNow)	488✔
145		14✔
146	export interface BridgeTxParams {	14✔
147	addressTo: string,	14✔
148	chainIdTo: number,	14✔
149	amountFrom: BigNumber,	14✔
150	}	14✔
151		14✔
152	export const makeEasyParams = (	14✔
153	args: BridgeTxParams,	566✔
154	chainId: number,	566✔
155	t: Token	566✔
156	): [string, number, string, BigNumber] =>	566✔
157	[args.addressTo, args.chainIdTo, t.address(chainId), args.amountFrom]	566✔
158		14✔
159	export const makeEasySubParams = (	14✔
160	args: BridgeTxParams,	144✔
161	chainId: number,	144✔
162	t: Token	144✔
163	): [string, number, string] => {	144✔
164	let x = makeEasyParams(args, chainId, t);	144✔
165	return [x[0], x[1], x[2]]	144✔
166	}	144✔
167		14✔
168	export const depositETHParams = (args: BridgeTxParams): [string, number, BigNumber] =>	14✔
169	[args.addressTo, args.chainIdTo, args.amountFrom];	14✔
170		14✔
171	export async function calculateSwapL2Zap(	14✔
172	zapBridge: GenericZapBridgeContract,	168✔
173	intermediateToken: string,	168✔
174	tokenIndexFrom: number,	168✔
175	tokenIndexTo: number,	168✔
176	amount: BigNumber	168✔
177	): Promise<BigNumber> {	168✔
178	return (zapBridge as L2BridgeZapContract).calculateSwap(	168✔
179	intermediateToken,	168✔
180	tokenIndexFrom,	168✔
181	tokenIndexTo,	168✔
182	amount	168✔
183	)	168✔
184	}	168✔
185		14✔
186	export const isETHLikeToken = (t: Token): boolean =>	14✔
187	[Tokens.WETH_E.id, Tokens.ONE_ETH.id, Tokens.FTM_ETH.id, Tokens.METIS_ETH.id].includes(t.id)	120✔
188		14✔
189	export const overrides = (value: BigNumber): any => ({value})	14✔
190		14✔
191	/**	14✔
192	* Switch t1 with t3 is t1 is t2	14✔
193	* @param {Token} t1 token being checked	14✔
194	* @param {Token} t2 token to check t1 against	14✔
195	* @param {Token} t3 token to return instead of t1 if t1 equals t2	14✔
196	*/	14✔
197	const checkReplaceToken = (t1: Token, t2: Token, t3: Token): Token => t1.isEqual(t2) ? t3 : t1;	14✔
198	export const checkReplaceTokens = (	14✔
199	check: Token,	246✔
200	replace: Token	246✔
201	): ((t1: Token, t2: Token) => [Token, Token]) =>	246✔
202	(t1: Token, t2: Token) => [	246✔
203	checkReplaceToken(t1, check, replace),	246✔
204	checkReplaceToken(t2, check, replace)	246✔
205	];	246✔
206		14✔
207	function findSymbol(t1: Token, t2: Token, chainId: number): boolean {	14✔
208	let compare: Token = t2;	1,868✔
209	switch (tokenSwitch(t2)) {	1,868✔
210	case Tokens.WETH_E:	1,868✔
211	compare = Tokens.AVWETH;	182✔
212	break;	182✔
213	case Tokens.WETH:	1,868✔
214	compare = Tokens.WETH;	270✔
215	break;	270✔
216	case Tokens.WJEWEL:	1,868!
NEW 217	if (chainId === ChainId.HARMONY) {	×
NEW 218	compare = Tokens.SYN_JEWEL;	×
NEW 219	} else {	×
NEW 220	compare = t2.underlyingToken;	×
NEW 221	}	×
NEW 222	break;	×
223	default:	1,868✔
224	if (t2.isWrapperToken && t2.underlyingToken) {	1,416✔
225	compare = t2.underlyingToken;	56✔
226	}	56✔
227	break;	1,416✔
228	}	1,868✔
229		1,868✔
230	return t1.isEqual(compare);	1,868✔
231	}	1,868✔
232		14✔
233	export function makeTokenArgs(chainId: number, t: Token): [Token[], number] {	14✔
234	let	1,228✔
235	toks: Token[] = SwapPools.bridgeSwappableMap[chainId].swappableSwapGroups[t.swapType].poolTokens,	1,228✔
236	idx = toks.findIndex((tok: Token) => findSymbol(tok, t, chainId));	1,228✔
237		1,228✔
238	return [toks, idx]	1,228✔
239	}	1,228✔
240	}	14✔

synapsecns / sdk / 2052179033

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