synapsecns/sdk | Build 2002109309 | 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 {

13✔

76

    export type CanBridgeResult = {

13✔

77

        canBridge:     boolean;

13✔

78

        reasonUnable?: string;

13✔

79

        amount?:       BigNumber;

13✔

80

13✔

81

13✔

82

    type NeedsTokenApproveResult = {

13✔

83

        needsApproval:     boolean;

13✔

84

        currentAllowance?: BigNumber;

13✔

85

13✔

86

13✔

87

    export type BridgeOutputEstimate = {

13✔

88

        amountToReceive: BigNumber,

13✔

89

        bridgeFee:       BigNumber,

13✔

90

13✔

91

13✔

92

/**

13✔

93

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

13✔

94

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

13✔

95

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

13✔

96

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

13✔

97

*/

13✔

98

    export interface BridgeParams {

13✔

99

        tokenFrom:   Token,

13✔

100

        tokenTo:     Token

13✔

101

        chainIdTo:   number,

13✔

102

        amountFrom?: BigNumber,

13✔

103

13✔

104

13✔

105

/**

13✔

106

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

13✔

107

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

13✔

108

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

13✔

109

     * on the destination chain.

13✔

110

*/

13✔

111

    export interface BridgeTransactionParams extends BridgeParams {

13✔

112

        amountFrom: BigNumber;

13✔

113

        amountTo:   BigNumber;

13✔

114

        addressTo?: string;

13✔

115

13✔

116

13✔

117

    type EasyArgsCheck = {

13✔

118

        isEasy:   boolean;

13✔

119

        castArgs: BridgeUtils.BridgeTxParams;

13✔

120

        txn?:     Promise<PopulatedTransaction>;

13✔

121

13✔

122

13✔

123

    type BridgeTokenArgs = {

13✔

124

        fromChainTokens: Token[];

13✔

125

        toChainTokens:   Token[];

13✔

126

        tokenFrom:       Token;

13✔

127

        tokenTo:         Token;

13✔

128

        tokenIndexFrom:  number;

13✔

129

        tokenIndexTo:    number;

13✔

130

13✔

131

13✔

132

    interface CheckCanBridgeParams {

13✔

133

        address?: string;

13✔

134

        signer?:  EthersSigner;

13✔

135

        token:    Token;

13✔

136

        amount:   BigNumberish;

13✔

137

13✔

138

13✔

139

    interface CanBridgeParams extends CheckCanBridgeParams {

13✔

140

        address: string;

13✔

141

13✔

142

13✔

143

/**

13✔

144

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

13✔

145

*/

13✔

146

    export class SynapseBridge {

13✔

147

        protected network: Networks.Network;

13✔

148

        protected chainId: number;

924✔

149

        protected _provider: Provider | LCDClient;

924✔

150

924✔

151

        private readonly bridgeAddress: string;

924✔

152

924✔

153

        private readonly bridgeInstance:           SynapseBridgeContract;

924✔

154

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

924✔

155

924✔

156

        private readonly isTerra:      boolean;

924✔

157

        private readonly isL2Zap:      boolean;

924✔

158

        private readonly isL2ETHChain: boolean;

924✔

159

924✔

160

        private readonly zapBridgeAddress: string;

924✔

161

924✔

162

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

924✔

163

924✔

164

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

924✔

165

            chainId: ChainId.ETH,

924✔

166

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

924✔

167

});

924✔

168

924✔

169

        readonly requiredConfirmations: number;

13✔

170

13✔

171

        constructor(args: {

13✔

172

            network: Networks.Network | number,

924✔

173

            provider?: Provider

924✔

174

        }) {

924✔

175

            let {network, provider} = args;

924✔

176

924✔

177

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

924✔

178

            this.chainId = this.network.chainId;

924✔

179

924✔

180

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

924✔

181

924✔

182

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

924✔

183

            this.isL2Zap = this.network.zapIsL2BridgeZap;

924✔

184

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

924✔

185

924✔

186

            this._provider = provider ?? (this.isTerra

924✔

187

                ? terraRpcProvider(this.chainId)

858✔

188

                : rpcProviderForChain(this.chainId)

858✔

189

);

924✔

190

924✔

191

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

924✔

192

924✔

193

            this.bridgeAddress    = contractAddrs.bridgeAddress;

924✔

194

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

924✔

195

924✔

196

            if (!this.isTerra) {

924✔

197

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

904✔

198

904✔

199

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

904✔

200

904✔

201

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

904✔

202

                this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

904✔

203

904✔

204

904✔

205

924✔

206

13✔

207

        private get provider(): Provider {

13✔

208

            return this._provider as Provider

316✔

209

316✔

210

13✔

211

        private get terraProvider(): LCDClient {

13✔

212

            return this._provider as LCDClient

6✔

213

6✔

214

13✔

215

        bridgeVersion(): Promise<BigNumber> {

13✔

216

            if (this.isTerra) {

30✔

217

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

2✔

218

2✔

219

30✔

220

            return this.bridgeInstance.bridgeVersion()

30✔

221

30✔

222

13✔

223

        WETH_ADDRESS(): Promise<string> {

13✔

224

            if (this.isTerra) {

30✔

225

                return Promise.resolve("0x0000000000000000000000000000000000000000")

2✔

226

2✔

227

30✔

228

            return this.bridgeInstance.WETH_ADDRESS()

30✔

229

30✔

230

13✔

231

/**

13✔

232

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

13✔

233

         * is supported.

13✔

234

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

13✔

235

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

13✔

236

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

13✔

237

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

13✔

238

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

13✔

239

*/

13✔

240

        swapSupported(args: {

13✔

241

            tokenFrom: Token,

372✔

242

            tokenTo:   Token

372✔

243

            chainIdTo: number,

372✔

244

        }): [boolean, string] {

372✔

245

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

372✔

246

372✔

247

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

372✔

248

372✔

249

13✔

250

/**

13✔

251

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

13✔

252

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

13✔

253

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

13✔

254

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

13✔

255

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

13✔

256

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

13✔

257

*/

13✔

258

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

13✔

259

            return this.checkSwapSupported(args)

220✔

260

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

220✔

261

                .catch(rejectPromise)

220✔

262

220✔

263

13✔

264

/**

13✔

265

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

13✔

266

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

13✔

267

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

13✔

268

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

13✔

269

         * of web3/ethers/etc.

13✔

270

*/

13✔

271

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

13✔

272

            const

354✔

273

                {addressTo} = args,

354✔

274

                tokenArgs = this.makeBridgeTokenArgs(args),

354✔

275

                {tokenFrom, tokenTo} = tokenArgs;

354✔

276

354✔

277

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

354✔

278

                return rejectPromise(

4✔

279

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

4✔

280

4✔

281

4✔

282

354✔

283

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

354✔

284

                return rejectPromise(

2✔

285

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

2✔

286

2✔

287

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

354✔

288

                return rejectPromise(

2✔

289

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

2✔

290

2✔

291

2✔

292

354✔

293

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

354✔

294

354✔

295

            let newTxn: Promise<PopulatedTransaction>;

354✔

296

354✔

297

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

354✔

298

                if (this.isTerra) {

30✔

299

                    return this.buildTerraBridgeTxn(args)

8✔

300

8✔

301

24✔

302

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

24✔

303

                    args.chainIdTo,

24✔

304

                    Tokens.UST.address(this.chainId),

24✔

305

                    args.amountFrom

24✔

306

];

24✔

307

24✔

308

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

30✔

309

                    newTxn = this.bridgeInstance

8✔

310

                        .populateTransaction

8✔

311

                        .redeemV2(

8✔

312

                            bech32.decode(args.addressTo).words,

8✔

313

                            ...redeemArgs

8✔

314

);

8✔

315

                } else {

30✔

316

                    newTxn = this.bridgeInstance

14✔

317

                        .populateTransaction

14✔

318

                        .redeem(

14✔

319

                            args.addressTo,

14✔

320

                            ...redeemArgs

14✔

321

);

14✔

322

14✔

323

            } else {

354✔

324

                newTxn = this.chainId === ChainId.ETH

302✔

325

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

302✔

326

                : this.buildL2BridgeTxn(args, tokenArgs);

302✔

327

302✔

328

354✔

329

            return newTxn

354✔

330

                .then(txn =>

354✔

331

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

312✔

332

354✔

333

354✔

334

13✔

335

/**

13✔

336

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

13✔

337

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

13✔

338

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

13✔

339

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

13✔

340

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

13✔

341

         * @return {Promise<ContractTransaction>}

13✔

342

*/

13✔

343

        async executeBridgeTokenTransaction(

13✔

344

            args:       BridgeTransactionParams,

10✔

345

            signer:     EthersSigner | TerraWallet | GenericSigner,

10✔

346

            callStatic: boolean=false

10✔

347

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

10✔

348

            try {

10✔

349

                await this.checkSwapSupported(args);

10✔

351

                /* c8 ignore next 2 */

2✔

352

                return rejectPromise(e);

2✔

353

2✔

354

10✔

355

            const {tokenFrom, amountFrom, addressTo} = args;

10✔

356

10✔

357

            let txSigner: GenericSigner;

10✔

358

            let signerAddress: string;

10✔

359

10✔

360

            if (signer instanceof TerraWallet) {

10✔

361

                txSigner = new TerraSignerWrapper(signer);

2✔

362

            } else {

10✔

363

                txSigner = signer;

8✔

364

8✔

365

10✔

366

            signerAddress = await txSigner.getAddress();

10✔

368

10✔

369

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

10✔

370

10✔

371

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

10✔

378

10✔

379

            return this.checkCanBridge(checkArgs)

10✔

380

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

10✔

381

                    if (!canBridge) {

10✔

382

                        const rejection = new CanBridgeError(reasonUnable, amount);

10✔

383

                        return rejectPromise(rejection)

10✔

384

10✔

385

10✔

386

                    return this.buildBridgeTokenTransaction(args)

10✔

387

                        .then(sendTxn)

10✔

388

                        .catch(rejectPromise)

10✔

389

})

10✔

390

10✔

391

13✔

392

/**

13✔

393

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

13✔

394

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

13✔

395

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

13✔

396

         * framework so they can ultimately send the transaction.

13✔

397

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

13✔

398

         * @param {Object} args

13✔

399

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

13✔

400

         * to the bridge on the source chain.

13✔

401

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

13✔

402

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

13✔

403

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

13✔

404

         * of web3/ethers/etc.

13✔

405

*/

13✔

406

        async buildApproveTransaction(args: {

13✔

407

            token:   Token | string,

174✔

408

            amount?: BigNumberish

174✔

409

        }): Promise<PopulatedTransaction> {

174✔

410

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

174✔

411

174✔

412

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

174✔

413

174✔

414

13✔

415

/**

13✔

416

         * Builds and executes an ERC20 Approve call,

13✔

417

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

13✔

418

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

13✔

419

         * framework so they can ultimately send the transaction.

13✔

420

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

13✔

421

         * @param {Object} args

13✔

422

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

13✔

423

         * to the bridge on the source chain.

13✔

424

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

13✔

425

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

13✔

426

         * transaction.

13✔

427

*/

13✔

428

        async executeApproveTransaction(

13✔

429

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

2✔

430

            signer:     EthersSigner,

2✔

431

        ): Promise<ContractTransaction> {

2✔

432

            const

2✔

433

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

2✔

434

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

2✔

435

2✔

436

            return ERC20.approve(approveArgs, tokenParams, signer)

2✔

437

2✔

438

13✔

439

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

13✔

440

            const {token, signer, address} = args;

34✔

441

34✔

442

            let signerAddress: string;

34✔

444

                /* c8 ignore next */

2✔

445

                signerAddress = await signer.getAddress();

2✔

446

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

34✔

447

                signerAddress = address;

34✔

448

34✔

449

34✔

450

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

34✔

451

            const

34✔

452

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

34✔

453

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

34✔

454

34✔

455

            if (isTerraTx) {

34✔

456

                return this.checkTerraUSTBalance(checkArgs);

6✔

457

6✔

458

34✔

459

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

34✔

460

                ? this.checkGasTokenBalance(checkArgs)

34✔

461

                : this.checkERC20Balance(checkArgs);

34✔

462

34✔

463

            if (isGasTokenTransfer) {

34✔

464

                return hasBalanceRes

14✔

465

14✔

466

14✔

467

            return this.checkNeedsApprove(checkArgs)

14✔

468

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

14✔

469

                .catch(rejectPromise)

14✔

470

14✔

471

13✔

472

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

13✔

473

            let {chainIdTo, amountFrom} = args;

194✔

474

194✔

475

            let toChainZap: GenericZapBridgeContract;

194✔

476

194✔

477

            if (chainIdTo !== ChainId.TERRA) {

194✔

478

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

186✔

479

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

186✔

480

186✔

481

194✔

482

            const {

194✔

483

                tokenFrom, tokenTo,

194✔

484

                tokenIndexFrom, tokenIndexTo,

194✔

485

                fromChainTokens

194✔

486

            } = this.makeBridgeTokenArgs(args);

194✔

487

194✔

488

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

194✔

489

194✔

490

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

194✔

491

194✔

492

            const

194✔

493

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

194✔

494

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

194✔

495

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

194✔

496

194✔

497

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

194✔

498

                intermediateTokenAddr,

194✔

499

                chainIdTo,

194✔

500

                amtFrom

194✔

501

);

194✔

502

194✔

503

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

194✔

504

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

388✔

505

194✔

506

            const

194✔

507

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

194✔

508

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

194✔

509

194✔

510

            let amountToReceive_from_prom: Promise<BigNumber>;

194✔

511

            switch (true) {

194✔

512

                case amountFrom.eq(Zero):

194✔

513

                    amountToReceive_from_prom = Promise.resolve(Zero);

8✔

514

                    break;

8✔

515

                case ethToEth:

194✔

516

                case Tokens.isMintBurnToken(tokenFrom):

194✔

517

                case tokenFrom.isWrappedToken:

194✔

518

                    amountToReceive_from_prom = Promise.resolve(amountFrom);

130✔

519

                    break;

130✔

520

                case this.chainId === ChainId.ETH:

194✔

521

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

8✔

522

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

8✔

523

8✔

524

                    break;

8✔

525

                default:

194✔

526

                    amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

48✔

527

                        this.networkZapBridgeInstance,

48✔

528

                        intermediateToken.address(this.chainId),

48✔

529

                        tokenIndexFrom,

48✔

530

0,

48✔

531

                        amountFrom

48✔

532

);

48✔

533

194✔

534

194✔

535

            let amountToReceive_from = await amountToReceive_from_prom;

194✔

536

194✔

537

            let bridgeFee: BigNumber;

194✔

538

            /* c8 ignore start */

2✔

539

            try {

2✔

540

                bridgeFee = await bridgeFeeRequest;

2✔

541

                if (bridgeFee === null) {

2✔

542

                    console.error("calculateSwapFee returned null");

2✔

543

                    return rejectPromise("calculateSwapFee returned null")

2✔

544

2✔

545

            } catch (e) {

2✔

546

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

2✔

547

                return rejectPromise(e)

2✔

548

2✔

549

            /* c8 ignore stop */

2✔

550

194✔

551

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

194✔

552

194✔

553

            let amountToReceive_to_prom: Promise<BigNumber>;

194✔

554

            switch (true) {

194✔

555

                case amountToReceive_from.isZero():

194✔

556

                    amountToReceive_to_prom = Promise.resolve(Zero);

10✔

557

                    break;

10✔

558

                case ethFromEth:

194✔

559

                case Tokens.isMintBurnToken(tokenTo):

194✔

560

                case tokenTo.isWrappedToken:

194✔

561

                    amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

122✔

562

                    break;

122✔

563

                case chainIdTo === ChainId.ETH:

194✔

564

                    amountToReceive_to_prom = (toChainZap as L1BridgeZapContract)

6✔

565

                        .calculateRemoveLiquidityOneToken(amountToReceive_from, tokenIndexTo);

6✔

566

6✔

567

                    break;

6✔

568

                default:

194✔

569

                    amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

56✔

570

                        toChainZap,

56✔

571

                        intermediateToken.address(chainIdTo),

56✔

572

0,

56✔

573

                        tokenIndexTo,

56✔

574

                        amountToReceive_from

56✔

575

);

56✔

576

194✔

577

194✔

578

            let amountToReceive: BigNumber;

194✔

579

            /* c8 ignore next 6 */

2✔

580

            try {

2✔

581

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

2✔

582

            } catch (err) {

2✔

583

                return rejectPromise(err)

2✔

584

2✔

585

2✔

586

            return {

194✔

587

                amountToReceive,

194✔

589

194✔

590

194✔

591

13✔

592

        private buildETHMainnetBridgeTxn(

13✔

593

            args:      BridgeTransactionParams,

76✔

594

            tokenArgs: BridgeTokenArgs

76✔

595

        ): Promise<PopulatedTransaction> {

76✔

596

            const

76✔

597

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

76✔

598

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

76✔

599

                    chainId: this.chainId,

76✔

600

                    signerOrProvider: this.provider

76✔

601

});

76✔

602

76✔

603

let

76✔

604

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

76✔

605

                easyDeposits:   ID[] = [

76✔

606

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

76✔

607

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

76✔

608

],

76✔

609

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

76✔

610

76✔

611

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

76✔

612

            if (isEasy && txn) {

76✔

613

                return txn

32✔

614

32✔

615

76✔

616

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

76✔

617

                    args.tokenFrom.isEqual(t)

88✔

618

                        ? amountFrom

88✔

619

                        : Zero

88✔

620

);

76✔

621

76✔

622

            const {

76✔

623

                transactionDeadline,

76✔

624

                bridgeTransactionDeadline,

76✔

625

                minToSwapDestFromOrigin,

76✔

626

                minToSwapDest,

76✔

627

                minToSwapOriginMediumSlippage,

76✔

628

                minToSwapDestFromOriginMediumSlippage,

76✔

629

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

76✔

630

76✔

631

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

76✔

632

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

8✔

633

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

4✔

634

                        args as BridgeUtils.BridgeTxParams,

4✔

635

                        this.chainId,

4✔

636

                        args.tokenTo

4✔

637

);

4✔

638

4✔

639

                    return zapBridge

4✔

640

                        .populateTransaction

4✔

641

                        .deposit(...bridgeDepositArgs)

4✔

642

                } else {

4✔

643

                    return zapBridge.populateTransaction.zapAndDeposit(

4✔

644

                        addressTo,

4✔

645

                        chainIdTo,

4✔

646

                        Tokens.NUSD.address(this.chainId),

4✔

647

                        liquidityAmounts,

4✔

648

                        minToSwapDest,

4✔

649

                        transactionDeadline,

4✔

650

4✔

651

4✔

652

8✔

653

34✔

654

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

76✔

655

                return zapBridge.populateTransaction.depositETHAndSwap(

20✔

656

                    ...BridgeUtils.depositETHParams(castArgs),

20✔

657

                    0, // nusd tokenindex,

20✔

658

                    tokenArgs.tokenIndexTo,

20✔

659

                    minToSwapDestFromOrigin, // minDy

20✔

660

                    bridgeTransactionDeadline,

20✔

661

                    BridgeUtils.overrides(amountFrom)

20✔

662

20✔

663

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

40✔

664

                return zapBridge.populateTransaction.depositAndSwap(

6✔

665

                    addressTo,

6✔

666

                    chainIdTo,

6✔

667

                    Tokens.NUSD.address(this.chainId),

6✔

668

                    amountFrom,

6✔

669

0,

6✔

670

                    tokenArgs.tokenIndexTo,

6✔

671

                    minToSwapDestFromOriginMediumSlippage,

6✔

672

                    bridgeTransactionDeadline

6✔

673

6✔

674

6✔

675

72✔

676

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

72✔

677

                addressTo,

72✔

678

                chainIdTo,

72✔

679

                Tokens.NUSD.address(this.chainId),

72✔

680

                liquidityAmounts,

72✔

681

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

72✔

682

                transactionDeadline,

72✔

683

0,

72✔

684

                tokenArgs.tokenIndexTo,

72✔

685

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

72✔

686

                bridgeTransactionDeadline,

72✔

687

72✔

688

72✔

689

13✔

690

        private buildL2BridgeTxn(

13✔

691

            args: BridgeTransactionParams,

226✔

692

            tokenArgs: BridgeTokenArgs

226✔

693

        ): Promise<PopulatedTransaction> {

226✔

694

            const

226✔

695

                {chainIdTo, amountFrom, amountTo} = args,

226✔

696

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

226✔

697

                    chainId: this.chainId,

226✔

698

                    signerOrProvider: this.provider

226✔

699

});

226✔

700

226✔

701

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

226✔

703

                : tokenArgs.tokenFrom;

226✔

704

226✔

705

let

226✔

706

                easyDeposits:   ID[] = [],

226✔

707

                easyDepositETH: ID[] = [],

226✔

708

                easyRedeems:    ID[] = [

226✔

709

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

226✔

710

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

226✔

711

];

226✔

712

226✔

713

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

226✔

714

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

1,130✔

715

1,130✔

716

let

1,130✔

717

                    hasAltChain = typeof altChainId !== 'undefined',

1,130✔

718

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

1,130✔

719

1,130✔

720

                if (this.chainId === chainId) {

1,130✔

721

                    depositEth

120✔

722

                        ? easyDepositETH.push(...tokenHashes)

120✔

723

                        : easyDeposits.push(...tokenHashes);

120✔

724

                } else {

1,130✔

725

                    if (hasAltChain) {

1,010✔

726

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

378✔

727

                    } else {

1,010✔

728

                        easyRedeems.push(...tokenHashes);

632✔

729

632✔

730

1,010✔

731

})

226✔

732

226✔

733

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

226✔

734

            if (isEasy && txn) {

226✔

735

                return txn

74✔

736

74✔

737

226✔

738

            const {

226✔

739

                transactionDeadline,

226✔

740

                bridgeTransactionDeadline,

226✔

741

                minToSwapOriginHighSlippage,

226✔

742

                minToSwapDestFromOriginHighSlippage,

226✔

743

                minToSwapDest,

226✔

744

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

226✔

745

226✔

746

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

226✔

747

                zapBridge

10✔

748

                    .populateTransaction

10✔

749

                    .redeemAndSwap(

10✔

750

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

10✔

751

0,

10✔

752

                        tokenArgs.tokenIndexTo,

10✔

753

                        minToSwapDest,

10✔

754

                        transactionDeadline,

10✔

755

226✔

756

226✔

757

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

226✔

758

                let populateFn = swapETH

18✔

759

                    ? zapBridge.populateTransaction.swapETHAndRedeem

18✔

760

                    : zapBridge.populateTransaction.swapAndRedeem

18✔

761

18✔

762

                return populateFn(

18✔

763

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

18✔

764

                    tokenArgs.tokenIndexFrom,

18✔

765

0,

18✔

766

                    amountFrom,

18✔

767

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

18✔

768

                    transactionDeadline,

18✔

769

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

18✔

770

18✔

771

18✔

772

226✔

773

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

226✔

774

                let populateFn = swapETH

54✔

775

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

54✔

776

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

54✔

777

54✔

778

                return populateFn(

54✔

779

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

54✔

780

                    tokenArgs.tokenIndexFrom,

54✔

781

0,

54✔

782

                    amountFrom,

54✔

783

                    minToSwapOriginHighSlippage,

54✔

784

                    transactionDeadline,

54✔

785

0,

54✔

786

                    tokenArgs.tokenIndexTo,

54✔

787

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

54✔

788

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

54✔

789

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

54✔

790

54✔

791

54✔

792

226✔

793

            switch (tokenSwitch(args.tokenTo)) {

226✔

794

                case Tokens.NUSD:

226✔

795

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

28✔

796

                        return zapBridge

8✔

797

                            .populateTransaction

8✔

798

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

8✔

799

8✔

800

20✔

801

                    return zapBridge

20✔

802

                        .populateTransaction

20✔

803

                        .swapAndRedeem(

20✔

804

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

20✔

805

                            tokenArgs.tokenIndexFrom,

20✔

806

0,

20✔

807

                            amountFrom,

20✔

808

                            minToSwapOriginHighSlippage,

20✔

809

                            transactionDeadline

20✔

810

20✔

811

                case Tokens.GMX:

226✔

812

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

8✔

813

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

8✔

814

8✔

815

                    return this.chainId === ChainId.ARBITRUM

8✔

816

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

8✔

817

                        : this.bridgeInstance

8✔

818

                            .populateTransaction

4✔

819

                            .redeem(

4✔

820

                                addrTo,

4✔

821

                                chainTo,

4✔

822

                                Tokens.GMX.wrapperAddress(this.chainId),

4✔

823

                                amount

4✔

824

8✔

825

                default:

226✔

826

                    if (chainIdTo === ChainId.ETH) {

106✔

827

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

42✔

828

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

28✔

829

                                return zapBridge

10✔

830

                                    .populateTransaction

10✔

831

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

10✔

832

                            } else {

22✔

833

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

18✔

834

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

18✔

835

18✔

836

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

42✔

837

                            return zapBridge

8✔

838

                                .populateTransaction

8✔

839

                                .redeemAndRemove(

8✔

840

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

8✔

841

                                    amountFrom,

8✔

842

                                    tokenArgs.tokenIndexTo,

8✔

843

                                    minToSwapDest,

8✔

844

                                    transactionDeadline

8✔

845

8✔

846

8✔

847

6✔

848

                        return zapBridge

6✔

849

                            .populateTransaction

6✔

850

                            .swapAndRedeemAndRemove(

6✔

851

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

6✔

852

                                tokenArgs.tokenIndexFrom,

6✔

853

0,

6✔

854

                                amountFrom,

6✔

855

                                minToSwapOriginHighSlippage,

6✔

856

                                transactionDeadline,

6✔

857

                                tokenArgs.tokenIndexTo, //swapTokenIndex

6✔

858

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

6✔

859

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

6✔

860

6✔

861

6✔

862

64✔

863

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

106✔

864

                        return easyRedeemAndSwap(args.tokenFrom)

10✔

865

10✔

866

54✔

867

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

106✔

868

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

42✔

869

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

42✔

870

42✔

871

12✔

872

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

12✔

873

226✔

874

226✔

875

13✔

876

        private buildTerraBridgeTxn({

13✔

877

            addressTo,

8✔

878

            chainIdTo,

8✔

879

            amountFrom

8✔

880

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

8✔

881

            return Promise.resolve(new MsgExecuteContract(

8✔

882

                null,

8✔

883

                this.bridgeAddress,

8✔

884

8✔

885

                    deposit: {

8✔

886

                        to_address: toLower(addressTo),

8✔

887

                        chain_id:  `${chainIdTo}`,

8✔

888

                        denom:     "uusd"

8✔

889

8✔

890

},

8✔

891

                { uusd: amountFrom.toNumber() }

8✔

892

))

8✔

893

8✔

894

13✔

895

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

13✔

896

            let {tokenFrom, tokenTo, chainIdTo} = args;

548✔

897

548✔

898

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

548✔

899

548✔

900

            switch (tokenFrom.swapType) {

548✔

901

                case SwapType.ETH:

548✔

902

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

174✔

903

                    break;

174✔

904

                case SwapType.AVAX:

548✔

905

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

12✔

906

                    break;

12✔

907

                case SwapType.MOVR:

548✔

908

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

12✔

909

                    break;

12✔

910

                default:

548✔

911

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

350✔

912

548✔

913

548✔

914

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

548✔

915

548✔

916

            const

548✔

917

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

548✔

918

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

548✔

919

548✔

920

            return {

548✔

921

                fromChainTokens,

548✔

922

                toChainTokens,

548✔

923

                tokenFrom,

548✔

924

                tokenTo,

548✔

925

                tokenIndexFrom,

548✔

926

                tokenIndexTo

548✔

927

548✔

928

548✔

929

13✔

930

        private checkEasyArgs(

13✔

931

            args:            BridgeTransactionParams,

302✔

932

            zapBridge:       GenericZapBridgeContract,

302✔

933

            easyDeposits:    ID[],

302✔

934

            easyRedeems:     ID[],

302✔

935

            easyDepositETH?: ID[],

302✔

936

        ): EasyArgsCheck {

302✔

937

let

302✔

938

                castArgs = args as BridgeUtils.BridgeTxParams,

302✔

939

                isEasy: boolean = false,

302✔

940

                txn:    Promise<PopulatedTransaction>;

302✔

941

302✔

942

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

302✔

943

302✔

944

            switch (true) {

302✔

945

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

302✔

946

                    isEasy = true;

58✔

947

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

58✔

948

                    break;

58✔

949

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

302✔

950

                    isEasy = true;

30✔

951

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

30✔

952

                    break;

30✔

953

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

302✔

954

                    isEasy = true;

18✔

955

                    txn    =  zapBridge

18✔

956

                        .populateTransaction

18✔

957

                        .depositETH(

18✔

958

                            ...BridgeUtils.depositETHParams(castArgs),

18✔

959

                            BridgeUtils.overrides(args.amountFrom)

18✔

960

);

18✔

961

                    break;

18✔

962

302✔

963

302✔

964

            return {castArgs, isEasy, txn}

302✔

965

302✔

966

13✔

967

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

13✔

968

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

230✔

969

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

230✔

970

                if (!swapSupported) {

230✔

971

                    reject(errReason);

26✔

972

                    return

26✔

973

26✔

974

230✔

975

                resolve(true);

230✔

976

})

230✔

977

230✔

978

13✔

979

        private buildERC20ApproveArgs(args: {

13✔

980

            token:   Token | string,

190✔

981

            amount?: BigNumberish

190✔

982

        }): [ERC20.ApproveArgs, string] {

190✔

983

            const {token, amount} = args;

190✔

984

190✔

985

            let tokenAddr: string = instanceOfToken(token)

190✔

986

                ? token.address(this.chainId)

190✔

988

190✔

989

            let spender: string;

190✔

990

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

190✔

991

                spender = this.bridgeAddress;

22✔

992

            } else {

190✔

993

                spender = this.zapBridgeAddress;

168✔

994

168✔

995

190✔

996

            return [{

190✔

997

                spender,

190✔

998

                amount

190✔

999

            }, tokenAddr]

190✔

1000

190✔

1001

13✔

1002

        async getAllowanceForAddress(args: {

13✔

1003

            address: string,

10✔

1004

            token:   Token,

10✔

1005

        }): Promise<BigNumber> {

10✔

1006

            let { address, token } = args;

10✔

1007

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

10✔

1008

10✔

1009

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

10✔

1010

10✔

1011

13✔

1012

        private async resolveApproveFunc(

13✔

1013

            approveRes:    NeedsTokenApproveResult,

14✔

1014

            hasBalanceRes: Promise<CanBridgeResult>,

14✔

1015

            token:         Token

14✔

1016

        ): Promise<CanBridgeResult> {

14✔

1017

            const {needsApproval, currentAllowance} = approveRes;

14✔

1018

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

14✔

1019

14✔

1020

            return needsApproval

14✔

1022

                : hasBalanceRes

14✔

1023

14✔

1024

13✔

1025

        private async checkNeedsApprove({

13✔

1026

            address,

14✔

1027

            token,

14✔

1028

            amount=MAX_APPROVAL_AMOUNT.sub(1)

14✔

1029

        }: CheckCanBridgeParams): Promise<NeedsTokenApproveResult> {

14✔

1030

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

14✔

1031

14✔

1032

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

14✔

1033

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

14✔

1034

14✔

1035

13✔

1036

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

13✔

1037

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

14✔

1038

14✔

1039

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

14✔

1041

                /* c8 ignore next */

2✔

1042

                balanceFn = signer.getBalance;

2✔

1043

            } else if (address) {

14✔

1044

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

14✔

1045

14✔

1046

14✔

1047

            return this.resolveBalanceFunc(

14✔

1048

                balanceFn(),

14✔

1049

                amount,

14✔

1050

                token

14✔

1051

14✔

1052

14✔

1053

13✔

1054

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

13✔

1055

            const

14✔

1056

                {address, amount, token} = args,

14✔

1057

                tokenAddress = token.address(this.chainId);

14✔

1058

14✔

1059

            return this.resolveBalanceFunc(

14✔

1060

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

14✔

1061

                amount,

14✔

1062

                token

14✔

1063

14✔

1064

14✔

1065

13✔

1066

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

13✔

1067

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

6✔

1068

                .then(([res]) => {

6✔

1069

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

6✔

1070

6✔

1071

                    let ustBalance: BigNumber = Zero;

6✔

1072

6✔

1073

                    if (coin) {

6✔

1074

                        const {amount} = coin.toData();

6✔

1075

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

6✔

1076

                            ustBalance = BigNumber.from(amount);

6✔

1077

6✔

1078

6✔

1079

6✔

1080

                    return ustBalance

6✔

1081

})

6✔

1082

6✔

1083

            return this.resolveBalanceFunc(

6✔

1084

                balProm,

6✔

1085

                amount,

6✔

1086

                token

6✔

1087

6✔

1088

6✔

1089

13✔

1090

        private async resolveBalanceFunc(

13✔

1091

            prom:   Promise<BigNumber>,

34✔

1092

            amount: BigNumberish,

34✔

1093

            token:  Token

34✔

1094

        ): Promise<CanBridgeResult> {

34✔

1095

            return Promise.resolve(prom)

34✔

1096

                .then(balance => {

34✔

1097

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

34✔

1098

34✔

1099

                    if (balance.gte(amount)) {

34✔

1100

                        return {canBridge: true}

4✔

1101

4✔

1102

34✔

1103

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

34✔

1104

})

34✔

1105

                .catch(rejectPromise)

34✔

1106

34✔

1107

13✔

1108

13✔

1109

    const REQUIRED_CONFS: NumberMap = {

13✔

1110

        [ChainId.ETH]:       7,

13✔

1111

        [ChainId.OPTIMISM]:  1,

13✔

1112

        [ChainId.CRONOS]:    6,

13✔

1113

        [ChainId.BSC]:       14,

13✔

1114

        [ChainId.POLYGON]:   128,

13✔

1115

        [ChainId.FANTOM]:    5,

13✔

1116

        [ChainId.BOBA]:      1,

13✔

1117

        [ChainId.METIS]:     6,

13✔

1118

        [ChainId.MOONBEAM]:  21,

13✔

1119

        [ChainId.MOONRIVER]: 21,

13✔

1120

        [ChainId.ARBITRUM]:  40,

13✔

1121

        [ChainId.AVALANCHE]: 5,

13✔

1122

        [ChainId.TERRA]:     1,

13✔

1123

        [ChainId.AURORA]:    5,

13✔

1124

        [ChainId.HARMONY]:   1,

13✔

1125

};

13✔

1126

13✔

1127

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

13✔

1129

924✔

1131

924✔

1132

13✔

1133

    /* c8 ignore next */

2✔

1134

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

2✔

1135

        return TokenSwap.bridgeSwapSupported(args)

372✔

1136

372✔

1137

13✔

synapsecns / sdk / 2002109309

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

synapsecns / sdk / 2002109309

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