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

1

import {toLower} from "lodash-es";

2✔

2

2✔

3

import {ChainId}  from "@chainid";

2✔

4

import {Networks} from "@networks";

2✔

5

2✔

6

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

2✔

7

2✔

8

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

2✔

9

2✔

10

import * as SynapseEntities from "@entities";

2✔

11

2✔

12

import {

2✔

13

    type ID,

2✔

14

    SwapType,

2✔

15

    rpcProviderForChain,

2✔

16

    terraRpcProvider,

2✔

17

    tokenSwitch,

2✔

18

    TerraSignerWrapper,

2✔

19

    validateTerraAddress

2✔

20

} from "@internal/index";

2✔

21

2✔

22

import type {

2✔

23

    BridgeConfigV3Contract,

2✔

24

    GenericZapBridgeContract,

2✔

25

    L1BridgeZapContract,

2✔

26

    SynapseBridgeContract

2✔

27

} from "@contracts";

2✔

28

2✔

29

import {Tokens}    from "@tokens";

2✔

30

import {TokenSwap} from "@tokenswap";

2✔

31

2✔

32

import {

2✔

33

    type Token,

2✔

34

    instanceOfToken

2✔

35

} from "@token";

2✔

36

2✔

37

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

2✔

38

2✔

39

import {GasUtils}                   from "./gasutils";

2✔

40

2✔

41

import {

2✔

42

    BridgeUtils,

2✔

43

    CanBridgeError

2✔

44

} from "./bridgeutils";

2✔

45

2✔

46

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

2✔

47

2✔

48

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

2✔

49

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

2✔

50

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

2✔

51

2✔

52

import {

2✔

53

    Signer as EthersSigner

2✔

54

} from "@ethersproject/abstract-signer";

2✔

55

2✔

56

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

2✔

57

2✔

58

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

2✔

59

2✔

60

import {

2✔

61

    MsgExecuteContract,

2✔

62

    LCDClient,

2✔

63

    Wallet as TerraWallet,

2✔

64

    BlockTxBroadcastResult

2✔

65

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

2✔

66

2✔

67

import bech32 from "bech32";

2✔

68

2✔

69

const TEN = BigNumber.from(10);

2✔

70

2✔

71

/**

2✔

72

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

2✔

73

 * and most importantly, executing Bridge transactions.

2✔

74

*/

2✔

75

export namespace Bridge {

12✔

76

    export type CanBridgeResult = {

12✔

77

        canBridge:     boolean;

12✔

78

        reasonUnable?: string;

12✔

79

        amount?:       BigNumber;

12✔

80

12✔

81

12✔

82

    type NeedsTokenApproveResult = {

12✔

83

        needsApproval:     boolean;

12✔

84

        currentAllowance?: BigNumber;

12✔

85

12✔

86

12✔

87

    export type BridgeOutputEstimate = {

12✔

88

        amountToReceive: BigNumber,

12✔

89

        bridgeFee:       BigNumber,

12✔

90

12✔

91

12✔

92

/**

12✔

93

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

12✔

94

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

12✔

95

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

12✔

96

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

12✔

97

*/

12✔

98

    export interface BridgeParams {

12✔

99

        tokenFrom:   Token,

12✔

100

        tokenTo:     Token

12✔

101

        chainIdTo:   number,

12✔

102

        amountFrom?: BigNumber,

12✔

103

12✔

104

12✔

105

/**

12✔

106

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

12✔

107

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

12✔

108

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

12✔

109

     * on the destination chain.

12✔

110

*/

12✔

111

    export interface BridgeTransactionParams extends BridgeParams {

12✔

112

        amountFrom: BigNumber;

12✔

113

        amountTo:   BigNumber;

12✔

114

        addressTo?: string;

12✔

115

12✔

116

12✔

117

    type EasyArgsCheck = {

12✔

118

        isEasy:   boolean;

12✔

119

        castArgs: BridgeUtils.BridgeTxParams;

12✔

120

        txn?:     Promise<PopulatedTransaction>;

12✔

121

12✔

122

12✔

123

    type BridgeTokenArgs = {

12✔

124

        fromChainTokens: Token[];

12✔

125

        toChainTokens:   Token[];

12✔

126

        tokenFrom:       Token;

12✔

127

        tokenTo:         Token;

12✔

128

        tokenIndexFrom:  number;

12✔

129

        tokenIndexTo:    number;

12✔

130

12✔

131

12✔

132

    interface CheckCanBridgeParams {

12✔

133

        address?: string;

12✔

134

        signer?:  EthersSigner;

12✔

135

        token:    Token;

12✔

136

        amount:   BigNumberish;

12✔

137

12✔

138

12✔

139

    interface CanBridgeParams extends CheckCanBridgeParams {

12✔

140

        address: string;

12✔

141

12✔

142

12✔

143

/**

12✔

144

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

12✔

145

*/

12✔

146

    export class SynapseBridge {

12✔

147

        protected network: Networks.Network;

12✔

148

        protected chainId: number;

1,021✔

149

        protected _provider: Provider | LCDClient;

1,021✔

150

1,021✔

151

        private readonly bridgeAddress: string;

1,021✔

152

1,021✔

153

        private readonly bridgeInstance:           SynapseBridgeContract;

1,021✔

154

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

1,021✔

155

1,021✔

156

        private readonly isTerra:      boolean;

1,021✔

157

        private readonly isL2Zap:      boolean;

1,021✔

158

        private readonly isL2ETHChain: boolean;

1,021✔

159

1,021✔

160

        private readonly zapBridgeAddress: string;

1,021✔

161

1,021✔

162

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

1,021✔

163

1,021✔

164

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

1,021✔

165

            chainId: ChainId.ETH,

1,021✔

166

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

1,021✔

167

});

1,021✔

168

1,021✔

169

        readonly requiredConfirmations: number;

12✔

170

12✔

171

        constructor(args: {

12✔

172

            network: Networks.Network | number,

1,021✔

173

            provider?: Provider

1,021✔

174

        }) {

1,021✔

175

            let {network, provider} = args;

1,021✔

176

1,021✔

177

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

1,021✔

178

            this.chainId = this.network.chainId;

1,021✔

179

1,021✔

180

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

1,021✔

181

1,021✔

182

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

1,021✔

183

            this.isL2Zap = this.network.zapIsL2BridgeZap;

1,021✔

184

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

1,021✔

185

1,021✔

186

            this._provider = provider ?? (this.isTerra

1,021✔

187

                ? terraRpcProvider(this.chainId)

988✔

188

                : rpcProviderForChain(this.chainId)

988✔

189

);

1,021✔

190

1,021✔

191

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

1,021✔

192

1,021✔

193

            this.bridgeAddress    = contractAddrs.bridgeAddress;

1,021✔

194

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

1,021✔

195

1,021✔

196

            if (!this.isTerra) {

1,021✔

197

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

1,008✔

198

1,008✔

199

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

1,008✔

200

1,008✔

201

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

1,008✔

202

                this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

1,008✔

203

1,008✔

204

1,008✔

205

1,021✔

206

12✔

207

        private get provider(): Provider {

12✔

208

            return this._provider as Provider

356✔

209

356✔

210

12✔

211

        private get terraProvider(): LCDClient {

12✔

212

            return this._provider as LCDClient

3✔

213

3✔

214

12✔

215

        bridgeVersion(): Promise<BigNumber> {

12✔

216

            if (this.isTerra) {

15✔

217

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

1✔

218

1✔

219

15✔

220

            return this.bridgeInstance.bridgeVersion()

15✔

221

15✔

222

12✔

223

        WETH_ADDRESS(): Promise<string> {

12✔

224

            if (this.isTerra) {

15✔

225

                return Promise.resolve("0x0000000000000000000000000000000000000000")

1✔

226

1✔

227

14✔

228

            return this.bridgeInstance.WETH_ADDRESS()

14✔

229

14✔

230

12✔

231

/**

12✔

232

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

12✔

233

         * is supported.

12✔

234

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

12✔

235

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

12✔

236

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

12✔

237

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

12✔

238

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

12✔

239

*/

12✔

240

        swapSupported(args: {

12✔

241

            tokenFrom: Token,

405✔

242

            tokenTo:   Token

405✔

243

            chainIdTo: number,

405✔

244

        }): [boolean, string] {

405✔

245

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

405✔

246

405✔

247

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

405✔

248

405✔

249

12✔

250

/**

12✔

251

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

12✔

252

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

12✔

253

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

12✔

254

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

12✔

255

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

12✔

256

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

12✔

257

*/

12✔

258

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

12✔

259

            return this.checkSwapSupported(args)

248✔

260

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

248✔

261

                .catch(rejectPromise)

248✔

262

248✔

263

12✔

264

/**

12✔

265

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

12✔

266

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

12✔

267

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

12✔

268

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

12✔

269

         * of web3/ethers/etc.

12✔

270

*/

12✔

271

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

12✔

272

            const

399✔

273

                {addressTo} = args,

399✔

274

                tokenArgs = this.makeBridgeTokenArgs(args),

399✔

275

                {tokenFrom, tokenTo} = tokenArgs;

399✔

276

399✔

277

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

399✔

278

                return rejectPromise(

4✔

279

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

4✔

280

4✔

281

4✔

282

399✔

284

                return rejectPromise(

1✔

285

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

1✔

286

1✔

288

                return rejectPromise(

1✔

289

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

1✔

290

1✔

291

1✔

292

373✔

293

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

373✔

294

373✔

295

            let newTxn: Promise<PopulatedTransaction>;

373✔

296

373✔

297

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

399✔

298

                if (this.isTerra) {

24✔

299

                    return this.buildTerraBridgeTxn(args)

5✔

300

5✔

301

19✔

302

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

19✔

303

                    args.chainIdTo,

19✔

304

                    Tokens.UST.address(this.chainId),

19✔

305

                    args.amountFrom

19✔

306

];

19✔

307

19✔

308

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

24✔

309

                    newTxn = this.bridgeInstance

6✔

310

                        .populateTransaction

6✔

311

                        .redeemV2(

6✔

312

                            bech32.decode(args.addressTo).words,

6✔

313

                            ...redeemArgs

6✔

314

);

6✔

315

                } else {

24✔

316

                    newTxn = this.bridgeInstance

13✔

317

                        .populateTransaction

13✔

318

                        .redeem(

13✔

319

                            args.addressTo,

13✔

320

                            ...redeemArgs

13✔

321

);

13✔

322

13✔

323

            } else {

399✔

324

                newTxn = this.chainId === ChainId.ETH

349✔

325

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

349✔

326

                : this.buildL2BridgeTxn(args, tokenArgs);

349✔

327

349✔

328

356✔

329

            return newTxn

356✔

330

                .then(txn =>

356✔

331

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

356✔

332

356✔

333

356✔

334

12✔

335

/**

12✔

336

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

12✔

337

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

12✔

338

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

12✔

339

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

12✔

340

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

12✔

341

         * @return {Promise<ContractTransaction>}

12✔

342

*/

12✔

343

        async executeBridgeTokenTransaction(

12✔

344

            args:       BridgeTransactionParams,

5✔

345

            signer:     EthersSigner | TerraWallet | GenericSigner,

5✔

346

            callStatic: boolean=false

5✔

347

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

5✔

348

            try {

5✔

349

                await this.checkSwapSupported(args);

5✔

351

                /* c8 ignore next 2 */

2✔

352

                return rejectPromise(e);

2✔

353

2✔

354

5✔

355

            const {tokenFrom, amountFrom, addressTo} = args;

5✔

356

5✔

357

            let txSigner: GenericSigner;

5✔

358

            let signerAddress: string;

5✔

359

5✔

360

            if (signer instanceof TerraWallet) {

5✔

361

                txSigner = new TerraSignerWrapper(signer);

1✔

362

            } else {

5✔

363

                txSigner = signer;

4✔

364

4✔

365

5✔

366

            signerAddress = await txSigner.getAddress();

5✔

368

5✔

369

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

5✔

370

5✔

371

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

5✔

378

5✔

379

            return this.checkCanBridge(checkArgs)

5✔

380

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

5✔

381

                    if (!canBridge) {

5✔

382

                        const rejection = new CanBridgeError(reasonUnable, amount);

5✔

383

                        return rejectPromise(rejection)

5✔

384

5✔

385

5✔

386

                    return this.buildBridgeTokenTransaction(args)

5✔

387

                        .then(sendTxn)

5✔

388

                        .catch(rejectPromise)

5✔

389

})

5✔

390

5✔

391

12✔

392

/**

12✔

393

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

12✔

394

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

12✔

395

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

12✔

396

         * framework so they can ultimately send the transaction.

12✔

397

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

12✔

398

         * @param {Object} args

12✔

399

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

12✔

400

         * to the bridge on the source chain.

12✔

401

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

12✔

402

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

12✔

403

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

12✔

404

         * of web3/ethers/etc.

12✔

405

*/

12✔

406

        async buildApproveTransaction(args: {

12✔

407

            token:   Token | string,

205✔

408

            amount?: BigNumberish

205✔

409

        }): Promise<PopulatedTransaction> {

205✔

410

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

205✔

411

205✔

412

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

205✔

413

205✔

414

12✔

415

/**

12✔

416

         * Builds and executes an ERC20 Approve call,

12✔

417

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

12✔

418

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

12✔

419

         * framework so they can ultimately send the transaction.

12✔

420

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

12✔

421

         * @param {Object} args

12✔

422

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

12✔

423

         * to the bridge on the source chain.

12✔

424

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

12✔

425

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

12✔

426

         * transaction.

12✔

427

*/

12✔

428

        async executeApproveTransaction(

12✔

429

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

1✔

430

            signer:     EthersSigner,

1✔

431

        ): Promise<ContractTransaction> {

1✔

432

            const

1✔

433

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

1✔

434

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

1✔

435

1✔

436

            return ERC20.approve(approveArgs, tokenParams, signer)

1✔

437

1✔

438

12✔

439

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

12✔

440

            const {token, signer, address} = args;

17✔

441

17✔

442

            let signerAddress: string;

17✔

444

                /* c8 ignore next */

2✔

445

                signerAddress = await signer.getAddress();

2✔

446

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

17✔

447

                signerAddress = address;

17✔

448

17✔

449

17✔

450

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

17✔

451

            const

17✔

452

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

17✔

453

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

17✔

454

17✔

455

            if (isTerraTx) {

17✔

456

                return this.checkTerraUSTBalance(checkArgs);

3✔

457

3✔

458

17✔

459

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

17✔

460

                ? this.checkGasTokenBalance(checkArgs)

17✔

461

                : this.checkERC20Balance(checkArgs);

17✔

462

17✔

463

            if (isGasTokenTransfer) {

17✔

464

                return hasBalanceRes

7✔

465

7✔

466

7✔

467

            return this.checkNeedsApprove(checkArgs)

7✔

468

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

7✔

469

                    .catch(rejectPromise)

7✔

470

7✔

471

12✔

472

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

12✔

473

            let {chainIdTo, amountFrom} = args;

216✔

474

216✔

475

            let toChainZap: GenericZapBridgeContract;

216✔

476

216✔

477

            if (chainIdTo !== ChainId.TERRA) {

216✔

478

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

211✔

479

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

211✔

480

211✔

481

216✔

482

            const {

216✔

483

                tokenFrom, tokenTo,

216✔

484

                tokenIndexFrom, tokenIndexTo,

216✔

485

                fromChainTokens

216✔

486

            } = this.makeBridgeTokenArgs(args);

216✔

487

216✔

488

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

216✔

489

216✔

490

            const

216✔

491

                TEN = BigNumber.from(10),

216✔

492

                fromCoinDecimals = tokenFrom.decimals(this.chainId);

216✔

493

216✔

494

            const

216✔

495

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

216✔

496

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

216✔

497

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

216✔

498

                amountFromFixedDecimals = involvesUST ? amountFrom : amountFrom.mul(TEN.pow(18-fromCoinDecimals));

216✔

499

216✔

500

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

216✔

501

                intermediateTokenAddr,

216✔

502

                chainIdTo,

216✔

503

                amountFromFixedDecimals

216✔

504

);

216✔

505

216✔

506

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

216✔

507

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

432✔

508

216✔

509

            const

216✔

510

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

216✔

511

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

216✔

512

216✔

513

            let amountToReceive_from_prom: Promise<BigNumber>;

216✔

514

216✔

515

            if (amountFrom.isZero()) {

216✔

516

                amountToReceive_from_prom = Promise.resolve(Zero);

8✔

517

            } else if (ethToEth || Tokens.isMintBurnToken(tokenFrom) || tokenFrom.isWrapperToken) {

216✔

518

                amountToReceive_from_prom = Promise.resolve(amountFromFixedDecimals);

128✔

519

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

208✔

520

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

10✔

521

                    tokenFrom.isEqual(t) ? amountFrom : Zero

30✔

522

);

10✔

523

10✔

524

                amountToReceive_from_prom = this.zapBridgeInstance.calculateTokenAmount(

10✔

525

                    liquidityAmounts,

10✔

526

                    true

10✔

527

);

10✔

528

            } else {

80✔

529

                amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

70✔

530

                    this.networkZapBridgeInstance,

70✔

531

                    intermediateToken.address(this.chainId),

70✔

532

                    tokenIndexFrom,

70✔

533

0,

70✔

534

                    amountFrom

70✔

535

);

70✔

536

70✔

537

216✔

538

            let amountToReceive_from = await amountToReceive_from_prom;

216✔

539

216✔

540

            let bridgeFee: BigNumber;

216✔

541

            /* c8 ignore start */

2✔

542

            try {

2✔

543

                bridgeFee = await bridgeFeeRequest;

2✔

544

            } catch (e) {

2✔

545

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

2✔

546

                return rejectPromise(e)

2✔

547

2✔

548

            /* c8 ignore stop */

2✔

549

216✔

550

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

216✔

551

216✔

552

            let amountToReceive_to_prom: Promise<BigNumber>;

216✔

553

216✔

554

            if (amountToReceive_from.isZero()) {

216✔

555

                amountToReceive_to_prom = Promise.resolve(Zero);

10✔

556

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

216✔

557

                amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

123✔

558

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

206✔

559

                amountToReceive_to_prom =

8✔

560

                    (toChainZap as L1BridgeZapContract).calculateRemoveLiquidityOneToken(

8✔

561

                        amountToReceive_from,

8✔

562

                        tokenIndexTo

8✔

563

);

8✔

564

            } else {

83✔

565

                amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

75✔

566

                    toChainZap,

75✔

567

                    intermediateToken.address(chainIdTo),

75✔

568

0,

75✔

569

                    tokenIndexTo,

75✔

570

                    amountToReceive_from

75✔

571

);

75✔

572

75✔

573

216✔

574

            let amountToReceive: BigNumber;

216✔

575

            /* c8 ignore next 6 */

2✔

576

            try {

2✔

577

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

2✔

578

            } catch (err) {

2✔

579

                return rejectPromise(err)

2✔

580

2✔

581

2✔

582

            let fee = bridgeFee;

216✔

583

            if (fee) {

216✔

584

                fee = fee.mul(bridgeFeeMultiplier);

216✔

588

216✔

589

            return {

216✔

590

                amountToReceive,

216✔

591

                bridgeFee: fee

216✔

592

216✔

593

216✔

594

12✔

595

        private buildETHMainnetBridgeTxn(

12✔

596

            args:      BridgeTransactionParams,

82✔

597

            tokenArgs: BridgeTokenArgs

82✔

598

        ): Promise<PopulatedTransaction> {

82✔

599

            const

82✔

600

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

82✔

601

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

82✔

602

                    chainId: this.chainId,

82✔

603

                    signerOrProvider: this.provider

82✔

604

});

82✔

605

82✔

606

let

82✔

607

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

82✔

608

                easyDeposits:   ID[] = [

82✔

609

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

82✔

610

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

82✔

611

],

82✔

612

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

82✔

613

82✔

614

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

82✔

615

            if (isEasy && txn) {

82✔

616

                return txn

32✔

617

32✔

618

50✔

619

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

50✔

620

                    args.tokenFrom.isEqual(t)

98✔

621

                        ? amountFrom

98✔

622

                        : Zero

98✔

623

);

50✔

624

50✔

625

            const {

50✔

626

                transactionDeadline,

50✔

627

                bridgeTransactionDeadline,

50✔

628

                minToSwapDestFromOrigin,

50✔

629

                minToSwapDest,

50✔

630

                minToSwapOriginMediumSlippage,

50✔

631

                minToSwapDestFromOriginMediumSlippage,

50✔

632

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

50✔

633

50✔

634

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

80✔

635

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

8✔

636

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

4✔

637

                        args as BridgeUtils.BridgeTxParams,

4✔

638

                        this.chainId,

4✔

639

                        args.tokenTo

4✔

640

);

4✔

641

4✔

642

                    return zapBridge

4✔

643

                        .populateTransaction

4✔

644

                        .deposit(...bridgeDepositArgs)

4✔

645

                } else {

4✔

646

                    return zapBridge.populateTransaction.zapAndDeposit(

4✔

647

                        addressTo,

4✔

648

                        chainIdTo,

4✔

649

                        Tokens.NUSD.address(this.chainId),

4✔

650

                        liquidityAmounts,

4✔

651

                        minToSwapDest,

4✔

652

                        transactionDeadline,

4✔

653

4✔

654

4✔

655

8✔

656

80✔

657

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

82✔

658

                return zapBridge.populateTransaction.depositETHAndSwap(

24✔

659

                    ...BridgeUtils.depositETHParams(castArgs),

24✔

660

                    0, // nusd tokenindex,

24✔

661

                    tokenArgs.tokenIndexTo,

24✔

662

                    minToSwapDestFromOrigin, // minDy

24✔

663

                    bridgeTransactionDeadline,

24✔

664

                    BridgeUtils.overrides(amountFrom)

24✔

665

24✔

666

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

46✔

667

                return zapBridge.populateTransaction.depositAndSwap(

6✔

668

                    addressTo,

6✔

669

                    chainIdTo,

6✔

670

                    Tokens.NUSD.address(this.chainId),

6✔

671

                    amountFrom,

6✔

672

0,

6✔

673

                    tokenArgs.tokenIndexTo,

6✔

674

                    minToSwapDestFromOriginMediumSlippage,

6✔

675

                    bridgeTransactionDeadline

6✔

676

6✔

677

6✔

678

10✔

679

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

10✔

680

                addressTo,

10✔

681

                chainIdTo,

10✔

682

                Tokens.NUSD.address(this.chainId),

10✔

683

                liquidityAmounts,

10✔

684

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

10✔

685

                transactionDeadline,

10✔

686

0,

10✔

687

                tokenArgs.tokenIndexTo,

10✔

688

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

10✔

689

                bridgeTransactionDeadline,

10✔

690

10✔

691

10✔

692

12✔

693

        private buildL2BridgeTxn(

12✔

694

            args: BridgeTransactionParams,

267✔

695

            tokenArgs: BridgeTokenArgs

267✔

696

        ): Promise<PopulatedTransaction> {

267✔

697

            const

267✔

698

                {chainIdTo, amountFrom, amountTo} = args,

267✔

699

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

267✔

700

                    chainId: this.chainId,

267✔

701

                    signerOrProvider: this.provider

267✔

702

});

267✔

703

267✔

704

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

267✔

706

                : tokenArgs.tokenFrom;

267✔

707

267✔

708

let

267✔

709

                easyDeposits:   ID[] = [],

267✔

710

                easyDepositETH: ID[] = [],

267✔

711

                easyRedeems:    ID[] = [

267✔

712

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

267✔

713

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

267✔

714

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

267✔

715

];

267✔

716

267✔

717

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

267✔

718

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

1,335✔

719

1,335✔

720

let

1,335✔

721

                    hasAltChain = typeof altChainId !== 'undefined',

1,335✔

722

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

1,335✔

723

1,335✔

724

                if (this.chainId === chainId) {

1,335✔

725

                    depositEth

138✔

726

                        ? easyDepositETH.push(...tokenHashes)

138✔

727

                        : easyDeposits.push(...tokenHashes);

138✔

728

                } else {

1,335✔

729

                    if (hasAltChain) {

1,197✔

730

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

455✔

731

                    } else {

1,197✔

732

                        easyRedeems.push(...tokenHashes);

742✔

733

742✔

734

1,197✔

735

})

267✔

736

267✔

737

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

267✔

738

            if (isEasy && txn) {

267✔

739

                return txn

90✔

740

90✔

741

267✔

742

            const {

267✔

743

                transactionDeadline,

267✔

744

                bridgeTransactionDeadline,

267✔

745

                minToSwapOriginHighSlippage,

267✔

746

                minToSwapDestFromOriginHighSlippage,

267✔

747

                minToSwapDest,

267✔

748

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

267✔

749

267✔

750

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

267✔

751

                zapBridge

11✔

752

                    .populateTransaction

11✔

753

                    .redeemAndSwap(

11✔

754

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

11✔

755

0,

11✔

756

                        tokenArgs.tokenIndexTo,

11✔

757

                        minToSwapDest,

11✔

758

                        transactionDeadline,

11✔

759

267✔

760

267✔

761

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

267✔

762

                let populateFn = swapETH

20✔

763

                    ? zapBridge.populateTransaction.swapETHAndRedeem

20✔

764

                    : zapBridge.populateTransaction.swapAndRedeem

20✔

765

20✔

766

                return populateFn(

20✔

767

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

20✔

768

                    tokenArgs.tokenIndexFrom,

20✔

769

0,

20✔

770

                    amountFrom,

20✔

771

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

20✔

772

                    transactionDeadline,

20✔

773

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

20✔

774

20✔

775

20✔

776

267✔

777

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

267✔

778

                let populateFn = swapETH

72✔

779

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

72✔

780

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

72✔

781

72✔

782

                return populateFn(

72✔

783

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

72✔

784

                    tokenArgs.tokenIndexFrom,

72✔

785

0,

72✔

786

                    amountFrom,

72✔

787

                    minToSwapOriginHighSlippage,

72✔

788

                    transactionDeadline,

72✔

789

0,

72✔

790

                    tokenArgs.tokenIndexTo,

72✔

791

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

72✔

792

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

72✔

793

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

72✔

794

72✔

795

72✔

796

267✔

797

            switch (tokenSwitch(args.tokenTo)) {

267✔

798

                case Tokens.NUSD:

267✔

799

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

30✔

800

                        return zapBridge

8✔

801

                            .populateTransaction

8✔

802

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

8✔

803

8✔

804

30✔

805

                    return zapBridge

30✔

806

                        .populateTransaction

30✔

807

                        .swapAndRedeem(

30✔

808

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

30✔

809

                            tokenArgs.tokenIndexFrom,

30✔

810

0,

30✔

811

                            amountFrom,

30✔

812

                            minToSwapOriginHighSlippage,

30✔

813

                            transactionDeadline

30✔

814

30✔

815

                case Tokens.GMX:

267✔

816

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

8✔

817

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

8✔

818

8✔

819

                    return this.chainId === ChainId.ARBITRUM

8✔

820

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

8✔

821

                        : this.bridgeInstance

8✔

822

                            .populateTransaction

4✔

823

                            .redeem(

4✔

824

                                addrTo,

4✔

825

                                chainTo,

4✔

826

                                Tokens.GMX.wrapperAddress(this.chainId),

4✔

827

                                amount

4✔

828

8✔

829

                default:

267✔

830

                    if (chainIdTo === ChainId.ETH) {

129✔

831

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

46✔

832

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

30✔

833

                                return zapBridge

10✔

834

                                    .populateTransaction

10✔

835

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

10✔

836

                            } else {

30✔

837

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

20✔

838

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

20✔

839

20✔

840

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

46✔

841

                            return zapBridge

8✔

842

                                .populateTransaction

8✔

843

                                .redeemAndRemove(

8✔

844

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

8✔

845

                                    amountFrom,

8✔

846

                                    tokenArgs.tokenIndexTo,

8✔

847

                                    minToSwapDest,

8✔

848

                                    transactionDeadline

8✔

849

8✔

850

8✔

851

44✔

852

                        return zapBridge

44✔

853

                            .populateTransaction

44✔

854

                            .swapAndRedeemAndRemove(

44✔

855

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

44✔

856

                                tokenArgs.tokenIndexFrom,

44✔

857

0,

44✔

858

                                amountFrom,

44✔

859

                                minToSwapOriginHighSlippage,

44✔

860

                                transactionDeadline,

44✔

861

                                tokenArgs.tokenIndexTo, //swapTokenIndex

44✔

862

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

44✔

863

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

44✔

864

44✔

865

44✔

866

129✔

867

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

129✔

868

                        return easyRedeemAndSwap(args.tokenFrom)

11✔

869

11✔

870

129✔

871

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

129✔

872

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

55✔

873

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

55✔

874

55✔

875

125✔

876

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

125✔

877

267✔

879

12✔

880

        private buildTerraBridgeTxn({

12✔

881

            addressTo,

5✔

882

            chainIdTo,

5✔

883

            amountFrom

5✔

884

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

5✔

885

            return Promise.resolve(new MsgExecuteContract(

5✔

886

                null,

5✔

887

                this.bridgeAddress,

5✔

888

5✔

889

                    deposit: {

5✔

890

                        to_address: toLower(addressTo),

5✔

891

                        chain_id:  `${chainIdTo}`,

5✔

892

                        denom:     "uusd"

5✔

893

5✔

894

},

5✔

895

                { uusd: amountFrom.toNumber() }

5✔

896

))

5✔

897

5✔

898

12✔

899

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

12✔

900

            let {tokenFrom, tokenTo, chainIdTo} = args;

615✔

901

615✔

902

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

615✔

903

615✔

904

            switch (tokenFrom.swapType) {

615✔

905

                case SwapType.ETH:

615✔

906

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

206✔

907

                    break;

206✔

908

                case SwapType.AVAX:

615✔

909

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

12✔

910

                    break;

12✔

911

                case SwapType.MOVR:

615✔

912

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

12✔

913

                    break;

12✔

914

                default:

615✔

915

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

385✔

916

615✔

917

615✔

918

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

615✔

919

615✔

920

            const

615✔

921

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

615✔

922

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

615✔

923

615✔

924

            return {

615✔

925

                fromChainTokens,

615✔

926

                toChainTokens,

615✔

927

                tokenFrom,

615✔

928

                tokenTo,

615✔

929

                tokenIndexFrom,

615✔

930

                tokenIndexTo

615✔

931

615✔

932

615✔

933

12✔

934

        private checkEasyArgs(

12✔

935

            args:            BridgeTransactionParams,

349✔

936

            zapBridge:       GenericZapBridgeContract,

349✔

937

            easyDeposits:    ID[],

349✔

938

            easyRedeems:     ID[],

349✔

939

            easyDepositETH?: ID[],

349✔

940

        ): EasyArgsCheck {

349✔

941

let

349✔

942

                castArgs = args as BridgeUtils.BridgeTxParams,

349✔

943

                isEasy: boolean = false,

349✔

944

                txn:    Promise<PopulatedTransaction>;

349✔

945

349✔

946

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

349✔

947

349✔

948

            switch (true) {

349✔

949

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

349✔

950

                    isEasy = true;

74✔

951

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

74✔

952

                    break;

74✔

953

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

349✔

954

                    isEasy = true;

32✔

955

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

32✔

956

                    break;

32✔

957

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

349✔

958

                    isEasy = true;

16✔

959

                    txn    =  zapBridge

16✔

960

                        .populateTransaction

16✔

961

                        .depositETH(

16✔

962

                            ...BridgeUtils.depositETHParams(castArgs),

16✔

963

                            BridgeUtils.overrides(args.amountFrom)

16✔

964

);

16✔

965

                    break;

16✔

966

349✔

967

349✔

968

            return {castArgs, isEasy, txn}

349✔

969

349✔

970

12✔

971

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

12✔

972

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

253✔

973

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

253✔

974

                if (!swapSupported) {

253✔

975

                    reject(errReason);

32✔

976

                    return

32✔

977

32✔

978

253✔

979

                resolve(true);

253✔

980

})

253✔

981

253✔

982

12✔

983

        private buildERC20ApproveArgs(args: {

12✔

984

            token:   Token | string,

213✔

985

            amount?: BigNumberish

213✔

986

        }): [ERC20.ApproveArgs, string] {

213✔

987

            const {token, amount} = args;

213✔

988

213✔

989

            let tokenAddr: string = instanceOfToken(token)

213✔

990

                ? token.address(this.chainId)

213✔

992

213✔

993

            let spender: string;

213✔

994

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

213✔

995

                spender = this.bridgeAddress;

16✔

996

            } else {

213✔

997

                spender = this.zapBridgeAddress;

197✔

998

197✔

999

213✔

1000

            return [{

213✔

1001

                spender,

213✔

1002

                amount

213✔

1003

            }, tokenAddr]

213✔

1004

213✔

1005

12✔

1006

        async getAllowanceForAddress(args: {

12✔

1007

            address: string,

5✔

1008

            token:   Token,

5✔

1009

        }): Promise<BigNumber> {

5✔

1010

            let { address, token } = args;

5✔

1011

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

5✔

1012

5✔

1013

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

5✔

1014

5✔

1015

12✔

1016

        private async resolveApproveFunc(

12✔

1017

            approveRes:    NeedsTokenApproveResult,

7✔

1018

            hasBalanceRes: Promise<CanBridgeResult>,

7✔

1019

            token:         Token

7✔

1020

        ): Promise<CanBridgeResult> {

7✔

1021

            const {needsApproval, currentAllowance} = approveRes;

7✔

1022

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

7✔

1023

7✔

1024

            return needsApproval

7✔

1026

                : hasBalanceRes

7✔

1027

7✔

1028

12✔

1029

        private async checkNeedsApprove({

12✔

1030

            address,

7✔

1031

            token,

7✔

1032

            amount=MAX_APPROVAL_AMOUNT.sub(1)

7✔

1033

        }: CheckCanBridgeParams): Promise<NeedsTokenApproveResult> {

7✔

1034

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

7✔

1035

7✔

1036

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

7✔

1037

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

7✔

1038

7✔

1039

12✔

1040

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

12✔

1041

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

7✔

1042

7✔

1043

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

7✔

1045

                /* c8 ignore next */

2✔

1046

                balanceFn = signer.getBalance;

2✔

1047

            } else if (address) {

7✔

1048

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

7✔

1049

7✔

1050

7✔

1051

            return this.resolveBalanceFunc(

7✔

1052

                balanceFn(),

7✔

1053

                amount,

7✔

1054

                token

7✔

1055

7✔

1056

7✔

1057

12✔

1058

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

12✔

1059

            const

7✔

1060

                {address, amount, token} = args,

7✔

1061

                tokenAddress = token.address(this.chainId);

7✔

1062

7✔

1063

            return this.resolveBalanceFunc(

7✔

1064

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

7✔

1065

                amount,

7✔

1066

                token

7✔

1067

7✔

1068

7✔

1069

12✔

1070

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

12✔

1071

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

3✔

1072

                .then(([res]) => {

3✔

1073

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

3✔

1074

3✔

1075

                    let ustBalance: BigNumber = Zero;

3✔

1076

3✔

1077

                    if (coin) {

3✔

1078

                        const {amount} = coin.toData();

3✔

1079

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

3✔

1080

                            ustBalance = BigNumber.from(amount);

3✔

1081

3✔

1082

3✔

1083

3✔

1084

                    return ustBalance

3✔

1085

})

3✔

1086

3✔

1087

            return this.resolveBalanceFunc(

3✔

1088

                balProm,

3✔

1089

                amount,

3✔

1090

                token

3✔

1091

3✔

1092

3✔

1093

12✔

1094

        private async resolveBalanceFunc(

12✔

1095

            prom:   Promise<BigNumber>,

17✔

1096

            amount: BigNumberish,

17✔

1097

            token:  Token

17✔

1098

        ): Promise<CanBridgeResult> {

17✔

1099

            return Promise.resolve(prom)

17✔

1100

                .then(balance => {

17✔

1101

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

17✔

1102

17✔

1103

                    if (balance.gte(amount)) {

17✔

1104

                        return {canBridge: true}

2✔

1105

2✔

1106

17✔

1107

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

17✔

1108

})

17✔

1109

                .catch(rejectPromise)

17✔

1110

17✔

1111

12✔

1112

12✔

1113

    const REQUIRED_CONFS: NumberMap = {

12✔

1114

        [ChainId.ETH]:       7,

12✔

1115

        [ChainId.OPTIMISM]:  1,

12✔

1116

        [ChainId.CRONOS]:    6,

12✔

1117

        [ChainId.BSC]:       14,

12✔

1118

        [ChainId.POLYGON]:   128,

12✔

1119

        [ChainId.FANTOM]:    5,

12✔

1120

        [ChainId.BOBA]:      1,

12✔

1121

        [ChainId.METIS]:     6,

12✔

1122

        [ChainId.MOONBEAM]:  21,

12✔

1123

        [ChainId.MOONRIVER]: 21,

12✔

1124

        [ChainId.ARBITRUM]:  40,

12✔

1125

        [ChainId.AVALANCHE]: 5,

12✔

1126

        [ChainId.TERRA]:     1,

12✔

1127

        [ChainId.AURORA]:    5,

12✔

1128

        [ChainId.HARMONY]:   1,

12✔

1129

};

12✔

1130

12✔

1131

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

12✔

1133

1,021✔

1135

1,021✔

1136

12✔

1137

    /* c8 ignore next */

2✔

1138

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

2✔

1139

        return TokenSwap.bridgeSwapSupported(args)

405✔

1140

405✔

1141

12✔

synapsecns / sdk / 2032525430

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

synapsecns / sdk / 2032525430

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