synapsecns/sdk | Build 2985776531 | src/bridge/bridge.ts | Coveralls

1

import {ChainId, type ChainIdTypeMap} from "@chainid";

2✔

2

import {Networks} from "@networks";

2✔

3

2✔

4

import {

2✔

5

    type Token,

2✔

6

    instanceOfToken

2✔

7

} from "@token";

2✔

8

2✔

9

import {Tokens}    from "@tokens";

2✔

10

import {TokenSwap} from "@tokenswap";

2✔

11

2✔

12

import {

2✔

13

    rejectPromise,

2✔

14

    executePopulatedTransaction

2✔

15

} from "@common/utils";

2✔

16

2✔

17

import {

2✔

18

    type GasOptions,

2✔

19

    populateGasOptions

2✔

20

} from "@common/gasoptions";

2✔

21

2✔

22

import {SynapseContracts} from "@synapsecontracts";

2✔

23

2✔

24

import type {

2✔

25

    SynapseBridgeContract,

2✔

26

    L1BridgeZapContract,

2✔

27

    L2BridgeZapContract,

2✔

28

    GenericZapBridgeContract

2✔

29

} from "@contracts";

2✔

30

2✔

31

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

2✔

32

import {SwapType} from "@internal/swaptype";

2✔

33

import {rpcProviderForChain} from "@internal/rpcproviders";

2✔

34

import {tokenSwitch} from "@internal/utils";

2✔

35

2✔

36

import * as SynapseEntities from "@entities";

2✔

37

2✔

38

import {BridgeConfig}               from "./bridgeconfig";

2✔

39

import {GasUtils}                   from "./gasutils";

2✔

40

import {BridgeUtils}                from "./bridgeutils";

2✔

41

import {

2✔

42

    MAX_APPROVAL_AMOUNT,

2✔

43

    approve,

2✔

44

    balanceOf,

2✔

45

    allowanceOf,

2✔

46

    buildApproveTransaction

2✔

47

} from "./erc20";

2✔

48

2✔

49

import type {ApproveArgs} from "./erc20";

2✔

50

2✔

51

import {id as makeKappa} from "@ethersproject/hash";

2✔

52

import {Zero}            from "@ethersproject/constants";

2✔

53

import {formatUnits}     from "@ethersproject/units";

2✔

54

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

2✔

55

2✔

56

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

2✔

57

import type {Signer}       from "@ethersproject/abstract-signer";

2✔

58

import type {Provider}     from "@ethersproject/providers";

2✔

59

2✔

60

import type {

2✔

61

    ContractTransaction,

2✔

62

    PopulatedTransaction,

2✔

63

} from "@ethersproject/contracts";

2✔

64

2✔

65

/**

2✔

66

 * Bridge provides a wrapper around common Synapse Bridge interactions, such as output estimation, checking supported swaps/bridges,

2✔

67

 * and most importantly, executing Bridge transactions.

2✔

68

*/

2✔

69

export namespace Bridge {

12✔

70

    import DFK_ETH = Tokens.DFK_ETH

12✔

71

    export type CanBridgeResult = {

12✔

72

        canBridge:     boolean;

12✔

73

        reasonUnable?: string;

12✔

74

        amount?:       BigNumber;

12✔

75

12✔

76

12✔

77

    type NeedsTokenApproveResult = {

12✔

78

        needsApproval:     boolean;

12✔

79

        currentAllowance?: BigNumber;

12✔

80

12✔

81

12✔

82

    export type BridgeOutputEstimate = {

12✔

83

        amountToReceive: BigNumber;

12✔

84

        bridgeFee:       BigNumber;

12✔

85

12✔

86

12✔

87

/**

12✔

88

     * @param {Token} tokenFrom {@link Token} user will send to the bridge on the source chain

12✔

89

     * @param {Token} tokenTo {@link Token} user will receive from the bridge on the destination chain

12✔

90

     * @param {number} chainIdTo Chain ID of the destination chain

12✔

91

     * @param {BigNumber} amountFrom not necessarily used by this interface, and overriden in BridgeParamsWithAmounts.

12✔

92

*/

12✔

93

    export interface BridgeParams {

12✔

94

        tokenFrom:   Token;

12✔

95

        tokenTo:     Token;

12✔

96

        chainIdTo:   number;

12✔

97

        amountFrom?: BigNumber;

12✔

98

12✔

99

12✔

100

/**

12✔

101

     * @param {BigNumber} amountFrom Amount of tokenFrom (denoted in wei) that the user will send to the bridge on the source chain.

12✔

102

     * @param {BigNumber} amountTo Amount of tokenTo (denoted in wei) that the user will receive from the bridge on the destination chain.

12✔

103

     * @param {string} addressTo Optional, user can provide an address other than the one retrieved from signer to receive tokens

12✔

104

     * on the destination chain.

12✔

105

*/

12✔

106

    export interface BridgeTransactionParams extends BridgeParams {

12✔

107

        amountFrom: BigNumber;

12✔

108

        amountTo:   BigNumber;

12✔

109

        addressTo?: string;

12✔

110

12✔

111

12✔

112

    type EasyArgsCheck = {

12✔

113

        isEasy:   boolean;

12✔

114

        castArgs: BridgeUtils.BridgeTxParams;

12✔

115

        txn?:     Promise<PopulatedTransaction>;

12✔

116

12✔

117

12✔

118

    type BridgeTokenArgs = {

12✔

119

        fromChainTokens: Token[];

12✔

120

        toChainTokens:   Token[];

12✔

121

        tokenFrom:       Token;

12✔

122

        tokenTo:         Token;

12✔

123

        tokenIndexFrom:  number;

12✔

124

        tokenIndexTo:    number;

12✔

125

12✔

126

12✔

127

    interface CheckCanBridgeParams {

12✔

128

        address?: string;

12✔

129

        signer?:  Signer;

12✔

130

        token:    Token;

12✔

131

        amount:   BigNumberish;

12✔

132

12✔

133

12✔

134

    interface CanBridgeParams extends CheckCanBridgeParams {

12✔

135

        address: string;

12✔

136

12✔

137

12✔

138

/**

12✔

139

     * SynapseBridge is a wrapper around any Synapse Bridge contract which exists on chains supported by the Synapse Protocol.

12✔

140

*/

12✔

141

    export class SynapseBridge {

12✔

142

        readonly chainId: number;

12✔

143

        protected network: Networks.Network;

12✔

144

        protected provider: Provider;

12✔

145

12✔

146

        private readonly bridgeAddress:    string;

12✔

147

        private readonly zapBridgeAddress: string;

12✔

148

12✔

149

        private readonly bridgeInstance: SynapseBridgeContract;

12✔

150

        private readonly zapBridge:      GenericZapBridgeContract;

12✔

151

        private readonly l1BridgeZapEth: L1BridgeZapContract = BridgeUtils.newL1BridgeZap(ChainId.ETH);

12✔

152

        private readonly bridgeConfig:   BridgeConfig = new BridgeConfig();

12✔

153

12✔

154

        private readonly isL2ETHChain: boolean;

12✔

155

12✔

156

        constructor(args: {

12✔

157

            network: Networks.Network | number,

848✔

158

            provider?: Provider

848✔

159

        }) {

848✔

160

            let {network, provider} = args;

848✔

161

848✔

162

            this.network = network instanceof Networks.Network ? network : Networks.fromChainId(network);

848✔

163

            this.chainId = this.network.chainId;

848✔

164

            this.provider = provider ?? rpcProviderForChain(this.chainId);

848✔

165

848✔

166

            this.isL2ETHChain = BridgeUtils.isL2ETHChain(this.chainId);

848✔

167

848✔

168

            const contractAddrs = SynapseContracts.contractsForChainId(this.chainId);

848✔

169

848✔

170

            this.bridgeAddress    = contractAddrs.bridgeAddress;

848✔

171

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

848✔

172

848✔

173

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(BridgeUtils.entityParams(this.chainId));

848✔

174

848✔

175

            if (this.zapBridgeAddress && this.zapBridgeAddress !== "") {

848✔

176

                this.zapBridge = BridgeUtils.newBridgeZap(this.chainId);

848✔

177

848✔

178

848✔

179

12✔

180

        private get l1BridgeZap(): L1BridgeZapContract {

12✔

183

12✔

184

        private get l2BridgeZap(): L2BridgeZapContract {

12✔

185

            return this.zapBridge as L2BridgeZapContract

90✔

186

90✔

187

12✔

188

        bridgeVersion(): Promise<BigNumber> {

12✔

189

            return this.bridgeInstance.bridgeVersion()

32✔

190

32✔

191

12✔

192

        WETH_ADDRESS(): Promise<string> {

12✔

193

            return this.bridgeInstance.WETH_ADDRESS()

32✔

194

32✔

195

12✔

196

        kappaExists(kappa: string): Promise<boolean> {

12✔

197

            return this.bridgeInstance.kappaExists(kappa)

6✔

198

6✔

199

12✔

200

        get requiredConfirmations(): number {

12✔

201

            return getRequiredConfirmationsForBridge(this.chainId)

8✔

202

8✔

203

12✔

204

/**

12✔

205

         * Returns whether a swap/bridge from this Bridge's chain to another chain between two tokens

12✔

206

         * is supported.

12✔

207

         * @param {Token} args.tokenFrom {@link Token} user will send to the bridge

12✔

208

         * @param {Token} args.tokenTo {@link Token} user will receive from the bridge on the destination chain

12✔

209

         * @param {number} args.chainIdTo Chain ID of the destination chain

12✔

210

         * @return boolean value denoting whether the input params constitute a valid swap/bridge, along with a

12✔

211

         * string value denoting the reason for an unsupported swap, if applicable.

12✔

212

*/

12✔

213

        swapSupported(args: {

12✔

214

            tokenFrom: Token,

488✔

215

            tokenTo:   Token

488✔

216

            chainIdTo: number,

488✔

217

        }): [boolean, string] {

488✔

218

            const {swapSupported, reasonNotSupported} = bridgeSwapSupported({...args, chainIdFrom: this.chainId});

488✔

219

488✔

220

            return [swapSupported, reasonNotSupported?.reason || ""]

488✔

221

488✔

222

12✔

223

/**

12✔

224

         * Returns the estimated output of a given token on the destination chain were a user to send

12✔

225

         * some amount of another given token on the source chain.

12✔

226

         * @param {BridgeParams} args Parameters for the output estimation.

12✔

227

         * @return {Promise<BridgeOutputEstimate>} Object containing the estimated output of args.tokenTo, as well

12✔

228

         * as the estimated fee to be taken by the bridge. Note that the estimated output already accounts for the

12✔

229

         * bridge fee, so the bridge fee is entirely for user-facing purposes. Do not use it for calculations.

12✔

230

*/

12✔

231

        async estimateBridgeTokenOutput(args: BridgeParams): Promise<BridgeOutputEstimate> {

12✔

232

            return this.checkSwapSupported(args)

326✔

233

                .then(() => this.calculateBridgeRate(args))

326✔

234

                .catch(rejectPromise)

326✔

235

326✔

236

12✔

237

/**

12✔

238

         * Returns a populated transaction for initiating a token bridge between this Bridge (the source chain) and the bridge contract on the destination chain.

12✔

239

         * Note that this function **does not** send a signed transaction.

12✔

240

         * @param {BridgeTransactionParams} args Parameters for the bridge transaction

12✔

241

         * @param {GasOptions} gasOptions Optional gas price/fee options for the populated transaction.

12✔

242

         * @return {Promise<PopulatedTransaction>} Populated transaction instance which can be sent via ones choice

12✔

243

         * of web3/ethers/etc.

12✔

244

*/

12✔

245

        async buildBridgeTokenTransaction(args: BridgeTransactionParams, gasOptions?: GasOptions): Promise<PopulatedTransaction> {

12✔

246

            const

272✔

247

                {addressTo} = args,

272✔

248

                tokenArgs = this.makeBridgeTokenArgs(args),

272✔

249

                {tokenFrom, tokenTo} = tokenArgs;

272✔

250

272✔

256

254✔

257

            args = {...args, tokenFrom, tokenTo};

254✔

258

254✔

259

            let newTxn: Promise<PopulatedTransaction> = (this.chainId === ChainId.ETH)

254✔

260

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

272✔

261

                : this.buildL2BridgeTxn(args, tokenArgs);

272✔

262

272✔

263

            return newTxn

272✔

264

                .then(txn =>

272✔

265

                    GasUtils.populateGasParams(this.chainId, txn, "bridge")

272✔

266

                        .then(txn => populateGasOptions(txn, gasOptions, this.chainId, true))

272✔

267

272✔

268

272✔

269

12✔

270

/**

12✔

271

         * Starts the Bridge process between this Bridge (the source chain) and the bridge contract on the destination chain.

12✔

272

         * Note that this function **does** send a signed transaction.

12✔

273

         * @param {BridgeTransactionParams} args Parameters for the bridge transaction.

12✔

274

         * @param {Signer} signer Some instance which implements the Ethersjs {@link Signer} interface.

12✔

275

         * @param {boolean} callStatic (Optional, default: false) if true, uses provider.callStatic instead of actually sending the signed transaction.

12✔

276

         * @return {Promise<ContractTransaction>}

12✔

277

*/

12✔

278

        async executeBridgeTokenTransaction(

12✔

285

            } catch (e) { /* c8 ignore start */

2✔

286

                return rejectPromise(e);

2✔

287

            } /* c8 ignore stop */

2✔

293

            if (!addressTo) { /* c8 ignore start */

2✔

294

                args.addressTo = signerAddress;

2✔

295

            } /* c8 ignore stop */

2✔

312

12✔

313

/**

12✔

314

         * Builds an ethers PopulatedTransaction instance for an ERC20 Approve call,

12✔

315

         * approving some amount of a given token to be spent by the Synapse Bridge on its chain.

12✔

316

         * The returned PopulatedTransaction must then be passed to the user via Web3 or some other

12✔

317

         * framework so they can ultimately send the transaction.

12✔

318

         * Should ALWAYS be called before performing any bridge transactions to ensure they don't fail.

12✔

319

         * @param {Object} args

12✔

320

         * @param {Token|string} args.token {@link Token} instance or valid on-chain address of the token the user will be sending

12✔

321

         * to the bridge on the source chain.

12✔

322

         * @param {BigNumberish} args.amount Optional, a specific amount of args.token to approve. By default, this function

12✔

323

         * builds an Approve call using an "infinite" approval amount.

12✔

324

         * @param {GasOptions} gasOptions Optional gas price/fee options for the populated transaction.

12✔

325

         * @return {Promise<PopulatedTransaction>} Populated transaction instance which can be sent via ones choice

12✔

326

         * of web3/ethers/etc.

12✔

327

*/

12✔

328

        async buildApproveTransaction(

12✔

337

12✔

338

/**

12✔

339

         * Builds and executes an ERC20 Approve call,

12✔

340

         * approving some amount of a given token to be spent by the Synapse Bridge on its chain.

12✔

341

         * The returned PopulatedTransaction must then be passed to the user via Web3 or some other

12✔

342

         * framework so they can ultimately send the transaction.

12✔

343

         * Should ALWAYS be called before performing any bridge transactions to ensure they don't fail.

12✔

344

         * @param {Object} args

12✔

345

         * @param {Token|string} args.token {@link Token} instance or valid on-chain address of the token the user will be sending

12✔

346

         * to the bridge on the source chain.

12✔

347

         * @param {BigNumberish} args.amount Optional, a specific amount of args.token to approve. By default, this function

12✔

348

         * @param {Signer} signer Valid ethers Signer instance for building a fully and properly populated

12✔

349

         * transaction.

12✔

350

*/

12✔

351

        async executeApproveTransaction(

12✔

361

12✔

362

        async getAllowanceForAddress(args: {

12✔

363

            address: string,

10✔

364

            token:   Token,

10✔

365

        }): Promise<BigNumber> {

10✔

366

            let { address, token } = args;

10✔

367

            let tokenAddress = token.address(this.chainId);

10✔

368

10✔

369

            return allowanceOf(address, this.zapBridgeAddress, {tokenAddress, chainId: this.chainId})

10✔

370

10✔

371

12✔

372

        private async resolveApproveFunc(

12✔

392

12✔

393

        private async checkNeedsApprove({

12✔

403

12✔

404

        private async resolveBalanceFunc(

12✔

423

12✔

424

        private async checkGasTokenBalance(args: CanBridgeParams): Promise<CanBridgeResult> {

12✔

435

12✔

436

        async checkCanBridge(args: CheckCanBridgeParams): Promise<CanBridgeResult> {

12✔

442

            if (address && address !== "") { /* c8 ignore start */

2✔

443

                signerAddress = address;

2✔

444

            } else {

2✔

445

                signerAddress = await signer.getAddress();

2✔

446

            } /* c8 ignore stop */

2✔

463

12✔

464

        private async checkERC20Balance(args: CanBridgeParams): Promise<CanBridgeResult> {

12✔

475

12✔

476

        buildERC20ApproveArgs(args: {

12✔

487

            /* c8 ignore start */

2✔

488

            let tokenAddr: string = instanceOfToken(token)

2✔

489

                ? token.address(this.chainId)

2✔

490

                : token as string;

2✔

491

            /* c8 ignore stop */

2✔

498

12✔

499

        private async checkSwapSupported(args: BridgeParams): Promise<boolean> {

12✔

500

            return new Promise<boolean>((resolve, reject) => {

326✔

501

                let [swapSupported, errReason] = this.swapSupported(args);

326✔

502

                if (!swapSupported) {

326✔

503

                    reject(errReason);

28✔

504

                    return

28✔

505

28✔

506

298✔

507

                resolve(true);

298✔

508

})

326✔

509

326✔

510

12✔

511

        private async calculateBridgeRate(args: BridgeParams): Promise<BridgeOutputEstimate> {

12✔

512

            let {chainIdTo, amountFrom} = args;

298✔

513

298✔

514

            const l2BridgeZapTo = BridgeUtils.newL2BridgeZap(chainIdTo);

298✔

515

298✔

516

            const {

298✔

517

                tokenFrom, tokenTo,

298✔

518

                tokenIndexFrom, tokenIndexTo,

298✔

519

                fromChainTokens

298✔

520

            } = this.makeBridgeTokenArgs(args);

298✔

521

298✔

522

            let {intermediateToken} = TokenSwap.intermediateTokens(chainIdTo, tokenFrom, this.chainId);

298✔

523

298✔

524

            const {

298✔

525

                bridgeFee:  bridgeFeeRequest,

298✔

526

                amountFrom: amountFromFixedDecimals

298✔

527

            } = this.bridgeConfig.calculateSwapFee({

298✔

528

                chainIdFrom: this.chainId,

298✔

529

                tokenFrom,

298✔

530

                chainIdTo,

298✔

531

                amountFrom

298✔

532

});

298✔

533

298✔

534

            const checkEthBridge = (c1: number, c2: number, t: Token): boolean =>

298✔

535

                c1 === ChainId.ETH && (BridgeUtils.isL2ETHChain(c2) || c2 === ChainId.DFK) && t.swapType === SwapType.ETH

298✔

536

298✔

537

            const

298✔

538

                isSpecialFrom: boolean = BridgeUtils.isSpecialToken(this.chainId, tokenFrom),

298✔

539

                isSpecialTo:   boolean = BridgeUtils.isSpecialToken(chainIdTo,    tokenTo);

298✔

540

298✔

541

            const

298✔

542

                ethToEth:   boolean = checkEthBridge(this.chainId, chainIdTo,    tokenTo),

298✔

543

                ethFromEth: boolean = checkEthBridge(chainIdTo,    this.chainId, tokenFrom);

298✔

544

298✔

545

            let amountToReceive_from_prom: Promise<BigNumber>;

298✔

546

298✔

547

            if (amountFrom.isZero()) {

298✔

548

                amountToReceive_from_prom = Promise.resolve(Zero);

8✔

549

            } else if (ethToEth || Tokens.isMintBurnToken(tokenFrom) || tokenFrom.isWrapperToken || isSpecialFrom || this.chainId === ChainId.KLAYTN) {

298✔

550

                amountToReceive_from_prom = Promise.resolve(amountFromFixedDecimals);

190✔

551

            } else if (this.chainId === ChainId.ETH) {

288✔

552

                let liquidityAmounts = fromChainTokens.map((t) =>

12✔

553

                    tokenFrom.isEqual(t) ? amountFrom : Zero

12✔

554

);

12✔

555

12✔

556

                amountToReceive_from_prom = this.l1BridgeZapEth.calculateTokenAmount(

12✔

557

                    liquidityAmounts,

12✔

558

                    true

12✔

559

);

12✔

560

            } else {

98✔

561

                amountToReceive_from_prom = this.l2BridgeZap.calculateSwap(

86✔

562

                    intermediateToken.address(this.chainId),

86✔

563

                    tokenIndexFrom,

86✔

564

0,

86✔

565

                    amountFrom

86✔

566

);

86✔

567

86✔

568

296✔

569

            let amountToReceive_from = await amountToReceive_from_prom;

296✔

570

            let bridgeFee: BigNumber;

298✔

571

298✔

572

            try { /* c8 ignore start */

2✔

573

                bridgeFee = await bridgeFeeRequest;

2✔

574

                if (bridgeFee === null) {

2✔

575

                    console.error("calculateSwapFee returned null");

2✔

576

                    return rejectPromise("calculateSwapFee returned null")

2✔

577

2✔

578

            } catch (e) {

2✔

579

                console.error(`Error in bridge fee request: ${e}`);

2✔

580

                return rejectPromise(e)

2✔

581

            } /* c8 ignore stop */

2✔

582

298✔

583

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

298✔

584

298✔

585

            let amountToReceive_to_prom: Promise<BigNumber>;

298✔

586

298✔

587

            if (amountToReceive_from.isZero()) {

298✔

588

                amountToReceive_to_prom = Promise.resolve(Zero);

298✔

589

            } else if (ethFromEth || Tokens.isMintBurnToken(tokenTo) || tokenTo.isWrapperToken || isSpecialTo) {

298✔

590

                amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

298✔

591

            } else if (chainIdTo === ChainId.ETH) {

298✔

592

                amountToReceive_to_prom =

298✔

593

                    this.l1BridgeZapEth.calculateRemoveLiquidityOneToken(

298✔

594

                        amountToReceive_from,

298✔

595

                        tokenIndexTo

298✔

596

);

298✔

597

            } else if (chainIdTo === ChainId.KLAYTN && tokenTo.swapType !== SwapType.ETH) {

298✔

598

                amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

298✔

599

            } else {

298✔

600

                if (chainIdTo === ChainId.CRONOS) {

298✔

601

                    const swapContract = await TokenSwap.swapContract(intermediateToken, chainIdTo);

298✔

602

                    amountToReceive_to_prom = swapContract.calculateSwap(0, tokenIndexTo, amountToReceive_from)

298✔

603

                } else {

298✔

604

                    amountToReceive_to_prom = l2BridgeZapTo.calculateSwap(

298✔

605

                        intermediateToken.address(chainIdTo),

298✔

606

0,

298✔

607

                        tokenIndexTo,

298✔

608

                        amountToReceive_from

298✔

609

);

298✔

610

298✔

611

298✔

612

298✔

613

            let amountToReceive: BigNumber;

298✔

614

            try { /* c8 ignore start */

2✔

615

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

2✔

616

            } catch (err) {

2✔

617

                return rejectPromise(err)

2✔

618

            } /* c8 ignore stop */

2✔

621

298✔

622

12✔

623

        private checkEasyArgs(

12✔

624

            args:      BridgeTransactionParams,

252✔

625

            zapBridge: GenericZapBridgeContract,

252✔

626

            easyDeposits:    ID[],

252✔

627

            easyRedeems:     ID[],

252✔

628

            easyDepositETH?: ID[],

252✔

629

        ): EasyArgsCheck {

252✔

630

let

252✔

631

                castArgs = args as BridgeUtils.BridgeTxParams,

252✔

632

                isEasy: boolean = false,

252✔

633

                txn:    Promise<PopulatedTransaction>;

252✔

634

252✔

635

            const params = BridgeUtils.makeEasyParams(castArgs, this.chainId, args.tokenTo);

252✔

636

252✔

637

            switch (true) {

252✔

638

                case easyRedeems.includes(args.tokenTo.id):

252✔

639

                    isEasy = true;

62✔

640

                    txn    = zapBridge.populateTransaction.redeem(...params);

62✔

641

                    break;

62✔

642

                case easyDeposits.includes(args.tokenTo.id):

252✔

643

                    isEasy = true;

34✔

644

                    txn    = zapBridge.populateTransaction.deposit(...params);

34✔

645

                    break;

34✔

646

                case easyDepositETH.includes(args.tokenTo.id):

252✔

647

                    isEasy = true;

14✔

648

                    txn    =  zapBridge

14✔

649

                        .populateTransaction

14✔

650

                        .depositETH(

14✔

651

                            ...BridgeUtils.depositETHParams(castArgs),

14✔

652

                            BridgeUtils.overrides(args.amountFrom)

14✔

653

);

14✔

654

                    break;

14✔

655

252✔

656

252✔

657

            return {castArgs, isEasy, txn}

252✔

658

252✔

659

12✔

660

        private buildETHMainnetBridgeTxn(

12✔

661

            args:      BridgeTransactionParams,

56✔

662

            tokenArgs: BridgeTokenArgs

56✔

663

        ): Promise<PopulatedTransaction> {

56✔

664

            const {addressTo, chainIdTo, amountFrom, amountTo} = args;

56✔

665

56✔

666

let

56✔

667

                easyRedeems:    ID[] = [

56✔

668

                    Tokens.SYN.id,  Tokens.UST.id,  Tokens.USDB.id,

56✔

669

                    Tokens.VSTA.id,

56✔

670

],

56✔

671

56✔

672

                // Deposits are for tokens that can just be deposited on source chains, mostly likely Ethereum

56✔

673

                easyDeposits:   ID[] = [

56✔

674

                    Tokens.HIGH.id, Tokens.DOG.id,  Tokens.FRAX.id,

56✔

675

                    Tokens.GOHM.id, Tokens.NEWO.id, Tokens.SDT.id,

56✔

676

                    Tokens.H20.id,  Tokens.SFI.id

56✔

677

],

56✔

678

                easyDepositETH: ID[] = [Tokens.NETH.id, Tokens.DFK_ETH.id];

56✔

679

56✔

680

            // use L1BridgeZap deposit() and `depositETH`

56✔

681

            if (chainIdTo === ChainId.KLAYTN) {

56✔

682

                easyDeposits.push(...[

10✔

683

                    Tokens.USDC.id,

10✔

684

                    Tokens.USDT.id,

10✔

685

                    Tokens.DAI.id,

10✔

686

                    Tokens.WBTC.id

10✔

687

])

10✔

688

10✔

689

56✔

690

            let {castArgs, isEasy, txn} = this.checkEasyArgs(args, this.l1BridgeZapEth, easyDeposits, easyRedeems, easyDepositETH);

56✔

691

            if (isEasy && txn) {

56✔

692

                return txn

32✔

693

32✔

694

24✔

695

            const liquidityAmounts = tokenArgs.fromChainTokens.map(t =>

24✔

696

                    args.tokenFrom.isEqual(t)

24✔

697

                        ? amountFrom

24✔

698

                        : Zero

24✔

699

);

24✔

700

24✔

701

            const {

24✔

702

                transactionDeadline,

24✔

703

                bridgeTransactionDeadline,

24✔

704

                minToSwapDestFromOrigin,

24✔

705

                minToSwapDest,

24✔

706

                minToSwapOriginMediumSlippage,

24✔

707

                minToSwapDestFromOriginMediumSlippage,

24✔

708

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

24✔

709

24✔

710

            if (args.tokenTo.isEqual(Tokens.NUSD) || args.tokenTo.isEqual(Tokens.DFK_USDC)) {

56✔

711

                if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC)) {

4✔

712

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

2✔

713

                        args as BridgeUtils.BridgeTxParams,

2✔

714

                        this.chainId,

2✔

715

                        Tokens.NUSD

2✔

716

);

2✔

717

2✔

718

                    return this.l1BridgeZapEth

2✔

719

                        .populateTransaction

2✔

720

                        .deposit(...bridgeDepositArgs)

2✔

721

                } else {

2✔

722

                    return this.l1BridgeZapEth.populateTransaction.zapAndDeposit(

2✔

723

                        addressTo,

2✔

724

                        chainIdTo,

2✔

725

                        Tokens.NUSD.address(this.chainId),

2✔

726

                        liquidityAmounts,

2✔

727

                        minToSwapDest,

2✔

728

                        transactionDeadline,

2✔

729

2✔

730

2✔

731

4✔

732

18✔

733

            if (BridgeUtils.isETHLikeToken(args.tokenTo) || args.tokenTo.isEqual(Tokens.WETH)) {

56✔

734

                return this.l1BridgeZapEth.populateTransaction.depositETHAndSwap(

14✔

735

                    ...BridgeUtils.depositETHParams(castArgs),

14✔

736

                    0, // nusd tokenindex,

14✔

737

                    tokenArgs.tokenIndexTo,

14✔

738

                    minToSwapDestFromOrigin, // minDy

14✔

739

                    bridgeTransactionDeadline,

14✔

740

                    BridgeUtils.overrides(amountFrom)

14✔

741

14✔

742

            } else if (args.tokenFrom.isEqual(Tokens.NUSD)) {

54✔

743

                return this.l1BridgeZapEth.populateTransaction.depositAndSwap(

2✔

744

                    addressTo,

2✔

745

                    chainIdTo,

2✔

746

                    Tokens.NUSD.address(this.chainId),

2✔

747

                    amountFrom,

2✔

748

0,

2✔

749

                    tokenArgs.tokenIndexTo,

2✔

750

                    minToSwapDestFromOriginMediumSlippage,

2✔

751

                    bridgeTransactionDeadline

2✔

752

2✔

753

2✔

754

2✔

755

            return this.l1BridgeZapEth.populateTransaction.zapAndDepositAndSwap(

2✔

756

                addressTo,

2✔

757

                chainIdTo,

2✔

758

                Tokens.NUSD.address(this.chainId),

2✔

759

                liquidityAmounts,

2✔

760

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

2✔

761

                transactionDeadline,

2✔

762

0,

2✔

763

                tokenArgs.tokenIndexTo,

2✔

764

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

2✔

765

                bridgeTransactionDeadline,

2✔

766

2✔

767

2✔

768

12✔

769

        private buildL2BridgeTxn(

12✔

770

            args: BridgeTransactionParams,

198✔

771

            tokenArgs: BridgeTokenArgs

198✔

772

        ): Promise<PopulatedTransaction> {

198✔

773

let

198✔

774

                {chainIdTo, amountFrom, amountTo} = args,

198✔

775

                // NOTE: This is a problem - we don't support other L1s. Klaytn still uses L2BridgeZap However

198✔

776

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

198✔

777

                    chainId:          this.chainId,

198✔

778

                    signerOrProvider: this.provider

198✔

779

});

198✔

780

198✔

781

            tokenArgs.tokenFrom = tokenArgs.tokenFrom.isEqual(Tokens.AVWETH)

198✔

783

                : tokenArgs.tokenFrom;

198✔

784

198✔

785

            if (tokenArgs.tokenFrom.isEqual(Tokens.MULTIJEWEL)) {

198✔

786

                const jewelMigrator = SynapseEntities.AvaxJewelMigrationContractInstance();

2✔

787

2✔

788

                return jewelMigrator

2✔

789

                    .populateTransaction

2✔

790

                    .migrateAndBridge(

2✔

791

                        args.amountFrom,

2✔

792

                        args.addressTo,

2✔

793

                        args.chainIdTo

2✔

794

2✔

795

2✔

796

196✔

797

let

196✔

798

                easyDeposits:   ID[] = [],

196✔

799

                easyDepositETH: ID[] = [],

196✔

800

196✔

801

                // Redeems are for tokens that can just be burnt on non-source chains

196✔

802

                easyRedeems:    ID[] = [

196✔

803

                    Tokens.SYN.id,      Tokens.HIGH.id,    Tokens.DOG.id,

196✔

804

                    Tokens.FRAX.id,     Tokens.UST.id,     Tokens.GOHM.id,

196✔

805

                    Tokens.NEWO.id,     Tokens.SDT.id,     Tokens.LUNA.id,

196✔

806

                    Tokens.USDB.id,     Tokens.H20.id,     Tokens.SFI.id,

196✔

807

                    Tokens.BTCB.id

196✔

808

];

196✔

809

196✔

810

            // use `L2BridgeZap.redeem()`

196✔

811

            if (this.chainId === ChainId.KLAYTN) {

198✔

812

                easyRedeems.push(...[

8✔

813

                    Tokens.USDC.id,

8✔

814

                    Tokens.USDT.id,

8✔

815

                    Tokens.DAI.id,

8✔

816

                    Tokens.WBTC.id

8✔

817

])

8✔

818

                if (chainIdTo === ChainId.ETH) {

8✔

819

                    easyRedeems.push(Tokens.WETH.id)

8✔

820

8✔

821

8✔

822

                easyDepositETH.push(Tokens.WKLAY.id)

8✔

823

8✔

824

196✔

825

            if (this.chainId === ChainId.POLYGON) {

198✔

826

                easyDepositETH.push(Tokens.WMATIC.id)

10✔

827

10✔

828

196✔

829

            if (this.chainId === ChainId.FANTOM) {

198✔

830

                easyDepositETH.push(Tokens.WFTM.id)

14✔

831

14✔

832

196✔

833

            BridgeUtils.DepositIfChainTokens.forEach((depositIfChainArgs) => {

196✔

834

                if (this.chainId === ChainId.DFK && args.tokenTo.isEqual(Tokens.SYN_AVAX)) {

2,352✔

835

                    return

24✔

836

24✔

837

2,328✔

838

                let {chainId, tokens, depositEth, redeemChainIds} = depositIfChainArgs;

2,328✔

839

2,328✔

840

let

2,328✔

841

                    hasAltChains = redeemChainIds.length > 0,

2,328✔

842

                    tokenHashes  = tokens.map((t) => t.id);

2,328✔

843

2,328✔

844

                if (this.chainId === chainId) {

2,352✔

845

                    if (depositEth) {

230✔

846

                        easyDepositETH.push(...tokenHashes);

94✔

847

                    } else {

230✔

848

                        easyDeposits.push(...tokenHashes);

136✔

849

136✔

850

                } else {

2,352✔

851

                    if (hasAltChains && redeemChainIds.includes(this.chainId)) {

2,098✔

852

                        easyRedeems.push(...tokenHashes);

156✔

853

156✔

854

2,098✔

855

});

196✔

856

196✔

857

            const

196✔

858

                dfkBridgeZap = BridgeUtils.newL1BridgeZap(ChainId.DFK),

196✔

859

                checkEasyZap = this.chainId === ChainId.DFK ? dfkBridgeZap : this.zapBridge;

198✔

860

198✔

861

            let {castArgs, isEasy, txn} = this.checkEasyArgs(args, checkEasyZap, easyDeposits, easyRedeems, easyDepositETH);

198✔

862

            if (isEasy && txn) {

198✔

863

                return txn

78✔

864

78✔

865

118✔

866

            const {

118✔

867

                transactionDeadline,

118✔

868

                bridgeTransactionDeadline,

118✔

869

                minToSwapDestFromOrigin,

118✔

870

                minToSwapOriginHighSlippage,

118✔

871

                minToSwapDestFromOriginMediumSlippage,

118✔

872

                minToSwapDestFromOriginHighSlippage,

118✔

873

                minToSwapDest,

118✔

874

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

118✔

875

118✔

876

            const easyRedeemAndSwap = (baseToken: Token): Promise<PopulatedTransaction> =>

118✔

877

                zapBridge

8✔

878

                    .populateTransaction

118✔

879

                    .redeemAndSwap(

118✔

880

                        ...BridgeUtils.makeEasyParams(castArgs, this.chainId, baseToken),

118✔

881

0,

118✔

882

                        tokenArgs.tokenIndexTo,

118✔

883

                        minToSwapDest,

118✔

884

                        transactionDeadline,

118✔

885

118✔

886

118✔

888

                let populateFn = swapETH

16✔

889

                    ? zapBridge.populateTransaction.swapETHAndRedeem

16✔

890

                    : zapBridge.populateTransaction.swapAndRedeem

16✔

891

16✔

892

                return populateFn(

16✔

893

                    ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, baseToken),

16✔

894

                    tokenArgs.tokenIndexFrom,

16✔

895

0,

16✔

896

                    amountFrom,

16✔

897

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

16✔

898

                    transactionDeadline,

16✔

899

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

16✔

900

16✔

901

16✔

902

118✔

903

            const easySwapAndRedeemAndSwap = (baseToken: Token, swapETH: boolean = false): Promise<PopulatedTransaction> => {

118✔

904

                let populateFn = swapETH

26✔

905

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

26✔

906

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

26✔

907

26✔

908

                return populateFn(

26✔

909

                    ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, baseToken),

26✔

910

                    tokenArgs.tokenIndexFrom,

26✔

911

0,

26✔

912

                    amountFrom,

26✔

913

                    minToSwapOriginHighSlippage,

26✔

914

                    transactionDeadline,

26✔

915

0,

26✔

916

                    tokenArgs.tokenIndexTo,

26✔

917

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

26✔

918

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

26✔

919

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

26✔

920

26✔

921

26✔

922

118✔

923

            switch (tokenSwitch(args.tokenTo)) {

118✔

924

                case Tokens.NUSD:

198✔

925

                case Tokens.DFK_USDC:

198✔

926

                    if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC)) {

10✔

927

                        return zapBridge

4✔

928

                            .populateTransaction

4✔

929

                            .redeem(...BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.NUSD))

4✔

930

4✔

931

6✔

932

                    return zapBridge

6✔

933

                        .populateTransaction

6✔

934

                        .swapAndRedeem(

6✔

935

                            ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.NUSD),

6✔

936

                            tokenArgs.tokenIndexFrom,

6✔

937

0,

6✔

938

                            amountFrom,

6✔

939

                            minToSwapOriginHighSlippage,

6✔

940

                            transactionDeadline

6✔

941

198✔

942

                case Tokens.GMX:

198✔

943

                    let params = BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.GMX);

4✔

944

                    let [addrTo, chainTo,,amount] = params;

4✔

945

4✔

946

                    // GMX origin chain is Arbitrum, hence deposit there

4✔

947

                    return this.chainId === ChainId.ARBITRUM

4✔

948

                        ? zapBridge.populateTransaction.deposit(...params)

4✔

949

                        : this.bridgeInstance

4✔

950

                            .populateTransaction

2✔

951

                            .redeem(

2✔

952

                                addrTo,

2✔

953

                                chainTo,

2✔

954

                                Tokens.GMX.wrapperAddress(this.chainId),

2✔

955

                                amount

2✔

956

4✔

957

                case Tokens.JEWEL:

198✔

958

                    if (this.chainId === ChainId.HARMONY) {

10✔

959

                        return zapBridge

2✔

960

                            .populateTransaction

2✔

961

                            .swapAndRedeem(

2✔

962

                                ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.SYN_JEWEL),

2✔

963

0,

2✔

964

1,

2✔

965

                                amountFrom,

2✔

966

                                minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

2✔

967

                                transactionDeadline

2✔

968

2✔

969

                    } else if (this.chainId === ChainId.DFK) {

10✔

970

                        if (args.chainIdTo === ChainId.HARMONY) {

4✔

971

                            return dfkBridgeZap.populateTransaction.depositETHAndSwap(

2✔

972

                                args.addressTo,

2✔

973

                                args.chainIdTo,

2✔

974

                                args.amountFrom,

2✔

975

1,

2✔

976

0,

2✔

977

                                minToSwapDestFromOriginMediumSlippage,

2✔

978

                                bridgeTransactionDeadline,

2✔

979

                                BridgeUtils.overrides(args.amountFrom)

2✔

980

2✔

981

2✔

982

2✔

983

                        return dfkBridgeZap.populateTransaction.depositETH(

2✔

984

                            args.addressTo,

2✔

985

                            args.chainIdTo,

2✔

986

                            args.amountFrom,

2✔

987

                            BridgeUtils.overrides(args.amountFrom)

2✔

988

2✔

989

2✔

990

4✔

991

                    if (chainIdTo === ChainId.DFK) {

10✔

992

                        return zapBridge.populateTransaction.redeem(

2✔

993

                            args.addressTo,

2✔

994

                            ChainId.DFK,

2✔

995

                            Tokens.JEWEL.address(this.chainId),

2✔

996

                            args.amountFrom

2✔

997

2✔

998

2✔

999

2✔

1000

                    return zapBridge.populateTransaction.redeemAndSwap(

2✔

1001

                        args.addressTo,

2✔

1002

                        args.chainIdTo,

2✔

1003

                        Tokens.JEWEL.address(this.chainId),

2✔

1004

                        args.amountFrom,

2✔

1005

1,

2✔

1006

0,

2✔

1007

                        minToSwapDest,

2✔

1008

                        transactionDeadline

2✔

1009

2✔

1010

                case Tokens.SYN_JEWEL:

198✔

1011

                    if (this.chainId === ChainId.DFK) {

4✔

1012

                        return dfkBridgeZap

2✔

1013

                            .populateTransaction

2✔

1014

                            .depositETH(

2✔

1015

                                args.addressTo,

2✔

1016

                                args.chainIdTo,

2✔

1017

                                args.amountFrom,

2✔

1018

                                BridgeUtils.overrides(args.amountFrom)

2✔

1019

2✔

1020

2✔

1021

2✔

1022

                    return zapBridge

2✔

1023

                        .populateTransaction

2✔

1024

                        .swapAndRedeem(

2✔

1025

                            ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.JEWEL),

2✔

1026

0,

2✔

1027

1,

2✔

1028

                            amountFrom,

2✔

1029

                            minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

2✔

1030

                            transactionDeadline

2✔

1031

198✔

1032

                case Tokens.SYN_AVAX:

198✔

1033

                    if (this.chainId === ChainId.DFK) {

2✔

1034

                        return dfkBridgeZap

2✔

1035

                            .populateTransaction

2✔

1036

                            .redeem(...BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.WAVAX))

2✔

1037

2✔

1039

                    /* c8 ignore next */

2✔

1040

                    break;

2✔

1041

                case Tokens.MULTI_AVAX:

198✔

1042

                    switch (this.chainId) {

6✔

1043

                        case ChainId.DFK:

6✔

1044

                            return dfkBridgeZap

2✔

1045

                                .populateTransaction

2✔

1046

                                .redeemAndSwap(

2✔

1047

                                    castArgs.addressTo,

2✔

1048

                                    castArgs.chainIdTo,

2✔

1049

                                    Tokens.WAVAX.address(this.chainId),

2✔

1050

                                    castArgs.amountFrom,

2✔

1051

0,

2✔

1052

                                    tokenArgs.tokenIndexTo,

2✔

1053

                                    minToSwapDest,

2✔

1054

                                    transactionDeadline

2✔

1055

2✔

1056

                        case ChainId.MOONBEAM:

6✔

1057

                            return this.l2BridgeZap

2✔

1058

                                .populateTransaction

2✔

1059

                                .redeemAndSwap(

2✔

1060

                                    castArgs.addressTo,

2✔

1061

                                    castArgs.chainIdTo,

2✔

1062

                                    Tokens.WAVAX.address(this.chainId),

2✔

1063

                                    castArgs.amountFrom,

2✔

1064

0,

2✔

1065

                                    tokenArgs.tokenIndexTo,

2✔

1066

                                    minToSwapDest,

2✔

1067

                                    transactionDeadline

2✔

1068

2✔

1069

                        default:

6✔

1070

                            return this.l2BridgeZap

2✔

1071

                                .populateTransaction

2✔

1072

                                .depositETHAndSwap(

2✔

1073

                                    castArgs.addressTo, // to address

2✔

1074

                                    castArgs.chainIdTo, // to chainId

2✔

1075

                                    castArgs.amountFrom,

2✔

1076

                                    0, // tokenIndexFrom for nusd

2✔

1077

                                    tokenArgs.tokenIndexTo, // tokenIndexTo + 1,

2✔

1078

                                    minToSwapDestFromOrigin, // minDy

2✔

1079

                                    bridgeTransactionDeadline,

2✔

1080

                                    BridgeUtils.overrides(castArgs.amountFrom)

2✔

1081

2✔

1082

6✔

1083

                default:

198✔

1084

                    if (chainIdTo === ChainId.ETH) {

74✔

1085

                        if ((this.isL2ETHChain || this.chainId === ChainId.DFK) && args.tokenFrom.swapType === SwapType.ETH) {

22✔

1086

                            if (args.tokenFrom.isEqual(Tokens.NETH) || args.tokenFrom.isEqual(Tokens.DFK_ETH)) {

14✔

1087

                                let ethToken = (this.chainId === ChainId.DFK) ? Tokens.DFK_ETH : Tokens.NETH

6✔

1088

                                return zapBridge

6✔

1089

                                    .populateTransaction

6✔

1090

                                    .redeem(...BridgeUtils.makeEasyParams(castArgs, this.chainId, ethToken))

6✔

1091

                            } else {

14✔

1092

                                let useSwapETH = !BridgeUtils.isETHLikeToken(args.tokenFrom);

8✔

1093

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

8✔

1094

8✔

1095

                        } else if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC)) {

22✔

1096

                            return zapBridge

4✔

1097

                                .populateTransaction

4✔

1098

                                .redeemAndRemove(

4✔

1099

                                    ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.NUSD),

4✔

1100

                                    amountFrom,

4✔

1101

                                    tokenArgs.tokenIndexTo,

4✔

1102

                                    minToSwapDest,

4✔

1103

                                    transactionDeadline

4✔

1104

4✔

1105

4✔

1106

4✔

1107

                        return zapBridge

4✔

1108

                            .populateTransaction

4✔

1109

                            .swapAndRedeemAndRemove(

4✔

1110

                                ...BridgeUtils.makeEasySubParams(castArgs, this.chainId, Tokens.NUSD),

4✔

1111

                                tokenArgs.tokenIndexFrom,

4✔

1112

0,

4✔

1113

                                amountFrom,

4✔

1114

                                minToSwapOriginHighSlippage,

4✔

1115

                                transactionDeadline,

4✔

1116

                                tokenArgs.tokenIndexTo, //swapTokenIndex

4✔

1117

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

4✔

1118

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

4✔

1119

4✔

1120

4✔

1121

52✔

1122

                    if (this.chainId === ChainId.HARMONY) {

74✔

1123

                        if (args.tokenFrom.isEqual(Tokens.SYN_AVAX)) {

8✔

1124

                            const redeemArgs = BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.SYN_AVAX);

4✔

1125

4✔

1126

                            return zapBridge

4✔

1127

                                .populateTransaction

4✔

1128

                                .redeem(...redeemArgs)

4✔

1129

                        } else if (args.tokenFrom.isEqual(Tokens.MULTI_AVAX)) {

4✔

1130

                            return zapBridge

2✔

1131

                                .populateTransaction

2✔

1132

                                .swapAndRedeem(

2✔

1133

                                    castArgs.addressTo,

2✔

1134

                                    castArgs.chainIdTo,

2✔

1135

                                    Tokens.SYN_AVAX.address(this.chainId),

2✔

1136

                                    tokenArgs.tokenIndexFrom,

2✔

1137

0,

2✔

1138

                                    castArgs.amountFrom,

2✔

1139

                                    minToSwapOriginHighSlippage,

2✔

1140

                                    transactionDeadline

2✔

1141

2✔

1142

2✔

1143

8✔

1144

46✔

1145

                    if ((this.chainId === ChainId.DFK || chainIdTo === ChainId.DFK) && args.tokenFrom.swapType === SwapType.ETH) {

74✔

1146

                        if (this.isL2ETHChain) {

12✔

1147

                            if (args.tokenFrom.isEqual(Tokens.NETH)) {

8✔

1148

                                // Swapping nETH from L2 -> nETH on DFK

2✔

1149

                                return zapBridge.populateTransaction.redeem(

2✔

1150

                                    ...BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.NETH)

2✔

1151

);

2✔

1152

                            } else {

8✔

1153

                                // Swapping WETH from L2 -> nETH on DFK

6✔

1154

                                let ethToken = Tokens.WETH

6✔

1155

                                let swapEth = true

6✔

1156

6✔

1157

                                // WETH_E and FTM_ETH are ERC20s, not the gas token

6✔

1158

                                if (this.chainId === ChainId.AVALANCHE || this.chainId === ChainId.FANTOM) {

6✔

1159

                                    ethToken = Tokens.NETH

4✔

1160

                                    swapEth = false

4✔

1161

4✔

1162

6✔

1163

                                return easySwapAndRedeem(ethToken, swapEth)

6✔

1164

6✔

1165

                        } else {

12✔

1166

                            // Note: NETH is passed as tokenTo args as DFK_USDC is NETH underneath

4✔

1167

                            if (args.tokenTo.isEqual(Tokens.NETH)) {

4✔

1168

                                // DFK_ETH from DFK -> NETH on L2s

2✔

1169

                                return zapBridge.populateTransaction.redeem(

2✔

1170

                                    ...BridgeUtils.makeEasyParams(castArgs, this.chainId, Tokens.DFK_ETH)

2✔

1171

);

2✔

1172

                            } else {

2✔

1173

                                // DFK_ETH from DFK -> WETH on L2s

2✔

1174

                                return easyRedeemAndSwap(Tokens.DFK_ETH)

2✔

1175

2✔

1176

4✔

1177

12✔

1178

34✔

1179

                    // Bridging ETH from Klaytn to L2s

34✔

1184

34✔

1185

                    // Bridging ETH From L2s

34✔

1186

                    if (chainIdTo === ChainId.KLAYTN &&

34✔

1187

                        this.isL2ETHChain &&

74✔

1188

                        args.tokenFrom.swapType === SwapType.ETH

2✔

1189

) {

74✔

1190

                        // To bridge ETH from chains where it IS the gas token, use swapETHAndRedeem

2✔

1191

                        // This is because ETH is wrapped into WETH, swapped for nETH and then burnt

2✔

1192

                        return easySwapAndRedeem(args.tokenFrom, true)

2✔

1193

2✔

1194

32✔

1195

                    if (args.tokenFrom.isEqual(Tokens.NUSD) || args.tokenFrom.isEqual(Tokens.DFK_USDC) || args.tokenFrom.isEqual(Tokens.NETH)) {

74✔

1196

                        return easyRedeemAndSwap(args.tokenFrom)

6✔

1197

6✔

1198

26✔

1199

                    if (args.tokenFrom.swapType === SwapType.ETH) {

74✔

1200

                        let useSwapETH = !BridgeUtils.isETHLikeToken(args.tokenFrom);

22✔

1201

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

22✔

1202

22✔

1203

4✔

1204

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

4✔

1205

198✔

1206

198✔

1207

12✔

1208

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

12✔

1209

            let {tokenFrom, tokenTo, chainIdTo} = args;

570✔

1210

570✔

1211

            let bridgeTokens: (t1: Token, t2: Token) => [Token, Token];

570✔

1212

570✔

1213

            switch (tokenFrom.swapType) {

570✔

1214

                case SwapType.ETH:

570✔

1215

                    bridgeTokens = BridgeUtils.checkReplaceTokens(Tokens.ETH, Tokens.WETH);

166✔

1216

                    break;

166✔

1217

                case SwapType.AVAX:

570✔

1218

                    bridgeTokens = BridgeUtils.checkReplaceTokens(Tokens.AVAX, Tokens.WAVAX);

44✔

1219

                    break;

44✔

1220

                case SwapType.MOVR:

570✔

1221

                    bridgeTokens = BridgeUtils.checkReplaceTokens(Tokens.MOVR, Tokens.WMOVR);

8✔

1222

                    break;

8✔

1231

                    break;

570✔

1232

                case SwapType.JEWEL:

570✔

1233

                    bridgeTokens = BridgeUtils.checkReplaceTokens(Tokens.GAS_JEWEL, Tokens.JEWEL);

34✔

1234

                    break;

34✔

1235

                default:

570✔

1236

                    bridgeTokens = (t1: Token, t2: Token) => [t1, t2];

318✔

1237

570✔

1238

570✔

1239

            [tokenFrom, tokenTo] = bridgeTokens(tokenFrom, tokenTo);

570✔

1240

570✔

1241

            const

570✔

1242

                [fromChainTokens, tokenIndexFrom] = BridgeUtils.makeTokenArgs(this.chainId, tokenFrom),

570✔

1243

                [toChainTokens,   tokenIndexTo]   = BridgeUtils.makeTokenArgs(chainIdTo,    tokenTo);

570✔

1244

570✔

1245

            return {

570✔

1246

                fromChainTokens,

570✔

1247

                toChainTokens,

570✔

1248

                tokenFrom,

570✔

1249

                tokenTo,

570✔

1250

                tokenIndexFrom,

570✔

1251

                tokenIndexTo

570✔

1252

570✔

1253

570✔

1254

12✔

1255

12✔

1256

    const REQUIRED_CONFS: ChainIdTypeMap<number> = {

12✔

1257

        [ChainId.ETH]:       7,

12✔

1258

        [ChainId.OPTIMISM]:  1,

12✔

1259

        [ChainId.CRONOS]:    6,

12✔

1260

        [ChainId.BSC]:       14,

12✔

1261

        [ChainId.POLYGON]:   128,

12✔

1262

        [ChainId.FANTOM]:    5,

12✔

1263

        [ChainId.BOBA]:      1,

12✔

1264

        [ChainId.METIS]:     6,

12✔

1265

        [ChainId.MOONBEAM]:  21,

12✔

1266

        [ChainId.MOONRIVER]: 21,

12✔

1267

        [ChainId.ARBITRUM]:  40,

12✔

1268

        [ChainId.AVALANCHE]: 5,

12✔

1269

        [ChainId.DFK]:       1,

12✔

1270

        [ChainId.HARMONY]:   1,

12✔

1271

        [ChainId.AURORA]:    5,

12✔

1272

};

12✔

1273

12✔

1274

    export function getRequiredConfirmationsForBridge(network: Networks.Network | number): number | null {

12✔

1275

        let chainId: number = network instanceof Networks.Network ? network.chainId : network;

18✔

1276

18✔

1277

        if (chainId in REQUIRED_CONFS) {

18✔

1278

            return REQUIRED_CONFS[chainId]

16✔

1279

16✔

1280

2✔

1281

        return null

2✔

1282

2✔

1283

12✔

1284

    export function bridgeSwapSupported(args: TokenSwap.BridgeSwapSupportedParams): TokenSwap.SwapSupportedResult {

12✔

1285

        return TokenSwap.bridgeSwapSupported(args)

488✔

1286

488✔

1287

12✔

1288

    export interface BridgeTransactionCompleteParams {

12✔

1289

        chainIdTo:                number;

12✔

1290

        transactionHashChainFrom: string;

12✔

1291

12✔

1292

12✔

1293

    export function checkBridgeTransactionComplete(args: BridgeTransactionCompleteParams): Promise<boolean> {

12✔

1294

        const

6✔

1295

            {chainIdTo, transactionHashChainFrom} = args,

6✔

1296

            kappa = makeKappa(transactionHashChainFrom),

6✔

1297

            bridgeInstance = new SynapseBridge({network: chainIdTo});

6✔

1298

6✔

1299

        return bridgeInstance.kappaExists(kappa)

6✔

1300

            .then(res => res)

6✔

1301

            .catch(rejectPromise)

6✔

1302

6✔

1303

12✔

1304

2✔

1305

import SynapseBridge = Bridge.SynapseBridge;

2✔

1306

import getRequiredConfirmationsForBridge = Bridge.getRequiredConfirmationsForBridge;

2✔

1307

import bridgeSwapSupported = Bridge.bridgeSwapSupported;

2✔

1308

import checkBridgeTransactionComplete = Bridge.checkBridgeTransactionComplete;

2✔

1309

2✔

1310

export {

2✔

1311

    SynapseBridge,

2✔

1312

    getRequiredConfirmationsForBridge,

2✔

1313

    bridgeSwapSupported,

2✔

1314

    checkBridgeTransactionComplete

2✔

1315

};

2✔

1316

2✔

1317

import CanBridgeResult = Bridge.CanBridgeResult;

2✔

1318

import BridgeOutputEstimate = Bridge.BridgeOutputEstimate;

2✔

1319

import BridgeParams = Bridge.BridgeParams;

2✔

1320

import BridgeTransactionParams = Bridge.BridgeTransactionParams;

2✔

1321

2✔

1322

export type {

2✔

1323

    CanBridgeResult,

2✔

1324

    BridgeOutputEstimate,

2✔

1325

    BridgeParams,

2✔

1326

    BridgeTransactionParams

2✔

1327

};

2✔

synapsecns / sdk / 2985776531

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

synapsecns / sdk / 2985776531

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

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