@lifi/data-types 4.10.5 → 5.0.0-beta.2

package/src/chains/supportedChains.svm.int.spec.ts

@@ -0,0 +1,60 @@
+import { Connection, PublicKey } from '@solana/web3.js'
+import { describe, expect, test } from 'vitest'
+import { supportedSolanaChains } from './supportedChains.svm'
+
+const TokenProgramAddress = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+const WalletAddress = '6AUWsSCRFSCbrHKH9s84wfzJXtD6mNzAHs11x6pGEcmJ'
+
+describe.concurrent('SVM chains RPC check', () => {
+  const rpcUrls = supportedSolanaChains.flatMap((chain) =>
+    chain.metamask.rpcUrls.map((rpcUrl) => ({
+      rpcUrl: rpcUrl,
+      chainId: chain.id,
+      chainName: chain.name,
+    }))
+  )
+
+  test.for(rpcUrls)(
+    `should successfully get chain ID from $chainName - $chainId RPC: $rpcUrl`,
+    { timeout: 10_000 },
+    async ({ rpcUrl }) => {
+      const connection = new Connection(rpcUrl)
+      const accountPublicKey = new PublicKey(WalletAddress)
+      const tokenProgramPublicKey = new PublicKey(TokenProgramAddress)
+      const [blockHeight, slot, balance, tokenAccountsByOwner] =
+        await Promise.allSettled([
+          connection.getBlockHeight(),
+          connection.getSlot(),
+          connection.getBalance(accountPublicKey),
+          connection.getParsedTokenAccountsByOwner(accountPublicKey, {
+            programId: tokenProgramPublicKey,
+          }),
+        ])
+      expect(blockHeight.status).toBe('fulfilled')
+      expect(slot.status).toBe('fulfilled')
+      expect(balance.status).toBe('fulfilled')
+      expect(tokenAccountsByOwner.status).toBe('fulfilled')
+    }
+  )
+})
+
+describe.concurrent('SVM chains block explorer check', () => {
+  const blockExplorerUrls = supportedSolanaChains.flatMap((chain) =>
+    chain.metamask.blockExplorerUrls.map((blockExplorerUrl) => ({
+      blockExplorerUrl: blockExplorerUrl,
+      chainId: chain.id,
+      chainName: chain.name,
+    }))
+  )
+
+  test.for(blockExplorerUrls)(
+    `block explorer should be alive $chainName - $chainId - $blockExplorerUrl`,
+    { timeout: 10_000 },
+    async ({ blockExplorerUrl }) => {
+      const response = await fetch(blockExplorerUrl)
+      expect(response.url).toBe(blockExplorerUrl)
+      expect(response.ok).toBe(true)
+      expect(response.status).toBe(200)
+    }
+  )
+})

package/src/chains/supportedChains.svm.ts

@@ -0,0 +1,34 @@
+import type { SolanaChain } from '@lifi/types'
+import { ChainId, ChainKey, ChainType, CoinKey } from '@lifi/types'
+
+export const supportedSolanaChains: SolanaChain[] = [
+  {
+    key: ChainKey.SOL,
+    chainType: ChainType.SVM,
+    name: 'Solana',
+    coin: CoinKey.SOL,
+    id: ChainId.SOL,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/solana.svg',
+    faucetUrls: ['https://stakely.io/faucet/solana-sol'],
+    metamask: {
+      chainId: ChainId.SOL.toString(),
+      blockExplorerUrls: [
+        'https://explorer.solana.com/',
+        'https://solscan.io/',
+        'https://solana.fm/',
+      ],
+      chainName: 'Solana',
+      nativeCurrency: {
+        name: 'SOL',
+        symbol: 'SOL',
+        decimals: 9,
+      },
+      rpcUrls: [
+        'https://api.mainnet-beta.solana.com',
+        'https://solana-rpc.publicnode.com',
+      ],
+    },
+  },
+]

package/src/chains/supportedChains.ts

@@ -0,0 +1,29 @@
+import type { Chain, ChainKey } from '@lifi/types'
+import { supportedEVMChains } from './supportedChains.evm'
+import { supportedSolanaChains } from './supportedChains.svm'
+import { supportedUXTOChains } from './supportedChains.utxo'
+
+// This assignment is required to avoid breaking
+// changes with the new non EVM support types release
+// This will be removed in the future
+export const supportedChains = [
+  ...supportedEVMChains,
+  ...supportedSolanaChains,
+  ...supportedUXTOChains,
+]
+
+export const getChainByKey = (chainKey: ChainKey): Chain => {
+  const chain = supportedChains.find((c) => c.key === chainKey)
+  if (!chain) {
+    throw new Error('Invalid chainKey')
+  }
+  return chain
+}
+
+export const getChainById = (chainId: number): Chain => {
+  const chain = supportedChains.find((c) => c.id === chainId)
+  if (!chain) {
+    throw new Error('Invalid chainId')
+  }
+  return chain
+}

package/src/chains/supportedChains.unit.spec.ts

@@ -0,0 +1,114 @@
+import { ChainId, ChainKey, CoinKey } from '@lifi/types'
+import { describe, expect, it, test } from 'vitest'
+import {
+  findDefaultToken,
+  findTokenByChainIdAndAddress,
+  findWrappedGasOnChain,
+} from '../coins'
+import { getChainById, getChainByKey, supportedChains } from './supportedChains'
+import { supportedEVMChains } from './supportedChains.evm'
+import { prefixChainId } from './utils'
+
+test('getChainById', () => {
+  expect(getChainById(ChainId.ETH)).toBeDefined()
+})
+
+test('getChainByKey', () => {
+  expect(getChainByKey(ChainKey.ETH)).toBeDefined()
+})
+
+test('native token defined for all chains', () => {
+  // currently unused chains
+  const ignoredChainsForNativeToken = [
+    ChainId.FSN,
+    ChainId.EXP,
+    ChainId.TCH,
+    ChainId.UBQ,
+    ChainId.MET,
+    ChainId.DIO,
+    ChainId.TLO,
+    ChainId.SHI,
+    ChainId.GL1,
+    ChainId.RSK,
+    ChainId.TBW,
+  ]
+  const ignoredChainsForWrappedToken = [
+    ...ignoredChainsForNativeToken,
+    ChainId.BTC,
+    ChainId.BCH,
+    ChainId.LTC,
+    ChainId.DGE,
+  ]
+  for (const chain of supportedChains) {
+    if (ignoredChainsForNativeToken.includes(chain.id)) {
+      continue
+    }
+
+    try {
+      const gasToken = findDefaultToken(chain.coin, chain.id)
+      expect(gasToken).toBeDefined()
+    } catch (e) {
+      throw new Error(`Failed to load gas token for ${chain.name}(${chain.id})`)
+    }
+  }
+
+  for (const chain of supportedChains) {
+    if (ignoredChainsForWrappedToken.includes(chain.id)) {
+      continue
+    }
+
+    try {
+      const wrappedGasToken = findWrappedGasOnChain(chain.id)
+      expect(wrappedGasToken).toBeDefined()
+    } catch (e) {
+      throw new Error(
+        `Failed to load wrapped gas token for ${chain.name}(${chain.id})`
+      )
+    }
+  }
+})
+
+describe('findTokenByChainIdAndAddress', () => {
+  describe('token has no name override', () => {
+    it('returns a token with the coin name', () => {
+      expect(
+        findTokenByChainIdAndAddress(
+          ChainId.LNA,
+          '0xa219439258ca9da29e9cc4ce5596924745e12b93'
+        )!.name
+      ).toEqual(CoinKey.USDT)
+    })
+  })
+
+  describe('token has a name override', () => {
+    it('returns a token with the overrode name', () => {
+      expect(
+        findTokenByChainIdAndAddress(
+          ChainId.SOL,
+          '33fsBLA8djQm82RpHmE3SuVrPGtZBWNYExsEUeKX1HXX'
+        )!.name
+      ).toEqual('Binance USD (Wormhole from Ethereum)')
+    })
+  })
+})
+
+describe('validate chains', () => {
+  supportedEVMChains.forEach((chain) => {
+    it(`validate chain ${chain.name}`, () => {
+      // blockExplorerUrls
+      expect(chain.metamask.blockExplorerUrls.length).toBeGreaterThan(0)
+      chain.metamask.blockExplorerUrls.forEach((blockExplorerUrl) => {
+        expect(blockExplorerUrl.startsWith('https://')).toBeTruthy()
+        expect(blockExplorerUrl.endsWith('/')).toBeTruthy()
+      })
+
+      const chainId = prefixChainId(chain.id)
+
+      // chain ids match
+      expect(chainId).toEqual(chain.metamask.chainId)
+
+      // rpcs defined
+      expect(chain.metamask.rpcUrls.length).toBeGreaterThan(0)
+    })
+  })
+})

package/src/chains/supportedChains.utxo.int.spec.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from 'vitest'
+import { supportedUXTOChains } from './supportedChains.utxo'
+
+describe.concurrent('UTXO chains RPC check', () => {
+  const rpcUrls = supportedUXTOChains.flatMap((chain) =>
+    chain.metamask.rpcUrls.map((rpcUrl) => ({
+      rpcUrl: rpcUrl,
+      chainId: chain.id,
+      chainName: chain.name,
+    }))
+  )
+
+  test.for(rpcUrls)(
+    `should successfully get chain ID from $chainName - $chainId RPC: $rpcUrl`,
+    { timeout: 10_000 },
+    async ({ rpcUrl }) => {
+      const response = await fetch(rpcUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          jsonrpc: '1.0',
+          id: 'curltest',
+          method: 'getblockchaininfo',
+          params: [],
+        }),
+      })
+      const data = await response.json()
+      expect(response.ok).toBeTruthy()
+      expect(response.status).toBe(200)
+      expect(data.result.blocks).toBeGreaterThan(0)
+    }
+  )
+})
+
+describe.concurrent('UTXO chains block explorer check', () => {
+  const blockExplorerUrls = supportedUXTOChains.flatMap((chain) =>
+    chain.metamask.blockExplorerUrls.map((blockExplorerUrl) => ({
+      blockExplorerUrl: blockExplorerUrl,
+      chainId: chain.id,
+      chainName: chain.name,
+    }))
+  )
+
+  test.for(blockExplorerUrls)(
+    `block explorer should be alive $chainName - $chainId - $blockExplorerUrl`,
+    { timeout: 10_000 },
+    async ({ blockExplorerUrl }) => {
+      const response = await fetch(blockExplorerUrl)
+      expect(response.url).toBe(blockExplorerUrl)
+      expect(response.ok).toBe(true)
+      expect(response.status).toBe(200)
+    }
+  )
+})

package/src/chains/supportedChains.utxo.ts

@@ -0,0 +1,93 @@
+import type { UTXOChain } from '@lifi/types'
+import { ChainId, ChainKey, ChainType, CoinKey } from '@lifi/types'
+
+export const supportedUXTOChains: UTXOChain[] = [
+  {
+    key: ChainKey.BTC,
+    chainType: ChainType.UTXO,
+    name: 'Bitcoin',
+    coin: CoinKey.BTC,
+    id: ChainId.BTC,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/bitcoin.svg',
+    faucetUrls: [],
+    metamask: {
+      chainId: ChainId.BTC.toString(),
+      blockExplorerUrls: ['https://blockchair.com/bitcoin/'],
+      chainName: 'Bitcoin',
+      nativeCurrency: {
+        name: 'BTC',
+        symbol: 'BTC',
+        decimals: 8,
+      },
+      rpcUrls: ['https://node-router.thorswap.net/bitcoin'],
+    },
+  },
+  {
+    key: ChainKey.BCH,
+    chainType: ChainType.UTXO,
+    name: 'Bitcoin Cash',
+    coin: CoinKey.BCH,
+    id: ChainId.BCH,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/bitcoincash.svg',
+    faucetUrls: [],
+    metamask: {
+      chainId: ChainId.BCH.toString(),
+      blockExplorerUrls: ['https://blockchair.com/bitcoin-cash/'],
+      chainName: 'Bitcoin Cash',
+      nativeCurrency: {
+        name: 'BCH',
+        symbol: 'BCH',
+        decimals: 8,
+      },
+      rpcUrls: ['https://node-router.thorswap.net/bitcoin-cash'],
+    },
+  },
+  {
+    key: ChainKey.LTC,
+    chainType: ChainType.UTXO,
+    name: 'Litecoin',
+    coin: CoinKey.LTC,
+    id: ChainId.LTC,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/litecoin.svg',
+    faucetUrls: [],
+    metamask: {
+      chainId: ChainId.LTC.toString(),
+      blockExplorerUrls: ['https://blockchair.com/litecoin/'],
+      chainName: 'Litecoin',
+      nativeCurrency: {
+        name: 'LTC',
+        symbol: 'LTC',
+        decimals: 8,
+      },
+      rpcUrls: ['https://node-router.thorswap.net/litecoin'],
+    },
+  },
+  {
+    key: ChainKey.DGE,
+    chainType: ChainType.UTXO,
+    name: 'Dogecoin',
+    coin: CoinKey.DOGE,
+    id: ChainId.DGE,
+    mainnet: true,
+    logoURI:
+      'https://raw.githubusercontent.com/lifinance/types/main/src/assets/icons/chains/dogecoin.svg',
+    faucetUrls: [],
+    metamask: {
+      chainId: ChainId.DGE.toString(),
+      blockExplorerUrls: ['https://blockchair.com/dogecoin/'],
+      chainName: 'Dogecoin',
+      nativeCurrency: {
+        name: 'DODGE',
+        symbol: 'DOGE',
+        decimals: 8,
+      },
+      rpcUrls: ['https://node-router.thorswap.net/dogecoin'],
+    },
+  },
+]

package/src/chains/utils.ts

@@ -0,0 +1,3 @@
+export const prefixChainId = (chainId: number): string => {
+  return '0x' + chainId.toString(16)
+}

package/src/coins/coins.int.spec.ts

@@ -0,0 +1,35 @@
+import type { StaticToken } from '@lifi/types'
+import { describe, expect, test } from 'vitest'
+import { defaultCoins, wrappedTokens } from './coins'
+
+describe.concurrent('Coin logo test', { timeout: 30_000 }, () => {
+  const allImages: string[] = []
+
+  // default coins
+  allImages.push(
+    ...defaultCoins
+      .map((coin) => {
+        const baseURL = coin.logoURI
+        const tokenSpecificURLs = Object.values(coin.chains).flatMap(
+          ({ logoURI }) => (logoURI ? [logoURI] : [])
+        )
+        return [baseURL, ...tokenSpecificURLs]
+      })
+      .flat()
+  )
+
+  // wrapped tokens
+  allImages.push(
+    ...Object.values(wrappedTokens).map((token: StaticToken) => token.logoURI!)
+  )
+
+  test.each([...new Set(allImages)])(
+    'check that logoURI %s is valid',
+    async (image) => {
+      expect(image.startsWith('https://')).toBeTruthy()
+      const response = await fetch(image)
+      expect(response.status).toEqual(200)
+    },
+    2000
+  )
+})