@paraswap/dex-lib 3.6.2 → 3.6.3

package/src/abi/maverick-v2/MaverickV2Quoter.json

@@ -0,0 +1,278 @@
+[
+  {
+    "inputs": [],
+    "name": "BytesLibSliceOutOfBounds",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BytesLibSliceOverflow",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BytesLibToAddressOutOfBounds",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BytesLibToBoolOutOfBounds",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "MathOverflowedMulDiv",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "QuoterInvalidAddLiquidity",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "QuoterInvalidSwap",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint8",
+        "name": "bits",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "SafeCastOverflowedUintDowncast",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "int256",
+        "name": "tick",
+        "type": "int256"
+      }
+    ],
+    "name": "TickMaxExceeded",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IMaverickV2Pool",
+        "name": "pool",
+        "type": "address"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint8",
+            "name": "kind",
+            "type": "uint8"
+          },
+          {
+            "internalType": "int32[]",
+            "name": "ticks",
+            "type": "int32[]"
+          },
+          {
+            "internalType": "uint128[]",
+            "name": "amounts",
+            "type": "uint128[]"
+          }
+        ],
+        "internalType": "struct IMaverickV2Pool.AddLiquidityParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "calculateAddLiquidity",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "gasEstimate",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes",
+        "name": "path",
+        "type": "bytes"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bool",
+        "name": "exactOutput",
+        "type": "bool"
+      }
+    ],
+    "name": "calculateMultiHopSwap",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "returnAmount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "gasEstimate",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IMaverickV2Pool",
+        "name": "pool",
+        "type": "address"
+      },
+      {
+        "internalType": "uint128",
+        "name": "amount",
+        "type": "uint128"
+      },
+      {
+        "internalType": "bool",
+        "name": "tokenAIn",
+        "type": "bool"
+      },
+      {
+        "internalType": "bool",
+        "name": "exactOutput",
+        "type": "bool"
+      },
+      {
+        "internalType": "int32",
+        "name": "tickLimit",
+        "type": "int32"
+      }
+    ],
+    "name": "calculateSwap",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "gasEstimate",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IERC20",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "contract IERC20",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountA",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountB",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "name": "maverickV2AddLiquidityCallback",
+    "outputs": [],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IERC20",
+        "name": "",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "name": "maverickV2SwapCallback",
+    "outputs": [],
+    "stateMutability": "pure",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IMaverickV2Pool",
+        "name": "pool",
+        "type": "address"
+      }
+    ],
+    "name": "poolSqrtPrice",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "sqrtPrice",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/dex/index.ts

@@ -66,6 +66,7 @@ import { Camelot } from './camelot/camelot';
 import { Hashflow } from './hashflow/hashflow';
 import { SolidlyEthereum } from './solidly/solidly-ethereum';
 import { MaverickV1 } from './maverick-v1/maverick-v1';
+import { MaverickV2 } from './maverick-v2/maverick-v2';
 import { QuickSwapV3 } from './quickswap/quickswap-v3';
 import { ThenaFusion } from './quickswap/thena-fusion';
 import { TraderJoeV2 } from './trader-joe-v2';
@@ -152,6 +153,7 @@ const Dexes = [
   WstETH,
   Hashflow,
   MaverickV1,
+  MaverickV2,
   Camelot,
   SwaapV2,
   AngleStakedStable,

package/src/dex/maverick-v2/config.ts

@@ -0,0 +1,28 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network } from '../../constants';
+
+export const MAV_V2_BASE_GAS_COST = 50_000;
+export const MAV_V2_TICK_GAS_COST = 10_000;
+export const MAVERICK_API_URL = `https://v2-api.mav.xyz/`;
+
+export const MaverickV2Config: DexConfigMap<DexParams> = {
+  MaverickV2: {
+    [Network.BASE]: {
+      quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
+      poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
+    },
+    [Network.MAINNET]: {
+      quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
+      poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
+    },
+    [Network.BSC]: {
+      quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
+      poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
+    },
+    [Network.ARBITRUM]: {
+      quoterAddress: `0xb40AfdB85a07f37aE217E7D6462e609900dD8D7A`,
+      poolLensAddress: `0x942646b0A8B42Af1e1044439013436a9a3e080b5`,
+    },
+  },
+};

package/src/dex/maverick-v2/maverick-math/maverick-basic-math.ts

@@ -0,0 +1,152 @@
+import { BI_MAX_UINT256, BI_POWS } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+
+export class MaverickBasicMath {
+  static MAX_POW_RELATIVE_ERROR = BI_POWS[4];
+
+  static abs(x: bigint) {
+    return x < 0n ? -x : x;
+  }
+
+  static min(a: bigint, b: bigint): bigint {
+    return a < b ? a : b;
+  }
+
+  static max(a: bigint, b: bigint): bigint {
+    return a >= b ? a : b;
+  }
+
+  static clip(x: bigint, y: bigint): bigint {
+    return x < y ? 0n : x - y;
+  }
+
+  static mulDivFloor(x: bigint, y: bigint, k: bigint): bigint {
+    return this.mulDiv(x, y, this.max(1n, k));
+  }
+
+  static mulmod(x: bigint, y: bigint, k: bigint): bigint {
+    return (x * y) % k;
+  }
+
+  static mulFloor(x: bigint, y: bigint): bigint {
+    return this.mulDiv(x, y, BI_POWS[18]);
+  }
+
+  static mulDivCeil(x: bigint, y: bigint, k: bigint): bigint {
+    let result = this.mulDivFloor(x, y, k);
+    if (this.mulmod(x, y, this.max(1n, k)) != 0n) result = result + 1n;
+    return result;
+  }
+
+  static sqrt(x: bigint) {
+    let y = x;
+
+    let z = 181n;
+
+    if (y >= 0x10000000000000000000000000000000000) {
+      y >>= 128n;
+      z <<= 64n;
+    }
+
+    if (y >= 0x1000000000000000000) {
+      y >>= 64n;
+      z <<= 32n;
+    }
+
+    if (y >= 0x10000000000) {
+      y >>= 32n;
+      z <<= 16n;
+    }
+
+    if (y >= 0x1000000) {
+      y >>= 16n;
+      z <<= 8n;
+    }
+
+    z = (z * (y + 65536n)) >> 18n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+    z = (x / z + z) >> 1n;
+
+    return x / z < z ? z - 1n : z;
+  }
+
+  static divDown(x: bigint, y: bigint): bigint {
+    return this.mulDivDown(x, BI_POWS[18], y);
+  }
+
+  static divUp(x: bigint, y: bigint): bigint {
+    return this.mulDivUp(x, BI_POWS[18], y);
+  }
+
+  static mulUp(x: bigint, y: bigint): bigint {
+    return this.mulDivUp(x, y, BI_POWS[18]);
+  }
+
+  static mulDown(x: bigint, y: bigint): bigint {
+    return this.mulDivDown(x, y, BI_POWS[18]);
+  }
+
+  static invFloor(x: bigint): bigint {
+    return BI_POWS[36] / x;
+  }
+
+  static invCeil(denominator: bigint): bigint {
+    return (BI_POWS[36] - 1n) / denominator + 1n;
+  }
+
+  static mulDivDown(x: bigint, y: bigint, denominator: bigint): bigint {
+    let z = x * y;
+
+    if (denominator === 0n) {
+      denominator = 1n;
+    }
+
+    if (denominator === 0n && !(y === 0n || x <= BI_MAX_UINT256 / y)) {
+      throw new Error('MATH: MUL_DIV_DOWN_OVERFLOW');
+    }
+
+    return z / denominator;
+  }
+
+  static mulDiv(x: bigint, y: bigint, denominator: bigint): bigint {
+    const result = (x * y) / denominator;
+
+    _require(
+      result <= BI_MAX_UINT256,
+      '',
+      { result, BI_MAX_UINT: BI_MAX_UINT256 },
+      'result <= BI_MAX_UINT256',
+    );
+
+    return result;
+  }
+
+  static divCeil(x: bigint, y: bigint): bigint {
+    return this.mulDivCeil(x, BI_POWS[18], y);
+  }
+
+  static mulCeil(x: bigint, y: bigint): bigint {
+    return this.mulDivCeil(x, y, BI_POWS[18]);
+  }
+
+  static mulDivUp(x: bigint, y: bigint, denominator: bigint): bigint {
+    let z = x * y;
+
+    if (z === 0n) {
+      return 0n;
+    }
+
+    return (z - 1n) / denominator + 1n;
+  }
+
+  static floorD8Unchecked(val: bigint): bigint {
+    let val32 = val / BI_POWS[8];
+    let check = val < 0 && val % BI_POWS[8] != 0n;
+    return check ? val32 - 1n : val32;
+  }
+}