synapsecns/sdk | Build 2034486306 | 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 {id as makeKappa}         from "@ethersproject/hash";

2✔

49

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

2✔

50

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

2✔

51

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

2✔

52

2✔

53

import {

2✔

54

    Signer as EthersSigner

2✔

55

} from "@ethersproject/abstract-signer";

2✔

56

2✔

57

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

2✔

58

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 {

14✔

76

    export type CanBridgeResult = {

14✔

77

        canBridge:     boolean;

14✔

78

        reasonUnable?: string;

14✔

79

        amount?:       BigNumber;

14✔

80

14✔

81

14✔

82

    type NeedsTokenApproveResult = {

14✔

83

        needsApproval:     boolean;

14✔

84

        currentAllowance?: BigNumber;

14✔

85

14✔

86

14✔

87

    export type BridgeOutputEstimate = {

14✔

88

        amountToReceive: BigNumber,

14✔

89

        bridgeFee:       BigNumber,

14✔

90

14✔

91

14✔

92

/**

14✔

93

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

14✔

94

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

14✔

95

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

14✔

96

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

14✔

97

*/

14✔

98

    export interface BridgeParams {

14✔

99

        tokenFrom:   Token,

14✔

100

        tokenTo:     Token

14✔

101

        chainIdTo:   number,

14✔

102

        amountFrom?: BigNumber,

14✔

103

14✔

104

14✔

105

/**

14✔

106

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

14✔

107

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

14✔

108

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

14✔

109

     * on the destination chain.

14✔

110

*/

14✔

111

    export interface BridgeTransactionParams extends BridgeParams {

14✔

112

        amountFrom: BigNumber;

14✔

113

        amountTo:   BigNumber;

14✔

114

        addressTo?: string;

14✔

115

14✔

116

14✔

117

    type EasyArgsCheck = {

14✔

118

        isEasy:   boolean;

14✔

119

        castArgs: BridgeUtils.BridgeTxParams;

14✔

120

        txn?:     Promise<PopulatedTransaction>;

14✔

121

14✔

122

14✔

123

    type BridgeTokenArgs = {

14✔

124

        fromChainTokens: Token[];

14✔

125

        toChainTokens:   Token[];

14✔

126

        tokenFrom:       Token;

14✔

127

        tokenTo:         Token;

14✔

128

        tokenIndexFrom:  number;

14✔

129

        tokenIndexTo:    number;

14✔

130

14✔

131

14✔

132

    interface CheckCanBridgeParams {

14✔

133

        address?: string;

14✔

134

        signer?:  EthersSigner;

14✔

135

        token:    Token;

14✔

136

        amount:   BigNumberish;

14✔

137

14✔

138

14✔

139

    interface CanBridgeParams extends CheckCanBridgeParams {

14✔

140

        address: string;

14✔

141

14✔

142

14✔

143

/**

14✔

144

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

14✔

145

*/

14✔

146

    export class SynapseBridge {

14✔

147

        protected network: Networks.Network;

14✔

148

        protected chainId: number;

1,106✔

149

        protected _provider: Provider | LCDClient;

1,106✔

150

1,106✔

151

        private readonly bridgeAddress: string;

1,106✔

152

1,106✔

153

        private readonly bridgeInstance:           SynapseBridgeContract;

1,106✔

154

        private readonly networkZapBridgeInstance: GenericZapBridgeContract;

1,106✔

155

1,106✔

156

        private readonly isTerra:      boolean;

1,106✔

157

        private readonly isL2Zap:      boolean;

1,106✔

158

        private readonly isL2ETHChain: boolean;

1,106✔

159

1,106✔

160

        private readonly zapBridgeAddress: string;

1,106✔

161

1,106✔

162

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

1,106✔

163

1,106✔

164

        private readonly zapBridgeInstance: L1BridgeZapContract = SynapseEntities.L1BridgeZapContractInstance({

1,106✔

165

            chainId: ChainId.ETH,

1,106✔

166

            signerOrProvider: rpcProviderForChain(ChainId.ETH),

1,106✔

167

});

1,106✔

168

1,106✔

169

        readonly requiredConfirmations: number;

14✔

170

14✔

171

        constructor(args: {

14✔

172

            network: Networks.Network | number,

1,106✔

173

            provider?: Provider

1,106✔

174

        }) {

1,106✔

175

            let {network, provider} = args;

1,106✔

176

1,106✔

177

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

1,106✔

178

            this.chainId = this.network.chainId;

1,106✔

179

1,106✔

180

            this.requiredConfirmations = getRequiredConfirmationsForBridge(this.network);

1,106✔

181

1,106✔

182

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

1,106✔

183

            this.isL2Zap = this.network.zapIsL2BridgeZap;

1,106✔

184

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

1,106✔

185

1,106✔

186

            this._provider = provider ?? (this.isTerra

1,106✔

187

                ? terraRpcProvider(this.chainId)

1,040✔

188

                : rpcProviderForChain(this.chainId)

1,040✔

189

);

1,106✔

190

1,106✔

191

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

1,106✔

192

1,106✔

193

            this.bridgeAddress    = contractAddrs.bridgeAddress;

1,106✔

194

            this.zapBridgeAddress = contractAddrs.bridgeZapAddress;

1,106✔

195

1,106✔

196

            if (!this.isTerra) {

1,106✔

197

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

1,086✔

198

1,086✔

199

            this.bridgeInstance = SynapseEntities.SynapseBridgeContractInstance(factoryParams);

1,086✔

200

1,086✔

201

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

1,086✔

202

                this.networkZapBridgeInstance = SynapseEntities.GenericZapBridgeContractInstance(factoryParams);

1,086✔

203

1,086✔

204

1,086✔

205

1,106✔

206

14✔

207

        private get provider(): Provider {

14✔

208

            return this._provider as Provider

380✔

209

380✔

210

14✔

211

        private get terraProvider(): LCDClient {

14✔

212

            return this._provider as LCDClient

6✔

213

6✔

214

14✔

215

        bridgeVersion(): Promise<BigNumber> {

14✔

216

            if (this.isTerra) {

30✔

217

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

2✔

218

2✔

219

28✔

220

            return this.bridgeInstance.bridgeVersion()

28✔

221

28✔

222

14✔

223

        WETH_ADDRESS(): Promise<string> {

14✔

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

14✔

231

        kappaExists(kappa: string): Promise<boolean> {

14✔

232

            return this.bridgeInstance.kappaExists(kappa)

4✔

233

4✔

234

14✔

235

/**

14✔

236

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

14✔

237

         * is supported.

14✔

238

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

14✔

239

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

14✔

240

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

14✔

241

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

14✔

242

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

14✔

243

*/

14✔

244

        swapSupported(args: {

14✔

245

            tokenFrom: Token,

434✔

246

            tokenTo:   Token

434✔

247

            chainIdTo: number,

434✔

248

        }): [boolean, string] {

434✔

249

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

434✔

250

434✔

251

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

434✔

252

434✔

253

14✔

254

/**

14✔

255

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

14✔

256

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

14✔

257

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

14✔

258

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

14✔

259

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

14✔

260

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

14✔

261

*/

14✔

262

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

14✔

263

            return this.checkSwapSupported(args)

272✔

264

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

272✔

265

                .catch(rejectPromise)

272✔

266

272✔

267

14✔

268

/**

14✔

269

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

14✔

270

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

14✔

271

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

14✔

272

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

14✔

273

         * of web3/ethers/etc.

14✔

274

*/

14✔

275

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

14✔

276

            const

424✔

277

                {addressTo} = args,

424✔

278

                tokenArgs = this.makeBridgeTokenArgs(args),

424✔

279

                {tokenFrom, tokenTo} = tokenArgs;

424✔

280

424✔

281

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

424✔

282

                return rejectPromise(

4✔

283

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

4✔

284

4✔

285

4✔

286

424✔

287

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

424✔

288

                return rejectPromise(

2✔

289

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

2✔

290

2✔

291

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

424✔

292

                return rejectPromise(

2✔

293

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

2✔

294

2✔

295

2✔

296

396✔

297

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

396✔

298

396✔

299

            let newTxn: Promise<PopulatedTransaction>;

396✔

300

396✔

301

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

424✔

302

                if (this.isTerra) {

30✔

303

                    return this.buildTerraBridgeTxn(args)

8✔

304

8✔

305

22✔

306

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

22✔

307

                    args.chainIdTo,

22✔

308

                    Tokens.UST.address(this.chainId),

22✔

309

                    args.amountFrom

22✔

310

];

22✔

311

22✔

312

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

30✔

313

                    newTxn = this.bridgeInstance

8✔

314

                        .populateTransaction

8✔

315

                        .redeemV2(

8✔

316

                            bech32.decode(args.addressTo).words,

8✔

317

                            ...redeemArgs

8✔

318

);

8✔

319

                } else {

30✔

320

                    newTxn = this.bridgeInstance

14✔

321

                        .populateTransaction

14✔

322

                        .redeem(

14✔

323

                            args.addressTo,

14✔

324

                            ...redeemArgs

14✔

325

);

14✔

326

14✔

327

            } else {

424✔

328

                newTxn = this.chainId === ChainId.ETH

366✔

329

                ? this.buildETHMainnetBridgeTxn(args, tokenArgs)

366✔

330

                : this.buildL2BridgeTxn(args, tokenArgs);

366✔

331

366✔

332

376✔

333

            return newTxn

376✔

334

                .then(txn =>

376✔

335

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

376✔

336

376✔

337

376✔

338

14✔

339

/**

14✔

340

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

14✔

341

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

14✔

342

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

14✔

343

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

14✔

344

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

14✔

345

         * @return {Promise<ContractTransaction>}

14✔

346

*/

14✔

347

        async executeBridgeTokenTransaction(

14✔

348

            args:       BridgeTransactionParams,

10✔

349

            signer:     EthersSigner | TerraWallet | GenericSigner,

10✔

350

            callStatic: boolean=false

10✔

351

        ): Promise<ContractTransaction | BlockTxBroadcastResult> {

10✔

352

            try {

10✔

353

                await this.checkSwapSupported(args);

10✔

355

                /* c8 ignore next 2 */

2✔

356

                return rejectPromise(e);

2✔

357

2✔

358

10✔

359

            const {tokenFrom, amountFrom, addressTo} = args;

10✔

360

10✔

361

            let txSigner: GenericSigner;

10✔

362

            let signerAddress: string;

10✔

363

10✔

364

            if (signer instanceof TerraWallet) {

10✔

365

                txSigner = new TerraSignerWrapper(signer);

2✔

366

            } else {

10✔

367

                txSigner = signer;

8✔

368

8✔

369

10✔

370

            signerAddress = await txSigner.getAddress();

10✔

372

10✔

373

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

10✔

374

10✔

375

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

10✔

382

10✔

383

            return this.checkCanBridge(checkArgs)

10✔

384

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

10✔

385

                    if (!canBridge) {

10✔

386

                        const rejection = new CanBridgeError(reasonUnable, amount);

10✔

387

                        return rejectPromise(rejection)

10✔

388

10✔

389

10✔

390

                    return this.buildBridgeTokenTransaction(args)

10✔

391

                        .then(sendTxn)

10✔

392

                        .catch(rejectPromise)

10✔

393

})

10✔

394

10✔

395

14✔

396

/**

14✔

397

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

14✔

398

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

14✔

399

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

14✔

400

         * framework so they can ultimately send the transaction.

14✔

401

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

14✔

402

         * @param {Object} args

14✔

403

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

14✔

404

         * to the bridge on the source chain.

14✔

405

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

14✔

406

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

14✔

407

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

14✔

408

         * of web3/ethers/etc.

14✔

409

*/

14✔

410

        async buildApproveTransaction(args: {

14✔

411

            token:   Token | string,

220✔

412

            amount?: BigNumberish

220✔

413

        }): Promise<PopulatedTransaction> {

220✔

414

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

220✔

415

220✔

416

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

220✔

417

220✔

418

14✔

419

/**

14✔

420

         * Builds and executes an ERC20 Approve call,

14✔

421

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

14✔

422

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

14✔

423

         * framework so they can ultimately send the transaction.

14✔

424

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

14✔

425

         * @param {Object} args

14✔

426

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

14✔

427

         * to the bridge on the source chain.

14✔

428

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

14✔

429

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

14✔

430

         * transaction.

14✔

431

*/

14✔

432

        async executeApproveTransaction(

14✔

433

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

2✔

434

            signer:     EthersSigner,

2✔

435

        ): Promise<ContractTransaction> {

2✔

436

            const

2✔

437

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

2✔

438

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

2✔

439

2✔

440

            return ERC20.approve(approveArgs, tokenParams, signer)

2✔

441

2✔

442

14✔

443

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

14✔

444

            const {token, signer, address} = args;

34✔

445

34✔

446

            let signerAddress: string;

34✔

448

                /* c8 ignore next */

2✔

449

                signerAddress = await signer.getAddress();

2✔

450

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

34✔

451

                signerAddress = address;

34✔

452

34✔

453

34✔

454

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

34✔

455

            const

34✔

456

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

34✔

457

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

34✔

458

34✔

459

            if (isTerraTx) {

34✔

460

                return this.checkTerraUSTBalance(checkArgs);

6✔

461

6✔

462

34✔

463

            let hasBalanceRes: Promise<CanBridgeResult> = isGasTokenTransfer

34✔

464

                ? this.checkGasTokenBalance(checkArgs)

34✔

465

                : this.checkERC20Balance(checkArgs);

34✔

466

34✔

467

            if (isGasTokenTransfer) {

34✔

468

                return hasBalanceRes

14✔

469

14✔

470

14✔

471

            return this.checkNeedsApprove(checkArgs)

14✔

472

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

14✔

473

                    .catch(rejectPromise)

14✔

474

14✔

475

14✔

476

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

14✔

477

            let {chainIdTo, amountFrom} = args;

240✔

478

240✔

479

            let toChainZap: GenericZapBridgeContract;

240✔

480

240✔

481

            if (chainIdTo !== ChainId.TERRA) {

240✔

482

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

232✔

483

                toChainZap = SynapseEntities.GenericZapBridgeContractInstance(toChainZapParams);

232✔

484

232✔

485

240✔

486

            const {

240✔

487

                tokenFrom, tokenTo,

240✔

488

                tokenIndexFrom, tokenIndexTo,

240✔

489

                fromChainTokens

240✔

490

            } = this.makeBridgeTokenArgs(args);

240✔

491

240✔

492

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

240✔

493

240✔

494

            const

240✔

495

                TEN = BigNumber.from(10),

240✔

496

                fromCoinDecimals = tokenFrom.decimals(this.chainId);

240✔

497

240✔

498

            const

240✔

499

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

240✔

500

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

240✔

501

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

240✔

502

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

240✔

503

240✔

504

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

240✔

505

                intermediateTokenAddr,

240✔

506

                chainIdTo,

240✔

507

                amountFromFixedDecimals

240✔

508

);

240✔

509

240✔

510

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

240✔

511

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

480✔

512

240✔

513

            const

240✔

514

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

240✔

515

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

240✔

516

240✔

517

            let amountToReceive_from_prom: Promise<BigNumber>;

240✔

518

240✔

519

            if (amountFrom.isZero()) {

240✔

520

                amountToReceive_from_prom = Promise.resolve(Zero);

8✔

521

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

240✔

522

                amountToReceive_from_prom = Promise.resolve(amountFromFixedDecimals);

138✔

523

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

232✔

524

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

10✔

525

                    tokenFrom.isEqual(t) ? amountFrom : Zero

30✔

526

);

10✔

527

10✔

528

                amountToReceive_from_prom = this.zapBridgeInstance.calculateTokenAmount(

10✔

529

                    liquidityAmounts,

10✔

530

                    true

10✔

531

);

10✔

532

            } else {

94✔

533

                amountToReceive_from_prom = BridgeUtils.calculateSwapL2Zap(

84✔

534

                    this.networkZapBridgeInstance,

84✔

535

                    intermediateToken.address(this.chainId),

84✔

536

                    tokenIndexFrom,

84✔

537

0,

84✔

538

                    amountFrom

84✔

539

);

84✔

540

84✔

541

240✔

542

            let amountToReceive_from = await amountToReceive_from_prom;

240✔

543

240✔

544

            let bridgeFee: BigNumber;

240✔

545

240✔

546

            try { /* c8 ignore start */

2✔

547

                bridgeFee = await bridgeFeeRequest;

2✔

548

            } catch (e) {

2✔

549

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

2✔

550

                return rejectPromise(e)

2✔

551

            } /* c8 ignore stop */

2✔

552

240✔

553

            amountToReceive_from = BridgeUtils.subBigNumSafe(amountToReceive_from, bridgeFee);

240✔

554

240✔

555

            let amountToReceive_to_prom: Promise<BigNumber>;

240✔

556

240✔

557

            if (amountToReceive_from.isZero()) {

240✔

558

                amountToReceive_to_prom = Promise.resolve(Zero);

10✔

559

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

240✔

560

                amountToReceive_to_prom = Promise.resolve(amountToReceive_from);

136✔

561

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

230✔

562

                amountToReceive_to_prom =

10✔

563

                    (toChainZap as L1BridgeZapContract).calculateRemoveLiquidityOneToken(

10✔

564

                        amountToReceive_from,

10✔

565

                        tokenIndexTo

10✔

566

);

10✔

567

            } else {

94✔

568

                amountToReceive_to_prom = BridgeUtils.calculateSwapL2Zap(

84✔

569

                    toChainZap,

84✔

570

                    intermediateToken.address(chainIdTo),

84✔

571

0,

84✔

572

                    tokenIndexTo,

84✔

573

                    amountToReceive_from

84✔

574

);

84✔

575

84✔

576

240✔

577

            let amountToReceive: BigNumber;

240✔

578

240✔

579

            try { /* c8 ignore start */

2✔

580

                amountToReceive = await Promise.resolve(amountToReceive_to_prom)

2✔

581

            } catch (err) {

2✔

582

                return rejectPromise(err)

2✔

583

            } /* c8 ignore stop */

2✔

584

240✔

585

            let fee = bridgeFee;

240✔

586

            if (fee) {

240✔

587

                fee = fee.mul(bridgeFeeMultiplier);

240✔

591

240✔

592

            return {

240✔

593

                amountToReceive,

240✔

594

                bridgeFee: fee

240✔

595

240✔

596

240✔

597

14✔

598

        private buildETHMainnetBridgeTxn(

14✔

599

            args:      BridgeTransactionParams,

84✔

600

            tokenArgs: BridgeTokenArgs

84✔

601

        ): Promise<PopulatedTransaction> {

84✔

602

            const

84✔

603

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

84✔

604

                zapBridge = SynapseEntities.L1BridgeZapContractInstance({

84✔

605

                    chainId: this.chainId,

84✔

606

                    signerOrProvider: this.provider

84✔

607

});

84✔

608

84✔

609

let

84✔

610

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

84✔

611

                easyDeposits:   ID[] = [

84✔

612

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

84✔

613

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

84✔

614

],

84✔

615

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

84✔

616

84✔

617

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

84✔

618

            if (isEasy && txn) {

84✔

619

                return txn

34✔

620

34✔

621

84✔

622

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

84✔

623

                    args.tokenFrom.isEqual(t)

98✔

624

                        ? amountFrom

98✔

625

                        : Zero

98✔

626

);

84✔

627

84✔

628

            const {

84✔

629

                transactionDeadline,

84✔

630

                bridgeTransactionDeadline,

84✔

631

                minToSwapDestFromOrigin,

84✔

632

                minToSwapDest,

84✔

633

                minToSwapOriginMediumSlippage,

84✔

634

                minToSwapDestFromOriginMediumSlippage,

84✔

635

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

84✔

636

84✔

637

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

84✔

638

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

8✔

639

                    const bridgeDepositArgs = BridgeUtils.makeEasyParams(

4✔

640

                        args as BridgeUtils.BridgeTxParams,

4✔

641

                        this.chainId,

4✔

642

                        args.tokenTo

4✔

643

);

4✔

644

4✔

645

                    return zapBridge

4✔

646

                        .populateTransaction

4✔

647

                        .deposit(...bridgeDepositArgs)

4✔

648

                } else {

4✔

649

                    return zapBridge.populateTransaction.zapAndDeposit(

4✔

650

                        addressTo,

4✔

651

                        chainIdTo,

4✔

652

                        Tokens.NUSD.address(this.chainId),

4✔

653

                        liquidityAmounts,

4✔

654

                        minToSwapDest,

4✔

655

                        transactionDeadline,

4✔

656

4✔

657

4✔

658

8✔

659

84✔

660

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

84✔

661

                return zapBridge.populateTransaction.depositETHAndSwap(

24✔

662

                    ...BridgeUtils.depositETHParams(castArgs),

24✔

663

                    0, // nusd tokenindex,

24✔

664

                    tokenArgs.tokenIndexTo,

24✔

665

                    minToSwapDestFromOrigin, // minDy

24✔

666

                    bridgeTransactionDeadline,

24✔

667

                    BridgeUtils.overrides(amountFrom)

24✔

668

24✔

669

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

46✔

670

                return zapBridge.populateTransaction.depositAndSwap(

6✔

671

                    addressTo,

6✔

672

                    chainIdTo,

6✔

673

                    Tokens.NUSD.address(this.chainId),

6✔

674

                    amountFrom,

6✔

675

0,

6✔

676

                    tokenArgs.tokenIndexTo,

6✔

677

                    minToSwapDestFromOriginMediumSlippage,

6✔

678

                    bridgeTransactionDeadline

6✔

679

6✔

680

6✔

681

10✔

682

            return zapBridge.populateTransaction.zapAndDepositAndSwap(

10✔

683

                addressTo,

10✔

684

                chainIdTo,

10✔

685

                Tokens.NUSD.address(this.chainId),

10✔

686

                liquidityAmounts,

10✔

687

                minToSwapOriginMediumSlippage, // minToSwapOrigin,

10✔

688

                transactionDeadline,

10✔

689

0,

10✔

690

                tokenArgs.tokenIndexTo,

10✔

691

                minToSwapDestFromOriginMediumSlippage, //, minToSwapDestFromOrigin, // minDy

10✔

692

                bridgeTransactionDeadline,

10✔

693

10✔

694

10✔

695

14✔

696

        private buildL2BridgeTxn(

14✔

697

            args: BridgeTransactionParams,

282✔

698

            tokenArgs: BridgeTokenArgs

282✔

699

        ): Promise<PopulatedTransaction> {

282✔

700

            const

282✔

701

                {chainIdTo, amountFrom, amountTo} = args,

282✔

702

                zapBridge = SynapseEntities.L2BridgeZapContractInstance({

282✔

703

                    chainId: this.chainId,

282✔

704

                    signerOrProvider: this.provider

282✔

705

});

282✔

706

282✔

707

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

282✔

709

                : tokenArgs.tokenFrom;

282✔

710

282✔

711

let

282✔

712

                easyDeposits:   ID[] = [],

282✔

713

                easyDepositETH: ID[] = [],

282✔

714

                easyRedeems:    ID[] = [

282✔

715

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

282✔

716

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

282✔

717

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

282✔

718

];

282✔

719

282✔

720

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

282✔

721

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

1,410✔

722

1,410✔

723

let

1,410✔

724

                    hasAltChain = typeof altChainId !== 'undefined',

1,410✔

725

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

1,410✔

726

1,410✔

727

                if (this.chainId === chainId) {

1,410✔

728

                    depositEth

140✔

729

                        ? easyDepositETH.push(...tokenHashes)

140✔

730

                        : easyDeposits.push(...tokenHashes);

140✔

731

                } else {

1,410✔

732

                    if (hasAltChain) {

1,270✔

733

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

484✔

734

                    } else {

1,270✔

735

                        easyRedeems.push(...tokenHashes);

786✔

736

786✔

737

1,270✔

738

})

282✔

739

282✔

740

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

282✔

741

            if (isEasy && txn) {

282✔

742

                return txn

90✔

743

90✔

744

282✔

745

            const {

282✔

746

                transactionDeadline,

282✔

747

                bridgeTransactionDeadline,

282✔

748

                minToSwapOriginHighSlippage,

282✔

749

                minToSwapDestFromOriginHighSlippage,

282✔

750

                minToSwapDest,

282✔

751

            } = BridgeUtils.getSlippages(amountFrom, amountTo);

282✔

752

282✔

753

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

282✔

754

                zapBridge

12✔

755

                    .populateTransaction

12✔

756

                    .redeemAndSwap(

12✔

757

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

12✔

758

0,

12✔

759

                        tokenArgs.tokenIndexTo,

12✔

760

                        minToSwapDest,

12✔

761

                        transactionDeadline,

12✔

762

282✔

763

282✔

764

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

282✔

765

                let populateFn = swapETH

22✔

766

                    ? zapBridge.populateTransaction.swapETHAndRedeem

22✔

767

                    : zapBridge.populateTransaction.swapAndRedeem

22✔

768

22✔

769

                return populateFn(

22✔

770

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

22✔

771

                    tokenArgs.tokenIndexFrom,

22✔

772

0,

22✔

773

                    amountFrom,

22✔

774

                    minToSwapOriginHighSlippage, // minToSwapOrigin, // minToSwapOriginHighSlippage,

22✔

775

                    transactionDeadline,

22✔

776

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

22✔

777

22✔

778

22✔

779

282✔

780

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

282✔

781

                let populateFn = swapETH

80✔

782

                    ? zapBridge.populateTransaction.swapETHAndRedeemAndSwap

80✔

783

                    : zapBridge.populateTransaction.swapAndRedeemAndSwap

80✔

784

80✔

785

                return populateFn(

80✔

786

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

80✔

787

                    tokenArgs.tokenIndexFrom,

80✔

788

0,

80✔

789

                    amountFrom,

80✔

790

                    minToSwapOriginHighSlippage,

80✔

791

                    transactionDeadline,

80✔

792

0,

80✔

793

                    tokenArgs.tokenIndexTo,

80✔

794

                    minToSwapDestFromOriginHighSlippage, // swapMinAmount

80✔

795

                    bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

80✔

796

                    swapETH ? BridgeUtils.overrides(amountFrom) : {}

80✔

797

80✔

798

80✔

799

282✔

800

            switch (tokenSwitch(args.tokenTo)) {

282✔

801

                case Tokens.NUSD:

282✔

802

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

32✔

803

                        return zapBridge

8✔

804

                            .populateTransaction

8✔

805

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

8✔

806

8✔

807

32✔

808

                    return zapBridge

32✔

809

                        .populateTransaction

32✔

810

                        .swapAndRedeem(

32✔

811

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

32✔

812

                            tokenArgs.tokenIndexFrom,

32✔

813

0,

32✔

814

                            amountFrom,

32✔

815

                            minToSwapOriginHighSlippage,

32✔

816

                            transactionDeadline

32✔

817

32✔

818

                case Tokens.GMX:

282✔

819

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

8✔

820

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

8✔

821

8✔

822

                    return this.chainId === ChainId.ARBITRUM

8✔

823

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

8✔

824

                        : this.bridgeInstance

8✔

825

                            .populateTransaction

4✔

826

                            .redeem(

4✔

827

                                addrTo,

4✔

828

                                chainTo,

4✔

829

                                Tokens.GMX.wrapperAddress(this.chainId),

4✔

830

                                amount

4✔

831

8✔

832

                default:

282✔

833

                    if (chainIdTo === ChainId.ETH) {

142✔

834

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

50✔

835

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

32✔

836

                                return zapBridge

10✔

837

                                    .populateTransaction

10✔

838

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

10✔

839

                            } else {

32✔

840

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

22✔

841

                                return easySwapAndRedeem(Tokens.NETH, useSwapETH)

22✔

842

22✔

843

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

50✔

844

                            return zapBridge

8✔

845

                                .populateTransaction

8✔

846

                                .redeemAndRemove(

8✔

847

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

8✔

848

                                    amountFrom,

8✔

849

                                    tokenArgs.tokenIndexTo,

8✔

850

                                    minToSwapDest,

8✔

851

                                    transactionDeadline

8✔

852

8✔

853

8✔

854

10✔

855

                        return zapBridge

10✔

856

                            .populateTransaction

10✔

857

                            .swapAndRedeemAndRemove(

10✔

858

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

10✔

859

                                tokenArgs.tokenIndexFrom,

10✔

860

0,

10✔

861

                                amountFrom,

10✔

862

                                minToSwapOriginHighSlippage,

10✔

863

                                transactionDeadline,

10✔

864

                                tokenArgs.tokenIndexTo, //swapTokenIndex

10✔

865

                                minToSwapDestFromOriginHighSlippage, // swapMinAmount

10✔

866

                                bridgeTransactionDeadline, // toSwapDeadline, // swapDeadline

10✔

867

10✔

868

10✔

869

142✔

870

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

142✔

871

                        return easyRedeemAndSwap(args.tokenFrom)

12✔

872

12✔

873

80✔

874

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

142✔

875

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

56✔

876

                        return easySwapAndRedeemAndSwap(Tokens.NETH, useSwapETH)

56✔

877

56✔

878

134✔

879

                    return easySwapAndRedeemAndSwap(Tokens.NUSD)

134✔

880

282✔

881

282✔

882

14✔

883

        private buildTerraBridgeTxn({

14✔

884

            addressTo,

8✔

885

            chainIdTo,

8✔

886

            amountFrom

8✔

887

        }: BridgeTransactionParams): Promise<MsgExecuteContract> {

8✔

888

            return Promise.resolve(new MsgExecuteContract(

8✔

889

                null,

8✔

890

                this.bridgeAddress,

8✔

891

8✔

892

                    deposit: {

8✔

893

                        to_address: toLower(addressTo),

8✔

894

                        chain_id:  `${chainIdTo}`,

8✔

895

                        denom:     "uusd"

8✔

896

8✔

897

},

8✔

898

                { uusd: amountFrom.toNumber() }

8✔

899

))

8✔

900

8✔

901

14✔

902

        private makeBridgeTokenArgs(args: BridgeParams): BridgeTokenArgs {

14✔

903

            let {tokenFrom, tokenTo, chainIdTo} = args;

664✔

904

664✔

905

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

664✔

906

664✔

907

            switch (tokenFrom.swapType) {

664✔

908

                case SwapType.ETH:

664✔

909

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

216✔

910

                    break;

216✔

911

                case SwapType.AVAX:

664✔

912

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

12✔

913

                    break;

12✔

914

                case SwapType.MOVR:

664✔

915

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

12✔

916

                    break;

12✔

917

                default:

664✔

918

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

424✔

919

664✔

920

664✔

921

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

664✔

922

664✔

923

            const

664✔

924

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

664✔

925

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

664✔

926

664✔

927

            return {

664✔

928

                fromChainTokens,

664✔

929

                toChainTokens,

664✔

930

                tokenFrom,

664✔

931

                tokenTo,

664✔

932

                tokenIndexFrom,

664✔

933

                tokenIndexTo

664✔

934

664✔

935

664✔

936

14✔

937

        private checkEasyArgs(

14✔

938

            args:            BridgeTransactionParams,

366✔

939

            zapBridge:       GenericZapBridgeContract,

366✔

940

            easyDeposits:    ID[],

366✔

941

            easyRedeems:     ID[],

366✔

942

            easyDepositETH?: ID[],

366✔

943

        ): EasyArgsCheck {

366✔

944

let

366✔

945

                castArgs = args as BridgeUtils.BridgeTxParams,

366✔

946

                isEasy: boolean = false,

366✔

947

                txn:    Promise<PopulatedTransaction>;

366✔

948

366✔

949

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

366✔

950

366✔

951

            switch (true) {

366✔

952

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

366✔

953

                    isEasy = true;

74✔

954

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

74✔

955

                    break;

74✔

956

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

366✔

957

                    isEasy = true;

32✔

958

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

32✔

959

                    break;

32✔

960

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

366✔

961

                    isEasy = true;

18✔

962

                    txn    =  zapBridge

18✔

963

                        .populateTransaction

18✔

964

                        .depositETH(

18✔

965

                            ...BridgeUtils.depositETHParams(castArgs),

18✔

966

                            BridgeUtils.overrides(args.amountFrom)

18✔

967

);

18✔

968

                    break;

18✔

969

366✔

970

366✔

971

            return {castArgs, isEasy, txn}

366✔

972

366✔

973

14✔

974

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

14✔

975

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

282✔

976

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

282✔

977

                if (!swapSupported) {

282✔

978

                    reject(errReason);

32✔

979

                    return

32✔

980

32✔

981

282✔

982

                resolve(true);

282✔

983

})

282✔

984

282✔

985

14✔

986

        private buildERC20ApproveArgs(args: {

14✔

987

            token:   Token | string,

236✔

988

            amount?: BigNumberish

236✔

989

        }): [ERC20.ApproveArgs, string] {

236✔

990

            const {token, amount} = args;

236✔

991

236✔

992

            let tokenAddr: string = instanceOfToken(token)

236✔

993

                ? token.address(this.chainId)

236✔

995

236✔

996

            let spender: string;

236✔

997

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

236✔

998

                spender = this.bridgeAddress;

22✔

999

            } else {

236✔

1000

                spender = this.zapBridgeAddress;

214✔

1001

214✔

1002

236✔

1003

            return [{

236✔

1004

                spender,

236✔

1005

                amount

236✔

1006

            }, tokenAddr]

236✔

1007

236✔

1008

14✔

1009

        async getAllowanceForAddress(args: {

14✔

1010

            address: string,

10✔

1011

            token:   Token,

10✔

1012

        }): Promise<BigNumber> {

10✔

1013

            let { address, token } = args;

10✔

1014

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

10✔

1015

10✔

1016

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

10✔

1017

10✔

1018

14✔

1019

        private async resolveApproveFunc(

14✔

1020

            approveRes:    NeedsTokenApproveResult,

14✔

1021

            hasBalanceRes: Promise<CanBridgeResult>,

14✔

1022

            token:         Token

14✔

1023

        ): Promise<CanBridgeResult> {

14✔

1024

            const {needsApproval, currentAllowance} = approveRes;

14✔

1025

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

14✔

1026

14✔

1027

            return needsApproval

14✔

1029

                : hasBalanceRes

14✔

1030

14✔

1031

14✔

1032

        private async checkNeedsApprove({

14✔

1033

            address,

14✔

1034

            token,

14✔

1035

            amount=MAX_APPROVAL_AMOUNT.sub(1)

14✔

1036

        }: CheckCanBridgeParams): Promise<NeedsTokenApproveResult> {

14✔

1037

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

14✔

1038

14✔

1039

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

14✔

1040

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

14✔

1041

14✔

1042

14✔

1043

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

14✔

1044

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

14✔

1045

14✔

1046

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

14✔

1048

                /* c8 ignore next */

2✔

1049

                balanceFn = signer.getBalance;

2✔

1050

            } else if (address) {

14✔

1051

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

14✔

1052

14✔

1053

14✔

1054

            return this.resolveBalanceFunc(

14✔

1055

                balanceFn(),

14✔

1056

                amount,

14✔

1057

                token

14✔

1058

14✔

1059

14✔

1060

14✔

1061

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

14✔

1062

            const

14✔

1063

                {address, amount, token} = args,

14✔

1064

                tokenAddress = token.address(this.chainId);

14✔

1065

14✔

1066

            return this.resolveBalanceFunc(

14✔

1067

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

14✔

1068

                amount,

14✔

1069

                token

14✔

1070

14✔

1071

14✔

1072

14✔

1073

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

14✔

1074

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

6✔

1075

                .then(([res]) => {

6✔

1076

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

6✔

1077

6✔

1078

                    let ustBalance: BigNumber = Zero;

6✔

1079

6✔

1080

                    if (coin) {

6✔

1081

                        const {amount} = coin.toData();

6✔

1082

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

6✔

1083

                            ustBalance = BigNumber.from(amount);

6✔

1084

6✔

1085

6✔

1086

6✔

1087

                    return ustBalance

6✔

1088

})

6✔

1089

6✔

1090

            return this.resolveBalanceFunc(

6✔

1091

                balProm,

6✔

1092

                amount,

6✔

1093

                token

6✔

1094

6✔

1095

6✔

1096

14✔

1097

        private async resolveBalanceFunc(

14✔

1098

            prom:   Promise<BigNumber>,

34✔

1099

            amount: BigNumberish,

34✔

1100

            token:  Token

34✔

1101

        ): Promise<CanBridgeResult> {

34✔

1102

            return Promise.resolve(prom)

34✔

1103

                .then(balance => {

34✔

1104

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

34✔

1105

34✔

1106

                    if (balance.gte(amount)) {

34✔

1107

                        return {canBridge: true}

4✔

1108

4✔

1109

34✔

1110

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

34✔

1111

})

34✔

1112

                .catch(rejectPromise)

34✔

1113

34✔

1114

14✔

1115

14✔

1116

    const REQUIRED_CONFS: NumberMap = {

14✔

1117

        [ChainId.ETH]:       7,

14✔

1118

        [ChainId.OPTIMISM]:  1,

14✔

1119

        [ChainId.CRONOS]:    6,

14✔

1120

        [ChainId.BSC]:       14,

14✔

1121

        [ChainId.POLYGON]:   128,

14✔

1122

        [ChainId.FANTOM]:    5,

14✔

1123

        [ChainId.BOBA]:      1,

14✔

1124

        [ChainId.METIS]:     6,

14✔

1125

        [ChainId.MOONBEAM]:  21,

14✔

1126

        [ChainId.MOONRIVER]: 21,

14✔

1127

        [ChainId.ARBITRUM]:  40,

14✔

1128

        [ChainId.AVALANCHE]: 5,

14✔

1129

        [ChainId.TERRA]:     1,

14✔

1130

        [ChainId.AURORA]:    5,

14✔

1131

        [ChainId.HARMONY]:   1,

14✔

1132

        [ChainId.AURORA]:    5,

14✔

1133

};

14✔

1134

14✔

1135

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

14✔

1136

        let chainId: number = network instanceof Networks.Network ? network.chainId : network;

1,112✔

1137

1,112✔

1138

        if (chainId in REQUIRED_CONFS) {

1,112✔

1139

            return REQUIRED_CONFS[chainId]

1,110✔

1140

1,110✔

1141

2✔

1142

        return null

2✔

1143

2✔

1144

14✔

1145

    /* c8 ignore next */

2✔

1146

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

2✔

1147

        return TokenSwap.bridgeSwapSupported(args)

434✔

1148

434✔

1149

14✔

1150

    export interface BridgeTransactionCompleteParams {

14✔

1151

        chainIdTo:                number;

14✔

1152

        transactionHashChainFrom: string;

14✔

1153

14✔

1154

14✔

1155

    export function checkBridgeTransactionComplete(args: BridgeTransactionCompleteParams): Promise<boolean> {

14✔

1156

        const

4✔

1157

            {chainIdTo, transactionHashChainFrom} = args,

4✔

1158

            kappa = makeKappa(transactionHashChainFrom),

4✔

1159

            bridgeInstance = new SynapseBridge({network: chainIdTo});

4✔

1160

4✔

1161

        return bridgeInstance.kappaExists(kappa)

4✔

1162

            .then(res => res)

4✔

1163

            .catch(rejectPromise)

4✔

1164

4✔

1165

14✔

synapsecns / sdk / 2034486306

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

synapsecns / sdk / 2034486306

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