@meshconnect/web-link-sdk 3.2.15 → 3.3.0

package/src/utils/connectors/evm/chainSwitching.ts

@@ -1,165 +0,0 @@
-import { EVMProvider } from './types'
-import { getChainConfiguration } from './chainConfigs'
-import { getActiveRawProvider } from './provider'
-
-// Chain switch status tracking
-const isChainSwitching = false
-const chainSwitchError: Error | null = null
-
-const MAX_RETRY_ATTEMPTS = 3
-const RETRY_DELAY = 1000
-
-/**
- * Waits for a pending chain switch to complete
- */
-const waitForPendingSwitch = async (
-  provider: EVMProvider,
-  chainIdHex: string,
-  attempt: number = 0
-): Promise<void> => {
-  try {
-    // Get current chain
-    const currentChainHex = await provider.request({ method: 'eth_chainId' })
-    if (currentChainHex === chainIdHex) {
-      return // Switch completed
-    }
-
-    if (attempt >= MAX_RETRY_ATTEMPTS) {
-      throw new Error('Chain switch timeout')
-    }
-
-    // Wait and retry
-    await new Promise(resolve => setTimeout(resolve, RETRY_DELAY))
-    return waitForPendingSwitch(provider, chainIdHex, attempt + 1)
-  } catch (error: any) {
-    if (error.code === -32002) {
-      // Still pending, wait and retry
-      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY))
-      return waitForPendingSwitch(provider, chainIdHex, attempt + 1)
-    }
-    throw error
-  }
-}
-
-/**
- * Switches the current EVM chain
- */
-export const switchEVMChain = async (
-  chainId: number,
-  provider?: EVMProvider
-): Promise<{ chainId: number; accounts: string[] } | Error> => {
-  try {
-    const targetProvider = provider || getActiveRawProvider()
-    if (!targetProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    const chainIdHex = `0x${chainId.toString(16)}`
-
-    try {
-      await switchChain(targetProvider, chainIdHex)
-    } catch (switchError: any) {
-      await handleSwitchError(switchError, targetProvider, chainId, chainIdHex)
-    }
-
-    const accounts = await targetProvider.request({ method: 'eth_accounts' })
-    return { chainId, accounts }
-  } catch (error) {
-    if (isUserRejection(error)) {
-      return new Error('User rejected chain switch')
-    }
-    await new Promise(resolve => setTimeout(resolve, 1000))
-    console.error('Chain switch error:', error)
-    return error instanceof Error ? error : new Error('Failed to switch chain')
-  }
-}
-
-/**
- * Attempts to switch to a specific chain
- */
-const switchChain = async (
-  provider: EVMProvider,
-  chainIdHex: string
-): Promise<void> => {
-  await provider.request({
-    method: 'wallet_switchEthereumChain',
-    params: [{ chainId: chainIdHex }]
-  })
-}
-
-/**
- * Handles chain switch errors
- */
-const handleSwitchError = async (
-  error: any,
-  provider: EVMProvider,
-  chainId: number,
-  chainIdHex: string
-): Promise<void> => {
-  if (error.code === 4001) {
-    throw new Error('User rejected chain switch')
-  }
-
-  if (error.code === -32002) {
-    // Request already pending, wait for it
-    await waitForPendingSwitch(provider, chainIdHex)
-    return
-  }
-
-  if (error.code === 4902 || error.code === -32603) {
-    await addChain(provider, chainId, chainIdHex)
-    await switchChain(provider, chainIdHex)
-  } else {
-    throw error
-  }
-}
-
-/**
- * Adds a new chain to the wallet
- */
-const addChain = async (
-  provider: EVMProvider,
-  chainId: number,
-  chainIdHex: string
-): Promise<void> => {
-  const chainConfig = getChainConfiguration(chainId)
-
-  if (!chainConfig) {
-    throw new Error(`No configuration found for chain ${chainId}`)
-  }
-
-  try {
-    await provider.request({
-      method: 'wallet_addEthereumChain',
-      params: [
-        {
-          chainId: chainIdHex,
-          chainName: chainConfig.name,
-          nativeCurrency: chainConfig.nativeCurrency,
-          rpcUrls: chainConfig.rpcUrls.default.http,
-          blockExplorerUrls: [chainConfig.blockExplorers.default.url]
-        }
-      ]
-    })
-  } catch (addError: any) {
-    if (addError.code === 4001) {
-      throw new Error('User rejected chain add')
-    }
-    throw addError
-  }
-}
-
-/**
- * Checks if an error is a user rejection
- */
-const isUserRejection = (error: any): boolean => {
-  return error instanceof Error && error.message.includes('rejected')
-}
-
-/**
- * Gets the current chain switch status
- */
-export const getChainSwitchStatus = () => ({
-  isChainSwitching,
-  chainSwitchError
-})

package/src/utils/connectors/evm/index.ts

@@ -1,8 +0,0 @@
-export * from './types'
-export * from './walletConnection'
-export * from './transactions'
-export * from './chainSwitching'
-export * from './walletDiscovery'
-export * from './provider'
-export * from './chainConfigs'
-export * from './signing'

package/src/utils/connectors/evm/provider.ts

@@ -1,22 +0,0 @@
-import { ethers } from 'ethers'
-import { EVMProvider } from './types'
-
-// Keep track of the active provider
-let activeEVMProvider: ethers.BrowserProvider | null = null
-let activeRawProvider: EVMProvider | null = null
-
-export const setActiveEVMProvider = (
-  provider: ethers.BrowserProvider,
-  rawProvider: EVMProvider
-) => {
-  activeEVMProvider = provider
-  activeRawProvider = rawProvider
-}
-
-export const getActiveEVMProvider = () => activeEVMProvider
-export const getActiveRawProvider = () => activeRawProvider
-
-export const clearActiveProviders = () => {
-  activeEVMProvider = null
-  activeRawProvider = null
-}

package/src/utils/connectors/evm/signing.ts

@@ -1,39 +0,0 @@
-import { ethers } from 'ethers'
-import { getActiveEVMProvider, getActiveRawProvider } from './provider'
-
-export const signEVMMessage = async (
-  walletName: string,
-  address: string,
-  message: string
-): Promise<string | Error> => {
-  try {
-    const activeProvider = getActiveEVMProvider()
-    const activeRawProvider = getActiveRawProvider()
-
-    if (!activeProvider || !activeRawProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    // Special handling for Rainbow wallet using personal_sign
-    if (walletName.toLowerCase() === 'rainbow') {
-      const messageHex = ethers.hexlify(ethers.toUtf8Bytes(message))
-      const signature = await activeRawProvider.request({
-        method: 'personal_sign',
-        // EIP-191 standard order: address first, then message
-        params: [address.toLowerCase(), messageHex]
-      })
-      return signature
-    }
-
-    // For other wallets, use ethers.js signing
-    const provider = new ethers.BrowserProvider(activeRawProvider)
-    const signer = await provider.getSigner(address)
-    const signature = await signer.signMessage(message)
-    return signature
-  } catch (error) {
-    console.error('EVM message signing error:', error)
-    return error instanceof Error
-      ? error
-      : new Error(`Failed to sign message with ${walletName} wallet`)
-  }
-}

package/src/utils/connectors/evm/transactions.ts

@@ -1,356 +0,0 @@
-import { ethers } from 'ethers'
-import { getActiveRawProvider } from './provider'
-
-const isUserRejection = (error: any): boolean => {
-  if (!error) return false
-
-  // Check for various wallet rejection patterns
-  const message = error.message?.toLowerCase() || ''
-  return (
-    error.code === 4001 || // Standard EIP-1193 user rejection code
-    message.includes('user rejected') ||
-    message.includes('user denied') ||
-    message.includes('user cancelled') ||
-    message.includes('declined')
-  )
-}
-
-/**
- * Sends a native EVM transaction
- */
-export const sendEVMTransaction = async (
-  toAddress: string,
-  amount: bigint,
-  fromAddress: string,
-  gasLimit?: number | null,
-  maxFeePerGas?: number | null,
-  maxPriorityFeePerGas?: number | null
-): Promise<string | Error> => {
-  try {
-    const activeRawProvider = getActiveRawProvider()
-    if (!activeRawProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    // Get current chain ID before transaction
-    const chainIdHex = await activeRawProvider.request({
-      method: 'eth_chainId'
-    })
-    const chainId = parseInt(chainIdHex, 16)
-
-    // Create a new provider instance for this transaction
-    const provider = new ethers.BrowserProvider(activeRawProvider)
-    const signer = await provider.getSigner(fromAddress)
-
-    // Verify we're still on the same network before proceeding
-    const network = await provider.getNetwork()
-    if (Number(network.chainId) !== chainId) {
-      throw new Error('Network changed during transaction setup')
-    }
-
-    try {
-      const tx = await signer.sendTransaction({
-        to: toAddress,
-        value: amount,
-        gasLimit: gasLimit ? BigInt(Math.floor(gasLimit)) : undefined,
-        maxFeePerGas: maxFeePerGas
-          ? BigInt(Math.floor(maxFeePerGas))
-          : undefined,
-        maxPriorityFeePerGas: maxPriorityFeePerGas
-          ? BigInt(Math.floor(maxPriorityFeePerGas))
-          : undefined
-      })
-
-      const receipt = await tx.wait()
-      return receipt ? receipt.hash : ''
-    } catch (txError: any) {
-      if (isUserRejection(txError)) {
-        return new Error('Transaction was rejected by user')
-      }
-      throw txError
-    }
-  } catch (error: any) {
-    console.error('Transaction error:', error)
-
-    if (isUserRejection(error)) {
-      return new Error('Transaction was rejected by user')
-    }
-
-    if (error.code === 'NETWORK_ERROR') {
-      return new Error('Network changed during transaction. Please try again.')
-    }
-
-    return error instanceof Error
-      ? error
-      : new Error('Failed to send transaction')
-  }
-}
-
-/**
- * Sends an EVM token transaction
- */
-export const sendEVMTokenTransaction = async (
-  contractAddress: string,
-  abi: ethers.InterfaceAbi,
-  functionName: string,
-  args: unknown[],
-  fromAddress: string
-): Promise<string | Error> => {
-  try {
-    const activeRawProvider = getActiveRawProvider()
-    if (!activeRawProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    const chainIdHex = await activeRawProvider.request({
-      method: 'eth_chainId'
-    })
-    const chainId = parseInt(chainIdHex, 16)
-
-    const provider = new ethers.BrowserProvider(activeRawProvider)
-    const signer = await provider.getSigner(fromAddress)
-
-    // Verify we're still on the same network before proceeding
-    const network = await provider.getNetwork()
-    if (Number(network.chainId) !== chainId) {
-      throw new Error('Network changed during transaction setup')
-    }
-
-    const contract = new ethers.Contract(contractAddress, abi, signer)
-    const txOptions: ethers.Overrides = {}
-
-    const gasLimit =
-      args?.[2] !== undefined ? toSafeNumber(args[2], 'gasLimit') : undefined
-    const maxFeePerGas =
-      args?.[3] !== undefined
-        ? toSafeNumber(args[3], 'maxFeePerGas')
-        : undefined
-    const maxPriorityFeePerGas =
-      args?.[4] !== undefined
-        ? toSafeNumber(args[4], 'maxPriorityFeePerGas')
-        : undefined
-
-    txOptions.gasLimit = gasLimit ? BigInt(Math.floor(gasLimit)) : undefined
-    txOptions.maxFeePerGas = maxFeePerGas
-      ? BigInt(Math.floor(maxFeePerGas))
-      : undefined
-    txOptions.maxPriorityFeePerGas = maxPriorityFeePerGas
-      ? BigInt(Math.floor(maxPriorityFeePerGas))
-      : undefined
-
-    try {
-      // Send the transaction
-      const tx = await contract[functionName](args[0], args[1], txOptions)
-
-      // Wait for transaction confirmation
-      const receipt = await tx.wait()
-      return receipt ? receipt.hash : ''
-    } catch (txError: any) {
-      if (isUserRejection(txError)) {
-        return new Error('Transaction was rejected by user')
-      }
-      throw txError
-    }
-  } catch (error: any) {
-    console.error('Token transaction error:', error)
-
-    if (isUserRejection(error)) {
-      return new Error('Transaction was rejected by user')
-    }
-
-    if (error.code === 'NETWORK_ERROR') {
-      return new Error('Network changed during transaction. Please try again.')
-    }
-
-    return error instanceof Error
-      ? error
-      : new Error('Failed to send token transaction')
-  }
-}
-
-/**
- * Sends an native smart contract transaction
- */
-export const sendNativeSmartContractTransaction = async (
-  contractAddress: string,
-  abi: ethers.InterfaceAbi,
-  functionName: string,
-  args: unknown[],
-  fromAddress: string,
-  value?: string
-): Promise<string | Error> => {
-  try {
-    const activeRawProvider = getActiveRawProvider()
-    if (!activeRawProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    const chainIdHex = await activeRawProvider.request({
-      method: 'eth_chainId'
-    })
-    const chainId = parseInt(chainIdHex, 16)
-
-    const provider = new ethers.BrowserProvider(activeRawProvider)
-    const signer = await provider.getSigner(fromAddress)
-
-    // Verify we're still on the same network before proceeding
-    const network = await provider.getNetwork()
-    if (Number(network.chainId) !== chainId) {
-      throw new Error('Network changed during transaction setup')
-    }
-
-    const contract = new ethers.Contract(contractAddress, abi, signer)
-    const txOptions: ethers.Overrides = {}
-
-    const gasLimit =
-      args?.[1] !== undefined ? toSafeNumber(args[1], 'gasLimit') : undefined
-    const maxFeePerGas =
-      args?.[2] !== undefined
-        ? toSafeNumber(args[2], 'maxFeePerGas')
-        : undefined
-    const maxPriorityFeePerGas =
-      args?.[3] !== undefined
-        ? toSafeNumber(args[3], 'maxPriorityFeePerGas')
-        : undefined
-
-    txOptions.gasLimit = gasLimit ? BigInt(Math.floor(gasLimit)) : undefined
-    txOptions.maxFeePerGas = maxFeePerGas
-      ? BigInt(Math.floor(maxFeePerGas))
-      : undefined
-    txOptions.maxPriorityFeePerGas = maxPriorityFeePerGas
-      ? BigInt(Math.floor(maxPriorityFeePerGas))
-      : undefined
-
-    if (value) {
-      txOptions.value = value
-    }
-
-    try {
-      // Send the transaction
-      const tx = await contract[functionName](args[0], txOptions)
-
-      // Wait for transaction confirmation
-      const receipt = await tx.wait()
-      return receipt ? receipt.hash : ''
-    } catch (txError: any) {
-      if (isUserRejection(txError)) {
-        return new Error('Transaction was rejected by user')
-      }
-      throw txError
-    }
-  } catch (error: any) {
-    console.error('Token transaction error:', error)
-
-    if (isUserRejection(error)) {
-      return new Error('Transaction was rejected by user')
-    }
-
-    if (error.code === 'NETWORK_ERROR') {
-      return new Error('Network changed during transaction. Please try again.')
-    }
-
-    return error instanceof Error
-      ? error
-      : new Error('Failed to send token transaction')
-  }
-}
-
-function toSafeNumber(value: unknown, name: string): number {
-  if (typeof value !== 'number' || Number.isNaN(value)) {
-    throw new TypeError(
-      `Invalid ${name}: expected a number, got ${typeof value} (${value})`
-    )
-  }
-  return value
-}
-
-/**
- * Sends a batch of EVM transactions
- */
-export const sendEVMTransactionBatch = async (params: {
-  version: string
-  from: string
-  chainId: string
-  atomicRequired: boolean
-  calls: {
-    to: string
-    value: string
-    data?: string
-  }[]
-}): Promise<string | Error> => {
-  try {
-    const activeRawProvider = getActiveRawProvider()
-    if (!activeRawProvider) {
-      throw new Error('No active EVM provider')
-    }
-
-    const provider = new ethers.BrowserProvider(activeRawProvider)
-
-    try {
-      // Send the transaction batch
-      const response: { id: `0x${string}` } = await provider.send(
-        'wallet_sendCalls',
-        [params]
-      )
-
-      // Wait for transaction confirmation
-      let result: {
-        chainId: `0x${string}`
-        id: `0x${string}`
-        status: number
-        atomic: boolean
-        receipts: [
-          {
-            transactionHash: `0x${string}`
-          }
-        ]
-      }
-      do {
-        result = await provider.send('wallet_getCallsStatus', [response.id])
-
-        // wait 1 second if receipt is not yet available
-        if (result.status == 100) {
-          await new Promise(resolve => setTimeout(resolve, 1000))
-        }
-      } while (result.status == 100)
-
-      return result?.status != 200
-        ? new Error('Failed to send batched transactions')
-        : result.receipts.find(x => x)?.transactionHash ??
-            new Error('Failed to get batched transactions receipt')
-    } catch (txError: any) {
-      if (isUserRejection(txError)) {
-        return new Error('Transaction was rejected by user')
-      }
-      throw txError
-    }
-  } catch (error: any) {
-    console.error('Token transaction error:', error)
-
-    if (isUserRejection(error)) {
-      return new Error('Transaction was rejected by user')
-    }
-
-    if (error.code === 'NETWORK_ERROR') {
-      return new Error('Network changed during transaction. Please try again.')
-    }
-
-    return error instanceof Error
-      ? error
-      : new Error('Failed to send token transaction')
-  }
-}
-
-export const getWalletCapabilities = async (from: string, chainId: string) => {
-  const activeRawProvider = getActiveRawProvider()
-  if (!activeRawProvider) {
-    throw new Error('No active EVM provider')
-  }
-  const provider = new ethers.BrowserProvider(activeRawProvider)
-
-  const capabilities = await provider.send('wallet_getCapabilities', [
-    from,
-    [chainId]
-  ])
-  return capabilities[chainId]
-}

package/src/utils/connectors/evm/types.ts

@@ -1,63 +0,0 @@
-import { ethers, Eip1193Provider } from 'ethers'
-
-export interface EVMConnectResult {
-  accounts: string[]
-  chainId: number
-  isConnected: boolean
-}
-
-export interface EVMProvider extends ethers.Eip1193Provider {
-  on(event: string, listener: (...args: any[]) => void): void
-  removeListener(event: string, listener: (...args: any[]) => void): void
-  removeAllListeners(): void
-  [key: string]: any
-}
-
-export interface InjectedProviderInfo {
-  name: string
-  id: string
-  icon?: string
-  injectedData: {
-    provider: EVMProvider
-    [key: string]: any
-  }
-}
-
-export interface ChainConfig {
-  name: string
-  nativeCurrency: {
-    decimals: number
-    name: string
-    symbol: string
-  }
-  rpcUrls: {
-    default: { http: string[] }
-  }
-  blockExplorers: {
-    default: {
-      name: string
-      url: string
-    }
-  }
-}
-
-export interface EIP6963ProviderInfo {
-  uuid: string
-  name: string
-  icon?: string
-  rdns?: string
-}
-
-export interface EIP6963ProviderDetail {
-  info: EIP6963ProviderInfo
-  provider: Eip1193Provider
-}
-
-export interface EIP6963AnnounceProviderEvent extends CustomEvent {
-  type: 'eip6963:announceProvider'
-  detail: EIP6963ProviderDetail
-}
-
-export interface EIP6963RequestProviderEvent extends Event {
-  type: 'eip6963:requestProvider'
-}