@paraswap/dex-lib 3.8.2 → 3.8.3-integral-dex

package/src/dex/integral/utils-e2e.ts

@@ -0,0 +1,194 @@
+import _ from 'lodash';
+import fs from 'fs';
+import path from 'path';
+import { Log, BlockHeader, Address } from '../../types';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { Provider } from '@ethersproject/providers';
+import { DeepReadonly } from 'ts-essentials';
+
+const pathRoot = path.join(__dirname, './test-artifacts/');
+const configPath = './configs.json';
+const absConfigPath = path.join(pathRoot, configPath);
+let configs: { [k: string]: any } = {};
+if (fs.existsSync(absConfigPath)) configs = require(absConfigPath);
+
+const statePath = './states.json';
+const absStatePath = path.join(pathRoot, statePath);
+let states: { [k: string]: any } = {};
+if (fs.existsSync(absStatePath)) states = require(absStatePath);
+
+const logPath = './logs.json';
+const absLogPath = path.join(pathRoot, logPath);
+let logs: { [k: string]: BlockInfo } = {};
+if (fs.existsSync(absLogPath)) logs = require(absLogPath);
+
+const bigintify = (val: string) => BigInt(val);
+const stringify = (val: bigint) => val.toString();
+
+interface BlockInfo {
+  logs: Log[];
+  blockHeaders: { [blockNumber: number]: BlockHeader };
+}
+
+export async function updateEventSubscriber<SubscriberState>(
+  eventSubscriber: StatefulEventSubscriber<SubscriberState>,
+  subscribedAddress: Address[],
+  fetchState: (blocknumber: number) => Promise<SubscriberState>,
+  blockNumber: number,
+  cacheKey: string,
+  provider: Provider,
+) {
+  // Get state of the subscriber block before the event was released
+  let poolState = getSavedState(blockNumber - 1, cacheKey);
+  if (!poolState) {
+    poolState = await fetchState(blockNumber - 1);
+    saveState(blockNumber - 1, cacheKey, poolState);
+  }
+
+  // Set subscriber state before the event block
+  eventSubscriber.setState(
+    poolState as DeepReadonly<SubscriberState>,
+    blockNumber - 1,
+  );
+  eventSubscriber.isTracking = () => true;
+
+  // Get logs and blockHeader of the block when the event was emitted
+  let blockInfo = getSavedBlockInfo(blockNumber, cacheKey);
+  if (!blockInfo) {
+    const logs = (
+      await Promise.all(
+        subscribedAddress.map(address =>
+          provider.getLogs({
+            fromBlock: blockNumber,
+            toBlock: blockNumber,
+            address,
+          }),
+        ),
+      )
+    )
+      .flat()
+      .sort((a, b) => a.logIndex - b.logIndex);
+
+    blockInfo = {
+      logs,
+      blockHeaders: {
+        [blockNumber]: <BlockHeader>(
+          (<unknown>await provider.getBlock(blockNumber))
+        ),
+      },
+    };
+    saveBlockInfo(blockNumber, cacheKey, blockInfo);
+  }
+
+  // Update subscriber with event logs
+  await eventSubscriber.update(blockInfo.logs, blockInfo.blockHeaders);
+}
+
+export async function checkEventSubscriber<SubscriberState>(
+  eventSubscriber: StatefulEventSubscriber<SubscriberState>,
+  fetchState: (blocknumber: number) => Promise<SubscriberState>,
+  blockNumber: number,
+  cacheKey: string,
+  stateCompare?: (
+    state: SubscriberState,
+    expectedState: SubscriberState,
+  ) => void,
+) {
+  // Get the expected state of the subscriber after the event
+  let expectedNewPoolState = getSavedState(blockNumber, cacheKey);
+  if (!expectedNewPoolState) {
+    expectedNewPoolState = await fetchState(blockNumber);
+    saveState(blockNumber, cacheKey, expectedNewPoolState);
+  }
+
+  // Get the updated state of the subscriber
+  const newPoolState = eventSubscriber.getState(blockNumber);
+
+  // Expect the updated state to be same as the expected state
+  if (stateCompare) {
+    expect(newPoolState).not.toBeNull();
+    stateCompare(
+      newPoolState as SubscriberState,
+      expectedNewPoolState as SubscriberState,
+    );
+  } else {
+    expect(newPoolState).toEqual(expectedNewPoolState);
+  }
+}
+
+export function deepTypecast<T>(
+  obj: any,
+  checker: (val: any) => boolean,
+  caster: (val: T) => any,
+): any {
+  return _.forEach(obj, (val: any, key: any, obj: any) => {
+    obj[key] = checker(val)
+      ? caster(val)
+      : _.isObject(val)
+      ? deepTypecast(val, checker, caster)
+      : val;
+  });
+}
+
+export function getSavedConfig<Config>(
+  blockNumber: number,
+  cacheKey: string,
+): Config | undefined {
+  const _config = configs[`${cacheKey}_${blockNumber}`];
+  if (_config) {
+    const checker = (obj: any) => _.isString(obj) && obj.includes('bi@');
+    const caster = (obj: string) => bigintify(obj.slice(3));
+    return deepTypecast<string>(_.cloneDeep(_config), checker, caster);
+  }
+  return undefined;
+}
+
+export function saveConfig<Config>(
+  blockNumber: number,
+  cacheKey: string,
+  config: Config,
+) {
+  const checker = (obj: any) => typeof obj === 'bigint';
+  const caster = (obj: bigint) => 'bi@'.concat(stringify(obj));
+  const _config = deepTypecast<bigint>(_.cloneDeep(config), checker, caster);
+  configs[`${cacheKey}_${blockNumber}`] = _config;
+  fs.writeFileSync(absConfigPath, JSON.stringify(configs, null, 2));
+}
+
+export function getSavedState<SubscriberState>(
+  blockNumber: number,
+  cacheKey: string,
+): SubscriberState | undefined {
+  const _state = states[`${cacheKey}_${blockNumber}`];
+  if (_state) {
+    const checker = (obj: any) => _.isString(obj) && obj.includes('bi@');
+    const caster = (obj: string) => bigintify(obj.slice(3));
+    return deepTypecast<string>(_.cloneDeep(_state), checker, caster);
+  }
+  return undefined;
+}
+
+function saveState<SubscriberState>(
+  blockNumber: number,
+  cacheKey: string,
+  state: SubscriberState,
+) {
+  const checker = (obj: any) => typeof obj === 'bigint';
+  const caster = (obj: bigint) => 'bi@'.concat(stringify(obj));
+  const _state = deepTypecast<bigint>(_.cloneDeep(state), checker, caster);
+  states[`${cacheKey}_${blockNumber}`] = _state;
+  fs.writeFileSync(absStatePath, JSON.stringify(states, null, 2));
+}
+
+function getSavedBlockInfo(blockNumber: number, cacheKey: string): BlockInfo {
+  return logs[`${cacheKey}_${blockNumber}`];
+}
+
+function saveBlockInfo(
+  blockNumber: number,
+  cacheKey: string,
+  blockInfo: BlockInfo,
+) {
+  logs[`${cacheKey}_${blockNumber}`] = blockInfo;
+  fs.writeFileSync(absLogPath, JSON.stringify(logs, null, 2));
+}

package/src/dex/integral/utils.ts

@@ -0,0 +1,146 @@
+import _ from 'lodash';
+import { BytesLike } from 'ethers';
+import { generalDecoder } from '../../lib/decoders';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { Address } from '@paraswap/core';
+import { _require } from '../../utils';
+import { FullMath } from '../uniswap-v3/contract-math/FullMath';
+import { Oracle } from '../uniswap-v3/contract-math/Oracle';
+import { TickMath } from '../uniswap-v3/contract-math/TickMath';
+import { PoolState as UniswapPoolState } from '../uniswap-v3/types';
+import { IntegralContext } from './context';
+import { PoolStates, RelayerPoolState } from './types';
+
+export function ceil_div(a: bigint, b: bigint) {
+  const c = a / b;
+  if (a != b * c) {
+    return c + 1n;
+  } else {
+    return c;
+  }
+}
+
+export const uint32ToNumber = (
+  result: MultiResult<BytesLike> | BytesLike,
+): number => {
+  return generalDecoder(result, ['uint32'], 0, value =>
+    parseInt(value[0].toString(), 10),
+  );
+};
+
+export function sortTokens(srcAddress: Address, destAddress: Address) {
+  return [srcAddress, destAddress].sort((a, b) => (a < b ? -1 : 1));
+}
+
+export function getDecimalsConverter(
+  decimals0: number,
+  decimals1: number,
+  inverted: boolean,
+) {
+  return (
+    10n **
+    (18n + BigInt(inverted ? decimals1 - decimals0 : decimals0 - decimals1))
+  );
+}
+
+export function getPrice(states: PoolStates, inverted: boolean) {
+  const { base, pricing, relayer } = states;
+  const decimalsConverter = getDecimalsConverter(
+    base.decimals0,
+    base.decimals1,
+    false,
+  );
+  const spotPrice = getSpotPrice(pricing, decimalsConverter);
+  const averagePrice = getAveragePrice(relayer, pricing, decimalsConverter);
+  if (inverted) {
+    return 10n ** 36n / (spotPrice > averagePrice ? spotPrice : averagePrice);
+  } else {
+    return spotPrice < averagePrice ? spotPrice : averagePrice;
+  }
+}
+
+export function getSpotPrice(
+  pricing: UniswapPoolState,
+  decimalsConverter: bigint,
+) {
+  const sqrtPriceX96 = pricing.slot0.sqrtPriceX96;
+  const priceX128 = FullMath.mulDiv(sqrtPriceX96, sqrtPriceX96, 2n ** 64n);
+  return FullMath.mulDiv(priceX128, decimalsConverter, 2n ** 128n);
+}
+
+export function getAveragePrice(
+  relayer: RelayerPoolState,
+  pricing: UniswapPoolState,
+  decimalsConverter: bigint,
+) {
+  _require(relayer.twapInterval > 0, 'Twap Interval not set');
+  const secondsAgo = BigInt(relayer.twapInterval);
+  const secondsAgos = [secondsAgo, 0n];
+  const tickCumulatives = getTickCumulatives(pricing, secondsAgos);
+
+  const delta = tickCumulatives[1] - tickCumulatives[0];
+  let arithmeticMeanTick = delta / secondsAgo;
+  if (delta < 0 && delta % secondsAgo != 0n) {
+    --arithmeticMeanTick;
+  }
+
+  const sqrtRatioX96 = TickMath.getSqrtRatioAtTick(arithmeticMeanTick);
+  const ratioX128 = FullMath.mulDiv(sqrtRatioX96, sqrtRatioX96, 2n ** 64n);
+  return FullMath.mulDiv(ratioX128, decimalsConverter, 2n ** 128n);
+}
+
+export function getTickCumulatives(
+  poolState: UniswapPoolState,
+  secondsAgos: bigint[],
+) {
+  const { tickCumulatives } = secondsAgos.reduce(
+    (memo, secondsAgo, i) => {
+      [memo.tickCumulatives[i], memo.secondsPerLiquidityCumulativeX128s[i]] =
+        Oracle.observeSingle(
+          poolState,
+          BigInt.asUintN(32, poolState.blockTimestamp),
+          secondsAgo,
+          poolState.slot0.tick,
+          poolState.slot0.observationIndex,
+          poolState.liquidity,
+          poolState.slot0.observationCardinality,
+        );
+      return memo;
+    },
+    {
+      tickCumulatives: Array<bigint>(secondsAgos.length),
+      secondsPerLiquidityCumulativeX128s: Array<bigint>(secondsAgos.length),
+    },
+  );
+
+  return tickCumulatives;
+}
+
+export function isInverted(tokenIn: Address, tokenOut: Address) {
+  const [, token1] =
+    tokenIn.toLowerCase() < tokenOut.toLowerCase()
+      ? [tokenIn, tokenOut]
+      : [tokenOut, tokenIn];
+  return tokenIn === token1;
+}
+
+export function getPoolIdentifier(
+  dexKey: string,
+  srcAddress: Address,
+  destAddress: Address,
+) {
+  const tokenAddresses = sortTokens(
+    srcAddress.toLowerCase(),
+    destAddress.toLowerCase(),
+  ).join('_');
+  return `${dexKey}_${tokenAddresses}`;
+}
+
+export function getPoolBackReferencedFrom(
+  context: IntegralContext,
+  poolAddress: Address,
+) {
+  return Object.entries(context.pools).find(
+    ([, pool]) => pool.base?.poolAddress === poolAddress,
+  );
+}

package/src/dex/jarvis.ts

@@ -0,0 +1,262 @@
+import { Interface, JsonFragment } from '@ethersproject/abi';
+import { NULL_ADDRESS, SwapSide } from '../constants';
+import {
+  AdapterExchangeParam,
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  SimpleExchangeParam,
+} from '../types';
+import { IDexTxBuilder } from './idex';
+import { SimpleExchange } from './simple-exchange';
+import JarvisABI from '../abi/Jarvis.json';
+import Web3 from 'web3';
+import { IDexHelper } from '../dex-helper';
+import { extractReturnAmountPosition } from '../executor/utils';
+
+const THIRTY_MINUTES = 60 * 30;
+
+export type JarvisData = {
+  derivatives: string;
+  destDerivatives?: string;
+  pools: string[];
+  fee: string;
+  method: JarvisFunctions;
+  router: Address;
+};
+
+type JarvisMintParam = [
+  derivative: string,
+  minNumTokens: string,
+  collateralAmount: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisRedeemParam = [
+  derivative: string,
+  numTokens: string,
+  minCollateral: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisExchangeParam = [
+  derivative: string,
+  destPool: string,
+  destDerivative: string,
+  numTokens: string,
+  minDestNumTokens: string,
+  feePercentage: string,
+  expiration: string,
+  recipient: string,
+];
+
+type JarvisParam = JarvisExchangeParam | JarvisMintParam | JarvisRedeemParam;
+
+enum JarvisFunctions {
+  mint = 'mint',
+  redeem = 'redeem',
+  exchange = 'exchange',
+}
+
+export class Jarvis
+  extends SimpleExchange
+  implements IDexTxBuilder<JarvisData, JarvisParam>
+{
+  static dexKeys = ['jarvis'];
+  poolInterface: Interface;
+  needWrapNative = false;
+
+  constructor(dexHelper: IDexHelper) {
+    super(dexHelper, 'jarvis');
+    this.poolInterface = new Interface(JarvisABI as JsonFragment[]);
+  }
+
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: JarvisData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const { method } = data;
+    const type = [
+      JarvisFunctions.mint,
+      JarvisFunctions.redeem,
+      JarvisFunctions.exchange,
+    ].indexOf(method);
+
+    if (type === undefined) {
+      throw new Error(
+        `Jarvis: Invalid OpType ${method}, Should be one of ['mint', 'exchange', 'redeem']`,
+      );
+    }
+
+    const payload = this.abiCoder.encodeParameter(
+      {
+        ParentStruct: {
+          opType: 'uint',
+          derivatives: 'address',
+          destDerivatives: 'address',
+          fee: 'uint128',
+          destPool: 'address',
+          expiration: 'uint128',
+        },
+      },
+      {
+        opType: type,
+        derivatives: data.derivatives,
+        destDerivatives: data.destDerivatives || NULL_ADDRESS,
+        fee: data.fee,
+        destPool: data.pools[1] || NULL_ADDRESS,
+        expiration: (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0),
+      },
+    );
+
+    return {
+      targetExchange: data.pools[0],
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  async getSimpleParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: JarvisData,
+    side: SwapSide,
+  ): Promise<SimpleExchangeParam> {
+    const swapFunction = data.method;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+    let swapFunctionParams: JarvisParam;
+    switch (swapFunction) {
+      case JarvisFunctions.mint:
+        swapFunctionParams = [
+          data.derivatives,
+          destAmount,
+          srcAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      case JarvisFunctions.redeem:
+        swapFunctionParams = [
+          data.derivatives,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      case JarvisFunctions.exchange:
+        swapFunctionParams = [
+          data.derivatives,
+          data.pools[1],
+          data.destDerivatives!,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          this.augustusAddress,
+        ];
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+
+    const swapData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return this.buildSimpleParamWithoutWETHConversion(
+      srcToken,
+      srcAmount,
+      destToken,
+      destAmount,
+      swapData,
+      data.pools[0],
+    );
+  }
+
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: JarvisData,
+    side: SwapSide,
+  ): DexExchangeParam {
+    const swapFunction = data.method;
+    const timestamp = (Date.now() / 1000 + THIRTY_MINUTES).toFixed(0);
+    let swapFunctionParams: JarvisParam;
+    let outputName: string;
+
+    switch (swapFunction) {
+      case JarvisFunctions.mint:
+        swapFunctionParams = [
+          data.derivatives,
+          destAmount,
+          srcAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'syntheticTokensMinted';
+        break;
+      case JarvisFunctions.redeem:
+        swapFunctionParams = [
+          data.derivatives,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'collateralRedeemed';
+        break;
+      case JarvisFunctions.exchange:
+        swapFunctionParams = [
+          data.derivatives,
+          data.pools[1],
+          data.destDerivatives!,
+          srcAmount,
+          destAmount,
+          data.fee,
+          timestamp,
+          recipient,
+        ];
+        outputName = 'destNumTokensMinted';
+        break;
+      default:
+        throw new Error(`Unknown function ${swapFunction}`);
+    }
+
+    const swapData = this.poolInterface.encodeFunctionData(swapFunction, [
+      swapFunctionParams,
+    ]);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pools[0],
+      returnAmountPos:
+        side === SwapSide.SELL
+          ? extractReturnAmountPosition(
+              this.poolInterface,
+              swapFunction,
+              outputName,
+            )
+          : undefined,
+    };
+  }
+}