Skip to content

Why does it return a route with zero liquidity? #889

Open
@NavaFee

Description

@NavaFee

Why does it return a route with zero liquidity?
Here is my code. Could you please help me check if there’s any misconfiguration?

require("dotenv").config();
const UniswapService = require("./UniswapService");
const config = require("./config");
const { ethers } = require("ethers");
const { SwapType } = require("@uniswap/smart-order-router");
const { Percent, TradeType, CurrencyAmount } = require("@uniswap/sdk-core");
const { Protocol } = require("@uniswap/router-sdk");
const {
  SwapRouter,
  RoutePlanner,
  UniswapTrade,
} = require("@uniswap/universal-router-sdk");

const TOKENS = {
  ETH: "0x0000000000000000000000000000000000000000",
  WETH: "0x4200000000000000000000000000000000000006",
  AXR: "0x58Db197E91Bc8Cf1587F75850683e4bd0730e6BF",
};


class UniswapService {
    constructor(chainConfig) {
        this.chainConfig = chainConfig;
        this.provider = new ethers.providers.JsonRpcProvider(
            chainConfig.rpcUrl,
            chainConfig.chainId
        ); 
        this.router = new AlphaRouter({
            chainId: chainConfig.chainId,
            provider: this.provider,
        });
    }
}

async function main() {
  try {
    
    const chain = "base";
    const chainConfig = config[chain];
    //  init
    const uniswapService = new UniswapService(chainConfig);


    await getUniversalParams(
      process.env.WALLET_ADDRESS,
      uniswapService,
      TOKENS.WETH,
      TOKENS.AXR,
      "10"
    );

  } catch (error) {
    console.error("process failed:", error.message);
    process.exit(1);
  }
}

async function getUniversalParams(
  recipient,
  uniswapService,
  tokenIn,
  tokenOut,
  amountIn
) {
  const deadline = Math.floor(Date.now() / 1000) + 360;

  // build params
  const routeParams = {
    recipient: recipient,
    deadline,
    type: SwapType.UNIVERSAL_ROUTER,
    version: "2.0",
    slippageTolerance: new Percent(50, 100),
    deadlineOrPreviousBlockhash: Math.floor(Date.now() / 1000) + 360,
  };
  routeParams.useRouterBalance = true;

  const tokenInInfo = await uniswapService.getTokenInfo(tokenIn);

  const tokenOutInfo = await uniswapService.getTokenInfo(tokenOut);

  const parsedAmount = ethers.utils.parseUnits(amountIn, tokenInInfo.decimals);
  amount = CurrencyAmount.fromRawAmount(tokenInInfo, parsedAmount.toString());

  const ROUTING_CONFIG = {
    maxSwapsPerPath: 3,
    minSplits: 1,
    maxSplits: 3,
    distributionPercent: 25,
    forceCrossProtocol: false,
  };

  const route = await uniswapService.router.route(
    amount,
    tokenOutInfo,
    TradeType.EXACT_INPUT,
    routeParams,
    {
      ...ROUTING_CONFIG,
      protocols: [Protocol.V2, Protocol.V3, Protocol.V4],
      useCachedRoutes: false,
    }
  );

  var planner = new RoutePlanner();

  var trade = new UniswapTrade(route.trade, routeParams);
  var inputCurrency = trade.trade.inputAmount.currency;
  !!(inputCurrency.isNative && !!routeParams.inputTokenPermit)
    ? invariant(false, "NATIVE_INPUT_PERMIT")
    : void 0;
  if (routeParams.inputTokenPermit) {
    encodePermit(planner, routeParams.inputTokenPermit);
  }
  var nativeCurrencyValue = inputCurrency.isNative
    ? ethers.BigNumber.from(
        trade.trade
          .maximumAmountIn(routeParams.slippageTolerance)
          .quotient.toString()
      )
    : ethers.BigNumber.from(0);
  trade.encode(planner, {
    allowRevert: false,
  });
  console.log(
    "WETH -> AXR Routing: ",
    route.trade.routes[0].pairs[0].liquidityToken.address
  );
  // console.log(planner.commands);
  // console.log(planner.inputs);
}

main();

Image

Image

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions