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

1

import {toLower} from "lodash-es";

3✔

2

3✔

3

import {ChainId}  from "@chainid";

3✔

4

import {Networks} from "@networks";

3✔

5

3✔

6

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

3✔

7

3✔

8

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

3✔

9

3✔

10

import * as SynapseEntities from "@entities";

3✔

11

3✔

12

import {

3✔

13

    type ID,

3✔

14

    SwapType,

3✔

15

    rpcProviderForChain,

3✔

16

    terraRpcProvider,

3✔

17

    tokenSwitch,

3✔

18

    TerraSignerWrapper,

3✔

19

    validateTerraAddress

3✔

20

} from "@internal/index";

3✔

21

3✔

22

import type {

3✔

23

    BridgeConfigV3Contract,

3✔

24

    GenericZapBridgeContract,

3✔

25

    L1BridgeZapContract,

3✔

26

    SynapseBridgeContract

3✔

27

} from "@contracts";

3✔

28

3✔

29

import {Tokens}    from "@tokens";

3✔

30

import {TokenSwap} from "@tokenswap";

3✔

31

3✔

32

import {

3✔

33

    type Token,

3✔

34

    instanceOfToken

3✔

35

} from "@token";

3✔

36

3✔

37

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

3✔

38

3✔

39

import {GasUtils}                   from "./gasutils";

3✔

40

3✔

41

import {

3✔

42

    BridgeUtils,

3✔

43

    CanBridgeError

3✔

44

} from "./bridgeutils";

3✔

45

3✔

46

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

3✔

47

3✔

48

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

3✔

49

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

3✔

50

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

3✔

51

3✔

52

import {

3✔

53

    Signer as EthersSigner

3✔

54

} from "@ethersproject/abstract-signer";

3✔

55

3✔

56

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

3✔

57

3✔

58

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

3✔

59

3✔

60

import {

3✔

61

    MsgExecuteContract,

3✔

62

    LCDClient,

3✔

63

    Wallet as TerraWallet,

3✔

64

    BlockTxBroadcastResult

3✔

65

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

3✔

66

3✔

67

import bech32 from "bech32";

3✔

68

3✔

69

3✔

70

/**

3✔

71

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

3✔

72

 * and most importantly, executing Bridge transactions.

3✔

73

*/

3✔

74

export namespace Bridge {

21✔

75

    const TEN = BigNumber.from(10);

21✔

76

21✔

77

    type CanBridgeResult = {

21✔

78

        canBridge: boolean;

21✔

79

        error?:    Error | string;

21✔

80

        amount?:   BigNumberish;

21✔

81

21✔

82

21✔

83

    export type CheckCanBridgeResult = [boolean, BigNumber];

21✔

84

21✔

85

    export type BridgeOutputEstimate = {

21✔

86

        amountToReceive: BigNumber,

21✔

87

        bridgeFee:       BigNumber,

21✔

88

21✔

89

21✔

90

/**

21✔

91

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

21✔

92

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

21✔

93

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

21✔

94

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

21✔

95

*/

21✔

96

    export interface BridgeParams {

21✔

97

        tokenFrom:   Token,

21✔

98

        tokenTo:     Token

21✔

99

        chainIdTo:   number,

21✔

100

        amountFrom?: BigNumber,

21✔

101

21✔

102

21✔

103

/**

21✔

104

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

21✔

105

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

21✔

106

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

21✔

107

     * on the destination chain.

21✔

108

*/

21✔

109

    export interface BridgeTransactionParams extends BridgeParams {

21✔

110

        amountFrom: BigNumber,

21✔

111

        amountTo:   BigNumber,

21✔

112

        addressTo?: string

21✔

113

21✔

114

21✔

115

    type EasyArgsCheck = {

21✔

116

        isEasy:   boolean,

21✔

117

        castArgs: BridgeUtils.BridgeTxParams,

21✔

118

        txn?:     Promise<PopulatedTransaction>,

21✔

119

21✔

120

21✔

121

    type BridgeTokenArgs = {

21✔

122

        fromChainTokens: Token[],

21✔

123

        toChainTokens:   Token[],

21✔

124

        tokenFrom:       Token,

21✔

125

        tokenTo:         Token,

21✔

126

        tokenIndexFrom:  number,

21✔

127

        tokenIndexTo:    number,

21✔

128

21✔

129

21✔

130

    type CanBridgeArgs = {

21✔

131

        address?: string;

21✔

132

        signer?:  EthersSigner;

21✔

133

        amount:   BigNumberish;

21✔

134

        token:    Token;

21✔

135

21✔

136

21✔

137

    type CheckCanBridgeParams = {

21✔

138

        address: string,

21✔

139

        token:   Token,

21✔

140

        amount:  BigNumberish,

21✔

141

21✔

142

21✔

143

/**

21✔

144

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

21✔

145

*/

21✔

146

    export class SynapseBridge {

21✔

147

        protected network: Networks.Network;

21✔

148

        protected chainId: number;

1,386✔

149

        protected _provider: Provider | LCDClient;

1,386✔

150

1,386✔

151

        private readonly bridgeAddress: string;

1,386✔

152

1,386✔

153

        private readonly bridgeInstance:           SynapseBridgeContract;

1,386✔

154

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

1,386✔

155

1,386✔

156

        private readonly isTerra:      boolean;

1,386✔

157

        private readonly isL2Zap:      boolean;

1,386✔

158

        private readonly isL2ETHChain: boolean;

1,386✔

159

1,386✔

160

        private readonly zapBridgeAddress: string;

1,386✔

161

1,386✔

162

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

1,386✔

163

1,386✔

164

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

1,386✔

165

            chainId: ChainId.ETH,

1,386✔

166

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

1,386✔

167

});

1,386✔

168

1,386✔

169

        readonly requiredConfirmations: number;

21✔

170

21✔

171

        constructor(args: {

21✔

172

            network: Networks.Network | number,

1,386✔

173

            provider?: Provider

1,386✔

174

        }) {

1,386✔

175

            let {network, provider} = args;

1,386✔

176

1,386✔

177

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

1,386✔

178

            this.chainId = this.network.chainId;

1,386✔

179

1,386✔

180

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

1,386✔

181

1,386✔

182

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

1,386✔

183

            this.isL2Zap = this.network.zapIsL2BridgeZap;

1,386✔

184

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

1,386✔

185

1,386✔

186

            this._provider = provider ?? (this.isTerra

1,386✔

187

                ? terraRpcProvider(this.chainId)

1,287✔

188

                : rpcProviderForChain(this.chainId)

1,287✔

189

);

1,386✔

190

1,386✔

191

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

1,386✔

192

1,386✔

193

            this.bridgeAddress    = contractAddrs.bridgeAddress;

1,386✔

194

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

1,386✔

195

1,386✔

196

            if (!this.isTerra) {

1,386✔

197

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

1,356✔

198

1,356✔

199

                this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

1,356✔

200

1,356✔

201

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

1,356✔

202

                    this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

1,356✔

203

1,356✔

204

1,356✔

205

1,386✔

206

21✔

207

        private get provider(): Provider {

21✔

208

            return this._provider as Provider

474✔

209

474✔

210

21✔

211

        private get terraProvider(): LCDClient {

21✔

212

            return this._provider as LCDClient

9✔

213

9✔

214

21✔

215

        bridgeVersion(): Promise<BigNumber> {

21✔

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

21✔

223

        WETH_ADDRESS(): Promise<string> {

21✔

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

21✔

231

/**

21✔

232

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

21✔

233

         * is supported.

21✔

234

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

21✔

235

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

21✔

236

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

21✔

237

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

21✔

238

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

21✔

239

*/

21✔

240

        swapSupported(args: {

21✔

241

            tokenFrom: Token,

558✔

242

            tokenTo:   Token

558✔

243

            chainIdTo: number,

558✔

244

        }): [boolean, string] {

558✔

245

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

558✔

246

558✔

247

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

558✔

248

558✔

249

21✔

250

/**

21✔

251

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

21✔

252

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

21✔

253

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

21✔

254

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

21✔

255

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

21✔

256

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

21✔

257

*/

21✔

258

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

21✔

259

            return this.checkSwapSupported(args)

330✔

260

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

330✔

261

                .catch(rejectPromise)

330✔

262

330✔

263

21✔

264

/**

21✔

265

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

21✔

266

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

21✔

267

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

21✔

268

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

21✔

269

         * of web3/ethers/etc.

21✔

270

*/

21✔

271

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

21✔

272

            const

531✔

273

                {addressTo} = args,

531✔

274

                tokenArgs = this.makeBridgeTokenArgs(args),

531✔

275

                {tokenFrom, tokenTo} = tokenArgs;

531✔

276

531✔

277

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

531✔

278

                return rejectPromise(

6✔

279

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

6✔

280

6✔

281

6✔

282

531✔

283

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

531✔

284

                return rejectPromise(

3✔

285

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

3✔

286

3✔

287

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

531✔

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

531✔

293

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

531✔

294

531✔

295

            let newTxn: Promise<PopulatedTransaction>;

531✔

296

531✔

297

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

531✔

298

                if (this.isTerra) {

45✔

299

                    return this.buildTerraBridgeTxn(args)

12✔

300

12✔

301

36✔

302

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

36✔

303

                    args.chainIdTo,

36✔

304

                    Tokens.UST.address(this.chainId),

36✔

305

                    args.amountFrom

36✔

306

];

36✔

307

36✔

308

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

45✔

309

                    newTxn = this.bridgeInstance

12✔

310

                        .populateTransaction

12✔

311

                        .redeemV2(

12✔

312

                            bech32.decode(args.addressTo).words,

12✔

313

                            ...redeemArgs

12✔

314

);

12✔

315

                } else {

45✔

316

                    newTxn = this.bridgeInstance

21✔

317

                        .populateTransaction

21✔

318

                        .redeem(

21✔

319

                            args.addressTo,

21✔

320

                            ...redeemArgs

21✔

321

);

21✔

322

21✔

323

            } else {

531✔

324

                newTxn = this.chainId === ChainId.ETH

453✔

325

                    ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

453✔

326

                    : this.buildL2BridgeTxn(args, tokenArgs);

453✔

327

453✔

328

531✔

329

            return newTxn

531✔

330

                .then(txn =>

531✔

331

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

468✔

332

531✔

333

531✔

334

21✔

335

/**

21✔

336

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

21✔

337

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

21✔

338

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

21✔

339

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

21✔

340

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

21✔

341

         * @return {Promise<ContractTransaction>}

21✔

342

*/

21✔

343

        async executeBridgeTokenTransaction(

21✔

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 */

3✔

352

                return rejectPromise(e);

3✔

353

3✔

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, error, amount}) => {

15✔

381

                    if (!canBridge) {

15✔

382

                        return rejectPromise(new CanBridgeError(error, amount))

15✔

383

15✔

388

})

15✔

389

15✔

390

21✔

391

/**

21✔

392

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

21✔

393

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

21✔

394

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

21✔

395

         * framework so they can ultimately send the transaction.

21✔

396

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

21✔

397

         * @param {Object} args

21✔

398

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

21✔

399

         * to the bridge on the source chain.

21✔

400

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

21✔

401

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

21✔

402

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

21✔

403

         * of web3/ethers/etc.

21✔

404

*/

21✔

405

        async buildApproveTransaction(args: {

21✔

406

            token:   Token | string,

261✔

407

            amount?: BigNumberish

261✔

408

        }): Promise<PopulatedTransaction> {

261✔

409

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

261✔

410

261✔

411

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

261✔

412

261✔

413

21✔

414

/**

21✔

415

         * Builds and executes an ERC20 Approve call,

21✔

416

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

21✔

417

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

21✔

418

         * framework so they can ultimately send the transaction.

21✔

419

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

21✔

420

         * @param {Object} args

21✔

421

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

21✔

422

         * to the bridge on the source chain.

21✔

423

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

21✔

424

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

21✔

425

         * transaction.

21✔

426

*/

21✔

427

        async executeApproveTransaction(

21✔

428

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

3✔

429

            signer:     EthersSigner,

3✔

430

        ): Promise<ContractTransaction> {

3✔

431

            const

3✔

432

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

3✔

433

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

3✔

434

3✔

435

            return ERC20.approve(approveArgs, tokenParams, signer)

3✔

436

3✔

437

21✔

438

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

21✔

439

            const {token, signer, address} = args;

51✔

440

51✔

441

            let signerAddress: string;

51✔

443

                /* c8 ignore next */

3✔

444

                signerAddress = await signer.getAddress();

3✔

445

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

51✔

446

                signerAddress = address;

51✔

447

51✔

448

51✔

449

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

51✔

450

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

21✔

472

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

21✔

473

            let {chainIdTo, amountFrom} = args;

291✔

474

291✔

475

            let toChainZap: GenericZapBridgeContract;

291✔

476

291✔

477

            if (chainIdTo !== ChainId.TERRA) {

291✔

478

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

279✔

479

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

279✔

480

279✔

481

291✔

482

            const {

291✔

483

                tokenFrom, tokenTo,

291✔

484

                tokenIndexFrom, tokenIndexTo,

291✔

485

                fromChainTokens

291✔

486

            } = this.makeBridgeTokenArgs(args);

291✔

487

291✔

488

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

291✔

489

291✔

490

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

291✔

491

291✔

492

            const

291✔

493

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

291✔

494

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

291✔

495

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

291✔

496

291✔

497

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

291✔

498

                intermediateTokenAddr,

291✔

499

                chainIdTo,

291✔

500

                amtFrom

291✔

501

);

291✔

502

291✔

503

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

291✔

504

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

582✔

505

291✔

506

            const

291✔

507

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

291✔

508

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

291✔

509

291✔

510

            let amountToReceive_from_prom: Promise<BigNumber>;

291✔

511

            switch (true) {

291✔

512

                case amountFrom.eq(Zero):

291✔

513

                    amountToReceive_from_prom = Promise.resolve(Zero);

12✔

514

                    break;

12✔

515

                case ethToEth:

291✔

516

                case Tokens.isMintBurnToken(tokenFrom):

291✔

517

                case tokenFrom.isWrappedToken:

291✔

518

                    amountToReceive_from_prom = Promise.resolve(amountFrom);

195✔

519

                    break;

195✔

520

                case this.chainId === ChainId.ETH:

291✔

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:

291✔

526

                    amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

72✔

527

                        this.networkZapBridgeInstance,

72✔

528

                        intermediateToken.address(this.chainId),

72✔

529

                        tokenIndexFrom,

72✔

530

0,

72✔

531

                        amountFrom

72✔

532

);

72✔

533

291✔

534

291✔

535

            let amountToReceive_from = await amountToReceive_from_prom;

291✔

536

291✔

537

            let bridgeFee: BigNumber;

291✔

538

            /* c8 ignore start */

3✔

539

            try {

3✔

540

                bridgeFee = await bridgeFeeRequest;

3✔

541

                if (bridgeFee === null) {

3✔

542

                    console.error("calculateSwapFee returned null");

3✔

543

                    return rejectPromise("calculateSwapFee returned null")

3✔

544

3✔

545

            } catch (e) {

3✔

546

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

3✔

547

                return rejectPromise(e)

3✔

548

3✔

549

            /* c8 ignore stop */

3✔

550

291✔

551

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

291✔

552

291✔

553

            let amountToReceive_to_prom: Promise<BigNumber>;

291✔

554

            switch (true) {

291✔

555

                case amountToReceive_from.isZero():

291✔

556

                    amountToReceive_to_prom = Promise.resolve(Zero);

19✔

557

                    break;

19✔

558

                case ethFromEth:

291✔

559

                case Tokens.isMintBurnToken(tokenTo):

291✔

560

                case tokenTo.isWrappedToken:

291✔

561

                    amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

179✔

562

                    break;

179✔

563

                case chainIdTo === ChainId.ETH:

291✔

564

                    amountToReceive_to_prom = (toChainZap as L1BridgeZapContract)

9✔

565

                        .calculateRemoveLiquidityOneToken(amountToReceive_from, tokenIndexTo);

9✔

566

9✔

567

                    break;

9✔

568

                default:

291✔

569

                    amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

84✔

570

                        toChainZap,

84✔

571

                        intermediateToken.address(chainIdTo),

84✔

572

0,

84✔

573

                        tokenIndexTo,

84✔

574

                        amountToReceive_from

84✔

575

);

84✔

576

291✔

577

291✔

578

            let amountToReceive: BigNumber;

291✔

579

            /* c8 ignore next 6 */

3✔

580

            try {

3✔

581

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

3✔

582

            } catch (err) {

3✔

583

                return rejectPromise(err)

3✔

584

3✔

585

3✔

586

            return {

291✔

587

                amountToReceive,

291✔

589

291✔

590

291✔

591

21✔

592

        private buildETHMainnetBridgeTxn(

21✔

593

            args:      BridgeTransactionParams,

114✔

594

            tokenArgs: BridgeTokenArgs

114✔

595

        ): Promise<PopulatedTransaction> {

114✔

596

            const

114✔

597

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

114✔

598

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

114✔

599

                    chainId: this.chainId,

114✔

600

                    signerOrProvider: this.provider

114✔

601

});

114✔

602

114✔

603

let

114✔

604

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

114✔

605

                easyDeposits:   ID[] = [

114✔

606

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

114✔

607

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

114✔

608

],

114✔

609

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

114✔

610

114✔

611

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

114✔

612

            if (isEasy && txn) {

114✔

613

                return txn

48✔

614

48✔

615

114✔

616

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

114✔

617

                    args.tokenFrom.isEqual(t)

132✔

618

                        ? amountFrom

132✔

619

                        : Zero

132✔

620

);

114✔

621

114✔

622

            const {

114✔

623

                transactionDeadline,

114✔

624

                bridgeTransactionDeadline,

114✔

625

                minToSwapDestFromOrigin,

114✔

626

                minToSwapDest,

114✔

627

                minToSwapOriginMediumSlippage,

114✔

628

                minToSwapDestFromOriginMediumSlippage,

114✔

629

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

114✔

630

114✔

631

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

114✔

632

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

12✔

633

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

6✔

634

                        args as BridgeUtils.BridgeTxParams,

6✔

635

                        this.chainId,

6✔

636

                        args.tokenTo

6✔

637

);

6✔

638

6✔

639

                    return zapBridge

6✔

640

                        .populateTransaction

6✔

641

                        .deposit(...bridgeDepositArgs)

6✔

642

                } else {

6✔

643

                    return zapBridge.populateTransaction.zapAndDeposit(

6✔

644

                        addressTo,

6✔

645

                        chainIdTo,

6✔

646

                        Tokens.NUSD.address(this.chainId),

6✔

647

                        liquidityAmounts,

6✔

648

                        minToSwapDest,

6✔

649

                        transactionDeadline,

6✔

650

6✔

651

6✔

652

12✔

653

51✔

654

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

114✔

655

                return zapBridge.populateTransaction.depositETHAndSwap(

30✔

656

                    ...BridgeUtils.depositETHParams(castArgs),

30✔

657

                    0, // nusd tokenindex,

30✔

658

                    tokenArgs.tokenIndexTo,

30✔

659

                    minToSwapDestFromOrigin, // minDy

30✔

660

                    bridgeTransactionDeadline,

30✔

661

                    BridgeUtils.overrides(amountFrom)

30✔

662

30✔

663

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

60✔

664

                return zapBridge.populateTransaction.depositAndSwap(

9✔

665

                    addressTo,

9✔

666

                    chainIdTo,

9✔

667

                    Tokens.NUSD.address(this.chainId),

9✔

668

                    amountFrom,

9✔

669

0,

9✔

670

                    tokenArgs.tokenIndexTo,

9✔

671

                    minToSwapDestFromOriginMediumSlippage,

9✔

672

                    bridgeTransactionDeadline

9✔

673

9✔

674

9✔

675

108✔

676

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

108✔

677

                addressTo,

108✔

678

                chainIdTo,

108✔

679

                Tokens.NUSD.address(this.chainId),

108✔

680

                liquidityAmounts,

108✔

681

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

108✔

682

                transactionDeadline,

108✔

683

0,

108✔

684

                tokenArgs.tokenIndexTo,

108✔

685

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

108✔

686

                bridgeTransactionDeadline,

108✔

687

108✔

688

108✔

689

21✔

690

        private buildL2BridgeTxn(

21✔

691

            args: BridgeTransactionParams,

339✔

692

            tokenArgs: BridgeTokenArgs

339✔

693

        ): Promise<PopulatedTransaction> {

339✔

694

            const

339✔

695

                {chainIdTo, amountFrom, amountTo} = args,

339✔

696

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

339✔

697

                    chainId: this.chainId,

339✔

698

                    signerOrProvider: this.provider

339✔

699

});

339✔

700

339✔

701

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

339✔

703

                : tokenArgs.tokenFrom;

339✔

704

339✔

705

let

339✔

706

                easyDeposits:   ID[] = [],

339✔

707

                easyDepositETH: ID[] = [],

339✔

708

                easyRedeems:    ID[] = [

339✔

709

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

339✔

710

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

339✔

711

];

339✔

712

339✔

713

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

339✔

714

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

1,695✔

715

1,695✔

716

let

1,695✔

717

                    hasAltChain = typeof altChainId !== 'undefined',

1,695✔

718

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

1,695✔

719

1,695✔

720

                if (this.chainId === chainId) {

1,695✔

721

                    depositEth

180✔

722

                        ? easyDepositETH.push(...tokenHashes)

180✔

723

                        : easyDeposits.push(...tokenHashes);

180✔

724

                } else {

1,695✔

725

                    if (hasAltChain) {

1,515✔

726

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

567✔

727

                    } else {

1,515✔

728

                        easyRedeems.push(...tokenHashes);

948✔

729

948✔

730

1,515✔

731

})

339✔

732

339✔

733

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

339✔

734

            if (isEasy && txn) {

339✔

735

                return txn

111✔

736

111✔

737

339✔

738

            const {

339✔

739

                transactionDeadline,

339✔

740

                bridgeTransactionDeadline,

339✔

741

                minToSwapOriginHighSlippage,

339✔

742

                minToSwapDestFromOriginHighSlippage,

339✔

743

                minToSwapDest,

339✔

744

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

339✔

745

339✔

746

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

339✔

747

                zapBridge

15✔

748

                    .populateTransaction

15✔

749

                    .redeemAndSwap(

15✔

750

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

15✔

751

0,

15✔

752

                        tokenArgs.tokenIndexTo,

15✔

753

                        minToSwapDest,

15✔

754

                        transactionDeadline,

15✔

755

339✔

756

339✔

757

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

339✔

758

                let populateFn = swapETH

27✔

759

                    ? zapBridge.populateTransaction.swapETHAndRedeem

27✔

760

                    : zapBridge.populateTransaction.swapAndRedeem

27✔

761

27✔

762

                return populateFn(

27✔

763

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

27✔

764

                    tokenArgs.tokenIndexFrom,

27✔

765

0,

27✔

766

                    amountFrom,

27✔

767

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

27✔

768

                    transactionDeadline,

27✔

769

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

27✔

770

27✔

771

27✔

772

339✔

773

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

339✔

774

                let populateFn = swapETH

81✔

775

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

81✔

776

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

81✔

777

81✔

778

                return populateFn(

81✔

779

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

81✔

780

                    tokenArgs.tokenIndexFrom,

81✔

781

0,

81✔

782

                    amountFrom,

81✔

783

                    minToSwapOriginHighSlippage,

81✔

784

                    transactionDeadline,

81✔

785

0,

81✔

786

                    tokenArgs.tokenIndexTo,

81✔

787

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

81✔

788

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

81✔

789

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

81✔

790

81✔

791

81✔

792

339✔

793

            switch (tokenSwitch(args.tokenTo)) {

339✔

794

                case Tokens.NUSD:

339✔

795

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

42✔

796

                        return zapBridge

12✔

797

                            .populateTransaction

12✔

798

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

12✔

799

12✔

800

30✔

801

                    return zapBridge

30✔

802

                        .populateTransaction

30✔

803

                        .swapAndRedeem(

30✔

804

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

30✔

805

                            tokenArgs.tokenIndexFrom,

30✔

806

0,

30✔

807

                            amountFrom,

30✔

808

                            minToSwapOriginHighSlippage,

30✔

809

                            transactionDeadline

30✔

810

30✔

811

                case Tokens.GMX:

339✔

812

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

12✔

813

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

12✔

814

12✔

815

                    return this.chainId === ChainId.ARBITRUM

12✔

816

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

12✔

817

                        : this.bridgeInstance

12✔

818

                            .populateTransaction

6✔

819

                            .redeem(

6✔

820

                                addrTo,

6✔

821

                                chainTo,

6✔

822

                                Tokens.GMX.wrapperAddress(this.chainId),

6✔

823

                                amount

6✔

824

12✔

825

                default:

339✔

826

                    if (chainIdTo === ChainId.ETH) {

159✔

827

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

63✔

828

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

42✔

829

                                return zapBridge

15✔

830

                                    .populateTransaction

15✔

831

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

15✔

832

                            } else {

33✔

833

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

27✔

834

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

27✔

835

27✔

836

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

63✔

837

                            return zapBridge

12✔

838

                                .populateTransaction

12✔

839

                                .redeemAndRemove(

12✔

840

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

12✔

841

                                    amountFrom,

12✔

842

                                    tokenArgs.tokenIndexTo,

12✔

843

                                    minToSwapDest,

12✔

844

                                    transactionDeadline

12✔

845

12✔

846

12✔

847

9✔

848

                        return zapBridge

9✔

849

                            .populateTransaction

9✔

850

                            .swapAndRedeemAndRemove(

9✔

851

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

9✔

852

                                tokenArgs.tokenIndexFrom,

9✔

853

0,

9✔

854

                                amountFrom,

9✔

855

                                minToSwapOriginHighSlippage,

9✔

856

                                transactionDeadline,

9✔

857

                                tokenArgs.tokenIndexTo, //swapTokenIndex

9✔

858

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

9✔

859

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

9✔

860

9✔

861

9✔

862

96✔

863

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

159✔

864

                        return easyRedeemAndSwap(args.tokenFrom)

15✔

865

15✔

866

81✔

867

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

159✔

868

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

63✔

869

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

63✔

870

63✔

871

18✔

872

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

18✔

873

339✔

874

339✔

875

21✔

876

        private buildTerraBridgeTxn({

21✔

877

            addressTo,

12✔

878

            chainIdTo,

12✔

879

            amountFrom

12✔

880

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

12✔

881

            return Promise.resolve(new MsgExecuteContract(

12✔

882

                null,

12✔

883

                this.bridgeAddress,

12✔

884

12✔

885

                    deposit: {

12✔

886

                        to_address: toLower(addressTo),

12✔

887

                        chain_id:  `${chainIdTo}`,

12✔

888

                        denom:     "uusd"

12✔

889

12✔

890

},

12✔

891

                { uusd: amountFrom.toNumber() }

12✔

892

))

12✔

893

12✔

894

21✔

895

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

21✔

896

            let {tokenFrom, tokenTo, chainIdTo} = args;

822✔

897

822✔

898

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

822✔

899

822✔

900

            switch (tokenFrom.swapType) {

822✔

901

                case SwapType.ETH:

822✔

902

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

261✔

903

                    break;

261✔

904

                case SwapType.AVAX:

822✔

905

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

18✔

906

                    break;

18✔

907

                case SwapType.MOVR:

822✔

908

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

18✔

909

                    break;

18✔

910

                default:

822✔

911

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

525✔

912

822✔

913

822✔

914

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

822✔

915

822✔

916

            const

822✔

917

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

822✔

918

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

822✔

919

822✔

920

            return {

822✔

921

                fromChainTokens,

822✔

922

                toChainTokens,

822✔

923

                tokenFrom,

822✔

924

                tokenTo,

822✔

925

                tokenIndexFrom,

822✔

926

                tokenIndexTo

822✔

927

822✔

928

822✔

929

21✔

930

        private checkEasyArgs(

21✔

931

            args: BridgeTransactionParams,

453✔

932

            zapBridge: GenericZapBridgeContract,

453✔

933

            easyDeposits:    ID[],

453✔

934

            easyRedeems:     ID[],

453✔

935

            easyDepositETH?: ID[],

453✔

936

        ): EasyArgsCheck {

453✔

937

let

453✔

938

                castArgs = args as BridgeUtils.BridgeTxParams,

453✔

939

                isEasy: boolean = false,

453✔

940

                txn:    Promise<PopulatedTransaction>;

453✔

941

453✔

942

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

453✔

943

453✔

944

            switch (true) {

453✔

945

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

453✔

946

                    isEasy = true;

87✔

947

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

87✔

948

                    break;

87✔

949

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

453✔

950

                    isEasy = true;

45✔

951

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

45✔

952

                    break;

45✔

953

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

453✔

954

                    isEasy = true;

27✔

955

                    txn    =  zapBridge

27✔

956

                        .populateTransaction

27✔

957

                        .depositETH(

27✔

958

                            ...BridgeUtils.depositETHParams(castArgs),

27✔

959

                            BridgeUtils.overrides(args.amountFrom)

27✔

960

);

27✔

961

                    break;

27✔

962

453✔

963

453✔

964

            return {castArgs, isEasy, txn}

453✔

965

453✔

966

21✔

967

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

21✔

968

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

345✔

969

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

345✔

970

                if (!swapSupported) {

345✔

971

                    reject(errReason);

39✔

972

                    return

39✔

973

39✔

974

345✔

975

                resolve(true);

345✔

976

})

345✔

977

345✔

978

21✔

979

        private buildERC20ApproveArgs(args: {

21✔

980

            token:   Token | string,

285✔

981

            amount?: BigNumberish

285✔

982

        }): [ERC20.ApproveArgs, string] {

285✔

983

            const {token, amount} = args;

285✔

984

285✔

985

            let tokenAddr: string = instanceOfToken(token)

285✔

986

                ? token.address(this.chainId)

285✔

988

285✔

989

            let spender: string;

285✔

990

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

285✔

991

                spender = this.bridgeAddress;

33✔

992

            } else {

285✔

993

                spender = this.zapBridgeAddress;

252✔

994

252✔

995

285✔

996

            return [{

285✔

997

                spender,

285✔

998

                amount

285✔

999

            }, tokenAddr]

285✔

1000

285✔

1001

21✔

1002

        async getAllowanceForAddress(args: {

21✔

1003

            address: string,

15✔

1004

            token:   Token,

15✔

1005

        }): Promise<BigNumber> {

15✔

1006

            let { address, token } = args;

15✔

1007

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

15✔

1008

15✔

1009

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

15✔

1010

15✔

1011

21✔

1012

        private async resolveApproveFunc(

21✔

1013

            approveRes:    CheckCanBridgeResult,

21✔

1014

            hasBalanceRes: Promise<CanBridgeResult>,

21✔

1015

            token:         Token

21✔

1016

        ): Promise<CanBridgeResult> {

21✔

1017

            const [needsApprove, allowance] = approveRes;

21✔

1018

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

21✔

1019

21✔

1020

            return needsApprove

21✔

1022

                : hasBalanceRes

21✔

1023

21✔

1024

21✔

1025

        private async checkNeedsApprove({

21✔

1026

            address,

21✔

1027

            token,

21✔

1028

            amount=MAX_APPROVAL_AMOUNT.sub(1)

21✔

1029

        }: CheckCanBridgeParams): Promise<CheckCanBridgeResult> {

21✔

1030

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

21✔

1031

21✔

1032

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

21✔

1033

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

21✔

1034

21✔

1035

21✔

1036

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

21✔

1037

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

21✔

1038

21✔

1039

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

21✔

1041

                /* c8 ignore next */

3✔

1042

                balanceFn = signer.getBalance;

3✔

1043

            } else if (address) {

21✔

1044

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

21✔

1045

21✔

1046

21✔

1047

            return this.resolveBalanceFunc(

21✔

1048

                balanceFn(),

21✔

1049

                amount,

21✔

1050

                token

21✔

1051

21✔

1052

21✔

1053

21✔

1054

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

21✔

1055

            const

21✔

1056

                {address, amount, token} = args,

21✔

1057

                tokenAddress = token.address(this.chainId);

21✔

1058

21✔

1059

            return this.resolveBalanceFunc(

21✔

1060

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

21✔

1061

                amount,

21✔

1062

                token

21✔

1063

21✔

1064

21✔

1065

21✔

1066

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

21✔

1067

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

9✔

1068

                .then(([res]) => {

9✔

1069

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

9✔

1070

9✔

1071

                    let ustBalance: BigNumber = Zero;

9✔

1072

9✔

1073

                    if (coin) {

9✔

1074

                        const {amount} = coin.toData();

9✔

1075

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

9✔

1076

                            ustBalance = BigNumber.from(amount);

9✔

1077

9✔

1078

9✔

1079

9✔

1080

                    return ustBalance

9✔

1081

})

9✔

1082

9✔

1083

            return this.resolveBalanceFunc(

9✔

1084

                balProm,

9✔

1085

                amount,

9✔

1086

                token

9✔

1087

9✔

1088

9✔

1089

21✔

1090

        private async resolveBalanceFunc(

21✔

1091

            prom:   Promise<BigNumber>,

51✔

1092

            amount: BigNumberish,

51✔

1093

            token:  Token

51✔

1094

        ): Promise<CanBridgeResult> {

51✔

1095

            return Promise.resolve(prom)

51✔

1096

                .then(balance => {

51✔

1097

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

51✔

1098

51✔

1099

                    if (balance.gte(amount)) {

51✔

1100

                        return {canBridge: true}

6✔

1101

6✔

1102

51✔

1103

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

51✔

1104

})

51✔

1105

                .catch(rejectPromise)

51✔

1106

51✔

1107

21✔

1108

21✔

1109

    const REQUIRED_CONFS: NumberMap = {

21✔

1110

        [ChainId.ETH]:       7,

21✔

1111

        [ChainId.OPTIMISM]:  1,

21✔

1112

        [ChainId.CRONOS]:    6,

21✔

1113

        [ChainId.BSC]:       14,

21✔

1114

        [ChainId.POLYGON]:   128,

21✔

1115

        [ChainId.FANTOM]:    5,

21✔

1116

        [ChainId.BOBA]:      1,

21✔

1117

        [ChainId.METIS]:     6,

21✔

1118

        [ChainId.MOONBEAM]:  21,

21✔

1119

        [ChainId.MOONRIVER]: 21,

21✔

1120

        [ChainId.ARBITRUM]:  40,

21✔

1121

        [ChainId.AVALANCHE]: 5,

21✔

1122

        [ChainId.TERRA]:     1,

21✔

1123

        [ChainId.AURORA]:    5,

21✔

1124

        [ChainId.HARMONY]:   1,

21✔

1125

};

21✔

1126

21✔

1127

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

21✔

1129

1,386✔

1131

1,386✔

1132

21✔

1133

    /* c8 ignore next */

3✔

1134

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

3✔

1135

        return TokenSwap.bridgeSwapSupported(args)

558✔

1136

558✔

1137

21✔

synapsecns / sdk / 1995006113

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

synapsecns / sdk / 1995006113

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