blockchain-javascript/scripts/lib/lp-lib.js

const logger = require("../../utils/logger");
const debug = require('./../../utils/debug')
const BaseModel = require("../../model/base-model");
const V2ToolAbi = require('../../abi/UNIV2_TOOLS_ABI.json')
const V3ToolAbi = require('../../abi/UNIV3_TOOLS_ABI.json')
const FactoryLib = require("./factory-lib");
const TokenLib = require("./token-lib");

// basetoken
const baseTokenMap = require('../../config/base-token.json')
const baseTokenAddressList = Object.keys(baseTokenMap)
const ethTokenAddressList = baseTokenAddressList.filter(baseTokenAddress => {
  return baseTokenMap[baseTokenAddress].name.indexOf('ETH') !== -1
})

module.exports = class LpLib {
  static LEVEL = {
    NOT: 'not',
    DISCARD: 'discard',
    INIT: 'init',
    NORMAL: 'normal',
    TOP: 'top'
  }

  static VERSION = {
    UNIV2: 'univ2',
    UNIV3: 'univ3'
  }

  constructor(web3, chain) {
    this.web3 = web3
    this.chain = chain

    this.factoryLib = new FactoryLib(this.web3, this.chain)
    this.tokenLib = new TokenLib(this.web3, this.chain)
    
    this.v2LpModel = new BaseModel(this.chain.id, BaseModel.MODULES.V2_LP)
    this.v3LpModel = new BaseModel(this.chain.id, BaseModel.MODULES.V3_LP)

    // 初始化V2工具箱
    this.v2Tool = new this.web3.eth.Contract(V2ToolAbi, this.chain.v2ToolAddress)
    // 初始化V3工具箱
    this.v3Tool = new this.web3.eth.Contract(V3ToolAbi, this.chain.v3ToolAddress)
  }

  async saveLp(factory, lp) {
    let saveRst = undefined
    if (factory.version === 'univ2') {
      saveRst = await this.v2LpModel.appendOrUpdate(lp)
    } else if (factory.version === 'univ3') {
      saveRst = await this.v3LpModel.appendOrUpdate(lp)
    } else {
      throw Error(`Unknown factory version: ${factory.version}, hash is: ${factory.hash}.`)
    }

    if (!saveRst.state) throw Error(saveRst.msg)
  }

  getEffectiveLp(factory, position, lp) {
    // lp对象标准化
    lp.symbol0 = this.tokenLib.getEffectiveSymbol(lp.symbol0)
    lp.symbol1 = this.tokenLib.getEffectiveSymbol(lp.symbol1)
    lp.name = `${factory.name}_${lp.symbol0}_${lp.symbol1}`
    lp.router = factory.router
    lp.factory = factory.hash
    lp.fee = factory.fee
    lp.positionId = position
    lp.r0Str = String(lp.r0)
    lp.r1Str = String(lp.r1)
    lp.level = LpLib.LEVEL.INIT

    // lp各种地址最小化
    lp.hash = lp.hash.toLowerCase()
    lp.token0 = lp.token0.toLowerCase()
    lp.token1 = lp.token1.toLowerCase()

    // 字符化数字
    lp.decimals0 = parseInt(lp.decimals0)
    lp.decimals1 = parseInt(lp.decimals1)

    // 链信息
    lp.chainId = this.chain.id

    return lp
  }

  async getV2Pool(factory, position) {
    const info = await this.v2Tool.methods.getPairIdInfo(factory.hash, position).call()

    const lp = {
      hash: info['0'],
      decimals0: info['3'],
      decimals1: info['7'],
      r0: info['4'],
      r1: info['8'],
      symbol0: info['2'],
      symbol1: info['6'],
      token0: info['1'],
      token1: info['5']
    }

    return this.getEffectiveLp(factory, position, lp)
  }

  async getV3Pool(factory, position) {
    const positionManager = this.factoryLib.getPositionManager(factory.positionManager)
    const positionInfo = await positionManager.methods.positions(position).call()
    const info = await this.v3Tool.methods.getMoreInfo(positionInfo.token0, positionInfo.token1, positionInfo.fee).call()

    const lp = {
      hash: info.lp,
      decimals0: info.decimals0,
      decimals1: info.decimals1,
      factory: factory.hash,
      feei: positionInfo.fee,
      id: position,
      r0: info.r0,
      r1: info.r1,
      router: factory.router,
      token0: positionInfo.token0,
      token1: positionInfo.token1,
      symbol0: info.symbol0,
      symbol1: info.symbol1
    }

    return this.getEffectiveLp(factory, position, lp)
  }

  async getLpByPosition(factory, position) {
    if (factory.version === LpLib.VERSION.UNIV2) {
      return await this.getV2Pool(factory, position)
    } else if (factory.version === LpLib.VERSION.UNIV3) {
      return await this.getV3Pool(factory, position)
    } else {
      throw Error(`Unknown factory version: ${factory.version}, hash is: ${factory.hash}.`)
    }
  }

  getHashListByLpList(lpList) {
    const hashList = []

    for (const lp of lpList) {
      hashList.push(lp.hash)
    }

    return hashList
  }

  async putR0AndR1(lpList) {
    // 生成所有lp的hash
    const hashList = this.getHashListByLpList(lpList)
    // 以段为单位，更新r0、r1。每一段有SIZE个元素
    const SIZE = 600
    for (let from = 0; from < hashList.length; from += SIZE) {
      logger.debug(`${from}, ${hashList.length}`)

      // 拉取该段所有r0,r1
      const lpR0R1Info = await this.v2Tool.methods.getPairSBalance(hashList.slice(from, from + SIZE)).call()
      const r0s = lpR0R1Info.amounts0
      const r1s = lpR0R1Info.amounts1

      // 更新到lp中
      for (let index = from; index < from + SIZE && index < hashList.length; index++) {
        const lp = lpList[index]
        const relativeIndex = index % SIZE

        lp.appendTimestamp = undefined
        lp.updateTimestamp = undefined

        lp.r0Str = r0s[relativeIndex]
        lp.r0 = parseInt(lp.r0Str)

        lp.r1Str = r1s[relativeIndex]
        lp.r1 = parseInt(lp.r1Str)

        if (lp.r0 === 404 && lp.r1 === 404) {
          lp.r0Str = '0'
          lp.r0 = 0

          lp.r1Str = '0'
          lp.r1 = 0

          lp.level = LpLib.LEVEL.NOT
        }
      }
    }
  }

  putSwapPrice(lpList) {
    for (const lp of lpList) {
      const r0RealAmount = lp.r0 / Math.pow(10, parseInt(lp.decimals0))
      const r1RealAmount = lp.r1 / Math.pow(10, parseInt(lp.decimals1))

      // 计算0换1的价格和1换0的价格
      lp.token0ToToken1Price = r1RealAmount / r0RealAmount // 一个token0 = token0ToToken1Price个token1
      lp.token1ToToken0Price = r0RealAmount / r1RealAmount // 一个token1 = token1ToToken0Price个token0
    }
  }

  getBaseTokenCovertEthValue(maxValueLpMap) {
    const baseTokenConvertEthValueMap = {}

    for (const baseTokenAddress of baseTokenAddressList) {
      const isEthToken = ethTokenAddressList.indexOf(baseTokenAddress) !== -1
      // eth兑换eth价格当然是1：1了
      if (isEthToken) {
        baseTokenConvertEthValueMap[baseTokenAddress] = 1
      } else {
        // 在ETH token中查找适合兑换的
        for (const ethTokenAddress of ethTokenAddressList) {
          const maxValueLp = maxValueLpMap[this.getKey(baseTokenAddress, ethTokenAddress)]
          if (!maxValueLp) continue

          const token0 = maxValueLp.token0
          const token1 = maxValueLp.token1

          if (baseTokenAddress === token0) {
            baseTokenConvertEthValueMap[baseTokenAddress] = maxValueLp.token0ToToken1Price
          } else if (baseTokenAddress === token1) {
            baseTokenConvertEthValueMap[baseTokenAddress] = maxValueLp.token1ToToken0Price
          }
        }
      }
    }

    return baseTokenConvertEthValueMap
  }

  getKey(hash0, hash1) {
    if (hash0 < hash1) {
      return hash0 + hash1
    }
    else {
      return hash1 + hash0
    }
  }

  getLpEthValue(lp, baseTokenConvertEthValueMap, maxValueLpMap) {
    const r0 = lp.r0
    const r1 = lp.r1
    const token0 = lp.token0
    const token1 = lp.token1
    const decimals0 = lp.decimals0
    const decimals1 = lp.decimals1

    if (r0 === 0 && r1 === 0) {
      return 0
    }

    // 1.两token之一能直接与ethw或wethw做直接池子的
    if (ethTokenAddressList.indexOf(token0) !== -1 || ethTokenAddressList.indexOf(token1) !== -1) {
      if (ethTokenAddressList.indexOf(token0) !== -1) {
        const ethToken = baseTokenMap[token0]
        return 2 * r0 / (10 ** ethToken.decimals)
      } else if (ethTokenAddressList.indexOf(token1) !== -1) {
        const ethToken = baseTokenMap[token1]
        return 2 * r1 / (10 ** ethToken.decimals)
      }
    }

    // 2.两token之一能直接与baseToken做池子的 带入maxValueLpMap计算
    // 转换数量: token到base token
    function valueConvertTokenToBaseToken(lpLib, reserve, tokenHash, decimals, baseTokenAddress) {
      const tokenAndBaseKey = lpLib.getKey(tokenHash, baseTokenAddress)
      const tokenAndBaseTokenLp = maxValueLpMap[tokenAndBaseKey]
      const realAmount = reserve / Math.pow(10, decimals)

      if (tokenAndBaseTokenLp) {
        if (tokenAndBaseTokenLp.token0 === tokenHash) {
          const token0ToBaseTokenPrice = tokenAndBaseTokenLp.token0ToToken1Price

          return isNaN(token0ToBaseTokenPrice) ? 0 : token0ToBaseTokenPrice * realAmount
        } else {
          const token1ToBaseTokenPrice = tokenAndBaseTokenLp.token1ToToken0Price

          return isNaN(token1ToBaseTokenPrice) ? 0 : token1ToBaseTokenPrice * realAmount
        }
      }

      return 0
    }

    for (const baseTokenAddress of baseTokenAddressList) {
      const baseTokenToEthPrice = baseTokenConvertEthValueMap[baseTokenAddress]

      if (!baseTokenToEthPrice) continue

      // 如果token0跟baseToken能组成池子
      const r0ConvertToBaseTokenRealAmount = valueConvertTokenToBaseToken(this, r0, token0, decimals0, baseTokenAddress)
      if (r0ConvertToBaseTokenRealAmount !== 0) {
        return r0ConvertToBaseTokenRealAmount * baseTokenToEthPrice
      }

      // 如果token1跟baseToken能组成池子
      const r1ConvertToBaseTokenRealAmount = valueConvertTokenToBaseToken(this, r1, token1, decimals1, baseTokenAddress)
      if (r1ConvertToBaseTokenRealAmount !== 0) {
        return r1ConvertToBaseTokenRealAmount * baseTokenToEthPrice
      }
    }

    // 3.两token都不能与baseToken做池子的
    // 这种情况则视为lp类型池子
    return 0
  }

  getMaxValueLpMap(lpList) {
    const maxValueLpMap = {}

    for (const lp of lpList) {
      const key = lp.token0 + lp.token1
      const isExists = !!maxValueLpMap[key]
      const isMoreThanNowMax = isExists && maxValueLpMap[key].r0 < lp.r0

      if (!isExists) maxValueLpMap[key] = lp
      if (isMoreThanNowMax) maxValueLpMap[key] = lp
    }

    return maxValueLpMap
  }

  async getLpList(version) {
    let requestRst = undefined

    if (version === LpLib.VERSION.UNIV2) {
      requestRst = await this.v2LpModel.findByPaginate(1, debug.isDev() ? 200 : 10000000)
    } else if (version === LpLib.VERSION.UNIV3) {
      requestRst = await this.v3LpModel.findByPaginate(1, debug.isDev() ? 200 : 10000000)
    } else {
      throw Error(`Unknown lp version: ${version}.`)
    }

    if (requestRst.state) {
      return requestRst.data
    } else {
      logger.error(requestRst.msg)

      return []
    }
  }
}