Merge branch 'refs/heads/main' into feat/OP-4308-cross-chain-swap

# Conflicts: # package-lock.json # package.json
2026-03-17 00:31:34 +03:00 · 2024-05-06 14:21:10 +03:00
parent e815373b0b cf6dd964c9
commit 62825cb14a
36 changed files with 1108 additions and 98 deletions
--- a/ADVANCED.md
+++ b/ADVANCED.md
@@ -26,7 +26,7 @@ const orion = new Orion({

 // Also you can set some config as default and override it for some params
 const orion = new Orion("testing", {
-  analyticsAPI: "https://asdasd.orionprotocol.io",
+  analyticsAPI: "https://analytics-api.orionprotocol.io",
  networks: {
    [SupportedChainId.BSC_TESTNET]: {
      nodeJsonRpc: "https://data-seed-prebsc-1-s1.binance.org:8545/",
--- a/PMM-sample.md
+++ b/PMM-sample.md
@@ -0,0 +1,260 @@
+<!-- Insert logo -->
+
+<div align="center">
+    <img 
+        src="./logo.svg"
+        width="300"
+        alt="Orion Protocol SDK logo"
+     />
+    <h1>PMM example</h1>
+</div>
+
+## Overview
+
+This is special example which shows how to use PMM liquidity without using SDK, only using few libraries
+
+```ts
+import {ethers, Wallet} from "ethers";
+import {z} from "zod";
+import hmacSHA256 from "crypto-js/hmac-sha256";
+import Hex from "crypto-js/enc-hex";
+
+///////////////////////////////
+///////////////////////////////
+const pmmOrderQuotationSchema = z.object({
+  info: z.string().default(''),
+  makerAsset: z.string().default(''),
+  takerAsset: z.string().default(''),
+  maker: z.string().default(''),
+  allowedSender: z.string().default(''),
+  makingAmount: z.string().default(''),
+  takingAmount: z.string().default(''),
+});
+
+const pmmOrderSchema = z.object({
+  order: pmmOrderQuotationSchema.default({}),
+  signature: z.string().default(''),
+  success: z.boolean().default(false),
+  error: z.string().default(''),
+});
+
+const orionRFQContractABI =
+        [
+          {
+            "inputs": [
+              {
+                "components": [
+                  {
+                    "internalType": "uint256",
+                    "name": "info",
+                    "type": "uint256"
+                  },
+                  {
+                    "internalType": "address",
+                    "name": "makerAsset",
+                    "type": "address"
+                  },
+                  {
+                    "internalType": "address",
+                    "name": "takerAsset",
+                    "type": "address"
+                  },
+                  {
+                    "internalType": "address",
+                    "name": "maker",
+                    "type": "address"
+                  },
+                  {
+                    "internalType": "address",
+                    "name": "allowedSender",
+                    "type": "address"
+                  },
+                  {
+                    "internalType": "uint256",
+                    "name": "makingAmount",
+                    "type": "uint256"
+                  },
+                  {
+                    "internalType": "uint256",
+                    "name": "takingAmount",
+                    "type": "uint256"
+                  }
+                ],
+                "internalType": "struct OrderRFQLib.OrderRFQ",
+                "name": "order",
+                "type": "tuple"
+              },
+              {
+                "internalType": "bytes",
+                "name": "signature",
+                "type": "bytes"
+              },
+              {
+                "internalType": "uint256",
+                "name": "flagsAndAmount",
+                "type": "uint256"
+              }
+            ],
+            "name": "fillOrderRFQ",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+          }
+        ];
+
+function encode_utf8(s : string) {
+  return unescape(encodeURIComponent(s));
+}
+function sign(message : string, key: string) {
+  return hmacSHA256(
+          encode_utf8(message),
+          encode_utf8(key)
+  ).toString(Hex);
+}
+
+function generateHeaders(body : any, method : string, path : string, timestamp : number, apiKey : string, secretKey : string) {
+  const sortedBody = Object.keys(body)
+          .sort()
+          .map((key) => (
+                  `${key}=${body[key]}`
+          )).join('&');
+
+  const payload = timestamp + method.toUpperCase() + path + sortedBody;
+
+  const signature = sign(payload, secretKey);
+
+  const httpOptions = {
+    headers: {
+      'API-KEY': apiKey,
+      'ACCESS-TIMESTAMP': timestamp.toString(),
+      'ACCESS-SIGN': signature
+    }
+  };
+  return httpOptions;
+}
+
+//
+async function RFQOrder(
+        tokenFrom: string,
+        tokenTo: string,
+        fromTokenAmount: string,
+        apiKey: string, //
+        secretKey: string,
+        wallet: string
+) : Promise<z.infer<typeof pmmOrderSchema>> {
+
+  //  NB: replace with correct URL for networks
+  const apiUrl = 'https://testing.orion.xyz/bsc-testnet/backend'
+          //      const apiUrl = 'https://trade.orion.xyz/bsc-mainnet/backend'
+          , path = '/rfq'
+          , url = `${apiUrl}/api/v1/integration/pmm`+path
+          , headers = {
+            'Content-Type': 'application/json',
+          }
+          , data = {
+            "baseToken":tokenFrom, // USDT
+            "quoteToken":tokenTo, // ORN
+            "amount": fromTokenAmount, // 100
+            "taker": wallet,
+            "feeBps": 0
+          }
+          , method = 'POST'
+          , timestamp = Date.now()
+          , signatureHeaders = generateHeaders(data, method, path, timestamp, apiKey, secretKey)
+          , compiledHeaders = {...headers, ...signatureHeaders.headers, }
+          , body = JSON.stringify(data)
+  ;
+
+  let res  = pmmOrderSchema.parse({});
+
+  try {
+    const result = await fetch(url,{
+      headers: compiledHeaders,
+      method,
+      body
+    });
+
+    //  const data = await result.text();
+    //  console.log(data);
+
+    const json = await result.json();
+    console.log(json);
+    const parseResult = pmmOrderSchema.safeParse(json);
+
+    if(!parseResult.success) {
+      //  Try to parse error answer
+      const errorSchema = z.object({error: z.object({code: z.number(), reason: z.string()})});
+
+      const errorParseResult = errorSchema.safeParse(json);
+
+      if(!errorParseResult.success)
+        throw Error(`Unrecognized answer from aggregator: ${json}`);
+
+      throw Error(errorParseResult.data.error.reason);
+    }
+
+    res.order = parseResult.data.order;
+    res.signature = parseResult.data.signature;
+    res.error = '';
+    res.success = true;
+  }
+  catch(err) {
+    res.error = `${err}`;
+  }
+  return res;
+}
+
+
+(async() => {
+  const apiKey = '958153f1-b8b9-3ec4-84eb-2147429105d9';
+  const secretKey = 'secretKey';
+
+  //  BNB testnet tokens and router
+  const assetORN = '0xf223eca06261145b3287a0fefd8cfad371c7eb34';
+  const assetUSDT = '0xcb2951e90d8dcf16e1fa84ac0c83f48906d6a744';
+  const router = '0x89357522C0ed6E557D39dC75290859246077bdfC';
+
+  //  BNB mainnet tokens and router
+  //  const assetORN = '0xe4ca1f75eca6214393fce1c1b316c237664eaa8e';
+  //  const assetUSDT = '0x55d398326f99059ff775485246999027b3197955';
+  //  const router = '0xcb2D40EabC4f4c92Ee993Eb3D67f7717bE476E76';
+
+  const rfqOrder = await RFQOrder(
+          assetORN,   //  Spending asset
+          assetUSDT,  //  Receiving asset
+          '1000000000',        //  Amount in "satoshi" of spending asset
+          apiKey,
+          secretKey,
+          '0x61Eed69c0d112C690fD6f44bB621357B89fBE67F'  //  Can be any address, ignored for now
+  );
+
+  if(!rfqOrder.success) {
+    console.log(rfqOrder.error);
+    return;
+  }
+
+  //  ... here you can check order prices, etc.
+  console.log(rfqOrder);
+
+  //  Calldata according to provided rfqOrder
+  const contractInterface = new ethers.Interface(orionRFQContractABI);
+  const calldata = contractInterface.encodeFunctionData("fillOrderRFQ", [rfqOrder.order, rfqOrder.signature, 0]);
+  console.log('Calldata = ', calldata);
+
+  //  Call router with this data
+  //  Replace with your private key
+  const yourWalletPrivateKey = '0xf1.......';
+
+  const tx = {
+    to: router,
+    data: calldata
+  }
+
+  const provider = new ethers.JsonRpcProvider("https://data-seed-prebsc-1-s1.binance.org:8545/");
+  const signer = new ethers.Wallet(yourWalletPrivateKey, provider);
+  console.log('Address = ', signer.address);
+  const transactionResponse = await signer.sendTransaction(tx);
+  console.log("Transaction hash:", transactionResponse.hash);
+  await transactionResponse.wait();
+})();
+```
--- a/README.md
+++ b/README.md
@@ -1,12 +1,8 @@
 <!-- Insert logo -->
+[//]: # (    <img src="./logo.svg" width="300" alt="Orion Protocol SDK logo"/>)

 <div align="center">
-    <img 
-        src="./logo.svg"
-        width="300"
-        alt="Orion Protocol SDK logo"
-     />
-    <h1>Orion Protocol SDK</h1>
+    <h1>Lumia Stream SDK</h1>
    <p>Use CEX and DEX liquidity without KYC.</p>
 </div>

@@ -14,16 +10,15 @@
 ![npm bundle size (version)](https://img.shields.io/bundlephobia/minzip/@orionprotocol/sdk)
 [![Downloads](https://img.shields.io/npm/dm/@orionprotocol/sdk.svg)](https://www.npmjs.com/package/@orionprotocol/sdk)

-Do you want to integrate the Orion protocol into your application? See [integration guide](./docs/INTEGRATION.md)
+Do you want to integrate the Lumia Stream protocol into your application? See [integration guide](./docs/INTEGRATION.md)

 ## Overview

-Orion Software Developer Kit is a set of functions and methods that allow dApp developers connect to the superior aggregated liquidity of Orion Protocol which combines orderbooks of centralized exchanges as well decentralized automatic market makers such as Uniswap or Spookyswap across several supported blockchains.
-Through this connection, developers using the SDK can perform a wide range of actions, including swapping selected tokens using Orion’s aggregated liquidity, obtaining relevant market information through subscriptions, add and remove liquidity to Orion’s pools.
+Lumia Stream Developer Kit, natively built into Lumia, is a set of functions and methods that allow dApp developers to connect to the superior aggregated liquidity of Lumia Stream which combines orderbooks of centralized exchanges as well as decentralized Automatic Market Makers (AMMs) such as Uniswap, PancakeSwap, and Curve, across several supported blockchains. Through this connection, developers using the SDK can perform a wide range of actions, including swapping selected tokens, obtaining relevant market information through subscriptions, and more.

 ## API Key

-Orion’s SDK is free to use and does not require an API key or registration. Refer to integration examples for more detailed information.
+Lumia Stream’s SDK is free to use and does not require an API key or registration. Refer to integration examples for more detailed information.

 - [Overview](#overview)
 - [API Key](#api-key)
@@ -33,7 +28,7 @@ Orion’s SDK is free to use and does not require an API key or registration. Re
 - [High level methods](#high-level-methods)
  - [Get assets](#get-assets)
  - [Get pairs](#get-pairs)
-  - [Get Orion Bridge history](#get-orion-bridge-history)
+  - [Get Lumia Stream Bridge history](#get-lumia-stream-bridge-history)
  - [Bridge swap](#bridge-swap)
  - [Withdraw](#withdraw)
  - [Deposit](#deposit)
@@ -60,6 +55,7 @@ Orion’s SDK is free to use and does not require an API key or registration. Re
 - [Using contracts](#using-contracts)
 - [Utils](#utils)
  - [Parsing trade transactions](#parsing-trade-transactions)
+- [PMM](#pmm)

 ## Install

@@ -144,7 +140,7 @@ const pairs = await orion.getPairs("spot"); // 'spot'
 // }
 ```

-### Get Orion Bridge history
+### Get Lumia Stream Bridge history

 ```ts
 const bridgeHistory = await orion.bridge.getHistory(
@@ -719,3 +715,105 @@ switch (data.type) {
    break;
 }
 ```
+## PMM
+
+PMM allows institutional traders to request RFQ orders from Lumia Stream and then fill them.
+
+RFQ order allows trader to fix the price for a certain time interval (up to 90 seconds, including the order settlement time interval on blockchain). 
+
+After receiving the order (if the price of the order is satisfactory to the trader) the trader must immediately submit the transaction on behalf of his address or contract.
+
+For requesting RFQ-orders institutional trader should have API key and secret key.
+
+Please take look at code example below.
+
+Simple example:
+
+```ts
+// Node.js
+
+import  { Orion } from '@orionprotocol/sdk'
+import {Wallet} from "ethers";
+
+(async() => {
+    const apiKey = '958153f1-b8b9-3ec4-84eb-2147429105d9';
+    const secretKey = 'secretKey';
+    const yourWalletPrivateKey = '0x...';
+
+    const orion = new Orion('testing');   //  Leave empty for PROD environment
+    const bsc = orion.getUnit('bsc');
+    const wallet = new Wallet(yourWalletPrivateKey, bsc.provider);
+
+    //  This can be done only once, no need to repeat this every time
+    //      assetToDecimals can also be useful for calculations
+    //  const {assetToAddress, assetToDecimals} = await bsc.blockchainService.getInfo();
+    const info = await bsc.blockchainService.getInfo();
+
+    if(!info.isOk())
+        return;
+
+    const {assetToAddress, assetToDecimals} = info.value.data;
+
+    //  Also you need to allow FRQ contract to spend tokens from your address.
+    //      This also can be done only once.
+    await bsc.pmm.setAllowance(assetToAddress.ORN, '1000000000000000000', wallet);
+
+    //  Just output the PMM router contract address
+    console.log('Router contract address: ', await bsc.pmm.getContractAddress());
+
+    const rfqOrder = await bsc.aggregator.RFQOrder(
+        assetToAddress.ORN,   //  Spending asset
+        assetToAddress.USDT,  //  Receiving asset
+        '1000000000',        //  Amount in "satoshi" of spending asset
+        apiKey,
+        secretKey,
+        '0x61Eed69c0d112C690fD6f44bB621357B89fBE67F'  //  Can be any address, ignored for now
+    );
+
+    if(!rfqOrder.success) {
+        console.log(rfqOrder.error);
+        return;
+    }
+
+    //  ... here you can check order prices, etc.
+
+    //  Send order to blockchain
+    try {
+        const tx = await bsc.pmm.fillRFQOrder(rfqOrder, wallet);
+
+        // If tx.hash is not empty - then transaction was sent to blockchain
+        console.log(tx.hash);
+    }
+    catch(err) {
+        console.log(err);
+    }
+})();
+```
+
+RFQ order response example description (`rfqOrder` from example above):
+
+```
+    {
+      quotation: {
+        info: '31545611720730315633520017429',
+        makerAsset: '0xcb2951e90d8dcf16e1fa84ac0c83f48906d6a744',
+        takerAsset: '0xf223eca06261145b3287a0fefd8cfad371c7eb34',
+        maker: '0x1ff516e5ce789085cff86d37fc27747df852a80a',
+        allowedSender: '0x0000000000000000000000000000000000000000',
+        makingAmount: '193596929',
+        takingAmount: '10000000000'
+      },
+      signature: '0x8a2f9140a3c3a5734eda763a19c54c5ac909d8a03db37d9804af9115641fd1d35896b66ca6e136c1c89e0478fb7382a4b875d0f74529c1e83601f9383d310dde1b',
+      success: true,
+      error: ''
+    }
+```
+
+
+* info - can be ignored
+* makerAsset - your RECEIVING asset (what you expect to receive from contract, in this case USDT)
+* takerAsset - your SPENDING asset (what you're giving to contract, in this case ORN)
+* maker - can be ignored for now;
+* allowedSender - can be ignored for now;
+* makingAmount - how much you will RECEIVE (in receiving asset's precision)
+* takingAmount - how much you should SPEND (in spending asset's precision)
--- a/jest.config.js
+++ b/jest.config.js
@@ -13,7 +13,7 @@ export default {
      'ts-jest',
      {
        isolatedModules: true,
-        // tsconfig: 'tsconfig.json',
+        //  tsconfig: 'tsconfig.json',
        useESM: true,
      },
    ],
--- a/src/Orion/index.ts
+++ b/src/Orion/index.ts
@@ -21,10 +21,15 @@ export default class Orion {

  // TODO: get tradable pairs (aggregated)

+  public logger: ((message: string) => void) | undefined;
+
  constructor(
    envOrConfig: KnownEnv | EnvConfig = 'production',
-    overrides?: DeepPartial<EnvConfig>
+    overrides?: DeepPartial<EnvConfig>,
+    logger?: ((message: string) => void) | undefined
  ) {
+    this.logger = logger;
+
    let config: EnvConfig;
    if (typeof envOrConfig === 'string') {
      const envConfig = envs[envOrConfig];
@@ -33,7 +38,7 @@ export default class Orion {
      }
      this.env = envOrConfig;
      config = {
-        analyticsAPI: envConfig.analyticsAPI,
+        analyticsAPI: envConfig?.analyticsAPI,
        referralAPI: envConfig.referralAPI,
        networks: Object.entries(envConfig.networks).map(([chainId, networkConfig]) => {
          if (!isValidChainId(chainId)) throw new Error(`Invalid chainId: ${chainId}`);
@@ -59,7 +64,7 @@ export default class Orion {
                api: networkConfig.api + networkConfig.services.priceFeed.all,
              },
              indexer: {
-                api: networkConfig.api + networkConfig.services.indexer.http,
+                api: networkConfig.api + networkConfig.services.indexer?.http,
              }
            },
          };
@@ -92,7 +97,7 @@ export default class Orion {
          // api: networkConfig.api,
          nodeJsonRpc: networkConfig.nodeJsonRpc,
          services: networkConfig.services,
-        });
+        }, logger);
        return {
          ...acc,
          [chainId]: unit,
--- a/src/Unit/Exchange/generateSwapCalldata.ts
+++ b/src/Unit/Exchange/generateSwapCalldata.ts
@@ -397,7 +397,7 @@ async function shouldUseExchangeBalance(
  let useExchangeBalance = true;
  let additionalTransferAmount = 0n;

-  if (exchangeBalance == 0n) {
+  if (walletBalance >= amount || exchangeBalance == 0n) {
    useExchangeBalance = false;
    additionalTransferAmount = amount;
  } else {
--- a/src/Unit/Pmm/abi/OrionRFQ.ts
+++ b/src/Unit/Pmm/abi/OrionRFQ.ts
@@ -0,0 +1,63 @@
+export const orionRFQContractABI =
+    [
+        {
+            "inputs": [
+                {
+                    "components": [
+                        {
+                            "internalType": "uint256",
+                            "name": "info",
+                            "type": "uint256"
+                        },
+                        {
+                            "internalType": "address",
+                            "name": "makerAsset",
+                            "type": "address"
+                        },
+                        {
+                            "internalType": "address",
+                            "name": "takerAsset",
+                            "type": "address"
+                        },
+                        {
+                            "internalType": "address",
+                            "name": "maker",
+                            "type": "address"
+                        },
+                        {
+                            "internalType": "address",
+                            "name": "allowedSender",
+                            "type": "address"
+                        },
+                        {
+                            "internalType": "uint256",
+                            "name": "makingAmount",
+                            "type": "uint256"
+                        },
+                        {
+                            "internalType": "uint256",
+                            "name": "takingAmount",
+                            "type": "uint256"
+                        }
+                    ],
+                    "internalType": "struct OrderRFQLib.OrderRFQ",
+                    "name": "order",
+                    "type": "tuple"
+                },
+                {
+                    "internalType": "bytes",
+                    "name": "signature",
+                    "type": "bytes"
+                },
+                {
+                    "internalType": "uint256",
+                    "name": "flagsAndAmount",
+                    "type": "uint256"
+                }
+            ],
+            "name": "fillOrderRFQ",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function"
+        }
+    ];
--- a/src/Unit/Pmm/index.ts
+++ b/src/Unit/Pmm/index.ts
@@ -0,0 +1,84 @@
+import type Unit from '../index';
+import { z } from 'zod';
+import {pmmOrderSchema} from "./schemas/order";
+import {simpleFetch} from "simple-typed-fetch";
+import {ethers, Wallet} from "ethers";
+import {BigNumber} from "bignumber.js";
+import { ERC20__factory } from '@orionprotocol/contracts/lib/ethers-v6/index.js';
+import {orionRFQContractABI} from "./abi/OrionRFQ";
+
+export default class Pmm {
+    private readonly unit: Unit;
+    private readonly provider: ethers.Provider;
+    private contractAddress: string;
+
+    constructor(unit: Unit) {
+        this.unit = unit;
+        this.provider = unit.provider;
+        this.contractAddress = '';
+        //  this.contractAddress = '0x89357522c0ed6e557d39dc75290859246077bdfc';
+    }
+
+    private isInitialized() : boolean {
+        return this.contractAddress !== '';
+    }
+
+    public async init() {
+        if(this.isInitialized())
+            return;
+        const { orionPMMRouterContractAddress } = await simpleFetch(this.unit.blockchainService.getPmmInfo)();
+        this.contractAddress = orionPMMRouterContractAddress;
+    }
+
+    public async getContractAddress() {
+        await this.init();
+        return this.contractAddress;
+    }
+
+    public async setAllowance(token: string, amount: string, signer: Wallet) {
+        await this.init();
+
+        const bnTargetAmount = new BigNumber(amount);
+        const walletAddress = await signer.getAddress();
+
+        const tokenContract = ERC20__factory
+            .connect(token, this.unit.provider);
+
+        const unsignedApproveTx = await tokenContract
+            .approve.populateTransaction(
+                this.contractAddress,
+                bnTargetAmount.toString()
+            );
+        const nonce = await this.provider.getTransactionCount(walletAddress, 'pending');
+        const { gasPrice, maxFeePerGas } = await this.provider.getFeeData();
+        const network = await this.provider.getNetwork();
+
+        if (gasPrice !== null)
+            unsignedApproveTx.gasPrice = gasPrice;
+
+        if(maxFeePerGas !== null)
+            unsignedApproveTx.maxFeePerGas = maxFeePerGas;
+
+        unsignedApproveTx.chainId = network.chainId;
+        unsignedApproveTx.nonce = nonce;
+        unsignedApproveTx.from = walletAddress;
+        const gasLimit = await this.provider.estimateGas(unsignedApproveTx);
+        unsignedApproveTx.gasLimit = gasLimit;
+
+        const signedTx = await signer.signTransaction(unsignedApproveTx);
+        const txResponse = await this.provider.broadcastTransaction(signedTx);
+        await txResponse.wait();
+    }
+
+    public async fillRFQOrder(order : z.infer<typeof pmmOrderSchema>, signer: Wallet) {
+        await this.init();
+
+        if(!order.success)
+            throw Error("Invalid order provided");
+
+        const contract = new ethers.Contract(this.contractAddress, orionRFQContractABI, signer);
+
+        // @ts-ignore
+        return contract.fillOrderRFQ(order.order, order.signature, BigInt(0));
+    }
+}
--- a/src/Unit/Pmm/schemas/order.ts
+++ b/src/Unit/Pmm/schemas/order.ts
@@ -0,0 +1,18 @@
+import {z} from "zod";
+
+export const pmmOrderQuotationSchema = z.object({
+    info: z.string().default(''),
+    makerAsset: z.string().default(''),
+    takerAsset: z.string().default(''),
+    maker: z.string().default(''),
+    allowedSender: z.string().default(''),
+    makingAmount: z.string().default(''),
+    takingAmount: z.string().default(''),
+});
+
+export const pmmOrderSchema = z.object({
+    order: pmmOrderQuotationSchema.default({}),
+    signature: z.string().default(''),
+    success: z.boolean().default(false),
+    error: z.string().default(''),
+});
--- a/src/Unit/index.ts
+++ b/src/Unit/index.ts
@@ -1,16 +1,17 @@
 import { JsonRpcProvider } from 'ethers';
-import { Aggregator } from '../services/Aggregator/index.js';
-import { BlockchainService } from '../services/BlockchainService/index.js';
-import { PriceFeed } from '../services/PriceFeed/index.js';
+import { Aggregator } from '../services/Aggregator';
+import { BlockchainService } from '../services/BlockchainService';
+import { PriceFeed } from '../services/PriceFeed';
 import type {
  KnownEnv,
  SupportedChainId,
  VerboseUnitConfig,
 } from '../types.js';
 import Exchange from './Exchange/index.js';
-import { chains, envs } from '../config/index.js';
+import { chains, envs } from '../config';
 import type { networkCodes } from '../constants/index.js';
-import { IndexerService } from '../services/Indexer/index.js';
+import { IndexerService } from '../services/Indexer';
+import Pmm from "./Pmm";

 type KnownConfig = {
  env: KnownEnv
@@ -26,10 +27,12 @@ export default class Unit {

  public readonly blockchainService: BlockchainService;

-  public readonly indexer: IndexerService;
+  public readonly indexer: IndexerService | undefined;

  public readonly aggregator: Aggregator;

+  public readonly pmm: Pmm;
+
  public readonly priceFeed: PriceFeed;

  public readonly exchange: Exchange;
@@ -38,7 +41,10 @@ export default class Unit {

  public readonly contracts: Record<string, string>;

-  constructor(config: KnownConfig | VerboseUnitConfig) {
+  public logger: ((message: string) => void) | undefined;
+
+  constructor(config: KnownConfig | VerboseUnitConfig, logger?: ((message: string) => void) | undefined) {
+    this.logger = logger;
    if ('env' in config) {
      const staticConfig = envs[config.env];
      if (!staticConfig) {
@@ -83,7 +89,7 @@ export default class Unit {
            api: networkConfig.api + networkConfig.services.priceFeed.all,
          },
          indexer: {
-            api: networkConfig.api + networkConfig.services.indexer.http,
+            api: networkConfig.api + networkConfig.services.indexer?.http,
          },
        },
      };
@@ -106,19 +112,23 @@ export default class Unit {
      this.config.services.blockchainService.http,
      this.config.basicAuth
    );
-    this.indexer = new IndexerService(
-      this.config.services.indexer.api,
-      intNetwork
-    );
+    this.indexer = this.config.services.indexer
+      ? new IndexerService(
+        this.config.services.indexer.api,
+        intNetwork
+      )
+      : undefined;
    this.aggregator = new Aggregator(
      this.config.services.aggregator.http,
      this.config.services.aggregator.ws,
-      this.config.basicAuth
+      this.config.basicAuth,
+      logger,
    );
    this.priceFeed = new PriceFeed(
      this.config.services.priceFeed.api,
      this.config.basicAuth
    );
    this.exchange = new Exchange(this);
+    this.pmm = new Pmm(this);
  }
 }
--- a/src/config/chains.json
+++ b/src/config/chains.json
@@ -47,7 +47,8 @@
    "rpc": "https://opbnb-mainnet-rpc.bnbchain.org",
    "baseCurrencyName": "BNB",
    "contracts": {
-      "WETH": "0x4200000000000000000000000000000000000006"
+      "WETH": "0x4200000000000000000000000000000000000006",
+      "curveRegistry": ""
    }
  },
  "3": {
@@ -96,10 +97,10 @@
    "shortName": "Arbitrum",
    "code": "arb",
    "rpc": "https://arb1.arbitrum.io/rpc",
-    "baseCurrencyName": "ARB",
+    "baseCurrencyName": "ETH",
    "contracts": {
      "WETH": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-      "curveRegistiry": "0x445FE580eF8d70FF569aB36e80c647af338db351"
+      "curveRegistry": "0x445FE580eF8d70FF569aB36e80c647af338db351"
    }
  },
  "4002": {
@@ -192,5 +193,57 @@
      "WETH": "",
      "curveRegistry": ""
    }
+  },
+  "2525": {
+    "chainId": "2525",
+    "label": "inEVM",
+    "shortName": "inEVM",
+    "code": "inevm",
+    "baseCurrencyName": "INJ",
+    "rpc": "https://inevm.calderachain.xyz/http/",
+    "explorer": "https://explorer.injective.network/",
+    "contracts": {
+      "WETH": "0x4C3A213bd5e8c4BD70a8396d6F3C8302571598Cd",
+      "curveRegistry": ""
+    }
+  },
+  "59144": {
+    "chainId": "59144",
+    "label": "Linea",
+    "shortName": "Linea",
+    "code": "linea",
+    "baseCurrencyName": "ETH",
+    "rpc": "https://rpc.linea.build/",
+    "explorer": "https://lineascan.build/",
+    "contracts": {
+      "WETH": "0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f",
+      "curveRegistry": ""
+    }
+  },
+  "43114": {
+    "chainId": "43114",
+    "label": "Avalanche Network",
+    "shortName": "Avax",
+    "code": "avax",
+    "baseCurrencyName": "AVAX",
+    "rpc": "https://api.avax.network/ext/bc/C/rpc/",
+    "explorer": "https://snowtrace.io/",
+    "contracts": {
+      "WETH": "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
+      "curveRegistry": ""
+    }
+  },
+  "8453": {
+    "chainId": "8453",
+    "label": "Base",
+    "shortName": "BASE",
+    "code": "base",
+    "baseCurrencyName": "ETH",
+    "rpc": "https://mainnet.base.org/",
+    "explorer": "https://basescan.org/",
+    "contracts": {
+      "WETH": "0x4200000000000000000000000000000000000006",
+      "curveRegistry": ""
+    }
  }
 }
--- a/src/config/envs.json
+++ b/src/config/envs.json
@@ -1,6 +1,5 @@
 {
  "production": {
-    "analyticsAPI": "https://trade.orion.xyz/api/stats",
    "referralAPI": "https://trade.orion.xyz/referral-api",
    "networks": {
      "1": {
@@ -95,7 +94,7 @@
        }
      },
      "42161": {
-        "api": "https://trade.orion.xyz/arbitrum-mainnet",
+        "api": "https://trade.orion.xyz/arbitrum-one",
        "services": {
          "aggregator": {
            "http": "/backend",
@@ -129,11 +128,82 @@
            "http": "/orion-indexer/"
          }
        }
+      },
+      "2525": {
+        "api": "https://trade.orion.xyz/inevm-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "59144": {
+        "api": "https://trade.orion.xyz/linea-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "43114": {
+        "api": "https://trade.orion.xyz/avalanche-c-chain",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "8453": {
+        "api": "https://trade.orion.xyz/base-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
      }
    }
  },
  "testing": {
-    "analyticsAPI": "https://trade.orion.xyz/api/stats",
    "referralAPI": "https://testing.orion.xyz/referral-api",
    "networks": {
      "97": {
@@ -248,7 +318,6 @@
    }
  },
  "staging": {
-    "analyticsAPI": "https://trade.orion.xyz/api/stats",
    "referralAPI": "https://staging.orion.xyz/referral-api",
    "networks": {
      "1": {
@@ -340,11 +409,118 @@
            "http": "/orion-indexer/"
          }
        }
+      },
+      "42161": {
+        "api": "https://staging.orion.xyz/arbitrum-one",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "204": {
+        "api": "https://staging.orion.xyz/opbnb-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "2525": {
+        "api": "https://staging.orion.xyz/inevm-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "59144": {
+        "api": "https://staging.orion.xyz/linea-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "43114": {
+        "api": "https://staging.orion.xyz/avalanche-c-chain",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
+      },
+      "8453": {
+        "api": "https://staging.orion.xyz/base-mainnet",
+        "services": {
+          "aggregator": {
+            "http": "/backend",
+            "ws": "/v1"
+          },
+          "blockchain": {
+            "http": ""
+          },
+          "priceFeed": {
+            "all": "/price-feed"
+          },
+          "indexer": {
+            "http": "/orion-indexer/"
+          }
+        }
      }
    }
  },
  "experimental": {
-    "analyticsAPI": "https://trade.orion.xyz/api/stats",
    "referralAPI": "https://testing.orion.xyz/referral-api",
    "networks": {
      "97": {
@@ -386,7 +562,6 @@
    }
  },
  "kucoin-production": {
-    "analyticsAPI": "https://trade.orion.xyz/api/stats",
    "referralAPI": "https://trade.orion.xyz/referral-api",
    "networks": {
      "1": {
--- a/src/config/schemas/pureEnvSchema.ts
+++ b/src/config/schemas/pureEnvSchema.ts
@@ -16,14 +16,14 @@ export const pureEnvNetworksSchema = z.object({
    }),
    indexer: z.object({
      http: z.string(),
-    }),
+    }).optional(),
  }),
  rpc: z.string().optional(),
  liquidityMigratorAddress: z.string().optional(),
 });

 export const pureEnvPayloadSchema = z.object({
-  analyticsAPI: z.string().url(),
+  analyticsAPI: z.string().url().optional(),
  referralAPI: z.string().url(),
  networks: z.record(
    z.nativeEnum(SupportedChainId),
--- a/src/constants/chains.ts
+++ b/src/constants/chains.ts
@@ -17,4 +17,8 @@ export const productionChains = [
  SupportedChainId.OKC,
  SupportedChainId.ARBITRUM,
  SupportedChainId.OPBNB,
+  SupportedChainId.INEVM,
+  SupportedChainId.LINEA,
+  SupportedChainId.AVAX,
+  SupportedChainId.BASE,
 ];
--- a/src/constants/networkCodes.ts
+++ b/src/constants/networkCodes.ts
@@ -1 +1 @@
-export default ['ftm', 'bsc', 'eth', 'polygon', 'okc', 'arb', 'drip', 'opbnb'] as const;
+export default ['ftm', 'bsc', 'eth', 'polygon', 'okc', 'arb', 'drip', 'opbnb', 'inevm', 'linea', 'avax', 'base'] as const;
--- a/src/constants/uppercasedNetworkCodes.ts
+++ b/src/constants/uppercasedNetworkCodes.ts
@@ -1 +1 @@
-export default ['FTM', 'BSC', 'ETH', 'POLYGON', 'OKC', 'ARB'] as const;
+export default ['FTM', 'BSC', 'ETH', 'POLYGON', 'OKC', 'ARB', 'OPBNB', 'INEVM', 'LINEA', 'AVAX', 'BASE'] as const;
--- a/src/crypt/hashOrder.ts
+++ b/src/crypt/hashOrder.ts
@@ -1,35 +1,16 @@
-import { ethers } from 'ethers';
+import { ethers, keccak256 } from 'ethers';
 import type { Order } from '../types.js';

-const hashOrder = (order: Order) => ethers.solidityPackedKeccak256(
-  [
-    'uint8',
-    'address',
-    'address',
-    'address',
-    'address',
-    'address',
-    'uint64',
-    'uint64',
-    'uint64',
-    'uint64',
-    'uint64',
-    'uint8',
-  ],
-  [
-    '0x03',
-    order.senderAddress,
-    order.matcherAddress,
-    order.baseAsset,
-    order.quoteAsset,
-    order.matcherFeeAsset,
-    order.amount,
-    order.price,
-    order.matcherFee,
-    order.nonce,
-    order.expiration,
-    order.buySide === 1 ? '0x01' : '0x00',
-  ],
-);
+const ORDER_TYPEHASH = "0xb5132db62dfceb466f2f8aee7a039db36a99772e5a9771d28388a5f9baad7c54"

-export default hashOrder;
+export default function getOrderHash(order: Order) {
+	const abiCoder = ethers.AbiCoder.defaultAbiCoder()
+
+	const { senderAddress, matcherAddress, baseAsset, quoteAsset, matcherFeeAsset, amount, price, matcherFee, nonce, expiration, buySide } = order
+	const orderBytes = abiCoder.encode(
+		["bytes32", "address", "address", "address", "address", "address", "uint64", "uint64", "uint64", "uint64", "uint64", "uint8"],
+		[ORDER_TYPEHASH, senderAddress, matcherAddress, baseAsset, quoteAsset, matcherFeeAsset, amount, price, matcherFee, nonce, expiration, buySide]
+	)
+
+	return keccak256(orderBytes)
+}
--- a/src/services/Aggregator/index.ts
+++ b/src/services/Aggregator/index.ts
@@ -25,6 +25,10 @@ import httpToWS from '../../utils/httpToWS.js';
 import { ethers } from 'ethers';
 import orderSchema from './schemas/orderSchema.js';
 import { fetchWithValidation } from 'simple-typed-fetch';
+import { pmmOrderSchema } from '../../Unit/Pmm/schemas/order';
+//  import hmacSHA256 from "crypto-js/hmac-sha256";
+//  import Hex from "crypto-js/enc-hex";
+// const crypto = require('crypto')

 class Aggregator {
  private readonly apiUrl: string;
@@ -37,11 +41,16 @@ class Aggregator {
    return this.apiUrl;
  }

+  public logger: ((message: string) => void) | undefined;
+
  constructor(
    httpAPIUrl: string,
    wsAPIUrl: string,
-    basicAuth?: BasicAuthCredentials
+    basicAuth?: BasicAuthCredentials,
+    logger?: ((message: string) => void) | undefined
  ) {
+    this.logger = logger;
+
    // const oaUrl = new URL(apiUrl);
    // const oaWsProtocol = oaUrl.protocol === 'https:' ? 'wss' : 'ws';
    // const aggregatorWsUrl = `${oaWsProtocol}://${oaUrl.host + (oaUrl.pathname === '/'
@@ -49,7 +58,7 @@ class Aggregator {
    //   : oaUrl.pathname)}/v1`;

    this.apiUrl = httpAPIUrl;
-    this.ws = new AggregatorWS(httpToWS(wsAPIUrl));
+    this.ws = new AggregatorWS(httpToWS(wsAPIUrl), undefined, logger);
    this.basicAuth = basicAuth;

    this.getHistoryAtomicSwaps = this.getHistoryAtomicSwaps.bind(this);
@@ -59,6 +68,7 @@ class Aggregator {
    this.getSwapInfo = this.getSwapInfo.bind(this);
    this.getCrossChainAssetsByNetwork = this.getCrossChainAssetsByNetwork.bind(this);
    this.getTradeProfits = this.getTradeProfits.bind(this);
+    this.getStableCoins = this.getStableCoins.bind(this);
    this.placeAtomicSwap = this.placeAtomicSwap.bind(this);
    this.placeOrder = this.placeOrder.bind(this);
    this.placeLockOrder = this.placeLockOrder.bind(this);
@@ -70,6 +80,7 @@ class Aggregator {
    this.getPoolReserves = this.getPoolReserves.bind(this);
    this.getVersion = this.getVersion.bind(this);
    this.getPrices = this.getPrices.bind(this);
+    this.getIsCexLiquidityAvailable = this.getIsCexLiquidityAvailable.bind(this);
  }

  get basicAuthHeaders() {
@@ -383,6 +394,16 @@ class Aggregator {
    );
  };

+  getStableCoins = () => {
+    const url = new URL(`${this.apiUrl}/api/v1/tokens/stable/`);
+    return fetchWithValidation(
+      url.toString(),
+      z.array(z.string()),
+      { headers: this.basicAuthHeaders },
+      errorSchema,
+    );
+  };
+
  /**
     * Placing atomic swap. Placement must take place on the target chain.
     * @param secretHash Secret hash
@@ -422,6 +443,116 @@ class Aggregator {
    url.searchParams.append('limit', limit.toString());
    return fetchWithValidation(url.toString(), atomicSwapHistorySchema, { headers: this.basicAuthHeaders });
  };
+
+  getIsCexLiquidityAvailable = (
+    assetIn: string,
+    assetOut: string,
+  ) => {
+    const url = new URL(`${this.apiUrl}/api/v1/pairs/cex/liquidity/${assetIn}/${assetOut}`);
+
+    return fetchWithValidation(
+      url.toString(),
+      z.boolean(),
+      { headers: this.basicAuthHeaders },
+      errorSchema,
+    );
+  };
+
+  // private encode_utf8(s: string) {
+  //   return unescape(encodeURIComponent(s));
+  // }
+
+  // @ts-expect-error: TODO: please remove this line!
+  private sign(message: string, key: string) {
+    // return crypto.createHmac('sha256', this.encode_utf8(key))
+    //   .update(this.encode_utf8(message))
+    //   .digest('hex');
+    return '';
+  }
+
+  private generateHeaders(body: any, method: string, path: string, timestamp: number, apiKey: string, secretKey: string) {
+    const sortedBody = Object.keys(body)
+      .sort()
+      .map((key) => (
+        `${key}=${body[key]}`
+      )).join('&');
+
+    const payload = timestamp + method.toUpperCase() + path + sortedBody;
+
+    const signature = this.sign(payload, secretKey);
+
+    const httpOptions = {
+      headers: {
+        'API-KEY': apiKey,
+        'ACCESS-TIMESTAMP': timestamp.toString(),
+        'ACCESS-SIGN': signature
+      }
+    };
+    return httpOptions;
+  }
+
+  public async RFQOrder(
+    tokenFrom: string,
+    tokenTo: string,
+    fromTokenAmount: string,
+    apiKey: string, //
+    secretKey: string,
+    wallet: string
+  ): Promise<z.infer<typeof pmmOrderSchema>> {
+    //  Making the order structure
+    const
+      path = '/rfq';
+    const url = `${this.apiUrl}/api/v1/integration/pmm` + path;
+    const headers = {
+      'Content-Type': 'application/json',
+    };
+    const data = {
+      baseToken: tokenFrom, // USDT
+      quoteToken: tokenTo, // ORN
+      amount: fromTokenAmount, // 100
+      taker: wallet,
+      feeBps: 0
+    };
+    const method = 'POST';
+    const timestamp = Date.now();
+    const signatureHeaders = this.generateHeaders(data, method, path, timestamp, apiKey, secretKey);
+    const compiledHeaders = { ...headers, ...signatureHeaders.headers, };
+    const body = JSON.stringify(data)
+    ;
+
+    const res = pmmOrderSchema.parse({});
+
+    try {
+      const result = await fetch(url, {
+        headers: compiledHeaders,
+        method,
+        body
+      });
+
+      const json = await result.json();
+      const parseResult = pmmOrderSchema.safeParse(json);
+
+      if (!parseResult.success) {
+        //  Try to parse error answer
+        const errorSchema = z.object({ error: z.object({ code: z.number(), reason: z.string() }) });
+
+        const errorParseResult = errorSchema.safeParse(json);
+
+        if (!errorParseResult.success) { throw Error(`Unrecognized answer from aggregator: ${json}`); }
+
+        throw Error(errorParseResult.data.error.reason);
+      }
+
+      res.order = parseResult.data.order;
+      res.signature = parseResult.data.signature;
+      res.error = '';
+      res.success = true;
+      //  return result;
+    } catch (err) {
+      res.error = `${err}`;
+    }
+    return res;
+  }
 }

 export * as schemas from './schemas/index.js';
--- a/src/services/Aggregator/schemas/swapInfoSchema.ts
+++ b/src/services/Aggregator/schemas/swapInfoSchema.ts
@@ -49,6 +49,7 @@ const swapInfoBase = z.object({
    mi: z.number().optional(), // market amount in, USD
    d: z.string().optional(), // difference in available amount in/out (USD) and market amount out/in (USD) in percentage
  }).optional(),
+  autoSlippage: z.number().optional(),
 });

 const swapInfoByAmountIn = swapInfoBase.extend({
--- a/src/services/Aggregator/ws/index.ts
+++ b/src/services/Aggregator/ws/index.ts
@@ -66,10 +66,11 @@ type PairConfigSubscription = {

 type AggregatedOrderbookSubscription = {
  payload: string
+  dc?: number
  callback: (
    asks: OrderbookItem[],
    bids: OrderbookItem[],
-    pair: string
+    pair: string,
  ) => void
  errorCb?: (message: string) => void
 }
@@ -195,9 +196,10 @@ class AggregatorWS {

  readonly basicAuth?: BasicAuthCredentials | undefined;

-  constructor(wsUrl: string, basicAuth?: BasicAuthCredentials) {
+  constructor(wsUrl: string, basicAuth?: BasicAuthCredentials, logger?: ((message: string) => void) | undefined) {
    this.wsUrl = wsUrl;
    this.basicAuth = basicAuth;
+    this.logger = logger;
  }

  private messageQueue: BufferLike[] = [];
@@ -254,7 +256,7 @@ class AggregatorWS {
    subscription: Subscription[T],
    prevSubscriptionId?: string
  ) {
-    const id = type === 'aobus'
+    const id = type === SubscriptionType.AGGREGATED_ORDER_BOOK_UPDATES_SUBSCRIBE
      ? ((subscription as any).payload as string) // TODO: Refactor!!!
      : uuidv4();

@@ -264,6 +266,12 @@ class AggregatorWS {
      subRequest['T'] = type;
      subRequest['id'] = id;

+      if ('dc' in subscription) {
+        if (typeof subscription.dc === 'number') {
+          subRequest['dc'] = subscription.dc;
+        }
+      }
+
      if ('payload' in subscription) {
        if (typeof subscription.payload === 'string') {
          subRequest['S'] = subscription.payload;
@@ -371,11 +379,11 @@ class AggregatorWS {
      delete this.subscriptions[SubscriptionType.ASSET_PAIR_CONFIG_UPDATES_SUBSCRIBE]?.[newestSubId];
      // !!! swap info subscription is uuid that contains hyphen
    } else if (isOrderBooksSubscription(newestSubId)) { // is pair name(AGGREGATED_ORDER_BOOK_UPDATE)
-      const aobSubscriptions = this.subscriptions[SubscriptionType.AGGREGATED_ORDER_BOOK_UPDATES_SUBSCRIBE];
-      if (aobSubscriptions) {
-        const targetAobSub = Object.entries(aobSubscriptions).find(([, value]) => value?.payload === newestSubId);
-        if (targetAobSub) {
-          const [key] = targetAobSub;
+      const aobusSubscriptions = this.subscriptions[SubscriptionType.AGGREGATED_ORDER_BOOK_UPDATES_SUBSCRIBE];
+      if (aobusSubscriptions) {
+        const targetAobusSub = Object.entries(aobusSubscriptions).find(([, value]) => value?.payload === newestSubId);
+        if (targetAobusSub) {
+          const [key] = targetAobusSub;
          delete this.subscriptions[SubscriptionType.AGGREGATED_ORDER_BOOK_UPDATES_SUBSCRIBE]?.[key];
        }
      }
@@ -535,6 +543,7 @@ class AggregatorWS {
              marketAmountIn: json.usd.mi,
              difference: json.usd.d,
            },
+            autoSlippage: json.sl,
          };

          switch (json.k) { // kind
--- a/src/services/Aggregator/ws/schemas/swapInfoSchema.ts
+++ b/src/services/Aggregator/ws/schemas/swapInfoSchema.ts
@@ -48,6 +48,7 @@ const swapInfoSchemaBase = baseMessageSchema.extend({
    mi: z.number().optional(), // market amount in, USD
    d: z.string().optional(), // difference in available amount in/out (USD) and market amount out/in (USD) in percentage
  }).optional(),
+  sl: z.number().optional(),
 });

 const swapInfoSchemaByAmountIn = swapInfoSchemaBase.extend({
--- a/src/services/BlockchainService/index.ts
+++ b/src/services/BlockchainService/index.ts
@@ -12,6 +12,7 @@ import {
  pairStatusSchema,
  pricesWithQuoteAssetSchema,
  referralDataSchema,
+  pmmSchema
 } from './schemas/index.js';
 import type redeemOrderSchema from '../Aggregator/schemas/redeemOrderSchema.js';
 import { sourceAtomicHistorySchema, targetAtomicHistorySchema } from './schemas/atomicHistorySchema.js';
@@ -82,6 +83,7 @@ class BlockchainService {
    this.getAuthToken = this.getAuthToken.bind(this);
    this.getCirculatingSupply = this.getCirculatingSupply.bind(this);
    this.getInfo = this.getInfo.bind(this);
+    this.getPmmInfo = this.getPmmInfo.bind(this);
    this.getPoolsConfig = this.getPoolsConfig.bind(this);
    this.getPoolsInfo = this.getPoolsInfo.bind(this);
    this.getPoolsLpAndStaked = this.getPoolsLpAndStaked.bind(this);
@@ -111,6 +113,8 @@ class BlockchainService {
    this.getBlockNumber = this.getBlockNumber.bind(this);
    this.getRedeemOrderBySecretHash = this.getRedeemOrderBySecretHash.bind(this);
    this.claimOrder = this.claimOrder.bind(this);
+    this.getGasLimits = this.getGasLimits.bind(this);
+    this.getExchangeContractWalletBalance = this.getExchangeContractWalletBalance.bind(this);
  }

  get basicAuthHeaders() {
@@ -175,6 +179,8 @@ class BlockchainService {

  getInfo = () => fetchWithValidation(`${this.apiUrl}/api/info`, infoSchema);

+  getPmmInfo = () => fetchWithValidation(`${this.apiUrl}/api/pmm-info`, pmmSchema);
+
  getPoolsConfig = () => fetchWithValidation(
    `${this.apiUrl}/api/pools/config`,
    poolsConfigSchema,
@@ -484,6 +490,18 @@ class BlockchainService {
      body: JSON.stringify(secretHashes),
    },
  );
+
+  getGasLimits = () => fetchWithValidation(
+    `${this.apiUrl}/api/baseLimits`,
+    z.record(z.number()),
+    { headers: this.basicAuthHeaders }
+  );
+
+  getExchangeContractWalletBalance = (exchangeContractAddress: string) => fetchWithValidation(
+    `${this.apiUrl}/api/broker/getWalletBalance/${exchangeContractAddress}`,
+    z.record(z.string()),
+    { headers: this.basicAuthHeaders }
+  );
 }

 export * as schemas from './schemas/index.js';
--- a/src/services/BlockchainService/schemas/index.ts
+++ b/src/services/BlockchainService/schemas/index.ts
@@ -13,5 +13,6 @@ export { default as poolsLpAndStakedSchema } from './poolsLpAndStakedSchema.js';
 export { default as userVotesSchema } from './userVotesSchema.js';
 export { default as userEarnedSchema } from './userEarnedSchema.js';
 export { default as poolsV3InfoSchema } from './poolsV3InfoSchema.js';
+export { default as pmmSchema } from './pmmSchema.js';
 export { pricesWithQuoteAssetSchema } from './pricesWithQuoteAssetSchema.js';
 export { referralDataSchema } from './referralDataSchema.js';
--- a/src/services/BlockchainService/schemas/pmmSchema.ts
+++ b/src/services/BlockchainService/schemas/pmmSchema.ts
@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+const pmmSchema = z.object({
+    orionPMMRouterContractAddress: z.string()
+});
+
+export default pmmSchema
--- a/src/services/BlockchainService/schemas/referralDataSchema.ts
+++ b/src/services/BlockchainService/schemas/referralDataSchema.ts
@@ -1,6 +1,6 @@
-import { z } from "zod";
+import { z } from 'zod';

 export const referralDataSchema = z.object({
-  referer: z.string(),
+  referer: z.string().nullable(),
  isReferral: z.boolean(),
 });
--- a/src/services/Indexer/index.ts
+++ b/src/services/Indexer/index.ts
@@ -9,7 +9,7 @@ import {
  PoolV2InfoResponseSchema,
  testIncrementorSchema,
  veORNInfoResponseSchema,
-  votingInfoResponseSchema
+  votingInfoResponseSchema,
 } from './schemas';
 import { fetchWithValidation } from 'simple-typed-fetch';
 import { BigNumber } from 'bignumber.js';
@@ -94,6 +94,7 @@ class IndexerService {
    this.veORNInfo = this.veORNInfo.bind(this);
    this.listAmount = this.listAmount.bind(this);
    this.getAmountByORN = this.getAmountByORN.bind(this);
+    this.getAmountAt = this.getAmountAt.bind(this);
    this.getAmountAtCurrent = this.getAmountAtCurrent.bind(this);
    this.getVotingInfo = this.getVotingInfo.bind(this);
  }
@@ -117,6 +118,23 @@ class IndexerService {
    });
  };

+  /**
+   * @param {number} amount - amount
+   * @param {number} [timestamp = Date.now()] - timestamp, defaults to current time
+   */
+  readonly getAmountAt = (
+    amount: number,
+    timestamp = Date.now()
+  ): BigNumber => {
+    const finalTimestamp = timestamp / 1000;
+
+    // sqrt
+    return BigNumber(amount).dividedBy(this.getK(finalTimestamp));
+  };
+
+  /**
+   * @deprecated since version 69 in favor of getAmountAt
+   */
  readonly getAmountAtCurrent = (amount: number): BigNumber => {
    const timestamp = Date.now() / 1000;

@@ -134,8 +152,7 @@ class IndexerService {
    const multSQRT = deltaDaysBN.dividedBy(WEEK_DAYS).sqrt();
    const multCUBE = deltaDaysBN.dividedBy(alpha).pow(3);

-    return BigNumber(amountToken)
-      .multipliedBy(multSQRT.plus(multCUBE));
+    return BigNumber(amountToken).multipliedBy(multSQRT.plus(multCUBE));
  };

  readonly getVotingInfo = (userAddress?: string) => {
@@ -208,7 +225,11 @@ class IndexerService {
    });
  };

-  readonly poolV2Info = (token0: string, token1: string, address: string | undefined) => {
+  readonly poolV2Info = (
+    token0: string,
+    token1: string,
+    address: string | undefined
+  ) => {
    return fetchWithValidation(this.apiUrl, PoolV2InfoResponseSchema, {
      method: 'POST',
      body: this.makeRPCPayload({
--- a/src/services/PriceFeed/ws/PriceFeedSubscription.ts
+++ b/src/services/PriceFeed/ws/PriceFeedSubscription.ts
@@ -2,7 +2,7 @@ import WebSocket from 'isomorphic-ws';
 import { z } from 'zod';
 import { v4 as uuidv4 } from 'uuid';
 import priceFeedSubscriptions from './priceFeedSubscriptions.js';
-import { tickerInfoSchema, candleSchema } from './schemas/index.js';
+import { tickerInfoSchema, candleSchema, cexPricesSchema } from './schemas/index.js';
 import priceSchema from './schemas/priceSchema.js';
 import type { Json } from '../../../types.js';
 import allTickersSchema from './schemas/allTickersSchema.js';
@@ -24,6 +24,10 @@ export const subscriptions = {
    schema: candleSchema,
    payload: true as const,
  },
+  [priceFeedSubscriptions.CEX]: {
+    schema: cexPricesSchema,
+    payload: false as const,
+  },
 };

 export type SubscriptionType = keyof typeof subscriptions;
--- a/src/services/PriceFeed/ws/priceFeedSubscriptions.ts
+++ b/src/services/PriceFeed/ws/priceFeedSubscriptions.ts
@@ -3,6 +3,7 @@ const priceFeedSubscriptions = {
  ALL_TICKERS: 'allTickers',
  LAST_PRICE: 'lastPrice',
  CANDLE: 'candle',
+  CEX: 'cexPrices'
 } as const;

 export default priceFeedSubscriptions;
--- a/src/services/PriceFeed/ws/schemas/cexPricesSchema.ts
+++ b/src/services/PriceFeed/ws/schemas/cexPricesSchema.ts
@@ -0,0 +1,31 @@
+import { z } from 'zod';
+
+const cexPriceTickerInfoSchema = z.tuple([
+  z.string(), // pair name
+  z.number(), // lastPrice
+]).transform(([pairName, lastPrice]) => ({
+  pairName:pairName.toUpperCase(),
+  lastPrice,
+}));
+
+type CEXPriceTickerInfo = z.infer<typeof cexPriceTickerInfoSchema>
+
+const cexPricesSchema = z.unknown().array()
+.transform((tickers) => {
+  const data = [...tickers];
+  data.shift();
+  const parsedData = cexPriceTickerInfoSchema.array().parse(data);
+  return parsedData.reduce<
+    Partial<
+      Record<
+        string,
+        CEXPriceTickerInfo
+      >
+    >
+  >((prev, pairData) => ({
+    ...prev,
+    [pairData.pairName]: pairData,
+  }), {});
+});
+
+export default cexPricesSchema;
--- a/src/services/PriceFeed/ws/schemas/index.ts
+++ b/src/services/PriceFeed/ws/schemas/index.ts
@@ -2,3 +2,4 @@ export { default as tickerInfoSchema } from './tickerInfoSchema.js';
 export { default as candleSchema } from './candleSchema.js';
 export { default as priceSchema } from './priceSchema.js';
 export { default as allTickersSchema } from './allTickersSchema.js';
+export { default as cexPricesSchema } from './cexPricesSchema.js';
--- a/src/services/ReferralSystem/index.ts
+++ b/src/services/ReferralSystem/index.ts
@@ -13,6 +13,7 @@ import {
  aggregatedHistorySchema,
  inviteCodeLinkSchema,
  contractsAddressesSchema,
+  allTimeLeadersSchema,
 } from './schemas/index.js';
 import type { SupportedChainId } from '../../types.js';

@@ -71,6 +72,7 @@ class ReferralSystem {
    this.claimRewards = this.claimRewards.bind(this);
    this.getLeaderboard = this.getLeaderboard.bind(this);
    this.getLeaderboardSingleChain = this.getLeaderboardSingleChain.bind(this);
+    this.getAllTimeLeaders = this.getAllTimeLeaders.bind(this);
    this.getContractsAddresses = this.getContractsAddresses.bind(this);
    this.getClaimInfo = this.getClaimInfo.bind(this);
    this.getAggregatedHistory = this.getAggregatedHistory.bind(this);
@@ -231,6 +233,19 @@ class ReferralSystem {
      errorSchema
    );

+  getAllTimeLeaders = (refererAddress: string | undefined) =>
+    fetchWithValidation(
+      `${this.apiUrl}/referer/ve/leaderboard-lifetime`,
+      allTimeLeadersSchema,
+      {
+        headers:
+          refererAddress !== undefined
+            ? { 'referer-address': refererAddress }
+            : {},
+      },
+      errorSchema
+    );
+
  getContractsAddresses = () =>
    fetchWithValidation(
      `${this.apiUrl}/referer/view/contracts`,
--- a/src/services/ReferralSystem/schemas/allTimeLeadersSchema.ts
+++ b/src/services/ReferralSystem/schemas/allTimeLeadersSchema.ts
@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+const allTimeLeadersSchema = z.array(z.object({
+  wallet: z.string(),
+  total_earnings_fmt: z.number(),
+  referrals_count_fmt: z.number(),
+  total_trades_fmt: z.number(),
+  weekly_earnings_fmt: z.number(),
+}));
+
+export default allTimeLeadersSchema;
--- a/src/services/ReferralSystem/schemas/index.ts
+++ b/src/services/ReferralSystem/schemas/index.ts
@@ -10,3 +10,4 @@ export { default as claimInfoSchema } from './claimInfoSchema.js';
 export { default as aggregatedHistorySchema } from './aggregatedHistorySchema.js';
 export { default as contractsAddressesSchema } from './contractsAddressesSchema.js';
 export { default as inviteCodeLinkSchema } from './inviteCodeLinkSchema.js';
+export { default as allTimeLeadersSchema } from './allTimeLeadersSchema.js';
--- a/src/services/ReferralSystem/schemas/linkSchema.ts
+++ b/src/services/ReferralSystem/schemas/linkSchema.ts
@@ -1,8 +1,8 @@
 import { z } from 'zod';

 const linkSchema = z.object({
+  status: z.string(),
  referer: z.string(),
-  ref_link: z.string(),
 });

 export default linkSchema;
--- a/src/types.ts
+++ b/src/types.ts
@@ -109,6 +109,10 @@ export enum SupportedChainId {
  POLYGON = '137',
  OKC = '66',
  OPBNB = '204',
+  INEVM = '2525',
+  LINEA = '59144',
+  AVAX = '43114',
+  BASE = '8453',

  POLYGON_TESTNET = '80001',
  FANTOM_TESTNET = '4002',
@@ -229,6 +233,7 @@ export type SwapInfoBase = {
    marketAmountIn: number | undefined
    difference: string | undefined
  } | undefined
+  autoSlippage: number | undefined
 }

 export type SwapInfoByAmountIn = SwapInfoBase & {
@@ -285,12 +290,12 @@ export type VerboseUnitConfig = {
      // http://10.23.5.11:3003/,
      // https://price-feed:3003/
    }
-    indexer: {
+    indexer?: {
      api: string
      // For example:
      // http://localhost:3004/,
      // http://
-    }
+    } | undefined
  }
  basicAuth?: BasicAuthCredentials
 }
@@ -300,7 +305,7 @@ export type KnownEnv = typeof knownEnvs[number];
 export type Json = string | number | boolean | null | Json[] | { [key: string]: Json };

 export type EnvConfig = {
-  analyticsAPI: string
+  analyticsAPI: string | undefined
  referralAPI: string
  networks: Partial<
        Record<
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -11,6 +11,7 @@
    "lib"
  ],
  "compilerOptions": {
+    "moduleResolution": "node",
    "target": "esnext",
    "module": "ESNext",
    "esModuleInterop": true,