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

1

import {toLower} from "lodash-es";

2✔

2

2✔

3

import {

2✔

4

    ChainId,

2✔

5

    isTerraChainId

2✔

6

}  from "@chainid";

2✔

7

import {Networks} from "@networks";

2✔

8

2✔

9

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

2✔

10

2✔

11

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

2✔

12

2✔

13

import * as SynapseEntities from "@entities";

2✔

14

2✔

15

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

2✔

16

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

2✔

17

import {TerraSignerWrapper, tokenSwitch, validateTerraAddress} from "@internal/utils";

2✔

18

import {

2✔

19

    terraRpcProvider,

2✔

20

    rpcProviderForChain,

2✔

21

} from "@internal/rpcproviders";

2✔

22

2✔

23

import type {

2✔

24

    BridgeConfigV3Contract,

2✔

25

    GenericZapBridgeContract,

2✔

26

    L1BridgeZapContract,

2✔

27

    SynapseBridgeContract

2✔

28

} from "@contracts";

2✔

29

2✔

30

import {Tokens}    from "@tokens";

2✔

31

import {TokenSwap} from "@tokenswap";

2✔

32

2✔

33

import {

2✔

34

    type Token,

2✔

35

    instanceOfToken

2✔

36

} from "@token";

2✔

37

2✔

38

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

2✔

39

2✔

40

import {GasUtils}    from "./gasutils";

2✔

41

2✔

42

import {

2✔

43

    BridgeUtils,

2✔

44

    CanBridgeError

2✔

45

} from "./bridgeutils";

2✔

46

2✔

47

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

2✔

48

2✔

49

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

2✔

50

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

2✔

51

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

2✔

52

2✔

53

import {

2✔

54

    Signer as EthersSigner

2✔

55

} from "@ethersproject/abstract-signer";

2✔

56

2✔

57

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

2✔

58

2✔

59

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

2✔

60

2✔

61

import {

2✔

62

    MsgExecuteContract,

2✔

63

    LCDClient,

2✔

64

    Wallet as TerraWallet,

2✔

65

    BlockTxBroadcastResult

2✔

66

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

2✔

67

2✔

68

import bech32 from "bech32";

2✔

69

2✔

70

2✔

71

/**

2✔

72

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

2✔

73

 * and most importantly, executing Bridge transactions.

2✔

74

*/

2✔

75

export namespace Bridge {

12✔

76

    const TEN = BigNumber.from(10);

12✔

77

12✔

78

    type CanBridgeResult = {

12✔

79

        canBridge: boolean;

12✔

80

        error?:    Error | string;

12✔

81

        amount?:   BigNumberish;

12✔

82

12✔

83

12✔

84

    export type CheckCanBridgeResult = [boolean, BigNumber];

12✔

85

12✔

86

    export type BridgeOutputEstimate = {

12✔

87

        amountToReceive: BigNumber,

12✔

88

        bridgeFee:       BigNumber,

12✔

89

12✔

90

12✔

91

/**

12✔

92

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

12✔

93

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

12✔

94

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

12✔

95

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

12✔

96

*/

12✔

97

    export interface BridgeParams {

12✔

98

        tokenFrom:   Token,

12✔

99

        tokenTo:     Token

12✔

100

        chainIdTo:   number,

12✔

101

        amountFrom?: BigNumber,

12✔

102

12✔

103

12✔

104

/**

12✔

105

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

12✔

106

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

12✔

107

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

12✔

108

     * on the destination chain.

12✔

109

*/

12✔

110

    export interface BridgeTransactionParams extends BridgeParams {

12✔

111

        amountFrom: BigNumber,

12✔

112

        amountTo:   BigNumber,

12✔

113

        addressTo?: string

12✔

114

12✔

115

12✔

116

    type EasyArgsCheck = {

12✔

117

        isEasy:   boolean,

12✔

118

        castArgs: BridgeUtils.BridgeTxParams,

12✔

119

        txn?:     Promise<PopulatedTransaction>,

12✔

120

12✔

121

12✔

122

    type BridgeTokenArgs = {

12✔

123

        fromChainTokens: Token[],

12✔

124

        toChainTokens:   Token[],

12✔

125

        tokenFrom:       Token,

12✔

126

        tokenTo:         Token,

12✔

127

        tokenIndexFrom:  number,

12✔

128

        tokenIndexTo:    number,

12✔

129

12✔

130

12✔

131

    type CanBridgeArgs = {

12✔

132

        address?: string;

12✔

133

        signer?:  EthersSigner;

12✔

134

        amount:   BigNumberish;

12✔

135

        token:    Token;

12✔

136

12✔

137

12✔

138

    type CheckCanBridgeParams = {

12✔

139

        address: string,

12✔

140

        token:   Token,

12✔

141

        amount:  BigNumberish,

12✔

142

12✔

143

12✔

144

/**

12✔

145

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

12✔

146

*/

12✔

147

    export class SynapseBridge {

12✔

148

        protected network: Networks.Network;

12✔

149

        protected chainId: number;

682✔

150

        protected _provider: Provider | LCDClient;

682✔

151

682✔

152

        private readonly bridgeAddress: string;

682✔

153

682✔

154

        private readonly bridgeInstance:           SynapseBridgeContract;

682✔

155

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

682✔

156

682✔

157

        private readonly isTerra:      boolean;

682✔

158

        private readonly isL2Zap:      boolean;

682✔

159

        private readonly isL2ETHChain: boolean;

682✔

160

682✔

161

        private readonly zapBridgeAddress: string;

682✔

162

682✔

163

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

682✔

164

682✔

165

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

682✔

166

            chainId: ChainId.ETH,

682✔

167

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

682✔

168

});

682✔

169

682✔

170

        readonly requiredConfirmations: number;

12✔

171

12✔

172

        constructor(args: {

12✔

173

            network: Networks.Network | number,

682✔

174

            provider?: Provider

682✔

175

        }) {

682✔

176

            let {network, provider} = args;

682✔

177

682✔

178

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

682✔

179

            this.chainId = this.network.chainId;

682✔

180

682✔

181

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

682✔

182

682✔

183

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

682✔

184

            this.isL2Zap = this.network.zapIsL2BridgeZap;

682✔

185

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

682✔

186

682✔

187

            this._provider = provider ?? (this.isTerra

682✔

188

                ? terraRpcProvider(this.chainId)

616✔

189

                : rpcProviderForChain(this.chainId)

616✔

190

);

682✔

191

682✔

192

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

682✔

193

682✔

194

            this.bridgeAddress    = contractAddrs.bridgeAddress;

682✔

195

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

682✔

196

682✔

197

            if (!this.isTerra) {

682✔

198

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

664✔

199

664✔

200

                this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

664✔

201

664✔

202

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

664✔

203

                    this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

664✔

204

664✔

205

664✔

206

682✔

207

12✔

208

        private get provider(): Provider {

12✔

209

            return this._provider as Provider

174✔

210

174✔

211

12✔

212

        private get terraProvider(): LCDClient {

12✔

213

            return this._provider as LCDClient

4✔

214

4✔

215

12✔

216

        bridgeVersion(): Promise<BigNumber> {

12✔

217

            if (this.isTerra) {

30✔

218

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

2✔

219

2✔

220

28✔

221

            return this.bridgeInstance.bridgeVersion()

28✔

222

28✔

223

12✔

224

        WETH_ADDRESS(): Promise<string> {

12✔

225

            if (this.isTerra) {

30✔

226

                return Promise.resolve("0x0000000000000000000000000000000000000000")

2✔

227

2✔

228

30✔

229

            return this.bridgeInstance.WETH_ADDRESS()

30✔

230

30✔

231

12✔

232

/**

12✔

233

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

12✔

234

         * is supported.

12✔

235

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

12✔

236

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

12✔

237

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

12✔

238

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

12✔

239

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

12✔

240

*/

12✔

241

        swapSupported(args: {

12✔

242

            tokenFrom: Token,

308✔

243

            tokenTo:   Token

308✔

244

            chainIdTo: number,

308✔

245

        }): [boolean, string] {

308✔

246

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

308✔

247

308✔

248

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

308✔

249

308✔

250

12✔

251

/**

12✔

252

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

12✔

253

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

12✔

254

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

12✔

255

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

12✔

256

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

12✔

257

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

12✔

258

*/

12✔

259

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

12✔

260

            return this.checkSwapSupported(args)

184✔

261

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

184✔

262

                .catch(rejectPromise)

184✔

263

184✔

264

12✔

265

/**

12✔

266

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

12✔

267

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

12✔

268

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

12✔

269

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

12✔

270

         * of web3/ethers/etc.

12✔

271

*/

12✔

272

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

12✔

273

            const

186✔

274

                {addressTo} = args,

186✔

275

                tokenArgs = this.makeBridgeTokenArgs(args),

186✔

276

                {tokenFrom, tokenTo} = tokenArgs;

186✔

277

186✔

278

            if ((!addressTo) || addressTo === "") {

186✔

279

                return rejectPromise(

4✔

280

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

4✔

281

4✔

282

4✔

283

180✔

284

            if (args.chainIdTo === ChainId.TERRA && !validateTerraAddress(args.addressTo)) {

186✔

285

                return rejectPromise(

2✔

286

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

2✔

287

2✔

288

            } else if (args.chainIdTo !== ChainId.TERRA && !isAddress(args.addressTo)) {

186✔

289

                return rejectPromise(

2✔

290

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

2✔

291

2✔

292

2✔

293

176✔

294

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

176✔

295

176✔

296

            let newTxn: Promise<PopulatedTransaction>;

176✔

297

176✔

298

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

186✔

299

                if (this.isTerra) {

16✔

300

                    return this.buildTerraBridgeTxn(args)

6✔

301

6✔

302

10✔

303

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

10✔

304

                    args.chainIdTo,

10✔

305

                    Tokens.UST.address(this.chainId),

10✔

306

                    args.amountFrom

10✔

307

];

10✔

308

10✔

309

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

16✔

310

                    newTxn = this.bridgeInstance

4✔

311

                        .populateTransaction

4✔

312

                        .redeemV2(

4✔

313

                            bech32.decode(args.addressTo).words,

4✔

314

                            ...redeemArgs

4✔

315

);

4✔

316

                } else {

10✔

317

                    newTxn = this.bridgeInstance

6✔

318

                        .populateTransaction

6✔

319

                        .redeem(

6✔

320

                            args.addressTo,

6✔

321

                            ...redeemArgs

6✔

322

);

6✔

323

6✔

324

            } else {

186✔

325

                newTxn = this.chainId === ChainId.ETH

160✔

326

                    ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

160✔

327

                    : this.buildL2BridgeTxn(args, tokenArgs);

160✔

328

160✔

329

186✔

330

            return newTxn

186✔

331

                .then(txn =>

186✔

332

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

162✔

333

186✔

334

186✔

335

12✔

336

/**

12✔

337

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

12✔

338

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

12✔

339

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

12✔

340

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

12✔

341

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

12✔

342

         * @return {Promise<ContractTransaction>}

12✔

343

*/

12✔

344

        async executeBridgeTokenTransaction(

12✔

345

            args:       BridgeTransactionParams,

8✔

346

            signer:     EthersSigner | TerraWallet,

8✔

347

            callStatic: boolean=false

8✔

348

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

8✔

349

            try {

8✔

350

                await this.checkSwapSupported(args);

8✔

352

                /* c8 ignore next 2 */

2✔

353

                return rejectPromise(e);

2✔

354

2✔

355

8✔

356

            const {tokenFrom, amountFrom, addressTo} = args;

8✔

357

8✔

358

            let txSigner: GenericSigner;

8✔

359

            let signerAddress: string;

8✔

360

8✔

361

            if (signer instanceof TerraWallet) {

8✔

362

                txSigner = new TerraSignerWrapper(signer);

2✔

363

            } else {

8✔

364

                txSigner = signer;

6✔

365

6✔

366

8✔

367

            signerAddress = await txSigner.getAddress();

8✔

369

8✔

370

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

8✔

371

8✔

372

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

8✔

379

8✔

380

            return this.checkCanBridge(checkArgs)

8✔

381

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

8✔

382

                    canBridge

8✔

384

                        : rejectPromise(new CanBridgeError(error, amount))

8✔

385

8✔

386

8✔

387

12✔

388

/**

12✔

389

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

12✔

390

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

12✔

391

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

12✔

392

         * framework so they can ultimately send the transaction.

12✔

393

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

12✔

394

         * @param {Object} args

12✔

395

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

12✔

396

         * to the bridge on the source chain.

12✔

397

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

12✔

398

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

12✔

399

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

12✔

400

         * of web3/ethers/etc.

12✔

401

*/

12✔

402

        async buildApproveTransaction(args: {

12✔

403

            token:   Token | string,

156✔

404

            amount?: BigNumberish

156✔

405

        }): Promise<PopulatedTransaction> {

156✔

406

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

156✔

407

156✔

408

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

156✔

409

156✔

410

12✔

411

/**

12✔

412

         * Builds and executes an ERC20 Approve call,

12✔

413

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

12✔

414

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

12✔

415

         * framework so they can ultimately send the transaction.

12✔

416

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

12✔

417

         * @param {Object} args

12✔

418

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

12✔

419

         * to the bridge on the source chain.

12✔

420

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

12✔

421

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

12✔

422

         * transaction.

12✔

423

*/

12✔

424

        async executeApproveTransaction(

12✔

425

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

6✔

426

            signer:     EthersSigner,

6✔

427

        ): Promise<ContractTransaction> {

6✔

428

            const

6✔

429

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

6✔

430

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

6✔

431

6✔

432

            return ERC20.approve(approveArgs, tokenParams, signer)

6✔

433

6✔

434

12✔

435

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

12✔

436

            const {token, signer, address} = args;

28✔

437

28✔

438

            let signerAddress: string;

28✔

440

                /* c8 ignore next */

2✔

441

                signerAddress = await signer.getAddress();

2✔

442

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

28✔

443

                signerAddress = address;

28✔

444

28✔

445

28✔

446

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

28✔

447

28✔

448

            const

28✔

449

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

28✔

450

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

28✔

451

28✔

452

            if (isTerraTx) {

28✔

453

                return this.checkTerraUSTBalance(checkArgs);

4✔

454

4✔

455

28✔

456

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

28✔

457

                ? this.checkGasTokenBalance(checkArgs)

28✔

458

                : this.checkERC20Balance(checkArgs);

28✔

459

28✔

460

            return isGasTokenTransfer

28✔

461

                ? hasBalanceRes

28✔

462

                : this.checkNeedsApprove(checkArgs)

28✔

463

                    .then(approveRes => Bridge.SynapseBridge.resolveApproveFunc(approveRes, hasBalanceRes, token))

10✔

464

                    .catch(rejectPromise)

10✔

465

28✔

466

12✔

467

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

12✔

468

            let {chainIdTo, amountFrom} = args;

174✔

469

174✔

470

            let toChainZap: GenericZapBridgeContract;

174✔

471

174✔

472

            if (chainIdTo !== ChainId.TERRA) {

174✔

473

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

168✔

474

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

168✔

475

168✔

476

174✔

477

            const {

174✔

478

                tokenFrom, tokenTo,

174✔

479

                tokenIndexFrom, tokenIndexTo,

174✔

480

                fromChainTokens

174✔

481

            } = this.makeBridgeTokenArgs(args);

174✔

482

174✔

483

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

174✔

484

174✔

485

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

174✔

486

174✔

487

            const

174✔

488

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

174✔

489

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

174✔

490

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

174✔

491

174✔

492

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

174✔

493

                intermediateTokenAddr,

174✔

494

                chainIdTo,

174✔

495

                amtFrom

174✔

496

);

174✔

497

174✔

498

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

174✔

499

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

348✔

500

174✔

501

            const

174✔

502

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

174✔

503

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

174✔

504

174✔

505

            let amountToReceive_from_prom: Promise<BigNumber>;

174✔

506

            switch (true) {

174✔

507

                case amountFrom.eq(Zero):

174✔

508

                    amountToReceive_from_prom = Promise.resolve(Zero);

8✔

509

                    break;

8✔

510

                case ethToEth:

174✔

511

                case Tokens.isMintBurnToken(tokenFrom):

174✔

512

                case tokenFrom.isWrappedToken:

174✔

513

                    amountToReceive_from_prom = Promise.resolve(amountFrom);

110✔

514

                    break;

110✔

515

                case this.chainId === ChainId.ETH:

174✔

516

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

8✔

517

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

8✔

518

8✔

519

                    break;

8✔

520

                default:

174✔

521

                    amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

48✔

522

                        this.networkZapBridgeInstance,

48✔

523

                        intermediateToken.address(this.chainId),

48✔

524

                        tokenIndexFrom,

48✔

525

0,

48✔

526

                        amountFrom

48✔

527

);

48✔

528

174✔

529

174✔

530

            let amountToReceive_from = await amountToReceive_from_prom;

174✔

531

174✔

532

            let bridgeFee: BigNumber;

174✔

533

            /* c8 ignore start */

2✔

534

            try {

2✔

535

                bridgeFee = await bridgeFeeRequest;

2✔

536

                if (bridgeFee === null) {

2✔

537

                    console.error("calculateSwapFee returned null");

2✔

538

                    return rejectPromise("calculateSwapFee returned null")

2✔

539

2✔

540

            } catch (e) {

2✔

541

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

2✔

542

                return rejectPromise(e)

2✔

543

2✔

544

            /* c8 ignore stop */

2✔

545

174✔

546

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

174✔

547

174✔

548

            let amountToReceive_to_prom: Promise<BigNumber>;

174✔

549

            switch (true) {

174✔

550

                case amountToReceive_from.isZero():

174✔

551

                    amountToReceive_to_prom = Promise.resolve(Zero);

12✔

552

                    break;

12✔

553

                case ethFromEth:

174✔

554

                case Tokens.isMintBurnToken(tokenTo):

174✔

555

                case tokenTo.isWrappedToken:

174✔

556

                    amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

100✔

557

                    break;

100✔

558

                case chainIdTo === ChainId.ETH:

174✔

559

                    amountToReceive_to_prom = (toChainZap as L1BridgeZapContract)

6✔

560

                        .calculateRemoveLiquidityOneToken(amountToReceive_from, tokenIndexTo);

6✔

561

6✔

562

                    break;

6✔

563

                default:

174✔

564

                    amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

56✔

565

                        toChainZap,

56✔

566

                        intermediateToken.address(chainIdTo),

56✔

567

0,

56✔

568

                        tokenIndexTo,

56✔

569

                        amountToReceive_from

56✔

570

);

56✔

571

174✔

572

174✔

573

            let amountToReceive: BigNumber;

174✔

574

            /* c8 ignore next 6 */

2✔

575

            try {

2✔

576

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

2✔

577

            } catch (err) {

2✔

578

                return rejectPromise(err)

2✔

579

2✔

580

2✔

581

            return {

174✔

582

                amountToReceive,

174✔

584

174✔

585

174✔

586

12✔

587

        private buildETHMainnetBridgeTxn(

12✔

588

            args:      BridgeTransactionParams,

42✔

589

            tokenArgs: BridgeTokenArgs

42✔

590

        ): Promise<PopulatedTransaction> {

42✔

591

            const

42✔

592

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

42✔

593

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

42✔

594

                    chainId: this.chainId,

42✔

595

                    signerOrProvider: this.provider

42✔

596

});

42✔

597

42✔

598

let

42✔

599

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

42✔

600

                easyDeposits:   ID[] = [Tokens.HIGH.id, Tokens.DOG.id, Tokens.FRAX.id],

42✔

601

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

42✔

602

42✔

603

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

42✔

604

            if (isEasy && txn) {

42✔

605

                return txn

12✔

606

12✔

607

30✔

608

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

30✔

609

                    args.tokenFrom.isEqual(t)

58✔

610

                        ? amountFrom

58✔

611

                        : Zero

58✔

612

);

30✔

613

30✔

614

            const {

30✔

615

                transactionDeadline,

30✔

616

                bridgeTransactionDeadline,

30✔

617

                minToSwapDestFromOrigin,

30✔

618

                minToSwapDest,

30✔

619

                minToSwapOriginMediumSlippage,

30✔

620

                minToSwapDestFromOriginMediumSlippage,

30✔

621

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

30✔

622

30✔

623

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

38✔

624

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

4✔

625

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

2✔

626

                        args as BridgeUtils.BridgeTxParams,

2✔

627

                        this.chainId,

2✔

628

                        args.tokenTo

2✔

629

);

2✔

630

2✔

631

                    return zapBridge

2✔

632

                        .populateTransaction

2✔

633

                        .deposit(...bridgeDepositArgs)

2✔

634

                } else {

2✔

635

                    return zapBridge.populateTransaction.zapAndDeposit(

2✔

636

                        addressTo,

2✔

637

                        chainIdTo,

2✔

638

                        Tokens.NUSD.address(this.chainId),

2✔

639

                        liquidityAmounts,

2✔

640

                        minToSwapDest,

2✔

641

                        transactionDeadline,

2✔

642

2✔

643

2✔

644

4✔

645

38✔

646

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

42✔

647

                return zapBridge.populateTransaction.depositETHAndSwap(

10✔

648

                    ...BridgeUtils.depositETHParams(castArgs),

10✔

649

                    0, // nusd tokenindex,

10✔

650

                    tokenArgs.tokenIndexTo,

10✔

651

                    minToSwapDestFromOrigin, // minDy

10✔

652

                    bridgeTransactionDeadline,

10✔

653

                    BridgeUtils.overrides(amountFrom)

10✔

654

10✔

655

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

38✔

656

                return zapBridge.populateTransaction.depositAndSwap(

4✔

657

                    addressTo,

4✔

658

                    chainIdTo,

4✔

659

                    Tokens.NUSD.address(this.chainId),

4✔

660

                    amountFrom,

4✔

661

0,

4✔

662

                    tokenArgs.tokenIndexTo,

4✔

663

                    minToSwapDestFromOriginMediumSlippage,

4✔

664

                    bridgeTransactionDeadline

4✔

665

4✔

666

4✔

667

38✔

668

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

38✔

669

                addressTo,

38✔

670

                chainIdTo,

38✔

671

                Tokens.NUSD.address(this.chainId),

38✔

672

                liquidityAmounts,

38✔

673

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

38✔

674

                transactionDeadline,

38✔

675

0,

38✔

676

                tokenArgs.tokenIndexTo,

38✔

677

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

38✔

678

                bridgeTransactionDeadline,

38✔

679

38✔

680

38✔

681

12✔

682

        private buildL2BridgeTxn(

12✔

683

            args: BridgeTransactionParams,

118✔

684

            tokenArgs: BridgeTokenArgs

118✔

685

        ): Promise<PopulatedTransaction> {

118✔

686

            const

118✔

687

                {chainIdTo, amountFrom, amountTo} = args,

118✔

688

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

118✔

689

                    chainId: this.chainId,

118✔

690

                    signerOrProvider: this.provider

118✔

691

});

118✔

692

118✔

693

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

118✔

695

                : tokenArgs.tokenFrom;

118✔

696

118✔

697

let

118✔

698

                easyDeposits:   ID[] = [],

118✔

699

                easyDepositETH: ID[] = [],

118✔

700

                easyRedeems:    ID[] = [

118✔

701

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

118✔

702

                    Tokens.DOG.id, Tokens.FRAX.id

118✔

703

];

118✔

704

118✔

705

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

118✔

706

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

590✔

707

590✔

708

let

590✔

709

                    hasAltChain = typeof altChainId !== 'undefined',

590✔

710

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

590✔

711

590✔

712

                if (this.chainId === chainId) {

590✔

713

                    depositEth

58✔

714

                        ? easyDepositETH.push(...tokenHashes)

58✔

715

                        : easyDeposits.push(...tokenHashes);

58✔

716

                } else {

590✔

717

                    if (hasAltChain) {

532✔

718

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

202✔

719

                    } else {

532✔

720

                        easyRedeems.push(...tokenHashes);

330✔

721

330✔

722

532✔

723

})

118✔

724

118✔

725

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

118✔

726

            if (isEasy && txn) {

118✔

727

                return txn

26✔

728

26✔

729

118✔

730

            const {

118✔

731

                transactionDeadline,

118✔

732

                bridgeTransactionDeadline,

118✔

733

                minToSwapOriginHighSlippage,

118✔

734

                minToSwapDestFromOriginHighSlippage,

118✔

735

                minToSwapDest,

118✔

736

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

118✔

737

118✔

738

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

118✔

739

                zapBridge

6✔

740

                    .populateTransaction

6✔

741

                    .redeemAndSwap(

6✔

742

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

6✔

743

0,

6✔

744

                        tokenArgs.tokenIndexTo,

6✔

745

                        minToSwapDest,

6✔

746

                        transactionDeadline,

6✔

747

118✔

748

118✔

749

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

118✔

750

                let populateFn = swapETH

12✔

751

                    ? zapBridge.populateTransaction.swapETHAndRedeem

12✔

752

                    : zapBridge.populateTransaction.swapAndRedeem

12✔

753

12✔

754

                return populateFn(

12✔

755

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

12✔

756

                    tokenArgs.tokenIndexFrom,

12✔

757

0,

12✔

758

                    amountFrom,

12✔

759

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

12✔

760

                    transactionDeadline,

12✔

761

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

12✔

762

12✔

763

12✔

764

118✔

765

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

118✔

766

                let populateFn = swapETH

36✔

767

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

36✔

768

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

36✔

769

36✔

770

                return populateFn(

36✔

771

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

36✔

772

                    tokenArgs.tokenIndexFrom,

36✔

773

0,

36✔

774

                    amountFrom,

36✔

775

                    minToSwapOriginHighSlippage,

36✔

776

                    transactionDeadline,

36✔

777

0,

36✔

778

                    tokenArgs.tokenIndexTo,

36✔

779

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

36✔

780

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

36✔

781

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

36✔

782

36✔

783

36✔

784

118✔

785

            switch (tokenSwitch(args.tokenTo)) {

118✔

786

                case Tokens.NUSD:

118✔

787

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

18✔

788

                        return zapBridge

4✔

789

                            .populateTransaction

4✔

790

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

4✔

791

4✔

792

14✔

793

                    return zapBridge

14✔

794

                        .populateTransaction

14✔

795

                        .swapAndRedeem(

14✔

796

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

14✔

797

                            tokenArgs.tokenIndexFrom,

14✔

798

0,

14✔

799

                            amountFrom,

14✔

800

                            minToSwapOriginHighSlippage,

14✔

801

                            transactionDeadline

14✔

802

14✔

803

                case Tokens.GMX:

118✔

804

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

4✔

805

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

4✔

806

4✔

807

                    return this.chainId === ChainId.ARBITRUM

4✔

808

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

4✔

809

                        : this.bridgeInstance

4✔

810

                            .populateTransaction

2✔

811

                            .redeem(

2✔

812

                                addrTo,

2✔

813

                                chainTo,

2✔

814

                                Tokens.GMX.wrapperAddress(this.chainId),

2✔

815

                                amount

2✔

816

4✔

817

                default:

118✔

818

                    if (chainIdTo === ChainId.ETH) {

64✔

819

                        if (this.isL2ETHChain) {

22✔

820

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

18✔

821

                                return zapBridge

6✔

822

                                    .populateTransaction

6✔

823

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

6✔

824

6✔

825

12✔

826

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

12✔

827

                            return easySwapAndRedeem(Tokens.NETH, useSwapETH)

12✔

828

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

18✔

829

                            return zapBridge

2✔

830

                                .populateTransaction

2✔

831

                                .redeemAndRemove(

2✔

832

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

2✔

833

                                    amountFrom,

2✔

834

                                    tokenArgs.tokenIndexTo,

2✔

835

                                    minToSwapDest,

2✔

836

                                    transactionDeadline

2✔

837

2✔

838

2✔

839

2✔

840

                        return zapBridge

2✔

841

                            .populateTransaction

2✔

842

                            .swapAndRedeemAndRemove(

2✔

843

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

2✔

844

                                tokenArgs.tokenIndexFrom,

2✔

845

0,

2✔

846

                                amountFrom,

2✔

847

                                minToSwapOriginHighSlippage,

2✔

848

                                transactionDeadline,

2✔

849

                                tokenArgs.tokenIndexTo, //swapTokenIndex

2✔

850

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

2✔

851

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

2✔

852

2✔

853

2✔

854

42✔

855

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

64✔

856

                        return easyRedeemAndSwap(args.tokenFrom)

6✔

857

6✔

858

36✔

859

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

58✔

860

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

24✔

861

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

24✔

862

24✔

863

12✔

864

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

12✔

865

118✔

866

118✔

867

12✔

868

        private buildTerraBridgeTxn({

12✔

869

            addressTo,

6✔

870

            chainIdTo,

6✔

871

            amountFrom

6✔

872

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

6✔

873

            return Promise.resolve(new MsgExecuteContract(

6✔

874

                null,

6✔

875

                this.bridgeAddress,

6✔

876

6✔

877

                    deposit: {

6✔

878

                        to_address: toLower(addressTo),

6✔

879

                        chain_id:  `${chainIdTo}`,

6✔

880

                        denom:     "uusd"

6✔

881

6✔

882

},

6✔

883

                { uusd: amountFrom.toNumber() }

6✔

884

))

6✔

885

6✔

886

12✔

887

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

12✔

888

            let {tokenFrom, tokenTo, chainIdTo} = args;

360✔

889

360✔

890

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

360✔

891

360✔

892

            switch (tokenFrom.swapType) {

360✔

893

                case SwapType.ETH:

360✔

894

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

132✔

895

                    break;

132✔

896

                case SwapType.AVAX:

360✔

897

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

8✔

898

                    break;

8✔

899

                case SwapType.MOVR:

360✔

900

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

8✔

901

                    break;

8✔

902

                default:

360✔

903

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

212✔

904

360✔

905

360✔

906

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

360✔

907

360✔

908

            const

360✔

909

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

360✔

910

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

360✔

911

360✔

912

            return {

360✔

913

                fromChainTokens,

360✔

914

                toChainTokens,

360✔

915

                tokenFrom,

360✔

916

                tokenTo,

360✔

917

                tokenIndexFrom,

360✔

918

                tokenIndexTo

360✔

919

360✔

920

360✔

921

12✔

922

        private checkEasyArgs(

12✔

923

            args: BridgeTransactionParams,

160✔

924

            zapBridge: GenericZapBridgeContract,

160✔

925

            easyDeposits:    ID[],

160✔

926

            easyRedeems:     ID[],

160✔

927

            easyDepositETH?: ID[],

160✔

928

        ): EasyArgsCheck {

160✔

929

let

160✔

930

                castArgs = args as BridgeUtils.BridgeTxParams,

160✔

931

                isEasy: boolean = false,

160✔

932

                txn:    Promise<PopulatedTransaction>;

160✔

933

160✔

934

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

160✔

935

160✔

936

            switch (true) {

160✔

937

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

160✔

938

                    isEasy = true;

18✔

939

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

18✔

940

                    break;

18✔

941

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

160✔

942

                    isEasy = true;

8✔

943

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

8✔

944

                    break;

8✔

945

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

160✔

946

                    isEasy = true;

12✔

947

                    txn    =  zapBridge

12✔

948

                        .populateTransaction

12✔

949

                        .depositETH(

12✔

950

                            ...BridgeUtils.depositETHParams(castArgs),

12✔

951

                            BridgeUtils.overrides(args.amountFrom)

12✔

952

);

12✔

953

                    break;

12✔

954

160✔

955

160✔

956

            return {castArgs, isEasy, txn}

160✔

957

160✔

958

12✔

959

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

12✔

960

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

192✔

961

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

192✔

962

                if (!swapSupported) {

192✔

963

                    reject(errReason);

10✔

964

                    return

10✔

965

10✔

966

182✔

967

                resolve(true);

182✔

968

})

192✔

969

192✔

970

12✔

971

        private buildERC20ApproveArgs(args: {

12✔

972

            token:   Token | string,

182✔

973

            amount?: BigNumberish

182✔

974

        }): [ERC20.ApproveArgs, string] {

182✔

975

            const {token, amount} = args;

182✔

976

182✔

977

            let tokenAddr: string = instanceOfToken(token)

182✔

978

                ? token.address(this.chainId)

182✔

980

182✔

981

            let spender: string;

182✔

982

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

182✔

983

                spender = this.bridgeAddress;

18✔

984

            } else {

182✔

985

                spender = this.zapBridgeAddress;

164✔

986

164✔

987

182✔

988

            return [{

182✔

989

                spender,

182✔

990

                amount

182✔

991

            }, tokenAddr]

182✔

992

182✔

993

12✔

994

        async getAllowanceForAddress(args: {

12✔

995

            address: string,

10✔

996

            token:   Token,

10✔

997

        }): Promise<BigNumber> {

10✔

998

            let { address, token } = args;

10✔

999

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

10✔

1000

10✔

1001

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

10✔

1002

10✔

1003

12✔

1004

        private static async resolveApproveFunc(

12✔

1005

            approveRes:    CheckCanBridgeResult,

10✔

1006

            hasBalanceRes: Promise<CanBridgeResult>,

10✔

1007

            token:         Token

10✔

1008

        ): Promise<CanBridgeResult> {

10✔

1009

            const [needsApprove, allowance] = approveRes;

10✔

1010

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

10✔

1011

10✔

1012

            return needsApprove

10✔

1014

                : hasBalanceRes

10✔

1015

10✔

1016

12✔

1017

        private async checkNeedsApprove({

12✔

1018

            address,

10✔

1019

            token,

10✔

1020

            amount=MAX_APPROVAL_AMOUNT.sub(1)

10✔

1021

        }: CheckCanBridgeParams): Promise<CheckCanBridgeResult> {

10✔

1022

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

10✔

1023

10✔

1024

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

10✔

1025

                .then(allowance => [allowance.lt(amount), allowance] as CheckCanBridgeResult)

10✔

1026

10✔

1027

12✔

1028

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

12✔

1029

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

14✔

1030

14✔

1031

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

14✔

1033

                /* c8 ignore next */

2✔

1034

                balanceFn = signer.getBalance;

2✔

1035

            } else if (address) {

14✔

1036

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

14✔

1037

14✔

1038

14✔

1039

            return this.resolveBalanceFunc(

14✔

1040

                balanceFn(),

14✔

1041

                amount,

14✔

1042

                token

14✔

1043

14✔

1044

14✔

1045

12✔

1046

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

12✔

1047

            const

10✔

1048

                {address, amount, token} = args,

10✔

1049

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

10✔

1050

10✔

1051

            return this.resolveBalanceFunc(

10✔

1052

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

10✔

1053

                amount,

10✔

1054

                token

10✔

1055

10✔

1056

10✔

1057

12✔

1058

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

12✔

1059

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

4✔

1060

                .then(([res]) => {

4✔

1061

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

4✔

1062

4✔

1063

                    let ustBalance: BigNumber = Zero;

4✔

1064

4✔

1065

                    if (coin) {

4✔

1066

                        const {amount} = coin.toData();

4✔

1067

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

4✔

1068

                            ustBalance = BigNumber.from(amount);

4✔

1069

4✔

1070

4✔

1071

4✔

1072

                    return ustBalance

4✔

1073

})

4✔

1074

4✔

1075

            return this.resolveBalanceFunc(

4✔

1076

                balProm,

4✔

1077

                amount,

4✔

1078

                token

4✔

1079

4✔

1080

4✔

1081

12✔

1082

        private async resolveBalanceFunc(

12✔

1083

            prom:   Promise<BigNumber>,

28✔

1084

            amount: BigNumberish,

28✔

1085

            token:  Token

28✔

1086

        ): Promise<CanBridgeResult> {

28✔

1087

            return Promise.resolve(prom)

28✔

1088

                .then(balance => {

28✔

1089

                    const hasBalance = balance.gte(amount);

28✔

1090

28✔

1091

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

28✔

1092

28✔

1093

                    return hasBalance

28✔

1094

                        ? {canBridge: true}

28✔

1095

                        : {canBridge: false, error: new Error(errMsg), amount: balance}

28✔

1096

})

28✔

1097

                .catch(rejectPromise)

28✔

1098

28✔

1099

12✔

1100

12✔

1101

    const REQUIRED_CONFS: NumberMap = {

12✔

1102

        [ChainId.ETH]:       7,

12✔

1103

        [ChainId.OPTIMISM]:  1,

12✔

1104

        [ChainId.CRONOS]:    6,

12✔

1105

        [ChainId.BSC]:       14,

12✔

1106

        [ChainId.POLYGON]:   128,

12✔

1107

        [ChainId.FANTOM]:    5,

12✔

1108

        [ChainId.BOBA]:      1,

12✔

1109

        [ChainId.METIS]:     6,

12✔

1110

        [ChainId.MOONBEAM]:  21,

12✔

1111

        [ChainId.MOONRIVER]: 21,

12✔

1112

        [ChainId.ARBITRUM]:  40,

12✔

1113

        [ChainId.AVALANCHE]: 5,

12✔

1114

        [ChainId.TERRA]:     1,

12✔

1115

        [ChainId.AURORA]:    5,

12✔

1116

        [ChainId.HARMONY]:   1,

12✔

1117

};

12✔

1118

12✔

1119

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

12✔

1121

682✔

1123

682✔

1124

12✔

1125

    /* c8 ignore next */

2✔

1126

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

2✔

1127

        return TokenSwap.bridgeSwapSupported(args)

308✔

1128

308✔

1129

12✔

synapsecns / sdk / 1962405766

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

synapsecns / sdk / 1962405766

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