@meshconnect/web-link-sdk 3.2.15 → 3.3.0

package/src/utils/types.ts

@@ -1,270 +0,0 @@
-import type { BrokerType } from '@meshconnect/node-api'
-import { SessionSummary, LinkEventType } from './event-types'
-
-export type EventType =
-  | 'brokerageAccountAccessToken'
-  | 'delayedAuthentication'
-  | 'loaded'
-  | 'transferFinished'
-
-export interface Link {
-  /**
-   * A function that takes linkToken parameter from `/api/v1/linktoken` endpoint as an input, and opens the Link UI popup
-   * @param linkToken - Base64 encoded link token from the `/api/v1/linktoken` endpoint
-   * @param customIframeId - Optional custom ID for the existing iframe element. If not provided, a new iframe element will be created
-   */
-  openLink: (linkToken: string, customIframeId?: string) => void
-  /**
-   * A function to close Link UI popup
-   */
-  closeLink: () => void
-}
-
-export interface AccountToken {
-  account: Account
-  accessToken: string
-  refreshToken?: string
-  tokenId?: string
-}
-
-export interface Account {
-  accountId: string
-  accountName: string
-  fund?: number
-  cash?: number
-  isReconnected?: boolean
-}
-
-/**
- * Integration brand information
- */
-export interface BrandInfo {
-  /**
-   * Integration logo in base 64 format
-   */
-  brokerLogo: string
-  /**
-   * Integration logo URL (obsolete, use `logoLightUrl` instead)
-   */
-  brokerLogoUrl?: string
-  /**
-   * Integration logo URL for light theme
-   */
-  logoLightUrl?: string
-  /**
-   * Integration logo URL for dark theme
-   */
-  logoDarkUrl?: string
-  /**
-   * Integration icon URL for light theme
-   */
-  iconLightUrl?: string
-  /**
-   * Integration icon URL for dark theme
-   */
-  iconDarkUrl?: string
-}
-
-export interface LinkPayload {
-  accessToken?: AccessTokenPayload
-  delayedAuth?: DelayedAuthPayload
-}
-
-export interface AccessTokenPayload {
-  accountTokens: AccountToken[]
-  brokerBrandInfo: BrandInfo
-  expiresInSeconds?: number
-  refreshTokenExpiresInSeconds?: number
-  brokerType: BrokerType
-  brokerName: string
-}
-
-export interface DelayedAuthPayload {
-  refreshTokenExpiresInSeconds?: number
-  brokerType: BrokerType
-  refreshToken: string
-  brokerName: string
-  brokerBrandInfo: BrandInfo
-}
-
-export interface TransferFinishedPayload {
-  status: 'success'
-  txId: string
-  fromAddress: string
-  toAddress: string
-  symbol: string
-  amount: number
-  networkId: string
-  amountInFiat?: number
-  totalAmountInFiat?: number
-  networkName?: string
-  txHash?: string
-  transferId?: string
-  refundAddress?: string
-}
-
-export interface IntegrationAccessToken {
-  accountId: string
-  accountName: string
-  accessToken: string
-  brokerType: BrokerType
-  brokerName: string
-}
-
-// payloads from Link
-export interface WalletBrowserPayload {
-  networkType?: string
-  integrationName: string
-  targetChainId?: string
-  walletName?: string
-}
-
-export interface SignRequestPayload {
-  address: string
-  message: string
-  walletName?: string
-}
-
-export interface ChainSwitchPayload {
-  chainId: number
-  networkType?: string
-  walletName?: string
-}
-
-export interface TransferPayload {
-  toAddress: string
-  amount: number
-  decimalPlaces: number
-  chainId: number
-  account: string
-  network: string
-  blockhash?: string
-  walletName?: string
-  gasLimit?: number | null
-  maxFeePerGas?: number | null
-  maxPriorityFeePerGas?: number | null
-}
-
-export interface SmartContractPayload {
-  address: string
-  abi: string
-  functionName: string
-  args: unknown[]
-  account: string
-  value?: string
-  walletName?: string
-  tokenProgram?: string
-  blockhash?: string
-  createATA?: boolean
-  gasLimit?: number | null
-  maxFeePerGas?: number | null
-  maxPriorityFeePerGas?: number | null
-}
-
-export interface TransactionBatchPayload {
-  version: string
-  from: string
-  chainId: string
-  atomicRequired: boolean
-  calls: {
-    to: string
-    value: string
-    data?: string
-  }[]
-}
-
-export interface WalletCapabilitiesPayload {
-  from: string
-  chainId: string
-}
-
-export interface DisconnectPayload {
-  networkType?: string
-  walletName?: string
-}
-
-export interface AddressLookupTableStateDto {
-  deactivationSlot: bigint
-  lastExtendedSlot: number
-  lastExtendedStartIndex: number
-  key: string
-  authority?: string
-  addresses: string[]
-}
-
-export interface SolanaTransferWithInstructionsPayload {
-  transactionInstructions: {
-    states: AddressLookupTableStateDto[]
-    instructions: TransactionInstructionDto[]
-    account: string
-    blockhash: string
-    walletName?: string
-    network?: string
-  }
-  transferConfig: SmartContractPayload
-}
-
-export interface SolanaAccountMeta {
-  shouldFillPubkey: boolean
-  pubKey: string | null
-  isWritable: boolean
-  isSigner: boolean
-}
-
-export interface TransactionInstructionDto {
-  programId: string
-  accounts: SolanaAccountMeta[]
-  data: string
-}
-
-export interface LinkOptions {
-  /**
-   * Client ID that can be obtained at https://dashboard.meshconnect.com/company/keys
-   */
-  clientId?: string
-
-  /**
-   * A callback function that is called when an integration is successfully connected.
-   * It receives a payload of type `LinkPayload`.
-   */
-  onIntegrationConnected: (payload: LinkPayload) => void
-
-  /**
-   * (Optional) A callback function that is called when the Front iframe is closed.
-   */
-  onExit?: (error?: string, summary?: SessionSummary) => void
-
-  /**
-   * (Optional) A callback function that is called when a transfer is finished.
-   * It receives a payload of type `TransferFinishedPayload`.
-   */
-  onTransferFinished?: (payload: TransferFinishedPayload) => void
-
-  /**
-   * (Optional) A callback function that is called when various events occur within the Front iframe.
-   * It receives an object with type `LinkEventTypeKeys` indicating the event, and an optional 'payload' containing additional data.
-   */
-  onEvent?: (event: LinkEventType) => void
-
-  /**
-   * (Optional) An array of integration access tokens.
-   * These access tokens are used to initialize crypto transfers flow at 'Select asset step'
-   */
-  accessTokens?: IntegrationAccessToken[]
-
-  /**
-   * (Optional) An array of integration access tokens.
-   * Can be used to initialize the crypto transfers flow as an alternative to the target addresses.
-   */
-  transferDestinationTokens?: IntegrationAccessToken[]
-
-  /**
-   * Link UI language. Supported: 'en', 'ru'. Can be set as 'en-US', 'ru-RU', etc.
-   */
-  language?: string
-}
-
-export interface LinkStyle {
-  ir: number
-  io: number
-}

package/src/utils/version.ts

@@ -1 +0,0 @@
-export const sdkVersion = '3.2.15'

package/src/utils/wallet/EVMWalletStrategy.ts

@@ -1,176 +0,0 @@
-import { BaseWalletStrategy } from './WalletStrategy'
-import {
-  WalletBrowserPayload,
-  SignRequestPayload,
-  ChainSwitchPayload,
-  TransferPayload,
-  SmartContractPayload,
-  DisconnectPayload,
-  TransactionBatchPayload,
-  WalletCapabilitiesPayload
-} from '../types'
-import {
-  connectToEVMWallet,
-  disconnectFromEVMWallet,
-  signEVMMessage,
-  sendEVMTransaction,
-  sendEVMTokenTransaction,
-  sendNativeSmartContractTransaction,
-  switchEVMChain,
-  findAvailableProviders,
-  sendEVMTransactionBatch,
-  getWalletCapabilities
-} from '../connectors/evm'
-
-export class EVMWalletStrategy extends BaseWalletStrategy {
-  sendTransactionWithInstructions(): Promise<string> {
-    throw new Error('Method not implemented.')
-  }
-  async connect(payload: WalletBrowserPayload) {
-    try {
-      const result = await connectToEVMWallet(
-        payload.integrationName,
-        payload.targetChainId ? parseInt(payload.targetChainId, 10) : undefined
-      )
-
-      if (result instanceof Error) {
-        throw result
-      }
-
-      return {
-        accounts: result.accounts,
-        chainId: result.chainId,
-        isConnected: result.isConnected
-      }
-    } catch (error) {
-      throw this.handleError(error, 'connect to EVM wallet')
-    }
-  }
-
-  async disconnect(payload: DisconnectPayload) {
-    try {
-      const result = await disconnectFromEVMWallet(
-        payload.walletName || 'Unknown Wallet'
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-    } catch (error) {
-      throw this.handleError(error, 'disconnect from EVM wallet')
-    }
-  }
-
-  async signMessage(payload: SignRequestPayload) {
-    try {
-      const result = await signEVMMessage(
-        payload.walletName || 'Unknown Wallet',
-        payload.address,
-        payload.message
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'sign EVM message')
-    }
-  }
-
-  async switchChain(payload: ChainSwitchPayload) {
-    try {
-      const result = await switchEVMChain(payload.chainId)
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'switch EVM chain')
-    }
-  }
-
-  async sendNativeTransfer(payload: TransferPayload) {
-    try {
-      const result = await sendEVMTransaction(
-        payload.toAddress,
-        BigInt(payload.amount * Math.pow(10, payload.decimalPlaces)),
-        payload.account,
-        payload.gasLimit,
-        payload.maxFeePerGas,
-        payload.maxPriorityFeePerGas
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'send EVM native transfer')
-    }
-  }
-
-  async sendSmartContractInteraction(payload: SmartContractPayload) {
-    try {
-      const result = await sendEVMTokenTransaction(
-        payload.address,
-        JSON.parse(payload.abi),
-        payload.functionName,
-        payload.args,
-        payload.account
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'send EVM smart contract interaction')
-    }
-  }
-
-  async sendNativeSmartContractInteraction(
-    payload: SmartContractPayload
-  ): Promise<string> {
-    try {
-      const result = await sendNativeSmartContractTransaction(
-        payload.address,
-        JSON.parse(payload.abi),
-        payload.functionName,
-        payload.args,
-        payload.account,
-        payload.value
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'send EVM smart contract interaction')
-    }
-  }
-
-  async sendTransactionBatch(payload: TransactionBatchPayload) {
-    try {
-      const result = await sendEVMTransactionBatch(payload)
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'send EVM smart contract interaction')
-    }
-  }
-
-  async getWalletCapabilities(
-    payload: WalletCapabilitiesPayload
-  ): Promise<{ atomic: { status: string } }> {
-    const result = await getWalletCapabilities(payload.from, payload.chainId)
-    return result
-  }
-
-  getProviders() {
-    return findAvailableProviders().map(provider => ({
-      icon: provider.icon,
-      id: provider.id,
-      name: provider.name,
-      type: 'evm'
-    }))
-  }
-}

package/src/utils/wallet/SolanaWalletStrategy.ts

@@ -1,207 +0,0 @@
-import { BaseWalletStrategy } from './WalletStrategy'
-import {
-  WalletBrowserPayload,
-  SignRequestPayload,
-  ChainSwitchPayload,
-  TransferPayload,
-  SmartContractPayload,
-  DisconnectPayload,
-  SolanaTransferWithInstructionsPayload
-} from '../types'
-import {
-  connectToSolanaWallet,
-  disconnectFromSolanaWallet,
-  signSolanaMessage,
-  sendSOLTransaction,
-  findAvailableSolanaProviders,
-  getSolanaProvider,
-  sendSOLTransactionWithInstructions
-} from '../connectors/solana'
-
-export class SolanaWalletStrategy extends BaseWalletStrategy {
-  async connect(payload: WalletBrowserPayload) {
-    try {
-      const result = await connectToSolanaWallet(payload)
-      if (result instanceof Error) {
-        throw result
-      }
-      return {
-        accounts: result.accounts,
-        chainId: result.chainId,
-        isConnected: result.isConnected
-      }
-    } catch (error) {
-      throw this.handleError(error, 'connect to Solana wallet')
-    }
-  }
-
-  async disconnect(payload: DisconnectPayload) {
-    try {
-      const result = await disconnectFromSolanaWallet(
-        payload.walletName || 'Unknown Wallet'
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-    } catch (error) {
-      throw this.handleError(error, 'disconnect from Solana wallet')
-    }
-  }
-
-  async signMessage(payload: SignRequestPayload) {
-    try {
-      const result = await signSolanaMessage(
-        payload.walletName || 'Unknown Wallet',
-        payload.message
-      )
-      if (result instanceof Error) {
-        throw result
-      }
-      return result
-    } catch (error) {
-      throw this.handleError(error, 'sign Solana message')
-    }
-  }
-
-  /**
-   * Handles chain switching for Solana networks
-   * Supports both mainnet (101) and devnet (103)
-   */
-  async switchChain(payload: ChainSwitchPayload): Promise<{
-    chainId: string
-    accounts: string[]
-  }> {
-    // Check if the requested chainId is for Solana Devnet (103)
-    if (payload.chainId === 103) {
-      return {
-        chainId: '103',
-        accounts: []
-      }
-    }
-    
-    // Default to mainnet (101) for all other cases
-    return {
-      chainId: '101',
-      accounts: []
-    }
-  }
-
-  async sendNativeTransfer(payload: TransferPayload) {
-    try {
-      const result = await sendSOLTransaction({
-        toAddress: payload.toAddress,
-        amount: BigInt(payload.amount * Math.pow(10, payload.decimalPlaces)),
-        fromAddress: payload.account,
-        blockhash: payload.blockhash || '',
-        walletName: payload.walletName || ''
-      })
-
-      if (typeof result === 'string') {
-        return result
-      }
-      throw result
-    } catch (error) {
-      throw this.handleError(error, 'send Solana native transfer')
-    }
-  }
-
-  async sendSmartContractInteraction(
-    payload: SmartContractPayload
-  ): Promise<string> {
-    // Get the sender's address from the connected wallet if not provided
-    const provider = getSolanaProvider(payload.walletName || '')
-    const senderAddress =
-      payload.account || (await provider.publicKey?.toString())
-
-    if (!senderAddress) {
-      throw new Error('Sender account address is required')
-    }
-
-    // Convert the amount to the correct scale based on token decimals
-    const decimals = (payload.args[2] as number) || 9
-    const rawAmount = payload.args[1] as bigint
-    const scaledAmount = rawAmount
-
-    if (!payload.blockhash) {
-      throw new Error('Blockhash is required for Solana transactions')
-    }
-
-    return await sendSOLTransaction({
-      toAddress: payload.args[0] as string,
-      amount: scaledAmount,
-      fromAddress: senderAddress,
-      blockhash: payload.blockhash,
-      walletName: payload.walletName || '',
-      tokenMint: payload.address,
-      createATA: payload.createATA || false,
-      tokenProgram: payload.tokenProgram,
-      tokenDecimals: decimals
-    })
-  }
-
-  async sendTransactionWithInstructions(
-    payload: SolanaTransferWithInstructionsPayload
-  ): Promise<string> {
-    const provider = getSolanaProvider(
-      payload.transactionInstructions.walletName || ''
-    )
-    const senderAddress =
-      payload.transferConfig.account || (await provider.publicKey?.toString())
-
-    if (!senderAddress) {
-      throw new Error('Sender account address is required')
-    }
-
-    // Convert the amount to the correct scale based on token decimals
-    const decimals = (payload.transferConfig.args[2] as number) || 6 // USDC has 6 decimals
-    const rawAmount = payload.transferConfig.args[1] as bigint
-    const scaledAmount = rawAmount
-
-    if (!payload.transactionInstructions.blockhash) {
-      throw new Error('Blockhash is required for Solana transactions')
-    }
-
-    try {
-      const result = await sendSOLTransactionWithInstructions(payload, {
-        toAddress: payload.transferConfig.args[0] as string,
-        amount: scaledAmount,
-        fromAddress: senderAddress,
-        blockhash: payload.transactionInstructions.blockhash,
-        walletName: payload.transactionInstructions.walletName || '',
-        tokenMint: payload.transferConfig.address,
-        createATA: payload.transferConfig.createATA || false,
-        tokenProgram: payload.transferConfig.tokenProgram,
-        tokenDecimals: decimals
-      })
-      if (typeof result === 'string') {
-        return result
-      }
-      throw result
-    } catch (error) {
-      throw this.handleError(error, 'send Solana native transfer')
-    }
-  }
-  sendNativeSmartContractInteraction(): Promise<string> {
-    throw new Error('Method not implemented.')
-  }
-
-  sendTransactionBatch(): Promise<string> {
-    throw new Error('Method not implemented.')
-  }
-
-  async getWalletCapabilities(): Promise<{ atomic: { status: string } }> {
-    return {
-      atomic: {
-        status: 'ready'
-      }
-    }
-  }
-
-  getProviders() {
-    const solanaProviderMap = findAvailableSolanaProviders()
-    return Object.keys(solanaProviderMap).map(id => ({
-      id,
-      type: 'solana'
-    }))
-  }
-}