synapsecns/sdk | Build 1960895919 | 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 {BaseToken, type Token, WrappedToken} from "@token";

2✔

34

2✔

35

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

2✔

36

2✔

37

import {GasUtils}    from "./gasutils";

2✔

38

2✔

39

import {

2✔

40

    BridgeUtils,

2✔

41

    CanBridgeError

2✔

42

} from "./bridgeutils";

2✔

43

2✔

44

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

2✔

45

2✔

46

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

2✔

47

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

2✔

48

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

2✔

49

2✔

50

import {

2✔

51

    Signer as EthersSigner

2✔

52

} from "@ethersproject/abstract-signer";

2✔

53

2✔

54

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

2✔

55

2✔

56

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

2✔

57

2✔

58

import {

2✔

59

    MsgExecuteContract,

2✔

60

    LCDClient,

2✔

61

    Wallet as TerraWallet,

2✔

62

    BlockTxBroadcastResult

2✔

63

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

2✔

64

2✔

65

import bech32 from "bech32";

2✔

66

2✔

67

2✔

68

/**

2✔

69

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

2✔

70

 * and most importantly, executing Bridge transactions.

2✔

71

*/

2✔

72

export namespace Bridge {

12✔

73

    const TEN = BigNumber.from(10);

12✔

74

12✔

75

    type CanBridgeResult = {

12✔

76

        canBridge: boolean;

12✔

77

        error?:    Error | string;

12✔

78

        amount?:   BigNumberish;

12✔

79

12✔

80

12✔

81

    export type CheckCanBridgeResult = [boolean, BigNumber];

12✔

82

12✔

83

    export type BridgeOutputEstimate = {

12✔

84

        amountToReceive: BigNumber,

12✔

85

        bridgeFee:       BigNumber,

12✔

86

12✔

87

12✔

88

/**

12✔

89

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

12✔

90

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

12✔

91

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

12✔

92

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

12✔

93

*/

12✔

94

    export interface BridgeParams {

12✔

95

        tokenFrom:   Token,

12✔

96

        tokenTo:     Token

12✔

97

        chainIdTo:   number,

12✔

98

        amountFrom?: BigNumber,

12✔

99

12✔

100

12✔

101

/**

12✔

102

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

12✔

103

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

12✔

104

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

12✔

105

     * on the destination chain.

12✔

106

*/

12✔

107

    export interface BridgeTransactionParams extends BridgeParams {

12✔

108

        amountFrom: BigNumber,

12✔

109

        amountTo:   BigNumber,

12✔

110

        addressTo?: string

12✔

111

12✔

112

12✔

113

    type EasyArgsCheck = {

12✔

114

        isEasy:   boolean,

12✔

115

        castArgs: BridgeUtils.BridgeTxParams,

12✔

116

        txn?:     Promise<PopulatedTransaction>,

12✔

117

12✔

118

12✔

119

    type BridgeTokenArgs = {

12✔

120

        fromChainTokens: Token[],

12✔

121

        toChainTokens:   Token[],

12✔

122

        tokenFrom:       Token,

12✔

123

        tokenTo:         Token,

12✔

124

        tokenIndexFrom:  number,

12✔

125

        tokenIndexTo:    number,

12✔

126

12✔

127

12✔

128

    type CanBridgeArgs = {

12✔

129

        address?: string;

12✔

130

        signer?:  EthersSigner;

12✔

131

        amount:   BigNumberish;

12✔

132

        token:    Token;

12✔

133

12✔

134

12✔

135

    type CheckCanBridgeParams = {

12✔

136

        address: string,

12✔

137

        token:   Token,

12✔

138

        amount:  BigNumberish,

12✔

139

12✔

140

12✔

141

/**

12✔

142

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

12✔

143

*/

12✔

144

    export class SynapseBridge {

12✔

145

        protected network: Networks.Network;

12✔

146

        protected chainId: number;

684✔

147

        protected _provider: Provider | LCDClient;

684✔

148

684✔

149

        private readonly bridgeAddress: string;

684✔

150

684✔

151

        private readonly bridgeInstance:           SynapseBridgeContract;

684✔

152

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

684✔

153

684✔

154

        private readonly isTerra:      boolean;

684✔

155

        private readonly isL2Zap:      boolean;

684✔

156

        private readonly isL2ETHChain: boolean;

684✔

157

684✔

158

        private readonly zapBridgeAddress: string;

684✔

159

684✔

160

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

684✔

161

684✔

162

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

684✔

163

            chainId: ChainId.ETH,

684✔

164

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

684✔

165

});

684✔

166

684✔

167

        readonly requiredConfirmations: number;

12✔

168

12✔

169

        constructor(args: {

12✔

170

            network: Networks.Network | number,

684✔

171

            provider?: Provider

684✔

172

        }) {

684✔

173

            let {network, provider} = args;

684✔

174

684✔

175

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

684✔

176

            this.chainId = this.network.chainId;

684✔

177

684✔

178

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

684✔

179

684✔

180

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

684✔

181

            this.isL2Zap = this.network.zapIsL2BridgeZap;

684✔

182

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

684✔

183

684✔

184

            this._provider = provider ?? (this.isTerra

684✔

185

                ? terraRpcProvider(this.chainId)

618✔

186

                : rpcProviderForChain(this.chainId)

618✔

187

);

684✔

188

684✔

189

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

684✔

190

684✔

191

            this.bridgeAddress    = contractAddrs.bridgeAddress;

684✔

192

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

684✔

193

684✔

194

            if (!this.isTerra) {

684✔

195

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

664✔

196

664✔

197

                this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

664✔

198

664✔

199

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

664✔

200

                    this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

664✔

201

664✔

202

664✔

203

684✔

204

12✔

205

        private get provider(): Provider {

12✔

206

            return this._provider as Provider

174✔

207

174✔

208

12✔

209

        private get terraProvider(): LCDClient {

12✔

210

            return this._provider as LCDClient

8✔

211

8✔

212

12✔

213

        bridgeVersion(): Promise<BigNumber> {

12✔

214

            if (this.isTerra) {

30✔

215

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

2✔

216

2✔

217

30✔

218

            return this.bridgeInstance.bridgeVersion()

30✔

219

30✔

220

12✔

221

        WETH_ADDRESS(): Promise<string> {

12✔

222

            if (this.isTerra) {

30✔

223

                return Promise.resolve("0x0000000000000000000000000000000000000000")

2✔

224

2✔

225

28✔

226

            return this.bridgeInstance.WETH_ADDRESS()

28✔

227

28✔

228

12✔

229

/**

12✔

230

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

12✔

231

         * is supported.

12✔

232

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

12✔

233

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

12✔

234

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

12✔

235

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

12✔

236

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

12✔

237

*/

12✔

238

        swapSupported(args: {

12✔

239

            tokenFrom: Token,

312✔

240

            tokenTo:   Token

312✔

241

            chainIdTo: number,

312✔

242

        }): [boolean, string] {

312✔

243

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

312✔

244

312✔

245

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

312✔

246

312✔

247

12✔

248

/**

12✔

249

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

12✔

250

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

12✔

251

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

12✔

252

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

12✔

253

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

12✔

254

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

12✔

255

*/

12✔

256

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

12✔

257

            return this.checkSwapSupported(args)

186✔

258

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

186✔

259

                .catch(rejectPromise)

186✔

260

186✔

261

12✔

262

/**

12✔

263

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

12✔

264

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

12✔

265

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

12✔

266

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

12✔

267

         * of web3/ethers/etc.

12✔

268

*/

12✔

269

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

12✔

270

            const

188✔

271

                {addressTo} = args,

188✔

272

                tokenArgs = this.makeBridgeTokenArgs(args),

188✔

273

                {tokenFrom, tokenTo} = tokenArgs;

188✔

274

188✔

275

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

188✔

276

                return rejectPromise(

4✔

277

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

4✔

278

4✔

279

4✔

280

188✔

281

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

188✔

282

                return rejectPromise(

2✔

283

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

2✔

284

2✔

285

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

188✔

286

                return rejectPromise(

2✔

287

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

2✔

288

2✔

289

2✔

290

178✔

291

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

178✔

292

178✔

293

            let newTxn: Promise<PopulatedTransaction>;

178✔

294

178✔

295

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

188✔

296

                if (this.isTerra) {

18✔

297

                    return this.buildTerraBridgeTxn(args)

8✔

298

8✔

299

10✔

300

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

10✔

301

                    args.chainIdTo,

10✔

302

                    Tokens.UST.address(this.chainId),

10✔

303

                    args.amountFrom

10✔

304

];

10✔

305

10✔

306

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

10✔

307

                    newTxn = this.bridgeInstance

4✔

308

                        .populateTransaction

4✔

309

                        .redeemV2(

4✔

310

                            bech32.decode(args.addressTo).words,

4✔

311

                            ...redeemArgs

4✔

312

);

4✔

313

                } else {

10✔

314

                    newTxn = this.bridgeInstance

6✔

315

                        .populateTransaction

6✔

316

                        .redeem(

6✔

317

                            args.addressTo,

6✔

318

                            ...redeemArgs

6✔

319

);

6✔

320

6✔

321

            } else {

188✔

322

                newTxn = this.chainId === ChainId.ETH

160✔

323

                    ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

160✔

324

                    : this.buildL2BridgeTxn(args, tokenArgs);

160✔

325

160✔

326

162✔

327

            return newTxn

162✔

328

                .then(txn =>

162✔

329

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

162✔

330

162✔

331

162✔

332

12✔

333

/**

12✔

334

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

12✔

335

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

12✔

336

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

12✔

337

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

12✔

338

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

12✔

339

         * @return {Promise<ContractTransaction>}

12✔

340

*/

12✔

341

        async executeBridgeTokenTransaction(

12✔

342

            args:       BridgeTransactionParams,

10✔

343

            signer:     EthersSigner | TerraWallet,

10✔

344

            callStatic: boolean=false

10✔

345

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

10✔

346

            try {

10✔

347

                await this.checkSwapSupported(args);

10✔

351

10✔

352

            const {tokenFrom, amountFrom, addressTo} = args;

10✔

353

10✔

354

            let txSigner: GenericSigner;

10✔

355

            let signerAddress: string;

10✔

356

10✔

357

            if (signer instanceof TerraWallet) {

10✔

358

                txSigner = new TerraSignerWrapper(signer);

4✔

359

            } else {

10✔

360

                txSigner = signer;

6✔

361

6✔

362

10✔

363

            signerAddress = await txSigner.getAddress();

10✔

365

10✔

366

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

10✔

367

10✔

368

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

10✔

375

10✔

376

            return this.checkCanBridge(checkArgs)

10✔

377

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

10✔

378

                    canBridge

10✔

380

                        : rejectPromise(new CanBridgeError(error, amount))

10✔

381

10✔

382

10✔

383

12✔

384

/**

12✔

385

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

12✔

386

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

12✔

387

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

12✔

388

         * framework so they can ultimately send the transaction.

12✔

389

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

12✔

390

         * @param {Object} args

12✔

391

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

12✔

392

         * to the bridge on the source chain.

12✔

393

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

12✔

394

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

12✔

395

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

12✔

396

         * of web3/ethers/etc.

12✔

397

*/

12✔

398

        async buildApproveTransaction(args: {

12✔

399

            token:   Token | string,

156✔

400

            amount?: BigNumberish

156✔

401

        }): Promise<PopulatedTransaction> {

156✔

402

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

156✔

403

156✔

404

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

156✔

405

156✔

406

12✔

407

/**

12✔

408

         * Builds and executes an ERC20 Approve call,

12✔

409

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

12✔

410

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

12✔

411

         * framework so they can ultimately send the transaction.

12✔

412

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

12✔

413

         * @param {Object} args

12✔

414

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

12✔

415

         * to the bridge on the source chain.

12✔

416

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

12✔

417

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

12✔

418

         * transaction.

12✔

419

*/

12✔

420

        async executeApproveTransaction(

12✔

421

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

6✔

422

            signer:     EthersSigner,

6✔

423

        ): Promise<ContractTransaction> {

6✔

424

            const

6✔

425

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

6✔

426

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

6✔

427

6✔

428

            return ERC20.approve(approveArgs, tokenParams, signer)

6✔

429

6✔

430

12✔

431

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

12✔

432

            const {token, signer, address} = args;

32✔

433

32✔

434

            let signerAddress: string;

32✔

437

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

32✔

438

                signerAddress = address;

32✔

439

32✔

440

32✔

441

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

32✔

442

32✔

443

            const

32✔

444

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

32✔

445

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

32✔

446

32✔

447

            if (isTerraTx) {

32✔

448

                return this.checkTerraUSTBalance(checkArgs);

8✔

449

8✔

450

24✔

451

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

24✔

452

                ? this.checkGasTokenBalance(checkArgs)

32✔

453

                : this.checkERC20Balance(checkArgs);

32✔

454

32✔

455

            return isGasTokenTransfer

32✔

456

                ? hasBalanceRes

32✔

457

                : this.checkNeedsApprove(checkArgs)

32✔

458

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

10✔

459

                    .catch(rejectPromise)

10✔

460

32✔

461

12✔

462

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

12✔

463

            let {chainIdTo, amountFrom} = args;

176✔

464

176✔

465

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

176✔

466

            let toChainZap: GenericZapBridgeContract;

176✔

467

176✔

468

            if (!isTerraChainId(chainIdTo)) {

176✔

469

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

170✔

470

170✔

471

176✔

472

            const {

176✔

473

                tokenFrom, tokenTo,

176✔

474

                tokenIndexFrom, tokenIndexTo,

176✔

475

                fromChainTokens

176✔

476

            } = this.makeBridgeTokenArgs(args);

176✔

477

176✔

478

176✔

479

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

176✔

480

176✔

481

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

176✔

482

176✔

483

            const

176✔

484

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

176✔

485

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

176✔

486

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

176✔

487

176✔

488

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

176✔

489

                intermediateTokenAddr,

176✔

490

                chainIdTo,

176✔

491

                amtFrom

176✔

492

);

176✔

493

176✔

494

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

176✔

495

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

352✔

496

176✔

497

            const

176✔

498

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

176✔

499

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

176✔

500

176✔

501

            let amountToReceive_from_prom: Promise<BigNumber>;

176✔

502

            switch (true) {

176✔

503

                case amountFrom.eq(Zero):

176✔

504

                    amountToReceive_from_prom = Promise.resolve(Zero);

8✔

505

                    break;

8✔

506

                case ethToEth:

176✔

507

                case Tokens.isMintBurnToken(tokenFrom):

176✔

508

                case tokenFrom.isWrappedToken:

176✔

509

                    amountToReceive_from_prom = Promise.resolve(amountFrom);

112✔

510

                    break;

112✔

511

                case this.chainId === ChainId.ETH:

176✔

512

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

8✔

513

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

8✔

514

8✔

515

                    break;

8✔

516

                default:

176✔

517

                    amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

48✔

518

                        this.networkZapBridgeInstance,

48✔

519

                        intermediateToken.address(this.chainId),

48✔

520

                        tokenIndexFrom,

48✔

521

0,

48✔

522

                        amountFrom

48✔

523

);

48✔

524

176✔

525

176✔

526

            let amountToReceive_from = await amountToReceive_from_prom;

176✔

527

176✔

528

            let bridgeFee: BigNumber;

176✔

529

            try {

176✔

530

                bridgeFee = await bridgeFeeRequest;

176✔

539

176✔

540

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

176✔

541

176✔

542

            let amountToReceive_to_prom: Promise<BigNumber>;

176✔

543

            switch (true) {

176✔

544

                case amountToReceive_from.isZero():

176✔

545

                    amountToReceive_to_prom = Promise.resolve(Zero);

12✔

546

                    break;

12✔

547

                case ethFromEth:

176✔

548

                case Tokens.isMintBurnToken(tokenTo):

176✔

549

                case tokenTo.isWrappedToken:

176✔

550

                    amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

102✔

551

                    break;

102✔

552

                case chainIdTo === ChainId.ETH:

176✔

553

                    amountToReceive_to_prom = (toChainZap as L1BridgeZapContract)

6✔

554

                        .calculateRemoveLiquidityOneToken(amountToReceive_from, tokenIndexTo);

6✔

555

6✔

556

                    break;

6✔

557

                default:

176✔

558

                    amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

56✔

559

                        toChainZap,

56✔

560

                        intermediateToken.address(chainIdTo),

56✔

561

0,

56✔

562

                        tokenIndexTo,

56✔

563

                        amountToReceive_from

56✔

564

);

56✔

565

176✔

566

176✔

567

            let amountToReceive: BigNumber;

176✔

568

            try {

176✔

569

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

176✔

573

176✔

574

            return {

176✔

575

                amountToReceive,

176✔

577

176✔

578

176✔

579

12✔

580

        private buildETHMainnetBridgeTxn(

12✔

581

            args:      BridgeTransactionParams,

42✔

582

            tokenArgs: BridgeTokenArgs

42✔

583

        ): Promise<PopulatedTransaction> {

42✔

584

            const

42✔

585

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

42✔

586

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

42✔

587

                    chainId: this.chainId,

42✔

588

                    signerOrProvider: this.provider

42✔

589

});

42✔

590

42✔

591

let

42✔

592

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

42✔

593

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

42✔

594

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

42✔

595

42✔

596

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

42✔

597

            if (isEasy && txn) {

42✔

598

                return txn

12✔

599

12✔

600

42✔

601

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

42✔

602

                    args.tokenFrom.isEqual(t)

58✔

603

                        ? amountFrom

58✔

604

                        : Zero

58✔

605

);

42✔

606

42✔

607

            const {

42✔

608

                transactionDeadline,

42✔

609

                bridgeTransactionDeadline,

42✔

610

                minToSwapDestFromOrigin,

42✔

611

                minToSwapDest,

42✔

612

                minToSwapOriginMediumSlippage,

42✔

613

                minToSwapDestFromOriginMediumSlippage,

42✔

614

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

42✔

615

42✔

616

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

42✔

617

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

4✔

618

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

2✔

619

                        args as BridgeUtils.BridgeTxParams,

2✔

620

                        this.chainId,

2✔

621

                        args.tokenTo

2✔

622

);

2✔

623

2✔

624

                    return zapBridge

2✔

625

                        .populateTransaction

2✔

626

                        .deposit(...bridgeDepositArgs)

2✔

627

                } else {

2✔

628

                    return zapBridge.populateTransaction.zapAndDeposit(

2✔

629

                        addressTo,

2✔

630

                        chainIdTo,

2✔

631

                        Tokens.NUSD.address(this.chainId),

2✔

632

                        liquidityAmounts,

2✔

633

                        minToSwapDest,

2✔

634

                        transactionDeadline,

2✔

635

2✔

636

2✔

637

            } else {

42✔

638

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

24✔

639

                    return zapBridge.populateTransaction.depositETHAndSwap(

10✔

640

                        ...BridgeUtils.depositETHParams(castArgs),

10✔

641

                        0, // nusd tokenindex,

10✔

642

                        tokenArgs.tokenIndexTo,

10✔

643

                        minToSwapDestFromOrigin, // minDy

10✔

644

                        bridgeTransactionDeadline,

10✔

645

                        BridgeUtils.makeOverrides(amountFrom, true)

10✔

646

10✔

647

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

24✔

648

                    return zapBridge.populateTransaction.depositAndSwap(

4✔

649

                        addressTo,

4✔

650

                        chainIdTo,

4✔

651

                        Tokens.NUSD.address(this.chainId),

4✔

652

                        amountFrom,

4✔

653

0,

4✔

654

                        tokenArgs.tokenIndexTo,

4✔

655

                        minToSwapDestFromOriginMediumSlippage,

4✔

656

                        bridgeTransactionDeadline

4✔

657

4✔

658

                } else {

14✔

659

                    return zapBridge.populateTransaction.zapAndDepositAndSwap(

10✔

660

                        addressTo,

10✔

661

                        chainIdTo,

10✔

662

                        Tokens.NUSD.address(this.chainId),

10✔

663

                        liquidityAmounts,

10✔

664

                        minToSwapOriginMediumSlippage, // minToSwapOrigin,

10✔

665

                        transactionDeadline,

10✔

666

0,

10✔

667

                        tokenArgs.tokenIndexTo,

10✔

668

                        minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

10✔

669

                        bridgeTransactionDeadline,

10✔

670

10✔

671

10✔

672

24✔

673

42✔

674

12✔

675

        private buildL2BridgeTxn(

12✔

676

            args: BridgeTransactionParams,

118✔

677

            tokenArgs: BridgeTokenArgs

118✔

678

        ): Promise<PopulatedTransaction> {

118✔

679

            const

118✔

680

                {chainIdTo, amountFrom, amountTo} = args,

118✔

681

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

118✔

682

                    chainId: this.chainId,

118✔

683

                    signerOrProvider: this.provider

118✔

684

});

118✔

685

118✔

686

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

118✔

688

                : tokenArgs.tokenFrom;

118✔

689

118✔

690

let

118✔

691

                easyDeposits:   ID[] = [],

118✔

692

                easyDepositETH: ID[] = [],

118✔

693

                easyRedeems:    ID[] = [

118✔

694

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

118✔

695

                    Tokens.DOG.id, Tokens.FRAX.id

118✔

696

];

118✔

697

118✔

698

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

118✔

699

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

590✔

700

590✔

701

let

590✔

702

                    hasAltChain = typeof altChainId !== 'undefined',

590✔

703

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

590✔

704

590✔

705

                if (this.chainId === chainId) {

590✔

706

                    depositEth

58✔

707

                        ? easyDepositETH.push(...tokenHashes)

58✔

708

                        : easyDeposits.push(...tokenHashes);

58✔

709

                } else {

590✔

710

                    if (hasAltChain) {

532✔

711

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

202✔

712

                    } else {

532✔

713

                        easyRedeems.push(...tokenHashes);

330✔

714

330✔

715

532✔

716

})

118✔

717

118✔

718

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

118✔

719

            if (isEasy && txn) {

118✔

720

                return txn

26✔

721

26✔

722

92✔

723

            const {

92✔

724

                transactionDeadline,

92✔

725

                bridgeTransactionDeadline,

92✔

726

                minToSwapOriginHighSlippage,

92✔

727

                minToSwapDestFromOriginHighSlippage,

92✔

728

                minToSwapDest,

92✔

729

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

92✔

730

92✔

731

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

92✔

732

                zapBridge

6✔

733

                    .populateTransaction

6✔

734

                    .redeemAndSwap(

6✔

735

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

6✔

736

0,

6✔

737

                        tokenArgs.tokenIndexTo,

6✔

738

                        minToSwapDest,

6✔

739

                        transactionDeadline,

6✔

740

92✔

741

92✔

742

            const easySwapAndRedeemAndSwap = (baseToken: BaseToken): Promise<PopulatedTransaction> =>

92✔

743

                zapBridge

12✔

744

                    .populateTransaction

12✔

745

                    .swapAndRedeemAndSwap(

12✔

746

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

12✔

747

                        tokenArgs.tokenIndexFrom,

12✔

748

0,

12✔

749

                        amountFrom,

12✔

750

                        minToSwapOriginHighSlippage,

12✔

751

                        transactionDeadline,

12✔

752

0,

12✔

753

                        tokenArgs.tokenIndexTo,

12✔

754

                        minToSwapDestFromOriginHighSlippage, // swapMinAmount

12✔

755

                        bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

12✔

756

                        BridgeUtils.makeOverrides(amountFrom, false)

12✔

757

92✔

758

92✔

759

            switch (tokenSwitch(args.tokenTo)) {

92✔

760

                case Tokens.NUSD:

118✔

761

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

18✔

762

                        return zapBridge

4✔

763

                            .populateTransaction

4✔

764

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

4✔

765

                    } else {

18✔

766

                        return zapBridge

14✔

767

                            .populateTransaction

14✔

768

                            .swapAndRedeem(

14✔

769

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

14✔

770

                                tokenArgs.tokenIndexFrom,

14✔

771

0,

14✔

772

                                amountFrom,

14✔

773

                                minToSwapOriginHighSlippage,

14✔

774

                                transactionDeadline

14✔

775

14✔

776

14✔

777

                case Tokens.GMX:

118✔

778

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

4✔

779

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

4✔

780

4✔

781

                    return this.chainId === ChainId.ARBITRUM

4✔

782

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

4✔

783

                        : this.bridgeInstance

4✔

784

                            .populateTransaction

2✔

785

                            .redeem(

2✔

786

                                addrTo,

2✔

787

                                chainTo,

2✔

788

                                Tokens.GMX.wrapperAddress(this.chainId),

2✔

789

                                amount

2✔

790

4✔

791

                default:

118✔

792

                    if (chainIdTo === ChainId.ETH) {

64✔

793

                        if (this.isL2ETHChain) {

22✔

794

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

18✔

795

                                return zapBridge

6✔

796

                                    .populateTransaction

6✔

797

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

6✔

798

                            } else if (BridgeUtils.isETHLikeToken(args.tokenFrom)) {

18✔

799

                                return zapBridge

6✔

800

                                    .populateTransaction

6✔

801

                                    .swapAndRedeem(

6✔

802

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

6✔

803

                                        tokenArgs.tokenIndexFrom,

6✔

804

0,

6✔

805

                                        amountFrom,

6✔

806

                                        minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

6✔

807

                                        transactionDeadline

6✔

808

6✔

809

                            } else {

6✔

810

                                return zapBridge

6✔

811

                                    .populateTransaction

6✔

812

                                    .swapETHAndRedeem(

6✔

813

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

6✔

814

                                        tokenArgs.tokenIndexFrom,

6✔

815

0,

6✔

816

                                        amountFrom,

6✔

817

                                        minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

6✔

818

                                        transactionDeadline,

6✔

819

                                        BridgeUtils.makeOverrides(amountFrom, true)

6✔

820

6✔

821

6✔

822

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

22✔

823

                            return zapBridge

2✔

824

                                .populateTransaction

2✔

825

                                .redeemAndRemove(

2✔

826

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

2✔

827

                                    amountFrom,

2✔

828

                                    tokenArgs.tokenIndexTo,

2✔

829

                                    minToSwapDest,

2✔

830

                                    transactionDeadline

2✔

831

2✔

832

                        } else {

2✔

833

                            return zapBridge

2✔

834

                                .populateTransaction

2✔

835

                                .swapAndRedeemAndRemove(

2✔

836

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

2✔

837

                                    tokenArgs.tokenIndexFrom,

2✔

838

0,

2✔

839

                                    amountFrom,

2✔

840

                                    minToSwapOriginHighSlippage,

2✔

841

                                    transactionDeadline,

2✔

842

                                    tokenArgs.tokenIndexTo, //swapTokenIndex

2✔

843

                                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

2✔

844

                                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

2✔

845

2✔

846

2✔

847

                    } else {

64✔

848

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

42✔

849

                            return easyRedeemAndSwap(Tokens.NUSD)

4✔

850

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

42✔

851

                            return easyRedeemAndSwap(Tokens.NETH)

2✔

852

                        } else {

38✔

853

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

36✔

854

                                return BridgeUtils.isETHLikeToken(args.tokenFrom)

24✔

855

                                    ? zapBridge

24✔

856

                                        .populateTransaction

16✔

857

                                        .swapAndRedeemAndSwap(

16✔

858

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

16✔

859

                                            tokenArgs.tokenIndexFrom,

16✔

860

0,

16✔

861

                                            args.amountFrom,

16✔

862

                                            minToSwapOriginHighSlippage,

16✔

863

                                            transactionDeadline,

16✔

864

0,

16✔

865

                                            tokenArgs.tokenIndexTo,

16✔

866

                                            minToSwapDestFromOriginHighSlippage,

16✔

867

                                            bridgeTransactionDeadline

16✔

868

24✔

869

                                    : zapBridge

24✔

870

                                        .populateTransaction

8✔

871

                                        .swapETHAndRedeemAndSwap(

8✔

872

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

8✔

873

                                            tokenArgs.tokenIndexFrom,

8✔

874

0,

8✔

875

                                            amountFrom,

8✔

876

                                            minToSwapOriginHighSlippage,

8✔

877

                                            transactionDeadline,

8✔

878

0,

8✔

879

                                            tokenArgs.tokenIndexTo,

8✔

880

                                            minToSwapDestFromOriginHighSlippage,

8✔

881

                                            bridgeTransactionDeadline,

8✔

882

                                            BridgeUtils.makeOverrides(amountFrom, true)

8✔

883

24✔

884

                            } else {

36✔

885

                                return easySwapAndRedeemAndSwap(Tokens.NUSD)

12✔

886

12✔

887

36✔

888

42✔

889

118✔

890

118✔

891

12✔

892

        private buildTerraBridgeTxn({

12✔

893

            addressTo,

8✔

894

            chainIdTo,

8✔

895

            amountFrom

8✔

896

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

8✔

897

            return Promise.resolve(new MsgExecuteContract(

8✔

898

                null,

8✔

899

                this.bridgeAddress,

8✔

900

8✔

901

                    deposit: {

8✔

902

                        to_address: toLower(addressTo),

8✔

903

                        chain_id:  `${chainIdTo}`,

8✔

904

                        denom:     "uusd"

8✔

905

8✔

906

},

8✔

907

                { uusd: amountFrom.toNumber() }

8✔

908

))

8✔

909

8✔

910

12✔

911

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

12✔

912

            let {tokenFrom, tokenTo, chainIdTo} = args;

364✔

913

364✔

914

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

364✔

915

364✔

916

            switch (tokenFrom.swapType) {

364✔

917

                case SwapType.ETH:

364✔

918

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

132✔

919

                    break;

132✔

920

                case SwapType.AVAX:

364✔

921

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

8✔

922

                    break;

8✔

923

                case SwapType.MOVR:

364✔

924

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

8✔

925

                    break;

8✔

926

                default:

364✔

927

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

216✔

928

364✔

929

364✔

930

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

364✔

931

364✔

932

            const

364✔

933

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

364✔

934

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

364✔

935

364✔

936

            return {

364✔

937

                fromChainTokens,

364✔

938

                toChainTokens,

364✔

939

                tokenFrom,

364✔

940

                tokenTo,

364✔

941

                tokenIndexFrom,

364✔

942

                tokenIndexTo

364✔

943

364✔

944

364✔

945

12✔

946

        private checkEasyArgs(

12✔

947

            args: BridgeTransactionParams,

160✔

948

            zapBridge: GenericZapBridgeContract,

160✔

949

            easyDeposits:    ID[],

160✔

950

            easyRedeems:     ID[],

160✔

951

            easyDepositETH?: ID[],

160✔

952

        ): EasyArgsCheck {

160✔

953

let

160✔

954

                castArgs = args as BridgeUtils.BridgeTxParams,

160✔

955

                isEasy: boolean = false,

160✔

956

                txn:    Promise<PopulatedTransaction>;

160✔

957

160✔

958

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

160✔

959

160✔

960

            switch (true) {

160✔

961

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

160✔

962

                    isEasy = true;

18✔

963

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

18✔

964

                    break;

18✔

965

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

160✔

966

                    isEasy = true;

8✔

967

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

8✔

968

                    break;

8✔

969

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

160✔

970

                    isEasy = true;

12✔

971

                    txn    =  zapBridge

12✔

972

                        .populateTransaction

12✔

973

                        .depositETH(

12✔

974

                            ...BridgeUtils.depositETHParams(castArgs),

12✔

975

                            BridgeUtils.makeOverrides(args.amountFrom, true)

12✔

976

);

12✔

977

                    break;

12✔

978

160✔

979

160✔

980

            return {castArgs, isEasy, txn}

160✔

981

160✔

982

12✔

983

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

12✔

984

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

196✔

985

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

196✔

986

                if (!swapSupported) {

196✔

987

                    reject(errReason);

10✔

988

                    return

10✔

989

10✔

990

186✔

991

                resolve(true);

186✔

992

})

196✔

993

196✔

994

12✔

995

        private buildERC20ApproveArgs(args: {

12✔

996

            token:   Token | string,

182✔

997

            amount?: BigNumberish

182✔

998

        }): [ERC20.ApproveArgs, string] {

182✔

999

            const {token, amount} = args;

182✔

1000

182✔

1002

                ? token.address(this.chainId)

182✔

1004

182✔

1005

            let spender: string;

182✔

1006

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

182✔

1007

                spender = this.bridgeAddress;

18✔

1008

            } else {

182✔

1009

                spender = this.zapBridgeAddress;

164✔

1010

164✔

1011

182✔

1012

            return [{

182✔

1013

                spender,

182✔

1014

                amount

182✔

1015

            }, tokenAddr]

182✔

1016

182✔

1017

12✔

1018

        async getAllowanceForAddress(args: {

12✔

1019

            address: string,

10✔

1020

            token:   Token,

10✔

1021

        }): Promise<BigNumber> {

10✔

1022

            let { address, token } = args;

10✔

1023

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

10✔

1024

10✔

1025

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

10✔

1026

10✔

1027

12✔

1028

        private static async resolveApproveFunc(

12✔

1029

            approveRes:    CheckCanBridgeResult,

10✔

1030

            hasBalanceRes: Promise<CanBridgeResult>,

10✔

1031

            token:         Token

10✔

1032

        ): Promise<CanBridgeResult> {

10✔

1033

            const [needsApprove, allowance] = approveRes;

10✔

1034

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

10✔

1035

10✔

1036

            return needsApprove

10✔

1038

                : hasBalanceRes

10✔

1039

10✔

1040

12✔

1041

        private async checkNeedsApprove({

12✔

1042

            address,

10✔

1043

            token,

10✔

1044

            amount=MAX_APPROVAL_AMOUNT.sub(1)

10✔

1045

        }: CheckCanBridgeParams): Promise<CheckCanBridgeResult> {

10✔

1046

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

10✔

1047

10✔

1048

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

10✔

1049

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

10✔

1050

10✔

1051

12✔

1052

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

12✔

1053

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

14✔

1054

14✔

1055

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

14✔

1058

            } else if (address) {

14✔

1059

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

14✔

1060

14✔

1061

14✔

1062

            return this.resolveBalanceFunc(

14✔

1063

                balanceFn(),

14✔

1064

                amount,

14✔

1065

                token

14✔

1066

14✔

1067

14✔

1068

12✔

1069

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

12✔

1070

            const

10✔

1071

                {address, amount, token} = args,

10✔

1072

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

10✔

1073

10✔

1074

            return this.resolveBalanceFunc(

10✔

1075

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

10✔

1076

                amount,

10✔

1077

                token

10✔

1078

10✔

1079

10✔

1080

12✔

1081

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

12✔

1082

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

8✔

1083

                .then(([res]) => {

8✔

1084

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

8✔

1085

                    if (coin) {

8✔

1086

                        const {amount} = coin.toData();

8✔

1087

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

8✔

1088

                            return BigNumber.from(amount);

8✔

1089

8✔

1090

8✔

1091

                        return Zero

8✔

1092

8✔

1093

8✔

1094

                    return Zero

8✔

1095

})

8✔

1096

8✔

1097

            return this.resolveBalanceFunc(

8✔

1098

                balProm,

8✔

1099

                amount,

8✔

1100

                token

8✔

1101

8✔

1102

8✔

1103

12✔

1104

        private async resolveBalanceFunc(

12✔

1105

            prom:   Promise<BigNumber>,

32✔

1106

            amount: BigNumberish,

32✔

1107

            token:  Token

32✔

1108

        ): Promise<CanBridgeResult> {

32✔

1109

            return Promise.resolve(prom)

32✔

1110

                .then(balance => {

32✔

1111

                    const hasBalance = balance.gte(amount);

32✔

1112

32✔

1113

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

32✔

1114

32✔

1115

                    return hasBalance

32✔

1116

                        ? {canBridge: true}

32✔

1117

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

32✔

1118

})

32✔

1119

                .catch(rejectPromise)

32✔

1120

32✔

1121

12✔

1122

12✔

1123

    const REQUIRED_CONFS: NumberMap = {

12✔

1124

        [ChainId.ETH]:       7,

12✔

1125

        [ChainId.OPTIMISM]:  1,

12✔

1126

        [ChainId.CRONOS]:    6,

12✔

1127

        [ChainId.BSC]:       14,

12✔

1128

        [ChainId.POLYGON]:   128,

12✔

1129

        [ChainId.FANTOM]:    5,

12✔

1130

        [ChainId.BOBA]:      1,

12✔

1131

        [ChainId.METIS]:     6,

12✔

1132

        [ChainId.MOONBEAM]:  21,

12✔

1133

        [ChainId.MOONRIVER]: 21,

12✔

1134

        [ChainId.ARBITRUM]:  40,

12✔

1135

        [ChainId.AVALANCHE]: 5,

12✔

1136

        [ChainId.TERRA]:     1,

12✔

1137

        [ChainId.AURORA]:    5,

12✔

1138

        [ChainId.HARMONY]:   1,

12✔

1139

};

12✔

1140

12✔

1141

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

12✔

1143

684✔

1145

684✔

1146

12✔

1147

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

12✔

1150

12✔

synapsecns / sdk / 1960895919

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

synapsecns / sdk / 1960895919

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