@lifi/sdk 0.0.0-preview-f5cf9f8

package/src/actions/getTokenBalancesByChain.ts

@@ -0,0 +1,76 @@
+import type {
+  Token,
+  TokenAmount,
+  TokenAmountExtended,
+  TokenExtended,
+} from '@lifi/types'
+import { ValidationError } from '../errors/errors.js'
+import type { SDKClient } from '../types/core.js'
+import { isToken } from '../utils/isToken.js'
+
+/**
+ * This method queries the balances of tokens for a specific list of chains for a given wallet.
+ * @param client - The SDK client.
+ * @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 {ValidationError} Throws a ValidationError if validation fails.
+ * @throws {Error} Throws an Error if the SDK Provider for the wallet address is not found.
+ */
+export async function getTokenBalancesByChain(
+  client: SDKClient,
+  walletAddress: string,
+  tokensByChain: { [chainId: number]: Token[] }
+): Promise<{ [chainId: number]: TokenAmount[] }>
+export async function getTokenBalancesByChain(
+  client: SDKClient,
+  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 = client.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 client.getChainById(chainId)
+      if (provider.type === chain.chainType) {
+        const tokenAmounts = await provider.getBalance(
+          client,
+          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 (client.config.debug) {
+    for (const result of tokenAmountsSettled) {
+      if (result.status === 'rejected') {
+        console.warn("Couldn't fetch token balance.", result.reason)
+      }
+    }
+  }
+  return tokenAmountsByChain
+}

package/src/actions/getTokens.ts

@@ -0,0 +1,57 @@
+import type {
+  RequestOptions,
+  TokensExtendedResponse,
+  TokensRequest,
+  TokensResponse,
+} from '@lifi/types'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+import { withDedupe } from '../utils/withDedupe.js'
+
+/**
+ * Get all known tokens.
+ * @param client - The SDK client
+ * @param params - The configuration of the requested tokens
+ * @param options - Request options
+ * @returns The tokens that are available on the requested chains
+ */
+export async function getTokens(
+  client: SDKClient,
+  params?: TokensRequest & { extended?: false | undefined },
+  options?: RequestOptions
+): Promise<TokensResponse>
+export async function getTokens(
+  client: SDKClient,
+  params: TokensRequest & { extended: true },
+  options?: RequestOptions
+): Promise<TokensExtendedResponse>
+export async function getTokens(
+  client: SDKClient,
+  params?: TokensRequest,
+  options?: RequestOptions
+): Promise<TokensResponse> {
+  if (params) {
+    for (const key of Object.keys(params)) {
+      const value = params[key as keyof TokensRequest]
+      if (value === undefined || value === null) {
+        delete params[key as keyof TokensRequest]
+      }
+    }
+  }
+  const urlSearchParams = new URLSearchParams(
+    params as Record<string, string>
+  ).toString()
+  const _isExtended = params?.extended === true
+  const response = await withDedupe(
+    () =>
+      request<
+        typeof _isExtended extends true
+          ? TokensExtendedResponse
+          : TokensResponse
+      >(client.config, `${client.config.apiUrl}/tokens?${urlSearchParams}`, {
+        signal: options?.signal,
+      }),
+    { id: `${getTokens.name}.${urlSearchParams}` }
+  )
+  return response
+}

package/src/actions/getTools.ts

@@ -0,0 +1,34 @@
+import type { RequestOptions, ToolsRequest, ToolsResponse } from '@lifi/types'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Get the available tools to bridge and swap tokens.
+ * @param client - The SDK client
+ * @param params - The configuration of the requested tools
+ * @param options - Request options
+ * @returns The tools that are available on the requested chains
+ */
+export const getTools = async (
+  client: SDKClient,
+  params?: ToolsRequest,
+  options?: RequestOptions
+): Promise<ToolsResponse> => {
+  if (params) {
+    for (const key of Object.keys(params)) {
+      const value = params[key as keyof ToolsRequest]
+      if (value === undefined || value === null) {
+        delete params[key as keyof ToolsRequest]
+      }
+    }
+  }
+  return await request<ToolsResponse>(
+    client.config,
+    `${client.config.apiUrl}/tools?${new URLSearchParams(
+      params as Record<string, string>
+    )}`,
+    {
+      signal: options?.signal,
+    }
+  )
+}

package/src/actions/getTransactionHistory.ts

@@ -0,0 +1,54 @@
+import type {
+  RequestOptions,
+  TransactionAnalyticsRequest,
+  TransactionAnalyticsResponse,
+} from '@lifi/types'
+import { ValidationError } from '../errors/errors.js'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Get the transaction history for a wallet
+ * @param client - The SDK client
+ * @param params - The parameters for the transaction history request
+ * @param params.wallet - The wallet address
+ * @param params.status - The status of the transactions
+ * @param params.fromTimestamp - The start timestamp for the transactions
+ * @param params.toTimestamp - The end timestamp for the transactions
+ * @param options - Request options
+ * @throws {ValidationError} - Throws a ValidationError if parameters are invalid
+ * @throws {LiFiError} - Throws a LiFiError if request fails.
+ * @returns The transaction history response
+ */
+export const getTransactionHistory = async (
+  client: SDKClient,
+  { wallet, status, fromTimestamp, toTimestamp }: TransactionAnalyticsRequest,
+  options?: RequestOptions
+): Promise<TransactionAnalyticsResponse> => {
+  if (!wallet) {
+    throw new ValidationError('Required parameter "wallet" is missing.')
+  }
+
+  const url = new URL(`${client.config.apiUrl}/analytics/transfers`)
+
+  url.searchParams.append('integrator', client.config.integrator)
+  url.searchParams.append('wallet', wallet)
+
+  if (status) {
+    url.searchParams.append('status', status)
+  }
+
+  if (fromTimestamp) {
+    url.searchParams.append('fromTimestamp', fromTimestamp.toString())
+  }
+
+  if (toTimestamp) {
+    url.searchParams.append('toTimestamp', toTimestamp.toString())
+  }
+
+  return await request<TransactionAnalyticsResponse>(
+    client.config,
+    url,
+    options
+  )
+}

package/src/actions/getWalletBalances.ts

@@ -0,0 +1,36 @@
+import type {
+  GetWalletBalanceExtendedResponse,
+  RequestOptions,
+  WalletTokenExtended,
+} from '@lifi/types'
+import { ValidationError } from '../errors/errors.js'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+/**
+ * Returns the balances of tokens a wallet holds across EVM chains.
+ * @param client - The SDK client.
+ * @param walletAddress - A wallet address.
+ * @param options - Optional request options.
+ * @returns An object containing the tokens and the amounts organized by chain ids.
+ * @throws {ValidationError} Throws a ValidationError if parameters are invalid.
+ */
+export const getWalletBalances = async (
+  client: SDKClient,
+  walletAddress: string,
+  options?: RequestOptions
+): Promise<Record<number, WalletTokenExtended[]>> => {
+  if (!walletAddress) {
+    throw new ValidationError('Missing walletAddress.')
+  }
+
+  const response = await request<GetWalletBalanceExtendedResponse>(
+    client.config,
+    `${client.config.apiUrl}/wallets/${walletAddress}/balances?extended=true`,
+    {
+      signal: options?.signal,
+    }
+  )
+
+  return (response?.balances || {}) as Record<number, WalletTokenExtended[]>
+}

package/src/actions/index.ts

@@ -0,0 +1,347 @@
+import type {
+  ChainId,
+  ChainKey,
+  ChainsRequest,
+  ChainType,
+  ConnectionsRequest,
+  ConnectionsResponse,
+  ContractCallsQuoteRequest,
+  ExtendedChain,
+  GasRecommendationRequest,
+  GasRecommendationResponse,
+  LiFiStep,
+  PatchCallDataRequest,
+  RelayRequest,
+  RelayResponseData,
+  RelayStatusRequest,
+  RelayStatusResponseData,
+  RequestOptions,
+  RoutesRequest,
+  RoutesResponse,
+  SignedLiFiStep,
+  StatusResponse,
+  Token,
+  TokenAmount,
+  TokenExtended,
+  TokensExtendedResponse,
+  TokensRequest,
+  TokensResponse,
+  ToolsRequest,
+  ToolsResponse,
+  TransactionAnalyticsRequest,
+  TransactionAnalyticsResponse,
+  WalletTokenExtended,
+} from '@lifi/types'
+import type {
+  GetStatusRequestExtended,
+  QuoteRequestFromAmount,
+} from '../types/actions.js'
+import type { SDKClient } from '../types/core.js'
+import { getChains } from './getChains.js'
+import { getConnections } from './getConnections.js'
+import { getContractCallsQuote } from './getContractCallsQuote.js'
+import { getGasRecommendation } from './getGasRecommendation.js'
+import { getNameServiceAddress } from './getNameServiceAddress.js'
+import { getQuote } from './getQuote.js'
+import { getRelayedTransactionStatus } from './getRelayedTransactionStatus.js'
+import { getRelayerQuote } from './getRelayerQuote.js'
+import { getRoutes } from './getRoutes.js'
+import { getStatus } from './getStatus.js'
+import { getStepTransaction } from './getStepTransaction.js'
+import { getToken } from './getToken.js'
+import { getTokenBalance } from './getTokenBalance.js'
+import { getTokenBalances } from './getTokenBalances.js'
+import { getTokenBalancesByChain } from './getTokenBalancesByChain.js'
+import { getTokens } from './getTokens.js'
+import { getTools } from './getTools.js'
+import { getTransactionHistory } from './getTransactionHistory.js'
+import { getWalletBalances } from './getWalletBalances.js'
+import {
+  type PatchContractCallsResponse,
+  patchContractCalls,
+} from './patchContractCalls.js'
+import { relayTransaction } from './relayTransaction.js'
+
+export type Actions = {
+  /**
+   * Get all available chains
+   * @param params - The configuration of the requested chains
+   * @param options - Request options
+   * @returns A list of all available chains
+   */
+  getChains: (
+    params?: ChainsRequest,
+    options?: RequestOptions
+  ) => Promise<ExtendedChain[]>
+
+  /**
+   * Get connections between chains
+   * @param params - The configuration of the requested connections
+   * @param options - Request options
+   * @returns A list of connections
+   */
+  getConnections: (
+    params: ConnectionsRequest,
+    options?: RequestOptions
+  ) => Promise<ConnectionsResponse>
+
+  /**
+   * Get a quote for contract calls
+   * @param params - The configuration of the requested contract calls quote
+   * @param options - Request options
+   * @returns Quote for contract calls
+   */
+  getContractCallsQuote: (
+    params: ContractCallsQuoteRequest,
+    options?: RequestOptions
+  ) => Promise<LiFiStep>
+
+  /**
+   * Get gas recommendation for a chain
+   * @param params - The configuration of the requested gas recommendation
+   * @param options - Request options
+   * @returns Gas recommendation
+   */
+  getGasRecommendation: (
+    params: GasRecommendationRequest,
+    options?: RequestOptions
+  ) => Promise<GasRecommendationResponse>
+
+  /**
+   * Get the address of a name service
+   * @param name - The name to resolve
+   * @param chainType - The chain type to resolve the name on
+   * @returns The address of the name service
+   */
+  getNameServiceAddress: (
+    name: string,
+    chainType?: ChainType
+  ) => Promise<string | undefined>
+
+  /**
+   * Get a quote for a token transfer
+   * @param params - The configuration of the requested quote
+   * @param options - Request options
+   * @returns Quote for a token transfer
+   */
+  getQuote: (
+    params: Parameters<typeof getQuote>[1],
+    options?: RequestOptions
+  ) => Promise<LiFiStep>
+
+  /**
+   * Get the status of a relayed transaction
+   * @param params - The configuration of the requested relay status
+   * @param options - Request options
+   * @returns Status of the relayed transaction
+   */
+  getRelayedTransactionStatus: (
+    params: RelayStatusRequest,
+    options?: RequestOptions
+  ) => Promise<RelayStatusResponseData>
+
+  /**
+   * Get a quote from a relayer
+   * @param params - The configuration of the requested relayer quote
+   * @param options - Request options
+   * @returns Quote from a relayer
+   */
+  getRelayerQuote: (
+    params: QuoteRequestFromAmount,
+    options?: RequestOptions
+  ) => Promise<LiFiStep>
+
+  /**
+   * Get a set of routes for a request that describes a transfer of tokens
+   * @param params - A description of the transfer
+   * @param options - Request options
+   * @returns The resulting routes that can be used to realize the described transfer
+   */
+  getRoutes: (
+    params: RoutesRequest,
+    options?: RequestOptions
+  ) => Promise<RoutesResponse>
+
+  /**
+   * Get the status of a transaction
+   * @param params - The configuration of the requested status
+   * @param options - Request options
+   * @returns Status of the transaction
+   */
+  getStatus: (
+    params: GetStatusRequestExtended,
+    options?: RequestOptions
+  ) => Promise<StatusResponse>
+
+  /**
+   * Get a step transaction
+   * @param params - The configuration of the requested step transaction
+   * @param options - Request options
+   * @returns Step transaction
+   */
+  getStepTransaction: (
+    params: LiFiStep | SignedLiFiStep,
+    options?: RequestOptions
+  ) => Promise<LiFiStep>
+
+  /**
+   * Get a specific token
+   * @param chain - Id or key of the chain that contains the token
+   * @param token - Address or symbol of the token on the requested chain
+   * @param options - Request options
+   * @returns Token information
+   */
+  getToken: (
+    chain: ChainKey | ChainId,
+    token: string,
+    options?: RequestOptions
+  ) => Promise<TokenExtended>
+
+  /**
+   * Get token balance for a specific token
+   * @param walletAddress - A wallet address
+   * @param token - A Token object
+   * @returns Token balance
+   */
+  getTokenBalance: (
+    walletAddress: string,
+    token: Token
+  ) => Promise<TokenAmount | null>
+
+  /**
+   * Get token balances for multiple tokens
+   * @param walletAddress - A wallet address
+   * @param tokens - A list of Token objects
+   * @returns Token balances
+   */
+  getTokenBalances: (
+    walletAddress: string,
+    tokens: Token[]
+  ) => Promise<TokenAmount[]>
+
+  /**
+   * Get token balances by chain
+   * @param walletAddress - A wallet address
+   * @param tokensByChain - A list of token objects organized by chain ids
+   * @returns Token balances by chain
+   */
+  getTokenBalancesByChain: (
+    walletAddress: string,
+    tokensByChain: { [chainId: number]: Token[] }
+  ) => Promise<{
+    [chainId: number]: TokenAmount[]
+  }>
+
+  /**
+   * Get all available tokens
+   * @param params - The configuration of the requested tokens
+   * @param options - Request options
+   * @returns A list of all available tokens
+   */
+  getTokens: {
+    (
+      params?: TokensRequest & { extended?: false | undefined },
+      options?: RequestOptions
+    ): Promise<TokensResponse>
+    (
+      params: TokensRequest & { extended: true },
+      options?: RequestOptions
+    ): Promise<TokensExtendedResponse>
+  }
+
+  /**
+   * Get all available tools (bridges and exchanges)
+   * @param params - The configuration of the requested tools
+   * @param options - Request options
+   * @returns A list of all available tools
+   */
+  getTools: (
+    params?: ToolsRequest,
+    options?: RequestOptions
+  ) => Promise<ToolsResponse>
+
+  /**
+   * Get transaction history
+   * @param params - The configuration of the requested transaction history
+   * @param options - Request options
+   * @returns Transaction history
+   */
+  getTransactionHistory: (
+    params: TransactionAnalyticsRequest,
+    options?: RequestOptions
+  ) => Promise<TransactionAnalyticsResponse>
+
+  /**
+   * Get wallet balances
+   * @param params - The configuration of the requested wallet balances
+   * @param options - Request options
+   * @returns Wallet balances
+   */
+  getWalletBalances: (
+    walletAddress: string,
+    options?: RequestOptions
+  ) => Promise<Record<number, WalletTokenExtended[]>>
+
+  /**
+   * Relay a transaction through the relayer service
+   * @param params - The configuration for the relay request
+   * @param options - Request options
+   * @returns Task ID and transaction link for the relayed transaction
+   */
+  relayTransaction: (
+    params: RelayRequest,
+    options?: RequestOptions
+  ) => Promise<RelayResponseData>
+
+  /**
+   * Patch contract calls
+   * @param params - The configuration for the patch contract calls request
+   * @param options - Request options
+   * @returns Patched contract calls
+   */
+  patchContractCalls: (
+    params: PatchCallDataRequest,
+    options?: RequestOptions
+  ) => Promise<PatchContractCallsResponse[]>
+}
+
+export function actions(client: SDKClient): Actions {
+  return {
+    getChains: (params, options) => getChains(client, params, options),
+    getConnections: (params, options) =>
+      getConnections(client, params, options),
+    getContractCallsQuote: (params, options) =>
+      getContractCallsQuote(client, params, options),
+    getGasRecommendation: (params, options) =>
+      getGasRecommendation(client, params, options),
+    getNameServiceAddress: (name, chainType) =>
+      getNameServiceAddress(client, name, chainType),
+    getTokens: (params, options) => getTokens(client, params as any, options),
+    getTools: (params, options) => getTools(client, params, options),
+    getQuote: (params, options) => getQuote(client, params, options),
+    getRelayedTransactionStatus: (params, options) =>
+      getRelayedTransactionStatus(client, params, options),
+    getRelayerQuote: (params, options) =>
+      getRelayerQuote(client, params, options),
+    getRoutes: (params, options) => getRoutes(client, params, options),
+    getStatus: (params, options) => getStatus(client, params, options),
+    getStepTransaction: (params, options) =>
+      getStepTransaction(client, params, options),
+    getToken: (chain, token, options) =>
+      getToken(client, chain, token, options),
+    getTokenBalance: (walletAddress, token) =>
+      getTokenBalance(client, walletAddress, token),
+    getTokenBalances: (walletAddress, tokens) =>
+      getTokenBalances(client, walletAddress, tokens),
+    getTokenBalancesByChain: (walletAddress, tokensByChain) =>
+      getTokenBalancesByChain(client, walletAddress, tokensByChain),
+    getTransactionHistory: (params, options) =>
+      getTransactionHistory(client, params, options),
+    getWalletBalances: (walletAddress, options) =>
+      getWalletBalances(client, walletAddress, options),
+    relayTransaction: (params, options) =>
+      relayTransaction(client, params, options),
+    patchContractCalls: (params, options) =>
+      patchContractCalls(client, params, options),
+  }
+}

package/src/actions/patchContractCalls.ts

@@ -0,0 +1,30 @@
+import type { PatchCallDataRequest, RequestOptions } from '@lifi/types'
+import type { SDKClient } from '../types/core.js'
+import { request } from '../utils/request.js'
+
+export interface PatchContractCallsResponse {
+  target: string
+  value: bigint
+  callData: string
+  allowFailure: boolean
+  isDelegateCall: boolean
+}
+
+export const patchContractCalls = async (
+  client: SDKClient,
+  params: PatchCallDataRequest,
+  options?: RequestOptions
+): Promise<PatchContractCallsResponse[]> => {
+  return await request<PatchContractCallsResponse[]>(
+    client.config,
+    `${client.config.apiUrl}/patcher`,
+    {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(params),
+      signal: options?.signal,
+    }
+  )
+}