@meshconnect/web-link-sdk 3.2.15 → 3.3.0

package/src/Link.ts

@@ -1,491 +0,0 @@
-import {
-  LinkOptions,
-  Link,
-  EventType,
-  AccessTokenPayload,
-  DelayedAuthPayload,
-  TransferFinishedPayload,
-  LinkPayload,
-  WalletBrowserPayload,
-  SignRequestPayload,
-  ChainSwitchPayload,
-  TransferPayload,
-  SmartContractPayload,
-  DisconnectPayload,
-  TransactionBatchPayload,
-  WalletCapabilitiesPayload,
-  SolanaTransferWithInstructionsPayload
-} from './utils/types'
-import { addPopup, iframeId, removePopup } from './utils/popup'
-import { LinkEventType, isLinkEventTypeKey } from './utils/event-types'
-import {
-  WalletBrowserEventType,
-  isWalletBrowserEventTypeKey
-} from './utils/wallet-browser-event-types'
-import { sdkSpecs } from './utils/sdk-specs'
-import { WalletStrategyFactory, NetworkType } from './utils/wallet'
-
-let currentOptions: LinkOptions | undefined
-let targetOrigin: string | undefined
-let linkTokenOrigin: string | undefined
-let currentIframeId = iframeId
-
-const iframeElement = () => {
-  return document.getElementById(currentIframeId) as HTMLIFrameElement
-}
-
-function sendMessageToIframe<T extends { type: string }>(message: T) {
-  const iframe = iframeElement()
-  if (!iframe) {
-    console.warn(
-      `Mesh SDK: Failed to deliver ${message.type} message to the iframe - no iframe element found`
-    )
-    return
-  }
-  if (!linkTokenOrigin) {
-    console.warn(
-      `Mesh SDK: Failed to deliver ${message.type} message to the iframe - no link token origin found`
-    )
-    return
-  }
-  try {
-    iframe.contentWindow?.postMessage(message, linkTokenOrigin)
-  } catch (e) {
-    console.error(
-      `Mesh SDK: Failed to deliver ${message.type} message to the iframe`
-    )
-    console.error(e)
-  }
-}
-
-async function handleLinkEvent(
-  event:
-    | MessageEvent<{
-        type: EventType
-        payload?:
-          | AccessTokenPayload
-          | DelayedAuthPayload
-          | TransferFinishedPayload
-        link?: string
-      }>
-    | MessageEvent<LinkEventType>
-) {
-  switch (event.data.type) {
-    case 'brokerageAccountAccessToken': {
-      const payload: LinkPayload = {
-        accessToken: event.data.payload as AccessTokenPayload
-      }
-      currentOptions?.onEvent?.({
-        type: 'integrationConnected',
-        payload: payload
-      })
-      currentOptions?.onIntegrationConnected?.(payload)
-      break
-    }
-    case 'delayedAuthentication': {
-      const payload: LinkPayload = {
-        delayedAuth: event.data.payload as DelayedAuthPayload
-      }
-      currentOptions?.onEvent?.({
-        type: 'integrationConnected',
-        payload: payload
-      })
-      currentOptions?.onIntegrationConnected?.(payload)
-      break
-    }
-    case 'transferFinished': {
-      const payload = event.data.payload as TransferFinishedPayload
-
-      currentOptions?.onEvent?.({
-        type: 'transferCompleted',
-        payload: payload
-      })
-      currentOptions?.onTransferFinished?.(payload)
-      break
-    }
-    case 'close':
-    case 'done': {
-      const payload = event.data?.payload
-      currentOptions?.onExit?.(payload?.errorMessage, payload)
-      removePopup()
-      break
-    }
-    case 'loaded': {
-      sendMessageToIframe({
-        type: 'meshSDKSpecs',
-        payload: { ...sdkSpecs }
-      })
-
-      // Get all providers using the wallet factory
-      const walletFactory = WalletStrategyFactory.getInstance()
-      const allProviders = walletFactory.getAllProviders()
-
-      sendMessageToIframe({
-        type: 'SDKinjectedWalletProviders',
-        payload: allProviders
-      })
-
-      if (currentOptions?.accessTokens) {
-        sendMessageToIframe({
-          type: 'frontAccessTokens',
-          payload: currentOptions.accessTokens
-        })
-      }
-      if (currentOptions?.transferDestinationTokens) {
-        sendMessageToIframe({
-          type: 'frontTransferDestinationTokens',
-          payload: currentOptions.transferDestinationTokens
-        })
-      }
-      currentOptions?.onEvent?.({ type: 'pageLoaded' })
-      break
-    }
-    default: {
-      if (isLinkEventTypeKey(event.data.type)) {
-        currentOptions?.onEvent?.(event.data)
-      }
-      break
-    }
-  }
-}
-
-async function handleWalletBrowserEvent(
-  event: MessageEvent<WalletBrowserEventType>
-) {
-  const walletFactory = WalletStrategyFactory.getInstance()
-  switch (event.data.type) {
-    case 'walletBrowserInjectedWalletSelected': {
-      const payload = event.data.payload as WalletBrowserPayload
-      try {
-        const networkType = (
-          payload.networkType?.includes('solana') ? 'solana' : 'evm'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-
-        const result = await strategy.connect(payload)
-
-        sendMessageToIframe({
-          type: 'SDKinjectedConnectionCompleted',
-          payload: {
-            accounts: result.accounts,
-            chainId: result.chainId,
-            networkType: networkType
-          }
-        })
-      } catch (error) {
-        console.error('Connection error:', error)
-        handleErrorAndSendMessage(
-          error as Error,
-          'SDKinjectedConnectionCompleted'
-        )
-      }
-      break
-    }
-    case 'walletBrowserSignRequest': {
-      const payload = event.data.payload as SignRequestPayload
-      try {
-        const networkType = (
-          !payload.address.startsWith('0x') ? 'solana' : 'evm'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-
-        const result = await strategy.signMessage(payload)
-
-        sendMessageToIframe({
-          type: 'SDKsignRequestCompleted',
-          payload: result
-        })
-      } catch (error) {
-        handleErrorAndSendMessage(error as Error, 'SDKsignRequestCompleted')
-      }
-      break
-    }
-    case 'walletBrowserChainSwitchRequest': {
-      const payload = event.data.payload as ChainSwitchPayload
-      try {
-        const networkType = (
-          payload.networkType === 'solana' ? 'solana' : 'evm'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-
-        const result = await strategy.switchChain(payload)
-
-        sendMessageToIframe({
-          type: 'SDKswitchChainCompleted',
-          payload: {
-            chainId: result.chainId,
-            accounts: result.accounts,
-            networkType: networkType
-          }
-        })
-      } catch (error) {
-        console.error('Chain switch failed:', error)
-        handleErrorAndSendMessage(error as Error, 'SDKswitchChainCompleted')
-      }
-      break
-    }
-    case 'walletBrowserNativeTransferRequest': {
-      const payload = event.data.payload as TransferPayload
-      try {
-        const networkType = (
-          payload.network === 'solana' ? 'solana' : 'evm'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-
-        const result = await strategy.sendNativeTransfer(payload)
-
-        sendMessageToIframe({
-          type: 'SDKnativeTransferCompleted',
-          payload: result
-        })
-      } catch (error) {
-        handleErrorAndSendMessage(error as Error, 'SDKnativeTransferCompleted')
-      }
-      break
-    }
-    case 'walletBrowserNonNativeTransferRequest':
-    case 'walletBrowserNonNativeSmartDeposit': {
-      const payload = event.data.payload as SmartContractPayload
-      const getResponseType = (type: WalletBrowserEventType['type']) => {
-        switch (type) {
-          case 'walletBrowserNonNativeTransferRequest':
-            return 'SDKnonNativeTransferCompleted'
-          case 'walletBrowserNativeSmartDeposit':
-            return 'SDKnativeSmartDepositCompleted'
-          case 'walletBrowserNonNativeSmartDeposit':
-            return 'SDKnonNativeSmartDepositCompleted'
-          default:
-            return 'SDKnonNativeTransferCompleted'
-        }
-      }
-
-      try {
-        const networkType = (
-          payload.address.startsWith('0x') ? 'evm' : 'solana'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-        const result = await strategy.sendSmartContractInteraction(payload)
-
-        const responseType = getResponseType(event.data.type)
-
-        sendMessageToIframe({
-          type: responseType,
-          payload: {
-            txHash: result
-          }
-        })
-      } catch (error) {
-        const errorType = getResponseType(event.data.type)
-        handleErrorAndSendMessage(error as Error, errorType)
-      }
-      break
-    }
-    case 'walletBrowserNativeSmartDeposit': {
-      const payload = event.data.payload as SmartContractPayload
-      const getResponseType = (type: WalletBrowserEventType['type']) => {
-        switch (type) {
-          case 'walletBrowserNonNativeTransferRequest':
-            return 'SDKnonNativeTransferCompleted'
-          case 'walletBrowserNativeSmartDeposit':
-            return 'SDKnativeSmartDepositCompleted'
-          case 'walletBrowserNonNativeSmartDeposit':
-            return 'SDKnonNativeSmartDepositCompleted'
-          default:
-            return 'SDKnonNativeTransferCompleted'
-        }
-      }
-
-      try {
-        const networkType = (
-          payload.address.startsWith('0x') ? 'evm' : 'solana'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-        const result = await strategy.sendNativeSmartContractInteraction(
-          payload
-        )
-
-        const responseType = getResponseType(event.data.type)
-
-        sendMessageToIframe({
-          type: responseType,
-          payload: {
-            txHash: result
-          }
-        })
-      } catch (error) {
-        const errorType = getResponseType(event.data.type)
-        handleErrorAndSendMessage(error as Error, errorType)
-      }
-      break
-    }
-    case 'walletBrowserTransactionBatchRequest': {
-      const payload = event.data.payload as TransactionBatchPayload
-      const responseType = 'SDKtransactionBatchCompleted'
-
-      try {
-        const networkType = (
-          payload.from.startsWith('0x') ? 'evm' : 'solana'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-        const result = await strategy.sendTransactionBatch(payload)
-
-        sendMessageToIframe({
-          type: responseType,
-          payload: {
-            txHash: result
-          }
-        })
-      } catch (error) {
-        handleErrorAndSendMessage(error as Error, responseType)
-      }
-      break
-    }
-    case 'walletBrowserWalletCapabilities': {
-      const payload = event.data.payload as WalletCapabilitiesPayload
-      const responseType = 'SDKwalletCapabilitiesCompleted'
-      try {
-        const networkType = (
-          payload.from.startsWith('0x') ? 'evm' : 'solana'
-        ) as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-        const result = await strategy.getWalletCapabilities(payload)
-
-        sendMessageToIframe({
-          type: responseType,
-          payload: result
-        })
-      } catch (error) {
-        handleErrorAndSendMessage(error as Error, responseType)
-      }
-      break
-      break
-    }
-    case 'walletBrowserDisconnect': {
-      const payload = event.data.payload as DisconnectPayload
-
-      try {
-        if (payload?.networkType) {
-          const networkType = (
-            payload.networkType === 'solana' ? 'solana' : 'evm'
-          ) as NetworkType
-          const strategy = walletFactory.getStrategy(networkType)
-          await strategy.disconnect(payload)
-        } else {
-          // Disconnect from all if no specific network type
-          await Promise.all([
-            walletFactory.getStrategy('solana').disconnect(payload),
-            walletFactory.getStrategy('evm').disconnect(payload)
-          ])
-        }
-
-        sendMessageToIframe({
-          type: 'SDKdisconnectSuccess'
-        })
-      } catch (error) {
-        console.error('Error during disconnect:', error)
-        handleErrorAndSendMessage(error as Error, 'SDKdisconnectSuccess')
-      }
-      break
-    }
-    case 'walletBrowserSolanaTransferWithInstructionsRequest': {
-      const payload = event.data
-        .payload as SolanaTransferWithInstructionsPayload
-
-      try {
-        const networkType = 'solana' as NetworkType
-        const strategy = walletFactory.getStrategy(networkType)
-        const result = await strategy.sendTransactionWithInstructions(payload)
-        sendMessageToIframe({
-          type: 'SDKnonNativeTransferCompleted',
-          payload: {
-            txHash: result
-          }
-        })
-      } catch (error) {
-        handleErrorAndSendMessage(error as Error, 'SDKdisconnectSuccess')
-      }
-      break
-    }
-  }
-}
-
-async function eventsListener(
-  event: MessageEvent<
-    LinkEventType | WalletBrowserEventType | { type: EventType }
-  >
-) {
-  if (event.origin !== targetOrigin && event.origin !== linkTokenOrigin) {
-    console.warn('Received message from untrusted origin:', event.origin)
-  } else if (isWalletBrowserEventTypeKey(event.data.type)) {
-    await handleWalletBrowserEvent(
-      event as MessageEvent<WalletBrowserEventType>
-    )
-  } else {
-    await handleLinkEvent(event as MessageEvent<{ type: EventType }>)
-  }
-}
-
-function handleErrorAndSendMessage(error: Error, messageType: string) {
-  sendMessageToIframe({
-    type: messageType,
-    payload: {
-      error: error
-    }
-  })
-}
-
-export const createLink = (options: LinkOptions): Link => {
-  const openLink = (linkToken: string, customIframeId?: string) => {
-    if (!linkToken) {
-      options?.onExit?.('Invalid link token!')
-      return
-    }
-
-    currentOptions = options
-    let linkUrl = window.atob(linkToken)
-    linkUrl = addLanguage(linkUrl, currentOptions?.language)
-    linkTokenOrigin = new URL(linkUrl).origin
-    window.removeEventListener('message', eventsListener)
-    if (customIframeId) {
-      const iframe = document.getElementById(
-        customIframeId
-      ) as HTMLIFrameElement
-      if (iframe) {
-        iframe.allow = 'clipboard-read *; clipboard-write *'
-        iframe.src = linkUrl
-        currentIframeId = customIframeId
-      } else {
-        console.warn(`Mesh SDK: No iframe found with id ${customIframeId}`)
-      }
-    } else {
-      currentIframeId = iframeId
-      addPopup(linkUrl)
-    }
-
-    window.addEventListener('message', eventsListener)
-
-    targetOrigin = window.location.origin
-  }
-
-  const closeLink = () => {
-    removePopup()
-    window.removeEventListener('message', eventsListener)
-    options.onExit?.()
-  }
-
-  return {
-    openLink: openLink,
-    closeLink: closeLink
-  }
-}
-
-function addLanguage(linkUrl: string, language: string | undefined) {
-  if (language === 'system') {
-    language =
-      typeof navigator !== 'undefined' && navigator.language
-        ? encodeURIComponent(navigator.language)
-        : undefined
-  }
-
-  return `${linkUrl}${linkUrl.includes('?') ? '&' : '?'}lng=${language || 'en'}`
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './utils/types'
-export * from './utils/event-types'
-export { createLink } from './Link'

package/src/utils/__snapshots__/popup.test.ts.snap

@@ -1,89 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`Popup tests addPopup should add correct popup 1`] = `
-<style
-  id="mesh-link-popup__styles"
->
-  
-  body {
-    position: fixed;
-    left: 0;
-    top: 0;
-    bottom: 0;
-    right: 0;
-    overflow: hidden;
-  }
-
-  #mesh-link-popup {
-    all: unset;
-    position: fixed;
-    left: 0;
-    top: 0;
-    bottom: 0;
-    right: 0;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    z-index: 10000;
-  }
-
-  #mesh-link-popup__backdrop {
-    position: absolute;
-    left: 0;
-    top: 0;
-    bottom: 0;
-    right: 0;
-    z-index: 10000;
-    background: black;
-    opacity: 0.8;
-  }
-
-  #mesh-link-popup__popup-content {
-    position: absolute;
-    height: 80%;
-    max-height: 710px;
-    min-height: 685px;
-    margin: auto;
-    z-index: 10001;
-    width: 30%;
-    max-width: 430px;
-    min-width: 380px;
-    display: flex;
-    flex-direction: column;
-    border-radius: 2px;
-    flex-grow: 1;
-  }
-
-  #mesh-link-popup__popup-content iframe {
-    border: none;
-    width: 100%;
-    flex-grow: 1;
-    border-radius: 2px;
-  }
-
-  @media only screen and (max-width: 768px) {
-    #mesh-link-popup__popup-content {
-      height: 100vh;
-      width: 100vw;
-      max-width: 100%;
-      min-width: 100%;
-      max-height: 100%;
-      min-height: 100%;
-      border-radius: 0px;
-    }
-
-    #mesh-link-popup__popup-content iframe {
-      border-radius: 0px;
-    }
-  }
-
-  @media only screen and (max-height: 710px) {
-    #mesh-link-popup__popup-content {
-      max-height: 100%;
-      min-height: 100%;
-    }
-  }
-
-</style>
-`;

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

@@ -1,120 +0,0 @@
-import { ChainConfig } from './types'
-
-// Chain configurations
-const chainConfigs: Record<number, ChainConfig> = {
-  43114: {
-    // Avalanche
-    name: 'Avalanche',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'Avalanche',
-      symbol: 'AVAX'
-    },
-    rpcUrls: {
-      default: { http: ['https://avalanche-mainnet.infura.io'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'SnowTrace',
-        url: 'https://snowtrace.io'
-      }
-    }
-  },
-  42161: {
-    // Arbitrum
-    name: 'Arbitrum One',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'Ether',
-      symbol: 'ETH'
-    },
-    rpcUrls: {
-      default: { http: ['https://arb1.arbitrum.io/rpc'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'Arbiscan',
-        url: 'https://arbiscan.io'
-      }
-    }
-  },
-  10: {
-    // Optimism
-    name: 'OP Mainnet',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'Ether',
-      symbol: 'ETH'
-    },
-    rpcUrls: {
-      default: { http: ['https://mainnet.optimism.io'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'Optimism Explorer',
-        url: 'https://optimistic.etherscan.io'
-      }
-    }
-  },
-  8453: {
-    // Base
-    name: 'Base',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'Ether',
-      symbol: 'ETH'
-    },
-    rpcUrls: {
-      default: { http: ['https://mainnet.base.org'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'Basescan',
-        url: 'https://basescan.org'
-      }
-    }
-  },
-  137: {
-    // Polygon
-    name: 'Polygon',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'MATIC',
-      symbol: 'MATIC'
-    },
-    rpcUrls: {
-      default: { http: ['https://polygon-rpc.com'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'PolygonScan',
-        url: 'https://polygonscan.com'
-      }
-    }
-  },
-  56: {
-    // BSC
-    name: 'BNB Smart Chain',
-    nativeCurrency: {
-      decimals: 18,
-      name: 'BNB',
-      symbol: 'BNB'
-    },
-    rpcUrls: {
-      default: { http: ['https://rpc.ankr.com/bsc'] }
-    },
-    blockExplorers: {
-      default: {
-        name: 'BscScan',
-        url: 'https://bscscan.com'
-      }
-    }
-  }
-}
-
-// Helper function to get chain configuration
-export const getChainConfiguration = (
-  chainId: number
-): ChainConfig | undefined => {
-  return chainConfigs[chainId]
-}