@rango-dev/provider-okx 0.63.1-next.1 → 0.63.1-next.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rango-dev/provider-okx",
-  "version": "0.63.1-next.1",
+  "version": "0.63.1-next.3",
   "license": "MIT",
   "type": "module",
   "source": "./src/mod.ts",
@@ -28,11 +28,13 @@
     "@hub3js/std": "^0.2.0",
     "@rango-dev/signer-evm": "^0.44.1-next.0",
     "@rango-dev/signer-solana": "^0.48.1-next.0",
+    "@rango-dev/signer-tron": "^0.41.1-next.0",
     "@rango-dev/wallets-core": "^0.60.1-next.3",
     "@rango-dev/wallets-shared": "^0.61.1-next.4",
+    "@ton/core": "^0.59.0",
     "rango-types": "^0.5.0"
   },
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/readme.md

@@ -39,10 +39,6 @@ Supported networks :
 The wallet only supports bitcoin.
 
 
-#### 🚧 TON
-
-The wallet supports TON, but it is **not implemented** in the current integration.
-
 #### 🚧 Sui
 
 The wallet supports Sui, but it is **not implemented** in the current integration.
@@ -51,6 +47,16 @@ The wallet supports Sui, but it is **not implemented** in the current integratio
 
 ### Feature
 
+#### ⚠️ Connect and AutoConnect
+
+For Tron, connecting on page load — or disconnecting and reconnecting within the app —
+returns the **first account you connected**, not the account you last switched to. The OKX
+extension resets the Tron address in these cases and gives no way to recover the active
+one; it corrects itself only once you switch accounts in the wallet.
+
+If you sign a transaction while that wrong account is selected, the OKX wallet rejects it
+with a **"Transaction Unavailable"** error.
+
 #### ⚠️ Disconnect
 
 The disconnect function will not work for this wallet, as it attempts to invoke disconnect on the connect method for private key imported wallets.

package/src/actions/ton.ts

@@ -0,0 +1,99 @@
+import type {
+  TonConnectEvent,
+  TonProviderApi,
+} from '../namespaces/ton/types.js';
+import type { Context, FunctionWithContext } from '@hub3js/core';
+
+import { type TonActions } from '@rango-dev/wallets-core/namespaces/ton';
+
+import {
+  TON_CONNECT_PROTOCOL_VERSION,
+  TON_CONNECT_USER_REJECTED_CODE,
+} from '../constants.js';
+import {
+  connectEventToCAIP,
+  getTonConnectManifestUrl,
+  isTonConnectEventSuccess,
+  nextTonRequestId,
+} from '../namespaces/ton/utils.js';
+
+export function connect(
+  getInstance: () => TonProviderApi
+): FunctionWithContext<TonActions['connect'], Context> {
+  return async () => {
+    const instance = getInstance();
+
+    /*
+     * If the dApp was approved before, `restoreConnection` resolves the current
+     * session without prompting the user; otherwise fall back to a fresh
+     * connect request.
+     */
+    let connectEvent: TonConnectEvent | undefined;
+    try {
+      connectEvent = await instance.restoreConnection();
+    } catch {
+      // No restorable session; a fresh connect request is made below.
+    }
+
+    if (!connectEvent || !isTonConnectEventSuccess(connectEvent)) {
+      connectEvent = await instance.connect(TON_CONNECT_PROTOCOL_VERSION, {
+        manifestUrl: getTonConnectManifestUrl(),
+        items: [{ name: 'ton_addr' }],
+      });
+    }
+
+    if (!isTonConnectEventSuccess(connectEvent)) {
+      // The bridge reports a user-cancelled prompt as a `connect_error` event.
+      if (connectEvent.payload.code === TON_CONNECT_USER_REJECTED_CODE) {
+        throw new Error('User rejected the request.');
+      }
+      throw new Error(
+        `Couldn't connect to OKX TON. code: ${connectEvent.payload.code}, message: ${connectEvent.payload.message}`
+      );
+    }
+
+    const accounts = await connectEventToCAIP(connectEvent);
+    if (!accounts.length) {
+      throw new Error("Couldn't find any TON address!");
+    }
+
+    return accounts;
+  };
+}
+
+export function canEagerConnect(
+  getInstance: () => TonProviderApi
+): FunctionWithContext<TonActions['canEagerConnect'], Context> {
+  return async () => {
+    /*
+     * Auto connect may run this before the wallet is injected; it should never
+     * throw.
+     */
+    try {
+      const connectEvent = await getInstance().restoreConnection();
+      return isTonConnectEventSuccess(connectEvent);
+    } catch {
+      return false;
+    }
+  };
+}
+
+export function disconnect(getInstance: () => TonProviderApi) {
+  return async () => {
+    /*
+     * Revoking the session on the wallet side is best effort; local state
+     * cleanup should proceed even if it fails.
+     */
+    try {
+      await getInstance().send({
+        method: 'disconnect',
+        params: [],
+        id: nextTonRequestId(),
+      });
+    } catch {
+      // ignore
+    }
+  };
+}
+
+export const tonActions = { connect, canEagerConnect, disconnect };

package/src/actions/tron.ts

@@ -0,0 +1,37 @@
+import { utils } from '@rango-dev/wallets-core/namespaces/tron';
+
+import {
+  TRON_OK_REQUEST_CODE,
+  TRON_USER_REJECTION_CODE,
+} from '../constants.js';
+import { tronOKX } from '../utils.js';
+
+const connect = async () => {
+  const instance = tronOKX();
+  const accountsResult = await instance.request({
+    method: 'tron_requestAccounts',
+  });
+
+  if (accountsResult?.code && accountsResult.code !== TRON_OK_REQUEST_CODE) {
+    if (accountsResult.code === TRON_USER_REJECTION_CODE) {
+      throw new Error('User rejected the request.');
+    }
+    throw new Error(
+      accountsResult.message ?? 'Failed to connect to OKX Wallet Tron.'
+    );
+  }
+  return utils.formatAccountsToCAIP([instance.tronWeb.defaultAddress.base58]);
+};
+
+/*
+ * Wrapped in a try-catch in the case of wallet injection delay
+ */
+const canEagerConnect = async () => {
+  try {
+    const tronInstance = tronOKX();
+    return !!tronInstance.ready;
+  } catch {
+    return false;
+  }
+};
+export const tronActions = { connect, canEagerConnect };

package/src/builders/ton.ts

@@ -0,0 +1,48 @@
+import type { TonProviderApi } from '../namespaces/ton/types.js';
+
+import { ChangeAccountSubscriberBuilder } from '@hub3js/std/hooks';
+import { type TonActions, utils } from '@rango-dev/wallets-core/namespaces/ton';
+
+import { connectEventToCAIP } from '../namespaces/ton/utils.js';
+
+/*
+ * OKX emits its non-standard `accountChanged` event without a documented
+ * payload, so the switched address can't be read from the event. Because the
+ * bridge is standard TON Connect, `format` re-reads the active account from the
+ * instance via `restoreConnection` instead
+ */
+export const changeAccountSubscriber = (getInstance: () => TonProviderApi) =>
+  new ChangeAccountSubscriberBuilder<unknown, TonProviderApi, TonActions>()
+    .getInstance(getInstance)
+    .format(async (instance) => {
+      try {
+        const connectEvent = await instance.restoreConnection();
+        return await connectEventToCAIP(connectEvent);
+      } catch {
+        // No active session after the switch — treat as disconnected.
+        return utils.formatAccountsToCAIP([]);
+      }
+    })
+    .addEventListener((instance, callback) => {
+      instance.on('accountChanged', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.off('accountChanged', callback);
+    });
+
+export const disconnectSubscriber = (getInstance: () => TonProviderApi) =>
+  new ChangeAccountSubscriberBuilder<unknown, TonProviderApi, TonActions>()
+    .getInstance(getInstance)
+    .onSwitchAccount((event, context) => {
+      event.preventDefault();
+      void context.action('disconnect');
+    })
+    .format(async () => [])
+    .addEventListener((instance, callback) => {
+      instance.on('disconnect', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.off('disconnect', callback);
+    });
+
+export const tonBuilders = { changeAccountSubscriber, disconnectSubscriber };

package/src/builders/tron.ts

@@ -0,0 +1,63 @@
+import { ChangeAccountSubscriberBuilder } from '@hub3js/std/hooks';
+import {
+  type ProviderAPI,
+  type TronActions,
+  utils,
+} from '@rango-dev/wallets-core/namespaces/tron';
+
+import { isOkxTronMessageEvent } from '../utils.js';
+
+export const changeAccountSubscriber = (getInstance: () => ProviderAPI) =>
+  new ChangeAccountSubscriberBuilder<
+    MessageEvent<unknown>,
+    ProviderAPI,
+    TronActions
+  >()
+    .getInstance(getInstance)
+    .onSwitchAccount((event, context) => {
+      const data = event.payload?.data;
+
+      if (!isOkxTronMessageEvent(data)) {
+        event.preventDefault();
+        return;
+      }
+
+      const { action } = data.message;
+
+      if (action === 'disconnect') {
+        event.preventDefault();
+        context.action('disconnect');
+        return;
+      }
+
+      /*
+       * Change account only on `accountsChanged` with a string address (`format`
+       * reads it). Everything else — including `accountsChanged` with address
+       * `false` (its disconnect is handled above) — is ignored.
+       */
+      if (
+        action !== 'accountsChanged' ||
+        typeof data.message.data?.address !== 'string'
+      ) {
+        event.preventDefault();
+      }
+    })
+    .format(async (_, event) => {
+      const data = event.data;
+      const address =
+        isOkxTronMessageEvent(data) && data.message.action === 'accountsChanged'
+          ? data.message.data?.address
+          : undefined;
+      if (typeof address !== 'string') {
+        throw new Error('No Tron address received from OKX Wallet.');
+      }
+      return utils.formatAccountsToCAIP([address]);
+    })
+    .addEventListener((_, callback) => {
+      window.addEventListener('message', callback);
+    })
+    .removeEventListener((_, callback) => {
+      window.removeEventListener('message', callback);
+    });
+
+export const tronBuilders = { changeAccountSubscriber };

package/src/constants.ts

@@ -5,13 +5,21 @@ import { Networks } from '@rango-dev/wallets-shared';
 import {
   type BlockchainMeta,
   solanaBlockchain,
+  tonBlockchain,
   type TransferBlockchainMeta,
+  tronBlockchain,
 } from 'rango-types';
 
 import getSigners from './signer.js';
 import { getInstanceOrThrow } from './utils.js';
 
 export const WALLET_ID = 'okx';
+export const TON_CONNECT_PROTOCOL_VERSION = 2;
+export const TON_CONNECT_USER_REJECTED_CODE = 300;
+export const TRON_OK_REQUEST_CODE = 200;
+// EIP-1193 user-rejected-request code returned by `tron_requestAccounts`.
+export const TRON_USER_REJECTION_CODE = 4001;
+
 export const OKX_WALLET_SUPPORTED_CHAINS = [
   LegacyNetworks.ETHEREUM,
   LegacyNetworks.BSC,
@@ -73,6 +81,20 @@ export const metadata: ProviderMetadata = {
                   chain.name === Networks.BTC
               ),
           },
+          {
+            label: 'Ton',
+            value: 'Ton',
+            id: 'TON',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              tonBlockchain(allBlockchains),
+          },
+          {
+            label: 'Tron',
+            value: 'Tron',
+            id: 'TRON',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              tronBlockchain(allBlockchains),
+          },
         ],
       },
     },

package/src/namespaces/ton/ton.ts

@@ -0,0 +1,50 @@
+import { NamespaceBuilder } from '@hub3js/core';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+import {
+  builders,
+  type TonActions,
+} from '@rango-dev/wallets-core/namespaces/ton';
+
+import { tonActions } from '../../actions/ton.js';
+import { tonBuilders } from '../../builders/ton.js';
+import { WALLET_ID } from '../../constants.js';
+import { tonOKX } from '../../utils.js';
+
+const [changeAccountSubscriber, changeAccountCleanup] = tonBuilders
+  .changeAccountSubscriber(tonOKX)
+  .build();
+
+const [walletDisconnectSubscriber, walletDisconnectCleanup] = tonBuilders
+  .disconnectSubscriber(tonOKX)
+  .build();
+
+const connect = builders
+  .connect()
+  .action(tonActions.connect(tonOKX))
+  .before(changeAccountSubscriber)
+  .before(walletDisconnectSubscriber)
+  .or(walletDisconnectCleanup)
+  .or(changeAccountCleanup)
+  .or(standardizeAndThrowError)
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<TonActions>()
+  .before(tonActions.disconnect(tonOKX))
+  .after(changeAccountCleanup)
+  .after(walletDisconnectCleanup)
+  .build();
+
+const canEagerConnect = builders
+  .canEagerConnect()
+  .action(tonActions.canEagerConnect(tonOKX))
+  .build();
+
+const ton = new NamespaceBuilder<TonActions>('Ton', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(canEagerConnect)
+  .build();
+
+export { ton };

package/src/namespaces/ton/types.ts

@@ -0,0 +1,89 @@
+export type Environments = {
+  tonConnectManifestUrl?: string;
+};
+
+/*
+ * OKX injects a standard TonConnect JS bridge at `window.okxTonWallet.tonconnect`.
+ * The types below describe the subset of the TonConnect protocol we rely on,
+ * plus OKX's non-standard `on`/`off` event API.
+ */
+export type TonAddressItemReply = {
+  name: 'ton_addr';
+  // Raw format: `<workchain>:<hex>`
+  address: string;
+  // '-239' for mainnet, '-3' for testnet
+  network: string;
+  walletStateInit: string;
+  publicKey: string;
+};
+
+export type TonConnectEventSuccess = {
+  event: 'connect';
+  id: number;
+  payload: {
+    items: Array<TonAddressItemReply | { name: string }>;
+    device: unknown;
+  };
+};
+
+export type TonConnectEventError = {
+  event: 'connect_error';
+  id: number;
+  payload: {
+    code: number;
+    message: string;
+  };
+};
+
+export type TonConnectEvent = TonConnectEventSuccess | TonConnectEventError;
+
+export type TonConnectRequest = {
+  manifestUrl: string;
+  items: Array<{ name: 'ton_addr' }>;
+};
+
+export type TonConnectAppRequest = {
+  method: 'sendTransaction' | 'disconnect';
+  params: string[];
+  id: string;
+};
+
+export type TonConnectWalletResponseSuccess = {
+  result: string;
+  id: string;
+};
+
+export type TonConnectWalletResponseError = {
+  error: { code: number; message: string; data?: unknown };
+  id: string;
+};
+
+export type TonConnectWalletResponse =
+  | TonConnectWalletResponseSuccess
+  | TonConnectWalletResponseError;
+
+export interface TonProviderApi {
+  deviceInfo: unknown;
+  walletInfo?: unknown;
+  protocolVersion: number;
+  connect(
+    protocolVersion: number,
+    message: TonConnectRequest
+  ): Promise<TonConnectEvent>;
+  restoreConnection(): Promise<TonConnectEvent>;
+  send(message: TonConnectAppRequest): Promise<TonConnectWalletResponse>;
+  listen(callback: (event: unknown) => void): () => void;
+  /*
+   * Non-standard OKX-specific event API. `accountChanged` fires when the user
+   * switches the active account inside the wallet; its payload is undocumented
+   * and must not be relied on.
+   */
+  on(
+    event: 'accountChanged' | 'connect' | 'disconnect',
+    callback: (payload?: unknown) => void
+  ): void;
+  off(
+    event: 'accountChanged' | 'connect' | 'disconnect',
+    callback: (payload?: unknown) => void
+  ): void;
+}

package/src/namespaces/ton/utils.ts

@@ -0,0 +1,79 @@
+import type {
+  Environments,
+  TonAddressItemReply,
+  TonConnectEvent,
+  TonConnectEventSuccess,
+} from './types.js';
+import type { CaipAccount } from '@rango-dev/wallets-core/namespaces/common';
+
+import { utils as tonCoreUtils } from '@rango-dev/wallets-core/namespaces/ton';
+import { dynamicImportWithRefinedError } from '@rango-dev/wallets-shared';
+
+export function isTonConnectEventSuccess(
+  event: TonConnectEvent
+): event is TonConnectEventSuccess {
+  return (
+    !!event && event.event === 'connect' && Array.isArray(event.payload?.items)
+  );
+}
+
+export function isTonAddressItemReply(
+  item: unknown
+): item is TonAddressItemReply {
+  return (
+    typeof item === 'object' &&
+    item !== null &&
+    'name' in item &&
+    item.name === 'ton_addr' &&
+    'address' in item &&
+    typeof item.address === 'string'
+  );
+}
+
+let environments: Environments | undefined;
+
+export function setEnvironments(env?: Environments) {
+  environments = env;
+}
+
+export function getTonConnectManifestUrl(): string {
+  const manifestUrl = environments?.tonConnectManifestUrl;
+  if (!manifestUrl) {
+    throw new Error(
+      'OKX TON requires a TonConnect manifest URL. Please provide it through the provider environments.'
+    );
+  }
+  return manifestUrl;
+}
+
+let tonRequestId = 0;
+
+// TonConnect requires a unique string `id` on every request sent to the bridge.
+export function nextTonRequestId(): string {
+  tonRequestId += 1;
+  return tonRequestId.toString();
+}
+
+// Convert a `ConnectEvent`'s raw `<workchain>:<hex>` address to user-friendly CAIP.
+export async function connectEventToCAIP(
+  connectEvent: TonConnectEvent
+): Promise<CaipAccount[]> {
+  if (!isTonConnectEventSuccess(connectEvent)) {
+    return tonCoreUtils.formatAccountsToCAIP([]);
+  }
+
+  const addressItem = connectEvent.payload.items.find(isTonAddressItemReply);
+  if (!addressItem) {
+    return tonCoreUtils.formatAccountsToCAIP([]);
+  }
+
+  const { Address } = await dynamicImportWithRefinedError(
+    async () => await import('@ton/core')
+  );
+  const userFriendlyAddress = Address.parseRaw(addressItem.address).toString({
+    bounceable: false,
+    urlSafe: true,
+  });
+
+  return tonCoreUtils.formatAccountsToCAIP([userFriendlyAddress]);
+}

package/src/namespaces/tron.ts

@@ -0,0 +1,40 @@
+import { NamespaceBuilder } from '@hub3js/core';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+import { type TronActions } from '@rango-dev/wallets-core/namespaces/tron';
+import { builders } from '@rango-dev/wallets-core/namespaces/tron';
+
+import { tronActions } from '../actions/tron.js';
+import { tronBuilders } from '../builders/tron.js';
+import { WALLET_ID } from '../constants.js';
+import { tronOKX } from '../utils.js';
+
+const [changeAccountSubscriber, changeAccountCleanup] = tronBuilders
+  .changeAccountSubscriber(tronOKX)
+  .build();
+
+const connect = builders
+  .connect()
+  .action(tronActions.connect)
+  .before(changeAccountSubscriber)
+  .or(changeAccountCleanup)
+  .or(standardizeAndThrowError)
+  .build();
+
+const canEagerConnect = builders
+  .canEagerConnect()
+  .action(tronActions.canEagerConnect)
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<TronActions>()
+  .after(changeAccountCleanup)
+  .build();
+
+const tron = new NamespaceBuilder<TronActions>('Tron', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(canEagerConnect)
+  .build();
+
+export { tron };

package/src/provider.ts

@@ -1,14 +1,20 @@
+import type { Environments } from './namespaces/ton/types.js';
+
 import { ProviderBuilder } from '@hub3js/core';
 
 import { metadata, WALLET_ID } from './constants.js';
 import { evm } from './namespaces/evm.js';
 import { solana } from './namespaces/solana.js';
+import { ton } from './namespaces/ton/ton.js';
+import { setEnvironments } from './namespaces/ton/utils.js';
+import { tron } from './namespaces/tron.js';
 import { utxo } from './namespaces/utxo.js';
 import { okx as okxInstance } from './utils.js';
 
 const buildProvider = () =>
   new ProviderBuilder(WALLET_ID)
-    .init(function (context) {
+    .init(function (context, environments?: Environments) {
+      setEnvironments(environments);
       const [, setState] = context.state();
 
       if (okxInstance()) {
@@ -20,6 +26,8 @@ const buildProvider = () =>
     .add('solana', solana)
     .add('evm', evm)
     .add('utxo', utxo)
+    .add('ton', ton)
+    .add('tron', tron)
 
     .build();
 

package/src/signer.ts

@@ -5,6 +5,8 @@ import {
   EVM_NAMESPACE,
   SOLANA_NAMESPACE,
   UTXO_NAMESPACE,
+  TON_NAMESPACE,
+  TRON_NAMESPACE,
 } from '@hub3js/namespaces';
 import {
   dynamicImportWithRefinedError,
@@ -13,6 +15,7 @@ import {
 import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
 
 import { OKXSolanaSigner } from './signers/solana.js';
+import { OKXTonSigner } from './signers/ton.js';
 import { OKXUTXOSigner } from './signers/utxo.js';
 
 export default async function getSigners(
@@ -21,14 +24,21 @@ export default async function getSigners(
   const ethProvider = getNetworkInstance(provider, EVM_NAMESPACE);
   const solProvider = getNetworkInstance(provider, SOLANA_NAMESPACE);
   const utxoProvider = getNetworkInstance(provider, UTXO_NAMESPACE);
+  const tonProvider = getNetworkInstance(provider, TON_NAMESPACE);
+  const tronProvider = getNetworkInstance(provider, TRON_NAMESPACE);
 
   const signers = new DefaultSignerFactory();
   const { DefaultEvmSigner } = await dynamicImportWithRefinedError(
     async () => await import('@rango-dev/signer-evm')
   );
+  const { DefaultTronSigner } = await dynamicImportWithRefinedError(
+    async () => await import('@rango-dev/signer-tron')
+  );
   signers.registerSigner(TxType.EVM, new DefaultEvmSigner(ethProvider));
   signers.registerSigner(TxType.SOLANA, new OKXSolanaSigner(solProvider));
   signers.registerSigner(TxType.TRANSFER, new OKXUTXOSigner(utxoProvider));
+  signers.registerSigner(TxType.TON, new OKXTonSigner(tonProvider));
+  signers.registerSigner(TxType.TRON, new DefaultTronSigner(tronProvider));
 
   return signers;
 }