@pancakeswap/sdk 3.1.4 → 3.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/index.d.ts +14 -5
  2. package/dist/index.js +375 -232
  3. package/dist/index.mjs +288 -154
  4. package/package.json +13 -6
package/dist/index.js CHANGED
@@ -1,92 +1,46 @@
1
- "use strict";
2
- var __create = Object.create;
3
- var __defProp = Object.defineProperty;
4
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
- var __getOwnPropNames = Object.getOwnPropertyNames;
6
- var __getProtoOf = Object.getPrototypeOf;
7
- var __hasOwnProp = Object.prototype.hasOwnProperty;
8
- var __export = (target, all) => {
9
- for (var name in all)
10
- __defProp(target, name, { get: all[name], enumerable: true });
11
- };
12
- var __copyProps = (to, from, except, desc) => {
13
- if (from && typeof from === "object" || typeof from === "function") {
14
- for (let key of __getOwnPropNames(from))
15
- if (!__hasOwnProp.call(to, key) && key !== except)
16
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
17
- }
18
- return to;
19
- };
20
- var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
21
- var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
22
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
1
+ 'use strict';
23
2
 
24
- // src/index.ts
25
- var src_exports = {};
26
- __export(src_exports, {
27
- ChainId: () => ChainId,
28
- ERC20Token: () => ERC20Token,
29
- FACTORY_ADDRESS: () => FACTORY_ADDRESS,
30
- FACTORY_ADDRESS_MAP: () => FACTORY_ADDRESS_MAP,
31
- INIT_CODE_HASH: () => INIT_CODE_HASH,
32
- INIT_CODE_HASH_MAP: () => INIT_CODE_HASH_MAP,
33
- JSBI: () => import_jsbi2.default,
34
- NATIVE: () => NATIVE,
35
- Native: () => Native,
36
- ONE_HUNDRED_PERCENT: () => ONE_HUNDRED_PERCENT,
37
- Pair: () => Pair,
38
- Route: () => Route,
39
- Router: () => Router,
40
- Trade: () => Trade,
41
- WBNB: () => WBNB,
42
- WETH9: () => WETH9,
43
- WNATIVE: () => WNATIVE,
44
- ZERO_PERCENT: () => ZERO_PERCENT,
45
- computePairAddress: () => computePairAddress,
46
- inputOutputComparator: () => inputOutputComparator,
47
- isTradeBetter: () => isTradeBetter,
48
- tradeComparator: () => tradeComparator
49
- });
50
- module.exports = __toCommonJS(src_exports);
51
- var import_jsbi2 = __toESM(require("jsbi"));
3
+ var JSBI = require('jsbi');
4
+ var swapSdkCore = require('@pancakeswap/swap-sdk-core');
5
+ var address = require('@ethersproject/address');
6
+ var invariant4 = require('tiny-invariant');
7
+ var warning = require('tiny-warning');
8
+ var solidity = require('@ethersproject/solidity');
52
9
 
53
- // src/constants.ts
54
- var import_swap_sdk_core2 = require("@pancakeswap/swap-sdk-core");
10
+ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
55
11
 
56
- // src/entities/token.ts
57
- var import_swap_sdk_core = require("@pancakeswap/swap-sdk-core");
12
+ var JSBI__default = /*#__PURE__*/_interopDefault(JSBI);
13
+ var invariant4__default = /*#__PURE__*/_interopDefault(invariant4);
14
+ var warning__default = /*#__PURE__*/_interopDefault(warning);
58
15
 
59
- // src/utils.ts
60
- var import_address = require("@ethersproject/address");
61
- var import_tiny_invariant = __toESM(require("tiny-invariant"));
62
- var import_tiny_warning = __toESM(require("tiny-warning"));
63
- function validateAndParseAddress(address) {
16
+ // src/index.ts
17
+ function validateAndParseAddress(address$1) {
64
18
  try {
65
- const checksummedAddress = (0, import_address.getAddress)(address);
66
- (0, import_tiny_warning.default)(address === checksummedAddress, `${address} is not checksummed.`);
19
+ const checksummedAddress = address.getAddress(address$1);
20
+ warning__default.default(address$1 === checksummedAddress, `${address$1} is not checksummed.`);
67
21
  return checksummedAddress;
68
22
  } catch (error) {
69
- (0, import_tiny_invariant.default)(false, `${address} is not a valid address.`);
23
+ invariant4__default.default(false, `${address$1} is not a valid address.`);
70
24
  }
71
25
  }
72
26
 
73
27
  // src/entities/token.ts
74
- var ERC20Token = class extends import_swap_sdk_core.Token {
28
+ var ERC20Token = class extends swapSdkCore.Token {
75
29
  constructor(chainId, address, decimals, symbol, name, projectLink) {
76
30
  super(chainId, validateAndParseAddress(address), decimals, symbol, name, projectLink);
77
31
  }
78
32
  };
79
33
 
80
34
  // src/constants.ts
81
- var ChainId = /* @__PURE__ */ ((ChainId2) => {
82
- ChainId2[ChainId2["ETHEREUM"] = 1] = "ETHEREUM";
83
- ChainId2[ChainId2["GOERLI"] = 5] = "GOERLI";
84
- ChainId2[ChainId2["BSC"] = 56] = "BSC";
85
- ChainId2[ChainId2["BSC_TESTNET"] = 97] = "BSC_TESTNET";
86
- return ChainId2;
35
+ var ChainId = /* @__PURE__ */ ((ChainId3) => {
36
+ ChainId3[ChainId3["ETHEREUM"] = 1] = "ETHEREUM";
37
+ ChainId3[ChainId3["GOERLI"] = 5] = "GOERLI";
38
+ ChainId3[ChainId3["BSC"] = 56] = "BSC";
39
+ ChainId3[ChainId3["BSC_TESTNET"] = 97] = "BSC_TESTNET";
40
+ return ChainId3;
87
41
  })(ChainId || {});
88
- var ZERO_PERCENT = new import_swap_sdk_core2.Percent("0");
89
- var ONE_HUNDRED_PERCENT = new import_swap_sdk_core2.Percent("1");
42
+ var ZERO_PERCENT = new swapSdkCore.Percent("0");
43
+ var ONE_HUNDRED_PERCENT = new swapSdkCore.Percent("1");
90
44
  var FACTORY_ADDRESS = "0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73";
91
45
  var FACTORY_ADDRESS_ETH = "0x1097053Fd2ea711dad45caCcc45EfF7548fCB362";
92
46
  var FACTORY_ADDRESS_MAP = {
@@ -104,13 +58,48 @@ var INIT_CODE_HASH_MAP = {
104
58
  [97 /* BSC_TESTNET */]: "0xd0d4c4cd0848c93cb4fd1f498d7013ee6bfb25783ea21593d5834f5d250ece66"
105
59
  };
106
60
  var WETH9 = {
107
- [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", 18, "WETH", "Wrapped Ether", "https://weth.io"),
108
- [5 /* GOERLI */]: new ERC20Token(5 /* GOERLI */, "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6", 18, "WETH", "Wrapped Ether", "https://weth.io")
61
+ [1 /* ETHEREUM */]: new ERC20Token(
62
+ 1 /* ETHEREUM */,
63
+ "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
64
+ 18,
65
+ "WETH",
66
+ "Wrapped Ether",
67
+ "https://weth.io"
68
+ ),
69
+ [5 /* GOERLI */]: new ERC20Token(
70
+ 5 /* GOERLI */,
71
+ "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
72
+ 18,
73
+ "WETH",
74
+ "Wrapped Ether",
75
+ "https://weth.io"
76
+ )
109
77
  };
110
78
  var WBNB = {
111
- [1 /* ETHEREUM */]: new ERC20Token(1 /* ETHEREUM */, "0x418D75f65a02b3D53B2418FB8E1fe493759c7605", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
112
- [56 /* BSC */]: new ERC20Token(56 /* BSC */, "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", 18, "WBNB", "Wrapped BNB", "https://www.binance.org"),
113
- [97 /* BSC_TESTNET */]: new ERC20Token(97 /* BSC_TESTNET */, "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd", 18, "WBNB", "Wrapped BNB", "https://www.binance.org")
79
+ [1 /* ETHEREUM */]: new ERC20Token(
80
+ 1 /* ETHEREUM */,
81
+ "0x418D75f65a02b3D53B2418FB8E1fe493759c7605",
82
+ 18,
83
+ "WBNB",
84
+ "Wrapped BNB",
85
+ "https://www.binance.org"
86
+ ),
87
+ [56 /* BSC */]: new ERC20Token(
88
+ 56 /* BSC */,
89
+ "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
90
+ 18,
91
+ "WBNB",
92
+ "Wrapped BNB",
93
+ "https://www.binance.org"
94
+ ),
95
+ [97 /* BSC_TESTNET */]: new ERC20Token(
96
+ 97 /* BSC_TESTNET */,
97
+ "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
98
+ 18,
99
+ "WBNB",
100
+ "Wrapped BNB",
101
+ "https://www.binance.org"
102
+ )
114
103
  };
115
104
  var WNATIVE = {
116
105
  [1 /* ETHEREUM */]: WETH9[1 /* ETHEREUM */],
@@ -149,13 +138,6 @@ function isTradeBetter(tradeA, tradeB, minimumDelta = ZERO_PERCENT) {
149
138
  }
150
139
  return tradeA.executionPrice.asFraction.multiply(minimumDelta.add(ONE_HUNDRED_PERCENT)).lessThan(tradeB.executionPrice);
151
140
  }
152
-
153
- // src/entities/pair.ts
154
- var import_swap_sdk_core3 = require("@pancakeswap/swap-sdk-core");
155
- var import_address2 = require("@ethersproject/address");
156
- var import_solidity = require("@ethersproject/solidity");
157
- var import_jsbi = __toESM(require("jsbi"));
158
- var import_tiny_invariant2 = __toESM(require("tiny-invariant"));
159
141
  var PAIR_ADDRESS_CACHE = {};
160
142
  var composeKey = (token0, token1) => `${token0.chainId}-${token0.address}-${token1.address}`;
161
143
  var computePairAddress = ({
@@ -168,7 +150,11 @@ var computePairAddress = ({
168
150
  if ((PAIR_ADDRESS_CACHE == null ? void 0 : PAIR_ADDRESS_CACHE[key]) === void 0) {
169
151
  PAIR_ADDRESS_CACHE = {
170
152
  ...PAIR_ADDRESS_CACHE,
171
- [key]: (0, import_address2.getCreate2Address)(factoryAddress, (0, import_solidity.keccak256)(["bytes"], [(0, import_solidity.pack)(["address", "address"], [token0.address, token1.address])]), INIT_CODE_HASH_MAP[token0.chainId])
153
+ [key]: address.getCreate2Address(
154
+ factoryAddress,
155
+ solidity.keccak256(["bytes"], [solidity.pack(["address", "address"], [token0.address, token1.address])]),
156
+ INIT_CODE_HASH_MAP[token0.chainId]
157
+ )
172
158
  };
173
159
  }
174
160
  return PAIR_ADDRESS_CACHE[key];
@@ -179,24 +165,47 @@ var Pair = class {
179
165
  }
180
166
  constructor(currencyAmountA, tokenAmountB) {
181
167
  const tokenAmounts = currencyAmountA.currency.sortsBefore(tokenAmountB.currency) ? [currencyAmountA, tokenAmountB] : [tokenAmountB, currencyAmountA];
182
- this.liquidityToken = new ERC20Token(tokenAmounts[0].currency.chainId, Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency), 18, "Cake-LP", "Pancake LPs");
168
+ this.liquidityToken = new ERC20Token(
169
+ tokenAmounts[0].currency.chainId,
170
+ Pair.getAddress(tokenAmounts[0].currency, tokenAmounts[1].currency),
171
+ 18,
172
+ "Cake-LP",
173
+ "Pancake LPs"
174
+ );
183
175
  this.tokenAmounts = tokenAmounts;
184
176
  }
177
+ /**
178
+ * Returns true if the token is either token0 or token1
179
+ * @param token to check
180
+ */
185
181
  involvesToken(token) {
186
182
  return token.equals(this.token0) || token.equals(this.token1);
187
183
  }
184
+ /**
185
+ * Returns the current mid price of the pair in terms of token0, i.e. the ratio of reserve1 to reserve0
186
+ */
188
187
  get token0Price() {
189
188
  const result = this.tokenAmounts[1].divide(this.tokenAmounts[0]);
190
- return new import_swap_sdk_core3.Price(this.token0, this.token1, result.denominator, result.numerator);
189
+ return new swapSdkCore.Price(this.token0, this.token1, result.denominator, result.numerator);
191
190
  }
191
+ /**
192
+ * Returns the current mid price of the pair in terms of token1, i.e. the ratio of reserve0 to reserve1
193
+ */
192
194
  get token1Price() {
193
195
  const result = this.tokenAmounts[0].divide(this.tokenAmounts[1]);
194
- return new import_swap_sdk_core3.Price(this.token1, this.token0, result.denominator, result.numerator);
196
+ return new swapSdkCore.Price(this.token1, this.token0, result.denominator, result.numerator);
195
197
  }
198
+ /**
199
+ * Return the price of the given token in terms of the other token in the pair.
200
+ * @param token token to return price of
201
+ */
196
202
  priceOf(token) {
197
- (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
203
+ invariant4__default.default(this.involvesToken(token), "TOKEN");
198
204
  return token.equals(this.token0) ? this.token0Price : this.token1Price;
199
205
  }
206
+ /**
207
+ * Returns the chain ID of the tokens in the pair.
208
+ */
200
209
  get chainId() {
201
210
  return this.token0.chainId;
202
211
  }
@@ -213,73 +222,82 @@ var Pair = class {
213
222
  return this.tokenAmounts[1];
214
223
  }
215
224
  reserveOf(token) {
216
- (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
225
+ invariant4__default.default(this.involvesToken(token), "TOKEN");
217
226
  return token.equals(this.token0) ? this.reserve0 : this.reserve1;
218
227
  }
219
228
  getOutputAmount(inputAmount) {
220
- (0, import_tiny_invariant2.default)(this.involvesToken(inputAmount.currency), "TOKEN");
221
- if (import_jsbi.default.equal(this.reserve0.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.equal(this.reserve1.quotient, import_swap_sdk_core3.ZERO)) {
222
- throw new import_swap_sdk_core3.InsufficientReservesError();
229
+ invariant4__default.default(this.involvesToken(inputAmount.currency), "TOKEN");
230
+ if (JSBI__default.default.equal(this.reserve0.quotient, swapSdkCore.ZERO) || JSBI__default.default.equal(this.reserve1.quotient, swapSdkCore.ZERO)) {
231
+ throw new swapSdkCore.InsufficientReservesError();
223
232
  }
224
233
  const inputReserve = this.reserveOf(inputAmount.currency);
225
234
  const outputReserve = this.reserveOf(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
226
- const inputAmountWithFee = import_jsbi.default.multiply(inputAmount.quotient, import_swap_sdk_core3._9975);
227
- const numerator = import_jsbi.default.multiply(inputAmountWithFee, outputReserve.quotient);
228
- const denominator = import_jsbi.default.add(import_jsbi.default.multiply(inputReserve.quotient, import_swap_sdk_core3._10000), inputAmountWithFee);
229
- const outputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(inputAmount.currency.equals(this.token0) ? this.token1 : this.token0, import_jsbi.default.divide(numerator, denominator));
230
- if (import_jsbi.default.equal(outputAmount.quotient, import_swap_sdk_core3.ZERO)) {
231
- throw new import_swap_sdk_core3.InsufficientInputAmountError();
235
+ const inputAmountWithFee = JSBI__default.default.multiply(inputAmount.quotient, swapSdkCore._9975);
236
+ const numerator = JSBI__default.default.multiply(inputAmountWithFee, outputReserve.quotient);
237
+ const denominator = JSBI__default.default.add(JSBI__default.default.multiply(inputReserve.quotient, swapSdkCore._10000), inputAmountWithFee);
238
+ const outputAmount = swapSdkCore.CurrencyAmount.fromRawAmount(
239
+ inputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
240
+ JSBI__default.default.divide(numerator, denominator)
241
+ );
242
+ if (JSBI__default.default.equal(outputAmount.quotient, swapSdkCore.ZERO)) {
243
+ throw new swapSdkCore.InsufficientInputAmountError();
232
244
  }
233
245
  return [outputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
234
246
  }
235
247
  getInputAmount(outputAmount) {
236
- (0, import_tiny_invariant2.default)(this.involvesToken(outputAmount.currency), "TOKEN");
237
- if (import_jsbi.default.equal(this.reserve0.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.equal(this.reserve1.quotient, import_swap_sdk_core3.ZERO) || import_jsbi.default.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient)) {
238
- throw new import_swap_sdk_core3.InsufficientReservesError();
248
+ invariant4__default.default(this.involvesToken(outputAmount.currency), "TOKEN");
249
+ if (JSBI__default.default.equal(this.reserve0.quotient, swapSdkCore.ZERO) || JSBI__default.default.equal(this.reserve1.quotient, swapSdkCore.ZERO) || JSBI__default.default.greaterThanOrEqual(outputAmount.quotient, this.reserveOf(outputAmount.currency).quotient)) {
250
+ throw new swapSdkCore.InsufficientReservesError();
239
251
  }
240
252
  const outputReserve = this.reserveOf(outputAmount.currency);
241
253
  const inputReserve = this.reserveOf(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0);
242
- const numerator = import_jsbi.default.multiply(import_jsbi.default.multiply(inputReserve.quotient, outputAmount.quotient), import_swap_sdk_core3._10000);
243
- const denominator = import_jsbi.default.multiply(import_jsbi.default.subtract(outputReserve.quotient, outputAmount.quotient), import_swap_sdk_core3._9975);
244
- const inputAmount = import_swap_sdk_core3.CurrencyAmount.fromRawAmount(outputAmount.currency.equals(this.token0) ? this.token1 : this.token0, import_jsbi.default.add(import_jsbi.default.divide(numerator, denominator), import_swap_sdk_core3.ONE));
254
+ const numerator = JSBI__default.default.multiply(JSBI__default.default.multiply(inputReserve.quotient, outputAmount.quotient), swapSdkCore._10000);
255
+ const denominator = JSBI__default.default.multiply(JSBI__default.default.subtract(outputReserve.quotient, outputAmount.quotient), swapSdkCore._9975);
256
+ const inputAmount = swapSdkCore.CurrencyAmount.fromRawAmount(
257
+ outputAmount.currency.equals(this.token0) ? this.token1 : this.token0,
258
+ JSBI__default.default.add(JSBI__default.default.divide(numerator, denominator), swapSdkCore.ONE)
259
+ );
245
260
  return [inputAmount, new Pair(inputReserve.add(inputAmount), outputReserve.subtract(outputAmount))];
246
261
  }
247
262
  getLiquidityMinted(totalSupply, tokenAmountA, tokenAmountB) {
248
- (0, import_tiny_invariant2.default)(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
263
+ invariant4__default.default(totalSupply.currency.equals(this.liquidityToken), "LIQUIDITY");
249
264
  const tokenAmounts = tokenAmountA.currency.sortsBefore(tokenAmountB.currency) ? [tokenAmountA, tokenAmountB] : [tokenAmountB, tokenAmountA];
250
- (0, import_tiny_invariant2.default)(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
265
+ invariant4__default.default(tokenAmounts[0].currency.equals(this.token0) && tokenAmounts[1].currency.equals(this.token1), "TOKEN");
251
266
  let liquidity;
252
- if (import_jsbi.default.equal(totalSupply.quotient, import_swap_sdk_core3.ZERO)) {
253
- liquidity = import_jsbi.default.subtract((0, import_swap_sdk_core3.sqrt)(import_jsbi.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)), import_swap_sdk_core3.MINIMUM_LIQUIDITY);
267
+ if (JSBI__default.default.equal(totalSupply.quotient, swapSdkCore.ZERO)) {
268
+ liquidity = JSBI__default.default.subtract(
269
+ swapSdkCore.sqrt(JSBI__default.default.multiply(tokenAmounts[0].quotient, tokenAmounts[1].quotient)),
270
+ swapSdkCore.MINIMUM_LIQUIDITY
271
+ );
254
272
  } else {
255
- const amount0 = import_jsbi.default.divide(import_jsbi.default.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
256
- const amount1 = import_jsbi.default.divide(import_jsbi.default.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
257
- liquidity = import_jsbi.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
273
+ const amount0 = JSBI__default.default.divide(JSBI__default.default.multiply(tokenAmounts[0].quotient, totalSupply.quotient), this.reserve0.quotient);
274
+ const amount1 = JSBI__default.default.divide(JSBI__default.default.multiply(tokenAmounts[1].quotient, totalSupply.quotient), this.reserve1.quotient);
275
+ liquidity = JSBI__default.default.lessThanOrEqual(amount0, amount1) ? amount0 : amount1;
258
276
  }
259
- if (!import_jsbi.default.greaterThan(liquidity, import_swap_sdk_core3.ZERO)) {
260
- throw new import_swap_sdk_core3.InsufficientInputAmountError();
277
+ if (!JSBI__default.default.greaterThan(liquidity, swapSdkCore.ZERO)) {
278
+ throw new swapSdkCore.InsufficientInputAmountError();
261
279
  }
262
- return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
280
+ return swapSdkCore.CurrencyAmount.fromRawAmount(this.liquidityToken, liquidity);
263
281
  }
264
282
  getLiquidityValue(token, totalSupply, liquidity, feeOn = false, kLast) {
265
- (0, import_tiny_invariant2.default)(this.involvesToken(token), "TOKEN");
266
- (0, import_tiny_invariant2.default)(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
267
- (0, import_tiny_invariant2.default)(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
268
- (0, import_tiny_invariant2.default)(import_jsbi.default.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
283
+ invariant4__default.default(this.involvesToken(token), "TOKEN");
284
+ invariant4__default.default(totalSupply.currency.equals(this.liquidityToken), "TOTAL_SUPPLY");
285
+ invariant4__default.default(liquidity.currency.equals(this.liquidityToken), "LIQUIDITY");
286
+ invariant4__default.default(JSBI__default.default.lessThanOrEqual(liquidity.quotient, totalSupply.quotient), "LIQUIDITY");
269
287
  let totalSupplyAdjusted;
270
288
  if (!feeOn) {
271
289
  totalSupplyAdjusted = totalSupply;
272
290
  } else {
273
- (0, import_tiny_invariant2.default)(!!kLast, "K_LAST");
274
- const kLastParsed = import_jsbi.default.BigInt(kLast);
275
- if (!import_jsbi.default.equal(kLastParsed, import_swap_sdk_core3.ZERO)) {
276
- const rootK = (0, import_swap_sdk_core3.sqrt)(import_jsbi.default.multiply(this.reserve0.quotient, this.reserve1.quotient));
277
- const rootKLast = (0, import_swap_sdk_core3.sqrt)(kLastParsed);
278
- if (import_jsbi.default.greaterThan(rootK, rootKLast)) {
279
- const numerator = import_jsbi.default.multiply(totalSupply.quotient, import_jsbi.default.subtract(rootK, rootKLast));
280
- const denominator = import_jsbi.default.add(import_jsbi.default.multiply(rootK, import_swap_sdk_core3.FIVE), rootKLast);
281
- const feeLiquidity = import_jsbi.default.divide(numerator, denominator);
282
- totalSupplyAdjusted = totalSupply.add(import_swap_sdk_core3.CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity));
291
+ invariant4__default.default(!!kLast, "K_LAST");
292
+ const kLastParsed = JSBI__default.default.BigInt(kLast);
293
+ if (!JSBI__default.default.equal(kLastParsed, swapSdkCore.ZERO)) {
294
+ const rootK = swapSdkCore.sqrt(JSBI__default.default.multiply(this.reserve0.quotient, this.reserve1.quotient));
295
+ const rootKLast = swapSdkCore.sqrt(kLastParsed);
296
+ if (JSBI__default.default.greaterThan(rootK, rootKLast)) {
297
+ const numerator = JSBI__default.default.multiply(totalSupply.quotient, JSBI__default.default.subtract(rootK, rootKLast));
298
+ const denominator = JSBI__default.default.add(JSBI__default.default.multiply(rootK, swapSdkCore.FIVE), rootKLast);
299
+ const feeLiquidity = JSBI__default.default.divide(numerator, denominator);
300
+ totalSupplyAdjusted = totalSupply.add(swapSdkCore.CurrencyAmount.fromRawAmount(this.liquidityToken, feeLiquidity));
283
301
  } else {
284
302
  totalSupplyAdjusted = totalSupply;
285
303
  }
@@ -287,26 +305,28 @@ var Pair = class {
287
305
  totalSupplyAdjusted = totalSupply;
288
306
  }
289
307
  }
290
- return import_swap_sdk_core3.CurrencyAmount.fromRawAmount(token, import_jsbi.default.divide(import_jsbi.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient));
308
+ return swapSdkCore.CurrencyAmount.fromRawAmount(
309
+ token,
310
+ JSBI__default.default.divide(JSBI__default.default.multiply(liquidity.quotient, this.reserveOf(token).quotient), totalSupplyAdjusted.quotient)
311
+ );
291
312
  }
292
313
  };
293
-
294
- // src/entities/route.ts
295
- var import_tiny_invariant3 = __toESM(require("tiny-invariant"));
296
- var import_swap_sdk_core4 = require("@pancakeswap/swap-sdk-core");
297
314
  var Route = class {
298
315
  constructor(pairs, input, output) {
299
316
  this._midPrice = null;
300
- (0, import_tiny_invariant3.default)(pairs.length > 0, "PAIRS");
317
+ invariant4__default.default(pairs.length > 0, "PAIRS");
301
318
  const chainId = pairs[0].chainId;
302
- (0, import_tiny_invariant3.default)(pairs.every((pair) => pair.chainId === chainId), "CHAIN_IDS");
319
+ invariant4__default.default(
320
+ pairs.every((pair) => pair.chainId === chainId),
321
+ "CHAIN_IDS"
322
+ );
303
323
  const wrappedInput = input.wrapped;
304
- (0, import_tiny_invariant3.default)(pairs[0].involvesToken(wrappedInput), "INPUT");
305
- (0, import_tiny_invariant3.default)(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
324
+ invariant4__default.default(pairs[0].involvesToken(wrappedInput), "INPUT");
325
+ invariant4__default.default(typeof output === "undefined" || pairs[pairs.length - 1].involvesToken(output.wrapped), "OUTPUT");
306
326
  const path = [wrappedInput];
307
327
  for (const [i, pair] of pairs.entries()) {
308
328
  const currentInput = path[i];
309
- (0, import_tiny_invariant3.default)(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
329
+ invariant4__default.default(currentInput.equals(pair.token0) || currentInput.equals(pair.token1), "PATH");
310
330
  const output2 = currentInput.equals(pair.token0) ? pair.token1 : pair.token0;
311
331
  path.push(output2);
312
332
  }
@@ -320,22 +340,20 @@ var Route = class {
320
340
  return this._midPrice;
321
341
  const prices = [];
322
342
  for (const [i, pair] of this.pairs.entries()) {
323
- prices.push(this.path[i].equals(pair.token0) ? new import_swap_sdk_core4.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new import_swap_sdk_core4.Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient));
343
+ prices.push(
344
+ this.path[i].equals(pair.token0) ? new swapSdkCore.Price(pair.reserve0.currency, pair.reserve1.currency, pair.reserve0.quotient, pair.reserve1.quotient) : new swapSdkCore.Price(pair.reserve1.currency, pair.reserve0.currency, pair.reserve1.quotient, pair.reserve0.quotient)
345
+ );
324
346
  }
325
347
  const reduced = prices.slice(1).reduce((accumulator, currentValue) => accumulator.multiply(currentValue), prices[0]);
326
- return this._midPrice = new import_swap_sdk_core4.Price(this.input, this.output, reduced.denominator, reduced.numerator);
348
+ return this._midPrice = new swapSdkCore.Price(this.input, this.output, reduced.denominator, reduced.numerator);
327
349
  }
328
350
  get chainId() {
329
351
  return this.pairs[0].chainId;
330
352
  }
331
353
  };
332
-
333
- // src/entities/trade.ts
334
- var import_tiny_invariant4 = __toESM(require("tiny-invariant"));
335
- var import_swap_sdk_core5 = require("@pancakeswap/swap-sdk-core");
336
354
  function inputOutputComparator(a, b) {
337
- (0, import_tiny_invariant4.default)(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
338
- (0, import_tiny_invariant4.default)(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
355
+ invariant4__default.default(a.inputAmount.currency.equals(b.inputAmount.currency), "INPUT_CURRENCY");
356
+ invariant4__default.default(a.outputAmount.currency.equals(b.outputAmount.currency), "OUTPUT_CURRENCY");
339
357
  if (a.outputAmount.equalTo(b.outputAmount)) {
340
358
  if (a.inputAmount.equalTo(b.inputAmount)) {
341
359
  return 0;
@@ -364,67 +382,112 @@ function tradeComparator(a, b) {
364
382
  return a.route.path.length - b.route.path.length;
365
383
  }
366
384
  var Trade = class {
385
+ /**
386
+ * Constructs an exact in trade with the given amount in and route
387
+ * @param route route of the exact in trade
388
+ * @param amountIn the amount being passed in
389
+ */
367
390
  static exactIn(route, amountIn) {
368
- return new Trade(route, amountIn, import_swap_sdk_core5.TradeType.EXACT_INPUT);
391
+ return new Trade(route, amountIn, swapSdkCore.TradeType.EXACT_INPUT);
369
392
  }
393
+ /**
394
+ * Constructs an exact out trade with the given amount out and route
395
+ * @param route route of the exact out trade
396
+ * @param amountOut the amount returned by the trade
397
+ */
370
398
  static exactOut(route, amountOut) {
371
- return new Trade(route, amountOut, import_swap_sdk_core5.TradeType.EXACT_OUTPUT);
399
+ return new Trade(route, amountOut, swapSdkCore.TradeType.EXACT_OUTPUT);
372
400
  }
373
401
  constructor(route, amount, tradeType) {
374
402
  this.route = route;
375
403
  this.tradeType = tradeType;
376
404
  const tokenAmounts = new Array(route.path.length);
377
- if (tradeType === import_swap_sdk_core5.TradeType.EXACT_INPUT) {
378
- (0, import_tiny_invariant4.default)(amount.currency.equals(route.input), "INPUT");
405
+ if (tradeType === swapSdkCore.TradeType.EXACT_INPUT) {
406
+ invariant4__default.default(amount.currency.equals(route.input), "INPUT");
379
407
  tokenAmounts[0] = amount.wrapped;
380
408
  for (let i = 0; i < route.path.length - 1; i++) {
381
409
  const pair = route.pairs[i];
382
410
  const [outputAmount] = pair.getOutputAmount(tokenAmounts[i]);
383
411
  tokenAmounts[i + 1] = outputAmount;
384
412
  }
385
- this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
386
- this.outputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.output, tokenAmounts[tokenAmounts.length - 1].numerator, tokenAmounts[tokenAmounts.length - 1].denominator);
413
+ this.inputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(route.input, amount.numerator, amount.denominator);
414
+ this.outputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(
415
+ route.output,
416
+ tokenAmounts[tokenAmounts.length - 1].numerator,
417
+ tokenAmounts[tokenAmounts.length - 1].denominator
418
+ );
387
419
  } else {
388
- (0, import_tiny_invariant4.default)(amount.currency.equals(route.output), "OUTPUT");
420
+ invariant4__default.default(amount.currency.equals(route.output), "OUTPUT");
389
421
  tokenAmounts[tokenAmounts.length - 1] = amount.wrapped;
390
422
  for (let i = route.path.length - 1; i > 0; i--) {
391
423
  const pair = route.pairs[i - 1];
392
424
  const [inputAmount] = pair.getInputAmount(tokenAmounts[i]);
393
425
  tokenAmounts[i - 1] = inputAmount;
394
426
  }
395
- this.inputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.input, tokenAmounts[0].numerator, tokenAmounts[0].denominator);
396
- this.outputAmount = import_swap_sdk_core5.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
427
+ this.inputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(
428
+ route.input,
429
+ tokenAmounts[0].numerator,
430
+ tokenAmounts[0].denominator
431
+ );
432
+ this.outputAmount = swapSdkCore.CurrencyAmount.fromFractionalAmount(route.output, amount.numerator, amount.denominator);
397
433
  }
398
- this.executionPrice = new import_swap_sdk_core5.Price(this.inputAmount.currency, this.outputAmount.currency, this.inputAmount.quotient, this.outputAmount.quotient);
399
- this.priceImpact = (0, import_swap_sdk_core5.computePriceImpact)(route.midPrice, this.inputAmount, this.outputAmount);
400
- }
434
+ this.executionPrice = new swapSdkCore.Price(
435
+ this.inputAmount.currency,
436
+ this.outputAmount.currency,
437
+ this.inputAmount.quotient,
438
+ this.outputAmount.quotient
439
+ );
440
+ this.priceImpact = swapSdkCore.computePriceImpact(route.midPrice, this.inputAmount, this.outputAmount);
441
+ }
442
+ /**
443
+ * Get the minimum amount that must be received from this trade for the given slippage tolerance
444
+ * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
445
+ */
401
446
  minimumAmountOut(slippageTolerance) {
402
- (0, import_tiny_invariant4.default)(!slippageTolerance.lessThan(import_swap_sdk_core5.ZERO), "SLIPPAGE_TOLERANCE");
403
- if (this.tradeType === import_swap_sdk_core5.TradeType.EXACT_OUTPUT) {
447
+ invariant4__default.default(!slippageTolerance.lessThan(swapSdkCore.ZERO), "SLIPPAGE_TOLERANCE");
448
+ if (this.tradeType === swapSdkCore.TradeType.EXACT_OUTPUT) {
404
449
  return this.outputAmount;
405
450
  }
406
- const slippageAdjustedAmountOut = new import_swap_sdk_core5.Fraction(import_swap_sdk_core5.ONE).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
407
- return import_swap_sdk_core5.CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
451
+ const slippageAdjustedAmountOut = new swapSdkCore.Fraction(swapSdkCore.ONE).add(slippageTolerance).invert().multiply(this.outputAmount.quotient).quotient;
452
+ return swapSdkCore.CurrencyAmount.fromRawAmount(this.outputAmount.currency, slippageAdjustedAmountOut);
408
453
  }
454
+ /**
455
+ * Get the maximum amount in that can be spent via this trade for the given slippage tolerance
456
+ * @param slippageTolerance tolerance of unfavorable slippage from the execution price of this trade
457
+ */
409
458
  maximumAmountIn(slippageTolerance) {
410
- (0, import_tiny_invariant4.default)(!slippageTolerance.lessThan(import_swap_sdk_core5.ZERO), "SLIPPAGE_TOLERANCE");
411
- if (this.tradeType === import_swap_sdk_core5.TradeType.EXACT_INPUT) {
459
+ invariant4__default.default(!slippageTolerance.lessThan(swapSdkCore.ZERO), "SLIPPAGE_TOLERANCE");
460
+ if (this.tradeType === swapSdkCore.TradeType.EXACT_INPUT) {
412
461
  return this.inputAmount;
413
462
  }
414
- const slippageAdjustedAmountIn = new import_swap_sdk_core5.Fraction(import_swap_sdk_core5.ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
415
- return import_swap_sdk_core5.CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
416
- }
463
+ const slippageAdjustedAmountIn = new swapSdkCore.Fraction(swapSdkCore.ONE).add(slippageTolerance).multiply(this.inputAmount.quotient).quotient;
464
+ return swapSdkCore.CurrencyAmount.fromRawAmount(this.inputAmount.currency, slippageAdjustedAmountIn);
465
+ }
466
+ /**
467
+ * Given a list of pairs, and a fixed amount in, returns the top `maxNumResults` trades that go from an input token
468
+ * amount to an output token, making at most `maxHops` hops.
469
+ * Note this does not consider aggregation, as routes are linear. It's possible a better route exists by splitting
470
+ * the amount in among multiple routes.
471
+ * @param pairs the pairs to consider in finding the best trade
472
+ * @param nextAmountIn exact amount of input currency to spend
473
+ * @param currencyOut the desired currency out
474
+ * @param maxNumResults maximum number of results to return
475
+ * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
476
+ * @param currentPairs used in recursion; the current list of pairs
477
+ * @param currencyAmountIn used in recursion; the original value of the currencyAmountIn parameter
478
+ * @param bestTrades used in recursion; the current list of best trades
479
+ */
417
480
  static bestTradeExactIn(pairs, currencyAmountIn, currencyOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountIn = currencyAmountIn, bestTrades = []) {
418
- (0, import_tiny_invariant4.default)(pairs.length > 0, "PAIRS");
419
- (0, import_tiny_invariant4.default)(maxHops > 0, "MAX_HOPS");
420
- (0, import_tiny_invariant4.default)(currencyAmountIn === nextAmountIn || currentPairs.length > 0, "INVALID_RECURSION");
481
+ invariant4__default.default(pairs.length > 0, "PAIRS");
482
+ invariant4__default.default(maxHops > 0, "MAX_HOPS");
483
+ invariant4__default.default(currencyAmountIn === nextAmountIn || currentPairs.length > 0, "INVALID_RECURSION");
421
484
  const amountIn = nextAmountIn.wrapped;
422
485
  const tokenOut = currencyOut.wrapped;
423
486
  for (let i = 0; i < pairs.length; i++) {
424
487
  const pair = pairs[i];
425
488
  if (!pair.token0.equals(amountIn.currency) && !pair.token1.equals(amountIn.currency))
426
489
  continue;
427
- if (pair.reserve0.equalTo(import_swap_sdk_core5.ZERO) || pair.reserve1.equalTo(import_swap_sdk_core5.ZERO))
490
+ if (pair.reserve0.equalTo(swapSdkCore.ZERO) || pair.reserve1.equalTo(swapSdkCore.ZERO))
428
491
  continue;
429
492
  let amountOut;
430
493
  try {
@@ -437,31 +500,72 @@ var Trade = class {
437
500
  throw error;
438
501
  }
439
502
  if (amountOut.currency.equals(tokenOut)) {
440
- (0, import_swap_sdk_core5.sortedInsert)(bestTrades, new Trade(new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut), currencyAmountIn, import_swap_sdk_core5.TradeType.EXACT_INPUT), maxNumResults, tradeComparator);
503
+ swapSdkCore.sortedInsert(
504
+ bestTrades,
505
+ new Trade(
506
+ new Route([...currentPairs, pair], currencyAmountIn.currency, currencyOut),
507
+ currencyAmountIn,
508
+ swapSdkCore.TradeType.EXACT_INPUT
509
+ ),
510
+ maxNumResults,
511
+ tradeComparator
512
+ );
441
513
  } else if (maxHops > 1 && pairs.length > 1) {
442
514
  const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
443
- Trade.bestTradeExactIn(pairsExcludingThisPair, currencyAmountIn, currencyOut, {
444
- maxNumResults,
445
- maxHops: maxHops - 1
446
- }, [...currentPairs, pair], amountOut, bestTrades);
515
+ Trade.bestTradeExactIn(
516
+ pairsExcludingThisPair,
517
+ currencyAmountIn,
518
+ currencyOut,
519
+ {
520
+ maxNumResults,
521
+ maxHops: maxHops - 1
522
+ },
523
+ [...currentPairs, pair],
524
+ amountOut,
525
+ bestTrades
526
+ );
447
527
  }
448
528
  }
449
529
  return bestTrades;
450
530
  }
531
+ /**
532
+ * Return the execution price after accounting for slippage tolerance
533
+ * @param slippageTolerance the allowed tolerated slippage
534
+ */
451
535
  worstExecutionPrice(slippageTolerance) {
452
- return new import_swap_sdk_core5.Price(this.inputAmount.currency, this.outputAmount.currency, this.maximumAmountIn(slippageTolerance).quotient, this.minimumAmountOut(slippageTolerance).quotient);
453
- }
536
+ return new swapSdkCore.Price(
537
+ this.inputAmount.currency,
538
+ this.outputAmount.currency,
539
+ this.maximumAmountIn(slippageTolerance).quotient,
540
+ this.minimumAmountOut(slippageTolerance).quotient
541
+ );
542
+ }
543
+ /**
544
+ * similar to the above method but instead targets a fixed output amount
545
+ * given a list of pairs, and a fixed amount out, returns the top `maxNumResults` trades that go from an input token
546
+ * to an output token amount, making at most `maxHops` hops
547
+ * note this does not consider aggregation, as routes are linear. it's possible a better route exists by splitting
548
+ * the amount in among multiple routes.
549
+ * @param pairs the pairs to consider in finding the best trade
550
+ * @param currencyIn the currency to spend
551
+ * @param nextAmountOut the exact amount of currency out
552
+ * @param maxNumResults maximum number of results to return
553
+ * @param maxHops maximum number of hops a returned trade can make, e.g. 1 hop goes through a single pair
554
+ * @param currentPairs used in recursion; the current list of pairs
555
+ * @param currencyAmountOut used in recursion; the original value of the currencyAmountOut parameter
556
+ * @param bestTrades used in recursion; the current list of best trades
557
+ */
454
558
  static bestTradeExactOut(pairs, currencyIn, currencyAmountOut, { maxNumResults = 3, maxHops = 3 } = {}, currentPairs = [], nextAmountOut = currencyAmountOut, bestTrades = []) {
455
- (0, import_tiny_invariant4.default)(pairs.length > 0, "PAIRS");
456
- (0, import_tiny_invariant4.default)(maxHops > 0, "MAX_HOPS");
457
- (0, import_tiny_invariant4.default)(currencyAmountOut === nextAmountOut || currentPairs.length > 0, "INVALID_RECURSION");
559
+ invariant4__default.default(pairs.length > 0, "PAIRS");
560
+ invariant4__default.default(maxHops > 0, "MAX_HOPS");
561
+ invariant4__default.default(currencyAmountOut === nextAmountOut || currentPairs.length > 0, "INVALID_RECURSION");
458
562
  const amountOut = nextAmountOut.wrapped;
459
563
  const tokenIn = currencyIn.wrapped;
460
564
  for (let i = 0; i < pairs.length; i++) {
461
565
  const pair = pairs[i];
462
566
  if (!pair.token0.equals(amountOut.currency) && !pair.token1.equals(amountOut.currency))
463
567
  continue;
464
- if (pair.reserve0.equalTo(import_swap_sdk_core5.ZERO) || pair.reserve1.equalTo(import_swap_sdk_core5.ZERO))
568
+ if (pair.reserve0.equalTo(swapSdkCore.ZERO) || pair.reserve1.equalTo(swapSdkCore.ZERO))
465
569
  continue;
466
570
  let amountIn;
467
571
  try {
@@ -474,23 +578,36 @@ var Trade = class {
474
578
  throw error;
475
579
  }
476
580
  if (amountIn.currency.equals(tokenIn)) {
477
- (0, import_swap_sdk_core5.sortedInsert)(bestTrades, new Trade(new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency), currencyAmountOut, import_swap_sdk_core5.TradeType.EXACT_OUTPUT), maxNumResults, tradeComparator);
581
+ swapSdkCore.sortedInsert(
582
+ bestTrades,
583
+ new Trade(
584
+ new Route([pair, ...currentPairs], currencyIn, currencyAmountOut.currency),
585
+ currencyAmountOut,
586
+ swapSdkCore.TradeType.EXACT_OUTPUT
587
+ ),
588
+ maxNumResults,
589
+ tradeComparator
590
+ );
478
591
  } else if (maxHops > 1 && pairs.length > 1) {
479
592
  const pairsExcludingThisPair = pairs.slice(0, i).concat(pairs.slice(i + 1, pairs.length));
480
- Trade.bestTradeExactOut(pairsExcludingThisPair, currencyIn, currencyAmountOut, {
481
- maxNumResults,
482
- maxHops: maxHops - 1
483
- }, [pair, ...currentPairs], amountIn, bestTrades);
593
+ Trade.bestTradeExactOut(
594
+ pairsExcludingThisPair,
595
+ currencyIn,
596
+ currencyAmountOut,
597
+ {
598
+ maxNumResults,
599
+ maxHops: maxHops - 1
600
+ },
601
+ [pair, ...currentPairs],
602
+ amountIn,
603
+ bestTrades
604
+ );
484
605
  }
485
606
  }
486
607
  return bestTrades;
487
608
  }
488
609
  };
489
-
490
- // src/entities/native.ts
491
- var import_tiny_invariant5 = __toESM(require("tiny-invariant"));
492
- var import_swap_sdk_core6 = require("@pancakeswap/swap-sdk-core");
493
- var _Native = class extends import_swap_sdk_core6.NativeCurrency {
610
+ var _Native = class extends swapSdkCore.NativeCurrency {
494
611
  constructor({
495
612
  chainId,
496
613
  decimals,
@@ -501,14 +618,14 @@ var _Native = class extends import_swap_sdk_core6.NativeCurrency {
501
618
  }
502
619
  get wrapped() {
503
620
  const wnative = WNATIVE[this.chainId];
504
- (0, import_tiny_invariant5.default)(!!wnative, "WRAPPED");
621
+ invariant4__default.default(!!wnative, "WRAPPED");
505
622
  return wnative;
506
623
  }
507
624
  static onChain(chainId) {
508
625
  if (chainId in this.cache) {
509
626
  return this.cache[chainId];
510
627
  }
511
- (0, import_tiny_invariant5.default)(!!NATIVE[chainId], "NATIVE_CURRENCY");
628
+ invariant4__default.default(!!NATIVE[chainId], "NATIVE_CURRENCY");
512
629
  const { decimals, name, symbol } = NATIVE[chainId];
513
630
  return this.cache[chainId] = new _Native({ chainId, decimals, symbol, name });
514
631
  }
@@ -518,33 +635,32 @@ var _Native = class extends import_swap_sdk_core6.NativeCurrency {
518
635
  };
519
636
  var Native = _Native;
520
637
  Native.cache = {};
521
-
522
- // src/router.ts
523
- var import_swap_sdk_core7 = require("@pancakeswap/swap-sdk-core");
524
- var import_tiny_invariant6 = __toESM(require("tiny-invariant"));
525
638
  function toHex(currencyAmount) {
526
639
  return `0x${currencyAmount.quotient.toString(16)}`;
527
640
  }
528
641
  var ZERO_HEX = "0x0";
529
642
  var Router = class {
530
- constructor() {
531
- }
643
+ /**
644
+ * Produces the on-chain method name to call and the hex encoded parameters to pass as arguments for a given trade.
645
+ * @param trade to produce call parameters for
646
+ * @param options options for the call parameters
647
+ */
532
648
  static swapCallParameters(trade, options) {
533
649
  const etherIn = trade.inputAmount.currency.isNative;
534
650
  const etherOut = trade.outputAmount.currency.isNative;
535
- (0, import_tiny_invariant6.default)(!(etherIn && etherOut), "ETHER_IN_OUT");
536
- (0, import_tiny_invariant6.default)(!("ttl" in options) || options.ttl > 0, "TTL");
651
+ invariant4__default.default(!(etherIn && etherOut), "ETHER_IN_OUT");
652
+ invariant4__default.default(!("ttl" in options) || options.ttl > 0, "TTL");
537
653
  const to = validateAndParseAddress(options.recipient);
538
654
  const amountIn = toHex(trade.maximumAmountIn(options.allowedSlippage));
539
655
  const amountOut = toHex(trade.minimumAmountOut(options.allowedSlippage));
540
656
  const path = trade.route.path.map((token) => token.address);
541
- const deadline = "ttl" in options ? `0x${(Math.floor(new Date().getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
657
+ const deadline = "ttl" in options ? `0x${(Math.floor(( new Date()).getTime() / 1e3) + options.ttl).toString(16)}` : `0x${options.deadline.toString(16)}`;
542
658
  const useFeeOnTransfer = Boolean(options.feeOnTransfer);
543
659
  let methodName;
544
660
  let args;
545
661
  let value;
546
662
  switch (trade.tradeType) {
547
- case import_swap_sdk_core7.TradeType.EXACT_INPUT:
663
+ case swapSdkCore.TradeType.EXACT_INPUT:
548
664
  if (etherIn) {
549
665
  methodName = useFeeOnTransfer ? "swapExactETHForTokensSupportingFeeOnTransferTokens" : "swapExactETHForTokens";
550
666
  args = [amountOut, path, to, deadline];
@@ -559,8 +675,8 @@ var Router = class {
559
675
  value = ZERO_HEX;
560
676
  }
561
677
  break;
562
- case import_swap_sdk_core7.TradeType.EXACT_OUTPUT:
563
- (0, import_tiny_invariant6.default)(!useFeeOnTransfer, "EXACT_OUT_FOT");
678
+ case swapSdkCore.TradeType.EXACT_OUTPUT:
679
+ invariant4__default.default(!useFeeOnTransfer, "EXACT_OUT_FOT");
564
680
  if (etherIn) {
565
681
  methodName = "swapETHForExactTokens";
566
682
  args = [amountOut, path, to, deadline];
@@ -583,31 +699,58 @@ var Router = class {
583
699
  };
584
700
  }
585
701
  };
702
+ var _Ether = class extends swapSdkCore.NativeCurrency {
703
+ constructor(chainId) {
704
+ super(chainId, 18, "ETH", "Ether");
705
+ }
706
+ get wrapped() {
707
+ const weth9 = WETH9[this.chainId];
708
+ invariant4__default.default(!!weth9, "WRAPPED");
709
+ return weth9;
710
+ }
711
+ static onChain(chainId) {
712
+ if (!this._etherCache[chainId]) {
713
+ this._etherCache[chainId] = new _Ether(chainId);
714
+ }
715
+ return this._etherCache[chainId];
716
+ }
717
+ equals(other) {
718
+ return other.isNative && other.chainId === this.chainId;
719
+ }
720
+ };
721
+ var Ether = _Ether;
722
+ Ether._etherCache = {};
586
723
 
587
- // src/index.ts
588
- __reExport(src_exports, require("@pancakeswap/swap-sdk-core"), module.exports);
589
- // Annotate the CommonJS export names for ESM import in node:
590
- 0 && (module.exports = {
591
- ChainId,
592
- ERC20Token,
593
- FACTORY_ADDRESS,
594
- FACTORY_ADDRESS_MAP,
595
- INIT_CODE_HASH,
596
- INIT_CODE_HASH_MAP,
597
- JSBI,
598
- NATIVE,
599
- Native,
600
- ONE_HUNDRED_PERCENT,
601
- Pair,
602
- Route,
603
- Router,
604
- Trade,
605
- WBNB,
606
- WETH9,
607
- WNATIVE,
608
- ZERO_PERCENT,
609
- computePairAddress,
610
- inputOutputComparator,
611
- isTradeBetter,
612
- tradeComparator
724
+ Object.defineProperty(exports, 'JSBI', {
725
+ enumerable: true,
726
+ get: function () { return JSBI__default.default; }
727
+ });
728
+ exports.ChainId = ChainId;
729
+ exports.ERC20Token = ERC20Token;
730
+ exports.Ether = Ether;
731
+ exports.FACTORY_ADDRESS = FACTORY_ADDRESS;
732
+ exports.FACTORY_ADDRESS_MAP = FACTORY_ADDRESS_MAP;
733
+ exports.INIT_CODE_HASH = INIT_CODE_HASH;
734
+ exports.INIT_CODE_HASH_MAP = INIT_CODE_HASH_MAP;
735
+ exports.NATIVE = NATIVE;
736
+ exports.Native = Native;
737
+ exports.ONE_HUNDRED_PERCENT = ONE_HUNDRED_PERCENT;
738
+ exports.Pair = Pair;
739
+ exports.Route = Route;
740
+ exports.Router = Router;
741
+ exports.Trade = Trade;
742
+ exports.WBNB = WBNB;
743
+ exports.WETH9 = WETH9;
744
+ exports.WNATIVE = WNATIVE;
745
+ exports.ZERO_PERCENT = ZERO_PERCENT;
746
+ exports.computePairAddress = computePairAddress;
747
+ exports.inputOutputComparator = inputOutputComparator;
748
+ exports.isTradeBetter = isTradeBetter;
749
+ exports.tradeComparator = tradeComparator;
750
+ exports.validateAndParseAddress = validateAndParseAddress;
751
+ Object.keys(swapSdkCore).forEach(function (k) {
752
+ if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
753
+ enumerable: true,
754
+ get: function () { return swapSdkCore[k]; }
755
+ });
613
756
  });