synapsecns / sdk / 2276935185

2276935185

Pull #104

github

GitHub 
<a href="https://github.com/synapsecns/sdk/commit/<a class=hub.com/synapsecns/sdk/commit/0af7853bef1d26f62e45d4654f4cfe32ee56be18">0af7853be<a href="https://github.com/synapsecns/sdk/commit/0af7853bef1d26f62e45d4654f4cfe32ee56be18">">Merge </a><a class="double-link" href="https://github.com/synapsecns/sdk/commit/<a class="double-link" href="https://github.com/synapsecns/sdk/commit/8459ce2b36cb9cbe82ae98028c04d74a2c051c86">8459ce2b3</a>">8459ce2b3</a><a href="https://github.com/synapsecns/sdk/commit/0af7853bef1d26f62e45d4654f4cfe32ee56be18"> into 0f9fbc54d">0f9fbc54d</a>
Pull Request #104: Release v0.95.1

809 of 834 branches covered (97.0%)

Branch coverage included in aggregate %.

3173 of 3210 new or added lines in 34 files covered. (98.85%)

49 existing lines in 10 files now uncovered.

12103 of 12204 relevant lines covered (99.17%)

54.49 hits per line

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

99.0
/src/swappools.ts
1 
import {isEqual} from "lodash-es";
2✔
2 



2✔





3



import {Tokens} from "@tokens";




2✔





4






2✔






5



import {




2✔






6



    ChainId,




2✔






7



    supportedChainIds,




2✔






8



    type ChainIdTypeMap




2✔






9



} from "@chainid";




2✔





10






2✔





11



import type {




2✔





12



    AddressMap,




2✔





13



    DecimalsMap




2✔





14



} from "@common/types";




2✔





15






2✔






16



import {




2✔






17



    BaseToken,




2✔






18



    type IBaseToken,




2✔






19



    type Token




2✔






20



} from "@token";




2✔





21






2✔






22



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




2✔





23



import {




2✔






24



    SwapType,




2✔






25



    type SwapTypeMap




2✔






26



} from "@internal/swaptype";




2✔





27






2✔






28



import {BigNumber} from "@ethersproject/bignumber";




2✔






29



import type {BigNumberish} from "@ethersproject/bignumber";




2✔





30






2✔





31



export namespace SwapPools {





12✔





32



    function moveFirstToLast(arr: Token[]) {





12✔





33



        return [




180✔





34



            ...arr.slice(1),




180✔





35



            arr[0]




180✔





36



        ]




180✔





37



    }




180✔





38






12✔





39



    export interface LPToken {




12✔






40



        readonly poolTokens: Token[];




12✔






41



        readonly swapType:   SwapType;




12✔






42



    }




12✔






43






12✔






44



    export type PoolTokensAmountsMap = {




12✔






45



        [k: string]: BigNumberish;




12✔





46



    }




12✔





47






12✔





48



    export interface SwapPoolToken extends IBaseToken, LPToken {




12✔





49



        readonly baseToken:       BaseToken;




12✔






50



        readonly chainId:         number;




12✔





51



        readonly poolId:          number;




12✔





52



        readonly poolName:        string;




12✔





53



        readonly poolType:        string;




12✔





54



        readonly nativeTokens?:   Token[];




12✔





55



        readonly depositTokens?:  Token[];




12✔





56



        readonly swapAddress:     string;




12✔





57



        readonly swapETHAddress:  string | null;




12✔





58






12✔





59



        readonly poolTokensForBridgeSwaps: Token[]




12✔






60






12✔






61



        liquidityAmountsMap:     () => PoolTokensAmountsMap;




12✔






62



        liquidityAmountsFromMap: (m: PoolTokensAmountsMap) => BigNumber[];




12✔





63



    }




12✔





64






12✔





65



    interface SwapTokenArgs {




12✔





66



        name:           string;




12✔





67



        symbol:         string;




12✔






68



        chainId:        number;




12✔





69



        decimals:       number | DecimalsMap;




12✔





70



        addresses:      AddressMap;




12✔





71



        poolId:         number;




12✔





72



        poolName:       string;




12✔





73



        poolType:       SwapType;




12✔





74



        poolTokens:     Token[];




12✔





75



        swapAddress:    string;




12✔





76



    }




12✔





77






12✔





78



    interface ETHSwapTokenArgs extends SwapTokenArgs {




12✔





79



        nativeTokens?:     Token[];




12✔





80



        depositTokens?:    Token[];




12✔





81



        swapEthAddress?:   string;




12✔





82



    }




12✔





83






12✔





84



    interface makeSwapTokenArgs {




12✔





85



        chainId:      number;




12✔





86



        netName:      string;




12✔





87



        address:      string;




12✔





88



        swapAddress:  string;




12✔





89



        poolId:       number;




12✔





90



        poolTokens:   Token[];




12✔





91



        notLP?:       boolean;




12✔





92



        symbol?:      string;




12✔





93



    }




12✔





94






12✔





95



    interface makeETHSwapTokenArgs extends makeSwapTokenArgs {




12✔





96



        swapETHAddress?: string;




12✔





97



        poolName?:       string;




12✔





98



        nativeTokens?:   Token[];




12✔





99



        depositTokens?:  Token[];




12✔





100



    }




12✔





101






12✔





102



    const makeSwapToken = (args: makeSwapTokenArgs): SwapToken =>





12✔





103



        new SwapToken({




144✔






104



            name:           `Synapse nUSD LP Token${args.netName != "BSC" ? ` ${args.netName}` : ""}`,





144✔






105



            poolName:       `${args.netName} Stableswap Pool `,




144✔





106



            symbol:          args.symbol ?? ((args.notLP ?? false) ? "nUSD" : "nUSD-LP"),





144!






107



            chainId:         args.chainId,




144✔






108



            decimals:        18,




144✔





109



            poolId:          args.poolId,




144✔





110



            poolTokens:      args.poolTokens,




144✔





111



            addresses:     {[args.chainId]: args.address},




144✔





112



            swapAddress:     args.swapAddress,




144✔





113



            poolType:        SwapType.USD,




144✔





114



        })




144✔





115






12✔





116



    const makeETHSwapToken = (args: makeETHSwapTokenArgs): ETHSwapToken =>





12✔





117



        new ETHSwapToken({




84✔






118



            name:            `Synapse ${args.poolName ?? "ETH"} LP Token ${args.netName}`,





84✔






119



            poolName:        `${args.netName} ${args.poolName ?? "ETH"} Pool `,





84✔





120



            symbol:           args.symbol ?? "nETH-LP",





84!






121



            chainId:          args.chainId,




84✔






122



            decimals:         18,




84✔





123



            poolId:           args.poolId,




84✔





124



            addresses:      {[args.chainId]: args.address},




84✔





125



            swapAddress:      args.swapAddress,




84✔





126



            swapEthAddress:   args.swapETHAddress,




84✔





127



            poolTokens:       args.poolTokens,




84✔





128



            nativeTokens:     args.nativeTokens,




84✔





129



            depositTokens:    args.depositTokens,




84✔





130



            poolType:         SwapType.ETH,




84✔





131



        })




84✔





132






12✔





133



    export class SwapToken implements SwapPoolToken {





12✔





134



        readonly baseToken: BaseToken;




12✔






135



        readonly chainId:   number;




12✔





136






12✔





137



        readonly poolId:   number;




12✔





138



        readonly poolName: string;




12✔





139



        readonly poolType: SwapType;




12✔





140






12✔





141



        readonly poolTokens: Token[];




12✔





142






12✔





143



        readonly swapAddress: string;




12✔





144






12✔





145



        constructor(args: SwapTokenArgs) {





12✔





146



            this.baseToken = new BaseToken({




252✔





147



                name:      args.name,




252✔





148



                symbol:    args.symbol,




252✔





149



                decimals:  args.decimals,




252✔





150



                addresses: args.addresses,




252✔





151



                swapType:  args.poolType




252✔





152



            });




252✔





153






252✔






154



            this.chainId     = args.chainId;




252✔






155



            this.poolId      = args.poolId;




252✔






156



            this.poolName    = args.poolName;




252✔






157



            this.poolType    = args.poolType;




252✔





158



            this.swapAddress = args.swapAddress;




252✔






159



            this.poolTokens  = args.poolTokens;




252✔





160



        }




252✔





161






12✔





162



        get id(): ID {





12✔





163



            return this.baseToken.id




6✔





164



        }




6✔





165






12✔





166



        get name(): string {





12✔





167



           return this.baseToken.name




36✔





168



        }




36✔





169






12✔





170



        get symbol(): string {





12✔





171



            return this.baseToken.symbol




6✔





172



        }




6✔





173






12✔





174



        get addresses(): {[k: number]: string} {





12✔





175



            return this.baseToken.addresses




4✔





176



        }




4✔





177






12✔





178



        get swapType(): SwapType {





12✔





179



            return this.baseToken.swapType




332✔





180



        }




332✔





181






12✔





182



        address(chainId: number): string|null {





12✔





183



            return this.baseToken.address(chainId)




316✔





184



        }




316✔





185






12✔





186



        decimals(chainId: number): number | null {





12✔





187



            return this.baseToken.decimals(chainId)




6✔





188



        }




6✔





189






12✔





190



        get poolTokensForBridgeSwaps(): Token[] {





12✔






191



            return moveFirstToLast(this.poolTokens)




132✔





192



        }




132✔





193






12✔





194



        get swapETHAddress(): string | null {





12✔





195



            return null




22✔





196



        }




22✔






197






12✔






198



        liquidityAmountsMap(): PoolTokensAmountsMap {





12✔






199



            let m: PoolTokensAmountsMap = {};




42✔






200






42✔






201



            for (const t of this.poolTokens) {





42✔






202



                m[t.symbol] = BigNumber.from(0);




126✔






203



            }




126✔






204






42✔






205



            return m




42✔






206



        }




42✔






207






12✔






208



        liquidityAmountsFromMap(m: PoolTokensAmountsMap): BigNumber[] {





12✔






209



            let amounts: BigNumber[] = new Array<BigNumber>(this.poolTokens.length);




36✔






210






36✔






211



            const mapKeys = Object.keys(m);




36✔






212



            const wantMapKeys = Object.keys(this.liquidityAmountsMap());




36✔






213






36✔






214



            if (!isEqual(mapKeys, wantMapKeys)) {





36!






NEW


215



                const err = new Error(`expected passed PoolTokensAmountsMap to have keys ${wantMapKeys}; got ${mapKeys}`);




×








NEW


216



                console.error(err);




×








NEW


217



                return amounts;




×








NEW


218



            }




×








219






36✔






220



            mapKeys.forEach((k, idx) => {





36✔






221



                const amt = m[k];




108✔






222






108✔






223



                let realAmt: BigNumber;




108✔






224






108✔






225



                if (amt instanceof BigNumber) {




108✔






226



                    realAmt = amt as BigNumber;




108✔






227



                } else {





108!






NEW


228



                    const token = this.poolTokens[idx];




×








NEW


229



                    realAmt = token.etherToWei(amt, this.chainId);




×








NEW


230



                }




×








231






108✔






232



                amounts[idx] = realAmt;




108✔






233



            });




36✔






234






36✔






235



            return amounts




36✔






236



        }




36✔





237



    }




12✔





238






12✔





239



    export class ETHSwapToken extends SwapToken {





12✔





240



        readonly nativeTokens:  Token[];




12✔





241



        readonly depositTokens: Token[];




12✔





242






12✔





243



        private readonly _swapETHAddress: string | null = null;




12✔





244






12✔





245



        constructor(args: ETHSwapTokenArgs) {





12✔





246



            let {




84✔





247



                swapEthAddress,




84✔





248



                nativeTokens,




84✔





249



                depositTokens,




84✔





250



                ...constructorArgs




84✔





251



            } = args;




84✔





252






84✔





253



            super(constructorArgs);




84✔





254






84✔





255



            if (swapEthAddress) {





84✔





256



                this._swapETHAddress = args.swapEthAddress;




48✔





257



            }




48✔





258






84✔





259



            if (args.nativeTokens) {





84✔





260



                this.nativeTokens = args.nativeTokens;




60✔





261



            }




60✔





262






84✔





263



            if (args.depositTokens) {





84✔





264



                this.depositTokens = args.depositTokens;




24✔





265



            }




24✔





266



        }




84✔





267






12✔





268



        get poolTokensForBridgeSwaps(): Token[] {





12✔





269



            return this.depositTokens?.length > 0





48✔





270



                ? moveFirstToLast(this.depositTokens)





48✔






271



                : moveFirstToLast(this.poolTokens)





48✔





272



        }




48✔





273






12✔





274



        get swapETHAddress(): string | null {





12✔





275



            return this._swapETHAddress




14✔





276



        }




14✔





277



    }




12✔





278






12✔





279



    const USDPoolTokens = (tok: Token = Tokens.DAI, nUSD: boolean = true): Token[] => [





12✔





280



        ...(nUSD ? [Tokens.NUSD] : []),





12✔





281



        ...(tok === null ? [] : [tok]),





12✔





282



        Tokens.USDC,




12✔





283



        Tokens.USDT,




12✔





284



    ]




12✔





285






12✔





286



    const




12✔





287



        ETHTokensPool = (t: Token): Token[] => [Tokens.NETH, t],





12✔





288



        WETHTokenPool: Token[] = ETHTokensPool(Tokens.WETH),




12✔





289



        ETHTokenPool:  Token[] = ETHTokensPool(Tokens.ETH);




12✔





290






12✔





291



    export const ETH_POOL_SWAP_TOKEN = makeSwapToken({




12✔





292



        chainId:     ChainId.ETH,




12✔





293



        address:     Tokens.NUSD.address(ChainId.ETH),




12✔





294



        netName:     "Ethereum",




12✔





295



        poolId:       420,




12✔





296



        swapAddress: "0x1116898DdA4015eD8dDefb84b6e8Bc24528Af2d8",




12✔





297



        poolTokens:   USDPoolTokens(Tokens.DAI, false),




12✔





298



        notLP:        true




12✔





299



    });




12✔





300






12✔






301



    export const OPTIMISM_POOL_SWAP_TOKEN = makeSwapToken({




12✔






302



        chainId:     ChainId.OPTIMISM,




12✔






303



        address:     "0x2c6d91accC5Aa38c84653F28A80AEC69325BDd12",




12✔






304



        netName:     "Optimism",




12✔






305



        poolId:      1,




12✔






306



        swapAddress: "0xF44938b0125A6662f9536281aD2CD6c499F22004",




12✔






307



        poolTokens:  [Tokens.NUSD, Tokens.USDC],




12✔






308



    });




12✔






309






12✔





310



    export const OPTIMISM_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





311



        chainId:         ChainId.OPTIMISM,




12✔





312



        address:        "0x4619a06ddd3b8f0f951354ec5e75c09cd1cd1aef",




12✔





313



        netName:        "Optimism",




12✔





314



        poolId:          0,




12✔





315



        swapAddress:    "0xE27BFf97CE92C3e1Ff7AA9f86781FDd6D48F5eE9",




12✔





316



        swapETHAddress: "0x8c7d5f8A8e154e1B59C92D8FB71314A43F32ef7B",




12✔





317



        poolTokens:      WETHTokenPool,




12✔





318



        nativeTokens:    ETHTokenPool,




12✔





319



    });




12✔





320






12✔






321



    export const CRONOS_POOL_SWAP_TOKEN = makeSwapToken({




12✔






322



        chainId:     ChainId.CRONOS,




12✔






323



        address:     "0xd5Da35646A79C42a0BAB148656192A22e8CBfad6",




12✔






324



        netName:     "Cronos",




12✔






325



        poolId:      1,




12✔






326



        swapAddress: "0xCb6674548586F20ca39C97A52A0ded86f48814De",




12✔






327



        poolTokens:  [




12✔






328



            Tokens.NUSD,




12✔






329



            Tokens.USDC,




12✔






330



        ],




12✔






331



    });




12✔






332






12✔





333



    export const BSC_POOL_SWAP_TOKEN = makeSwapToken({




12✔





334



        chainId:      ChainId.BSC,




12✔





335



        address:     "0xa4b7Bc06EC817785170C2DbC1dD3ff86CDcdcc4C",




12✔





336



        netName:     "BSC",




12✔





337



        poolId:       1,




12✔





338



        swapAddress: "0x28ec0B36F0819ecB5005cAB836F4ED5a2eCa4D13",




12✔





339



        poolTokens:   USDPoolTokens(Tokens.BUSD),




12✔





340



    });




12✔





341






12✔





342



    export const POLYGON_POOL_SWAP_TOKEN = makeSwapToken({




12✔





343



        chainId:      ChainId.POLYGON,




12✔





344



        address:     "0x7479e1bc2f2473f9e78c89b4210eb6d55d33b645",




12✔





345



        netName:     "Polygon",




12✔





346



        poolId:       1,




12✔





347



        swapAddress: "0x85fCD7Dd0a1e1A9FCD5FD886ED522dE8221C3EE5",




12✔





348



        poolTokens:   USDPoolTokens(),




12✔





349



    });




12✔





350






12✔





351



    export const FANTOM_POOL_SWAP_TOKEN = makeSwapToken({




12✔





352



        chainId:      ChainId.FANTOM,




12✔





353



        address:     "0x2DC777ff99058a12844A33D9B1AE6c8AB4701F66",




12✔





354



        netName:     "Fantom",




12✔





355



        poolId:       3,




12✔





356



        swapAddress: "0x85662fd123280827e11C59973Ac9fcBE838dC3B4",




12✔





357



        poolTokens:   USDPoolTokens(null),




12✔





358



    });




12✔





359






12✔





360



    export const FANTOM_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





361



        chainId:     ChainId.FANTOM,




12✔





362



        address:     "0x0e3dD3403ee498694A8f61B04AFed8919F747f77",




12✔





363



        netName:     "Fantom",




12✔





364



        poolId:       2,




12✔





365



        swapAddress: "0x8D9bA570D6cb60C7e3e0F31343Efe75AB8E65FB1",




12✔





366



        poolTokens:   ETHTokensPool(Tokens.FTM_ETH),




12✔





367



    });




12✔





368






12✔





369



    export const BOBA_POOL_SWAP_TOKEN = makeSwapToken({




12✔





370



        chainId:      ChainId.BOBA,




12✔





371



        address:     "0x9D7283A6AeeD9BCd4Ac70876fEA2b69a63DD8cb9",




12✔





372



        netName:     "Boba",




12✔





373



        poolId:       1,




12✔





374



        swapAddress: "0x75FF037256b36F15919369AC58695550bE72fead",




12✔





375



        poolTokens:   USDPoolTokens(),




12✔





376



    });




12✔





377






12✔





378



    export const BOBA_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





379



        chainId:        ChainId.BOBA,




12✔





380



        address:        "0x498657f2AF18D525049dE520dD86ee376Db9c67c",




12✔





381



        netName:        "Boba",




12✔





382



        poolId:          2,




12✔





383



        swapAddress:    "0x753bb855c8fe814233d26Bb23aF61cb3d2022bE5",




12✔





384



        swapETHAddress: "0x4F4f66964335D7bef23C16a62Fcd3d1E89f02959",




12✔





385



        poolTokens:      WETHTokenPool,




12✔





386



        nativeTokens:    ETHTokenPool,




12✔





387



    });




12✔





388






12✔





389



    export const METIS_POOL_SWAP_TOKEN = makeSwapToken({




12✔





390



        chainId:      ChainId.METIS,




12✔





391



        address:     "0xC6f684aE516480A35f337a4dA8b40EB6550e07E0",




12✔





392



        netName:     "Metis",




12✔





393



        poolId:       0,




12✔





394



        swapAddress: "0x555982d2E211745b96736665e19D9308B615F78e",




12✔





395



        poolTokens:   [Tokens.NUSD, Tokens.USDC],




12✔





396



    });




12✔





397






12✔





398



    export const METIS_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





399



        chainId:      ChainId.METIS,




12✔





400



        address:     "0x9C1340Bf093d057fA29819575517fb9fE2f04AcE",




12✔





401



        netName:     "Metis",




12✔





402



        poolId:       1,




12✔





403



        swapAddress: "0x09fEC30669d63A13c666d2129230dD5588E2e240",




12✔





404



        poolTokens:   ETHTokensPool(Tokens.METIS_ETH),




12✔





405



    });




12✔





406






12✔





407



    export const ARBITRUM_POOL_SWAP_TOKEN = makeSwapToken({




12✔





408



        chainId:      ChainId.ARBITRUM,




12✔





409



        address:     "0xcFd72be67Ee69A0dd7cF0f846Fc0D98C33d60F16",




12✔





410



        netName:     "Arbitrum",




12✔





411



        poolId:       2,




12✔





412



        swapAddress: "0x9Dd329F5411466d9e0C488fF72519CA9fEf0cb40",




12✔





413



        poolTokens:   USDPoolTokens(null),




12✔





414



    });




12✔





415






12✔





416



    export const ARBITRUM_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





417



        chainId:        ChainId.ARBITRUM,




12✔





418



        address:        "0xD70A52248e546A3B260849386410C7170c7BD1E9",




12✔





419



        netName:        "Arbitrum",




12✔





420



        poolId:          0,




12✔





421



        swapAddress:    "0xa067668661C84476aFcDc6fA5D758C4c01C34352",




12✔





422



        swapETHAddress: "0x1c3fe783a7c06bfAbd124F2708F5Cc51fA42E102",




12✔





423



        poolTokens:      WETHTokenPool,




12✔





424



        nativeTokens:    ETHTokenPool,




12✔





425



    });




12✔





426






12✔





427



    export const AVALANCHE_POOL_SWAP_TOKEN = makeSwapToken({




12✔





428



        chainId:      ChainId.AVALANCHE,




12✔





429



        address:     "0xCA87BF3ec55372D9540437d7a86a7750B42C02f4",




12✔





430



        netName:     "Avalanche",




12✔





431



        poolId:       1,




12✔





432



        swapAddress: "0xED2a7edd7413021d440b09D654f3b87712abAB66",




12✔





433



        poolTokens:   USDPoolTokens(),




12✔





434



    });




12✔





435






12✔





436



    const




12✔





437



        AVAX_AVWETH_POOLTOKENS = ETHTokensPool(Tokens.AVWETH),




12✔





438



        AVAX_WETHE_POOLTOKENS  = ETHTokensPool(Tokens.WETH_E);




12✔





439






12✔





440



    export const AVALANCHE_ETH_SWAP_TOKEN = makeETHSwapToken({




12✔





441



        chainId:        ChainId.AVALANCHE,




12✔





442



        address:        "0x5dF1dB940dd8fEE0e0eB0C8917cb50b4dfaDF98c",




12✔





443



        netName:        "Avalanche",




12✔





444



        poolId:          2,




12✔





445



        swapAddress:    "0x77a7e60555bC18B4Be44C181b2575eee46212d44",




12✔





446



        swapETHAddress: "0xdd60483Ace9B215a7c019A44Be2F22Aa9982652E",




12✔





447



        poolTokens:      AVAX_AVWETH_POOLTOKENS,




12✔





448



        nativeTokens:    AVAX_WETHE_POOLTOKENS,




12✔





449



        depositTokens:   AVAX_WETHE_POOLTOKENS,




12✔





450



    });




12✔





451






12✔





452



    export const AURORA_POOL_SWAP_TOKEN = makeSwapToken({




12✔





453



        chainId:      ChainId.AURORA,




12✔





454



        address:     "0xEAdC3524f3F007cdC5104BF28663b1141D3e3127",




12✔





455



        netName:     "Aurora",




12✔





456



        poolId:       0,




12✔





457



        swapAddress: "0xcEf6C2e20898C2604886b888552CA6CcF66933B0",




12✔





458



        poolTokens:   USDPoolTokens(null),




12✔





459



    });




12✔





460






12✔





461



    export const HARMONY_POOL_SWAP_TOKEN = makeSwapToken({




12✔





462



        chainId:      ChainId.HARMONY,




12✔





463



        address:     "0xE269abBFAF52b26D2632F55B6b223A5223088B96",




12✔





464



        netName:     "Harmony",




12✔





465



        poolId:       1,




12✔





466



        swapAddress: "0x3ea9B0ab55F34Fb188824Ee288CeaEfC63cf908e",




12✔





467



        poolTokens:   USDPoolTokens(),




12✔





468



    });




12✔





469






12✔





470



    const ONEETH_POOL_TOKENS = ETHTokensPool(Tokens.ONE_ETH);




12✔





471






12✔





472



    export const HARMONY_ONEETH_TOKEN = makeETHSwapToken({




12✔





473



        chainId:        ChainId.HARMONY,




12✔





474



        address:        "0x464d121D3cA63cEEfd390D76f19364D3Bd024cD2",




12✔





475



        netName:        "Harmony",




12✔





476



        poolName:       "1ETH",




12✔





477



        poolId:          1,




12✔





478



        swapAddress:    "0x2913E812Cf0dcCA30FB28E6Cac3d2DCFF4497688",




12✔





479



        poolTokens:      ONEETH_POOL_TOKENS,




12✔





480



        nativeTokens:    ONEETH_POOL_TOKENS,




12✔





481



        depositTokens:   ONEETH_POOL_TOKENS,




12✔





482



    });




12✔





483






12✔






484



    export const HARMONY_AVAX_SWAP_TOKEN = new SwapToken({




12✔






485



        chainId:  ChainId.HARMONY,




12✔






486



        name:     "AVAX LP Token Harmony ",




12✔






487



        symbol:   "AVAXLP",




12✔






488



        decimals: 18,




12✔






489



        addresses: {




12✔






490



            [ChainId.HARMONY]: "0x02f7D17f126BD54573c8EbAD9e05408A56f46452"




12✔






491



        },




12✔






492



        poolId:      0,




12✔






493



        poolType:    SwapType.AVAX,




12✔






494



        poolName:    "Harmony AVAX Swap Pool ",




12✔






495



        poolTokens:  [Tokens.SYN_AVAX, Tokens.MULTI_AVAX],




12✔






496



        swapAddress: "0x00A4F57D926781f62D09bb05ec76e6D8aE4268da"




12✔






497



    });




12✔






498






12✔






499



    export const HARMONY_JEWEL_SWAP_TOKEN = new SwapToken({




12✔






500



        chainId:  ChainId.HARMONY,




12✔






501



        name:     "Jewel LP Token Harmony ",




12✔






502



        symbol:   "JEWELP",




12✔






503



        decimals: 18,




12✔






504



        addresses: {




12✔






505



            [ChainId.HARMONY]: "0x0000000000000000000000000000000000000000"




12✔






506



        },




12✔






507



        poolId:      0,




12✔






508



        poolType:    SwapType.JEWEL,




12✔






509



        poolName:    "Harmony Jewel Swap Pool ",




12✔






510



        poolTokens:  [Tokens.JEWEL, Tokens.SYN_JEWEL],




12✔






511



        swapAddress: "0x7bE461cce1501f07969BCE24Ccb2140fCA0a35b3"




12✔






512



    });




12✔






513






12✔





514



    const makeSingleTokenPool = (t: Token): LPToken => ({poolTokens: [t], swapType: t.swapType});





12✔





515






12✔





516



    const




12✔






517



        ETH_Pool        = makeSingleTokenPool(Tokens.ETH),




12✔






518



        SYN_Pool        = makeSingleTokenPool(Tokens.SYN),




12✔






519



        FRAX_Pool       = makeSingleTokenPool(Tokens.FRAX),




12✔






520



        HIGH_Pool       = makeSingleTokenPool(Tokens.HIGH),




12✔






521



        DOG_Pool        = makeSingleTokenPool(Tokens.DOG),




12✔






522



        JUMP_Pool       = makeSingleTokenPool(Tokens.JUMP),




12✔






523



        NFD_Pool        = makeSingleTokenPool(Tokens.NFD),




12✔






524



        GOHM_Pool       = makeSingleTokenPool(Tokens.GOHM),




12✔






525



        GMX_Pool        = makeSingleTokenPool(Tokens.GMX),




12✔






526



        SOLAR_Pool      = makeSingleTokenPool(Tokens.SOLAR),




12✔






527



        AVAX_Pool       = makeSingleTokenPool(Tokens.AVAX),




12✔






528



        WAVAX_Pool      = makeSingleTokenPool(Tokens.WAVAX),




12✔






529



        MOVR_Pool       = makeSingleTokenPool(Tokens.MOVR),




12✔






530



        WMOVR_Pool      = makeSingleTokenPool(Tokens.WMOVR),




12✔






531



        UST_Pool        = makeSingleTokenPool(Tokens.UST),




12✔






532



        NEWO_Pool       = makeSingleTokenPool(Tokens.NEWO),




12✔






533



        SDT_Pool        = makeSingleTokenPool(Tokens.SDT),




12✔






534



        LUNA_Pool       = makeSingleTokenPool(Tokens.LUNA),




12✔






535



        USDB_Pool       = makeSingleTokenPool(Tokens.USDB),




12✔






536



        DFK_USDC_Pool   = makeSingleTokenPool(Tokens.DFK_USDC),




12✔






537



        XJEWEL_Pool     = makeSingleTokenPool(Tokens.XJEWEL),




12✔






538



        DFKTEARS_Pool   = makeSingleTokenPool(Tokens.DFKTEARS),




12✔






539



        VSTA_Pool       = makeSingleTokenPool(Tokens.VSTA);




12✔






540






12✔






541



    const




12✔






542



        AVAX_JEWEL_Pool:    LPToken = {poolTokens: [Tokens.JEWEL, Tokens.MULTIJEWEL], swapType: SwapType.JEWEL},




12✔






543



        DFK_JEWEL_Pool:     LPToken = {poolTokens: [Tokens.GAS_JEWEL, Tokens.JEWEL],  swapType: SwapType.JEWEL},




12✔






544



        HARMONY_JEWEL_Pool: LPToken = {poolTokens: [Tokens.JEWEL, Tokens.SYN_JEWEL],  swapType: SwapType.JEWEL};




12✔






545






12✔






546



    export type SwapTypePoolTokens = SwapTypeMap<LPToken>




12✔





547






12✔





548



    interface SwapTypeMapArgs {




12✔






549



        usdPool?:   [SwapToken, Token[]];




12✔






550



        ethPool?:   [ETHSwapToken, Token[]];




12✔






551



        ohm?:        boolean;




12✔





552



    }




12✔





553






12✔





554



    interface BridgeTokenMapping {




12✔






555



        swappableTokens:     SwapTypeMap<Token[]>;




12✔






556



        swappableSwapGroups: SwapTypeMap<LPToken>;




12✔





557



    }




12✔





558






12✔






559



    type ChainSwapTypePoolsMap = ChainIdTypeMap<BridgeTokenMapping>




12✔





560






12✔





561



    const makeSwapTypeMap = (base: SwapTypeMapArgs, ...pools: LPToken[]): BridgeTokenMapping => {





12✔





562



        let m: BridgeTokenMapping = {




168✔





563



            swappableTokens: {




168✔





564



                [SwapType.SYN]: SYN_Pool.poolTokens,




168✔





565



                [SwapType.UST]: UST_Pool.poolTokens,




168✔





566



                [SwapType.OHM]: GOHM_Pool.poolTokens,




168✔





567



            },




168✔





568



            swappableSwapGroups: {




168✔





569



                [SwapType.SYN]: SYN_Pool,




168✔





570



                [SwapType.UST]: UST_Pool,




168✔





571



                [SwapType.OHM]: GOHM_Pool,




168✔





572



            }




168✔





573



        };




168✔





574






168✔





575



        const {usdPool=null, ethPool=null, ohm: useOhm=true} = base;





168✔





576






168✔





577



        if (usdPool) {





168✔





578



            m.swappableSwapGroups[SwapType.USD] = usdPool[0];




144✔





579



            m.swappableTokens[SwapType.USD] = usdPool[1];




144✔





580



        }




144✔





581



        if (ethPool) {





168✔





582



            m.swappableSwapGroups[SwapType.ETH] = ethPool[0];




84✔





583



            m.swappableTokens[SwapType.ETH] = ethPool[1];




84✔





584



        }




84✔





585






168✔





586



        for (const p of pools) {





168✔





587



            m.swappableTokens[p.swapType] = p.poolTokens;




540✔





588



            m.swappableSwapGroups[p.swapType] = p;




540✔





589



        }




540✔





590






168✔





591



        if (!useOhm) {





168✔





592



            delete m.swappableTokens[SwapType.OHM];




12✔






593



            delete m.swappableSwapGroups[SwapType.OHM];




12✔





594



        }




12✔





595






168✔





596



        return m




168✔





597



    }




168✔





598






12✔





599



    export const bridgeSwappableMap: ChainSwapTypePoolsMap = {




12✔





600



        [ChainId.ETH]: makeSwapTypeMap(




12✔





601



            {




12✔





602



                usdPool: [




12✔





603



                    ETH_POOL_SWAP_TOKEN,




12✔





604



                    [...ETH_POOL_SWAP_TOKEN.poolTokens, Tokens.NUSD]




12✔





605



                ]




12✔





606



            },




12✔





607



            ETH_Pool,




12✔





608



            HIGH_Pool,




12✔





609



            DOG_Pool,




12✔





610



            FRAX_Pool,




12✔





611



            NEWO_Pool,




12✔





612



            SDT_Pool,




12✔






613



            USDB_Pool,




12✔






614



            VSTA_Pool,




12✔





615



        ),




12✔





616



        [ChainId.OPTIMISM]: makeSwapTypeMap(




12✔





617



            {




12✔






618



                usdPool: [OPTIMISM_POOL_SWAP_TOKEN, OPTIMISM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔






619



                ethPool: [OPTIMISM_ETH_SWAP_TOKEN,  OPTIMISM_ETH_SWAP_TOKEN.poolTokens]




12✔





620



            },




12✔





621



            LUNA_Pool,




12✔





622



        ),




12✔






623



        [ChainId.CRONOS]: makeSwapTypeMap(




12✔






624



            {




12✔






625



                usdPool: [CRONOS_POOL_SWAP_TOKEN, CRONOS_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔






626



            }




12✔






627



        ),




12✔






628



        [ChainId.BSC]:    makeSwapTypeMap(




12✔





629



            {




12✔





630



                usdPool: [BSC_POOL_SWAP_TOKEN, BSC_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔





631



            },




12✔





632



            HIGH_Pool,




12✔





633



            DOG_Pool,




12✔





634



            JUMP_Pool,




12✔





635



            NFD_Pool,




12✔






636



            USDB_Pool,




12✔





637



        ),




12✔





638



        [ChainId.POLYGON]: makeSwapTypeMap(




12✔





639



            {




12✔





640



                usdPool: [POLYGON_POOL_SWAP_TOKEN, POLYGON_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔





641



            },




12✔





642



            NFD_Pool,




12✔





643



            DOG_Pool,




12✔






644



            USDB_Pool,




12✔





645



        ),




12✔





646



        [ChainId.FANTOM]: makeSwapTypeMap(




12✔





647



            {




12✔





648



                usdPool: [FANTOM_POOL_SWAP_TOKEN, FANTOM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





649



                ethPool: [FANTOM_ETH_SWAP_TOKEN,  FANTOM_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔





650



            },




12✔





651



            JUMP_Pool,




12✔





652



            FRAX_Pool,




12✔





653



            SDT_Pool,




12✔






654



            USDB_Pool,




12✔





655



        ),




12✔





656



        [ChainId.BOBA]: makeSwapTypeMap(




12✔





657



            {




12✔





658



                usdPool: [BOBA_POOL_SWAP_TOKEN, BOBA_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





659



                ethPool: [BOBA_ETH_SWAP_TOKEN,  BOBA_ETH_SWAP_TOKEN.poolTokens]




12✔





660



            },




12✔





661



        ),




12✔





662



        [ChainId.METIS]: makeSwapTypeMap(




12✔





663



            {




12✔





664



                usdPool: [METIS_POOL_SWAP_TOKEN, METIS_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





665



                ethPool: [METIS_ETH_SWAP_TOKEN,  METIS_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔





666



            }




12✔





667



        ),




12✔





668



        [ChainId.MOONBEAM]: makeSwapTypeMap(




12✔





669



            {},




12✔





670



            SOLAR_Pool,




12✔





671



            WMOVR_Pool,




12✔





672



            WAVAX_Pool,




12✔





673



        ),




12✔





674



        [ChainId.MOONRIVER]: makeSwapTypeMap(




12✔





675



            {},




12✔





676



            SOLAR_Pool,




12✔





677



            FRAX_Pool,




12✔





678



            MOVR_Pool,




12✔






679



            USDB_Pool,




12✔





680



        ),




12✔





681



        [ChainId.ARBITRUM]: makeSwapTypeMap(




12✔





682



            {




12✔





683



                usdPool: [ARBITRUM_POOL_SWAP_TOKEN, ARBITRUM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





684



                ethPool: [ARBITRUM_ETH_SWAP_TOKEN,  ARBITRUM_ETH_SWAP_TOKEN.poolTokens]




12✔





685



            },




12✔





686



            GMX_Pool,




12✔





687



            NEWO_Pool,




12✔





688



            LUNA_Pool,




12✔






689



            VSTA_Pool




12✔





690



        ),




12✔





691



        [ChainId.AVALANCHE]: makeSwapTypeMap(




12✔





692



            {




12✔





693



                usdPool: [AVALANCHE_POOL_SWAP_TOKEN, AVALANCHE_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





694



                ethPool: [AVALANCHE_ETH_SWAP_TOKEN,  AVALANCHE_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




12✔





695



            },




12✔





696



            NFD_Pool,




12✔





697



            GMX_Pool,




12✔





698



            AVAX_Pool,




12✔





699



            NEWO_Pool,




12✔





700



            SDT_Pool,




12✔






701



            USDB_Pool,




12✔






702



            AVAX_JEWEL_Pool




12✔





703



        ),




12✔






704



        [ChainId.DFK]: {




12✔






705



            swappableTokens: {




12✔






706



                [SwapType.USD]:      DFK_USDC_Pool.poolTokens,




12✔






707



                [SwapType.JEWEL]:    DFK_JEWEL_Pool.poolTokens,




12✔






708



                [SwapType.XJEWEL]:   XJEWEL_Pool.poolTokens,




12✔






709



                [SwapType.DFKTEARS]: DFKTEARS_Pool.poolTokens,




12✔






710



                [SwapType.AVAX]:     WAVAX_Pool.poolTokens,




12✔






711



            },




12✔






712



            swappableSwapGroups: {




12✔






713



                [SwapType.USD]:      DFK_USDC_Pool,




12✔






714



                [SwapType.JEWEL]:    DFK_JEWEL_Pool,




12✔






715



                [SwapType.XJEWEL]:   XJEWEL_Pool,




12✔






716



                [SwapType.DFKTEARS]: DFKTEARS_Pool,




12✔






717



                [SwapType.AVAX]:     WAVAX_Pool,




12✔






718



            }




12✔






719



        },




12✔





720



        [ChainId.AURORA]: makeSwapTypeMap(




12✔





721



            {




12✔





722



                usdPool: [AURORA_POOL_SWAP_TOKEN, AURORA_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔






723



                ohm:     false




12✔





724



            }




12✔





725



        ),




12✔





726



        [ChainId.HARMONY]: makeSwapTypeMap(




12✔





727



            {




12✔





728



                usdPool: [HARMONY_POOL_SWAP_TOKEN, HARMONY_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




12✔





729



                ethPool: [HARMONY_ONEETH_TOKEN,    HARMONY_ONEETH_TOKEN.poolTokensForBridgeSwaps]




12✔





730



            },




12✔





731



            FRAX_Pool,




12✔





732



            SDT_Pool,




12✔






733



            HARMONY_AVAX_SWAP_TOKEN,




12✔






734



            XJEWEL_Pool,




12✔






735



            DFKTEARS_Pool,




12✔






736



            HARMONY_JEWEL_Pool




12✔





737



        )




12✔






738



    };




12✔





739






12✔





740



    export function swapGroupsForChain(chainId: number): string[] {





12✔





741



        return Object.values(bridgeSwappableMap[chainId].swappableSwapGroups).map(lp => lp.swapType)





214✔





742



    }




214✔





743






12✔





744



    export function tokensForChainBySwapGroup(





12✔





745



        chainId: number,




5,326✔





746



        swapGroup: string




5,326✔





747



    ): Token[] {




5,326✔





748



        const m = bridgeSwappableMap[chainId].swappableTokens;




5,326✔





749



        return swapGroup in m ? m[swapGroup] : []





5,326✔





750



    }




5,326✔





751






12✔





752



    export function getAllSwappableTokensForNetwork(chainId: number): Token[] {





12✔





753



        let swappableTokens: Token[] = [];




180✔





754






180✔





755



        swapGroupsForChain(chainId).forEach((grp) => {





180✔





756



            const tokens = tokensForChainBySwapGroup(chainId, grp);




1,320✔





757



            swappableTokens = [...swappableTokens, ...tokens];




1,320✔





758



        })




180✔





759






180✔





760



        return swappableTokens




180✔





761



    }




180✔





762






12✔





763



    export function stableswapPoolForNetwork(chainId: number): SwapPoolToken {





12✔





764



        switch (chainId) {




84✔





765



            case ChainId.ETH:





84✔





766



                return ETH_POOL_SWAP_TOKEN




2✔






767



            case ChainId.OPTIMISM:





84✔






768



                return OPTIMISM_POOL_SWAP_TOKEN




6✔






769



            case ChainId.CRONOS:





84✔






770



                return CRONOS_POOL_SWAP_TOKEN




18✔





771



            case ChainId.BSC:





84✔





772



                return BSC_POOL_SWAP_TOKEN




6✔





773



            case ChainId.POLYGON:





84✔





774



                return POLYGON_POOL_SWAP_TOKEN




6✔





775



            case ChainId.FANTOM:





84✔





776



                return FANTOM_POOL_SWAP_TOKEN




6✔





777



            case ChainId.BOBA:





84✔





778



                return BOBA_POOL_SWAP_TOKEN




6✔





779



            case ChainId.METIS:





84✔





780



                return METIS_POOL_SWAP_TOKEN




6✔





781



            case ChainId.ARBITRUM:





84✔





782



                return ARBITRUM_POOL_SWAP_TOKEN




6✔





783



            case ChainId.AVALANCHE:





84✔





784



                return AVALANCHE_POOL_SWAP_TOKEN




6✔





785



            case ChainId.AURORA:





84✔





786



                return AURORA_POOL_SWAP_TOKEN




6✔





787



            case ChainId.HARMONY:





84✔





788



                return HARMONY_POOL_SWAP_TOKEN




6✔





789



        }




84✔





790







4✔





791



        return undefined




4✔





792



    }




4✔





793






12✔





794



    export function ethSwapPoolForNetwork(chainId: number): SwapPoolToken {





12✔





795



        switch (chainId) {




56✔





796



            case ChainId.OPTIMISM:





56✔





797



                return OPTIMISM_ETH_SWAP_TOKEN




6✔





798



            case ChainId.FANTOM:





56✔





799



                return FANTOM_ETH_SWAP_TOKEN




6✔





800



            case ChainId.BOBA:





56✔





801



                return BOBA_ETH_SWAP_TOKEN




6✔





802



            case ChainId.METIS:





56✔





803



                return METIS_ETH_SWAP_TOKEN




6✔





804



            case ChainId.ARBITRUM:





56✔





805



                return ARBITRUM_ETH_SWAP_TOKEN




6✔





806



            case ChainId.AVALANCHE:





56✔





807



                return AVALANCHE_ETH_SWAP_TOKEN




6✔





808



            case ChainId.HARMONY:





56✔





809



                return HARMONY_ONEETH_TOKEN




6✔





810



        }




56✔





811







14✔





812



        return undefined




14✔





813



    }




14✔






814






12✔






815



    export const AllSwapPoolTokens: SwapPoolToken[] = [




12✔






816



        ETH_POOL_SWAP_TOKEN,




12✔






817



        OPTIMISM_POOL_SWAP_TOKEN,




12✔






818



        OPTIMISM_ETH_SWAP_TOKEN,




12✔






819



        CRONOS_POOL_SWAP_TOKEN,




12✔






820



        BSC_POOL_SWAP_TOKEN,




12✔






821



        POLYGON_POOL_SWAP_TOKEN,




12✔






822



        FANTOM_POOL_SWAP_TOKEN,




12✔






823



        FANTOM_ETH_SWAP_TOKEN,




12✔






824



        BOBA_POOL_SWAP_TOKEN,




12✔






825



        BOBA_ETH_SWAP_TOKEN,




12✔






826



        METIS_POOL_SWAP_TOKEN,




12✔






827



        METIS_ETH_SWAP_TOKEN,




12✔






828



        ARBITRUM_POOL_SWAP_TOKEN,




12✔






829



        ARBITRUM_ETH_SWAP_TOKEN,




12✔






830



        AVALANCHE_POOL_SWAP_TOKEN,




12✔






831



        AVALANCHE_ETH_SWAP_TOKEN,




12✔






832



        AURORA_POOL_SWAP_TOKEN,




12✔






833



        HARMONY_POOL_SWAP_TOKEN,




12✔






834



        HARMONY_ONEETH_TOKEN,




12✔






835



        HARMONY_AVAX_SWAP_TOKEN,




12✔






836



        HARMONY_JEWEL_SWAP_TOKEN,




12✔






837



    ];




12✔






838






12✔






839



    function checkChainId(t: SwapPoolToken, chainId?: number): boolean {





12✔






840



        if (typeof chainId !== 'undefined' && chainId !== null) {





32✔






841



            return chainId === t.chainId




20✔






842



        }




20✔






843







12✔






844



        return true




12✔






845



    }




12✔






846






12✔






847



    enum CheckAddressKind {





12✔






848



        LpTokenAddress,




12✔






849



        SwapAddress




12✔






850



    }




12✔






851






12✔






852



    function checkSwapPoolTokenAddress(address: string, field: CheckAddressKind, chainId?: number): SwapPoolToken {





12✔






853



        let res: SwapPoolToken = null;




38✔






854






38✔






855



        for (const t of AllSwapPoolTokens) {





38✔






856



            let checkAddress: string;




662✔






857



            switch (field) {




662✔






858



                case CheckAddressKind.LpTokenAddress:





662✔






859



                    checkAddress = t.address(t.chainId);




310✔






860



                    break;




310✔






861



                case CheckAddressKind.SwapAddress:





662✔






862



                    checkAddress = t.swapAddress;




352✔






863



                    break;




352✔






864



            }




662✔






865






662✔






866



            if (checkAddress === address) {





662✔






867



                if (checkChainId(t, chainId)) {





32✔






868



                    res = t;




24✔






869



                    break;




24✔






870



                }




24✔






871



            }




32✔






872



        }




662✔






873






38✔






874



        return res




38✔






875



    }




38✔






876






12✔






877



    export function swapPoolTokenFromLPTokenAddress(lpTokenAddress: string, chainId?: number): SwapPoolToken {





12✔






878



        return checkSwapPoolTokenAddress(lpTokenAddress, CheckAddressKind.LpTokenAddress, chainId)




18✔






879



    }




18✔






880






12✔






881



    export function swapPoolTokenFromSwapAddress(swapAddress: string, chainId?: number): SwapPoolToken {





12✔






882



        return checkSwapPoolTokenAddress(swapAddress, CheckAddressKind.SwapAddress, chainId)




20✔






883



    }




20✔






884






12✔






885



    export function swapPoolTokenForTypeForChain(chainId: number, swapType: SwapType): SwapPoolToken {





12✔






886



        let res: SwapPoolToken = null;




6✔






887






6✔






888



        for (const t of swapPoolTokensForChainId(chainId)) {





6✔






889



            if (t.swapType === swapType) {





18✔






890



                res = t;




6✔






891



                break;




6✔






892



            }




6✔






893



        }




18✔






894






6✔






895



        return res




6✔






896



    }




6✔






897






12✔






898



    export function swapPoolTokensForChainId(chainId: number): SwapPoolToken[] {





12✔






899



        let res: SwapPoolToken[] = [];




14✔






900






14✔






901



        AllSwapPoolTokens.forEach(t => {





14✔






902



            if (t.chainId === chainId) {





294✔






903



                res.push(t);




32✔






904



            }




32✔






905



        });




14✔






906






14✔






907



        return res




14✔






908



    }




14✔





909



}




12✔





910






2✔





911



export type NetworkSwappableTokensMap     = ChainIdTypeMap<Token[]>;




2✔





912



export type AllNetworksSwappableTokensMap = ChainIdTypeMap<NetworkSwappableTokensMap>;




2✔





913






2✔





914



function filterGrps(chainAGrps: string[], chainBGrpsMap: SwapPools.SwapTypePoolTokens): Token[] {





450✔





915



    let tokens: Token[] = [];




450✔





916






450✔





917



    Object.keys(chainBGrpsMap).forEach((grp: string) => {





450✔





918



        if (chainAGrps.includes(grp)) {





3,294✔





919



            tokens = [...tokens, ...chainBGrpsMap[grp].poolTokens];




1,842✔





920



        }




1,842✔





921



    })




450✔





922






450✔





923



    return tokens




450✔





924



}




450✔





925






2✔





926



function swapGroupsLoop(chainIdA: number, swapGrps: string[]): NetworkSwappableTokensMap {





32✔





927



    let res: NetworkSwappableTokensMap = {}




32✔





928






32✔





929



    supportedChainIds().forEach((chainId: number) => {





32✔





930



        if (chainIdA === chainId) {





480✔





931



            return




32✔





932



        }




32✔





933







448✔





934



        res[chainId] = filterGrps(swapGrps, SwapPools.bridgeSwappableMap[chainId].swappableSwapGroups);




448✔





935



    })




32✔





936






32✔





937



    return res




32✔





938



}




32✔





939






2✔





940






2✔





941



/**




2✔





942



 * Returns a map of swappable tokens for two given networks; or, if a second chainid isn't passed,




2✔





943



 * a map of all swappable tokens for the passed chainid between all supported networks.




2✔





944



 * @param chainIdA




2✔





945



 * @param chainIdB Optional second network; if passed, a map of swappable tokens between ONLY chainIdA and chainIdB is returned.




2✔





946



 * @return NetworkSwappableTokensMap




2✔





947



 */




2✔





948



export function networkSwapTokensMap(chainIdA: number, chainIdB?: number): NetworkSwappableTokensMap {





2✔





949



    let res: NetworkSwappableTokensMap = {};




4✔





950






4✔





951



    const swapGrpsA: string[] = SwapPools.swapGroupsForChain(chainIdA);




4✔





952






4✔





953



    if (typeof chainIdB !== 'undefined') {





4✔





954



        res[chainIdB] = filterGrps(swapGrpsA, SwapPools.bridgeSwappableMap[chainIdB].swappableSwapGroups);




2✔





955



    } else {




2✔





956



        res = swapGroupsLoop(chainIdA, swapGrpsA);




2✔





957



    }




2✔





958






4✔





959



    return res




4✔





960



}




4✔





961






2✔





962



/**




2✔





963



 * Returns map of all swappable tokens between all supported networks.




2✔





964



 * @return AllNetworksSwappableTokensMap




2✔





965



 */




2✔





966



export function allNetworksSwapTokensMap(): AllNetworksSwappableTokensMap {





2✔





967



    let res: AllNetworksSwappableTokensMap = {};




2✔





968






2✔





969



    supportedChainIds().forEach((chainIdA: number) => {





2✔





970



        const swapGrpsA: string[] = SwapPools.swapGroupsForChain(chainIdA);




30✔





971






30✔





972



        res[chainIdA] = swapGroupsLoop(chainIdA, swapGrpsA);




30✔





973



    })




2✔





974






2✔





975



    return res




2✔





976



}



2✔



















    

  • 

    •