@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/services/balance.ts

@@ -1,149 +0,0 @@
-import type {
-  GetWalletBalanceExtendedResponse,
-  RequestOptions,
-  Token,
-  TokenAmount,
-  TokenAmountExtended,
-  TokenExtended,
-  WalletTokenExtended,
-} from '@lifi/types'
-import { config } from '../config.js'
-import { ValidationError } from '../errors/errors.js'
-import { request } from '../request.js'
-import { isToken } from '../typeguards.js'
-
-/**
- * Returns the balances of a specific token a wallet holds across all aggregated chains.
- * @param walletAddress - A wallet address.
- * @param token - A Token object.
- * @returns An object containing the token and the amounts on different chains.
- * @throws {BaseError} Throws a ValidationError if parameters are invalid.
- */
-export const getTokenBalance = async (
-  walletAddress: string,
-  token: Token
-): Promise<TokenAmount | null> => {
-  const tokenAmounts = await getTokenBalances(walletAddress, [token])
-  return tokenAmounts.length ? tokenAmounts[0] : null
-}
-
-/**
- * Returns the balances for a list tokens a wallet holds across all aggregated chains.
- * @param walletAddress - A wallet address.
- * @param tokens - A list of Token (or TokenExtended) objects.
- * @returns A list of objects containing the tokens and the amounts on different chains.
- * @throws {BaseError} Throws a ValidationError if parameters are invalid.
- */
-export async function getTokenBalances(
-  walletAddress: string,
-  tokens: Token[]
-): Promise<TokenAmount[]>
-export async function getTokenBalances(
-  walletAddress: string,
-  tokens: TokenExtended[]
-): Promise<TokenAmountExtended[]> {
-  // split by chain
-  const tokensByChain = tokens.reduce(
-    (tokens, token) => {
-      if (!tokens[token.chainId]) {
-        tokens[token.chainId] = []
-      }
-      tokens[token.chainId].push(token)
-      return tokens
-    },
-    {} as { [chainId: number]: Token[] | TokenExtended[] }
-  )
-
-  const tokenAmountsByChain = await getTokenBalancesByChain(
-    walletAddress,
-    tokensByChain
-  )
-  return Object.values(tokenAmountsByChain).flat()
-}
-
-/**
- * This method queries the balances of tokens for a specific list of chains for a given wallet.
- * @param walletAddress - A wallet address.
- * @param tokensByChain - A list of token objects organized by chain ids.
- * @returns A list of objects containing the tokens and the amounts on different chains organized by the chosen chains.
- * @throws {BaseError} Throws a ValidationError if parameters are invalid.
- */
-export async function getTokenBalancesByChain(
-  walletAddress: string,
-  tokensByChain: { [chainId: number]: Token[] }
-): Promise<{ [chainId: number]: TokenAmount[] }>
-export async function getTokenBalancesByChain(
-  walletAddress: string,
-  tokensByChain: { [chainId: number]: TokenExtended[] }
-): Promise<{ [chainId: number]: TokenAmountExtended[] }> {
-  if (!walletAddress) {
-    throw new ValidationError('Missing walletAddress.')
-  }
-
-  const tokenList = Object.values(tokensByChain).flat()
-  const invalidTokens = tokenList.filter((token) => !isToken(token))
-  if (invalidTokens.length) {
-    throw new ValidationError('Invalid tokens passed.')
-  }
-
-  const provider = config
-    .get()
-    .providers.find((provider) => provider.isAddress(walletAddress))
-  if (!provider) {
-    throw new Error(`SDK Token Provider for ${walletAddress} is not found.`)
-  }
-
-  const tokenAmountsByChain: {
-    [chainId: number]: TokenAmount[] | TokenAmountExtended[]
-  } = {}
-  const tokenAmountsSettled = await Promise.allSettled(
-    Object.keys(tokensByChain).map(async (chainIdStr) => {
-      const chainId = Number.parseInt(chainIdStr, 10)
-      const chain = await config.getChainById(chainId)
-      if (provider.type === chain.chainType) {
-        const tokenAmounts = await provider.getBalance(
-          walletAddress,
-          tokensByChain[chainId]
-        )
-        tokenAmountsByChain[chainId] = tokenAmounts
-      } else {
-        // if the provider is not the same as the chain type,
-        // return the tokens as is
-        tokenAmountsByChain[chainId] = tokensByChain[chainId]
-      }
-    })
-  )
-  if (config.get().debug) {
-    for (const result of tokenAmountsSettled) {
-      if (result.status === 'rejected') {
-        console.warn("Couldn't fetch token balance.", result.reason)
-      }
-    }
-  }
-  return tokenAmountsByChain
-}
-
-/**
- * Returns the balances of tokens a wallet holds across EVM chains.
- * @param walletAddress - A wallet address.
- * @param options - Optional request options.
- * @returns An object containing the tokens and the amounts organized by chain ids.
- * @throws {BaseError} Throws a ValidationError if parameters are invalid.
- */
-export const getWalletBalances = async (
-  walletAddress: string,
-  options?: RequestOptions
-): Promise<Record<number, WalletTokenExtended[]>> => {
-  if (!walletAddress) {
-    throw new ValidationError('Missing walletAddress.')
-  }
-
-  const response = await request<GetWalletBalanceExtendedResponse>(
-    `${config.get().apiUrl}/wallets/${walletAddress}/balances?extended=true`,
-    {
-      signal: options?.signal,
-    }
-  )
-
-  return (response?.balances || {}) as Record<number, WalletTokenExtended[]>
-}

package/src/services/getNameServiceAddress.ts

@@ -1,30 +0,0 @@
-import type { ChainType } from '@lifi/types'
-import { config } from '../config.js'
-
-export const getNameServiceAddress = async (
-  name: string,
-  chainType?: ChainType
-): Promise<string | undefined> => {
-  try {
-    let providers = config.get().providers
-    if (chainType) {
-      providers = providers.filter((provider) => provider.type === chainType)
-    }
-    const resolvers = providers.map((provider) => provider.resolveAddress)
-    if (!resolvers.length) {
-      return
-    }
-    const result = await Promise.any(
-      resolvers.map(async (resolve) => {
-        const address = await resolve(name)
-        if (!address) {
-          throw undefined
-        }
-        return address
-      })
-    )
-    return result
-  } catch (_) {
-    return
-  }
-}

package/src/typeguards.ts

@@ -1,87 +0,0 @@
-import type {
-  Action,
-  Estimate,
-  LiFiStep,
-  RouteOptions,
-  RoutesRequest,
-  StaticToken,
-} from '@lifi/types'
-
-export const isRoutesRequest = (
-  routesRequest: RoutesRequest
-): routesRequest is RoutesRequest => {
-  const {
-    fromChainId,
-    fromAmount,
-    fromTokenAddress,
-    toChainId,
-    toTokenAddress,
-    options,
-  } = routesRequest
-
-  return (
-    typeof fromChainId === 'number' &&
-    typeof fromAmount === 'string' &&
-    fromAmount !== '' &&
-    typeof fromTokenAddress === 'string' &&
-    fromTokenAddress !== '' &&
-    typeof toChainId === 'number' &&
-    typeof toTokenAddress === 'string' &&
-    toTokenAddress !== '' &&
-    (!options || isRoutesOptions(options))
-  )
-}
-
-const isRoutesOptions = (
-  routeOptions: RouteOptions
-): routeOptions is RouteOptions =>
-  !routeOptions?.slippage || typeof routeOptions.slippage === 'number'
-
-export const isStep = (step: LiFiStep): step is LiFiStep => {
-  const { id, type, tool, action, estimate } = step
-
-  return (
-    typeof id === 'string' &&
-    ['swap', 'cross', 'lifi'].includes(type) &&
-    typeof tool === 'string' &&
-    isAction(action) &&
-    isEstimate(estimate)
-  )
-}
-
-const isAction = (action: Action): action is Action => {
-  const { fromChainId, fromAmount, fromToken, toChainId, toToken } = action
-
-  return (
-    typeof fromChainId === 'number' &&
-    typeof fromAmount === 'string' &&
-    fromAmount !== '' &&
-    isToken(fromToken) &&
-    typeof toChainId === 'number' &&
-    isToken(toToken)
-  )
-}
-
-const isEstimate = (estimate: Estimate): estimate is Estimate => {
-  const { fromAmount, toAmount, toAmountMin, approvalAddress } = estimate
-
-  return (
-    typeof fromAmount === 'string' &&
-    fromAmount !== '' &&
-    typeof toAmount === 'string' &&
-    toAmount !== '' &&
-    typeof toAmountMin === 'string' &&
-    toAmountMin !== '' &&
-    (typeof approvalAddress === 'string' || approvalAddress === null)
-  )
-}
-
-export const isToken = (token: StaticToken): token is StaticToken => {
-  const { address, decimals, chainId } = token
-
-  return (
-    typeof address === 'string' &&
-    typeof decimals === 'number' &&
-    typeof chainId === 'number'
-  )
-}

package/src/types/internal.ts

@@ -1,23 +0,0 @@
-import type { ChainId, ExtendedChain, RouteOptions } from '@lifi/types'
-import type { SDKProvider } from '../core/types.js'
-
-export interface SDKBaseConfig {
-  apiKey?: string
-  apiUrl: string
-  integrator: string
-  userId?: string
-  providers: SDKProvider[]
-  routeOptions?: RouteOptions
-  rpcUrls: RPCUrls
-  chains: ExtendedChain[]
-  disableVersionCheck?: boolean
-  widgetVersion?: string
-  preloadChains: boolean
-  debug: boolean
-}
-
-export interface SDKConfig extends Partial<Omit<SDKBaseConfig, 'integrator'>> {
-  integrator: string
-}
-
-export type RPCUrls = Partial<Record<ChainId, string[]>>

package/src/utils/base64ToUint8Array.ts

@@ -1,9 +0,0 @@
-export function base64ToUint8Array(base64String: string) {
-  const binaryString = atob(base64String)
-  const len = binaryString.length
-  const bytes = new Uint8Array(len)
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i)
-  }
-  return bytes
-}

package/src/utils/invariant.ts

@@ -1,51 +0,0 @@
-// https://github.com/alexreardon/tiny-invariant
-
-const isProduction: boolean = process.env.NODE_ENV === 'production'
-const prefix: string = 'Invariant failed'
-
-/**
- * `invariant` is used to [assert](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions) that the `condition` is [truthy](https://github.com/getify/You-Dont-Know-JS/blob/bdbe570600d4e1107d0b131787903ca1c9ec8140/up%20%26%20going/ch2.md#truthy--falsy).
- *
- * 💥 `invariant` will `throw` an `Error` if the `condition` is [falsey](https://github.com/getify/You-Dont-Know-JS/blob/bdbe570600d4e1107d0b131787903ca1c9ec8140/up%20%26%20going/ch2.md#truthy--falsy)
- *
- * 🤏 `message`s are not displayed in production environments to help keep bundles small
- *
- * @example
- *
- * ```ts
- * const value: Person | null = { name: 'Alex' };
- * invariant(value, 'Expected value to be a person');
- * // type of `value`` has been narrowed to `Person`
- * ```
- */
-export function invariant(
-  condition: any,
-  // Not providing an inline default argument for message as the result is smaller
-  /**
-   * Can provide a string, or a function that returns a string for cases where
-   * the message takes a fair amount of effort to compute
-   */
-  message?: string | (() => string)
-): asserts condition {
-  if (condition) {
-    return
-  }
-  // Condition not passed
-
-  // In production we strip the message but still throw
-  if (isProduction) {
-    throw new Error(prefix)
-  }
-
-  // When not in production we allow the message to pass through
-  // *This block will be removed in production builds*
-
-  const provided: string | undefined =
-    typeof message === 'function' ? message() : message
-
-  // Options:
-  // 1. message provided: `${prefix}: ${provided}`
-  // 2. message not provided: prefix
-  const value: string = provided ? `${prefix}: ${provided}` : prefix
-  throw new Error(value)
-}

package/src/utils/isZeroAddress.ts

@@ -1,8 +0,0 @@
-import { AddressZero, AlternativeAddressZero } from '../constants.js'
-
-export const isZeroAddress = (address: string): boolean => {
-  if (address === AddressZero || address === AlternativeAddressZero) {
-    return true
-  }
-  return false
-}

package/src/utils/median.ts

@@ -1,11 +0,0 @@
-export const median = (arr: bigint[]): bigint | undefined => {
-  if (!arr.length) {
-    return
-  }
-  const s = [...arr].sort((a, b) => (a > b ? 1 : a < b ? -1 : 0))
-  const mid = Math.floor(s.length / 2)
-  if (s.length % 2 === 0) {
-    return (s[mid - 1] + s[mid]) / 2n
-  }
-  return s[mid]
-}