@xyo-network/uniswap-crypto-market-plugin 2.42.0

package/src/Plugin.ts

@@ -0,0 +1,16 @@
+import { PayloadSetSchema } from '@xyo-network/payload'
+import { createPayloadSetPlugin, PayloadSetWitnessPlugin } from '@xyo-network/payloadset-plugin'
+import { XyoUniswapCryptoMarketSchema } from '@xyo-network/uniswap-crypto-market-payload-plugin'
+
+import { XyoUniswapCryptoMarketWitness, XyoUniswapCryptoMarketWitnessParams } from './Witness'
+
+export const XyoUniswapCryptoMarketPlugin = () =>
+  createPayloadSetPlugin<PayloadSetWitnessPlugin<XyoUniswapCryptoMarketWitnessParams>>(
+    { required: { [XyoUniswapCryptoMarketSchema]: 1 }, schema: PayloadSetSchema },
+    {
+      witness: async (params) => {
+        const result = await XyoUniswapCryptoMarketWitness.create(params)
+        return result
+      },
+    },
+  )

package/src/Witness.spec.ts

@@ -0,0 +1,56 @@
+// Mock Date.now
+const now = new Date()
+jest.useFakeTimers().setSystemTime(now)
+
+import { InfuraProvider } from '@ethersproject/providers'
+import { PayloadWrapper } from '@xyo-network/payload'
+import { XyoUniswapCryptoMarketPayload, XyoUniswapCryptoMarketWitnessConfigSchema } from '@xyo-network/uniswap-crypto-market-payload-plugin'
+
+import { UniswapPoolContracts } from './lib'
+import { XyoUniswapCryptoMarketWitness } from './Witness'
+
+describe('XyoUniswapCryptoMarketWitness', () => {
+  test('observe', async () => {
+    const provider = new InfuraProvider('homestead', { projectId: process.env.INFURA_PROJECT_ID, projectSecret: process.env.INFURA_PROJECT_SECRET })
+    const witness = await XyoUniswapCryptoMarketWitness.create({
+      config: {
+        pools: UniswapPoolContracts,
+        schema: XyoUniswapCryptoMarketWitnessConfigSchema,
+      },
+      provider,
+    })
+    const [observation] = (await witness.observe()) as XyoUniswapCryptoMarketPayload[]
+    expect(observation.pairs.length).toBeGreaterThan(1)
+    expect(observation.timestamp).toBe(+now)
+
+    const answerWrapper = new PayloadWrapper(observation)
+    expect(answerWrapper.valid).toBe(true)
+  })
+  test('observe [no config]', async () => {
+    const provider = new InfuraProvider('homestead', { projectId: process.env.INFURA_PROJECT_ID, projectSecret: process.env.INFURA_PROJECT_SECRET })
+    const witness = await XyoUniswapCryptoMarketWitness.create({
+      config: {
+        pools: UniswapPoolContracts,
+        schema: XyoUniswapCryptoMarketWitnessConfigSchema,
+      },
+      provider,
+    })
+    const [observation] = (await witness.observe()) as XyoUniswapCryptoMarketPayload[]
+    expect(observation.pairs.length).toBeGreaterThan(1)
+    expect(observation.timestamp).toBe(+now)
+
+    const answerWrapper = new PayloadWrapper(observation)
+    expect(answerWrapper.valid).toBe(true)
+  })
+  test('observe [no params]', async () => {
+    const didThrow = async () => {
+      try {
+        await XyoUniswapCryptoMarketWitness.create()
+        return false
+      } catch {
+        return true
+      }
+    }
+    expect(await didThrow()).toBe(true)
+  })
+})

package/src/Witness.ts

@@ -0,0 +1,51 @@
+import { Provider } from '@ethersproject/providers'
+import { assertEx } from '@xylabs/assert'
+import { XyoModuleParams } from '@xyo-network/module'
+import { XyoPayload } from '@xyo-network/payload'
+import {
+  XyoUniswapCryptoMarketPayload,
+  XyoUniswapCryptoMarketSchema,
+  XyoUniswapCryptoMarketWitnessConfigSchema,
+} from '@xyo-network/uniswap-crypto-market-payload-plugin'
+import { AbstractWitness } from '@xyo-network/witness'
+
+import { XyoUniswapCryptoMarketWitnessConfig } from './Config'
+import { createUniswapPoolContracts, EthersUniSwap3Pair, pricesFromUniswap3, UniswapPoolContracts } from './lib'
+
+export interface XyoUniswapCryptoMarketWitnessParams extends XyoModuleParams<XyoUniswapCryptoMarketWitnessConfig> {
+  provider: Provider
+}
+
+export class XyoUniswapCryptoMarketWitness extends AbstractWitness<XyoUniswapCryptoMarketWitnessConfig> {
+  static override configSchema = XyoUniswapCryptoMarketWitnessConfigSchema
+
+  protected pairs?: EthersUniSwap3Pair[]
+  protected provider?: Provider
+  protected constructor(params: XyoUniswapCryptoMarketWitnessParams) {
+    super(params)
+    this.provider = params?.provider
+  }
+
+  static override async create(params?: XyoUniswapCryptoMarketWitnessParams): Promise<XyoUniswapCryptoMarketWitness> {
+    return (await super.create(params)) as XyoUniswapCryptoMarketWitness
+  }
+
+  override async observe(): Promise<XyoPayload[]> {
+    this.started('throw')
+    const pairs = await pricesFromUniswap3(assertEx(this.pairs))
+    const timestamp = Date.now()
+
+    const payload: XyoUniswapCryptoMarketPayload = {
+      pairs,
+      schema: XyoUniswapCryptoMarketSchema,
+      timestamp,
+    }
+
+    return super.observe([payload])
+  }
+
+  override async start() {
+    this.pairs = createUniswapPoolContracts(assertEx(this.provider, 'Provider Required'), this.config?.pools ?? UniswapPoolContracts)
+    return await super.start()
+  }
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { XyoUniswapCryptoMarketPlugin } from './Plugin'
+
+export * from './Config'
+export * from './lib'
+export * from './Witness'
+
+export { XyoUniswapCryptoMarketPlugin }
+
+// eslint-disable-next-line import/no-default-export
+export default XyoUniswapCryptoMarketPlugin

package/src/lib/Ethers/UniSwap3Pair.ts

@@ -0,0 +1,109 @@
+import { Provider } from '@ethersproject/providers'
+import { ChainId } from '@uniswap/sdk'
+import { Token } from '@uniswap/sdk-core'
+import { Pool } from '@uniswap/v3-sdk'
+import { assertEx } from '@xylabs/assert'
+import { delay } from '@xylabs/delay'
+import { IERC20Metadata, IERC20Metadata__factory } from '@xyo-network/typechain'
+import { IUniswapV3Pool, IUniswapV3Pool__factory } from '@xyo-network/uniswap-typechain'
+
+import { logErrors, logErrorsAsync } from '../logErrors'
+import { EthersUniswap3PoolSlot0Wrapper } from './Uniswap3PoolSlot0Wrapper'
+
+//null is used as 'in-progress'
+const waitNotNull = async (closure: () => unknown) => {
+  while (closure() === null) {
+    await delay(10)
+  }
+}
+
+export class EthersUniSwap3Pair {
+  protected address: string
+  protected provider: Provider
+
+  private _pool?: Pool | null
+  private _poolContract?: IUniswapV3Pool
+  private _slot0?: EthersUniswap3PoolSlot0Wrapper | null
+  private _tokenContracts: (IERC20Metadata | null | undefined)[] = [undefined, undefined]
+  private _tokens: (Token | null | undefined)[] = [undefined, undefined]
+
+  constructor(address: string, provider: Provider) {
+    this.address = address
+    this.provider = provider
+  }
+
+  public async pool(): Promise<Pool> {
+    return await logErrorsAsync(async () => {
+      await waitNotNull(() => this._pool)
+      this._pool = this._pool || null
+      const slot0 = await this.slot0()
+      this._pool =
+        this._pool ??
+        new Pool(
+          await this.token(0),
+          await this.token(1),
+          slot0.feeProtocol,
+          slot0.sqrtPriceX96.toHexString(),
+          (await this.poolContract().liquidity()).toHexString(),
+          slot0.tick,
+        )
+      return assertEx(this._pool)
+    })
+  }
+
+  public poolContract(): IUniswapV3Pool {
+    return logErrors(() => {
+      this._poolContract = this._poolContract ?? IUniswapV3Pool__factory.connect(this.address, this.provider)
+      return assertEx(this._poolContract)
+    })
+  }
+
+  public async price() {
+    return await logErrorsAsync(async () => {
+      const tokenIndexes: (0 | 1)[] = [0, 1]
+      const pool = await this.pool()
+      const tokens = await Promise.all(tokenIndexes.map((value) => this.token(value)))
+      const tokenContracts = await Promise.all(tokenIndexes.map((value) => this.tokenContract(value)))
+      const tokenPrices = tokens.map((token) => parseFloat(pool.priceOf(token).toSignificant()))
+      const tokenSymbols = tokens.map((token, index) => assertEx(token.symbol, `Token[${index}] Missing Symbols`).toLowerCase())
+      const result = {
+        tokens: tokenIndexes.map((value) => {
+          return { address: tokenContracts[value].address, symbol: tokenSymbols[value], value: tokenPrices[value] }
+        }),
+      }
+      return result
+    })
+  }
+
+  public async slot0(): Promise<EthersUniswap3PoolSlot0Wrapper> {
+    return await logErrorsAsync(async () => {
+      await waitNotNull(() => this._slot0)
+      this._slot0 = this._slot0 || null
+      this._slot0 = this._slot0 ?? new EthersUniswap3PoolSlot0Wrapper(await this.poolContract().slot0())
+      return assertEx(this._slot0)
+    })
+  }
+
+  public async token(index: 0 | 1): Promise<Token> {
+    return await logErrorsAsync(async () => {
+      await waitNotNull(() => this._tokens[index])
+      this._tokens[index] = this._tokens[index] || null
+      const tokenContract = await this.tokenContract(index)
+      this._tokens[index] =
+        this._tokens[index] ??
+        new Token(ChainId.MAINNET, tokenContract.address, await tokenContract.decimals(), await tokenContract.symbol(), await tokenContract.name())
+      return assertEx(this._tokens[index])
+    })
+  }
+
+  public async tokenContract(index: 0 | 1): Promise<IERC20Metadata> {
+    return await logErrorsAsync(async () => {
+      await waitNotNull(() => this._tokenContracts[index])
+      this._tokenContracts[index] = this._tokenContracts[index] || null
+      this._tokenContracts[index] =
+        this._tokenContracts[index] ??
+        IERC20Metadata__factory.connect(await (index === 0 ? this.poolContract().token0() : this.poolContract().token1()), this.provider)
+      return assertEx(this._tokenContracts[index])
+    })
+  }
+}

package/src/lib/Ethers/Uniswap3PoolSlot0Wrapper.ts

@@ -0,0 +1,36 @@
+import { EthersUniswapV3Slot0Fields } from './UniswapV3Slot0Fields'
+
+export class EthersUniswap3PoolSlot0Wrapper {
+  protected values: EthersUniswapV3Slot0Fields
+  constructor(values: EthersUniswapV3Slot0Fields) {
+    this.values = values
+  }
+
+  get feeProtocol() {
+    return this.values[5]
+  }
+
+  get observationCardinality() {
+    return this.values[3]
+  }
+
+  get observationCardinalityNext() {
+    return this.values[4]
+  }
+
+  get observationIndex() {
+    return this.values[2]
+  }
+
+  get sqrtPriceX96() {
+    return this.values[0]
+  }
+
+  get tick() {
+    return this.values[1]
+  }
+
+  get unlocked() {
+    return this.values[6]
+  }
+}

package/src/lib/Ethers/UniswapV3Slot0Fields.ts

@@ -0,0 +1,3 @@
+import { BigNumber } from '@ethersproject/bignumber'
+
+export type EthersUniswapV3Slot0Fields = [BigNumber, number, number, number, number, number, boolean]

package/src/lib/Ethers/createUniswapPoolContracts.ts

@@ -0,0 +1,10 @@
+import { Provider } from '@ethersproject/providers'
+
+import { logErrors } from '../logErrors'
+import { EthersUniSwap3Pair } from './UniSwap3Pair'
+
+export const createUniswapPoolContracts = (provider: Provider, contracts: string[]) => {
+  return logErrors(() => {
+    return contracts.map((contract) => new EthersUniSwap3Pair(contract, provider))
+  })
+}

package/src/lib/Ethers/index.ts

@@ -0,0 +1,4 @@
+export * from './createUniswapPoolContracts'
+export * from './UniSwap3Pair'
+export * from './Uniswap3PoolSlot0Wrapper'
+export * from './UniswapV3Slot0Fields'

package/src/lib/UniswapPoolContracts.ts

@@ -0,0 +1,15 @@
+export const UniswapPoolContracts = [
+  /*xyo/weth*/ '0xE331DE28cd81B768C19A366b0e4e4675c45eC2dA',
+  /*xyo/usdt*/ '0xd0AF1981f52146a6939385451dAeA0726e13a484',
+  /*xyo/dai*/ '0x9D7e5647CE3c7C2d835F2F5e82C8fDb36B0BB0fe',
+  /*wbtc/xyo*/ '0x0cF7494c9dE661467403aBeE8454b3BBf0179a84',
+  /*link/xyo*/ '0x4693456599a8a4975862A0E720C5de7E1D09A1e4',
+  /*wbtc/weth*/ '0xCBCdF9626bC03E24f779434178A73a0B4bad62eD',
+  /*dai/usdc*/ '0x5777d92f208679DB4b9778590Fa3CAB3aC9e2168',
+  /*usdc/weth*/ '0x8ad599c3A0ff1De082011EFDDc58f1908eb6e6D8',
+  /*usdc/weth*/ '0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640',
+  /*dai/usdc*/ '0x6c6Bc977E13Df9b0de53b251522280BB72383700',
+  /*frax/usdc*/ '0xc63B0708E2F7e69CB8A1df0e1389A98C35A76D52',
+  /*wbtc/usdc*/ '0x99ac8cA7087fA4A2A1FB6357269965A2014ABc35',
+  /*usdc/usdt*/ '0x3416cF6C708Da44DB2624D63ea0AAef7113527C6',
+]

package/src/lib/UniswapV3Slot0Fields.ts

@@ -0,0 +1,4 @@
+import { BigNumber } from '@xylabs/bignumber'
+
+//we do not export any EthersBigNumber fields
+export type UniswapV3Slot0Fields = [BigNumber, number, number, number, number, number, boolean]

package/src/lib/index.ts

@@ -0,0 +1,3 @@
+export * from './Ethers'
+export * from './pricesFromUniswap3'
+export * from './UniswapPoolContracts'

package/src/lib/logErrors.ts

@@ -0,0 +1,17 @@
+export const logErrors = <T>(func: () => T) => {
+  try {
+    return func()
+  } catch (ex) {
+    console.error(ex)
+    throw ex
+  }
+}
+
+export const logErrorsAsync = async <T>(func: () => Promise<T>) => {
+  try {
+    return await func()
+  } catch (ex) {
+    console.error(ex)
+    throw ex
+  }
+}

package/src/lib/pricesFromUniswap3.spec.ts

@@ -0,0 +1,13 @@
+import { InfuraProvider } from '@ethersproject/providers'
+
+import { createUniswapPoolContracts } from './Ethers'
+import { pricesFromUniswap3 } from './pricesFromUniswap3'
+import { UniswapPoolContracts } from './UniswapPoolContracts'
+
+describe('pricesFromUniswap3', () => {
+  test('observe', async () => {
+    const provider = new InfuraProvider('homestead', { projectId: process.env.INFURA_PROJECT_ID, projectSecret: process.env.INFURA_PROJECT_SECRET })
+    const pairs = await pricesFromUniswap3(createUniswapPoolContracts(provider, UniswapPoolContracts))
+    expect(pairs.length).toBeGreaterThan(1)
+  })
+})

package/src/lib/pricesFromUniswap3.ts

@@ -0,0 +1,19 @@
+import { XyoUniswapCryptoPair } from '@xyo-network/uniswap-crypto-market-payload-plugin'
+
+import { EthersUniSwap3Pair } from './Ethers'
+import { logErrorsAsync } from './logErrors'
+
+export const pricesFromUniswap3 = async (pools: EthersUniSwap3Pair[]): Promise<XyoUniswapCryptoPair[]> => {
+  return await logErrorsAsync(async () => {
+    const promiseResults = await Promise.allSettled(
+      pools.map(async (pool): Promise<XyoUniswapCryptoPair> => {
+        const result = await pool.price()
+        return result
+      }),
+    )
+
+    return (promiseResults.filter((result) => result.status === 'fulfilled') as PromiseFulfilledResult<XyoUniswapCryptoPair>[]).map(
+      (result) => result.value,
+    )
+  })
+}