@meshconnect/web-link-sdk 3.2.14 → 3.2.15

package/src/utils/types.ts

@@ -0,0 +1,270 @@
+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

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

package/src/utils/wallet/EVMWalletStrategy.ts

@@ -0,0 +1,176 @@
+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

@@ -0,0 +1,207 @@
+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'
+    }))
+  }
+}