@hot-labs/kit 1.3.2 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-labs/kit",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "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,25 +1,24 @@
 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 { OmniToken } from "./chains";
 import { formatter } from "./utils";
 import { tokens } from "./tokens";
 import { api } from "./api";
 
-import { openConnector, openConnectPrimaryWallet, openPayment, openToast } from "../ui/router";
-import { BridgeReview } from "../exchange";
-
 export const TGAS = 1000000000000n;
 
 export class Intents {
   constructor(readonly wibe3?: HotConnector) {}
 
-  static get builder() {
-    return new Intents();
+  static builder(signer?: OmniWallet) {
+    return new Intents().attachWallet(signer);
   }
 
   signedHashes: string[] = [];
@@ -62,6 +61,7 @@ export class Intents {
    * Use this method to pay for a merchant's item created in pay.hot-labs.org
    */
   merchantPayment({ merchantId, token, itemId, email, amount, memo }: { token: OmniToken; merchantId: string; itemId: string; amount: number | bigint; memo: string; email: string }) {
+    if (typeof window === "undefined") throw "Merchant payment is only available in browser";
     return this.transfer({
       msg: JSON.stringify({ merchant_id: merchantId, item_id: itemId, memo: memo }),
       recipient: "pay.fi.tg",
@@ -376,11 +376,13 @@ 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);
   }
 
   async setupSigner() {
+    if (typeof window === "undefined") throw "Setup signer is only available in browser";
     if (!this.wibe3) throw new Error("No wibe3 attached");
     if (this.signer) return this.signer;
 
@@ -389,6 +391,7 @@ export class Intents {
       return this.signer;
     }
 
+    const { openConnectPrimaryWallet, openConnector } = await import("../ui/router");
     if (this.wibe3.wallets.length > 0) await openConnectPrimaryWallet(this.wibe3);
     else await openConnector(this.wibe3);
 
@@ -408,6 +411,7 @@ export class Intents {
     excludedTokens?: string[];
     onConfirm: (args: { depositQoute?: BridgeReview; processing?: () => Promise<BridgeReview> }) => Promise<void>;
   }) {
+    if (typeof window === "undefined") throw "Open sign flow is only available in browser";
     if (!this.wibe3) throw "Attach wibe3";
     if (!this.signer) throw "Attach signer";
 
@@ -417,6 +421,7 @@ export class Intents {
     const balance = await this.wibe3.fetchToken(payableToken!, this.signer);
     const prepaidAmount = formatter.bigIntMin(payableAmount, balance);
 
+    const { openPayment } = await import("../ui/router");
     return await openPayment(this.wibe3, {
       onConfirm,
       needAmount: payableAmount - prepaidAmount,
@@ -444,6 +449,8 @@ export class Intents {
     serverSideProcessing?: boolean;
     payload?: Record<string, any>;
   } = {}) {
+    if (typeof window === "undefined") throw "Deposit and execute is only available in browser";
+
     await this.setupSigner();
     if (this.need.size === 0) return this.execute();
 
@@ -468,11 +475,12 @@ export class Intents {
     });
 
     if (serverSideProcessing) return;
+    const { openToast } = await import("../ui/router");
     const close = openToast(message || "Executing payment");
 
     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());
   }
@@ -511,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/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]: {

package/src/core/defaultTokens.ts

@@ -1,13 +1,4 @@
 export const defaultTokens = [
-  // {
-  //   assetId: "nep245:v2_1.omni.hot.tg:4444118_EFL2FKC",
-  //   decimals: 6,
-  //   blockchain: "juno-1",
-  //   symbol: "JUNO",
-  //   price: 0,
-  //   priceUpdatedAt: "2025-11-23T18:01:00.349Z",
-  //   contractAddress: "ujuno",
-  // },
   {
     assetId: "nep245:v2_1.omni.hot.tg:36900_11111111111111111111",
     decimals: 18,