feat: ton connector

.changeset/sweet-years-tell.md

@@ -0,0 +1,5 @@
+---
+"@stakekit/widget": patch
+---
+
+feat: ton connector

packages/widget/package.json

@@ -80,11 +80,13 @@
     "@solana/wallet-adapter-react": "^0.15.39",
     "@solana/wallet-adapter-wallets": "^0.19.37",
     "@solana/web3.js": "^1.98.4",
-    "@stakekit/rainbowkit": "^2.2.10",
-    "@tanstack/react-query": "^5.90.9",
     "@stakekit/api-hooks": "0.0.113",
     "@stakekit/common": "^0.0.61",
+    "@stakekit/rainbowkit": "^2.2.10",
+    "@tanstack/react-query": "^5.90.9",
     "@tanstack/react-virtual": "^3.13.12",
+    "@ton/core": "^0.62.0",
+    "@tonconnect/ui": "^2.3.1",
     "@tronweb3/tronwallet-abstract-adapter": "^1.1.10",
     "@tronweb3/tronwallet-adapter-bitkeep": "^1.1.7",
     "@tronweb3/tronwallet-adapter-ledger": "^1.1.11",

packages/widget/src/domain/types/transaction.ts

@@ -112,11 +112,13 @@ export type DecodedSolanaTransaction = GetType<
   typeof unsignedSolanaTransactionCodec
 >;
 
+export const unsignedTonTransactionTonConnectCodec = Codec.interface({
+  seqno: bigintCodec,
+  message: string,
+});
+
 export const unsignedTonTransactionCodec = oneOf([
-  Codec.interface({
-    seqno: bigintCodec,
-    message: string,
-  }),
+  unsignedTonTransactionTonConnectCodec,
   array(
     Codec.interface({
       address: string,

packages/widget/src/providers/misc/config.ts

@@ -21,12 +21,14 @@ const queryFn = async ({
   solanaWallets,
   solanaConnection,
   variant,
+  tonConnectManifestUrl,
 }: {
   enabledNetworks: Set<Networks>;
   forceWalletConnectOnly: boolean;
   solanaWallets: Wallet[];
   solanaConnection: Connection;
   variant: VariantProps["variant"];
+  tonConnectManifestUrl: string | undefined;
 }): Promise<{
   miscChainsMap: Partial<MiscChainsMap>;
   miscChains: Chain[];
@@ -71,6 +73,11 @@ const queryFn = async ({
           v.getCardanoConnectors()
         )
     ),
+    MaybeAsync.liftMaybe(Maybe.fromFalsy(filteredMiscChainsMap.ton)).chain(() =>
+      MaybeAsync(() => import("./ton-connector")).map((v) =>
+        v.getTonConnectors({ tonConnectManifestUrl })
+      )
+    ),
   ]).then((connectors) => ({
     miscChainsMap: filteredMiscChainsMap,
     miscChains,

packages/widget/src/providers/misc/ton-connector-meta.ts

@@ -0,0 +1,21 @@
+import type { EitherAsync } from "purify-ts";
+import type { Connector } from "wagmi";
+import type { ConnectorWithFilteredChains } from "../../domain/types/connectors";
+
+export const configMeta = {
+  type: "tonWallet",
+} as const;
+
+export type ExtraProps = ConnectorWithFilteredChains & {
+  signTransaction: (tx: string) => EitherAsync<Error, string>;
+};
+
+type TonConnector = Connector & ExtraProps;
+
+export type StorageItem = {
+  "ton.disconnected": boolean;
+};
+
+export const isTonConnector = (
+  connector: Connector
+): connector is TonConnector => connector.type === "tonWallet";

packages/widget/src/providers/misc/ton-connector.ts

@@ -0,0 +1,197 @@
+import { MiscNetworks } from "@stakekit/common";
+import type { WalletDetailsParams, WalletList } from "@stakekit/rainbowkit";
+import {
+  Cell,
+  type CommonMessageInfoRelaxedInternal,
+  loadMessageRelaxed,
+} from "@ton/core";
+import {
+  TonConnectUI,
+  toUserFriendlyAddress,
+  type Wallet,
+} from "@tonconnect/ui";
+import { Either, EitherAsync } from "purify-ts";
+import { BehaviorSubject } from "rxjs";
+import type { Address, Chain } from "viem";
+import { createConnector } from "wagmi";
+import { ton } from "../../domain/types/chains/misc";
+import { unsignedTonTransactionTonConnectCodec } from "../../domain/types/transaction";
+import { getNetworkLogo } from "../../utils";
+import {
+  configMeta,
+  type ExtraProps,
+  type StorageItem,
+} from "./ton-connector-meta";
+
+const createTonConnector = (
+  walletDetailsParams: WalletDetailsParams,
+  manifestUrl: string | undefined
+) =>
+  createConnector<unknown, ExtraProps, StorageItem>((config) => {
+    const tonconnectUI = new TonConnectUI({
+      manifestUrl:
+        manifestUrl ?? "https://dapp.stakek.it/tonconnect-manifest.json",
+    });
+
+    let deferred: {
+      resolve: (wallet: Wallet) => void;
+      reject: () => void;
+    } | null = null;
+    let connectedWallet: Wallet | null = null;
+
+    tonconnectUI.onStatusChange((wallet) => {
+      connectedWallet = wallet;
+      if (wallet) {
+        deferred?.resolve(wallet);
+      }
+    });
+
+    tonconnectUI.onModalStateChange((state) => {
+      if (state.status === "closed") {
+        deferred?.reject();
+      }
+    });
+
+    return {
+      ...walletDetailsParams,
+      id: "tonconnect",
+      name: "TonConnect",
+      type: configMeta.type,
+      signTransaction: (tx: string) =>
+        EitherAsync(async ({ throwE, liftEither }) => {
+          if (!connectedWallet) {
+            return throwE(new Error("No wallet connected"));
+          }
+
+          const parsedTx = await liftEither(
+            Either.encase(() => JSON.parse(tx)).chain((val) =>
+              unsignedTonTransactionTonConnectCodec
+                .decode(val)
+                .mapLeft((e) => new Error(e))
+            )
+          ).then(({ message }) =>
+            loadMessageRelaxed(Cell.fromBase64(message).beginParse())
+          );
+
+          const info = parsedTx.info as CommonMessageInfoRelaxedInternal;
+
+          const result = await tonconnectUI.sendTransaction({
+            messages: [
+              {
+                address: info.dest.toString(),
+                amount: info.value.coins.toString(),
+                payload: parsedTx.body.toBoc().toString("base64"),
+              },
+            ],
+            validUntil: Date.now() + 1000 * 60 * 60 * 24,
+          });
+
+          const externalMessageCell = Cell.fromBase64(result.boc);
+          const txHash = externalMessageCell.hash().toString("hex");
+
+          return txHash;
+        }),
+      connect: async (args) => {
+        config.emitter.emit("message", { type: "connecting" });
+
+        config.storage?.removeItem("ton.disconnected");
+
+        const wallet: Wallet =
+          connectedWallet ??
+          (await tonconnectUI
+            .openModal()
+            .then(
+              () =>
+                new Promise<Wallet>((resolve, reject) => {
+                  deferred = { resolve, reject };
+                })
+            )
+            .then((wallet) => {
+              deferred = null;
+              return wallet;
+            }));
+
+        const userFriendlyAddress = toUserFriendlyAddress(
+          wallet.account.address
+        );
+
+        return {
+          accounts: args?.withCapabilities
+            ? [
+                {
+                  address: userFriendlyAddress as Address,
+                  capabilities: {},
+                },
+              ]
+            : [userFriendlyAddress as Address],
+          chainId: ton.id,
+        } as never;
+      },
+      disconnect: async () => {
+        config.storage?.setItem("ton.disconnected", true);
+        await tonconnectUI.disconnect();
+        connectedWallet = null;
+      },
+      getAccounts: async () => {
+        await tonconnectUI.connectionRestored;
+
+        if (!connectedWallet) throw new Error("No wallet connected");
+
+        return [
+          toUserFriendlyAddress(connectedWallet.account.address) as Address,
+        ];
+      },
+      switchChain: async () => ton,
+      getChainId: async () => ton.id,
+      isAuthorized: async () => {
+        await tonconnectUI.connectionRestored;
+
+        const isDisconnected =
+          await config.storage?.getItem("ton.disconnected");
+
+        if (isDisconnected) return false;
+
+        return !!connectedWallet;
+      },
+      onAccountsChanged: (accounts: string[]) => {
+        if (accounts.length === 0) {
+          config.emitter.emit("disconnect");
+        } else {
+          config.emitter.emit("change", { accounts: accounts as Address[] });
+        }
+      },
+      onChainChanged: (chainId) => {
+        config.emitter.emit("change", {
+          chainId: chainId as unknown as number,
+        });
+      },
+      onDisconnect: () => {
+        config.emitter.emit("disconnect");
+      },
+      getProvider: async () => ({}),
+      $filteredChains: new BehaviorSubject<Chain[]>([ton]).asObservable(),
+    };
+  });
+
+export const getTonConnectors = ({
+  tonConnectManifestUrl,
+}: {
+  tonConnectManifestUrl: string | undefined;
+}): WalletList[number] => ({
+  groupName: "Ton",
+  wallets: [
+    () => ({
+      id: "tonconnect",
+      name: "TonConnect",
+      iconUrl: getNetworkLogo(MiscNetworks.Ton),
+      iconBackground: "transparent",
+      chainGroup: {
+        id: "ton",
+        title: "Ton",
+        iconUrl: getNetworkLogo(MiscNetworks.Ton),
+      },
+      createConnector: (walletDetailsParams) =>
+        createTonConnector(walletDetailsParams, tonConnectManifestUrl),
+    }),
+  ],
+});

packages/widget/src/providers/settings/types.ts

@@ -71,6 +71,7 @@ export type SettingsProps = {
   showUSDeBanner?: boolean;
   preferredTokenYieldsPerNetwork?: PreferredTokenYieldsPerNetwork;
   portalContainer?: HTMLElement;
+  tonConnectManifestUrl?: string;
 };
 
 export type SettingsContextType = SettingsProps & VariantProps;

packages/widget/src/providers/sk-wallet/index.tsx

@@ -46,6 +46,7 @@ import { isExternalProviderConnector } from "../external-provider";
 import { isLedgerLiveConnector } from "../ledger/ledger-live-connector-meta";
 import { isCardanoConnector } from "../misc/cardano-connector-meta";
 import { isSolanaConnector } from "../misc/solana-connector-meta";
+import { isTonConnector } from "../misc/ton-connector-meta";
 import { isTronConnector } from "../misc/tron-connector-meta";
 import { isSafeConnector } from "../safe/safe-connector-meta";
 import { isSubstrateConnector } from "../substrate/substrate-connector-meta";
@@ -356,6 +357,13 @@ export const SKWalletProvider = ({ children }: PropsWithChildren) => {
               .map((res) => ({ signedTx: res, broadcasted: false }));
           }
 
+          if (isTonConnector(conn)) {
+            return conn
+              .signTransaction(tx)
+              .mapLeft(() => new SendTransactionError())
+              .map((res) => ({ signedTx: res, broadcasted: true }));
+          }
+
           /**
            * Safe connector
            */

packages/widget/src/providers/wagmi/index.ts

@@ -75,6 +75,7 @@ const buildWagmiConfig = async (opts: {
   solanaWallets: SolanaWallet[];
   solanaConnection: Connection;
   mapWalletListFn?: (val: WalletList) => WalletList;
+  tonConnectManifestUrl: string | undefined;
 }): Promise<{
   evmConfig: GetEitherAsyncRight<ReturnType<typeof getEvmConfig>>;
   cosmosConfig: GetEitherAsyncRight<ReturnType<typeof getCosmosConfig>>;
@@ -103,6 +104,7 @@ const buildWagmiConfig = async (opts: {
             solanaWallets: opts.solanaWallets,
             solanaConnection: opts.solanaConnection,
             variant: opts.variant,
+            tonConnectManifestUrl: opts.tonConnectManifestUrl,
           }),
           getSubstrateConfig({
             queryClient: opts.queryClient,
@@ -375,6 +377,7 @@ export const useWagmiConfig = () => {
     chainIconMapping,
     variant,
     mapWalletListFn,
+    tonConnectManifestUrl,
   } = useSettings();
 
   const solanaWallets = useSolanaWallet();
@@ -409,6 +412,7 @@ export const useWagmiConfig = () => {
         solanaWallets: solanaWallets.wallets,
         solanaConnection: solanaConnection.connection,
         mapWalletListFn,
+        tonConnectManifestUrl,
       }),
   });
 

packages/widget/tests/fixtures/index.ts

@@ -15,7 +15,7 @@ export const yieldFixture = (overrides?: Partial<YieldDto>) =>
     .map(
       (val) =>
         ({
-          ...getYieldV2ControllerGetYieldByIdResponseMock(),
+          ...val,
           rewardRate: apyFaker(),
           rewardType: "apy",
           apy: apyFaker(),