@hot-labs/kit 1.3.2 → 1.4.0

package/src/evm/wallet.ts

@@ -2,14 +2,14 @@ import { base64, base58, hex } from "@scure/base";
 import { BrowserProvider, ethers, JsonRpcProvider, TransactionRequest } from "ethers";
 import { JsonRpcSigner, FetchRequest } from "ethers";
 
-import { OmniConnector } from "../OmniConnector";
-import { OmniWallet } from "../OmniWallet";
-import { WalletType } from "../core/chains";
+import { OmniConnector } from "../core/OmniConnector";
+import { OmniWallet } from "../core/OmniWallet";
+import { Network, WalletType } from "../core/chains";
 import { ReviewFee } from "../core/bridge";
 import { Token } from "../core/token";
-import { erc20abi } from "./abi";
 import { Commitment } from "../core";
 import { api } from "../core/api";
+import { erc20abi } from "./abi";
 
 export interface EvmProvider {
   request: (args: any) => Promise<any>;
@@ -25,8 +25,8 @@ class EvmWallet extends OmniWallet {
     super();
   }
 
-  async disconnect() {
-    await this.provider.request?.({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
+  get omniAddress() {
+    return this.address.toLowerCase();
   }
 
   get icon() {
@@ -35,6 +35,7 @@ class EvmWallet extends OmniWallet {
 
   private rpcs: Record<number, JsonRpcProvider> = {};
   rpc(chain: number) {
+    console.log("getting rpc for chain", { chain });
     if (chain < 1 || chain == null) throw "Invalid chain";
     if (this.rpcs[chain]) return this.rpcs[chain];
 
@@ -46,38 +47,32 @@ class EvmWallet extends OmniWallet {
     return rpc;
   }
 
-  get omniAddress() {
-    return this.address.toLowerCase();
+  async disconnect() {
+    await this.provider.request?.({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
   }
 
   async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
-    const native = await this.fetchBalance(chain, "native");
+    if (chain === Network.Omni) return await super.fetchBalances(chain, whitelist);
     try {
-      const res = await fetch(`https://api0.herewallet.app/api/v1/user/balances/${chain}/${this.address}`, { body: JSON.stringify({ whitelist, chain_id: chain }), method: "POST" });
-      if (!res.ok) throw new Error("Failed to fetch balances");
-      const { balances } = await res.json();
-      return { ...balances, native };
+      return await super.fetchBalances(chain, whitelist);
     } catch {
-      const balances = await Promise.all(
-        whitelist.map(async (token) => {
-          const balance = await this.fetchBalance(chain, token);
-          return [token, balance];
-        })
-      );
-      return { ...Object.fromEntries(balances), native };
+      const tasks = whitelist.map(async (token) => [token, await this.fetchBalance(chain, token)]);
+      return Object.fromEntries(await Promise.all(tasks));
     }
   }
 
   async fetchBalance(chain: number, address: string) {
+    if (chain === Network.Omni) return super.fetchBalance(chain, address);
+
     const rpc = this.rpc(chain);
     if (address === "native") {
       const balance = await rpc.getBalance(this.address);
-      return BigInt(balance);
+      return this.setBalance(`${chain}:${address}`, BigInt(balance));
     }
 
     const erc20 = new ethers.Contract(address, erc20abi, rpc);
     const balance = await erc20.balanceOf(this.address);
-    return BigInt(balance);
+    return this.setBalance(`${chain}:${address}`, BigInt(balance));
   }
 
   async signMessage(msg: string) {
@@ -107,20 +102,23 @@ class EvmWallet extends OmniWallet {
     return fee.changeGasLimit(extaLimit);
   }
 
-  async sendTransaction(chain: number, request: TransactionRequest): Promise<string> {
+  async sendTransaction(request: TransactionRequest): Promise<string> {
+    if (!request.chainId) throw "Chain ID is required";
+
     if (!this.provider.request) throw "not impl";
     const provider = new BrowserProvider(this.provider as any);
     const signer = new JsonRpcSigner(provider, this.address);
 
-    await this.provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: `0x${chain.toString(16)}` }] });
+    await this.provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: `0x${request.chainId.toString(16)}` }] });
     const tx = await signer.sendTransaction(request);
     return tx.hash;
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
     if (args.token.address === "native") {
-      return await this.sendTransaction(args.token.chain, {
+      return await this.sendTransaction({
         ...args.gasFee?.evmGas,
+        chainId: args.token.chain,
         from: this.address,
         value: args.amount,
         to: args.receiver,
@@ -129,9 +127,10 @@ class EvmWallet extends OmniWallet {
 
     const erc20 = new ethers.Contract(args.token.address, erc20abi, this.rpc(args.token.chain));
     const tx = await erc20.transfer.populateTransaction(args.receiver, args.amount, { ...args.gasFee?.evmGas });
+    tx.chainId = BigInt(args.token.chain);
     tx.from = this.address;
 
-    return await this.sendTransaction(args.token.chain, tx);
+    return await this.sendTransaction(tx);
   }
 
   async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Commitment> {

package/src/hot-wallet/google.ts

@@ -3,14 +3,14 @@ import { Transaction } from "@stellar/stellar-base";
 import { action, makeObservable } from "mobx";
 import uuid4 from "uuid4";
 
-import { ConnectorType, OmniConnector } from "../OmniConnector";
-import { OmniWallet } from "../OmniWallet";
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
+import { OmniWallet } from "../core/OmniWallet";
 import { WalletType } from "../core/chains";
 
 import EvmWallet from "../evm/wallet";
+import TonWallet from "../ton/wallet";
 import NearWallet from "../near/wallet";
 import SolanaWallet from "../solana/wallet";
-import TonWallet from "../ton/wallet";
 import StellarWallet from "../stellar/wallet";
 import { HotConnector } from "../HotConnector";
 
@@ -52,10 +52,10 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
       const signTransaction = async (transaction: Transaction) => request("stellar:signTransaction", { transaction: transaction.toXDR() });
       this.wallets.push(
         new StellarWallet({
-          rpc: this.wibe3.hotBridge.stellar,
+          rpc: this.wibe3.exchange.bridge.stellar,
           address: account.address,
-          signMessage,
           signTransaction,
+          signMessage,
         })
       );
     }

package/src/index.ts

@@ -1,7 +1,7 @@
 import "@lottiefiles/dotlottie-wc";
 
-export { OmniWallet } from "./OmniWallet";
-export { OmniConnector } from "./OmniConnector";
+export { OmniWallet } from "./core/OmniWallet";
+export { OmniConnector } from "./core/OmniConnector";
 export { HotConnector } from "./HotConnector";
 
 export { Bridge as BridgeWidget } from "./ui/bridge/Bridge";

package/src/near/connector.ts

@@ -1,9 +1,9 @@
 import { NearConnector } from "@hot-labs/near-connect";
 import { runInAction } from "mobx";
 
+import type { HotConnector } from "../HotConnector";
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
 import { WalletType } from "../core/chains";
-import { ConnectorType, OmniConnector } from "../OmniConnector";
-import { HotConnector } from "../HotConnector";
 import NearWallet from "./wallet";
 
 class Connector extends OmniConnector<NearWallet> {

package/src/near/index.ts

@@ -1,6 +1,7 @@
 import { NearConnector as NearConnectorBase } from "@hot-labs/near-connect";
 
-import { HotConnector } from "../HotConnector";
+import type { HotConnector } from "../HotConnector";
+
 import NearConnector from "./connector";
 import NearWallet from "./wallet";
 

package/src/near/rpc.ts

@@ -4,7 +4,6 @@ import { TypedError, FinalExecutionOutcome } from "@near-js/types";
 import { base64 } from "@scure/base";
 
 import { api, NetworkError, TimeoutNetworkError } from "../core/api";
-import { Network } from "../core";
 
 let _nextId = 123;
 
@@ -14,7 +13,7 @@ const wait = (timeout: number) => {
   return new Promise<void>((resolve) => setTimeout(resolve, timeout));
 };
 
-const rpcUrls = [api.getRpcUrl(Network.Near), "https://relmn.aurora.dev", "https://archival-rpc.mainnet.near.org", "https://rpc-near.hapi.mobi", "https://nearrpc.aurora.dev"];
+const rpcUrls = [api.getRpcUrl(1010), "https://relmn.aurora.dev", "https://archival-rpc.mainnet.near.org", "https://rpc-near.hapi.mobi", "https://nearrpc.aurora.dev"];
 
 export class NearRpc extends JsonRpcProvider {
   public providers: string[];

package/src/near/standalone.ts

@@ -0,0 +1,52 @@
+import * as ed from "@noble/ed25519";
+import { SignAndSendTransactionParams, SignAndSendTransactionsParams, SignMessageParams, WalletManifest } from "@hot-labs/near-connect";
+import { hex, base58, base64 } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { serialize } from "borsh";
+
+import NearWallet from "./wallet";
+
+const Nep413MessageSchema = {
+  struct: {
+    message: "string",
+    nonce: { array: { type: "u8", len: 32 } },
+    recipient: "string",
+    callbackUrl: { option: "string" },
+  },
+};
+
+export const createNearWallet = async (privateKeyBuf: Buffer, address?: string) => {
+  const privateKey = privateKeyBuf.slice(0, 32);
+  const publicKeyBuffer = Buffer.from(await ed.getPublicKey(privateKey));
+  const addr = address || hex.encode(publicKeyBuffer);
+  const publicKey = `ed25519:${base58.encode(publicKeyBuffer)}`;
+
+  console.log({ publicKey });
+
+  return new NearWallet(addr, publicKey, {
+    manifest: {} as unknown as WalletManifest,
+    signAndSendTransaction: async (params: SignAndSendTransactionParams) => {
+      throw new Error("Not implemented");
+    },
+
+    signAndSendTransactions: async (params: SignAndSendTransactionsParams) => {
+      throw new Error("Not implemented");
+    },
+
+    signMessage: async (params: SignMessageParams) => {
+      const serializedPrefix = serialize("u32", 2147484061);
+      const serializedParams = serialize(Nep413MessageSchema, params);
+
+      const serializedMessage = new Uint8Array(serializedPrefix.length + serializedParams.length);
+      serializedMessage.set(serializedPrefix);
+      serializedMessage.set(serializedParams, serializedPrefix.length);
+
+      const signature = base64.encode(await ed.sign(sha256(serializedMessage), privateKey));
+      return { accountId: addr, publicKey, signature };
+    },
+
+    getAccounts: async () => [{ accountId: addr, publicKey: publicKey }],
+    signIn: async () => [{ accountId: addr, publicKey: publicKey }],
+    signOut: async () => {},
+  });
+};

package/src/near/wallet.ts

@@ -1,17 +1,24 @@
 import { NearWalletBase, SignMessageParams, SignedMessage, SignAndSendTransactionParams, SignAndSendTransactionsParams } from "@hot-labs/near-connect";
 import { base64, base58 } from "@scure/base";
+import crypto from "crypto";
 
-import { OmniWallet } from "../OmniWallet";
-import { WalletType } from "../core/chains";
+import { OmniWallet } from "../core/OmniWallet";
+import { Network, WalletType } from "../core/chains";
 import { ReviewFee } from "../core/bridge";
 import { Token } from "../core/token";
 import { Commitment } from "../core";
+
 import { rpc, TGAS } from "./rpc";
+import { createNearWallet } from "./standalone";
 
 export default class NearWallet extends OmniWallet {
   readonly icon = "https://storage.herewallet.app/upload/73a44e583769f11112b0eff1f2dd2a560c05eed5f6d92f0c03484fa047c31668.png";
   readonly type = WalletType.NEAR;
 
+  static fromPrivateKey(privateKey: Buffer, address?: string) {
+    return createNearWallet(privateKey, address);
+  }
+
   constructor(readonly address: string, readonly publicKey?: string, readonly wallet?: NearWalletBase) {
     super();
   }
@@ -20,15 +27,14 @@ export default class NearWallet extends OmniWallet {
     return this.address;
   }
 
-  async fetchBalances(_: number, whitelist: string[]): Promise<Record<string, bigint>> {
-    const balances = await Promise.all(
-      whitelist.map(async (token) => {
-        const balance = await this.fetchBalance(1010, token);
-        return [token, balance];
-      })
-    );
-
-    return Object.fromEntries(balances);
+  async fetchBalances(chain: number, whitelist: string[] = []): Promise<Record<string, bigint>> {
+    if (chain === Network.Omni) return await super.fetchBalances(chain, whitelist);
+    try {
+      return await super.fetchBalances(chain, whitelist);
+    } catch (error) {
+      const tasks = whitelist.map(async (token) => [token, await this.fetchBalance(chain, token)]);
+      return Object.fromEntries(await Promise.all(tasks));
+    }
   }
 
   async sendTransactions(params: SignAndSendTransactionsParams): Promise<string[]> {
@@ -111,7 +117,7 @@ export default class NearWallet extends OmniWallet {
   }
 
   async fetchBalance(chain: number, address: string) {
-    if (chain !== 1010) throw "Invalid chain";
+    if (chain !== 1010) return super.fetchBalance(chain, address);
 
     if (address === "native") {
       const protocolConfig = await rpc.experimental_protocolConfig({ finality: "near-final" });
@@ -121,7 +127,7 @@ export default class NearWallet extends OmniWallet {
       const locked = BigInt(state.locked);
       const total = BigInt(state.amount) + locked;
       const available = total - (locked > usedOnStorage ? locked : usedOnStorage);
-      return available < 0n ? 0n : available;
+      return this.setBalance(`${chain}:${address}`, available < 0n ? 0n : available);
     }
 
     const balance = await rpc.viewMethod({
@@ -130,7 +136,7 @@ export default class NearWallet extends OmniWallet {
       methodName: "ft_balance_of",
     });
 
-    return BigInt(balance);
+    return this.setBalance(`${chain}:${address}`, BigInt(balance));
   }
 
   async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }) {
@@ -207,7 +213,7 @@ export default class NearWallet extends OmniWallet {
   async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number; signerId?: string }): Promise<Commitment> {
     if (!this.wallet) throw "not impl";
 
-    const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+    const nonce = new Uint8Array(options?.nonce || crypto.randomBytes(32));
     const message = JSON.stringify({
       deadline: options?.deadline ? new Date(options.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
       signer_id: options?.signerId || this.omniAddress,

package/src/solana/connector.ts

@@ -3,9 +3,10 @@ import { Transaction, PublicKey, VersionedTransaction, Connection } from "@solan
 import { base58 } from "@scure/base";
 import { runInAction } from "mobx";
 
-import { ConnectorType, OmniConnector, WC_ICON } from "../OmniConnector";
-import { HotConnector } from "../HotConnector";
-import { OmniWallet } from "../OmniWallet";
+import type { HotConnector } from "../HotConnector";
+
+import { ConnectorType, OmniConnector, WC_ICON } from "../core/OmniConnector";
+import { OmniWallet } from "../core/OmniWallet";
 import { WalletType } from "../core/chains";
 import HOT from "../hot-wallet/iframe";
 
@@ -16,8 +17,8 @@ import SolanaWallet from "./wallet";
 const wallets = getWallets();
 
 class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
-  type = ConnectorType.WALLET;
   walletTypes = [WalletType.SOLANA, WalletType.OMNI];
+  type = ConnectorType.WALLET;
 
   icon = "https://storage.herewallet.app/upload/8700f33153ad813e133e5bf9b791b5ecbeea66edca6b8d17aeccb8048eb29ef7.png";
   name = "Solana Wallet";
@@ -70,8 +71,16 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
     });
 
     this.initWalletConnect()
-      .then(async (wc) => {
-        this.options.unshift({ type: "external", download: "https://www.walletconnect.com/get", wallet: {} as Wallet, name: "WalletConnect", id: "walletconnect", icon: WC_ICON });
+      .then(async () => {
+        this.options.unshift({
+          type: "external",
+          download: "https://www.walletconnect.com/get",
+          wallet: {} as Wallet,
+          name: "WalletConnect",
+          id: "walletconnect",
+          icon: WC_ICON,
+        });
+
         const selected = await this.getConnectedWallet();
         if (selected.type !== "walletconnect") return;
         this.setupWalletConnect();

package/src/solana/wallet.ts

@@ -7,14 +7,14 @@ import {
   getMinimumBalanceForRentExemptAccount,
   createAssociatedTokenAccountInstruction,
   createTransferInstruction,
-  getAccount,
   ASSOCIATED_TOKEN_PROGRAM_ID,
   getAssociatedTokenAddressSync,
   createTransferCheckedInstruction,
+  getAccount,
 } from "@solana/spl-token";
 
 import { Network, WalletType } from "../core/chains";
-import { OmniWallet } from "../OmniWallet";
+import { OmniWallet } from "../core/OmniWallet";
 
 import { Token } from "../core/token";
 import { formatter } from "../core/utils";
@@ -50,17 +50,18 @@ class SolanaWallet extends OmniWallet {
     return hex.encode(base58.decode(this.address)).toLowerCase();
   }
 
-  async fetchBalance(_: number, address: string) {
+  async fetchBalance(chain: number, address: string) {
+    if (chain !== Network.Solana) return super.fetchBalance(chain, address);
     const connection = this.getConnection();
 
     if (address === "native") {
       const balance = await connection.getBalance(new PublicKey(this.address));
-      return BigInt(balance);
+      return this.setBalance(`${chain}:${address}`, BigInt(balance));
     }
 
     const ATA = getAssociatedTokenAddressSync(new PublicKey(address), new PublicKey(this.address));
     const meta = await connection.getTokenAccountBalance(ATA);
-    return BigInt(meta.value.amount);
+    return this.setBalance(`${chain}:${address}`, BigInt(meta.value.amount));
   }
 
   async buildTranferInstructions(token: Token, amount: bigint, receiver: string, fee: ReviewFee) {
@@ -174,15 +175,13 @@ class SolanaWallet extends OmniWallet {
     return await this.wallet.sendTransaction(transaction, connection, { preflightCommitment: "confirmed" });
   }
 
-  async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
-    const native = await this.fetchBalance(chain, "native");
-    const connection = this.getConnection();
-
+  async fetchBalances(chain: number, whitelist: string[] = []): Promise<Record<string, bigint>> {
+    if (chain === Network.Omni) return await super.fetchBalances(chain, whitelist);
     try {
-      const res = await fetch(`https://api0.herewallet.app/api/v1/user/balances/${chain}/${this.address}`, { body: JSON.stringify({ whitelist }), method: "POST" });
-      const { balances } = await res.json();
-      return { ...balances, native };
+      return await super.fetchBalances(chain, whitelist);
     } catch {
+      const connection = this.getConnection();
+      const native = await this.fetchBalance(chain, "native");
       const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(this.address), { programId: TOKEN_PROGRAM_ID });
       const balances = Object.fromEntries(
         tokenAccounts.value.map((account) => {
@@ -191,6 +190,7 @@ class SolanaWallet extends OmniWallet {
         })
       );
 
+      Object.entries(balances).forEach(([address, balance]) => this.setBalance(`${chain}:${address}`, BigInt(balance as string)));
       return { ...balances, native };
     }
   }

package/src/stellar/connector.ts

@@ -1,10 +1,10 @@
 import { Transaction } from "@stellar/stellar-base";
 
 import HOT from "../hot-wallet/iframe";
-import { WalletType } from "../core/chains";
-import { HotConnector } from "../HotConnector";
-import { ConnectorType, OmniConnector } from "../OmniConnector";
+import type { HotConnector } from "../HotConnector";
 
+import { WalletType } from "../core/chains";
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
 import { FreighterModule } from "./freigher";
 import { HotWalletModule } from "./hotWallet";
 import StellarWallet from "./wallet";
@@ -56,7 +56,8 @@ class StellarConnector extends OmniConnector<StellarWallet> {
   async selectWallet(address: string, wallet: HotWalletModule | FreighterModule) {
     const signMessage = async (message: string) => wallet.signMessage(message);
     const signTransaction = async (transaction: Transaction) => wallet.signTransaction(transaction.toXDR());
-    return this.setWallet(new StellarWallet({ address, rpc: this.wibe3.hotBridge.stellar, signMessage, signTransaction }));
+    const instance = new StellarWallet({ address, rpc: this.wibe3.exchange.bridge.stellar, signMessage, signTransaction });
+    return this.setWallet(instance);
   }
 
   async connect(id: string) {

package/src/stellar/wallet.ts

@@ -2,13 +2,13 @@ import { base64, base58, hex, base32 } from "@scure/base";
 import { Address, Asset, BASE_FEE, Claimant, Contract, Memo, nativeToScVal, Networks, Operation, TimeoutInfinite, Transaction, TransactionBuilder, xdr } from "@stellar/stellar-base";
 import { rpc } from "@stellar/stellar-sdk";
 
+import { Commitment } from "../core/types";
 import { WalletType } from "../core/chains";
-import { OmniWallet } from "../OmniWallet";
+import { OmniWallet } from "../core/OmniWallet";
 import { ReviewFee } from "../core/bridge";
 import { formatter } from "../core/utils";
 import { Network } from "../core/chains";
 import { Token } from "../core/token";
-import { Commitment } from "../core";
 
 interface ProtocolWallet {
   address: string;
@@ -52,30 +52,36 @@ class StellarWallet extends OmniWallet {
     return hex.encode(payload.slice(1, -2));
   }
 
-  async fetchBalances(): Promise<Record<string, bigint>> {
-    const data = await fetch(`https://horizon.stellar.org/accounts/${this.address}`).then((res) => res.json());
-    const balances = data.balances?.map((ft: { asset_type: string; sponsor?: string | null; asset_code: string; asset_issuer: string; balance: string }) => {
-      const asset = ft.asset_type === "native" ? Asset.native() : new Asset(ft.asset_code, ft.asset_issuer);
-      const contractId = ft.asset_type === "native" ? "native" : asset.contractId(Networks.PUBLIC);
-
-      if (contractId === "native") {
-        const activatingReserve = ft.sponsor != null ? 0 : 1;
-        const trustlines = data.balances.filter((t: any) => t.asset_type !== "native" && t.sponsor == null);
-        const balance = BigInt(formatter.parseAmount(ft.balance, 7));
-        const reserved = BigInt(formatter.parseAmount(activatingReserve + 0.5 * (trustlines.length + (data.num_sponsoring || 0)), 7));
-        return [contractId, formatter.bigIntMax(0n, balance - BigInt(reserved))];
-      }
-
-      return [contractId, BigInt(formatter.parseAmount(ft.balance, 7))];
-    });
+  async fetchBalances(chain: number): Promise<Record<string, bigint>> {
+    if (chain === Network.Omni) return await super.fetchBalances(chain);
+    try {
+      return await super.fetchBalances(chain);
+    } catch {
+      const data = await fetch(`https://horizon.stellar.org/accounts/${this.address}`).then((res) => res.json());
+      const balances = data.balances?.map((ft: { asset_type: string; sponsor?: string | null; asset_code: string; asset_issuer: string; balance: string }) => {
+        const asset = ft.asset_type === "native" ? Asset.native() : new Asset(ft.asset_code, ft.asset_issuer);
+        const contractId = ft.asset_type === "native" ? "native" : asset.contractId(Networks.PUBLIC);
+
+        if (contractId === "native") {
+          const activatingReserve = ft.sponsor != null ? 0 : 1;
+          const trustlines = data.balances.filter((t: any) => t.asset_type !== "native" && t.sponsor == null);
+          const balance = BigInt(formatter.parseAmount(ft.balance, 7));
+          const reserved = BigInt(formatter.parseAmount(activatingReserve + 0.5 * (trustlines.length + (data.num_sponsoring || 0)), 7));
+          return [contractId, formatter.bigIntMax(0n, balance - BigInt(reserved))];
+        }
+
+        return [contractId, BigInt(formatter.parseAmount(ft.balance, 7))];
+      });
 
-    return Object.fromEntries(balances);
+      Object.entries(balances).forEach(([address, balance]) => this.setBalance(`${chain}:${address}`, BigInt(balance as string)));
+      return Object.fromEntries(balances);
+    }
   }
 
   async fetchBalance(chain: number, token: string): Promise<bigint> {
-    if (chain !== Network.Stellar) throw "Invalid chain";
-    const balances = await this.fetchBalances();
-    return balances[token] || 0n;
+    if (chain !== Network.Stellar) return super.fetchBalance(chain, token);
+    const balances = await this.fetchBalances(chain);
+    return this.setBalance(`${chain}:${token}`, balances[token] || 0n);
   }
 
   async transferFee(token: Token): Promise<ReviewFee> {

package/src/ton/connector.ts

@@ -1,10 +1,11 @@
 import { TonConnectUI, TonConnect, Feature } from "@tonconnect/ui";
 import { runInAction } from "mobx";
 
-import { WalletType } from "../core/chains";
-import { HotConnector } from "../HotConnector";
-import { ConnectorType, OmniConnector } from "../OmniConnector";
+import type { HotConnector } from "../HotConnector";
 import HOT from "../hot-wallet/iframe";
+
+import { WalletType } from "../core/chains";
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
 import TonWallet from "./wallet";
 
 export interface TonConnectorOptions {

package/src/ton/wallet.ts

@@ -4,8 +4,8 @@ import { JettonVerificationType } from "@ton-api/client";
 import { toUserFriendlyAddress } from "@tonconnect/ui";
 import { base58, base64, hex } from "@scure/base";
 
-import { OmniWallet } from "../OmniWallet";
-import { WalletType } from "../core/chains";
+import { OmniWallet } from "../core/OmniWallet";
+import { Network, WalletType } from "../core/chains";
 import { ReviewFee } from "../core/bridge";
 import { Token } from "../core/token";
 
@@ -40,31 +40,37 @@ class TonWallet extends OmniWallet {
     return this.wallet.account.publicKey.toLowerCase();
   }
 
-  async fetchBalances(): Promise<Record<string, bigint>> {
-    const native = await this.fetchBalance(1111, "native");
-    const { balances } = await tonApi.accounts.getAccountJettonsBalances(Address.parse(this.address), { supported_extensions: ["custom_payload"] });
-    const list: Record<string, bigint> = {};
-
-    balances.map((data) => {
-      const jetton = data.jetton.address.toString();
-      const isScam = data.walletAddress.isScam || data.jetton.verification === JettonVerificationType.Blacklist;
-      if (isScam) return;
-      list[jetton] = BigInt(data.balance);
-    });
-
-    return { ...list, native };
+  async fetchBalances(chain: number): Promise<Record<string, bigint>> {
+    if (chain === Network.Omni) return await super.fetchBalances(chain);
+    try {
+      return await super.fetchBalances(chain);
+    } catch {
+      const native = await this.fetchBalance(chain, "native");
+      const { balances } = await tonApi.accounts.getAccountJettonsBalances(Address.parse(this.address), { supported_extensions: ["custom_payload"] });
+      const list: Record<string, bigint> = {};
+
+      balances.map((data) => {
+        const jetton = data.jetton.address.toString();
+        if (data.walletAddress.isScam || data.jetton.verification === JettonVerificationType.Blacklist) return;
+        list[jetton] = BigInt(data.balance);
+      });
+
+      Object.entries(list).forEach(([address, balance]) => this.setBalance(`${chain}:${address}`, balance));
+      return { ...list, native };
+    }
   }
 
-  async fetchBalance(_: number, address: string) {
+  async fetchBalance(chain: number, address: string) {
+    if (chain !== Network.Ton) return super.fetchBalance(chain, address);
     const owner = Address.parse(this.address);
 
     if (address === "native") {
       const balance = await tonApi.accounts.getAccount(owner);
-      return BigInt(balance.balance);
+      return this.setBalance(`${Network.Ton}:${address}`, BigInt(balance.balance));
     }
 
     const jetton = await tonApi.accounts.getAccountJettonBalance(owner, Address.parse(address), { supported_extensions: ["custom_payload"] });
-    return BigInt(jetton.balance);
+    return this.setBalance(`${Network.Ton}:${address}`, BigInt(jetton.balance));
   }
 
   async waitNextSeqno(seqno: number): Promise<number> {

package/src/tron/connector.ts

@@ -1,6 +1,6 @@
+import type { HotConnector } from "../HotConnector";
+import { ConnectorType, OmniConnector } from "../core/OmniConnector";
 import { WalletType } from "../core/chains";
-import { ConnectorType, OmniConnector } from "../OmniConnector";
-import { HotConnector } from "../HotConnector";
 import TronWallet from "./wallet";
 
 declare global {