@paraswap/dex-lib 3.7.7-skip-approval.3 → 3.7.8-oswap

package/src/dex/oswap/oswap-pool.ts

@@ -0,0 +1,190 @@
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { Log, Logger, Token } from '../../types';
+import { catchParseLogError } from '../../utils';
+import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { MultiCallParams } from '../../lib/multi-wrapper';
+import { uint256ToBigInt } from '../../lib/decoders';
+import { OSwapPool, OSwapPoolState } from './types';
+import OSwapABI from '../../abi/oswap/oswap.abi.json';
+import ERC20ABI from '../../abi/ERC20.abi.json';
+
+export class OSwapEventPool extends StatefulEventSubscriber<OSwapPoolState> {
+  handlers: {
+    [event: string]: (
+      event: any,
+      state: DeepReadonly<OSwapPoolState>,
+      log: Readonly<Log>,
+    ) => DeepReadonly<OSwapPoolState> | null;
+  } = {};
+
+  logDecoder: (log: Log) => any;
+
+  addressesSubscribed: string[];
+
+  constructor(
+    readonly parentName: string,
+    readonly pool: OSwapPool,
+    protected network: number,
+    protected dexHelper: IDexHelper,
+    logger: Logger,
+    protected iOSwap = new Interface(OSwapABI),
+    protected iERC20 = new Interface(ERC20ABI),
+  ) {
+    super(parentName, pool.id, dexHelper, logger);
+
+    this.logDecoder = (log: Log) => this.parseLog(log);
+
+    this.addressesSubscribed = [pool.address, pool.token0, pool.token1];
+    this.handlers['TraderateChanged'] = this.handleTraderateChanged.bind(this);
+    this.handlers['Transfer'] = this.handleTransfer.bind(this);
+  }
+
+  protected parseLog(log: Log) {
+    if (log.address.toLowerCase() === this.pool.address) {
+      return this.iOSwap.parseLog(log);
+    }
+    return this.iERC20.parseLog(log);
+  }
+
+  /**
+   * The function is called every time any of the subscribed
+   * addresses release log. The function accepts the current
+   * state, updates the state according to the log, and returns
+   * the updated state.
+   * @param state - Current state of event subscriber
+   * @param log - Log released by one of the subscribed addresses
+   * @returns Updates state of the event subscriber after the log
+   */
+  protected processLog(
+    state: DeepReadonly<OSwapPoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<OSwapPoolState> | null {
+    try {
+      const event = this.logDecoder(log);
+      if (event.name in this.handlers) {
+        return this.handlers[event.name](event, state, log);
+      }
+    } catch (e) {
+      catchParseLogError(e, this.logger);
+    }
+
+    return null;
+  }
+
+  /**
+   * The function generates state using on-chain calls. This
+   * function is called to regenerate state if the event based
+   * system fails to fetch events and the local state is no
+   * more correct.
+   * @param blockNumber - Blocknumber for which the state should
+   * should be generated
+   * @returns state of the event subscriber at blocknumber
+   */
+  async generateState(
+    blockNumber: number,
+  ): Promise<DeepReadonly<OSwapPoolState>> {
+    const iERC20 = new Interface(ERC20ABI);
+    const callData: MultiCallParams<bigint>[] = [
+      {
+        target: this.pool.token0,
+        callData: iERC20.encodeFunctionData('balanceOf', [this.pool.address]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.pool.token1,
+        callData: iERC20.encodeFunctionData('balanceOf', [this.pool.address]),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.pool.address,
+        callData: this.iOSwap.encodeFunctionData('traderate0', []),
+        decodeFunction: uint256ToBigInt,
+      },
+      {
+        target: this.pool.address,
+        callData: this.iOSwap.encodeFunctionData('traderate1', []),
+        decodeFunction: uint256ToBigInt,
+      },
+    ];
+
+    const results = await this.dexHelper.multiWrapper.aggregate<bigint>(
+      callData,
+      blockNumber,
+      this.dexHelper.multiWrapper.defaultBatchSize,
+    );
+
+    return {
+      balance0: results[0],
+      balance1: results[1],
+      traderate0: results[2],
+      traderate1: results[3],
+    };
+  }
+
+  async getStateOrGenerate(
+    blockNumber: number,
+    readonly: boolean = true,
+  ): Promise<OSwapPoolState> {
+    let state = this.getState(blockNumber);
+    if (!state) {
+      state = await this.generateState(blockNumber);
+      if (!readonly) this.setState(state, blockNumber);
+    }
+    return state;
+  }
+
+  /**
+   * Handle a trade rate change on the pool.
+   */
+  handleTraderateChanged(
+    event: any,
+    state: DeepReadonly<OSwapPoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<OSwapPoolState> | null {
+    return {
+      ...state,
+      traderate0: event.args.traderate0.toBigInt(),
+      traderate1: event.args.traderate1.toBigInt(),
+    };
+  }
+
+  /**
+   * Process the transfer events for tokens in/out of the pool
+   * to keep the state's token balances up to date.
+   */
+  handleTransfer(
+    event: any,
+    state: DeepReadonly<OSwapPoolState>,
+    log: Readonly<Log>,
+  ): DeepReadonly<OSwapPoolState> | null {
+    let balance0: bigint = state.balance0;
+    let balance1: bigint = state.balance1;
+
+    const tokenAddress = log.address.toLowerCase();
+    const fromAddress = event.args.from.toLowerCase();
+    const toAddress = event.args.to.toLowerCase();
+    const amount = event.args.value.toBigInt();
+
+    if (fromAddress == this.pool.address) {
+      if (tokenAddress === this.pool.token0) {
+        balance0 -= amount;
+      } else if (tokenAddress === this.pool.token1) {
+        balance1 -= amount;
+      }
+    } else if (toAddress == this.pool.address) {
+      if (tokenAddress === this.pool.token0) {
+        balance0 += amount;
+      } else if (tokenAddress === this.pool.token1) {
+        balance1 += amount;
+      }
+    }
+
+    return {
+      ...state,
+      balance0,
+      balance1,
+    };
+  }
+}

package/src/dex/oswap/oswap.ts

@@ -0,0 +1,359 @@
+import { Interface } from '@ethersproject/abi';
+import { AsyncOrSync } from 'ts-essentials';
+import {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  SimpleExchangeParam,
+  PoolLiquidity,
+  Logger,
+  NumberAsString,
+  DexExchangeParam,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
+import { Context, IDex } from '../../dex/idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { OSwapData, OSwapPool, OSwapPoolState } from './types';
+import {
+  SimpleExchange,
+  getLocalDeadlineAsFriendlyPlaceholder,
+} from '../simple-exchange';
+import { OSwapConfig, Adapters, OSWAP_GAS_COST } from './config';
+import { OSwapEventPool } from './oswap-pool';
+import OSwapABI from '../../abi/oswap/oswap.abi.json';
+
+export class OSwap extends SimpleExchange implements IDex<OSwapData> {
+  readonly eventPools: { [id: string]: OSwapEventPool } = {};
+
+  readonly hasConstantPriceLargeAmounts = false;
+
+  // This may change in the future, but currently OSwap does not support native ETH.
+  readonly needWrapNative = true;
+
+  readonly isFeeOnTransferSupported = false;
+
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(OSwapConfig);
+
+  logger: Logger;
+
+  readonly iOSwap: Interface;
+
+  readonly pools: [OSwapPool];
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    protected adapters = Adapters[network] || {},
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+    this.iOSwap = new Interface(OSwapABI);
+
+    this.pools = OSwapConfig[dexKey][network].pools;
+
+    // Create an OSwapEventPool per pool, to track each pool's state by subscribing to on-chain events.
+    for (const pool of this.pools) {
+      this.eventPools[pool.id] = new OSwapEventPool(
+        dexKey,
+        pool,
+        network,
+        dexHelper,
+        this.logger,
+      );
+    }
+  }
+
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters(side: SwapSide): { name: string; index: number }[] | null {
+    return null;
+  }
+
+  // Returns the pool matching the specified token pair or null if none found.
+  // Note: OSwap V1 does not support more than 1 pool per pair.
+  getPoolByTokenPair(srcToken: Token, destToken: Token): OSwapPool | null {
+    const srcAddress = srcToken.address.toLowerCase();
+    const destAddress = destToken.address.toLowerCase();
+
+    // A pair must have 2 different tokens.
+    if (srcAddress === destAddress) return null;
+
+    for (const pool of this.pools) {
+      if (
+        (srcAddress === pool.token0 && destAddress === pool.token1) ||
+        (srcAddress === pool.token1 && destAddress === pool.token0)
+      ) {
+        return pool;
+      }
+    }
+    return null;
+  }
+
+  getPoolById(id: string): OSwapPool | null {
+    for (const pool of this.pools) {
+      if (pool.id === id) return pool;
+    }
+    return null;
+  }
+
+  // Returns a list of pool using the token.
+  getPoolsByTokenAddress(tokenAddress: Address): OSwapPool[] {
+    const address = tokenAddress.toLowerCase();
+    let pools: OSwapPool[] = [];
+    for (const pool of this.pools) {
+      if (address === pool.token0 || address === pool.token1) {
+        pools.push(pool);
+      }
+    }
+    return pools;
+  }
+
+  // Returns the list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes. It is recommended to use
+  // ${dexKey}_${poolAddress} as a poolIdentifier
+  async getPoolIdentifiers(
+    srcToken: Token,
+    destToken: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    const pool = this.getPoolByTokenPair(srcToken, destToken);
+    return pool ? [pool.id] : [];
+  }
+
+  // Sell: Given "amount" of "from" token, how much of "to" token will be received by the trader.
+  // Buy: Given "amount" of "dest" token, how much of "to" token is required from the trader.
+  // Note: OSwap traderate is at precision 36.
+  calcPrice(
+    pool: OSwapPool,
+    state: OSwapPoolState,
+    from: Token,
+    amount: bigint,
+    side: SwapSide,
+  ): bigint {
+    const rate =
+      from.address.toLowerCase() === pool.token0
+        ? state.traderate0
+        : state.traderate1;
+    return side === SwapSide.SELL
+      ? (amount * rate) / getBigIntPow(36)
+      : (amount * getBigIntPow(36)) / rate;
+  }
+
+  // Returns true if the pool has enough liquidity for the swap. False otherwise.
+  checkLiquidity(
+    pool: OSwapPool,
+    state: OSwapPoolState,
+    from: Token,
+    amount: bigint,
+    side: SwapSide,
+  ): boolean {
+    if (side === SwapSide.SELL) {
+      const needed = this.calcPrice(pool, state, from, amount, side);
+      return from.address.toLowerCase() === pool.token0
+        ? needed <= state.balance1
+        : needed <= state.balance0;
+    }
+    // SwapSide.BUY
+    return from.address.toLowerCase() === pool.token0
+      ? amount <= state.balance1
+      : amount <= state.balance0;
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pool can be used.
+  async getPricesVolume(
+    srcToken: Token,
+    destToken: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<OSwapData>> {
+    // Get the pool to use.
+    const pool = this.getPoolByTokenPair(srcToken, destToken);
+    if (!pool) return null;
+
+    // Make sure the pool meets the optional limitPools filter.
+    if (limitPools && !limitPools.includes(pool.id)) return null;
+
+    const eventPool = this.eventPools[pool.id];
+    if (!eventPool)
+      throw new Error(`OSwap pool ${pool.id}: No EventPool found.`);
+
+    const state = await eventPool.getStateOrGenerate(blockNumber);
+
+    // Ensure there is enough liquidity in the pool to process all the requested swaps.
+    const totalAmount = amounts.reduce(
+      (a: bigint, b: bigint) => a + b,
+      BigInt(0),
+    );
+    if (!this.checkLiquidity(pool, state, srcToken, totalAmount, side)) {
+      return null;
+    }
+    // Calculate the prices
+    const unitAmount = getBigIntPow(18);
+    const unitPrice = this.calcPrice(pool, state, srcToken, unitAmount, side);
+    const prices = amounts.map(amount =>
+      this.calcPrice(pool, state, srcToken, amount, side),
+    );
+
+    return [
+      {
+        prices,
+        unit: unitPrice,
+        data: {
+          pool: pool.address,
+          path: [srcToken.address, destToken.address],
+        },
+        exchange: this.dexKey,
+        poolIdentifier: pool.id,
+        gasCost: OSWAP_GAS_COST,
+        poolAddresses: [pool.address],
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<OSwapData>): number | number[] {
+    return (
+      CALLDATA_GAS_COST.DEX_OVERHEAD +
+      // ParentStruct header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> path[] header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> path length
+      CALLDATA_GAS_COST.LENGTH_SMALL +
+      // ParentStruct -> path[0]
+      CALLDATA_GAS_COST.ADDRESS +
+      // ParentStruct -> path[1]
+      CALLDATA_GAS_COST.ADDRESS +
+      // ParentStruct -> receiver header
+      CALLDATA_GAS_COST.OFFSET_SMALL +
+      // ParentStruct -> receiver
+      CALLDATA_GAS_COST.ADDRESS
+    );
+  }
+
+  // Encode params required by the exchange adapter
+  // Used for multiSwap, buy & megaSwap
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: OSwapData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    return {
+      targetExchange: data.pool,
+      payload: '',
+      networkFee: '0',
+    };
+  }
+
+  // Encode call data used by simpleSwap like routers
+  // Used for simpleSwap & simpleBuy
+  getDexParam(
+    srcToken: Address,
+    destToken: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: OSwapData,
+    side: SwapSide,
+    _: Context,
+    executorAddress: Address,
+  ): DexExchangeParam {
+    let method: string;
+    let args: any;
+
+    const deadline = getLocalDeadlineAsFriendlyPlaceholder();
+    if (side === SwapSide.SELL) {
+      method = 'swapExactTokensForTokens';
+      args = [srcAmount, destAmount, data.path, recipient, deadline];
+    } else {
+      method = 'swapTokensForExactTokens';
+      args = [destAmount, srcAmount, data.path, recipient, deadline];
+    }
+
+    const swapData = this.iOSwap.encodeFunctionData(method, args);
+
+    return {
+      needWrapNative: this.needWrapNative,
+      dexFuncHasRecipient: true,
+      exchangeData: swapData,
+      targetExchange: data.pool,
+      returnAmountPos: undefined,
+    };
+  }
+
+  // This is called once before getTopPoolsForToken is
+  // called for multiple tokens. This can be helpful to
+  // update common state required for calculating
+  // getTopPoolsForToken. It is optional for a DEX
+  // to implement this
+  async updatePoolState(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  // Returns a list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    // Get the list of pools using the token.
+    const pools = this.getPoolsByTokenAddress(tokenAddress);
+    if (!pools.length) return [];
+
+    const results = await Promise.all<PoolLiquidity>(
+      pools.map(async pool => {
+        // Get the pool's balance and its USD value.
+        const eventPool = this.eventPools[pool.id];
+        const blockNumber =
+          await this.dexHelper.web3Provider.eth.getBlockNumber();
+        const state = await eventPool.getStateOrGenerate(blockNumber);
+
+        const usd0 = await this.dexHelper.getTokenUSDPrice(
+          { address: pool.token0, decimals: 18 },
+          state.balance0,
+        );
+        const usd1 = await this.dexHelper.getTokenUSDPrice(
+          { address: pool.token1, decimals: 18 },
+          state.balance1,
+        );
+
+        // Get the other token in the pair.
+        const pairedToken =
+          pool.token0 === tokenAddress.toLowerCase()
+            ? { address: pool.token1, decimals: 18 }
+            : { address: pool.token0, decimals: 18 };
+
+        return {
+          exchange: this.dexKey,
+          address: pool.address,
+          connectorTokens: [pairedToken],
+          liquidityUSD: usd0 + usd1,
+        };
+      }),
+    );
+    return results
+      .filter(r => r)
+      .sort((a, b) => a.liquidityUSD - b.liquidityUSD)
+      .slice(0, limit);
+  }
+
+  // This is optional function in case if your implementation has acquired any resources
+  // you need to release for graceful shutdown. For example, it may be any interval timer
+  releaseResources(): AsyncOrSync<void> {}
+}

package/src/dex/oswap/types.ts

@@ -0,0 +1,29 @@
+import { Address } from '../../types';
+
+// OSwapPoolState is the state of the event subscriber. It is the minimum
+// set of parameters required to compute pool prices.
+export type OSwapPoolState = {
+  traderate0: bigint;
+  traderate1: bigint;
+  balance0: bigint;
+  balance1: bigint;
+};
+
+// OSwapPoolState is the state of the event subscriber. It is the minimum
+// set of parameters required to compute pool prices.
+export type OSwapData = {
+  pool: Address;
+  path: Address[];
+};
+
+// Each pool has a contract address and token pairs.
+export type OSwapPool = {
+  id: string;
+  address: Address;
+  token0: Address;
+  token1: Address;
+};
+
+export type DexParams = {
+  pools: [OSwapPool];
+};

package/src/dex/simple-exchange.ts

@@ -110,12 +110,12 @@ export class SimpleExchange {
     spender?: Address,
     networkFee: NumberAsString = '0',
     preCalls?: Omit<SimpleExchangeParam, 'networkFee'>,
-    skipAllowance?: boolean,
   ): Promise<SimpleExchangeParam> {
-    const approveParam = await (!skipAllowance
-      ? this.getApproveSimpleParam(src, spender || swapCallee, srcAmount)
-      : { callees: [], calldata: [], values: [], networkFee: '0' });
-
+    const approveParam = await this.getApproveSimpleParam(
+      src,
+      spender || swapCallee,
+      srcAmount,
+    );
     const swapValue = (
       BigInt(networkFee) + (isETHAddress(src) ? BigInt(srcAmount) : 0n)
     ).toString();

package/src/dex/spark/spark-e2e.test.ts

@@ -29,17 +29,9 @@ function testForNetwork(
         ContractMethod.simpleSwap,
         ContractMethod.multiSwap,
         ContractMethod.megaSwap,
-        ContractMethod.swapExactAmountIn,
-      ],
-    ],
-    [
-      SwapSide.BUY,
-      [
-        ContractMethod.simpleBuy,
-        ContractMethod.buy,
-        ContractMethod.swapExactAmountOut,
       ],
     ],
+    [SwapSide.BUY, [ContractMethod.simpleBuy, ContractMethod.buy]],
   ]);
 
   describe(`${network}`, () => {

package/src/dex/spark/spark.ts

@@ -207,10 +207,6 @@ export class Spark
       destAmount,
       swapData,
       exchange,
-      undefined,
-      undefined,
-      undefined,
-      isSell && this.isDai(destToken),
     );
   }
 

package/src/executor/Executor01BytecodeBuilder.ts

@@ -268,7 +268,6 @@ export class Executor01BytecodeBuilder extends ExecutorBytecodeBuilder<
       (!isETHAddress(swap.srcToken) ||
         (isETHAddress(swap.srcToken) && index !== 0)) &&
       !curExchangeParam.transferSrcTokenBeforeSwap &&
-      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       const approveCallData = this.buildApproveCallData(

package/src/executor/Executor02BytecodeBuilder.ts

@@ -606,7 +606,6 @@ export class Executor02BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (
       !isETHAddress(swap.srcToken) &&
       !curExchangeParam.transferSrcTokenBeforeSwap &&
-      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       const approveCallData = this.buildApproveCallData(

package/src/executor/Executor03BytecodeBuilder.ts

@@ -147,7 +147,6 @@ export class Executor03BytecodeBuilder extends ExecutorBytecodeBuilder<
     if (
       flags.dexes[index] % 4 !== 1 && // not sendEth
       !isETHAddress(swap.srcToken) &&
-      !curExchangeParam.skipApproval &&
       curExchangeParam.approveData
     ) {
       // TODO: as we give approve for MAX_UINT and approve for current targetExchange was given

package/src/executor/executor01-bytecode-builder-e2e.test.ts

@@ -102,31 +102,6 @@ describe('Executor01ByteCodeBuilder e2e tests', () => {
     const network = Network.MAINNET;
 
     describe('SimpleSwap', () => {
-      describe('AngleStakedStableUSD', () => {
-        const dexKey = 'AngleStakedStableUSD';
-
-        const tokens = Tokens[network];
-        const holders = Holders[network];
-        const provider = new StaticJsonRpcProvider(
-          generateConfig(network).privateHttpProvider,
-          network,
-        );
-
-        it('SimpleSwap stUSD -> USDA', async () => {
-          await testE2E(
-            tokens['stUSD'],
-            tokens['USDA'],
-            holders['stUSD'],
-            '1000000000000',
-            SwapSide.SELL,
-            dexKey,
-            ContractMethod.simpleSwap,
-            network,
-            provider,
-          );
-        });
-      });
-
       describe('UniswapV3', () => {
         const dexKey = 'UniswapV3';