@meshconnect/uwc-ton-connector 0.2.1 → 0.3.0

package/src/ton-connect-connector.ts

@@ -0,0 +1,347 @@
+import type {
+  Network,
+  Connector,
+  ConnectorResult,
+  SwitchNetworkResult,
+  TonConnectConfig,
+  TonConnectWalletProvider,
+  TonNativeTransferRequest,
+  TransactionRequest,
+  TransactionResult,
+  SignatureType,
+  NetworkId,
+  AvailableAddress
+} from '@meshconnect/uwc-types'
+import type {
+  ITonConnect,
+  WalletInfoRemote,
+  TonConnectOptions
+} from '@tonconnect/sdk'
+import { NamespacedStorage } from './namespaced-storage'
+import {
+  buildTonTransactionRequest,
+  buildSignDataPayload,
+  executeSignData,
+  unwrapBoc,
+  bocToHash,
+  toFriendlyAddress
+} from './ton-transaction-utils'
+
+// 5 minutes matches WalletConnect's proposal expiry. The TonConnect protocol
+// has no built-in timeout — without this, a pending connect hangs indefinitely.
+const CONNECT_TIMEOUT_MS = 5 * 60 * 1000
+
+// Shape of the error object passed to onStatusChange's errorCallback.
+// Not exported by @tonconnect/sdk — the SDK wraps the raw bridge RPC error internally.
+interface TonConnectErrorEvent {
+  payload?: { code?: number; message?: string }
+  message?: string
+}
+
+export class TonConnectConnector implements Connector {
+  private config: TonConnectConfig
+  private sdk: ITonConnect | null = null
+  private connectionURI: string | undefined
+  private connectedAddress: string | null = null
+  private connectedNetworkId: NetworkId | null = null
+  private visibilityHandler: (() => void) | null = null
+  private connectTimeout: ReturnType<typeof setTimeout> | null = null
+  private toUserFriendlyAddressFn:
+    | ((hex: string, testOnly?: boolean) => string)
+    | null = null
+  private UserRejectsErrorClass: (new (...args: never[]) => Error) | null = null
+  private connectInFlight = false
+
+  constructor(config: TonConnectConfig) {
+    this.config = config
+  }
+
+  /** Connect to a TON wallet via HTTP Bridge (QR code / deeplink). */
+  async connect(
+    network: Network,
+    provider?: TonConnectWalletProvider
+  ): Promise<ConnectorResult> {
+    if (!provider) {
+      throw new Error(
+        'TonConnectWalletProvider is required for TON Connect connection'
+      )
+    }
+    if (!provider.walletListAppName) {
+      throw new Error(
+        'walletListAppName is required — set it on TonConnectWalletProvider, or ensure the wallet has a jsBridgeKey in extensionInjectedProvider.tvm'
+      )
+    }
+
+    if (this.connectInFlight) {
+      throw new Error('TON Connect connection already in progress')
+    }
+    this.connectInFlight = true
+
+    if (this.sdk) {
+      await this.cleanupSdk(this.sdk)
+    }
+
+    try {
+      const { TonConnect, toUserFriendlyAddress, UserRejectsError } =
+        await import('@tonconnect/sdk')
+      this.toUserFriendlyAddressFn = toUserFriendlyAddress
+      this.UserRejectsErrorClass = UserRejectsError
+
+      const sdkOptions: TonConnectOptions = {
+        storage: new NamespacedStorage('uwc-ton-remote'),
+        manifestUrl: this.config.manifestUrl
+      }
+      if (this.config.walletsListSource) {
+        sdkOptions.walletsListSource = this.config.walletsListSource
+      }
+
+      this.sdk = new TonConnect(sdkOptions) as ITonConnect
+
+      // ONC-2717: The SDK supports restoreConnection() to resume a previous
+      // session from NamespacedStorage without a new QR scan. Currently we
+      // always start fresh (disconnect stale sessions below). Adding session
+      // resumption would let users stay connected across page reloads —
+      // call sdk.restoreConnection() here and skip the QR flow if it succeeds.
+
+      if (this.sdk.connected) {
+        // Can't reuse: the SDK binds one provider (JS or HTTP bridge) per instance.
+        // A stale HTTP session from a previous wallet would corrupt the new one.
+        try {
+          await this.sdk.disconnect()
+        } catch {
+          /* best effort — clear stale session from NamespacedStorage */
+        }
+      }
+
+      const sdkRef = this.sdk
+
+      // Resolve bridge URLs from the SDK's wallet list (built-in or custom walletsListSource)
+      const wallets = await sdkRef.getWallets()
+      const remoteWallets = wallets.filter(
+        (w): w is WalletInfoRemote => 'bridgeUrl' in w && 'universalLink' in w
+      )
+      const walletInfo = remoteWallets.find(
+        w => w.appName === provider.walletListAppName
+      )
+      if (!walletInfo) {
+        throw new Error(
+          `Wallet '${provider.walletListAppName}' not found in TonConnect wallet list, or missing bridge/universalLink`
+        )
+      }
+
+      const address = await this.waitForWalletApproval(
+        sdkRef,
+        walletInfo.universalLink,
+        walletInfo.bridgeUrl
+      )
+      this.connectionURI = undefined // URI consumed — clear before notify fires
+
+      const friendlyAddress = this.toUserFriendlyAddressFn
+        ? toFriendlyAddress(address, this.toUserFriendlyAddressFn)
+        : address
+
+      this.connectedAddress = friendlyAddress
+      this.connectedNetworkId = network.id
+      this.setupVisibilityHandler(sdkRef)
+
+      const availableAddresses = this.buildAvailableAddresses(
+        provider.supportedNetworkIds,
+        friendlyAddress
+      )
+
+      return {
+        networkId: network.id,
+        address: friendlyAddress,
+        availableAddresses
+      }
+    } finally {
+      this.connectInFlight = false
+    }
+  }
+
+  /** Return the connection URI generated by the last connect() call. */
+  getConnectionURI(): string {
+    if (!this.connectionURI) {
+      throw new Error('No connection URI available. Call connect() first.')
+    }
+    return this.connectionURI
+  }
+
+  /** Sign a message using TON Connect signData. */
+  async signMessage(message: string): Promise<SignatureType> {
+    if (!this.sdk) {
+      throw new Error('No active TON connection')
+    }
+
+    const payload = buildSignDataPayload(message)
+    return executeSignData(this.sdk, payload)
+  }
+
+  /** Send a TON transaction via the connected wallet. */
+  async sendTransaction(
+    request: TransactionRequest
+  ): Promise<TransactionResult> {
+    if (!this.sdk) {
+      throw new Error('No active TON connection')
+    }
+
+    const tonRequest = request as TonNativeTransferRequest
+    const senderRawAddress = this.sdk.account?.address
+    const txRequest = buildTonTransactionRequest(tonRequest, senderRawAddress)
+
+    try {
+      const result = await this.sdk.sendTransaction(txRequest)
+      const boc = unwrapBoc(result as string | { boc: string })
+      return bocToHash(boc)
+    } catch (error) {
+      if (
+        this.UserRejectsErrorClass &&
+        error instanceof this.UserRejectsErrorClass
+      ) {
+        throw new Error('Transaction was rejected by the user')
+      }
+      throw error
+    }
+  }
+
+  /** TON is single-chain — switchNetwork returns the current state. */
+  async switchNetwork(network: Network): Promise<SwitchNetworkResult> {
+    return {
+      networkId: this.connectedNetworkId ?? network.id,
+      address: this.connectedAddress ?? ''
+    }
+  }
+
+  /** Disconnect from the wallet and clean up resources. */
+  async disconnect(): Promise<void> {
+    if (this.sdk) {
+      try {
+        await this.sdk.disconnect()
+      } catch {
+        /* best effort */
+      }
+    }
+    this.sdk = null
+    this.connectedAddress = null
+    this.connectedNetworkId = null
+    this.connectionURI = undefined
+    this.connectInFlight = false
+    this.clearConnectTimeout()
+    this.removeVisibilityHandler()
+  }
+
+  /** Tear down SDK, event listeners, and pending timeouts. */
+  async destroy(): Promise<void> {
+    await this.disconnect()
+  }
+
+  private async waitForWalletApproval(
+    sdk: ITonConnect,
+    universalLink: string,
+    bridgeUrl: string
+  ): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      let settled = false
+      let unsubscribe: () => void
+
+      const cleanup = (): void => {
+        this.clearConnectTimeout()
+        unsubscribe()
+        this.connectionURI = undefined
+        this.cleanupSdk(sdk)
+      }
+
+      this.connectTimeout = setTimeout(() => {
+        if (settled) return
+        settled = true
+        cleanup()
+        reject(new Error('TON wallet connection timed out'))
+      }, CONNECT_TIMEOUT_MS)
+
+      unsubscribe = sdk.onStatusChange(
+        wallet => {
+          if (settled) return
+          settled = true
+          if (wallet?.account?.address) {
+            this.clearConnectTimeout()
+            unsubscribe()
+            resolve(wallet.account.address)
+          } else {
+            cleanup()
+            reject(new Error('TON wallet connection was rejected'))
+          }
+        },
+        error => {
+          if (settled) return
+          settled = true
+          const errorObj = error as TonConnectErrorEvent
+          const message =
+            errorObj?.payload?.message ||
+            this.extractSdkErrorMessage(error) ||
+            'TON wallet connection was rejected'
+          cleanup()
+          reject(new Error(message))
+        }
+      )
+
+      this.connectionURI = sdk.connect({ universalLink, bridgeUrl })
+    })
+  }
+
+  private extractSdkErrorMessage(error: unknown): string | undefined {
+    if (error && typeof error === 'object' && 'message' in error) {
+      const msg = (error as { message: string }).message
+      const lines = msg.split('\n')
+      if (lines.length > 1) {
+        return lines[lines.length - 1]
+      }
+    }
+    return undefined
+  }
+
+  private async cleanupSdk(sdk: ITonConnect): Promise<void> {
+    try {
+      await sdk.disconnect()
+    } catch {
+      /* best effort */
+    }
+    if (this.sdk === sdk) {
+      this.sdk = null
+    }
+  }
+
+  private setupVisibilityHandler(sdk: ITonConnect): void {
+    this.removeVisibilityHandler()
+    this.visibilityHandler = () => {
+      if (document.visibilityState === 'visible') {
+        sdk.unPauseConnection()
+      } else {
+        sdk.pauseConnection()
+      }
+    }
+    document.addEventListener('visibilitychange', this.visibilityHandler)
+  }
+
+  private removeVisibilityHandler(): void {
+    if (this.visibilityHandler) {
+      document.removeEventListener('visibilitychange', this.visibilityHandler)
+      this.visibilityHandler = null
+    }
+  }
+
+  private clearConnectTimeout(): void {
+    if (this.connectTimeout) {
+      clearTimeout(this.connectTimeout)
+      this.connectTimeout = null
+    }
+  }
+
+  private buildAvailableAddresses(
+    supportedNetworkIds: string[],
+    address: string
+  ): AvailableAddress[] {
+    return supportedNetworkIds
+      .filter(id => id.startsWith('tvm:'))
+      .map(networkId => ({ address, networkId: networkId as NetworkId }))
+  }
+}

package/src/ton-transaction-utils.ts

@@ -3,31 +3,13 @@ import type {
   TonSignDataPayload,
   SignatureType
 } from '@meshconnect/uwc-types'
+import type { SendTransactionRequest } from '@tonconnect/sdk'
 import { TON_MAINNET_CHAIN_ID } from '@meshconnect/uwc-constants'
 import { isValidBase64 } from './validation'
 
 /** Default transaction expiry window in seconds. TON transactions must include an expiry timestamp. */
 const TX_EXPIRY_SECONDS = 300
 
-/*
- * Local mirrors of @tonconnect/sdk types.
- * Defined here so ton-connector has zero runtime dependency on @tonconnect/sdk,
- * avoiding type leaks in the published .d.ts files.
- */
-
-/** Mirrors @tonconnect/sdk SendTransactionRequest. */
-interface TonConnectTransactionRequest {
-  validUntil: number
-  network?: string
-  from?: string
-  messages: {
-    address: string
-    amount: string
-    stateInit?: string
-    payload?: string
-  }[]
-}
-
 /**
  * Convert raw TON address to user-friendly format.
  * TON has two formats:
@@ -85,10 +67,10 @@ export function buildTonTransactionMessage(request: TonNativeTransferRequest) {
 export function buildTonTransactionRequest(
   request: TonNativeTransferRequest,
   senderRawAddress?: string
-): TonConnectTransactionRequest & { sendMode?: number } {
+): SendTransactionRequest & { sendMode?: number } {
   const message = buildTonTransactionMessage(request)
 
-  const txRequest: TonConnectTransactionRequest & { sendMode?: number } = {
+  const txRequest: SendTransactionRequest & { sendMode?: number } = {
     validUntil:
       request.validUntil ?? Math.floor(Date.now() / 1000) + TX_EXPIRY_SECONDS,
     network: TON_MAINNET_CHAIN_ID,