synapsecns/sdk | Build 2586660196 | src/tokenswap.ts | Coveralls

1

import {

2✔

2

    isNil,

2✔

3

    isNull,

2✔

4

    isEmpty,

2✔

5

    isUndefined

2✔

6

} from "lodash-es";

2✔

7

2✔

8

import {

2✔

9

    ChainId, ChainIdTypeMap,

2✔

10

    supportedChainIds

2✔

11

} from "@chainid";

2✔

12

import {Networks}      from "@networks";

2✔

13

import type {Token}    from "@token";

2✔

14

import {Tokens}        from "@tokens";

2✔

15

import {SwapPools}     from "@swappools";

2✔

16

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

2✔

17

import {

2✔

18

    GasOptions,

2✔

19

    populateGasOptions,

2✔

20

    makeTransactionGasOverrides

2✔

21

} from "@common/gasoptions";

2✔

22

2✔

23

import {BridgeConfigV3ContractInstance} from "@entities";

2✔

24

2✔

25

import {

2✔

26

    SwapContract,

2✔

27

    SwapFactory,

2✔

28

    type BridgeConfigV3Contract

2✔

29

} from "@contracts";

2✔

30

2✔

31

import {SwapType, mintBurnSwapTypes} from "@internal/swaptype";

2✔

32

import {rpcProviderForChain} from "@internal/rpcproviders";

2✔

33

2✔

34

import {

2✔

35

    BigNumber,

2✔

36

    type BigNumberish

2✔

37

} from "@ethersproject/bignumber";

2✔

38

2✔

39

import type {Signer} from "@ethersproject/abstract-signer";

2✔

40

import {

2✔

41

    Overrides,

2✔

42

    type ContractTransaction,

2✔

43

    type PopulatedTransaction,

2✔

44

} from "@ethersproject/contracts";

2✔

45

2✔

46

2✔

47

export namespace UnsupportedSwapErrors {

12✔

48

    export enum UnsupportedSwapErrorKind {

12✔

49

        UnsupportedToken,

12✔

50

        UnsupportedTokenNetFrom,

12✔

51

        UnsupportedTokenNetTo,

12✔

52

        NonmatchingSwapTypes,

12✔

53

        UnsupportedMultiJEWELMigration,

12✔

54

12✔

55

12✔

56

    export interface UnsupportedSwapErrorArgs {

12✔

57

        reason:    string;

12✔

58

        errorKind: UnsupportedSwapErrorKind;

12✔

59

12✔

60

12✔

61

    export class UnsupportedSwapError extends Error {

12✔

62

        readonly reason:    string;

12✔

63

        readonly errorKind: UnsupportedSwapErrorKind;

12✔

64

12✔

65

        constructor({reason, errorKind}: UnsupportedSwapErrorArgs) {

12✔

67

96✔

68

            this.name = this.constructor.name;

96✔

69

            Error.captureStackTrace(this, this.constructor);

96✔

70

96✔

71

            this.reason    = reason;

96✔

72

            this.errorKind = errorKind;

96✔

73

96✔

74

12✔

75

12✔

76

    export const tokenNotSupported = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({

12✔

77

        reason:    `Token ${t.symbol} not supported on network ${netName}`,

12✔

78

        errorKind:  UnsupportedSwapErrorKind.UnsupportedToken,

12✔

79

});

12✔

80

12✔

81

    export const tokenNotSupportedNetFrom = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({

12✔

82

        reason:    `Token ${t.symbol} not supported on 'from' network ${netName}`,

12✔

83

        errorKind:  UnsupportedSwapErrorKind.UnsupportedTokenNetFrom,

12✔

84

});

12✔

85

12✔

86

    export const tokenNotSupportedNetTo = (t: {symbol: string}, netName: string): UnsupportedSwapError => new UnsupportedSwapError({

12✔

87

        reason:    `Token ${t.symbol} not supported on 'to' network ${netName}`,

12✔

88

        errorKind:  UnsupportedSwapErrorKind.UnsupportedTokenNetTo,

12✔

89

});

12✔

90

12✔

91

    export const nonMatchingSwapTypes = (): UnsupportedSwapError => new UnsupportedSwapError({

12✔

92

        reason:    "Token swap types don't match",

12✔

93

        errorKind:  UnsupportedSwapErrorKind.NonmatchingSwapTypes,

12✔

94

});

12✔

95

12✔

96

    export const unsupportedMultiJEWELMigration = (): UnsupportedSwapError => new UnsupportedSwapError({

12✔

97

        reason:    "Migrating multiJEWEL from Avalanche to Harmony is not supported",

12✔

98

        errorKind: UnsupportedSwapErrorKind.UnsupportedMultiJEWELMigration,

12✔

99

});

12✔

100

12✔

101

2✔

102

export namespace TokenSwap {

12✔

103

    const BRIDGE_CONFIG_INSTANCE: BridgeConfigV3Contract = BridgeConfigV3ContractInstance();

12✔

104

12✔

105

    export interface SwapParams {

12✔

106

        chainId:       number;

12✔

107

        tokenFrom:     Token;

12✔

108

        tokenTo:       Token;

12✔

109

        amountIn:      BigNumberish;

12✔

110

        swapData?:     SwapSetup;

12✔

111

12✔

112

12✔

113

    export interface SwapTokensParams extends SwapParams {

12✔

114

        minAmountOut: BigNumberish;

12✔

115

        deadline?:    number;

12✔

116

12✔

117

12✔

118

    export interface BridgeSwapSupportedParams {

12✔

119

        tokenFrom:   Token;

12✔

120

        tokenTo:     Token;

12✔

121

        chainIdFrom: number;

12✔

122

        chainIdTo:   number;

12✔

123

12✔

124

12✔

125

    export interface AddRemoveLiquidityParams {

12✔

126

        chainId:        number;

12✔

127

        lpToken:        SwapPools.SwapPoolToken;

12✔

128

        deadline?:      BigNumber;

12✔

129

        signer?:        Signer;

12✔

130

12✔

131

12✔

132

    export interface AddLiquidityParams extends AddRemoveLiquidityParams {

12✔

133

        amounts:    BigNumber[];

12✔

134

        minToMint?: BigNumber;

12✔

135

12✔

136

12✔

137

    export interface RemoveLiquidityParams extends AddRemoveLiquidityParams {

12✔

138

        amount:      BigNumber;

12✔

139

        minAmounts?: BigNumber[];

12✔

140

12✔

141

12✔

142

    export interface RemoveLiquidityOneParams extends AddRemoveLiquidityParams {

12✔

143

        token:      Token;

12✔

144

        amount:     BigNumber;

12✔

145

        minAmount?: BigNumber;

12✔

146

12✔

147

12✔

148

    export type EstimatedSwapRate = {

12✔

149

        amountOut: BigNumber

12✔

150

12✔

151

12✔

152

    export type IntermediateSwapTokens = {

12✔

153

        intermediateToken?:            Token;

12✔

154

        bridgeConfigIntermediateToken: Token;

12✔

155

12✔

156

12✔

157

    export type SwapSupportedResult = {

12✔

158

        swapSupported:       boolean;

12✔

159

        reasonNotSupported?: UnsupportedSwapErrors.UnsupportedSwapError;

12✔

160

12✔

161

12✔

162

    export type DetailedTokenSwapMap = {

12✔

163

        [chainId: number]: {

12✔

164

            token: Token;

12✔

165

            [chainId: number]: Token[];

12✔

166

        }[];

12✔

167

12✔

168

12✔

169

    interface TokenSwapMap {

12✔

170

        token: Token;

12✔

171

        [chainId: number]: Token[];

12✔

172

12✔

173

12✔

174

    const CHAIN_SWAPS_GAS_LIMITS: ChainIdTypeMap<GasOptions> = {

12✔

175

        [ChainId.AVALANCHE]: {gasLimit: BigNumber.from("165000")}

12✔

176

12✔

177

12✔

178

    const

12✔

179

        ADD_LIQUIDITY_GAS_LIMT:         BigNumber = BigNumber.from("210000"),

12✔

180

        REMOVE_LIQUIDITY_GAS_LIMT:      BigNumber = BigNumber.from("265000"),

12✔

181

        REMOVE_LIQUIDITY_ONE_GAS_LIMIT: BigNumber = BigNumber.from("210000");

12✔

182

12✔

183

12✔

184

    export function swapSupported(args: SwapParams): SwapSupportedResult {

12✔

185

        const {tokenFrom, tokenTo, chainId} = args;

52✔

186

        return checkCanSwap(tokenFrom, tokenTo, chainId)

52✔

187

52✔

188

12✔

189

    export function bridgeSwapSupported(args: BridgeSwapSupportedParams): SwapSupportedResult {

12✔

190

        const {tokenFrom, tokenTo, chainIdFrom, chainIdTo} = args;

468✔

191

        return checkCanSwap(tokenFrom, tokenTo, chainIdFrom, chainIdTo);

468✔

192

468✔

193

12✔

194

/**

12✔

195

     * calculateAddLiquidity returns the estimated number of LP tokens which a user would receive

12✔

196

     * were they to deposit a given number of liquidity tokens into a pool.

12✔

197

12✔

198

     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.

12✔

199

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

200

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.

12✔

201

     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.

12✔

202

12✔

203

     * @return {BigNumber} Amount of LP tokens a user would receive if the deposited liquidity tokens into the pool.

12✔

204

*/

12✔

205

    export async function calculateAddLiquidity(args: AddLiquidityParams): Promise<BigNumber> {

12✔

206

        const swapInstance = await swapContractFromLPSwapAddress(

8✔

207

            args.lpToken.swapAddress,

8✔

208

            args.chainId

8✔

209

);

8✔

210

8✔

211

        return swapInstance.calculateTokenAmount(

8✔

212

            args.amounts,

8✔

213

            true

8✔

214

8✔

215

8✔

216

12✔

217

/**

12✔

218

     * calculateRemoveLiquidity returns the estimated number of pooled tokens which a user would receive

12✔

219

     * were they to return some amount of their LP tokens to the Pool.

12✔

220

12✔

221

     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.

12✔

222

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

223

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.

12✔

224

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.

12✔

225

12✔

226

     * @return {BigNumber[]} Pool-index-relative array of token amounts which a user would receive if they remove the passed amount of LP tokens.

12✔

227

*/

12✔

228

    export async function calculateRemoveLiquidity(args: RemoveLiquidityParams): Promise<BigNumber[]> {

12✔

229

        const swapInstance = await swapContractFromLPSwapAddress(

12✔

230

            args.lpToken.swapAddress,

12✔

231

            args.chainId

12✔

232

);

12✔

233

12✔

234

        return swapInstance.calculateRemoveLiquidity(args.amount)

12✔

235

12✔

236

12✔

237

/**

12✔

238

     * calculateRemoveLiquidityOneToken returns the estimated number of a single pooled token

12✔

239

     * which would be removed from a Liquidity Pool and transferred to a user

12✔

240

     * were they to return some amount of their LP tokens to the Pool.

12✔

241

12✔

242

     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.

12✔

243

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

244

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.

12✔

245

     * @param {Token} args.token Token which will be removed as liquidity from the Liquidity Pool and transferred to the user in exchange for their LP tokens.

12✔

246

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.

12✔

247

12✔

248

     * @return {BigNumber} Amount of a single pooled liquidity token which would be removed from the Liquidity Pool and transferred to the user.

12✔

249

*/

12✔

250

    export async function calculateRemoveLiquidityOneToken(args: RemoveLiquidityOneParams): Promise<BigNumber> {

12✔

251

        const swapInstance = await swapContractFromLPSwapAddress(

14✔

252

            args.lpToken.swapAddress,

14✔

253

            args.chainId

14✔

254

);

14✔

255

14✔

256

        const tokenAddress = args.token.address(args.chainId);

14✔

261

14✔

262

        let tokenIndex: number;

14✔

263

        try {

14✔

264

            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);

14✔

265

        } catch (e) {

14✔

266

            return rejectPromise(e)

14✔

267

14✔

268

14✔

269

        return swapInstance.calculateRemoveLiquidityOneToken(args.amount, tokenIndex)

14✔

270

14✔

271

12✔

272

/**

12✔

273

     * addLiquidity adds a given amount of a user's tokens (such as USDC for Stableswap pools)

12✔

274

     * as liquidity to a Liquidity Pool, providing the user with LP tokens which can be staked.

12✔

275

12✔

276

     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.

12✔

277

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

278

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.

12✔

279

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

280

     * @param {Signer} args.signer EthersJS-compatible transaction signer.

12✔

281

     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.

12✔

282

     * @param {BigNumber} args.minToMint Amount of LP tokens to mint. Can be calculated with {@link calculateAddLiquidity}.

12✔

283

12✔

284

     * @return {Promise<ContractTransaction>} Executed transaction object.

12✔

285

*/

12✔

286

    export async function addLiquidity(args: AddLiquidityParams): Promise<ContractTransaction> {

12✔

287

        if (isEmpty(args.signer)) { /* c8 ignore start */

2✔

288

            return rejectPromiseMissingField("signer", "AddLiquidityParams")

2✔

289

        } else if (isEmpty(args.deadline)) {

2✔

290

            return rejectPromiseMissingField("deadline", "AddLiquidityParams")

2✔

291

        } else if (isEmpty(args.minToMint)) {

2✔

292

            return rejectPromiseMissingField("minToMint", "AddLiquidityParams")

2✔

293

        } /* c8 ignore stop */

2✔

294

6✔

295

        const swapInstance = await swapContractFromLPSwapAddress(

6✔

296

            args.lpToken.swapAddress,

6✔

297

            args.chainId,

6✔

298

            args.signer

6✔

299

);

6✔

300

6✔

301

        return swapInstance.addLiquidity(

6✔

302

            args.amounts,

6✔

303

            args.minToMint,

6✔

304

            args.deadline,

6✔

305

            {gasLimit: ADD_LIQUIDITY_GAS_LIMT}

6✔

306

6✔

307

6✔

308

12✔

309

/**

12✔

310

     * buildAddLiquidityTransaction populates a transaction which adds a given amount of a

12✔

311

     * user's tokens (such as USDC for Stableswap pools) as liquidity to a Liquidity Pool,

12✔

312

     * providing the user with LP tokens which can be staked.

12✔

313

12✔

314

     * @param {AddLiquidityParams} args {@link AddLiquidityParams} object containing arguments.

12✔

315

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

316

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.

12✔

317

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

318

     * @param {BigNumber[]} args.amounts Pool-index-relative array of token amounts to add as liquidity to the pool.

12✔

319

     * @param {BigNumber} args.minToMint Amount of LP tokens to mint. Can be calculated with {@link calculateAddLiquidity}.

12✔

320

12✔

321

     * @return {Promise<PopulatedTransaction>} Populated transaction object.

12✔

322

*/

12✔

323

    export async function buildAddLiquidityTransaction(args: AddLiquidityParams): Promise<PopulatedTransaction> {

12✔

324

        if (isEmpty(args.deadline)) { /* c8 ignore start */

2✔

325

            return rejectPromiseMissingField("deadline", "AddLiquidityParams")

2✔

326

        } else if (isEmpty(args.minToMint)) {

2✔

327

            return rejectPromiseMissingField("minToMint", "AddLiquidityParams")

2✔

328

        } /* c8 ignore stop */

2✔

329

6✔

330

        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);

6✔

331

6✔

332

        return swapInstance.populateTransaction.addLiquidity(

6✔

333

            args.amounts,

6✔

334

            args.minToMint,

6✔

335

            args.deadline

6✔

336

6✔

337

6✔

338

12✔

339

/**

12✔

340

     * removeLiquidity exchanges a given amount of a user's LP tokens for a given Liquidity Pool for

12✔

341

     * various amounts of pooled liquidity tokens, thereby removing liquidity from the Pool.

12✔

342

12✔

343

     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.

12✔

344

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

345

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.

12✔

346

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

347

     * @param {Signer} args.signer EthersJS-compatible transaction signer.

12✔

348

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.

12✔

349

     * @param {BigNumber[]} args.minAmounts Pool-index-relative array of pooled liquidity token amounts to return in exchange for LP tokens. Can be calculated with {@link calculateRemoveLiquidity}.

12✔

350

12✔

351

     * @return {Promise<ContractTransaction>} Executed transaction object.

12✔

352

*/

12✔

353

    export async function removeLiquidity(args: RemoveLiquidityParams): Promise<ContractTransaction> {

12✔

354

        if (isEmpty(args.signer)) { /* c8 ignore start */

2✔

355

            return rejectPromiseMissingField("signer", "RemoveLiquidityParams")

2✔

356

        } else if (isEmpty(args.deadline)) {

2✔

357

            return rejectPromiseMissingField("deadline", "RemoveLiquidityParams")

2✔

358

        } else if (isEmpty(args.minAmounts)) {

2✔

359

            return rejectPromiseMissingField("minAmounts", "RemoveLiquidityParams")

2✔

360

        } /* c8 ignore stop */

2✔

361

8✔

362

        const swapInstance = await swapContractFromLPSwapAddress(

8✔

363

            args.lpToken.swapAddress,

8✔

364

            args.chainId,

8✔

365

            args.signer

8✔

366

);

8✔

367

8✔

368

        return swapInstance.removeLiquidity(

8✔

369

            args.amount,

8✔

370

            args.minAmounts,

8✔

371

            args.deadline,

8✔

372

            {gasLimit: REMOVE_LIQUIDITY_GAS_LIMT}

8✔

373

8✔

374

8✔

375

12✔

376

/**

12✔

377

     * buildRemoveLiquidityTransaction populates a transaction which exchanges a given amount of a user's LP tokens for a given Liquidity Pool for

12✔

378

     * various amounts of pooled liquidity tokens, thereby removing liquidity from the Pool.

12✔

379

12✔

380

     * @param {RemoveLiquidityParams} args {@link RemoveLiquidityParams} object containing arguments.

12✔

381

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

382

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token with which to interact.

12✔

383

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

384

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for pooled liquidity tokens.

12✔

385

     * @param {BigNumber[]} args.minAmounts Pool-index-relative array of pooled liquidity token amounts to return in exchange for LP tokens. Can be calculated with {@link calculateRemoveLiquidity}.

12✔

386

12✔

387

     * @return {Promise<PopulatedTransaction>} Populated transaction object.

12✔

388

*/

12✔

389

    export async function buildRemoveLiquidityTransaction(args: RemoveLiquidityParams): Promise<PopulatedTransaction> {

12✔

390

        if (isEmpty(args.deadline)) { /* c8 ignore start */

2✔

391

            return rejectPromiseMissingField("deadline", "RemoveLiquidityParams")

2✔

392

        } else if (isEmpty(args.minAmounts)) {

2✔

393

            return rejectPromiseMissingField("minAmounts", "RemoveLiquidityParams")

2✔

394

        } /* c8 ignore stop */

2✔

395

8✔

396

        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);

8✔

397

8✔

398

        return swapInstance.populateTransaction.removeLiquidity(

8✔

399

            args.amount,

8✔

400

            args.minAmounts,

8✔

401

            args.deadline

8✔

402

8✔

403

8✔

404

12✔

405

/**

12✔

406

     * removeLiquidityOneToken exchanges a given amount of a user's LP tokens for a given Liquidity Pool for

12✔

407

     * an amount of a single liquidity token in the given Liquidity Pool, removing that amount from available liquidity

12✔

408

     * and transferring it to the user.

12✔

409

12✔

410

     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.

12✔

411

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

412

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.

12✔

413

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

414

     * @param {Signer} args.signer EthersJS-compatible transaction signer.

12✔

415

     * @param {Token} args.token Token which will be returned to the user in exchange for their LP tokens.

12✔

416

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.

12✔

417

     * @param {BigNumber} args.minAmount Minimum amount of pooled liquidity token to be removed from the Liquidity Pool and transferred to the user.

12✔

418

12✔

419

     * @return {Promise<ContractTransaction>} Executed transaction object.

12✔

420

*/

12✔

421

    export async function removeLiquidityOneToken(args: RemoveLiquidityOneParams): Promise<ContractTransaction> {

12✔

422

        if (isEmpty(args.signer)) { /* c8 ignore start */

2✔

423

            return rejectPromiseMissingField("signer", "RemoveLiquidityOneParams")

2✔

424

        } else if (isEmpty(args.deadline)) {

2✔

425

            return rejectPromiseMissingField("deadline", "RemoveLiquidityOneParams")

2✔

426

        } else if (isEmpty(args.minAmount)) {

2✔

427

            return rejectPromiseMissingField("minAmount", "RemoveLiquidityOneParams")

2✔

428

        } /* c8 ignore stop */

2✔

429

10✔

430

        const swapInstance = await swapContractFromLPSwapAddress(

10✔

431

            args.lpToken.swapAddress,

10✔

432

            args.chainId,

10✔

433

            args.signer

10✔

434

);

10✔

435

10✔

436

        const tokenAddress = args.token.address(args.chainId);

10✔

441

10✔

442

        let tokenIndex: number;

10✔

443

        try {

10✔

444

            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);

10✔

445

        } catch (e) {

10✔

446

            return rejectPromise(e)

10✔

447

10✔

448

10✔

449

        return swapInstance.removeLiquidityOneToken(

10✔

450

            args.amount,

10✔

451

            tokenIndex,

10✔

452

            args.minAmount,

10✔

453

            args.deadline,

10✔

454

            {gasLimit: REMOVE_LIQUIDITY_ONE_GAS_LIMIT}

10✔

455

10✔

456

10✔

457

12✔

458

/**

12✔

459

     * buildRemoveLiquidityOneTokenTransaction populates a transaction exchanges a given amount of a user's LP tokens for a given Liquidity Pool for

12✔

460

     * an amount of a single liquidity token in the given Liquidity Pool, removing that amount from available liquidity

12✔

461

     * and transferring it to the user.

12✔

462

12✔

463

     * @param {RemoveLiquidityOneParams} args {@link RemoveLiquidityOneParams} object containing arguments.

12✔

464

     * @param {number} args.chainId Chain ID of the Liquidity Pool.

12✔

465

     * @param {SwapPools.SwapPoolToken} args.lpToken LP Token/Pool with which to interact.

12✔

466

     * @param {BigNumber} args.deadline Latest deadline which transaction will be accepted at.

12✔

467

     * @param {Token} args.token Token which will be returned to the user in exchange for their LP tokens.

12✔

468

     * @param {BigNumber} args.amount Amount of LP tokens to exchange for desired pooled liquidity token.

12✔

469

     * @param {BigNumber} args.minAmount Minimum amount of pooled liquidity token to be removed from the Liquidity Pool and transferred to the user.

12✔

470

12✔

471

     * @return {Promise<PopulatedTransaction>} Populated transaction object.

12✔

472

*/

12✔

473

    export async function buildRemoveLiquidityOneTokenTransaction(args: RemoveLiquidityOneParams): Promise<PopulatedTransaction> {

12✔

474

        if (isEmpty(args.deadline)) { /* c8 ignore start */

2✔

475

            return rejectPromiseMissingField("deadline", "RemoveLiquidityOneParams")

2✔

476

        } else if (isEmpty(args.minAmount)) {

2✔

477

            return rejectPromiseMissingField("minAmount", "RemoveLiquidityOneParams")

2✔

478

        } /* c8 ignore stop */

2✔

479

10✔

480

        const swapInstance = await swapContractFromLPSwapAddress(args.lpToken.swapAddress, args.chainId);

10✔

481

10✔

482

        const tokenAddress = args.token.address(args.chainId);

10✔

487

10✔

488

        let tokenIndex: number;

10✔

489

        try {

10✔

490

            tokenIndex = await swapInstance.getTokenIndex(tokenAddress);

10✔

491

        } catch (e) {

10✔

492

            return rejectPromise(e)

10✔

493

10✔

494

10✔

495

        return swapInstance.populateTransaction.removeLiquidityOneToken(

10✔

496

            args.amount,

10✔

497

            tokenIndex,

10✔

498

            args.minAmount,

10✔

499

            args.deadline

10✔

500

10✔

501

10✔

502

12✔

503

12✔

504

    function rejectPromiseMissingField(fieldName: string, paramsType: string): Promise<never> {

12✔

508

12✔

509

    export async function calculateSwapRate(args: SwapParams): Promise<EstimatedSwapRate> {

12✔

510

        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);

26✔

511

        if (!canSwap) {

26✔

512

            return rejectPromise(reasonNotSupported)

8✔

513

8✔

514

26✔

515

        return resolveSwapData(args)

26✔

516

            .then(({swapInstance, tokenIndexFrom, tokenIndexTo}) =>

26✔

517

                swapInstance

14✔

518

                    .calculateSwap(tokenIndexFrom, tokenIndexTo, args.amountIn)

26✔

519

                    .then((res): EstimatedSwapRate => ({amountOut: res}))

26✔

520

26✔

521

            .catch(rejectPromise)

26✔

522

26✔

523

12✔

524

    interface SwapTokensFnParams extends SwapTokensParams {

12✔

525

        signer: Signer

12✔

526

12✔

527

12✔

528

    export async function swapTokens(

12✔

529

        args:        SwapTokensFnParams,

8✔

530

        gasOptions?: GasOptions

8✔

531

    ): Promise<ContractTransaction> {

8✔

532

        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);

8✔

533

        if (!canSwap) {

8✔

534

            return rejectPromise(reasonNotSupported)

8✔

535

8✔

536

8✔

537

        return resolveSwapData(args)

8✔

538

            .then(swapSetup => {

8✔

539

                const {deadline} = args;

2✔

540

2✔

541

                return swapContract(args.tokenFrom, args.chainId, args.signer)

2✔

542

                    .then(swapInstance => {

2✔

543

                        return swapInstance.swap(

2✔

544

                            swapSetup.tokenIndexFrom,

2✔

545

                            swapSetup.tokenIndexTo,

2✔

546

                            args.amountIn,

2✔

547

                            args.minAmountOut,

2✔

549

                            buildSwapTokensOverrides(args, gasOptions)

2✔

550

2✔

551

})

2✔

552

})

8✔

553

            .catch(rejectPromise)

8✔

554

8✔

555

12✔

556

    export async function buildSwapTokensTransaction(

12✔

557

        args:        SwapTokensParams,

18✔

558

        gasOptions?: GasOptions

18✔

559

    ): Promise<PopulatedTransaction> {

18✔

560

        const {swapSupported: canSwap, reasonNotSupported} = swapSupported(args);

18✔

561

        if (!canSwap) {

18✔

562

            return rejectPromise(reasonNotSupported)

4✔

563

4✔

564

18✔

565

        return resolveSwapData(args)

18✔

566

            .then(swapData => populateSwapTransaction(args, swapData, gasOptions))

18✔

567

            .catch(rejectPromise)

18✔

568

18✔

569

12✔

570

    async function resolveSwapData(args: SwapTokensParams|SwapParams): Promise<SwapSetup> {

12✔

571

        const {swapData} = args;

36✔

572

        return Promise.resolve(swapData ? swapData : await swapSetup(args.tokenFrom, args.tokenTo, args.chainId))

36✔

573

36✔

574

12✔

575

    function populateSwapTransaction(

12✔

576

        args:        SwapTokensParams,

12✔

577

        swapSetup:   SwapSetup,

12✔

578

        gasOptions?: GasOptions

12✔

579

    ): Promise<PopulatedTransaction> {

12✔

580

        const {deadline} = args;

12✔

581

        const {swapInstance} = swapSetup;

12✔

582

12✔

583

        let txnProm = swapInstance.populateTransaction.swap(

12✔

584

            swapSetup.tokenIndexFrom,

12✔

585

            swapSetup.tokenIndexTo,

12✔

586

            args.amountIn,

12✔

587

            args.minAmountOut,

12✔

589

);

12✔

590

12✔

591

        const gasLimit = CHAIN_SWAPS_GAS_LIMITS[args.chainId]?.gasLimit;

12✔

592

12✔

594

        if (gasLimit) {

12✔

595

            gasOpts.gasLimit = gasLimit;

2✔

596

2✔

597

12✔

598

        return txnProm.then(txn => populateGasOptions(txn, gasOpts, args.chainId))

12✔

599

12✔

600

12✔

601

    /* c8 ignore start */

2✔

602

    function buildSwapTokensOverrides(

2✔

603

        args:         SwapTokensParams,

2✔

604

        gasOptions?:  GasOptions

2✔

605

    ): Overrides | null {

2✔

606

        const {chainId} = args;

2✔

607

2✔

608

        const overrides: Overrides = {

2✔

609

            ...makeTransactionGasOverrides(gasOptions, chainId, true),

2✔

610

            ...makeTransactionGasOverrides(CHAIN_SWAPS_GAS_LIMITS[chainId], chainId)

2✔

611

};

2✔

612

2✔

613

        if (Object.keys(overrides).length === 0) {

2✔

614

            return null

2✔

615

2✔

616

2✔

617

        return overrides

2✔

618

2✔

619

    /* c8 ignore stop */

2✔

620

12✔

621

    export function intermediateTokens(chainId: number, token: Token, otherChainId?: number): IntermediateSwapTokens {

12✔

622

        if (mintBurnSwapTypes.includes(token.swapType)) {

636✔

623

            switch (token.swapType) {

160✔

624

                case SwapType.JEWEL:

160✔

625

                    let bridgeConfigIntermediate: Token = chainId === ChainId.HARMONY

42✔

626

                        ? Tokens.SYN_JEWEL

42✔

627

                        : Tokens.JEWEL;

42✔

628

42✔

629

                    return {intermediateToken: Tokens.JEWEL, bridgeConfigIntermediateToken: bridgeConfigIntermediate}

42✔

630

                // case SwapType.AVAX:

160✔

631

                //     break;

160✔

632

                default:

160✔

633

                    return {intermediateToken: token, bridgeConfigIntermediateToken: token}

118✔

634

160✔

635

160✔

636

476✔

637

let

476✔

638

            intermediateToken:             Token,

476✔

639

            bridgeConfigIntermediateToken: Token;

476✔

640

476✔

641

        switch (token.swapType) {

476✔

642

            case SwapType.SYN:

636✔

643

                intermediateToken = Tokens.SYN;

8✔

644

                break;

8✔

645

            case SwapType.FRAX:

636✔

646

                bridgeConfigIntermediateToken = chainId === ChainId.ETH ? Tokens.FRAX : Tokens.SYN_FRAX;

14✔

647

                break;

14✔

648

            case SwapType.ETH:

636✔

649

                intermediateToken             = Tokens.NETH;

152✔

650

                bridgeConfigIntermediateToken = chainId === ChainId.ETH ? Tokens.WETH : Tokens.NETH;

152✔

651

                break;

152✔

652

            case SwapType.AVAX:

636✔

653

                const

54✔

654

                    fromAvax    = chainId === ChainId.AVALANCHE,

54✔

655

                    fromHarmony = chainId === ChainId.HARMONY;

54✔

656

54✔

657

                if (!isNil(otherChainId)) {

54✔

658

                    if (fromAvax && otherChainId === ChainId.HARMONY) {

52✔

659

                        intermediateToken             = Tokens.WAVAX;

6✔

660

                        bridgeConfigIntermediateToken = Tokens.SYN_AVAX;

6✔

661

                        break;

6✔

662

                    } else if (fromHarmony && otherChainId === ChainId.AVALANCHE) {

52✔

663

                        intermediateToken             = Tokens.WAVAX;

16✔

664

                        bridgeConfigIntermediateToken = Tokens.WAVAX;

16✔

665

                        break;

16✔

666

                    } else {

42✔

667

                        intermediateToken             = Tokens.WAVAX;

30✔

668

                        bridgeConfigIntermediateToken = chainId === ChainId.HARMONY ? Tokens.SYN_AVAX : Tokens.WAVAX;

30✔

669

                        break;

30✔

670

30✔

671

52✔

672

2✔

673

                /* c8 ignore next 3 */

2✔

674

                intermediateToken             = Tokens.WAVAX;

2✔

675

                bridgeConfigIntermediateToken = chainId === ChainId.HARMONY ? Tokens.SYN_AVAX : Tokens.WAVAX;

2✔

676

                break;

2✔

677

            case SwapType.MOVR:

636✔

678

                intermediateToken = Tokens.WMOVR;

8✔

679

                break;

8✔

680

            case SwapType.DFKTEARS:

636✔

681

                intermediateToken = Tokens.DFKTEARS;

8✔

682

                break;

8✔

683

            default:

636✔

684

                intermediateToken = Tokens.NUSD;

232✔

685

                break;

232✔

686

636✔

687

476✔

688

        bridgeConfigIntermediateToken = bridgeConfigIntermediateToken ?? intermediateToken;

636✔

689

636✔

690

        return {intermediateToken, bridgeConfigIntermediateToken}

636✔

691

636✔

692

12✔

693

    export function detailedTokenSwapMap(): DetailedTokenSwapMap {

12✔

694

        let res: DetailedTokenSwapMap = {};

2✔

695

2✔

696

        const allChainIds = supportedChainIds();

2✔

697

2✔

698

        for (const c1 of allChainIds) {

2✔

699

            let n1: Networks.Network = Networks.fromChainId(c1);

30✔

700

            let networkTokens: Token[] = n1.tokens;

30✔

701

30✔

702

            const chainGasToken = Tokens.gasTokenForChain(c1);

30✔

703

30✔

704

            res[c1] = networkTokens.map((t: Token) => {

30✔

705

                let swapType = t.swapType;

300✔

706

300✔

707

                if (!isNull(chainGasToken)) {

300✔

708

                    const gasWrapper = Tokens.gasTokenWrapper(chainGasToken);

150✔

709

                    if (gasWrapper.isEqual(t)) {

150✔

710

                        return

8✔

711

8✔

712

150✔

713

292✔

714

                let tokSwapMap: TokenSwapMap = {

292✔

715

                    token: t,

292✔

716

292✔

717

292✔

718

                for (const c2 of allChainIds) {

292✔

719

                    if (c1 === c2) continue

4,380✔

720

4,088✔

721

                    if (c1 === ChainId.AVALANCHE && t.isEqual(Tokens.MULTIJEWEL) && c2 !== ChainId.DFK) {

4,380✔

722

                        continue

26✔

723

26✔

724

4,062✔

725

                    const chain2GasToken = Tokens.gasTokenForChain(c2);

4,062✔

726

                    let outToks: Token[] = SwapPools.tokensForChainBySwapGroup(c2, swapType);

4,062✔

727

                    if (outToks.length === 0) continue

4,062✔

728

4,380✔

729

                    outToks = outToks.filter((t2: Token) => {

4,380✔

730

                        if (!isNull(chain2GasToken)) {

4,538✔

731

                            return !Tokens.gasTokenWrapper(chain2GasToken).isEqual(t2)

2,108✔

732

2,108✔

733

2,430✔

734

                        return true

2,430✔

735

})

4,380✔

736

4,380✔

737

                    tokSwapMap[c2] = outToks;

4,380✔

738

4,380✔

739

292✔

740

                return tokSwapMap

292✔

741

            }).filter(t => !isUndefined(t))

30✔

742

30✔

743

2✔

744

        return res

2✔

745

2✔

746

12✔

747

    interface SwapSetup {

12✔

748

        swapInstance:   SwapContract,

12✔

749

        tokenIndexFrom: number,

12✔

750

        tokenIndexTo:   number,

12✔

751

12✔

752

12✔

753

    export async function swapContract(token: Token, chainId: number, signer?: Signer): Promise<SwapContract> {

12✔

754

        const provider = signer ? signer : rpcProviderForChain(chainId);

56✔

755

56✔

756

        const lpToken = _intermediateToken(token, chainId);

56✔

757

56✔

758

        // temp fix until BridgeConfig is updated

56✔

759

        if (lpToken.isEqual(Tokens.NUSD) && chainId === ChainId.CRONOS) {

56✔

760

            return swapContractFromLPSwapAddress(

12✔

761

                SwapPools.stableswapPoolForNetwork(chainId).swapAddress,

12✔

762

                chainId,

12✔

763

                signer

12✔

764

12✔

765

12✔

766

56✔

767

        return BRIDGE_CONFIG_INSTANCE.getPoolConfig(lpToken.address(chainId), chainId)

56✔

768

            .then(({poolAddress}) => SwapFactory.connect(poolAddress, provider))

56✔

769

            .catch(rejectPromise)

56✔

770

56✔

771

12✔

772

    async function swapContractFromLPSwapAddress(lpSwapAddress: string, chainId: number, signer?: Signer): Promise<SwapContract> {

12✔

773

        const provider = signer ? signer : rpcProviderForChain(chainId);

94✔

774

94✔

775

        return SwapFactory.connect(lpSwapAddress, provider)

94✔

776

94✔

777

12✔

778

    export async function swapSetup(tokenFrom: Token, tokenTo: Token, chainId: number): Promise<SwapSetup> {

12✔

779

        const swapInstance = await swapContract(tokenFrom, chainId);

54✔

780

54✔

781

        return Promise.all([

54✔

782

                swapInstance.getTokenIndex(tokenFrom.address(chainId)),

54✔

783

                swapInstance.getTokenIndex(tokenTo.address(chainId)),

54✔

784

        ]).then(([tokenIndexFrom, tokenIndexTo]) => ({

54✔

785

            swapInstance,

54✔

786

            tokenIndexFrom,

54✔

787

            tokenIndexTo,

54✔

788

        })).catch(rejectPromise)

54✔

789

54✔

790

12✔

791

    function _intermediateToken(token: Token, chainId: number): Token {

12✔

792

        const {intermediateToken, bridgeConfigIntermediateToken} = intermediateTokens(chainId, token);

56✔

793

        /* c8 ignore next */

2✔

794

        return intermediateToken ?? bridgeConfigIntermediateToken

2✔

795

56✔

796

12✔

797

    function checkCanSwap(tokenFrom: Token, tokenTo: Token, chainFrom: number, chainTo?: number): SwapSupportedResult {

12✔

798

        const

520✔

799

            tokensCanSwap   = checkTokensCanSwap(tokenFrom, tokenTo),

520✔

800

            tokensSupported = checkTokensSupported(tokenFrom, tokenTo, chainFrom, chainTo);

520✔

801

520✔

802

        if (!tokensSupported.swapSupported) {

520✔

803

            return tokensSupported

54✔

804

        } else if (!tokensCanSwap.swapSupported) {

520✔

805

            return tokensCanSwap

40✔

806

40✔

807

426✔

808

        return {swapSupported: true}

426✔

809

426✔

810

12✔

811

    function checkTokensCanSwap(tokenFrom: Token, tokenTo: Token): SwapSupportedResult {

12✔

812

let

520✔

813

            swapSupported: boolean = true,

520✔

814

            reasonNotSupported: UnsupportedSwapErrors.UnsupportedSwapError;

520✔

815

520✔

816

        if (tokenFrom.swapType !== tokenTo.swapType) {

520✔

817

            swapSupported = false;

42✔

818

            reasonNotSupported = UnsupportedSwapErrors.nonMatchingSwapTypes();

42✔

819

42✔

820

520✔

821

        return {swapSupported, reasonNotSupported}

520✔

822

520✔

823

12✔

824

    function checkTokensSupported(

12✔

825

        tokenFrom:   Token,

520✔

826

        tokenTo:     Token,

520✔

827

        chainIdFrom: number,

520✔

828

        chainIdTo?:  number

520✔

829

    ): SwapSupportedResult {

520✔

830

        const hasDestChain: boolean = !isUndefined(chainIdTo);

520✔

831

520✔

832

        const

520✔

833

            unsupportedFromErr = hasDestChain ? UnsupportedSwapErrors.tokenNotSupportedNetFrom : UnsupportedSwapErrors.tokenNotSupported,

520✔

834

            unsupportedToErr   = hasDestChain ? UnsupportedSwapErrors.tokenNotSupportedNetTo   : UnsupportedSwapErrors.tokenNotSupported;

520✔

835

520✔

836

        const

520✔

837

            netFrom = Networks.fromChainId(chainIdFrom),

520✔

838

            netTo   = hasDestChain ? Networks.fromChainId(chainIdTo) : netFrom;

520✔

839

520✔

840

        if (hasDestChain) {

520✔

841

            if (tokenFrom.isEqual(Tokens.MULTIJEWEL) && chainIdTo !== ChainId.DFK) {

468✔

842

                return {swapSupported: false, reasonNotSupported: UnsupportedSwapErrors.unsupportedMultiJEWELMigration()}

2✔

843

2✔

844

468✔

845

518✔

846

let

518✔

847

            swapSupported: boolean = true,

518✔

848

            reasonNotSupported: UnsupportedSwapErrors.UnsupportedSwapError;

518✔

849

518✔

850

        if (!netFrom.supportsToken(tokenFrom)) {

520✔

851

            swapSupported = false;

20✔

852

            reasonNotSupported = unsupportedFromErr(tokenFrom, netFrom.name);

20✔

853

        } else if (!netTo.supportsToken(tokenTo)) {

520✔

854

            swapSupported = false;

32✔

855

            reasonNotSupported = unsupportedToErr(tokenTo, netTo.name);

32✔

856

32✔

857

518✔

858

        return {swapSupported, reasonNotSupported}

518✔

859

518✔

860

12✔

synapsecns / sdk / 2586660196

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

synapsecns / sdk / 2586660196

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