@lifi/sdk 3.13.5 → 4.0.0-alpha.1

package/src/_types/utils/sleep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../utils/sleep.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/C"}

package/src/_types/utils/waitForResult.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"waitForResult.d.ts","sourceRoot":"","sources":["../../utils/waitForResult.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAU,CAAC,EACnC,IAAI,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,EAChC,iBAAe,EACf,mBAAc,EACd,cAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAoB,KACnE,OAAO,CAAC,CAAC,CAuBX,CAAA"}

package/src/_types/utils/withDedupe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withDedupe.d.ts","sourceRoot":"","sources":["../../utils/withDedupe.ts"],"names":[],"mappings":"AAyBA,KAAK,iBAAiB,GAAG;IACvB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACxB,CAAA;AAED,uCAAuC;AACvC,wBAAgB,UAAU,CAAC,CAAC,EAC1B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,EAAE,OAAc,EAAE,EAAE,EAAE,EAAE,iBAAiB,GACxC,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/src/_types/version.d.ts

@@ -1,3 +0,0 @@
-export declare const name = "@lifi/sdk";
-export declare const version = "3.13.5";
-//# sourceMappingURL=version.d.ts.map

package/src/_types/version.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,cAAc,CAAA;AAC/B,eAAO,MAAM,OAAO,WAAW,CAAA"}

package/src/config.ts

@@ -1,100 +0,0 @@
-import { ChainId, type ChainType, type ExtendedChain } from '@lifi/types'
-import type { SDKProvider } from './core/types.js'
-import type { RPCUrls, SDKBaseConfig, SDKConfig } from './types/internal.js'
-
-export const config = (() => {
-  const _config: SDKBaseConfig = {
-    integrator: 'lifi-sdk',
-    apiUrl: 'https://li.quest/v1',
-    rpcUrls: {},
-    chains: [],
-    providers: [],
-    preloadChains: true,
-    debug: false,
-  }
-  let _loading: Promise<void> | undefined
-  return {
-    set loading(loading: Promise<void>) {
-      _loading = loading
-    },
-    get() {
-      return _config
-    },
-    set(options: SDKConfig) {
-      const { chains, providers, rpcUrls, ...otherOptions } = options
-      Object.assign(_config, otherOptions)
-      if (chains) {
-        this.setChains(chains)
-      }
-      if (providers) {
-        this.setProviders(providers)
-      }
-      if (rpcUrls) {
-        this.setRPCUrls(rpcUrls)
-      }
-      return _config
-    },
-    getProvider(type: ChainType) {
-      return _config.providers.find((provider) => provider.type === type)
-    },
-    setProviders(providers: SDKProvider[]) {
-      const providerMap = new Map(
-        _config.providers.map((provider) => [provider.type, provider])
-      )
-      for (const provider of providers) {
-        providerMap.set(provider.type, provider)
-      }
-      _config.providers = Array.from(providerMap.values())
-    },
-    setChains(chains: ExtendedChain[]) {
-      const rpcUrls = chains.reduce((rpcUrls, chain) => {
-        if (chain.metamask?.rpcUrls?.length) {
-          rpcUrls[chain.id as ChainId] = chain.metamask.rpcUrls
-        }
-        return rpcUrls
-      }, {} as RPCUrls)
-      this.setRPCUrls(rpcUrls, [ChainId.SOL])
-      _config.chains = chains
-      _loading = undefined
-    },
-    async getChains() {
-      if (_loading) {
-        await _loading
-      }
-      return _config.chains
-    },
-    async getChainById(chainId: ChainId) {
-      if (_loading) {
-        await _loading
-      }
-      const chain = _config.chains?.find((chain) => chain.id === chainId)
-      if (!chain) {
-        throw new Error(`ChainId ${chainId} not found`)
-      }
-      return chain
-    },
-    setRPCUrls(rpcUrls: RPCUrls, skipChains?: ChainId[]) {
-      for (const rpcUrlsKey in rpcUrls) {
-        const chainId = Number(rpcUrlsKey) as ChainId
-        const urls = rpcUrls[chainId]
-        if (!urls?.length) {
-          continue
-        }
-        if (!_config.rpcUrls[chainId]?.length) {
-          _config.rpcUrls[chainId] = Array.from(urls)
-        } else if (!skipChains?.includes(chainId)) {
-          const filteredUrls = urls.filter(
-            (url) => !_config.rpcUrls[chainId]?.includes(url)
-          )
-          _config.rpcUrls[chainId].push(...filteredUrls)
-        }
-      }
-    },
-    async getRPCUrls() {
-      if (_loading) {
-        await _loading
-      }
-      return _config.rpcUrls
-    },
-  }
-})()

package/src/constants.ts

@@ -1,10 +0,0 @@
-export const AddressZero = '0x0000000000000000000000000000000000000000'
-export const AlternativeAddressZero =
-  '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
-
-export const SolSystemProgram = '11111111111111111111111111111111'
-
-export const MaxUint48 = BigInt('0xffffffffffff')
-export const MaxUint160 = BigInt('0xffffffffffffffffffffffffffffffffffffffff')
-export const MaxUint256 =
-  BigInt(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn)

package/src/core/EVM/EVM.ts

@@ -1,47 +0,0 @@
-import { ChainType } from '@lifi/types'
-import { isAddress } from 'viem'
-import type { StepExecutorOptions } from '../types.js'
-import { EVMStepExecutor } from './EVMStepExecutor.js'
-import { getEVMBalance } from './getEVMBalance.js'
-import { resolveEVMAddress } from './resolveEVMAddress.js'
-import type { EVMProvider, EVMProviderOptions } from './types.js'
-
-export function EVM(options?: EVMProviderOptions): EVMProvider {
-  const _options: EVMProviderOptions = options ?? {}
-  return {
-    get type() {
-      return ChainType.EVM
-    },
-    get options() {
-      return _options
-    },
-    isAddress,
-    resolveAddress: resolveEVMAddress,
-    getBalance: getEVMBalance,
-    getWalletClient: _options.getWalletClient,
-    async getStepExecutor(
-      options: StepExecutorOptions
-    ): Promise<EVMStepExecutor> {
-      if (!_options.getWalletClient) {
-        throw new Error('Client is not provided.')
-      }
-
-      const walletClient = await _options.getWalletClient()
-
-      const executor = new EVMStepExecutor({
-        client: walletClient,
-        routeId: options.routeId,
-        executionOptions: {
-          ...options.executionOptions,
-          switchChainHook:
-            _options.switchChain ?? options.executionOptions?.switchChainHook,
-        },
-      })
-
-      return executor
-    },
-    setOptions(options: EVMProviderOptions) {
-      Object.assign(_options, options)
-    },
-  }
-}