synapsecns / sdk / 2736884940

2736884940

Pull #131

github

GitHub 
Merge 1f6241ef8 into 3ae9f2f59
Pull Request #131: Add ETH support for DFK

25 of 38 branches covered (65.79%)

Branch coverage included in aggregate %.

0 of 48 new or added lines in 3 files covered. (0.0%)

5066 existing lines in 20 files now uncovered.

1432 of 6565 relevant lines covered (21.81%)

0.45 hits per line

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

6.58
/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✔






UNCOV

31



export namespace SwapPools {




×








UNCOV

32



    function moveFirstToLast(arr: Token[]) {




×








UNCOV

33



        return [




×








UNCOV

34



            ...arr.slice(1),




×








UNCOV

35



            arr[0]




×








UNCOV

36



        ]




×








UNCOV

37



    }




×








UNCOV

38






×








UNCOV

39



    export interface LPToken {




×








UNCOV

40



        readonly poolTokens: Token[];




×








UNCOV

41



        readonly swapType:   SwapType;




×








UNCOV

42



    }




×








UNCOV

43






×








UNCOV

44



    export type PoolTokensAmountsMap = {




×








UNCOV

45



        [k: string]: BigNumberish;




×








UNCOV

46



    }




×








UNCOV

47






×








UNCOV

48



    export interface SwapPoolToken extends IBaseToken, LPToken {




×








UNCOV

49



        readonly baseToken:       BaseToken;




×








UNCOV

50



        readonly chainId:         number;




×








UNCOV

51



        readonly poolId:          number;




×








UNCOV

52



        readonly poolName:        string;




×








UNCOV

53



        readonly poolType:        string;




×








UNCOV

54



        readonly nativeTokens?:   Token[];




×








UNCOV

55



        readonly depositTokens?:  Token[];




×








UNCOV

56



        readonly swapAddress:     string;




×








UNCOV

57



        readonly swapETHAddress:  string | null;




×








UNCOV

58






×








UNCOV

59



        readonly poolTokensForBridgeSwaps: Token[]




×








UNCOV

60






×








UNCOV

61



        liquidityAmountsMap:     () => PoolTokensAmountsMap;




×








UNCOV

62



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




×








UNCOV

63



    }




×








UNCOV

64






×








UNCOV

65



    interface SwapTokenArgs {




×








UNCOV

66



        name:           string;




×








UNCOV

67



        symbol:         string;




×








UNCOV

68



        chainId:        number;




×








UNCOV

69



        decimals:       number | DecimalsMap;




×








UNCOV

70



        addresses:      AddressMap;




×








UNCOV

71



        poolId:         number;




×








UNCOV

72



        poolName:       string;




×








UNCOV

73



        poolType:       SwapType;




×








UNCOV

74



        poolTokens:     Token[];




×








UNCOV

75



        swapAddress:    string;




×








UNCOV

76



    }




×








UNCOV

77






×








UNCOV

78



    interface ETHSwapTokenArgs extends SwapTokenArgs {




×








UNCOV

79



        nativeTokens?:     Token[];




×








UNCOV

80



        depositTokens?:    Token[];




×








UNCOV

81



        swapEthAddress?:   string;




×








UNCOV

82



    }




×








UNCOV

83






×








UNCOV

84



    interface makeSwapTokenArgs {




×








UNCOV

85



        chainId:      number;




×








UNCOV

86



        netName:      string;




×








UNCOV

87



        address:      string;




×








UNCOV

88



        swapAddress:  string;




×








UNCOV

89



        poolId:       number;




×








UNCOV

90



        poolTokens:   Token[];




×








UNCOV

91



        notLP?:       boolean;




×








UNCOV

92



        symbol?:      string;




×








UNCOV

93



    }




×








UNCOV

94






×








UNCOV

95



    interface makeETHSwapTokenArgs extends makeSwapTokenArgs {




×








UNCOV

96



        swapETHAddress?: string;




×








UNCOV

97



        poolName?:       string;




×








UNCOV

98



        nativeTokens?:   Token[];




×








UNCOV

99



        depositTokens?:  Token[];




×








UNCOV

100



    }




×








UNCOV

101






×








UNCOV

102



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




×








UNCOV

103



        new SwapToken({




×








UNCOV

104



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




×








UNCOV

105



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




×








UNCOV

106



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




×








UNCOV

107



            chainId:         args.chainId,




×








UNCOV

108



            decimals:        18,




×








UNCOV

109



            poolId:          args.poolId,




×








UNCOV

110



            poolTokens:      args.poolTokens,




×








UNCOV

111



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




×








UNCOV

112



            swapAddress:     args.swapAddress,




×








UNCOV

113



            poolType:        SwapType.USD,




×








UNCOV

114



        })




×








UNCOV

115






×








UNCOV

116



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




×








UNCOV

117



        new ETHSwapToken({




×








UNCOV

118



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




×








UNCOV

119



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




×








UNCOV

120



            symbol:           "nETH-LP",




×








UNCOV

121



            chainId:          args.chainId,




×








UNCOV

122



            decimals:         18,




×








UNCOV

123



            poolId:           args.poolId,




×








UNCOV

124



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




×








UNCOV

125



            swapAddress:      args.swapAddress,




×








UNCOV

126



            swapEthAddress:   args.swapETHAddress,




×








UNCOV

127



            poolTokens:       args.poolTokens,




×








UNCOV

128



            nativeTokens:     args.nativeTokens,




×








UNCOV

129



            depositTokens:    args.depositTokens,




×








UNCOV

130



            poolType:         SwapType.ETH,




×








UNCOV

131



        })




×








UNCOV

132






×








UNCOV

133



    export class SwapToken implements SwapPoolToken {




×








UNCOV

134



        readonly baseToken: BaseToken;




×








UNCOV

135



        readonly chainId:   number;




×








UNCOV

136






×








UNCOV

137



        readonly poolId:   number;




×








UNCOV

138



        readonly poolName: string;




×








UNCOV

139



        readonly poolType: SwapType;




×








UNCOV

140






×








UNCOV

141



        readonly poolTokens: Token[];




×








UNCOV

142






×








UNCOV

143



        readonly swapAddress: string;




×








UNCOV

144






×








UNCOV

145



        constructor(args: SwapTokenArgs) {




×








UNCOV

146



            this.baseToken = new BaseToken({




×








UNCOV

147



                name:      args.name,




×








UNCOV

148



                symbol:    args.symbol,




×








UNCOV

149



                decimals:  args.decimals,




×








UNCOV

150



                addresses: args.addresses,




×








UNCOV

151



                swapType:  args.poolType




×








UNCOV

152



            });




×








UNCOV

153






×








UNCOV

154



            this.chainId     = args.chainId;




×








UNCOV

155



            this.poolId      = args.poolId;




×








UNCOV

156



            this.poolName    = args.poolName;




×








UNCOV

157



            this.poolType    = args.poolType;




×








UNCOV

158



            this.swapAddress = args.swapAddress;




×








UNCOV

159



            this.poolTokens  = args.poolTokens;




×








UNCOV

160



        }




×








UNCOV

161






×








UNCOV

162



        get id(): ID {




×








UNCOV

163



            return this.baseToken.id




×








UNCOV

164



        }




×








UNCOV

165






×








UNCOV

166



        get name(): string {




×








UNCOV

167



           return this.baseToken.name




×








UNCOV

168



        }




×








UNCOV

169






×








UNCOV

170



        get symbol(): string {




×








UNCOV

171



            return this.baseToken.symbol




×








UNCOV

172



        }




×








UNCOV

173






×








UNCOV

174



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




×








UNCOV

175



            return this.baseToken.addresses




×








UNCOV

176



        }




×








UNCOV

177






×








UNCOV

178



        get swapType(): SwapType {




×








UNCOV

179



            return this.baseToken.swapType




×








UNCOV

180



        }




×








UNCOV

181






×








UNCOV

182



        address(chainId: number): string|null {




×








UNCOV

183



            return this.baseToken.address(chainId)




×








UNCOV

184



        }




×








UNCOV

185






×








UNCOV

186



        decimals(chainId: number): number | null {




×








UNCOV

187



            return this.baseToken.decimals(chainId)




×








UNCOV

188



        }




×








UNCOV

189






×








UNCOV

190



        get poolTokensForBridgeSwaps(): Token[] {




×








UNCOV

191



            return moveFirstToLast(this.poolTokens)




×








UNCOV

192



        }




×








UNCOV

193






×








UNCOV

194



        get swapETHAddress(): string | null {




×








UNCOV

195



            return null




×








UNCOV

196



        }




×








UNCOV

197






×








UNCOV

198



        liquidityAmountsMap(): PoolTokensAmountsMap {




×








UNCOV

199



            let m: PoolTokensAmountsMap = {};




×








UNCOV

200






×








UNCOV

201



            for (const t of this.poolTokens) {




×








UNCOV

202



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




×








UNCOV

203



            }




×








UNCOV

204






×








UNCOV

205



            return m




×








UNCOV

206



        }




×








UNCOV

207






×








UNCOV

208



        liquidityAmountsFromMap(m: PoolTokensAmountsMap): BigNumber[] {




×








UNCOV

209



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




×








UNCOV

210






×








UNCOV

211



            const mapKeys = Object.keys(m);




×








UNCOV

212



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




×








UNCOV

213






×







214



            /* c8 ignore start */




2✔





215



            if (!isEqual(mapKeys, wantMapKeys)) {




2✔





216



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




2✔





217



                console.error(err);




2✔





218



                return amounts;




2✔





219



            }




2✔





220



            /* c8 ignore stop */




2✔






UNCOV

221






×








UNCOV

222



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




×








UNCOV

223



                const amt = m[k];




×








UNCOV

224






×








UNCOV

225



                let realAmt: BigNumber;




×








UNCOV

226






×







227



                /* c8 ignore start */




2✔





228



                if (amt instanceof BigNumber) {




2✔





229



                    realAmt = amt as BigNumber;




2✔





230



                } else {




2✔





231



                    const token = this.poolTokens[idx];




2✔





232



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




2✔





233



                }




2✔





234



                /* c8 ignore stop */




2✔






UNCOV

235






×








UNCOV

236



                amounts[idx] = realAmt;




×








UNCOV

237



            });




×








UNCOV

238






×








UNCOV

239



            return amounts




×








UNCOV

240



        }




×








UNCOV

241



    }




×








UNCOV

242






×








UNCOV

243



    export class ETHSwapToken extends SwapToken {




×








UNCOV

244



        readonly nativeTokens:  Token[];




×








UNCOV

245



        readonly depositTokens: Token[];




×








UNCOV

246






×








UNCOV

247



        private readonly _swapETHAddress: string | null = null;




×








UNCOV

248






×








UNCOV

249



        constructor(args: ETHSwapTokenArgs) {




×








UNCOV

250



            let {




×








UNCOV

251



                swapEthAddress,




×








UNCOV

252



                nativeTokens,




×








UNCOV

253



                depositTokens,




×








UNCOV

254



                ...constructorArgs




×








UNCOV

255



            } = args;




×








UNCOV

256






×








UNCOV

257



            super(constructorArgs);




×








UNCOV

258






×








UNCOV

259



            if (swapEthAddress) {




×








UNCOV

260



                this._swapETHAddress = args.swapEthAddress;




×








UNCOV

261



            }




×








UNCOV

262






×








UNCOV

263



            if (args.nativeTokens) {




×








UNCOV

264



                this.nativeTokens = args.nativeTokens;




×








UNCOV

265



            }




×








UNCOV

266






×








UNCOV

267



            if (args.depositTokens) {




×








UNCOV

268



                this.depositTokens = args.depositTokens;




×








UNCOV

269



            }




×








UNCOV

270



        }




×








UNCOV

271






×








UNCOV

272



        get poolTokensForBridgeSwaps(): Token[] {




×








UNCOV

273



            return this.depositTokens?.length > 0




×








UNCOV

274



                ? moveFirstToLast(this.depositTokens)




×








UNCOV

275



                : moveFirstToLast(this.poolTokens)




×








UNCOV

276



        }




×








UNCOV

277






×








UNCOV

278



        get swapETHAddress(): string | null {




×








UNCOV

279



            return this._swapETHAddress




×








UNCOV

280



        }




×








UNCOV

281



    }




×








UNCOV

282






×








UNCOV

283



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




×








UNCOV

284



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




×








UNCOV

285



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




×








UNCOV

286



        Tokens.USDC,




×








UNCOV

287



        Tokens.USDT,




×








UNCOV

288



    ]




×








UNCOV

289






×








UNCOV

290



    const




×








UNCOV

291



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




×








UNCOV

292



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




×








UNCOV

293



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




×








UNCOV

294






×








UNCOV

295



    export const ETH_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

296



        chainId:     ChainId.ETH,




×








UNCOV

297



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




×








UNCOV

298



        netName:     "Ethereum",




×








UNCOV

299



        poolId:       420,




×








UNCOV

300



        swapAddress: "0x1116898DdA4015eD8dDefb84b6e8Bc24528Af2d8",




×








UNCOV

301



        poolTokens:   USDPoolTokens(Tokens.DAI, false),




×








UNCOV

302



        notLP:        true




×








UNCOV

303



    });




×








UNCOV

304






×








UNCOV

305



    export const OPTIMISM_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

306



        chainId:     ChainId.OPTIMISM,




×








UNCOV

307



        address:     "0x2c6d91accC5Aa38c84653F28A80AEC69325BDd12",




×








UNCOV

308



        netName:     "Optimism",




×








UNCOV

309



        poolId:      1,




×








UNCOV

310



        swapAddress: "0xF44938b0125A6662f9536281aD2CD6c499F22004",




×








UNCOV

311



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




×








UNCOV

312



    });




×








UNCOV

313






×








UNCOV

314



    export const OPTIMISM_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

315



        chainId:         ChainId.OPTIMISM,




×








UNCOV

316



        address:        "0x4619a06ddd3b8f0f951354ec5e75c09cd1cd1aef",




×








UNCOV

317



        netName:        "Optimism",




×








UNCOV

318



        poolId:          0,




×








UNCOV

319



        swapAddress:    "0xE27BFf97CE92C3e1Ff7AA9f86781FDd6D48F5eE9",




×








UNCOV

320



        swapETHAddress: "0x8c7d5f8A8e154e1B59C92D8FB71314A43F32ef7B",




×








UNCOV

321



        poolTokens:      WETHTokenPool,




×








UNCOV

322



        nativeTokens:    ETHTokenPool,




×








UNCOV

323



    });




×








UNCOV

324






×








UNCOV

325



    export const CRONOS_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

326



        chainId:     ChainId.CRONOS,




×








UNCOV

327



        address:     "0xd5Da35646A79C42a0BAB148656192A22e8CBfad6",




×








UNCOV

328



        netName:     "Cronos",




×








UNCOV

329



        poolId:      1,




×








UNCOV

330



        swapAddress: "0xCb6674548586F20ca39C97A52A0ded86f48814De",




×








UNCOV

331



        poolTokens:  [




×








UNCOV

332



            Tokens.NUSD,




×








UNCOV

333



            Tokens.USDC,




×








UNCOV

334



        ],




×








UNCOV

335



    });




×








UNCOV

336






×








UNCOV

337



    export const BSC_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

338



        chainId:      ChainId.BSC,




×








UNCOV

339



        address:     "0xa4b7Bc06EC817785170C2DbC1dD3ff86CDcdcc4C",




×








UNCOV

340



        netName:     "BSC",




×








UNCOV

341



        poolId:       1,




×








UNCOV

342



        swapAddress: "0x28ec0B36F0819ecB5005cAB836F4ED5a2eCa4D13",




×








UNCOV

343



        poolTokens:   USDPoolTokens(Tokens.BUSD),




×








UNCOV

344



    });




×








UNCOV

345






×








UNCOV

346



    export const POLYGON_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

347



        chainId:      ChainId.POLYGON,




×








UNCOV

348



        address:     "0x7479e1bc2f2473f9e78c89b4210eb6d55d33b645",




×








UNCOV

349



        netName:     "Polygon",




×








UNCOV

350



        poolId:       1,




×








UNCOV

351



        swapAddress: "0x85fCD7Dd0a1e1A9FCD5FD886ED522dE8221C3EE5",




×








UNCOV

352



        poolTokens:   USDPoolTokens(),




×








UNCOV

353



    });




×








UNCOV

354






×








UNCOV

355



    export const FANTOM_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

356



        chainId:      ChainId.FANTOM,




×








UNCOV

357



        address:     "0x2DC777ff99058a12844A33D9B1AE6c8AB4701F66",




×








UNCOV

358



        netName:     "Fantom",




×








UNCOV

359



        poolId:       3,




×








UNCOV

360



        swapAddress: "0x85662fd123280827e11C59973Ac9fcBE838dC3B4",




×








UNCOV

361



        poolTokens:   USDPoolTokens(null),




×








UNCOV

362



    });




×








UNCOV

363






×








UNCOV

364



    export const FANTOM_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

365



        chainId:     ChainId.FANTOM,




×








UNCOV

366



        address:     "0x0e3dD3403ee498694A8f61B04AFed8919F747f77",




×








UNCOV

367



        netName:     "Fantom",




×








UNCOV

368



        poolId:       2,




×








UNCOV

369



        swapAddress: "0x8D9bA570D6cb60C7e3e0F31343Efe75AB8E65FB1",




×








UNCOV

370



        poolTokens:   ETHTokensPool(Tokens.FTM_ETH),




×








UNCOV

371



    });




×








UNCOV

372






×








UNCOV

373



    export const BOBA_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

374



        chainId:      ChainId.BOBA,




×








UNCOV

375



        address:     "0x9D7283A6AeeD9BCd4Ac70876fEA2b69a63DD8cb9",




×








UNCOV

376



        netName:     "Boba",




×








UNCOV

377



        poolId:       1,




×








UNCOV

378



        swapAddress: "0x75FF037256b36F15919369AC58695550bE72fead",




×








UNCOV

379



        poolTokens:   USDPoolTokens(),




×








UNCOV

380



    });




×








UNCOV

381






×








UNCOV

382



    export const BOBA_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

383



        chainId:        ChainId.BOBA,




×








UNCOV

384



        address:        "0x498657f2AF18D525049dE520dD86ee376Db9c67c",




×








UNCOV

385



        netName:        "Boba",




×








UNCOV

386



        poolId:          2,




×








UNCOV

387



        swapAddress:    "0x753bb855c8fe814233d26Bb23aF61cb3d2022bE5",




×








UNCOV

388



        swapETHAddress: "0x4F4f66964335D7bef23C16a62Fcd3d1E89f02959",




×








UNCOV

389



        poolTokens:      WETHTokenPool,




×








UNCOV

390



        nativeTokens:    ETHTokenPool,




×








UNCOV

391



    });




×








UNCOV

392






×








UNCOV

393



    export const METIS_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

394



        chainId:      ChainId.METIS,




×








UNCOV

395



        address:     "0xC6f684aE516480A35f337a4dA8b40EB6550e07E0",




×








UNCOV

396



        netName:     "Metis",




×








UNCOV

397



        poolId:       0,




×








UNCOV

398



        swapAddress: "0x555982d2E211745b96736665e19D9308B615F78e",




×








UNCOV

399



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




×








UNCOV

400



    });




×








UNCOV

401






×








UNCOV

402



    export const METIS_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

403



        chainId:      ChainId.METIS,




×








UNCOV

404



        address:     "0x9C1340Bf093d057fA29819575517fb9fE2f04AcE",




×








UNCOV

405



        netName:     "Metis",




×








UNCOV

406



        poolId:       1,




×








UNCOV

407



        swapAddress: "0x09fEC30669d63A13c666d2129230dD5588E2e240",




×








UNCOV

408



        poolTokens:   ETHTokensPool(Tokens.METIS_ETH),




×








UNCOV

409



    });




×








UNCOV

410






×








UNCOV

411



    export const ARBITRUM_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

412



        chainId:      ChainId.ARBITRUM,




×








UNCOV

413



        address:     "0xcFd72be67Ee69A0dd7cF0f846Fc0D98C33d60F16",




×








UNCOV

414



        netName:     "Arbitrum",




×








UNCOV

415



        poolId:       2,




×








UNCOV

416



        swapAddress: "0x9Dd329F5411466d9e0C488fF72519CA9fEf0cb40",




×








UNCOV

417



        poolTokens:   USDPoolTokens(null),




×








UNCOV

418



    });




×








UNCOV

419






×








UNCOV

420



    export const ARBITRUM_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

421



        chainId:        ChainId.ARBITRUM,




×








UNCOV

422



        address:        "0xD70A52248e546A3B260849386410C7170c7BD1E9",




×








UNCOV

423



        netName:        "Arbitrum",




×








UNCOV

424



        poolId:          0,




×








UNCOV

425



        swapAddress:    "0xa067668661C84476aFcDc6fA5D758C4c01C34352",




×








UNCOV

426



        swapETHAddress: "0x1c3fe783a7c06bfAbd124F2708F5Cc51fA42E102",




×








UNCOV

427



        poolTokens:      WETHTokenPool,




×








UNCOV

428



        nativeTokens:    ETHTokenPool,




×








UNCOV

429



    });




×








UNCOV

430






×








UNCOV

431



    export const AVALANCHE_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

432



        chainId:      ChainId.AVALANCHE,




×








UNCOV

433



        address:     "0xCA87BF3ec55372D9540437d7a86a7750B42C02f4",




×








UNCOV

434



        netName:     "Avalanche",




×








UNCOV

435



        poolId:       1,




×








UNCOV

436



        swapAddress: "0xED2a7edd7413021d440b09D654f3b87712abAB66",




×








UNCOV

437



        poolTokens:   USDPoolTokens(),




×








UNCOV

438



    });




×








UNCOV

439






×








UNCOV

440



    const




×








UNCOV

441



        AVAX_AVWETH_POOLTOKENS = ETHTokensPool(Tokens.AVWETH),




×








UNCOV

442



        AVAX_WETHE_POOLTOKENS  = ETHTokensPool(Tokens.WETH_E);




×








UNCOV

443






×








UNCOV

444



    export const AVALANCHE_ETH_SWAP_TOKEN = makeETHSwapToken({




×








UNCOV

445



        chainId:        ChainId.AVALANCHE,




×








UNCOV

446



        address:        "0x5dF1dB940dd8fEE0e0eB0C8917cb50b4dfaDF98c",




×








UNCOV

447



        netName:        "Avalanche",




×








UNCOV

448



        poolId:          2,




×








UNCOV

449



        swapAddress:    "0x77a7e60555bC18B4Be44C181b2575eee46212d44",




×








UNCOV

450



        swapETHAddress: "0xdd60483Ace9B215a7c019A44Be2F22Aa9982652E",




×








UNCOV

451



        poolTokens:      AVAX_AVWETH_POOLTOKENS,




×








UNCOV

452



        nativeTokens:    AVAX_WETHE_POOLTOKENS,




×








UNCOV

453



        depositTokens:   AVAX_WETHE_POOLTOKENS,




×








UNCOV

454



    });




×








UNCOV

455






×








UNCOV

456



    export const AURORA_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

457



        chainId:      ChainId.AURORA,




×








UNCOV

458



        address:     "0xEAdC3524f3F007cdC5104BF28663b1141D3e3127",




×








UNCOV

459



        netName:     "Aurora",




×








UNCOV

460



        poolId:       0,




×








UNCOV

461



        swapAddress: "0xcEf6C2e20898C2604886b888552CA6CcF66933B0",




×








UNCOV

462



        poolTokens:   USDPoolTokens(null),




×








UNCOV

463



    });




×








UNCOV

464






×








UNCOV

465



    export const HARMONY_POOL_SWAP_TOKEN = makeSwapToken({




×








UNCOV

466



        chainId:      ChainId.HARMONY,




×








UNCOV

467



        address:     "0xE269abBFAF52b26D2632F55B6b223A5223088B96",




×








UNCOV

468



        netName:     "Harmony",




×








UNCOV

469



        poolId:       1,




×








UNCOV

470



        swapAddress: "0x3ea9B0ab55F34Fb188824Ee288CeaEfC63cf908e",




×








UNCOV

471



        poolTokens:   USDPoolTokens(),




×








UNCOV

472



    });




×








UNCOV

473






×








UNCOV

474



    const ONEETH_POOL_TOKENS = ETHTokensPool(Tokens.ONE_ETH);




×








UNCOV

475






×








UNCOV

476



    export const HARMONY_ONEETH_TOKEN = makeETHSwapToken({




×








UNCOV

477



        chainId:        ChainId.HARMONY,




×








UNCOV

478



        address:        "0x464d121D3cA63cEEfd390D76f19364D3Bd024cD2",




×








UNCOV

479



        netName:        "Harmony",




×








UNCOV

480



        poolName:       "1ETH",




×








UNCOV

481



        poolId:          1,




×








UNCOV

482



        swapAddress:    "0x2913E812Cf0dcCA30FB28E6Cac3d2DCFF4497688",




×








UNCOV

483



        poolTokens:      ONEETH_POOL_TOKENS,




×








UNCOV

484



        nativeTokens:    ONEETH_POOL_TOKENS,




×








UNCOV

485



        depositTokens:   ONEETH_POOL_TOKENS,




×








UNCOV

486



    });




×








UNCOV

487






×








UNCOV

488



    export const HARMONY_AVAX_SWAP_TOKEN = new SwapToken({




×








UNCOV

489



        chainId:  ChainId.HARMONY,




×








UNCOV

490



        name:     "AVAX LP Token Harmony ",




×








UNCOV

491



        symbol:   "AVAXLP",




×








UNCOV

492



        decimals: 18,




×








UNCOV

493



        addresses: {




×








UNCOV

494



            [ChainId.HARMONY]: "0x02f7D17f126BD54573c8EbAD9e05408A56f46452"




×








UNCOV

495



        },




×








UNCOV

496



        poolId:      0,




×








UNCOV

497



        poolType:    SwapType.AVAX,




×








UNCOV

498



        poolName:    "Harmony AVAX Swap Pool ",




×








UNCOV

499



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




×








UNCOV

500



        swapAddress: "0x00A4F57D926781f62D09bb05ec76e6D8aE4268da"




×








UNCOV

501



    });




×








UNCOV

502






×








UNCOV

503



    export const HARMONY_JEWEL_SWAP_TOKEN = new SwapToken({




×








UNCOV

504



        chainId:  ChainId.HARMONY,




×








UNCOV

505



        name:     "Jewel LP Token Harmony ",




×








UNCOV

506



        symbol:   "JEWELP",




×








UNCOV

507



        decimals: 18,




×








UNCOV

508



        addresses: {




×








UNCOV

509



            [ChainId.HARMONY]: "0x0000000000000000000000000000000000000000"




×








UNCOV

510



        },




×








UNCOV

511



        poolId:      0,




×








UNCOV

512



        poolType:    SwapType.JEWEL,




×








UNCOV

513



        poolName:    "Harmony Jewel Swap Pool ",




×








UNCOV

514



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




×








UNCOV

515



        swapAddress: "0x7bE461cce1501f07969BCE24Ccb2140fCA0a35b3"




×








UNCOV

516



    });




×








UNCOV

517






×








UNCOV

518



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




×








UNCOV

519






×








UNCOV

520



    const




×








UNCOV

521



        ETH_Pool        = makeSingleTokenPool(Tokens.ETH),




×








UNCOV

522



        SYN_Pool        = makeSingleTokenPool(Tokens.SYN),




×








UNCOV

523



        FRAX_Pool       = makeSingleTokenPool(Tokens.FRAX),




×








UNCOV

524



        HIGH_Pool       = makeSingleTokenPool(Tokens.HIGH),




×








UNCOV

525



        DOG_Pool        = makeSingleTokenPool(Tokens.DOG),




×








UNCOV

526



        JUMP_Pool       = makeSingleTokenPool(Tokens.JUMP),




×








UNCOV

527



        NFD_Pool        = makeSingleTokenPool(Tokens.NFD),




×








UNCOV

528



        GOHM_Pool       = makeSingleTokenPool(Tokens.GOHM),




×








UNCOV

529



        GMX_Pool        = makeSingleTokenPool(Tokens.GMX),




×








UNCOV

530



        SOLAR_Pool      = makeSingleTokenPool(Tokens.SOLAR),




×








UNCOV

531



        AVAX_Pool       = makeSingleTokenPool(Tokens.AVAX),




×








UNCOV

532



        WAVAX_Pool      = makeSingleTokenPool(Tokens.WAVAX),




×








UNCOV

533



        MOVR_Pool       = makeSingleTokenPool(Tokens.MOVR),




×








UNCOV

534



        WMOVR_Pool      = makeSingleTokenPool(Tokens.WMOVR),




×








UNCOV

535



        UST_Pool        = makeSingleTokenPool(Tokens.UST),




×








UNCOV

536



        NEWO_Pool       = makeSingleTokenPool(Tokens.NEWO),




×








UNCOV

537



        SDT_Pool        = makeSingleTokenPool(Tokens.SDT),




×








UNCOV

538



        LUNA_Pool       = makeSingleTokenPool(Tokens.LUNA),




×








UNCOV

539



        USDB_Pool       = makeSingleTokenPool(Tokens.USDB),




×








UNCOV

540



        DFK_USDC_Pool   = makeSingleTokenPool(Tokens.DFK_USDC),




×








UNCOV

541



        XJEWEL_Pool     = makeSingleTokenPool(Tokens.XJEWEL),




×








UNCOV

542



        DFKTEARS_Pool   = makeSingleTokenPool(Tokens.DFKTEARS),




×








UNCOV

543



        VSTA_Pool       = makeSingleTokenPool(Tokens.VSTA),




×








UNCOV

544



        H20_Pool        = makeSingleTokenPool(Tokens.H20),




×








UNCOV

545



        SFI_Pool        = makeSingleTokenPool(Tokens.SFI),




×








UNCOV

546



        WBTC_Pool       = makeSingleTokenPool(Tokens.WBTC);




×








UNCOV

547






×








UNCOV

548



    const




×








UNCOV

549



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




×








UNCOV

550



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




×








UNCOV

551



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




×








UNCOV

552






×








UNCOV

553



    export type SwapTypePoolTokens = SwapTypeMap<LPToken>




×








UNCOV

554






×








UNCOV

555



    interface SwapTypeMapArgs {




×








UNCOV

556



        usdPool?:   [SwapToken, Token[]];




×








UNCOV

557



        ethPool?:   [ETHSwapToken, Token[]];




×








UNCOV

558



        ohm?:        boolean;




×








UNCOV

559



    }




×








UNCOV

560






×








UNCOV

561



    interface BridgeTokenMapping {




×








UNCOV

562



        swappableTokens:     SwapTypeMap<Token[]>;




×








UNCOV

563



        swappableSwapGroups: SwapTypeMap<LPToken>;




×








UNCOV

564



    }




×








UNCOV

565






×








UNCOV

566



    type ChainSwapTypePoolsMap = ChainIdTypeMap<BridgeTokenMapping>




×








UNCOV

567






×








UNCOV

568



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




×








UNCOV

569



        let m: BridgeTokenMapping = {




×








UNCOV

570



            swappableTokens: {




×








UNCOV

571



                [SwapType.SYN]: SYN_Pool.poolTokens,




×








UNCOV

572



                [SwapType.UST]: UST_Pool.poolTokens,




×








UNCOV

573



                [SwapType.OHM]: GOHM_Pool.poolTokens,




×








UNCOV

574



            },




×








UNCOV

575



            swappableSwapGroups: {




×








UNCOV

576



                [SwapType.SYN]: SYN_Pool,




×








UNCOV

577



                [SwapType.UST]: UST_Pool,




×








UNCOV

578



                [SwapType.OHM]: GOHM_Pool,




×








UNCOV

579



            }




×








UNCOV

580



        };




×








UNCOV

581






×








UNCOV

582



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




×








UNCOV

583






×








UNCOV

584



        if (usdPool) {




×








UNCOV

585



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




×








UNCOV

586



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




×








UNCOV

587



        }




×








UNCOV

588



        if (ethPool) {




×








UNCOV

589



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




×








UNCOV

590



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




×








UNCOV

591



        }




×








UNCOV

592






×








UNCOV

593



        for (const p of pools) {




×








UNCOV

594



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




×








UNCOV

595



            m.swappableSwapGroups[p.swapType] = p;




×








UNCOV

596



        }




×








UNCOV

597






×








UNCOV

598



        if (!useOhm) {




×








UNCOV

599



            delete m.swappableTokens[SwapType.OHM];




×








UNCOV

600



            delete m.swappableSwapGroups[SwapType.OHM];




×








UNCOV

601



        }




×








UNCOV

602






×








UNCOV

603



        return m




×








UNCOV

604



    }




×








UNCOV

605






×








UNCOV

606



    export const bridgeSwappableMap: ChainSwapTypePoolsMap = {




×








UNCOV

607



        [ChainId.ETH]: makeSwapTypeMap(




×








UNCOV

608



            {




×








UNCOV

609



                usdPool: [




×








UNCOV

610



                    ETH_POOL_SWAP_TOKEN,




×








UNCOV

611



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




×








UNCOV

612



                ]




×








UNCOV

613



            },




×








UNCOV

614



            ETH_Pool,




×








UNCOV

615



            HIGH_Pool,




×








UNCOV

616



            DOG_Pool,




×








UNCOV

617



            FRAX_Pool,




×








UNCOV

618



            NEWO_Pool,




×








UNCOV

619



            SDT_Pool,




×








UNCOV

620



            USDB_Pool,




×








UNCOV

621



            VSTA_Pool,




×








UNCOV

622



            H20_Pool,




×








UNCOV

623



            SFI_Pool,




×








UNCOV

624



            WBTC_Pool,




×








UNCOV

625



        ),




×








UNCOV

626



        [ChainId.OPTIMISM]: makeSwapTypeMap(




×








UNCOV

627



            {




×








UNCOV

628



                usdPool: [OPTIMISM_POOL_SWAP_TOKEN, OPTIMISM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

629



                ethPool: [OPTIMISM_ETH_SWAP_TOKEN,  OPTIMISM_ETH_SWAP_TOKEN.poolTokens]




×








UNCOV

630



            },




×








UNCOV

631



            LUNA_Pool,




×








UNCOV

632



        ),




×








UNCOV

633



        [ChainId.CRONOS]: makeSwapTypeMap(




×








UNCOV

634



            {




×








UNCOV

635



                usdPool: [CRONOS_POOL_SWAP_TOKEN, CRONOS_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

636



            }




×








UNCOV

637



        ),




×








UNCOV

638



        [ChainId.BSC]:    makeSwapTypeMap(




×








UNCOV

639



            {




×








UNCOV

640



                usdPool: [BSC_POOL_SWAP_TOKEN, BSC_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

641



            },




×








UNCOV

642



            HIGH_Pool,




×








UNCOV

643



            DOG_Pool,




×








UNCOV

644



            JUMP_Pool,




×








UNCOV

645



            NFD_Pool,




×








UNCOV

646



            USDB_Pool,




×








UNCOV

647



        ),




×








UNCOV

648



        [ChainId.POLYGON]: makeSwapTypeMap(




×








UNCOV

649



            {




×








UNCOV

650



                usdPool: [POLYGON_POOL_SWAP_TOKEN, POLYGON_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

651



            },




×








UNCOV

652



            NFD_Pool,




×








UNCOV

653



            DOG_Pool,




×








UNCOV

654



            USDB_Pool,




×








UNCOV

655



            H20_Pool,




×








UNCOV

656



        ),




×








UNCOV

657



        [ChainId.FANTOM]: makeSwapTypeMap(




×








UNCOV

658



            {




×








UNCOV

659



                usdPool: [FANTOM_POOL_SWAP_TOKEN, FANTOM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

660



                ethPool: [FANTOM_ETH_SWAP_TOKEN,  FANTOM_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

661



            },




×








UNCOV

662



            JUMP_Pool,




×








UNCOV

663



            FRAX_Pool,




×








UNCOV

664



            SDT_Pool,




×








UNCOV

665



            USDB_Pool,




×








UNCOV

666



        ),




×








UNCOV

667



        [ChainId.BOBA]: makeSwapTypeMap(




×








UNCOV

668



            {




×








UNCOV

669



                usdPool: [BOBA_POOL_SWAP_TOKEN, BOBA_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

670



                ethPool: [BOBA_ETH_SWAP_TOKEN,  BOBA_ETH_SWAP_TOKEN.poolTokens]




×








UNCOV

671



            },




×








UNCOV

672



        ),




×








UNCOV

673



        [ChainId.METIS]: makeSwapTypeMap(




×








UNCOV

674



            {




×








UNCOV

675



                usdPool: [METIS_POOL_SWAP_TOKEN, METIS_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

676



                ethPool: [METIS_ETH_SWAP_TOKEN,  METIS_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

677



            }




×








UNCOV

678



        ),




×








UNCOV

679



        [ChainId.MOONBEAM]: makeSwapTypeMap(




×








UNCOV

680



            {},




×








UNCOV

681



            SOLAR_Pool,




×








UNCOV

682



            WMOVR_Pool,




×








UNCOV

683



            WAVAX_Pool,




×








UNCOV

684



        ),




×








UNCOV

685



        [ChainId.MOONRIVER]: makeSwapTypeMap(




×








UNCOV

686



            {},




×








UNCOV

687



            SOLAR_Pool,




×








UNCOV

688



            FRAX_Pool,




×








UNCOV

689



            MOVR_Pool,




×








UNCOV

690



            USDB_Pool,




×








UNCOV

691



        ),




×








UNCOV

692



        [ChainId.ARBITRUM]: makeSwapTypeMap(




×








UNCOV

693



            {




×








UNCOV

694



                usdPool: [ARBITRUM_POOL_SWAP_TOKEN, ARBITRUM_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

695



                ethPool: [ARBITRUM_ETH_SWAP_TOKEN,  ARBITRUM_ETH_SWAP_TOKEN.poolTokens]




×








UNCOV

696



            },




×








UNCOV

697



            GMX_Pool,




×








UNCOV

698



            NEWO_Pool,




×








UNCOV

699



            LUNA_Pool,




×








UNCOV

700



            VSTA_Pool




×








UNCOV

701



        ),




×








UNCOV

702



        [ChainId.AVALANCHE]: makeSwapTypeMap(




×








UNCOV

703



            {




×








UNCOV

704



                usdPool: [AVALANCHE_POOL_SWAP_TOKEN, AVALANCHE_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

705



                ethPool: [AVALANCHE_ETH_SWAP_TOKEN,  AVALANCHE_ETH_SWAP_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

706



            },




×








UNCOV

707



            NFD_Pool,




×








UNCOV

708



            GMX_Pool,




×








UNCOV

709



            AVAX_Pool,




×








UNCOV

710



            NEWO_Pool,




×








UNCOV

711



            SDT_Pool,




×








UNCOV

712



            USDB_Pool,




×








UNCOV

713



            AVAX_JEWEL_Pool,




×








UNCOV

714



            SFI_Pool




×








UNCOV

715



        ),




×








UNCOV

716



        [ChainId.DFK]: {




×








UNCOV

717



            swappableTokens: {




×








UNCOV

718



                [SwapType.USD]:      DFK_USDC_Pool.poolTokens,




×








UNCOV

719



                [SwapType.JEWEL]:    DFK_JEWEL_Pool.poolTokens,




×








UNCOV

720



                [SwapType.XJEWEL]:   XJEWEL_Pool.poolTokens,




×








UNCOV

721



                [SwapType.DFKTEARS]: DFKTEARS_Pool.poolTokens,




×








UNCOV

722



                [SwapType.AVAX]:     WAVAX_Pool.poolTokens,




×








NEW


723



                [SwapType.ETH]:      [Tokens.DFK_ETH],




×








UNCOV

724



            },




×








UNCOV

725



            swappableSwapGroups: {




×








UNCOV

726



                [SwapType.USD]:      DFK_USDC_Pool,




×








UNCOV

727



                [SwapType.JEWEL]:    DFK_JEWEL_Pool,




×








UNCOV

728



                [SwapType.XJEWEL]:   XJEWEL_Pool,




×








UNCOV

729



                [SwapType.DFKTEARS]: DFKTEARS_Pool,




×








UNCOV

730



                [SwapType.AVAX]:     WAVAX_Pool,




×








NEW


731



                [SwapType.ETH]:      {poolTokens: [Tokens.DFK_ETH], swapType: SwapType.ETH},




×








UNCOV

732



            }




×








UNCOV

733



        },




×








UNCOV

734



        [ChainId.AURORA]: makeSwapTypeMap(




×








UNCOV

735



            {




×








UNCOV

736



                usdPool: [AURORA_POOL_SWAP_TOKEN, AURORA_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

737



                ohm:     false




×








UNCOV

738



            }




×








UNCOV

739



        ),




×








UNCOV

740



        [ChainId.HARMONY]: makeSwapTypeMap(




×








UNCOV

741



            {




×








UNCOV

742



                usdPool: [HARMONY_POOL_SWAP_TOKEN, HARMONY_POOL_SWAP_TOKEN.poolTokensForBridgeSwaps],




×








UNCOV

743



                ethPool: [HARMONY_ONEETH_TOKEN,    HARMONY_ONEETH_TOKEN.poolTokensForBridgeSwaps]




×








UNCOV

744



            },




×








UNCOV

745



            FRAX_Pool,




×








UNCOV

746



            SDT_Pool,




×








UNCOV

747



            HARMONY_AVAX_SWAP_TOKEN,




×








UNCOV

748



            XJEWEL_Pool,




×








UNCOV

749



            DFKTEARS_Pool,




×








UNCOV

750



            HARMONY_JEWEL_Pool




×








UNCOV

751



        ),




×








UNCOV

752



        [ChainId.KLAYTN]: {




×








UNCOV

753



            swappableTokens: {




×








UNCOV

754



                [SwapType.USD]: USDPoolTokens(),




×








UNCOV

755



                [SwapType.ETH]: [Tokens.ETH, Tokens.WETH],




×








UNCOV

756



                [SwapType.WBTC]: [Tokens.WBTC],




×








UNCOV

757



            },




×








UNCOV

758



            swappableSwapGroups: {




×








UNCOV

759



                [SwapType.USD]: {poolTokens: USDPoolTokens(), swapType: SwapType.USD},




×








UNCOV

760



                [SwapType.ETH]: {poolTokens: [Tokens.ETH, Tokens.WETH], swapType: SwapType.ETH},




×








UNCOV

761



                [SwapType.WBTC]: {poolTokens: [Tokens.WBTC], swapType: SwapType.WBTC},




×








UNCOV

762



            }




×








UNCOV

763



        },




×








UNCOV

764



    };




×








UNCOV

765






×








UNCOV

766



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




×








UNCOV

767



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




×








UNCOV

768



    }




×








UNCOV

769






×








UNCOV

770



    export function tokensForChainBySwapGroup(




×








UNCOV

771



        chainId: number,




×








UNCOV

772



        swapGroup: string




×








UNCOV

773



    ): Token[] {




×








UNCOV

774



        const m = bridgeSwappableMap[chainId].swappableTokens;




×








UNCOV

775



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




×








UNCOV

776



    }




×








UNCOV

777






×








UNCOV

778



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




×








UNCOV

779



        let swappableTokens: Token[] = [];




×








UNCOV

780






×








UNCOV

781



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




×








UNCOV

782



            const tokens = tokensForChainBySwapGroup(chainId, grp);




×








UNCOV

783



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




×








UNCOV

784



        })




×








UNCOV

785






×








UNCOV

786



        return swappableTokens




×








UNCOV

787



    }




×








UNCOV

788






×








UNCOV

789



    export function stableswapPoolForNetwork(chainId: number): SwapPoolToken {




×








UNCOV

790



        switch (chainId) {




×








UNCOV

791



            case ChainId.ETH:




×








UNCOV

792



                return ETH_POOL_SWAP_TOKEN




×








UNCOV

793



            case ChainId.OPTIMISM:




×








UNCOV

794



                return OPTIMISM_POOL_SWAP_TOKEN




×








UNCOV

795



            case ChainId.CRONOS:




×








UNCOV

796



                return CRONOS_POOL_SWAP_TOKEN




×








UNCOV

797



            case ChainId.BSC:




×








UNCOV

798



                return BSC_POOL_SWAP_TOKEN




×








UNCOV

799



            case ChainId.POLYGON:




×








UNCOV

800



                return POLYGON_POOL_SWAP_TOKEN




×








UNCOV

801



            case ChainId.FANTOM:




×








UNCOV

802



                return FANTOM_POOL_SWAP_TOKEN




×








UNCOV

803



            case ChainId.BOBA:




×








UNCOV

804



                return BOBA_POOL_SWAP_TOKEN




×








UNCOV

805



            case ChainId.METIS:




×








UNCOV

806



                return METIS_POOL_SWAP_TOKEN




×








UNCOV

807



            case ChainId.ARBITRUM:




×








UNCOV

808



                return ARBITRUM_POOL_SWAP_TOKEN




×








UNCOV

809



            case ChainId.AVALANCHE:




×








UNCOV

810



                return AVALANCHE_POOL_SWAP_TOKEN




×








UNCOV

811



            case ChainId.AURORA:




×








UNCOV

812



                return AURORA_POOL_SWAP_TOKEN




×








UNCOV

813



            case ChainId.HARMONY:




×








UNCOV

814



                return HARMONY_POOL_SWAP_TOKEN




×








UNCOV

815



        }




×








UNCOV

816






×








UNCOV

817



        return undefined




×








UNCOV

818



    }




×








UNCOV

819






×








UNCOV

820



    export function ethSwapPoolForNetwork(chainId: number): SwapPoolToken {




×








UNCOV

821



        switch (chainId) {




×








UNCOV

822



            case ChainId.OPTIMISM:




×








UNCOV

823



                return OPTIMISM_ETH_SWAP_TOKEN




×








UNCOV

824



            case ChainId.FANTOM:




×








UNCOV

825



                return FANTOM_ETH_SWAP_TOKEN




×








UNCOV

826



            case ChainId.BOBA:




×








UNCOV

827



                return BOBA_ETH_SWAP_TOKEN




×








UNCOV

828



            case ChainId.METIS:




×








UNCOV

829



                return METIS_ETH_SWAP_TOKEN




×








UNCOV

830



            case ChainId.ARBITRUM:




×








UNCOV

831



                return ARBITRUM_ETH_SWAP_TOKEN




×








UNCOV

832



            case ChainId.AVALANCHE:




×








UNCOV

833



                return AVALANCHE_ETH_SWAP_TOKEN




×








UNCOV

834



            case ChainId.HARMONY:




×








UNCOV

835



                return HARMONY_ONEETH_TOKEN




×








UNCOV

836



        }




×








UNCOV

837






×








UNCOV

838



        return undefined




×








UNCOV

839



    }




×








UNCOV

840






×








UNCOV

841



    export const AllSwapPoolTokens: SwapPoolToken[] = [




×








UNCOV

842



        ETH_POOL_SWAP_TOKEN,




×








UNCOV

843



        OPTIMISM_POOL_SWAP_TOKEN,




×








UNCOV

844



        OPTIMISM_ETH_SWAP_TOKEN,




×








UNCOV

845



        CRONOS_POOL_SWAP_TOKEN,




×








UNCOV

846



        BSC_POOL_SWAP_TOKEN,




×








UNCOV

847



        POLYGON_POOL_SWAP_TOKEN,




×








UNCOV

848



        FANTOM_POOL_SWAP_TOKEN,




×








UNCOV

849



        FANTOM_ETH_SWAP_TOKEN,




×








UNCOV

850



        BOBA_POOL_SWAP_TOKEN,




×








UNCOV

851



        BOBA_ETH_SWAP_TOKEN,




×








UNCOV

852



        METIS_POOL_SWAP_TOKEN,




×








UNCOV

853



        METIS_ETH_SWAP_TOKEN,




×








UNCOV

854



        ARBITRUM_POOL_SWAP_TOKEN,




×








UNCOV

855



        ARBITRUM_ETH_SWAP_TOKEN,




×








UNCOV

856



        AVALANCHE_POOL_SWAP_TOKEN,




×








UNCOV

857



        AVALANCHE_ETH_SWAP_TOKEN,




×








UNCOV

858



        AURORA_POOL_SWAP_TOKEN,




×








UNCOV

859



        HARMONY_POOL_SWAP_TOKEN,




×








UNCOV

860



        HARMONY_ONEETH_TOKEN,




×








UNCOV

861



        HARMONY_AVAX_SWAP_TOKEN,




×








UNCOV

862



        HARMONY_JEWEL_SWAP_TOKEN,




×








UNCOV

863



    ];




×








UNCOV

864






×








UNCOV

865



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




×








UNCOV

866



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




×








UNCOV

867



            return chainId === t.chainId




×








UNCOV

868



        }




×








UNCOV

869






×








UNCOV

870



        return true




×








UNCOV

871



    }




×








UNCOV

872






×








UNCOV

873



    enum CheckAddressKind {




×








UNCOV

874



        LpTokenAddress,




×








UNCOV

875



        SwapAddress




×








UNCOV

876



    }




×








UNCOV

877






×








UNCOV

878



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




×








UNCOV

879



        let res: SwapPoolToken = null;




×








UNCOV

880






×








UNCOV

881



        for (const t of AllSwapPoolTokens) {




×








UNCOV

882



            let checkAddress: string;




×








UNCOV

883



            switch (field) {




×








UNCOV

884



                case CheckAddressKind.LpTokenAddress:




×








UNCOV

885



                    checkAddress = t.address(t.chainId);




×








UNCOV

886



                    break;




×








UNCOV

887



                case CheckAddressKind.SwapAddress:




×








UNCOV

888



                    checkAddress = t.swapAddress;




×








UNCOV

889



                    break;




×








UNCOV

890



            }




×








UNCOV

891






×








UNCOV

892



            if (checkAddress === address) {




×








UNCOV

893



                if (checkChainId(t, chainId)) {




×








UNCOV

894



                    res = t;




×








UNCOV

895



                    break;




×








UNCOV

896



                }




×








UNCOV

897



            }




×








UNCOV

898



        }




×








UNCOV

899






×








UNCOV

900



        return res




×








UNCOV

901



    }




×








UNCOV

902






×








UNCOV

903



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




×








UNCOV

904



        return checkSwapPoolTokenAddress(lpTokenAddress, CheckAddressKind.LpTokenAddress, chainId)




×








UNCOV

905



    }




×








UNCOV

906






×








UNCOV

907



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




×








UNCOV

908



        return checkSwapPoolTokenAddress(swapAddress, CheckAddressKind.SwapAddress, chainId)




×








UNCOV

909



    }




×








UNCOV

910






×








UNCOV

911



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




×








UNCOV

912



        let res: SwapPoolToken = null;




×








UNCOV

913






×








UNCOV

914



        for (const t of swapPoolTokensForChainId(chainId)) {




×








UNCOV

915



            if (t.swapType === swapType) {




×








UNCOV

916



                res = t;




×








UNCOV

917



                break;




×








UNCOV

918



            }




×








UNCOV

919



        }




×








UNCOV

920






×








UNCOV

921



        return res




×








UNCOV

922



    }




×








UNCOV

923






×








UNCOV

924



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




×








UNCOV

925



        let res: SwapPoolToken[] = [];




×








UNCOV

926






×








UNCOV

927



        AllSwapPoolTokens.forEach(t => {




×








UNCOV

928



            if (t.chainId === chainId) {




×








UNCOV

929



                res.push(t);




×








UNCOV

930



            }




×








UNCOV

931



        });




×








UNCOV

932






×








UNCOV

933



        return res




×








UNCOV

934



    }




×








UNCOV

935



}





×







936






2✔





937



export type NetworkSwappableTokensMap     = ChainIdTypeMap<Token[]>;




2✔





938



export type AllNetworksSwappableTokensMap = ChainIdTypeMap<NetworkSwappableTokensMap>;




2✔





939






2✔






UNCOV

940



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




×








UNCOV

941



    let tokens: Token[] = [];




×








UNCOV

942






×








UNCOV

943



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




×








UNCOV

944



        if (chainAGrps.includes(grp)) {




×








UNCOV

945



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




×








UNCOV

946



        }




×








UNCOV

947



    })




×








UNCOV

948






×








UNCOV

949



    return tokens




×








UNCOV

950



}




×







951






2✔






UNCOV

952



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




×








UNCOV

953



    let res: NetworkSwappableTokensMap = {}




×








UNCOV

954






×








UNCOV

955



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




×








UNCOV

956



        if (chainIdA === chainId) {




×








UNCOV

957



            return




×








UNCOV

958



        }




×








UNCOV

959






×








UNCOV

960



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




×








UNCOV

961



    })




×








UNCOV

962






×








UNCOV

963



    return res




×








UNCOV

964



}




×







965






2✔





966






2✔





967



/**




2✔





968



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




2✔





969



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




2✔





970



 * @param chainIdA




2✔





971



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




2✔





972



 * @return NetworkSwappableTokensMap




2✔





973



 */




2✔





974



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




2✔






UNCOV

975



    let res: NetworkSwappableTokensMap = {};




×








UNCOV

976






×








UNCOV

977



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




×








UNCOV

978






×








UNCOV

979



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




×








UNCOV

980



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




×








UNCOV

981



    } else {




×








UNCOV

982



        res = swapGroupsLoop(chainIdA, swapGrpsA);




×








UNCOV

983



    }




×








UNCOV

984






×








UNCOV

985



    return res




×








UNCOV

986



}




×







987






2✔





988



/**




2✔





989



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




2✔





990



 * @return AllNetworksSwappableTokensMap




2✔





991



 */




2✔





992



export function allNetworksSwapTokensMap(): AllNetworksSwappableTokensMap {




2✔






UNCOV

993



    let res: AllNetworksSwappableTokensMap = {};




×








UNCOV

994






×








UNCOV

995



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




×








UNCOV

996



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




×








UNCOV

997






×








UNCOV

998



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




×








UNCOV

999



    })




×








UNCOV

1000






×








UNCOV

1001



    return res




×








UNCOV

1002



}



×





















    

  • 

    •