@meshconnect/web-link-sdk 2.1.0-rc.2 → 2.1.0-rc.3

package/src/utils/wagmiCoreConnectorsUtils.ts

@@ -1,332 +0,0 @@
-import {
-  getConnectors,
-  connect,
-  disconnect,
-  getAccount,
-  signMessage,
-  getBalance,
-  sendTransaction,
-  switchChain,
-  simulateContract,
-  writeContract,
-  createConfig,
-  http,
-  fallback,
-  type Connector,
-  type GetAccountReturnType,
-  type Config,
-  type GetBalanceReturnType,
-  type Transport,
-  BaseError,
-  ChainNotConfiguredError,
-  ConnectorAccountNotFoundError,
-  ConnectorAlreadyConnectedError,
-  ConnectorNotConnectedError,
-  ConnectorNotFoundError,
-  ProviderNotFoundError,
-  SwitchChainNotSupportedError
-} from '@wagmi/core'
-
-import { injected } from '@wagmi/connectors'
-import {
-  WagmiInjectedConnectorData,
-  ConnectReturnTypeAndTxHash,
-  IncomingConfig,
-  Abi
-} from './types'
-import { parseUnits, Hash, Chain } from 'viem'
-
-let resolveConfigReady: (value: Config | PromiseLike<Config>) => void
-
-const configReady = new Promise<Config>(resolve => {
-  resolveConfigReady = resolve
-})
-
-const setConfig = (config: IncomingConfig) => {
-  try {
-    const transports: Record<number, Transport> = {}
-
-    for (const chainId in config.transports) {
-      const urls = config.transports[chainId]
-      if (Array.isArray(urls)) {
-        // If the URL is an array, create a fallback transport with multiple transports
-        transports[chainId] = fallback(urls.map(url => http(url)))
-      } else {
-        // If the URL is a string, create a single HTTP transport
-        transports[chainId] = http(urls)
-      }
-    }
-    const chainsTuple = [...config.chains] as [Chain, ...Chain[]]
-
-    const dynamicConfig = createConfig({
-      chains: chainsTuple,
-      multiInjectedProviderDiscovery: true,
-      transports: transports,
-      connectors: [injected()]
-    })
-
-    resolveConfigReady(dynamicConfig)
-  } catch (error) {
-    console.error('Error setting configuration:', error)
-  }
-}
-
-window.addEventListener('message', event => {
-  if (event.data.type === 'walletBrowserConfigInitialize') {
-    try {
-      const parsedConfig = JSON.parse(event.data.payload) as IncomingConfig
-      setConfig(parsedConfig)
-    } catch (error) {
-      console.error('Error parsing configuration:', error)
-    }
-  }
-})
-
-const configPromise = configReady
-
-export const getWagmiCoreInjectedData = async (): Promise<
-  WagmiInjectedConnectorData[] | Error
-> => {
-  return withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const connectors = await getConnectors(config)
-
-    const mappedConnectors: WagmiInjectedConnectorData[] = connectors.map(
-      ({ id, name, type, uid, icon }) => ({
-        id,
-        name,
-        type,
-        uid,
-        icon: icon || undefined
-      })
-    )
-    return mappedConnectors
-  })
-}
-
-export const connectToSpecificWallet = async (
-  walletName: string
-): Promise<ConnectReturnTypeAndTxHash | Error> => {
-  return withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const connectors = getConnectors(config)
-
-    const selectedConnector = connectors.find(
-      (connector: Connector) =>
-        connector.name.toLowerCase() === walletName.toLowerCase()
-    )
-
-    if (!selectedConnector) {
-      throw new Error(`No connector found for wallet: ${walletName}`)
-    }
-
-    await disconnectCurrentAccount(config, selectedConnector)
-
-    const result = await connect(config, { connector: selectedConnector })
-
-    const accountInfo = await getAccount(config)
-    const txSigned = await signedMessage(config, accountInfo)
-
-    return {
-      accounts: [...result.accounts],
-      chainId: result.chainId,
-      txSigned: txSigned as `0x${string}`
-    }
-  })
-}
-
-export const signedMessage = async (
-  config: Config,
-  accountInfo: GetAccountReturnType
-): Promise<Hash | Error> => {
-  if (!accountInfo.address) {
-    return new Error('Address not found')
-  }
-
-  return withWagmiErrorHandling(async () => {
-    const signedMessage = await signMessage(config, {
-      account: accountInfo.address,
-      message: 'Sign to verify ownership of wallet'
-    })
-
-    return signedMessage
-  })
-}
-
-export const walletBalance = async (
-  account: string,
-  chainId: number
-): Promise<GetBalanceReturnType | Error> => {
-  return withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const balance = await getBalance(config, {
-      address: account as `0x${string}`,
-      chainId: chainId
-    })
-    return balance
-  })
-}
-
-export const switchChainFromSDK = async (
-  chainId: number
-): Promise<Chain | Error> => {
-  return await withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const result = await switchChain(config, { chainId })
-    return result
-  })
-}
-
-export const sendTransactionFromSDK = async (
-  toAddress: string,
-  amount: number,
-  decimalPlaces: number,
-  chainId: number,
-  account: string
-): Promise<Hash | Error> => {
-  return await withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const result = await sendTransaction(config, {
-      to: formatAddress(toAddress) as `0x${string}`,
-      value: parseUnits(amount.toFixed(decimalPlaces) || '0', decimalPlaces),
-      chainId: chainId,
-      account: formatAddress(account) as `0x${string}`
-    })
-    return result
-  })
-}
-
-const formatAddress = (address: string) =>
-  address.startsWith('0x') ? address : `0x${address}`
-
-export const sendNonNativeTransactionFromSDK = async (
-  address: string,
-  abi: Abi,
-  functionName: string,
-  args: any[], // eslint-disable-line @typescript-eslint/no-explicit-any
-  value?: bigint
-): Promise<Hash | Error> => {
-  return await withWagmiErrorHandling(async () => {
-    const config = await configPromise
-    const { connector } = await getAccount(config)
-    const { request } = await simulateContract(config, {
-      address: formatAddress(address) as `0x${string}`,
-      abi: abi,
-      functionName: functionName,
-      args: args,
-      value: value,
-      connector
-    })
-    const result = await writeContract(config, request)
-    return result
-  })
-}
-
-const disconnectCurrentAccount = async (
-  config: Config,
-  currentConnector: Connector
-): Promise<void | Error> => {
-  return await withWagmiErrorHandling(async () => {
-    await disconnect(config, { connector: currentConnector })
-  })
-}
-
-export const disconnectAllAccounts = async (): Promise<void | Error> => {
-  const config = await configPromise
-  return withWagmiErrorHandling(async () => {
-    await disconnect(config)
-  })
-}
-
-/**
- * Wrapper function for Wagmi Core functions that handles errors
- * @param fn - The function to wrap
- * @returns - The result of the function or an error
- */
-async function withWagmiErrorHandling<T>(
-  fn: () => Promise<T>
-): Promise<T | Error> {
-  try {
-    return await fn()
-  } catch (error) {
-    if (error instanceof BaseError) {
-      return handleWagmiError(error)
-    } else {
-      if (error instanceof Error) {
-        throw new Error(error.message)
-      } else {
-        throw new Error('An unexpected error has occurred')
-      }
-    }
-  }
-}
-
-const handleWagmiError = (error: unknown): Error => {
-  if (error instanceof ChainNotConfiguredError) {
-    return handleChainNotConfiguredError(error)
-  } else if (error instanceof ConnectorAccountNotFoundError) {
-    return handleConnectorAccountNotFoundError(error)
-  } else if (error instanceof ConnectorAlreadyConnectedError) {
-    return handleConnectorAlreadyConnectedError(error)
-  } else if (error instanceof ConnectorNotConnectedError) {
-    return handleConnectorNotConnectedError(error)
-  } else if (error instanceof ConnectorNotFoundError) {
-    return handleConnectorNotFoundError(error)
-  } else if (error instanceof ProviderNotFoundError) {
-    return handleProviderNotFoundError(error)
-  } else if (error instanceof SwitchChainNotSupportedError) {
-    return handleSwitchChainNotSupportedError(error)
-  } else if (error instanceof BaseError) {
-    return handleBaseError(error)
-  } else {
-    // Handle unknown error types
-    if (error instanceof Error) {
-      throw new Error(error.message)
-    } else {
-      throw new Error('An unexpected error has occurred')
-    }
-  }
-}
-
-// All errors extend base error
-const handleBaseError = (error: BaseError): Error => {
-  throw new Error(error.message)
-}
-
-const handleChainNotConfiguredError = (
-  error: ChainNotConfiguredError
-): Error => {
-  throw new Error(`Chain not configured: ${error.message}`)
-}
-
-const handleConnectorAccountNotFoundError = (
-  error: ConnectorAccountNotFoundError
-): Error => {
-  throw new Error(`Connector account not found: ${error.message}`)
-}
-
-const handleConnectorAlreadyConnectedError = (
-  error: ConnectorAlreadyConnectedError
-): Error => {
-  throw new Error(`Connector already connected: ${error.message}`)
-}
-
-const handleConnectorNotConnectedError = (
-  error: ConnectorNotConnectedError
-): Error => {
-  throw new Error(`Connector not connected: ${error.message}`)
-}
-
-const handleConnectorNotFoundError = (error: ConnectorNotFoundError): Error => {
-  throw new Error(`Connector not found: ${error.message}`)
-}
-
-const handleProviderNotFoundError = (error: ProviderNotFoundError): Error => {
-  throw new Error(`Provider not found: ${error.message}`)
-}
-
-const handleSwitchChainNotSupportedError = (
-  error: SwitchChainNotSupportedError
-): Error => {
-  throw new Error(`Switch chain not supported: ${error.message}`)
-}

package/src/utils/wallet-browser-event-types.ts

@@ -1,102 +0,0 @@
-export type WalletBrowserEventType =
-  | WalletBrowserInjectedWalletSelected
-  | WalletBrowserChainSwitchRequest
-  | WalletBrowserTransferBalanceRequest
-  | WalletBrowserNativeTransferRequest
-  | WalletBrowserNonNativeTransferRequest
-  | WalletBrowserNativeSmartDeposit
-  | WalletBrowserNonNativeSmartDeposit
-  | WalletBrowserDisconnect
-
-const WALLET_BROWSER_EVENT_TYPE_KEYS = [
-  'walletBrowserInjectedWalletSelected',
-  'walletBrowserChainSwitchRequest',
-  'walletBrowserTransferBalanceRequest',
-  'walletBrowserNativeTransferRequest',
-  'walletBrowserNonNativeTransferRequest',
-  'walletBrowserNativeSmartDeposit',
-  'walletBrowserNonNativeSmartDeposit',
-  'walletBrowserDisconnect'
-] as const
-
-export type WalletBrowserEventTypeKeys =
-  (typeof WALLET_BROWSER_EVENT_TYPE_KEYS)[number]
-
-export function isWalletBrowserEventTypeKey(
-  key: string
-): key is WalletBrowserEventTypeKeys {
-  return WALLET_BROWSER_EVENT_TYPE_KEYS.includes(
-    key as WalletBrowserEventTypeKeys
-  )
-}
-
-interface WalletBrowserEventBase {
-  type: WalletBrowserEventTypeKeys
-}
-
-export interface WalletBrowserInjectedWalletSelected
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserInjectedWalletSelected'
-  payload: {
-    integrationName: string
-  }
-}
-
-export interface WalletBrowserChainSwitchRequest
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserChainSwitchRequest'
-  payload: {
-    chainId: number
-  }
-}
-
-export interface WalletBrowserTransferBalanceRequest
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserTransferBalanceRequest'
-  payload: {
-    account: string
-    chainId: number
-  }
-}
-
-export interface WalletBrowserNativeTransferRequest
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserNativeTransferRequest'
-  payload: {
-    toAddress: string
-    amount: number
-    decimalPlaces: number
-    chainId: number
-    account: string
-  }
-}
-
-interface SmartContractPayload {
-  address: string
-  abi: string
-  functionName: string
-  args: any[] // eslint-disable-line @typescript-eslint/no-explicit-any
-  value?: bigint
-}
-
-export interface WalletBrowserNonNativeTransferRequest
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserNonNativeTransferRequest'
-  payload: SmartContractPayload
-}
-
-export interface WalletBrowserNativeSmartDeposit
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserNativeSmartDeposit'
-  payload: SmartContractPayload
-}
-
-export interface WalletBrowserNonNativeSmartDeposit
-  extends WalletBrowserEventBase {
-  type: 'walletBrowserNonNativeSmartDeposit'
-  payload: SmartContractPayload
-}
-
-export interface WalletBrowserDisconnect extends WalletBrowserEventBase {
-  type: 'walletBrowserDisconnect'
-}

package/tools/copy.js

@@ -1,25 +0,0 @@
-import fs from 'fs'
-
-const rawData = fs.readFileSync('package.json')
-const packageModel = JSON.parse(rawData)
-delete packageModel.main
-delete packageModel.module
-delete packageModel.types
-delete packageModel.scripts
-delete packageModel.type
-
-packageModel.main = './cjs/index.js'
-packageModel.module = './index.js'
-packageModel.types = './index.d.ts'
-
-const versionFromNodeApi = fs.readFileSync('../node-api/package.json')
-const version = JSON.parse(versionFromNodeApi).version
-
-packageModel.dependencies['@meshconnect/node-api'] = `^${version}`
-
-const data = JSON.stringify(packageModel, null, 2)
-fs.writeFileSync('dist/package.json', data)
-console.log('package.json.dist was copied to ./dist folder')
-
-fs.copyFileSync('README.md', 'dist/README.md')
-console.log('README.md was copied to ./dist folder')

package/tools/update-version.js

@@ -1,10 +0,0 @@
-import fs from 'fs'
-
-const rawData = fs.readFileSync('package.json')
-const packageModel = JSON.parse(rawData)
-const version = packageModel?.version || '2.0.0'
-
-fs.writeFileSync(
-  'src/utils/version.ts',
-  `export const sdkVersion = '${version}'\n`
-)

package/tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist/",
-    "declaration": true,
-    "declarationDir": "./dist/",
-    "rootDir": "./src/",
-    "baseUrl": "./",
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src/"]
-}