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

1

import {toLower} from "lodash-es";

4✔

2

4✔

3

import {ChainId}  from "@chainid";

4✔

4

import {Networks} from "@networks";

4✔

5

4✔

6

import {executePopulatedTransaction, rejectPromise} from "@common/utils";

4✔

7

4✔

8

import {SynapseContracts} from "@common/synapse_contracts";

4✔

9

4✔

10

import * as SynapseEntities from "@entities";

4✔

11

4✔

12

import {

4✔

13

    type ID,

4✔

14

    SwapType,

4✔

15

    rpcProviderForChain,

4✔

16

    terraRpcProvider,

4✔

17

    tokenSwitch,

4✔

18

    TerraSignerWrapper,

4✔

19

    validateTerraAddress

4✔

20

} from "@internal/index";

4✔

21

4✔

22

import type {

4✔

23

    BridgeConfigV3Contract,

4✔

24

    GenericZapBridgeContract,

4✔

25

    L1BridgeZapContract,

4✔

26

    SynapseBridgeContract

4✔

27

} from "@contracts";

4✔

28

4✔

29

import {Tokens}    from "@tokens";

4✔

30

import {TokenSwap} from "@tokenswap";

4✔

31

4✔

32

import {

4✔

33

    type Token,

4✔

34

    instanceOfToken

4✔

35

} from "@token";

4✔

36

4✔

37

import type {GenericSigner, GenericTxnRequest, GenericTxnResponse, NumberMap} from "@common/types";

4✔

38

4✔

39

import {GasUtils}                   from "./gasutils";

4✔

40

4✔

41

import {

4✔

42

    BridgeUtils,

4✔

43

    CanBridgeError

4✔

44

} from "./bridgeutils";

4✔

45

4✔

46

import {ERC20, MAX_APPROVAL_AMOUNT} from "./erc20";

4✔

47

4✔

48

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

4✔

49

import {isAddress}   from "@ethersproject/address";

4✔

50

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

4✔

51

4✔

52

import {

4✔

53

    Signer as EthersSigner

4✔

54

} from "@ethersproject/abstract-signer";

4✔

55

4✔

56

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

4✔

57

4✔

58

import type {ContractTransaction, PopulatedTransaction} from "@ethersproject/contracts";

4✔

59

4✔

60

import {

4✔

61

    MsgExecuteContract,

4✔

62

    LCDClient,

4✔

63

    Wallet as TerraWallet,

4✔

64

    BlockTxBroadcastResult

4✔

65

} from "@terra-money/terra.js";

4✔

66

4✔

67

import bech32 from "bech32";

4✔

68

4✔

69

const TEN = BigNumber.from(10);

4✔

70

4✔

71

/**

4✔

72

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

4✔

73

 * and most importantly, executing Bridge transactions.

4✔

74

*/

4✔

75

export namespace Bridge {

22✔

76

    export type CanBridgeResult = {

22✔

77

        canBridge:     boolean;

22✔

78

        reasonUnable?: string;

22✔

79

        amount?:       BigNumber;

22✔

80

22✔

81

22✔

82

    type NeedsTokenApproveResult = {

22✔

83

        needsApproval:     boolean;

22✔

84

        currentAllowance?: BigNumber;

22✔

85

22✔

86

22✔

87

    export type BridgeOutputEstimate = {

22✔

88

        amountToReceive: BigNumber,

22✔

89

        bridgeFee:       BigNumber,

22✔

90

22✔

91

22✔

92

/**

22✔

93

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

22✔

94

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

22✔

95

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

22✔

96

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

22✔

97

*/

22✔

98

    export interface BridgeParams {

22✔

99

        tokenFrom:   Token,

22✔

100

        tokenTo:     Token

22✔

101

        chainIdTo:   number,

22✔

102

        amountFrom?: BigNumber,

22✔

103

22✔

104

22✔

105

/**

22✔

106

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

22✔

107

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

22✔

108

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

22✔

109

     * on the destination chain.

22✔

110

*/

22✔

111

    export interface BridgeTransactionParams extends BridgeParams {

22✔

112

        amountFrom: BigNumber;

22✔

113

        amountTo:   BigNumber;

22✔

114

        addressTo?: string;

22✔

115

22✔

116

22✔

117

    type EasyArgsCheck = {

22✔

118

        isEasy:   boolean;

22✔

119

        castArgs: BridgeUtils.BridgeTxParams;

22✔

120

        txn?:     Promise<PopulatedTransaction>;

22✔

121

22✔

122

22✔

123

    type BridgeTokenArgs = {

22✔

124

        fromChainTokens: Token[];

22✔

125

        toChainTokens:   Token[];

22✔

126

        tokenFrom:       Token;

22✔

127

        tokenTo:         Token;

22✔

128

        tokenIndexFrom:  number;

22✔

129

        tokenIndexTo:    number;

22✔

130

22✔

131

22✔

132

    interface CheckCanBridgeParams {

22✔

133

        address?: string;

22✔

134

        signer?:  EthersSigner;

22✔

135

        token:    Token;

22✔

136

        amount:   BigNumberish;

22✔

137

22✔

138

22✔

139

    interface CanBridgeParams extends CheckCanBridgeParams {

22✔

140

        address: string;

22✔

141

22✔

142

22✔

143

/**

22✔

144

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

22✔

145

*/

22✔

146

    export class SynapseBridge {

22✔

147

        protected network: Networks.Network;

22✔

148

        protected chainId: number;

1,622✔

149

        protected _provider: Provider | LCDClient;

1,622✔

150

1,622✔

151

        private readonly bridgeAddress: string;

1,622✔

152

1,622✔

153

        private readonly bridgeInstance:           SynapseBridgeContract;

1,622✔

154

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

1,622✔

155

1,622✔

156

        private readonly isTerra:      boolean;

1,622✔

157

        private readonly isL2Zap:      boolean;

1,622✔

158

        private readonly isL2ETHChain: boolean;

1,622✔

159

1,622✔

160

        private readonly zapBridgeAddress: string;

1,622✔

161

1,622✔

162

        private readonly bridgeConfigInstance: BridgeConfigV3Contract = SynapseEntities.BridgeConfigV3ContractInstance();

1,622✔

163

1,622✔

164

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

1,622✔

165

            chainId: ChainId.ETH,

1,622✔

166

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

1,622✔

167

});

1,622✔

168

1,622✔

169

        readonly requiredConfirmations: number;

22✔

170

22✔

171

        constructor(args: {

22✔

172

            network: Networks.Network | number,

1,622✔

173

            provider?: Provider

1,622✔

174

        }) {

1,622✔

175

            let {network, provider} = args;

1,622✔

176

1,622✔

177

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

1,622✔

178

            this.chainId = this.network.chainId;

1,622✔

179

1,622✔

180

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

1,622✔

181

1,622✔

182

            this.isTerra = this.chainId === ChainId.TERRA;

1,622✔

183

            this.isL2Zap = this.network.zapIsL2BridgeZap;

1,622✔

184

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

1,622✔

185

1,622✔

186

            this._provider = provider ?? (this.isTerra

1,622✔

188

                : rpcProviderForChain(this.chainId)

1,523✔

189

);

1,622✔

190

1,622✔

191

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

1,622✔

192

1,622✔

193

            this.bridgeAddress    = contractAddrs.bridgeAddress;

1,622✔

194

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

1,622✔

195

1,622✔

196

            if (!this.isTerra) {

1,622✔

197

                const factoryParams = {chainId: this.chainId, signerOrProvider: (this._provider as Provider)};

1,592✔

198

1,592✔

199

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

1,592✔

200

1,592✔

201

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

1,592✔

202

                this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

1,592✔

203

1,592✔

204

1,592✔

205

1,622✔

206

22✔

207

        private get provider(): Provider {

22✔

208

            return this._provider as Provider

605✔

209

605✔

210

22✔

211

        private get terraProvider(): LCDClient {

22✔

212

            return this._provider as LCDClient

9✔

213

9✔

214

22✔

215

        bridgeVersion(): Promise<BigNumber> {

22✔

216

            if (this.isTerra) {

45✔

217

                return Promise.resolve(BigNumber.from(6))

3✔

218

3✔

219

45✔

220

            return this.bridgeInstance.bridgeVersion()

45✔

221

45✔

222

22✔

223

        WETH_ADDRESS(): Promise<string> {

22✔

224

            if (this.isTerra) {

45✔

225

                return Promise.resolve("0x0000000000000000000000000000000000000000")

3✔

226

3✔

227

45✔

228

            return this.bridgeInstance.WETH_ADDRESS()

45✔

229

45✔

230

22✔

231

/**

22✔

232

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

22✔

233

         * is supported.

22✔

234

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

22✔

235

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

22✔

236

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

22✔

237

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

22✔

238

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

22✔

239

*/

22✔

240

        swapSupported(args: {

22✔

241

            tokenFrom: Token,

615✔

242

            tokenTo:   Token

615✔

243

            chainIdTo: number,

615✔

244

        }): [boolean, string] {

615✔

245

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

615✔

246

615✔

247

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

615✔

248

615✔

249

22✔

250

/**

22✔

251

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

22✔

252

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

22✔

253

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

22✔

254

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

22✔

255

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

22✔

256

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

22✔

257

*/

22✔

258

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

22✔

259

            return this.checkSwapSupported(args)

375✔

260

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

375✔

261

                .catch(rejectPromise)

375✔

262

375✔

263

22✔

264

/**

22✔

265

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

22✔

266

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

22✔

267

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

22✔

268

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

22✔

269

         * of web3/ethers/etc.

22✔

270

*/

22✔

271

        async buildBridgeTokenTransaction(args: BridgeTransactionParams): Promise<PopulatedTransaction | MsgExecuteContract> {

22✔

272

            const

674✔

273

                {addressTo} = args,

674✔

274

                tokenArgs = this.makeBridgeTokenArgs(args),

674✔

275

                {tokenFrom, tokenTo} = tokenArgs;

674✔

276

674✔

278

                return rejectPromise(

6✔

279

                    new CanBridgeError("BridgeTransactionParams.addressTo cannot be empty string or undefined")

6✔

280

6✔

281

6✔

282

674✔

284

                return rejectPromise(

3✔

285

                    new CanBridgeError(`${args.addressTo} passed as BridgeTransactionParams.addressTo is not a valid Terra address`)

3✔

286

3✔

288

                return rejectPromise(

3✔

289

                    new CanBridgeError(`${args.addressTo} passed as BridgeTransactionParams.addressTo is not a valid EVM address`)

3✔

290

3✔

291

3✔

292

674✔

293

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

674✔

294

674✔

295

            let newTxn: Promise<PopulatedTransaction>;

674✔

296

674✔

297

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

674✔

299

                    return this.buildTerraBridgeTxn(args)

12✔

300

12✔

301

39✔

302

                const redeemArgs: [BigNumberish, string, BigNumberish] = [

39✔

303

                    args.chainIdTo,

39✔

304

                    Tokens.UST.address(this.chainId),

39✔

305

                    args.amountFrom

39✔

306

];

39✔

307

39✔

308

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

48✔

309

                    newTxn = this.bridgeInstance

13✔

310

                        .populateTransaction

13✔

311

                        .redeemV2(

13✔

312

                            bech32.decode(args.addressTo).words,

13✔

313

                            ...redeemArgs

13✔

314

);

13✔

315

                } else {

48✔

316

                    newTxn = this.bridgeInstance

23✔

317

                        .populateTransaction

23✔

318

                        .redeem(

23✔

319

                            args.addressTo,

23✔

320

                            ...redeemArgs

23✔

321

);

23✔

322

23✔

323

            } else {

674✔

324

                newTxn = this.chainId === ChainId.ETH

584✔

325

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

584✔

326

                : this.buildL2BridgeTxn(args, tokenArgs);

584✔

327

584✔

328

674✔

329

            return newTxn

674✔

330

                .then(txn =>

674✔

331

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

602✔

332

674✔

333

674✔

334

22✔

335

/**

22✔

336

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

22✔

337

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

22✔

338

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

22✔

339

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

22✔

340

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

22✔

341

         * @return {Promise<ContractTransaction>}

22✔

342

*/

22✔

343

        async executeBridgeTokenTransaction(

22✔

344

            args:       BridgeTransactionParams,

15✔

345

            signer:     EthersSigner | TerraWallet | GenericSigner,

15✔

346

            callStatic: boolean=false

15✔

347

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

15✔

348

            try {

15✔

349

                await this.checkSwapSupported(args);

15✔

351

                /* c8 ignore next 2 */

4✔

352

                return rejectPromise(e);

4✔

353

4✔

354

15✔

355

            const {tokenFrom, amountFrom, addressTo} = args;

15✔

356

15✔

357

            let txSigner: GenericSigner;

15✔

358

            let signerAddress: string;

15✔

359

15✔

360

            if (signer instanceof TerraWallet) {

15✔

361

                txSigner = new TerraSignerWrapper(signer);

3✔

362

            } else {

15✔

363

                txSigner = signer;

12✔

364

12✔

365

15✔

366

            signerAddress = await txSigner.getAddress();

15✔

368

15✔

369

            let checkArgs = {token: tokenFrom, amount: amountFrom, address: toLower(signerAddress)};

15✔

370

15✔

371

            const sendTxn = (txn: GenericTxnRequest): Promise<GenericTxnResponse> => {

15✔

378

15✔

379

            return this.checkCanBridge(checkArgs)

15✔

380

                .then(({canBridge, reasonUnable, amount}) => {

15✔

381

                    if (!canBridge) {

15✔

382

                        const rejection = new CanBridgeError(reasonUnable, amount);

15✔

383

                        return rejectPromise(rejection)

15✔

384

15✔

385

15✔

386

                    return this.buildBridgeTokenTransaction(args)

15✔

387

                        .then(sendTxn)

15✔

388

                        .catch(rejectPromise)

15✔

389

})

15✔

390

15✔

391

22✔

392

/**

22✔

393

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

22✔

394

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

22✔

395

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

22✔

396

         * framework so they can ultimately send the transaction.

22✔

397

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

22✔

398

         * @param {Object} args

22✔

399

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

22✔

400

         * to the bridge on the source chain.

22✔

401

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

22✔

402

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

22✔

403

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

22✔

404

         * of web3/ethers/etc.

22✔

405

*/

22✔

406

        async buildApproveTransaction(args: {

22✔

407

            token:   Token | string,

297✔

408

            amount?: BigNumberish

297✔

409

        }): Promise<PopulatedTransaction> {

297✔

410

            const [approveArgs, tokenAddress] = this.buildERC20ApproveArgs(args);

297✔

411

297✔

412

            return ERC20.buildApproveTransaction(approveArgs, {tokenAddress, chainId: this.chainId})

297✔

413

297✔

414

22✔

415

/**

22✔

416

         * Builds and executes an ERC20 Approve call,

22✔

417

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

22✔

418

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

22✔

419

         * framework so they can ultimately send the transaction.

22✔

420

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

22✔

421

         * @param {Object} args

22✔

422

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

22✔

423

         * to the bridge on the source chain.

22✔

424

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

22✔

425

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

22✔

426

         * transaction.

22✔

427

*/

22✔

428

        async executeApproveTransaction(

22✔

429

            args:       {token: Token | string, amount?: BigNumberish},

3✔

430

            signer:     EthersSigner,

3✔

431

        ): Promise<ContractTransaction> {

3✔

432

            const

3✔

433

                [approveArgs, tokenAddress] = this.buildERC20ApproveArgs(args),

3✔

434

                tokenParams = {tokenAddress, chainId: this.chainId};

3✔

435

3✔

436

            return ERC20.approve(approveArgs, tokenParams, signer)

3✔

437

3✔

438

22✔

439

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

22✔

440

            const {token, signer, address} = args;

51✔

441

51✔

442

            let signerAddress: string;

51✔

444

                /* c8 ignore next */

4✔

445

                signerAddress = await signer.getAddress();

4✔

446

            } else if (address && address !== "") {

51✔

447

                signerAddress = address;

51✔

448

51✔

449

51✔

450

            const checkArgs: CanBridgeParams = {...args, address: signerAddress};

51✔

451

            const

51✔

452

                isTerraTx:          boolean = this.isTerra && token.isEqual(Tokens.UST),

51✔

453

                isGasTokenTransfer: boolean = (this.network.chainCurrency === token.symbol) && BridgeUtils.chainSupportsGasToken(this.chainId);

51✔

454

51✔

455

            if (isTerraTx) {

51✔

456

                return this.checkTerraUSTBalance(checkArgs);

9✔

457

9✔

458

51✔

459

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

51✔

460

                ? this.checkGasTokenBalance(checkArgs)

51✔

461

                : this.checkERC20Balance(checkArgs);

51✔

462

51✔

463

            if (isGasTokenTransfer) {

51✔

464

                return hasBalanceRes

21✔

465

21✔

466

21✔

467

            return this.checkNeedsApprove(checkArgs)

21✔

468

                    .then(approveRes => this.resolveApproveFunc(approveRes, hasBalanceRes, token))

21✔

469

                    .catch(rejectPromise)

21✔

470

21✔

471

22✔

472

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

22✔

473

            let {chainIdTo, amountFrom} = args;

327✔

474

327✔

475

            let toChainZap: GenericZapBridgeContract;

327✔

476

327✔

477

            if (chainIdTo !== ChainId.TERRA) {

327✔

478

                const toChainZapParams = {chainId: chainIdTo, signerOrProvider: rpcProviderForChain(chainIdTo)};

315✔

479

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

315✔

480

315✔

481

327✔

482

            const {

327✔

483

                tokenFrom, tokenTo,

327✔

484

                tokenIndexFrom, tokenIndexTo,

327✔

485

                fromChainTokens

327✔

486

            } = this.makeBridgeTokenArgs(args);

327✔

487

327✔

488

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

327✔

489

327✔

490

            const involvesUST = [tokenFrom.swapType, tokenTo.swapType].includes(SwapType.UST);

327✔

491

327✔

492

            const

327✔

493

                intermediateTokenAddr = toLower(bridgeConfigIntermediateToken.address(chainIdTo)),

327✔

494

                multiplier            = involvesUST ? TEN.pow(12) : 1,

327✔

495

                amtFrom               = involvesUST ? amountFrom : TEN.pow(18-tokenFrom.decimals(this.chainId));

327✔

496

327✔

497

            const bridgeFeeRequest: Promise<BigNumber> = this.bridgeConfigInstance["calculateSwapFee(string,uint256,uint256)"](

327✔

498

                intermediateTokenAddr,

327✔

499

                chainIdTo,

327✔

500

                amtFrom

327✔

501

);

327✔

502

327✔

503

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

327✔

504

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

654✔

505

327✔

506

            const

327✔

507

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

327✔

508

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

327✔

509

327✔

510

            let amountToReceive_from_prom: Promise<BigNumber>;

327✔

511

            switch (true) {

327✔

512

                case amountFrom.eq(Zero):

327✔

513

                    amountToReceive_from_prom = Promise.resolve(Zero);

12✔

514

                    break;

12✔

515

                case ethToEth:

327✔

516

                case Tokens.isMintBurnToken(tokenFrom):

327✔

517

                case tokenFrom.isWrappedToken:

327✔

518

                    amountToReceive_from_prom = Promise.resolve(amountFrom);

207✔

519

                    break;

207✔

520

                case this.chainId === ChainId.ETH:

327✔

521

                    let liquidityAmounts = fromChainTokens.map((t) => tokenFrom.isEqual(t) ? amountFrom : Zero);

12✔

522

                    amountToReceive_from_prom = this.zapBridgeInstance.calculateTokenAmount(liquidityAmounts, true);

12✔

523

12✔

524

                    break;

12✔

525

                default:

327✔

526

                    amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

96✔

527

                        this.networkZapBridgeInstance,

96✔

528

                        intermediateToken.address(this.chainId),

96✔

529

                        tokenIndexFrom,

96✔

530

0,

96✔

531

                        amountFrom

96✔

532

);

96✔

533

327✔

534

327✔

535

            let amountToReceive_from = await amountToReceive_from_prom;

327✔

536

327✔

537

            let bridgeFee: BigNumber;

327✔

538

            /* c8 ignore start */

4✔

539

            try {

4✔

540

                bridgeFee = await bridgeFeeRequest;

4✔

541

                if (bridgeFee === null) {

4✔

542

                    console.error("calculateSwapFee returned null");

4✔

543

                    return rejectPromise("calculateSwapFee returned null")

4✔

544

4✔

545

            } catch (e) {

4✔

546

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

4✔

547

                return rejectPromise(e)

4✔

548

4✔

549

            /* c8 ignore stop */

4✔

550

327✔

551

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

327✔

552

327✔

553

            let amountToReceive_to_prom: Promise<BigNumber>;

327✔

554

            switch (true) {

327✔

555

                case amountToReceive_from.isZero():

327✔

556

                    amountToReceive_to_prom = Promise.resolve(Zero);

16✔

557

                    break;

16✔

558

                case ethFromEth:

327✔

559

                case Tokens.isMintBurnToken(tokenTo):

327✔

560

                case tokenTo.isWrappedToken:

327✔

561

                    amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

197✔

562

                    break;

197✔

563

                case chainIdTo === ChainId.ETH:

327✔

564

                    amountToReceive_to_prom = (toChainZap as L1BridgeZapContract)

9✔

565

                        .calculateRemoveLiquidityOneToken(amountToReceive_from, tokenIndexTo);

9✔

566

9✔

567

                    break;

9✔

568

                default:

327✔

569

                    amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

105✔

570

                        toChainZap,

105✔

571

                        intermediateToken.address(chainIdTo),

105✔

572

0,

105✔

573

                        tokenIndexTo,

105✔

574

                        amountToReceive_from

105✔

575

);

105✔

576

327✔

577

327✔

578

            let amountToReceive: BigNumber;

327✔

579

            /* c8 ignore next 6 */

4✔

580

            try {

4✔

581

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

4✔

582

            } catch (err) {

4✔

583

                return rejectPromise(err)

4✔

584

4✔

585

4✔

586

            return {

327✔

587

                amountToReceive,

327✔

589

327✔

590

327✔

591

22✔

592

        private buildETHMainnetBridgeTxn(

22✔

593

            args:      BridgeTransactionParams,

136✔

594

            tokenArgs: BridgeTokenArgs

136✔

595

        ): Promise<PopulatedTransaction> {

136✔

596

            const

136✔

597

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

136✔

598

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

136✔

599

                    chainId: this.chainId,

136✔

600

                    signerOrProvider: this.provider

136✔

601

});

136✔

602

136✔

603

let

136✔

604

                easyRedeems:    ID[] = [Tokens.SYN.id,  Tokens.UST.id],

136✔

605

                easyDeposits:   ID[] = [

136✔

606

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

136✔

607

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

136✔

608

],

136✔

609

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

136✔

610

136✔

611

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

136✔

612

            if (isEasy && txn) {

136✔

613

                return txn

54✔

614

54✔

615

136✔

616

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

136✔

617

                    args.tokenFrom.isEqual(t)

156✔

618

                        ? amountFrom

156✔

619

                        : Zero

156✔

620

);

136✔

621

136✔

622

            const {

136✔

623

                transactionDeadline,

136✔

624

                bridgeTransactionDeadline,

136✔

625

                minToSwapDestFromOrigin,

136✔

626

                minToSwapDest,

136✔

627

                minToSwapOriginMediumSlippage,

136✔

628

                minToSwapDestFromOriginMediumSlippage,

136✔

629

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

136✔

630

136✔

631

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

136✔

632

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

14✔

633

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

7✔

634

                        args as BridgeUtils.BridgeTxParams,

7✔

635

                        this.chainId,

7✔

636

                        args.tokenTo

7✔

637

);

7✔

638

7✔

639

                    return zapBridge

7✔

640

                        .populateTransaction

7✔

641

                        .deposit(...bridgeDepositArgs)

7✔

642

                } else {

7✔

643

                    return zapBridge.populateTransaction.zapAndDeposit(

7✔

644

                        addressTo,

7✔

645

                        chainIdTo,

7✔

646

                        Tokens.NUSD.address(this.chainId),

7✔

647

                        liquidityAmounts,

7✔

648

                        minToSwapDest,

7✔

649

                        transactionDeadline,

7✔

650

7✔

651

7✔

652

14✔

653

65✔

654

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

136✔

655

                return zapBridge.populateTransaction.depositETHAndSwap(

42✔

656

                    ...BridgeUtils.depositETHParams(castArgs),

42✔

657

                    0, // nusd tokenindex,

42✔

658

                    tokenArgs.tokenIndexTo,

42✔

659

                    minToSwapDestFromOrigin, // minDy

42✔

660

                    bridgeTransactionDeadline,

42✔

661

                    BridgeUtils.overrides(amountFrom)

42✔

662

42✔

663

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

130✔

664

                return zapBridge.populateTransaction.depositAndSwap(

10✔

665

                    addressTo,

10✔

666

                    chainIdTo,

10✔

667

                    Tokens.NUSD.address(this.chainId),

10✔

668

                    amountFrom,

10✔

669

0,

10✔

670

                    tokenArgs.tokenIndexTo,

10✔

671

                    minToSwapDestFromOriginMediumSlippage,

10✔

672

                    bridgeTransactionDeadline

10✔

673

10✔

674

10✔

675

130✔

676

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

130✔

677

                addressTo,

130✔

678

                chainIdTo,

130✔

679

                Tokens.NUSD.address(this.chainId),

130✔

680

                liquidityAmounts,

130✔

681

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

130✔

682

                transactionDeadline,

130✔

683

0,

130✔

684

                tokenArgs.tokenIndexTo,

130✔

685

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

130✔

686

                bridgeTransactionDeadline,

130✔

687

130✔

688

130✔

689

22✔

690

        private buildL2BridgeTxn(

22✔

691

            args: BridgeTransactionParams,

448✔

692

            tokenArgs: BridgeTokenArgs

448✔

693

        ): Promise<PopulatedTransaction> {

448✔

694

            const

448✔

695

                {chainIdTo, amountFrom, amountTo} = args,

448✔

696

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

448✔

697

                    chainId: this.chainId,

448✔

698

                    signerOrProvider: this.provider

448✔

699

});

448✔

700

448✔

701

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

448✔

703

                : tokenArgs.tokenFrom;

448✔

704

448✔

705

let

448✔

706

                easyDeposits:   ID[] = [],

448✔

707

                easyDepositETH: ID[] = [],

448✔

708

                easyRedeems:    ID[] = [

448✔

709

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

448✔

710

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

448✔

711

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

448✔

712

];

448✔

713

448✔

714

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

448✔

715

                let {chainId, tokens, depositEth, altChainId} = args;

2,240✔

716

2,240✔

717

let

2,240✔

718

                    hasAltChain = typeof altChainId !== 'undefined',

2,240✔

719

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

2,240✔

720

2,240✔

721

                if (this.chainId === chainId) {

2,240✔

722

                    depositEth

226✔

723

                        ? easyDepositETH.push(...tokenHashes)

226✔

724

                        : easyDeposits.push(...tokenHashes);

226✔

725

                } else {

2,240✔

726

                    if (hasAltChain) {

2,014✔

727

                        if (this.chainId === altChainId) easyRedeems.push(...tokenHashes);

757✔

728

                    } else {

2,014✔

729

                        easyRedeems.push(...tokenHashes);

1,257✔

730

1,257✔

731

2,014✔

732

})

448✔

733

448✔

734

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

448✔

735

            if (isEasy && txn) {

448✔

736

                return txn

157✔

737

157✔

738

291✔

739

            const {

291✔

740

                transactionDeadline,

291✔

741

                bridgeTransactionDeadline,

291✔

742

                minToSwapOriginHighSlippage,

291✔

743

                minToSwapDestFromOriginHighSlippage,

291✔

744

                minToSwapDest,

291✔

745

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

291✔

746

291✔

747

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

291✔

748

                zapBridge

21✔

749

                    .populateTransaction

21✔

750

                    .redeemAndSwap(

21✔

751

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

21✔

752

0,

21✔

753

                        tokenArgs.tokenIndexTo,

21✔

754

                        minToSwapDest,

21✔

755

                        transactionDeadline,

21✔

756

291✔

757

291✔

758

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

291✔

759

                let populateFn = swapETH

37✔

760

                    ? zapBridge.populateTransaction.swapETHAndRedeem

37✔

761

                    : zapBridge.populateTransaction.swapAndRedeem

37✔

762

37✔

763

                return populateFn(

37✔

764

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

37✔

765

                    tokenArgs.tokenIndexFrom,

37✔

766

0,

37✔

767

                    amountFrom,

37✔

768

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

37✔

769

                    transactionDeadline,

37✔

770

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

37✔

771

37✔

772

37✔

773

291✔

774

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

291✔

775

                let populateFn = swapETH

115✔

776

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

115✔

777

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

115✔

778

115✔

779

                return populateFn(

115✔

780

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

115✔

781

                    tokenArgs.tokenIndexFrom,

115✔

782

0,

115✔

783

                    amountFrom,

115✔

784

                    minToSwapOriginHighSlippage,

115✔

785

                    transactionDeadline,

115✔

786

0,

115✔

787

                    tokenArgs.tokenIndexTo,

115✔

788

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

115✔

789

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

115✔

790

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

115✔

791

115✔

792

115✔

793

291✔

794

            switch (tokenSwitch(args.tokenTo)) {

291✔

795

                case Tokens.NUSD:

448✔

796

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

47✔

797

                        return zapBridge

14✔

798

                            .populateTransaction

14✔

799

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

14✔

800

14✔

801

33✔

802

                    return zapBridge

33✔

803

                        .populateTransaction

33✔

804

                        .swapAndRedeem(

33✔

805

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

33✔

806

                            tokenArgs.tokenIndexFrom,

33✔

807

0,

33✔

808

                            amountFrom,

33✔

809

                            minToSwapOriginHighSlippage,

33✔

810

                            transactionDeadline

33✔

811

33✔

812

                case Tokens.GMX:

448✔

813

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

14✔

814

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

14✔

815

14✔

816

                    return this.chainId === ChainId.ARBITRUM

14✔

817

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

14✔

818

                        : this.bridgeInstance

14✔

819

                            .populateTransaction

7✔

820

                            .redeem(

7✔

821

                                addrTo,

7✔

822

                                chainTo,

7✔

823

                                Tokens.GMX.wrapperAddress(this.chainId),

7✔

824

                                amount

7✔

825

14✔

826

                default:

448✔

827

                    if (chainIdTo === ChainId.ETH) {

215✔

828

                        if (this.isL2ETHChain && args.tokenFrom.swapType === SwapType.ETH) {

79✔

829

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

54✔

830

                                return zapBridge

17✔

831

                                    .populateTransaction

17✔

832

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

17✔

833

                            } else {

54✔

834

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

37✔

835

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

37✔

836

37✔

837

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

79✔

838

                            return zapBridge

14✔

839

                                .populateTransaction

14✔

840

                                .redeemAndRemove(

14✔

841

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

14✔

842

                                    amountFrom,

14✔

843

                                    tokenArgs.tokenIndexTo,

14✔

844

                                    minToSwapDest,

14✔

845

                                    transactionDeadline

14✔

846

14✔

847

14✔

848

11✔

849

                        return zapBridge

11✔

850

                            .populateTransaction

11✔

851

                            .swapAndRedeemAndRemove(

11✔

852

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

11✔

853

                                tokenArgs.tokenIndexFrom,

11✔

854

0,

11✔

855

                                amountFrom,

11✔

856

                                minToSwapOriginHighSlippage,

11✔

857

                                transactionDeadline,

11✔

858

                                tokenArgs.tokenIndexTo, //swapTokenIndex

11✔

859

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

11✔

860

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

11✔

861

11✔

862

11✔

863

136✔

864

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

215✔

865

                        return easyRedeemAndSwap(args.tokenFrom)

21✔

866

21✔

867

115✔

868

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

215✔

869

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

95✔

870

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

95✔

871

95✔

872

20✔

873

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

20✔

874

448✔

875

448✔

876

22✔

877

        private buildTerraBridgeTxn({

22✔

878

            addressTo,

12✔

879

            chainIdTo,

12✔

880

            amountFrom

12✔

881

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

12✔

882

            return Promise.resolve(new MsgExecuteContract(

12✔

883

                null,

12✔

884

                this.bridgeAddress,

12✔

885

12✔

886

                    deposit: {

12✔

887

                        to_address: toLower(addressTo),

12✔

888

                        chain_id:  `${chainIdTo}`,

12✔

889

                        denom:     "uusd"

12✔

890

12✔

891

},

12✔

892

                { uusd: amountFrom.toNumber() }

12✔

893

))

12✔

894

12✔

895

22✔

896

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

22✔

897

            let {tokenFrom, tokenTo, chainIdTo} = args;

1,001✔

898

1,001✔

899

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

1,001✔

900

1,001✔

901

            switch (tokenFrom.swapType) {

1,001✔

902

                case SwapType.ETH:

1,001✔

903

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

350✔

904

                    break;

350✔

905

                case SwapType.AVAX:

1,001✔

906

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

20✔

907

                    break;

20✔

908

                case SwapType.MOVR:

1,001✔

909

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

20✔

910

                    break;

20✔

911

                default:

1,001✔

912

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

611✔

913

1,001✔

914

1,001✔

915

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

1,001✔

916

1,001✔

917

            const

1,001✔

918

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

1,001✔

919

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

1,001✔

920

1,001✔

921

            return {

1,001✔

922

                fromChainTokens,

1,001✔

923

                toChainTokens,

1,001✔

924

                tokenFrom,

1,001✔

925

                tokenTo,

1,001✔

926

                tokenIndexFrom,

1,001✔

927

                tokenIndexTo

1,001✔

928

1,001✔

929

1,001✔

930

22✔

931

        private checkEasyArgs(

22✔

932

            args:            BridgeTransactionParams,

584✔

933

            zapBridge:       GenericZapBridgeContract,

584✔

934

            easyDeposits:    ID[],

584✔

935

            easyRedeems:     ID[],

584✔

936

            easyDepositETH?: ID[],

584✔

937

        ): EasyArgsCheck {

584✔

938

let

584✔

939

                castArgs = args as BridgeUtils.BridgeTxParams,

584✔

940

                isEasy: boolean = false,

584✔

941

                txn:    Promise<PopulatedTransaction>;

584✔

942

584✔

943

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

584✔

944

584✔

945

            switch (true) {

584✔

946

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

584✔

947

                    isEasy = true;

129✔

948

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

129✔

949

                    break;

129✔

950

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

584✔

951

                    isEasy = true;

52✔

952

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

52✔

953

                    break;

52✔

954

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

584✔

955

                    isEasy = true;

30✔

956

                    txn    =  zapBridge

30✔

957

                        .populateTransaction

30✔

958

                        .depositETH(

30✔

959

                            ...BridgeUtils.depositETHParams(castArgs),

30✔

960

                            BridgeUtils.overrides(args.amountFrom)

30✔

961

);

30✔

962

                    break;

30✔

963

584✔

964

584✔

965

            return {castArgs, isEasy, txn}

584✔

966

584✔

967

22✔

968

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

22✔

969

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

390✔

970

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

390✔

971

                if (!swapSupported) {

390✔

972

                    reject(errReason);

48✔

973

                    return

48✔

974

48✔

975

390✔

976

                resolve(true);

390✔

977

})

390✔

978

390✔

979

22✔

980

        private buildERC20ApproveArgs(args: {

22✔

981

            token:   Token | string,

321✔

982

            amount?: BigNumberish

321✔

983

        }): [ERC20.ApproveArgs, string] {

321✔

984

            const {token, amount} = args;

321✔

985

321✔

986

            let tokenAddr: string = instanceOfToken(token)

321✔

987

                ? token.address(this.chainId)

321✔

989

321✔

990

            let spender: string;

321✔

991

            if (tokenAddr === Tokens.UST.address(this.chainId)) {

321✔

992

                spender = this.bridgeAddress;

33✔

993

            } else {

321✔

994

                spender = this.zapBridgeAddress;

288✔

995

288✔

996

321✔

997

            return [{

321✔

998

                spender,

321✔

999

                amount

321✔

1000

            }, tokenAddr]

321✔

1001

321✔

1002

22✔

1003

        async getAllowanceForAddress(args: {

22✔

1004

            address: string,

15✔

1005

            token:   Token,

15✔

1006

        }): Promise<BigNumber> {

15✔

1007

            let { address, token } = args;

15✔

1008

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

15✔

1009

15✔

1010

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

15✔

1011

15✔

1012

22✔

1013

        private async resolveApproveFunc(

22✔

1014

            approveRes:    NeedsTokenApproveResult,

21✔

1015

            hasBalanceRes: Promise<CanBridgeResult>,

21✔

1016

            token:         Token

21✔

1017

        ): Promise<CanBridgeResult> {

21✔

1018

            const {needsApproval, currentAllowance} = approveRes;

21✔

1019

            const errStr: string = `Spend allowance of Bridge too low for token ${token.symbol}`;

21✔

1020

21✔

1021

            return needsApproval

21✔

1023

                : hasBalanceRes

21✔

1024

21✔

1025

22✔

1026

        private async checkNeedsApprove({

22✔

1027

            address,

21✔

1028

            token,

21✔

1029

            amount=MAX_APPROVAL_AMOUNT.sub(1)

21✔

1030

        }: CheckCanBridgeParams): Promise<NeedsTokenApproveResult> {

21✔

1031

            const [{spender}, tokenAddress] = this.buildERC20ApproveArgs({token, amount});

21✔

1032

21✔

1033

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

21✔

1034

                .then(currentAllowance => ({needsApproval: currentAllowance.lt(amount), currentAllowance}))

21✔

1035

21✔

1036

22✔

1037

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

22✔

1038

            const {signer, address, amount, token} = args;

21✔

1039

21✔

1040

            let balanceFn: () => Promise<BigNumber>;

21✔

1042

                /* c8 ignore next */

4✔

1043

                balanceFn = signer.getBalance;

4✔

1044

            } else if (address) {

21✔

1045

                balanceFn = () => this.provider.getBalance(address);

21✔

1046

21✔

1047

21✔

1048

            return this.resolveBalanceFunc(

21✔

1049

                balanceFn(),

21✔

1050

                amount,

21✔

1051

                token

21✔

1052

21✔

1053

21✔

1054

22✔

1055

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

22✔

1056

            const

21✔

1057

                {address, amount, token} = args,

21✔

1058

                tokenAddress = token.address(this.chainId);

21✔

1059

21✔

1060

            return this.resolveBalanceFunc(

21✔

1061

                ERC20.balanceOf(address, {tokenAddress, chainId: this.chainId}),

21✔

1062

                amount,

21✔

1063

                token

21✔

1064

21✔

1065

21✔

1066

22✔

1067

        private async checkTerraUSTBalance({address, token, amount}: CanBridgeParams): Promise<CanBridgeResult> {

22✔

1068

            const balProm: Promise<BigNumber> = this.terraProvider.bank.balance(address)

9✔

1069

                .then(([res]) => {

9✔

1070

                    let coin = res.get("uusd");

9✔

1071

9✔

1072

                    let ustBalance: BigNumber = Zero;

9✔

1073

9✔

1074

                    if (coin) {

9✔

1075

                        const {amount} = coin.toData();

9✔

1076

                        if (amount && (amount !== "")) {

9✔

1077

                            ustBalance = BigNumber.from(amount);

9✔

1078

9✔

1079

9✔

1080

9✔

1081

                    return ustBalance

9✔

1082

})

9✔

1083

9✔

1084

            return this.resolveBalanceFunc(

9✔

1085

                balProm,

9✔

1086

                amount,

9✔

1087

                token

9✔

1088

9✔

1089

9✔

1090

22✔

1091

        private async resolveBalanceFunc(

22✔

1092

            prom:   Promise<BigNumber>,

51✔

1093

            amount: BigNumberish,

51✔

1094

            token:  Token

51✔

1095

        ): Promise<CanBridgeResult> {

51✔

1096

            return Promise.resolve(prom)

51✔

1097

                .then(balance => {

51✔

1098

                    const errMsg: string = `Balance of token ${token.symbol} is too low`;

51✔

1099

51✔

1100

                    if (balance.gte(amount)) {

51✔

1101

                        return {canBridge: true}

6✔

1102

6✔

1103

51✔

1104

                    return {canBridge: false, reasonUnable: errMsg, amount: balance}

51✔

1105

})

51✔

1106

                .catch(rejectPromise)

51✔

1107

51✔

1108

22✔

1109

22✔

1110

    const REQUIRED_CONFS: NumberMap = {

22✔

1111

        [ChainId.ETH]:       7,

22✔

1112

        [ChainId.OPTIMISM]:  1,

22✔

1113

        [ChainId.CRONOS]:    6,

22✔

1114

        [ChainId.BSC]:       14,

22✔

1115

        [ChainId.POLYGON]:   128,

22✔

1116

        [ChainId.FANTOM]:    5,

22✔

1117

        [ChainId.BOBA]:      1,

22✔

1118

        [ChainId.METIS]:     6,

22✔

1119

        [ChainId.MOONBEAM]:  21,

22✔

1120

        [ChainId.MOONRIVER]: 21,

22✔

1121

        [ChainId.ARBITRUM]:  40,

22✔

1122

        [ChainId.AVALANCHE]: 5,

22✔

1123

        [ChainId.TERRA]:     1,

22✔

1124

        [ChainId.AURORA]:    5,

22✔

1125

        [ChainId.HARMONY]:   1,

22✔

1126

};

22✔

1127

22✔

1128

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

22✔

1130

1,622✔

1132

1,622✔

1133

22✔

1134

    /* c8 ignore next */

4✔

1135

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

4✔

1136

        return TokenSwap.bridgeSwapSupported(args)

615✔

1137

615✔

1138

22✔

synapsecns / sdk / 2010984896

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

synapsecns / sdk / 2010984896

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