@hot-labs/kit 1.3.3 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-labs/kit",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "description": "HOT Labs Kit is chain agnostic connector with omni payments",
   "license": "ISC",
   "author": "",

package/src/HotConnector.ts

@@ -2,14 +2,15 @@ import { computed, makeObservable, observable, runInAction } from "mobx";
 
 import packageJson from "../package.json";
 
+import { Exchange } from "./core/exchange";
+import { Telemetry } from "./core/telemetry";
+import { OmniWallet } from "./core/OmniWallet";
 import { ChainConfig, chains, Network, WalletType } from "./core/chains";
-import { createHotBridge, HotBridge } from "./core/bridge";
 import { EventEmitter } from "./core/events";
 import { Recipient } from "./core/recipient";
 import { OmniToken } from "./core/chains";
 import { Intents } from "./core/Intents";
 import { tokens } from "./core/tokens";
-import { Telemetry } from "./core/telemetry";
 import { Token } from "./core/token";
 import { api } from "./core/api";
 import { rpc } from "./near/rpc";
@@ -23,11 +24,9 @@ import type StellarWallet from "./stellar/wallet";
 import type TonWallet from "./ton/wallet";
 
 import { openBridge, openConnector, openProfile, openWalletPicker } from "./ui/router";
-import { ConnectorType, OmniConnector } from "./OmniConnector";
-import { OmniWallet } from "./OmniWallet";
-import { Exchange } from "./exchange";
-import { Activity } from "./activity";
+import { ConnectorType, OmniConnector } from "./core/OmniConnector";
 import { DataStorage, LocalStorage } from "./storage";
+import { Activity } from "./activity";
 
 interface HotConnectorOptions {
   apiKey: string;
@@ -48,13 +47,10 @@ interface HotConnectorOptions {
 export class HotConnector {
   public storage: DataStorage;
   public connectors: OmniConnector[] = [];
-  public balances: Record<string, Record<string, bigint>> = {};
   public telemetry: Telemetry;
-
-  public activity: Activity;
-  public hotBridge: HotBridge;
   public exchange: Exchange;
 
+  public activity: Activity;
   public version = packageJson.version;
 
   private events = new EventEmitter<{
@@ -71,8 +67,6 @@ export class HotConnector {
 
   constructor(options?: HotConnectorOptions) {
     makeObservable(this, {
-      balances: observable,
-
       priorityWallet: computed,
       walletsTokens: computed,
       wallets: computed,
@@ -93,9 +87,8 @@ export class HotConnector {
 
     this.storage = options?.storage ?? new LocalStorage();
     this.telemetry = new Telemetry(this);
-    this.hotBridge = createHotBridge();
-    this.exchange = new Exchange(this);
     this.activity = new Activity(this);
+    this.exchange = new Exchange();
 
     const connectors: OmniConnector[] = [];
     const configConnectors = options?.connectors || defaultConnectors;
@@ -116,21 +109,17 @@ export class HotConnector {
     });
 
     this.onConnect((payload) => {
+      console.log("onConnect", payload.wallet.type);
+      payload.wallet.fetchBalances(Network.Omni);
       this.fetchTokens(payload.wallet);
-      this.fetchOmniTokens(payload.wallet);
-    });
-
-    this.onDisconnect(({ wallet }) => {
-      if (!wallet) return;
-      runInAction(() => (this.balances[`${wallet.type}:${wallet.address}`] = {}));
     });
 
     tokens.startTokenPolling();
   }
 
   setOmniChainBranding(branding: { name: string; icon: string }) {
-    chains.get(Network.Hot).name = branding.name;
-    chains.get(Network.Hot).logo = branding.icon;
+    chains.get(Network.Omni).name = branding.name;
+    chains.get(Network.Omni).logo = branding.icon;
   }
 
   getWalletConnector(type: WalletType): OmniConnector | null {
@@ -228,7 +217,7 @@ export class HotConnector {
       .reduce((acc: number, token: Token) => {
         return this.wallets.reduce((acc: number, wallet) => {
           if (token.chain === chain) return acc;
-          const balance = this.balances[`${wallet.type}:${wallet.address}`][token.id] ?? 0n;
+          const balance = wallet.getBalance(token.id);
           return acc + token.float(balance) * token.usd;
         }, acc);
       }, 0);
@@ -236,7 +225,7 @@ export class HotConnector {
 
   balance(wallet?: OmniWallet, token?: Token) {
     if (!wallet || !token) return 0n;
-    return this.balances[`${wallet.type}:${wallet.address}`]?.[token.id] ?? 0n;
+    return wallet.getBalance(token.id);
   }
 
   omniBalance(token: OmniToken) {
@@ -254,37 +243,10 @@ export class HotConnector {
   }
 
   async fetchToken(token: Token, wallet: OmniWallet) {
-    const key = `${wallet.type}:${wallet.address}`;
-
-    if (token.type === WalletType.OMNI) {
-      if (!wallet.omniAddress) return 0n;
-      const balances = await Intents.getIntentsBalances([token.address], wallet.omniAddress);
-      runInAction(() => (this.balances[key][token.id] = balances[token.address]));
-      return balances[token.address] ?? 0n;
-    }
-
-    if (token.type === wallet.type) {
-      const balance = await wallet.fetchBalance(token.chain, token.address);
-      runInAction(() => (this.balances[key][token.id] = balance));
-      return balance;
-    }
-
-    return 0n;
-  }
-
-  async fetchOmniTokens(wallet: OmniWallet) {
-    const key = `${wallet.type}:${wallet.address}`;
-    const assets = await wallet.getAssets();
-    runInAction(() => {
-      Object.keys(assets).forEach((id) => {
-        this.balances[key][`-4:${id}`] = assets[id];
-      });
-    });
+    return await wallet.fetchBalance(token.chain, token.address);
   }
 
   async fetchTokens(wallet: OmniWallet) {
-    const key = `${wallet.type}:${wallet.address}`;
-    if (!this.balances[key]) runInAction(() => (this.balances[key] = {}));
     const tokensList = (await tokens.getTokens()).filter((t) => t.type === wallet.type && t.type !== WalletType.OMNI);
 
     // Group tokens by their chain
@@ -294,14 +256,8 @@ export class HotConnector {
       return acc;
     }, {} as Record<number, string[]>);
 
-    Object.entries(groups).forEach(async ([chain, tokens]) => {
-      const balances = await wallet.fetchBalances(+chain, tokens);
-      runInAction(() => {
-        for (const [token, balance] of Object.entries(balances)) {
-          this.balances[key][`${chain}:${token}`] = balance;
-        }
-      });
-    });
+    const tasks = Object.entries(groups).map(([chain, tokens]) => wallet.fetchBalances(+chain, tokens));
+    await Promise.allSettled(tasks);
   }
 
   intentsBuilder(wallet?: OmniWallet) {

package/src/activity.ts

@@ -3,8 +3,8 @@ import { computed, makeObservable, observable, runInAction } from "mobx";
 import { hex } from "@scure/base";
 
 import { chains, Network, WalletType } from "./core";
+import { OmniWallet } from "./core/OmniWallet";
 import { HotConnector } from "./HotConnector";
-import { OmniWallet } from "./OmniWallet";
 
 export class Activity {
   withdrawals: Record<number, (WithdrawArgsWithPending & { loading?: boolean })[]> = {};
@@ -25,7 +25,7 @@ export class Activity {
 
       if (withdrawal.chain === Network.Stellar) {
         if (!this.kit.stellar) throw new Error("Stellar wallet not connected");
-        await this.kit.hotBridge.stellar.withdraw({
+        await this.kit.exchange.bridge.stellar.withdraw({
           sendTransaction: (tx: any) => this.kit.stellar!.sendTransaction(tx),
           sender: this.kit.stellar.address,
           ...withdrawal,
@@ -34,7 +34,7 @@ export class Activity {
 
       if (withdrawal.chain === Network.Solana) {
         if (!this.kit.solana) throw new Error("Solana wallet not connected");
-        const solana = await this.kit.hotBridge.solana();
+        const solana = await this.kit.exchange.bridge.solana();
         await solana.withdraw({
           sendTransaction: (tx: any) => this.kit.solana!.sendTransaction(tx),
           sender: this.kit.solana.address,
@@ -44,7 +44,7 @@ export class Activity {
 
       if (withdrawal.chain === Network.Ton || withdrawal.chain === Network.OmniTon) {
         if (!this.kit.ton) throw new Error("Ton wallet not connected");
-        await this.kit.hotBridge.ton.withdraw({
+        await this.kit.exchange.bridge.ton.withdraw({
           sendTransaction: (tx: any) => this.kit.ton!.sendTransaction(tx),
           refundAddress: this.kit.ton.address,
           ...withdrawal,
@@ -53,15 +53,15 @@ export class Activity {
 
       if (chains.get(withdrawal.chain).type === WalletType.EVM) {
         if (!this.kit.evm) throw new Error("EVM wallet not connected");
-        await this.kit.hotBridge.evm.withdraw({
-          sendTransaction: (tx: any) => this.kit.evm!.sendTransaction(withdrawal.chain, tx),
+        await this.kit.exchange.bridge.evm.withdraw({
+          sendTransaction: (tx: any) => this.kit.evm!.sendTransaction(tx),
           ...withdrawal,
         });
       }
 
       if (withdrawal.chain === Network.Gonka) {
         if (!this.kit.cosmos) throw new Error("Gonka wallet not connected");
-        const cosmos = await this.kit.hotBridge.cosmos();
+        const cosmos = await this.kit.exchange.bridge.cosmos();
         await cosmos.withdraw({
           sendTransaction: (tx: any) => this.kit.cosmos!.sendTransaction(tx),
           senderPublicKey: hex.decode(this.kit.cosmos.publicKey!),
@@ -70,7 +70,7 @@ export class Activity {
         });
       }
 
-      await this.kit.hotBridge.clearPendingWithdrawals([withdrawal]).catch(() => {});
+      await this.kit.exchange.bridge.clearPendingWithdrawals([withdrawal]).catch(() => {});
     } finally {
       runInAction(() => (withdrawal.loading = false));
       const wallet = this.kit.wallets.find((w) => w.type === chains.get(withdrawal.chain).type);
@@ -85,7 +85,7 @@ export class Activity {
   }
 
   async fetchPendingWithdrawalsByChain(chain: number, wallet: OmniWallet) {
-    const pendings = await this.kit.hotBridge.getPendingWithdrawalsWithStatus(chain, wallet.address);
+    const pendings = await this.kit.exchange.bridge.getPendingWithdrawalsWithStatus(chain, wallet.address);
     runInAction(() => (this.withdrawals[chain] = pendings.filter((t) => !t.completed)));
   }
 }

package/src/core/Intents.ts

@@ -1,11 +1,11 @@
 import { sha256 } from "@noble/hashes/sha2.js";
 
 import type { HotConnector } from "../HotConnector";
-import type { OmniWallet } from "../OmniWallet";
+import type { OmniWallet } from "./OmniWallet";
 import { rpc } from "../near/rpc";
 
 import type { Intent, Commitment, TokenDiffIntent, MtWithdrawIntent, FtWithdrawIntent, NftWithdrawIntent, TransferIntent } from "./types";
-import type { BridgeReview } from "../exchange";
+import type { BridgeReview } from "./exchange";
 
 import { OmniToken } from "./chains";
 import { formatter } from "./utils";
@@ -376,6 +376,7 @@ export class Intents {
   }
 
   async simulate() {
+    if (this.unsignedCommitment != null) await this.sign();
     if (this.commitments.length === 0) throw new Error("No commitments attached");
     return await Intents.simulateIntents(this.commitments);
   }
@@ -479,7 +480,7 @@ export class Intents {
 
     const payableToken = tokens.get(Array.from(this.need.keys())[0]);
     const payableAmount = this.need.get(payableToken.omniAddress as OmniToken) || 0n;
-    await this.signer?.waitUntilBalance({ [payableToken.omniAddress]: payableAmount });
+    await this.signer?.waitUntilOmniBalance({ [payableToken.omniAddress]: payableAmount });
 
     await this.execute().finally(() => close());
   }
@@ -518,6 +519,16 @@ export class Intents {
     return hash;
   }
 
+  static async getPublicKeys(accountId: string): Promise<string[]> {
+    const keys = await rpc.viewMethod({
+      args: { account_id: accountId },
+      methodName: "public_keys_of",
+      contractId: "intents.near",
+    });
+
+    return keys.map((key: string) => key.split(":")[1]);
+  }
+
   static async hasPublicKey(accountId: string, publicKey: string): Promise<boolean> {
     return await rpc.viewMethod({
       args: { account_id: accountId, public_key: publicKey },

package/src/{OmniConnector.ts → core/OmniConnector.ts}

@@ -1,13 +1,10 @@
 import { makeObservable, observable, runInAction } from "mobx";
 import UniversalProvider, { NamespaceConfig } from "@walletconnect/universal-provider";
 
-import { EventEmitter } from "./core/events";
-import { LocalStorage } from "./storage";
-import { HotConnector } from "./HotConnector";
-
+import type { HotConnector } from "../HotConnector";
+import { EventEmitter } from "./events";
 import { OmniWallet } from "./OmniWallet";
-import { WalletType } from "./core/chains";
-import { openWCRequest } from "./ui/router";
+import { WalletType } from "./chains";
 
 export enum ConnectorType {
   WALLET = "wallet",
@@ -82,6 +79,7 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
   }
 
   async requestWalletConnect<T>(args: { chain?: string; request: any; deeplink?: string; name?: string; icon?: string }): Promise<T> {
+    const { openWCRequest } = await import("../ui/router");
     return openWCRequest<T>({
       deeplink: args.deeplink,
       name: args.name || "WalletConnect",

package/src/core/OmniWallet.ts

@@ -0,0 +1,125 @@
+import { hex } from "@scure/base";
+import { action, makeObservable, observable } from "mobx";
+
+import type { HotConnector } from "../HotConnector";
+import { Commitment } from "./types";
+import { WalletType } from "./chains";
+import { Intents } from "./Intents";
+import { ReviewFee } from "./bridge";
+import { Token } from "./token";
+import { api } from "./api";
+
+export abstract class OmniWallet {
+  balances: Record<string, bigint> = {};
+
+  abstract address: string;
+  abstract publicKey?: string;
+  abstract omniAddress: string;
+  abstract type: WalletType;
+  abstract icon: string;
+
+  constructor() {
+    makeObservable(this, { balances: observable, setBalance: action });
+  }
+
+  intents(wibe3?: HotConnector) {
+    return new Intents(wibe3).attachWallet(this);
+  }
+
+  setBalance(id: string, balance: bigint) {
+    this.balances[id] = balance;
+    return balance;
+  }
+
+  getBalance(id: string) {
+    return this.balances[id] ?? 0n;
+  }
+
+  async depositNfts(nftIds: string[], receiver: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  async getDepositNftsFee(nfts: string[]) {
+    return new ReviewFee({ chain: -4 });
+  }
+
+  async withdrawNfts(nftIds: string[], receiver: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  async transferNft(nftId: string, receiver: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  async sendTransaction(tx: any): Promise<string> {
+    throw new Error("Method not implemented.");
+  }
+
+  async getTranferNftFee(nftId: string, receiver: string) {
+    return new ReviewFee({ chain: -4 });
+  }
+
+  async getNfts(onLoad: (nfts: string[]) => void) {}
+
+  async transferFee(token: Token, receiver: string, amount: bigint): Promise<ReviewFee> {
+    return new ReviewFee({ chain: -4 });
+  }
+
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    throw new Error("Method not implemented.");
+  }
+
+  async fetchBalance(chain: number, address: string): Promise<bigint> {
+    if (chain !== -4) return 0n;
+    const balances = await Intents.getIntentsBalances([address], this.omniAddress);
+    return this.setBalance(`${chain}:${address}`, balances[address] || 0n);
+  }
+
+  async fetchBalances(chain: number, whitelist: string[] = []): Promise<Record<string, bigint>> {
+    if (chain === -4) {
+      const list = whitelist.length > 0 ? whitelist : await Intents.getIntentsAssets(this.omniAddress);
+      const balances = await Intents.getIntentsBalances(list, this.omniAddress);
+      Object.entries(balances).forEach(([address, balance]) => this.setBalance(`${chain}:${address}`, BigInt(balance as unknown as string)));
+      return balances;
+    }
+
+    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();
+
+    console.log("fetchBalances", { chain, whitelist, balances, l: Object.keys(balances).length });
+    if (Object.keys(balances).length === 0) throw "No balances found";
+
+    Object.entries(balances).forEach(([address, balance]) => this.setBalance(`${chain}:${address}`, BigInt(balance as string)));
+    const native = await this.fetchBalance(chain, "native").catch(() => 0n);
+    return { ...balances, native };
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number; signerId?: string }): Promise<Commitment> {
+    throw new Error("Method not implemented.");
+  }
+
+  async auth<T = string>(intents?: Record<string, any>[], options?: { domain?: string; signerId?: string; customAuth?: (commitment: Commitment, seed: string) => Promise<T> }): Promise<T> {
+    const authFn = async () => {
+      const seed = hex.encode(new Uint8Array(window.crypto.getRandomValues(new Uint8Array(32))));
+      const msgBuffer = new TextEncoder().encode(`${options?.domain || window.location.origin}_${seed}`);
+      const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
+      const signed = await this.signIntents(intents || [], { nonce: new Uint8Array(nonce), signerId: options?.signerId || this.omniAddress });
+
+      if (options?.customAuth) return await options.customAuth(signed, seed);
+      return (await api.auth(signed, seed)) as T;
+    };
+
+    if (typeof window === "undefined") return await authFn();
+    const { openAuthPopup } = await import("../ui/connect/AuthPopup");
+    return openAuthPopup(this, authFn);
+  }
+
+  async waitUntilOmniBalance(need: Record<string, bigint>, receiver = this.omniAddress, attempts = 0) {
+    if (attempts > 120) throw "Balance is not enough";
+    const assets = Object.keys(need) as string[];
+    const balances = await Intents.getIntentsBalances(assets, receiver);
+    if (assets.every((asset) => (balances[asset] || 0n) >= (need[asset] || 0n))) return;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await this.waitUntilOmniBalance(need, receiver, attempts + 1);
+  }
+}

package/src/core/address.ts

@@ -0,0 +1,155 @@
+import { Address } from "@ton/core";
+import { Address as StellarAddress } from "@stellar/stellar-sdk";
+import { base32, base58, hex } from "@scure/base";
+import { sha256 } from "@noble/hashes/sha2.js";
+import * as ethers from "ethers";
+import { chains, Network, WalletType } from "./chains";
+
+export const MinAccountIdLen = 2;
+export const MaxAccountIdLen = 64;
+export const ValidAccountRe = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+export const NEAR_DOMAINS = [".near", ".sweat", ".usn", ".tg"];
+export const NEAR_ADDRESS_HEX_LENGTH = 64;
+export const EVM_DOMAINS = [".eth", ".cb.id"];
+
+export const validateAddress = (address: string) => {
+  if (isValidNearAddress(address)) return { chainId: Network.Near, isEvm: false };
+  if (isValidSolanaAddress(address)) return { chainId: Network.Solana, isEvm: false };
+  if (isValidTronAddress(address)) return { chainId: Network.Tron, isEvm: false };
+  if (isValidTonAddress(address)) return { chainId: Network.Ton, isEvm: false };
+  if (isValidEvmAddress(address)) return { chainId: 1, isEvm: true };
+  if (isValidBtcAddress(address)) return { chainId: Network.Btc, isEvm: false };
+  if (isValidStellarAddress(address)) return { chainId: Network.Stellar, isEvm: false };
+  return { chainId: -1, isEvm: false };
+};
+
+export const isBase58 = (address: string) => {
+  try {
+    base58.decode(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isBase32 = (address: string) => {
+  try {
+    base32.decode(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isHex = (address: string) => {
+  try {
+    hex.decode(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isValidBtcAddress = (address: string) => {
+  // Basic validation for Bitcoin addresses (P2PKH, P2SH, Bech32)
+  const p2pkhRegex = /^[13][a-km-zA-HJ-NP-Z1-9]{25,34}$/;
+  const p2shRegex = /^[2mn][a-km-zA-HJ-NP-Z1-9]{25,39}$/;
+  const bech32Regex = /^(bc1|[13])[a-zA-HJ-NP-Z0-9]{25,90}$/;
+
+  return p2pkhRegex.test(address) || p2shRegex.test(address) || bech32Regex.test(address);
+};
+
+export function isValidNearAccountId(accountId: string) {
+  return !!accountId && accountId.length >= MinAccountIdLen && accountId.length <= MaxAccountIdLen && accountId.match(ValidAccountRe) != null;
+}
+
+export const isValidNearAddress = (address: string, { allowWithoutDomain, allowSubdomain } = { allowWithoutDomain: false, allowSubdomain: true }) => {
+  if (!isValidNearAccountId(address)) return false;
+
+  if (address.length === NEAR_ADDRESS_HEX_LENGTH) return true;
+  if (allowWithoutDomain && !address.includes(".")) return true;
+
+  const endsWithValidDomain = NEAR_DOMAINS.some((t) => address.endsWith(t));
+  if (!endsWithValidDomain) return false;
+
+  const parts = address.split(".");
+
+  const lastPart = `.${parts[parts.length - 1]}`;
+  if (!NEAR_DOMAINS.includes(lastPart)) return false;
+
+  const otherParts = parts.slice(0, -1);
+  const hasOtherDomains = otherParts.some((part) => NEAR_DOMAINS.includes(`.${part}`));
+  if (hasOtherDomains) return false;
+
+  if (allowSubdomain) return true;
+  return parts.length <= 2;
+};
+
+export const isValidTronAddress = (base58Sting: string) => {
+  if (base58Sting.length <= 4) return false;
+  let address: Uint8Array;
+
+  try {
+    address = base58.decode(base58Sting);
+  } catch (e) {
+    return false;
+  }
+
+  if (base58Sting.length <= 4) return false;
+
+  const len = address.length;
+  const offset = len - 4;
+  const checkSum = address.slice(offset);
+  address = address.slice(0, offset);
+  const hash0 = sha256(address);
+  const hash1 = sha256(new Uint8Array(hash0));
+  const checkSum1 = hash1.slice(0, 4);
+
+  if (checkSum[0] === checkSum1[0] && checkSum[1] === checkSum1[1] && checkSum[2] === checkSum1[2] && checkSum[3] === checkSum1[3]) {
+    return true;
+  }
+
+  return false;
+};
+
+export const isValidSolanaAddress = (address: string) => {
+  if (address.startsWith("0x")) return false;
+  if (ethers.isAddress(address) as boolean) return false;
+  if (isBase58(address) && [32, 44].includes(address.length)) return true;
+  return !!isValidNearAccountId(address) && address.endsWith(".sol");
+};
+
+export const isValidEvmAddress = (address: string) => {
+  return EVM_DOMAINS.some((t) => address.endsWith(t)) || ethers.isAddress(address);
+};
+
+export const isValidStellarAddress = (address: string) => {
+  try {
+    new StellarAddress(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isValidTonAddress = (address: string) => {
+  try {
+    Address.parse(address);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export const isValidAddress = (chain: number, address: string) => {
+  if (chains.get(chain)?.type === WalletType.EVM) return isValidEvmAddress(address);
+  if (chains.get(chain)?.type === WalletType.TON) return isValidTonAddress(address);
+
+  if (chain === Network.Omni) return isValidNearAddress(address, { allowWithoutDomain: true, allowSubdomain: false });
+  if (chain === Network.Near) return isValidNearAddress(address);
+  if (chain === Network.Solana) return isValidSolanaAddress(address);
+  if (chain === Network.Tron) return isValidTronAddress(address);
+  if (chain === Network.Btc) return isValidBtcAddress(address);
+  if (chain === Network.Stellar) return isValidStellarAddress(address);
+  return false;
+};

package/src/core/chains.ts

@@ -34,7 +34,7 @@ export enum WalletType {
 
 export enum Network {
   Omni_v1 = 0,
-  Hot = -4,
+  Omni = -4,
 
   Zcash = -5,
   Btc = -6,
@@ -332,13 +332,13 @@ const chainsRepository: Record<number, ChainConfig> = {
     rpc: rpc(Network.Xlayer),
     type: WalletType.EVM,
   },
-  [Network.Hot]: {
-    id: Network.Hot,
+  [Network.Omni]: {
+    id: Network.Omni,
     key: "hot",
     name: "Omni",
     logo: "https://tgapp.herewallet.app/images/hot/hot-icon.png",
-    currency: { id: "native", symbol: "OMNI", decimals: 6, logo: logo(Network.Hot) },
-    rpc: rpc(Network.Hot),
+    currency: { id: "native", symbol: "OMNI", decimals: 6, logo: logo(Network.Omni) },
+    rpc: rpc(Network.Omni),
     type: WalletType.OMNI,
   },
   [Network.Cardano]: {