@paraswap/dex-lib 2.28.9-take-surplus.0 → 2.28.9-take-surplus.1

package/src/dex/quick-perps/vault.ts

@@ -0,0 +1,290 @@
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../../composed-event-subscriber';
+import { Lens } from '../../lens';
+import VaultABI from '../../abi/quick-perps/vault.json';
+import { VaultUtils } from './vault-utils';
+import {
+  VaultConfig,
+  VaultState,
+  FastPriceFeedConfig,
+  PoolState,
+} from './types';
+import { VaultPriceFeed } from './vault-price-feed';
+import { USDQ } from './usdq';
+import {
+  MultiCallInput,
+  MultiCallOutput,
+  Address,
+  Logger,
+  Log,
+} from '../../types';
+import { BlockHeader } from 'web3-eth';
+
+export class Vault<State> extends PartialEventSubscriber<State, VaultState> {
+  static readonly interface: Interface = new Interface(VaultABI);
+
+  protected vaultUtils: VaultUtils<State>;
+
+  public tokenDecimals: { [address: string]: number };
+  public stableTokens: { [address: string]: boolean };
+  protected tokenWeights: { [address: string]: bigint };
+  public stableSwapFeeBasisPoints: bigint;
+  public swapFeeBasisPoints: bigint;
+  public stableTaxBasisPoints: bigint;
+  public taxBasisPoints: bigint;
+  public hasDynamicFees: bigint;
+  protected includeAmmPrice: boolean;
+  protected useSwapPricing: boolean;
+  protected totalTokenWeights: bigint;
+
+  constructor(
+    public readonly vaultAddress: Address,
+    protected tokenAddresses: Address[],
+    config: VaultConfig,
+    protected vaultPriceFeed: VaultPriceFeed<State>,
+    protected usdq: USDQ<State>,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<VaultState>>,
+    logger: Logger,
+  ) {
+    super([vaultAddress], lens, logger);
+    this.vaultUtils = new VaultUtils(this);
+    this.tokenDecimals = config.tokenDecimals;
+    this.stableTokens = config.stableTokens;
+    this.tokenWeights = config.tokenWeights;
+    this.stableSwapFeeBasisPoints = config.stableSwapFeeBasisPoints;
+    this.swapFeeBasisPoints = config.swapFeeBasisPoints;
+    this.stableTaxBasisPoints = config.stableTaxBasisPoints;
+    this.taxBasisPoints = config.taxBasisPoints;
+    this.hasDynamicFees = config.hasDynamicFees;
+    this.includeAmmPrice = config.includeAmmPrice;
+    this.useSwapPricing = config.useSwapPricing;
+    this.totalTokenWeights = config.totalTokenWeights;
+  }
+
+  getMinPrice(state: DeepReadonly<State>, _token: Address): bigint {
+    return this.vaultPriceFeed.getPrice(
+      state,
+      _token,
+      false,
+      this.includeAmmPrice,
+      this.useSwapPricing,
+    );
+  }
+
+  getMaxPrice(state: DeepReadonly<State>, _token: Address): bigint {
+    return this.vaultPriceFeed.getPrice(
+      state,
+      _token,
+      true,
+      this.includeAmmPrice,
+      this.useSwapPricing,
+    );
+  }
+
+  getFeeBasisPoints(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _usdqDelta: bigint,
+    _feeBasisPoints: bigint,
+    _taxBasisPoints: bigint,
+    _increment: boolean,
+  ): bigint {
+    return this.vaultUtils.getFeeBasisPoints(
+      state,
+      _token,
+      _usdqDelta,
+      _feeBasisPoints,
+      _taxBasisPoints,
+      _increment,
+    );
+  }
+
+  getTargetUsdqAmount(state: DeepReadonly<State>, _token: Address): bigint {
+    const supply = this.usdq.getTotalSupply(state);
+    if (supply == 0n) {
+      return 0n;
+    }
+    const weight = this.tokenWeights[_token];
+    return (weight * supply) / this.totalTokenWeights;
+  }
+
+  static getConfigMulticallInputs(
+    vaultAddress: Address,
+    tokenAddresses: Address[],
+  ): MultiCallInput[] {
+    return [
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('tokenDecimals', [t]),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('stableTokens', [t]),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('tokenWeights', [t]),
+      })),
+      ...[
+        'stableSwapFeeBasisPoints',
+        'swapFeeBasisPoints',
+        'stableTaxBasisPoints',
+        'taxBasisPoints',
+        'hasDynamicFees',
+        'includeAmmPrice',
+        'useSwapPricing',
+        'totalTokenWeights',
+      ].map(fn => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData(fn),
+      })),
+    ];
+  }
+
+  static getConfig(
+    multicallOutputs: MultiCallOutput[],
+    tokenAddresses: Address[],
+  ): VaultConfig {
+    let i = 0;
+    return {
+      tokenDecimals: tokenAddresses.reduce(
+        (acc: { [address: string]: number }, t: Address) => {
+          acc[t] = parseInt(
+            Vault.interface
+              .decodeFunctionResult('tokenDecimals', multicallOutputs[i++])[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      stableTokens: tokenAddresses.reduce(
+        (acc: { [address: string]: boolean }, t: Address) => {
+          acc[t] = Vault.interface.decodeFunctionResult(
+            'stableTokens',
+            multicallOutputs[i++],
+          )[0];
+          return acc;
+        },
+        {},
+      ),
+      tokenWeights: tokenAddresses.reduce(
+        (acc: { [address: string]: bigint }, t: Address) => {
+          acc[t] = BigInt(
+            Vault.interface
+              .decodeFunctionResult('tokenWeights', multicallOutputs[i++])[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      stableSwapFeeBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult(
+            'stableSwapFeeBasisPoints',
+            multicallOutputs[i++],
+          )[0]
+          .toString(),
+      ),
+      swapFeeBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult('swapFeeBasisPoints', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+      stableTaxBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult(
+            'stableTaxBasisPoints',
+            multicallOutputs[i++],
+          )[0]
+          .toString(),
+      ),
+      taxBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult('taxBasisPoints', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+      hasDynamicFees: Vault.interface.decodeFunctionResult(
+        'hasDynamicFees',
+        multicallOutputs[i++],
+      )[0],
+      includeAmmPrice: Vault.interface.decodeFunctionResult(
+        'includeAmmPrice',
+        multicallOutputs[i++],
+      )[0],
+      useSwapPricing: Vault.interface.decodeFunctionResult(
+        'useSwapPricing',
+        multicallOutputs[i++],
+      )[0],
+      totalTokenWeights: BigInt(
+        Vault.interface
+          .decodeFunctionResult('totalTokenWeights', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+    };
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return this.tokenAddresses.map((t: Address) => ({
+      target: this.vaultAddress,
+      callData: Vault.interface.encodeFunctionData('usdqAmounts', [t]),
+    }));
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<VaultState> {
+    let vaultState: VaultState = {
+      usdqAmounts: {},
+    };
+    this.tokenAddresses.forEach(
+      (t: Address, i: number) =>
+        (vaultState.usdqAmounts[t] = BigInt(
+          Vault.interface
+            .decodeFunctionResult('usdqAmounts', multicallOutputs[i])[0]
+            .toString(),
+        )),
+    );
+    return vaultState;
+  }
+
+  public getUSDQAmount(state: DeepReadonly<State>, token: Address): bigint {
+    return this.lens.get()(state).usdqAmounts[token];
+  }
+
+  public processLog(
+    state: DeepReadonly<VaultState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<VaultState | null> {
+    try {
+      const parsed = Vault.interface.parseLog(log);
+      const _state: VaultState = _.cloneDeep(state);
+      switch (parsed.name) {
+        case 'IncreaseUsdqAmount': {
+          const tokenAddress = parsed.args.token.toLowerCase();
+          const amount = BigInt(parsed.args.amount.toString());
+          if (tokenAddress in state.usdqAmounts)
+            _state.usdqAmounts[tokenAddress] += amount;
+          return _state;
+        }
+        case 'DecreaseUsdqAmount': {
+          const tokenAddress = parsed.args.token.toLowerCase();
+          const amount = BigInt(parsed.args.amount.toString());
+          if (tokenAddress in state.usdqAmounts)
+            _state.usdqAmounts[tokenAddress] -= amount;
+          return _state;
+        }
+        default:
+          return null;
+      }
+    } catch (e) {
+      this.logger.error('Failed to parse log', e);
+      return null;
+    }
+  }
+}

package/src/dex/solidly/config.ts

@@ -72,6 +72,28 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 2,
     },
   },
+  VelodromeV2: {
+    [Network.OPTIMISM]: {
+      // There is no subgraph for VelodromeV2
+      factoryAddress: '0xF1046053aa5682b4F9a81b5481394DA16BE5FF5a',
+      router: '0xa2f581b012E0f2dcCDe86fCbfb529f4aC5dD4983',
+      initCode:
+        '0x1a8f01f7eab324003d9388f229ea17991eee9c9d14586f429799f3656790eba0',
+      poolGasCost: 180 * 1000,
+      feeCode: 0,
+    },
+  },
+  Aerodrome: {
+    [Network.BASE]: {
+      // There is no subgraph for Aerodrome
+      factoryAddress: '0x420DD381b31aEf6683db6B902084cB0FFECe40Da',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      initCode:
+        '0x1a8f01f7eab324003d9388f229ea17991eee9c9d14586f429799f3656790eba0',
+      poolGasCost: 180 * 1000,
+      feeCode: 0,
+    },
+  },
   Cone: {
     [Network.BSC]: {
       subgraphURL: 'https://api.thegraph.com/subgraphs/name/cone-exchange/cone',
@@ -125,6 +147,37 @@ export const SolidlyConfig: DexConfigMap<DexParams> = {
       feeCode: 0,
     },
   },
+  Ramses: {
+    [Network.ARBITRUM]: {
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ramsesexchange/api-subgraph',
+      factoryAddress: '0xAAA20D08e59F6561f242b08513D36266C5A29415',
+      router: '0xb2634B3CBc1E401AB3C2743DB44d459C5c9aA662',
+      initCode:
+        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
+      poolGasCost: 180 * 1000,
+      feeCode: 0,
+    },
+  },
+  Equalizer: {
+    [Network.FANTOM]: {
+      factoryAddress: '0xc6366EFD0AF1d09171fe0EBF32c7943BB310832a',
+      router: '0x93d2611EB8b85bE4FDEa9D94Ce9913D90072eC0f',
+      initCode:
+        '0x02ada2a0163cd4f7e0f0c9805f5230716a95b174140e4c84c14883de216cc6a3',
+      feeCode: 0,
+      poolGasCost: 180 * 1000,
+    },
+    [Network.BASE]: {
+      factoryAddress: '0xed8db60acc29e14bc867a497d94ca6e3ceb5ec04',
+      router: '0xDCf4EE5B700e2a5Fec458e06B763A4a3E3004494',
+      initCode:
+        '0x7ba31a081e879b8e7f06d4e8bf5ee26b5c2680669c5701f4cdbdcde51727b275',
+      feeCode: 0,
+      feeFactor: 1e18,
+      poolGasCost: 180 * 1000,
+    },
+  },
 };
 
 export const Adapters: Record<number, AdapterMappings> = {
@@ -132,7 +185,7 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 3 }], // dystopia
   },
   [Network.FANTOM]: {
-    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly + spiritSwapV2
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 10 }], // solidly, spiritSwapV2, equalizer
   },
   [Network.OPTIMISM]: {
     [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 8 }], // velodrome
@@ -147,6 +200,9 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'AvalancheAdapter02', index: 3 }], // solisnek
   },
   [Network.ARBITRUM]: {
-    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 1 }], // chronos, ramses
+  },
+  [Network.BASE]: {
+    [SwapSide.SELL]: [{ name: 'BaseAdapter01', index: 3 }], // aerodrome, equalizer
   },
 };

package/src/dex/solidly/forks-override/aerodrome.ts

@@ -0,0 +1,53 @@
+import { VelodromeV2 } from './velodromeV2';
+import { Network, NULL_ADDRESS } from '../../../constants';
+import { getDexKeysWithNetwork } from '../../../utils';
+import _ from 'lodash';
+import { SolidlyConfig } from '../config';
+import { Token } from '../../../types';
+import { IDexHelper } from '../../../dex-helper';
+import AerodromeFactoryABI from '../../../abi/aerodrome/aerodrome-pool-factory.json';
+
+export class Aerodrome extends VelodromeV2 {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Aerodrome']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(network, dexKey, dexHelper);
+
+    this.factory = new dexHelper.web3Provider.eth.Contract(
+      AerodromeFactoryABI as any,
+      SolidlyConfig[dexKey][network].factoryAddress,
+    );
+  }
+
+  async findSolidlyPair(from: Token, to: Token, stable: boolean) {
+    if (from.address.toLowerCase() === to.address.toLowerCase()) return null;
+    const [token0, token1] =
+      from.address.toLowerCase() < to.address.toLowerCase()
+        ? [from, to]
+        : [to, from];
+
+    const typePostfix = this.poolPostfix(stable);
+    const key = `${token0.address.toLowerCase()}-${token1.address.toLowerCase()}-${typePostfix}`;
+    let pair = this.pairs[key];
+    if (pair) return pair;
+
+    let exchange = await this.factory.methods
+      // Solidly has additional boolean parameter "StablePool"
+      // At first we look for uniswap-like volatile pool
+      .getPool(token0.address, token1.address, stable)
+      .call();
+
+    if (exchange === NULL_ADDRESS) {
+      pair = { token0, token1, stable };
+    } else {
+      pair = { token0, token1, exchange, stable };
+    }
+    this.pairs[key] = pair;
+    return pair;
+  }
+}

package/src/dex/solidly/forks-override/equalizer.ts

@@ -0,0 +1,58 @@
+import { Solidly } from '../solidly';
+import { SolidlyPair } from '../types';
+import { Network } from '../../../constants';
+import { IDexHelper } from '../../../dex-helper';
+import { Interface } from '@ethersproject/abi';
+import { getDexKeysWithNetwork } from '../../../utils';
+import { SolidlyConfig } from '../config';
+import _ from 'lodash';
+
+const EqualizerFactoryABI = [
+  {
+    inputs: [{ internalType: 'address', name: '_pair', type: 'address' }],
+    name: 'getRealFee',
+    outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+    stateMutability: 'view',
+    type: 'function',
+  },
+];
+
+const equalizerFactoryIface = new Interface(EqualizerFactoryABI);
+
+export class Equalizer extends Solidly {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(_.pick(SolidlyConfig, ['Equalizer']));
+
+  constructor(
+    protected network: Network,
+    dexKey: string,
+    protected dexHelper: IDexHelper,
+  ) {
+    super(
+      network,
+      dexKey,
+      dexHelper,
+      true, // dynamic fees
+    );
+  }
+
+  protected getFeesMultiCallData(pair: SolidlyPair) {
+    const callEntry = {
+      target: this.factoryAddress,
+      callData: equalizerFactoryIface.encodeFunctionData('getRealFee', [
+        pair.exchange,
+      ]),
+    };
+    const callDecoder = (values: any[]) =>
+      parseInt(
+        equalizerFactoryIface
+          .decodeFunctionResult('getRealFee', values)[0]
+          .toString(),
+      );
+
+    return {
+      callEntry,
+      callDecoder,
+    };
+  }
+}