@hot-labs/kit 1.5.4 → 1.6.0

package/src/core/OmniConnector.ts

@@ -1,7 +1,7 @@
 import { action, makeObservable, observable, runInAction } from "mobx";
 import UniversalProvider, { NamespaceConfig } from "@walletconnect/universal-provider";
 
-import type { HotConnector } from "../HotConnector";
+import type { HotKit } from "../HotKit";
 import { EventEmitter } from "./events";
 import { OmniWallet } from "./OmniWallet";
 import { WalletType } from "./chains";
@@ -36,7 +36,7 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
 
   protected wc: Promise<UniversalProvider> | null = null;
 
-  constructor(readonly wibe3: HotConnector) {
+  constructor(readonly kit: HotKit) {
     makeObservable(this, {
       wallets: observable,
       options: observable,
@@ -46,19 +46,19 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
   }
 
   get storage() {
-    return this.wibe3.storage;
+    return this.kit.storage;
   }
 
   openWallet() {}
 
   async initWalletConnect() {
-    if (!this.wibe3.settings?.projectId) throw new Error("Project ID is required");
+    if (!this.kit.settings?.projectId) throw new Error("Project ID is required");
     if (this.wc) return this.wc;
     this.wc = UniversalProvider.init({
       relayUrl: "wss://relay.walletconnect.org",
-      projectId: this.wibe3.settings?.projectId,
-      metadata: this.wibe3.settings?.metadata,
-      customStoragePrefix: `wibe3:${this.id}`,
+      projectId: this.kit.settings?.projectId,
+      metadata: this.kit.settings?.metadata,
+      customStoragePrefix: `kit:${this.id}`,
       name: this.name,
     });
 
@@ -86,8 +86,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>({
+    return this.kit.router.openWCRequest<T>({
       deeplink: args.deeplink,
       name: args.name || "WalletConnect",
       icon: args.icon || WC_ICON,
@@ -109,6 +108,7 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
   abstract id: string;
 
   protected setWallet({ wallet, isNew }: { wallet: T; isNew: boolean }) {
+    wallet.kit = this.kit;
     const existing = this.wallets.find((t) => t.address === wallet.address);
     if (existing) return existing;
 
@@ -140,15 +140,15 @@ export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
   }
 
   async setStorage(obj: { type?: string; id?: string; address?: string; publicKey?: string; [key: string]: any }) {
-    await this.storage.set(`wibe3:${this.id}`, JSON.stringify(obj));
+    await this.storage.set(`kit:${this.id}`, JSON.stringify(obj));
   }
 
   async removeStorage() {
-    await this.storage.remove(`wibe3:${this.id}`);
+    await this.storage.remove(`kit:${this.id}`);
   }
 
   async getStorage(): Promise<{ type?: string; id?: string; address?: string; publicKey?: string; [key: string]: any }> {
-    const data = await this.storage.get(`wibe3:${this.id}`);
+    const data = await this.storage.get(`kit:${this.id}`);
     if (!data) return {};
     return JSON.parse(data);
   }

package/src/core/OmniWallet.ts

@@ -1,7 +1,7 @@
 import { hex } from "@scure/base";
 import { action, makeObservable, observable } from "mobx";
 
-import type { HotConnector } from "../HotConnector";
+import type { HotKit } from "../HotKit";
 import { Network, OmniToken, WalletType } from "./chains";
 import { Commitment } from "./types";
 import { Intents } from "./Intents";
@@ -11,6 +11,7 @@ import { api } from "./api";
 
 export abstract class OmniWallet {
   balances: Record<string, bigint> = {};
+  kit?: HotKit;
 
   abstract address: string;
   abstract publicKey?: string;
@@ -22,8 +23,8 @@ export abstract class OmniWallet {
     makeObservable(this, { balances: observable, setBalance: action });
   }
 
-  intents(wibe3?: HotConnector) {
-    return new Intents(wibe3).attachWallet(this);
+  intents(kit?: HotKit) {
+    return new Intents(kit).attachWallet(this);
   }
 
   setBalance(id: string, balance: bigint) {
@@ -113,9 +114,8 @@ export abstract class OmniWallet {
       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);
+    if (this.kit == null) return await authFn();
+    return this.kit.router.openAuthPopup(this, authFn);
   }
 
   async waitUntilOmniBalance(need: Record<string, bigint>, receiver = this.omniAddress, attempts = 0) {

package/src/core/chains.ts

@@ -8,6 +8,7 @@ export enum OmniToken {
   SOL = "nep141:sol.omft.near",
   BNB = "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
   ADI = "nep245:v2_1.omni.hot.tg:36900_11111111111111111111",
+  ZEC = "nep141:zec.omft.near",
 }
 
 export enum WalletType {

package/src/core/exchange.ts

@@ -1,9 +1,12 @@
-import { GetExecutionStatusResponse, OneClickService, ApiError, QuoteRequest, QuoteResponse } from "@defuse-protocol/one-click-sdk-typescript";
+import { OneClickService, ApiError, QuoteRequest, QuoteResponse } from "@defuse-protocol/one-click-sdk-typescript";
 import { utils } from "@hot-labs/omni-sdk";
 import { hex } from "@scure/base";
 
-import { chains, Network, OmniToken, WalletType } from "./chains";
+import type { HotKit } from "../HotKit";
+
+import { chains, Network, WalletType } from "./chains";
 import { createHotBridge, ReviewFee } from "./bridge";
+import { BridgePending } from "./pendings";
 import { OmniWallet } from "./OmniWallet";
 import { Recipient } from "./recipient";
 import { ILogger } from "./telemetry";
@@ -55,9 +58,8 @@ export interface BridgeRequest {
   to: Token;
 }
 
-const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
 export class Exchange {
+  constructor(readonly kit?: HotKit) {}
   readonly bridge = createHotBridge();
 
   async getToken(chain: number, address: string): Promise<string | null> {
@@ -196,11 +198,17 @@ export class Exchange {
   }
 
   async reviewSwap(request: BridgeRequest): Promise<BridgeReview> {
-    const { sender, refund, from, to, amount, recipient, slippage, type, logger } = request;
+    const { sender, refund, from, to, amount, recipient, type, logger } = request;
 
     const deadlineTime = 5 * 60 * 1000;
     const deadline = new Date(Date.now() + deadlineTime).toISOString();
-    const noFee = from.symbol === to.symbol || (from.symbol.toLowerCase().includes("usd") && to.symbol.toLowerCase().includes("usd"));
+
+    const stables = ["usdt", "usdc", "dai", "frax"];
+    const isFromStable = stables.some((stable) => from.symbol.toLowerCase().includes(stable));
+    const isToStable = stables.some((stable) => to.symbol.toLowerCase().includes(stable));
+    const isDirect = from.originalId === to.originalId;
+    const noFee = from.symbol === to.symbol || (isFromStable && isToStable) || isDirect;
+    const slippage = isDirect ? 0 : request.slippage;
 
     if (sender !== "qr" && this.isDirectDeposit(from, to)) {
       let fee: ReviewFee | null = null;
@@ -335,7 +343,7 @@ export class Exchange {
     };
   }
 
-  async makeSwap(review: BridgeReview): Promise<{ review: BridgeReview; processing?: () => Promise<BridgeReview> }> {
+  async makeSwap(review: BridgeReview): Promise<BridgePending> {
     const { sender, recipient, logger, refund } = review;
     if (sender == null) throw new Error("Sender is required");
     if (recipient == null) throw new Error("Recipient is required");
@@ -346,7 +354,7 @@ export class Exchange {
       await this.withdraw({ sender, token: review.to, amount: review.amountIn, recipient, logger });
       if (recipient instanceof OmniWallet) recipient.fetchBalance(review.to.chain, review.to.address);
       if (sender instanceof OmniWallet) sender.fetchBalance(review.from.chain, review.from.address);
-      return { review };
+      return new BridgePending(review, this.kit);
     }
 
     if (review.qoute === "deposit") {
@@ -354,7 +362,7 @@ export class Exchange {
       await this.deposit({ sender, token: review.from, amount: review.amountIn, recipient, logger });
       if (recipient instanceof OmniWallet) recipient.fetchBalance(review.to.chain, review.to.address);
       if (sender instanceof OmniWallet) sender.fetchBalance(review.from.chain, review.from.address);
-      return { review };
+      return new BridgePending(review, this.kit);
     }
 
     if (recipient.type === WalletType.STELLAR) {
@@ -364,18 +372,7 @@ export class Exchange {
     }
 
     if (sender === "qr") {
-      return {
-        review,
-        processing: async () => {
-          if (!(recipient instanceof OmniWallet)) return await this.processing(review);
-          const beforeBalance = await recipient.fetchBalance(review.to.chain, review.to.address).catch(() => null);
-          if (!beforeBalance) return await this.processing(review);
-          return await Promise.race([
-            this.waitBalance(review.to, recipient, beforeBalance, review),
-            this.processing(review), //
-          ]);
-        },
-      };
+      return new BridgePending(review, this.kit);
     }
 
     const depositAddress = review.qoute.depositAddress!;
@@ -389,73 +386,6 @@ export class Exchange {
 
     if (sender instanceof OmniWallet) sender.fetchBalance(review.from.chain, review.from.address);
     OneClickService.submitDepositTx({ txHash: hash, depositAddress }).catch(() => {});
-
-    return {
-      review,
-      processing: async () => {
-        if (!(recipient instanceof OmniWallet)) return await this.processing(review);
-
-        const beforeBalance = await recipient.fetchBalance(review.to.chain, review.to.address).catch(() => null);
-        if (!beforeBalance) return await this.processing(review);
-
-        return await Promise.race([
-          this.waitBalance(review.to, recipient, beforeBalance, review),
-          this.processing(review), //
-        ]);
-      },
-    };
-  }
-
-  async waitBalance(to: Token, wallet: OmniWallet, beforeBalance: bigint, review: BridgeReview): Promise<BridgeReview> {
-    const afterBalance = await wallet.fetchBalance(to.chain, to.address).catch(() => beforeBalance);
-    if (afterBalance > beforeBalance) {
-      return {
-        ...review,
-        amountOut: afterBalance - beforeBalance,
-        statusMessage: "Swap successful",
-        status: "success",
-      };
-    }
-
-    await wait(2000);
-    return await this.waitBalance(to, wallet, beforeBalance, review);
-  }
-
-  getMessage(status: GetExecutionStatusResponse.status): string | null {
-    if (status === GetExecutionStatusResponse.status.PENDING_DEPOSIT) return "Waiting for deposit";
-    if (status === GetExecutionStatusResponse.status.INCOMPLETE_DEPOSIT) return "Incomplete deposit";
-    if (status === GetExecutionStatusResponse.status.KNOWN_DEPOSIT_TX) return "Known deposit tx";
-    if (status === GetExecutionStatusResponse.status.PROCESSING) return "Processing swap";
-    if (status === GetExecutionStatusResponse.status.SUCCESS) return "Swap successful";
-    if (status === GetExecutionStatusResponse.status.FAILED) return "Swap failed";
-    if (status === GetExecutionStatusResponse.status.REFUNDED) return "Swap refunded";
-    return null;
-  }
-
-  async checkStatus(review: BridgeReview) {
-    if (review.qoute === "deposit" || review.qoute === "withdraw") return;
-    const status = await OneClickService.getExecutionStatus(review.qoute.depositAddress!, review.qoute.depositMemo);
-    const message = this.getMessage(status.status);
-
-    let state: "pending" | "success" | "failed" = "pending";
-    if (status.status === GetExecutionStatusResponse.status.SUCCESS) state = "success";
-    if (status.status === GetExecutionStatusResponse.status.FAILED) state = "failed";
-    if (status.status === GetExecutionStatusResponse.status.REFUNDED) state = "failed";
-
-    if (status.swapDetails.amountOut) review.amountOut = BigInt(status.swapDetails.amountOut);
-    review.statusMessage = message;
-    review.status = state;
-    return review;
-  }
-
-  async processing(review: BridgeReview, interval = 3000) {
-    while (review.status === "pending") {
-      await this.checkStatus(review);
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-
-    if (review.status === "success") return review;
-    if (review.status === "failed") throw review.statusMessage || "Bridge failed";
-    throw new Error("Unknown status");
+    return new BridgePending(review, this.kit);
   }
 }

package/src/core/pendings.ts

@@ -0,0 +1,151 @@
+import { makeObservable, observable, runInAction } from "mobx";
+import { GetExecutionStatusResponse, OneClickService } from "@defuse-protocol/one-click-sdk-typescript";
+import { v4 as uuidv4 } from "uuid";
+
+import type { ToastController } from "../ui/toast";
+import type { HotKit } from "../HotKit";
+
+import { wait } from "../hot-wallet/iframe";
+import { OmniWallet } from "../core/OmniWallet";
+import { BridgeReview } from "../core/exchange";
+import { Token } from "./token";
+
+export abstract class ActivityController {
+  status: "pending" | "success" | "failed" = "pending";
+  id = uuidv4();
+
+  title: string | null = null;
+  subtitle: string | null = null;
+
+  preview: Token | string | null = null;
+  actionLoading: boolean = false;
+  actionText: string | null = null;
+
+  action(): Promise<void> {
+    throw new Error("Not implemented");
+  }
+
+  constructor() {
+    makeObservable(this, {
+      status: observable,
+      subtitle: observable,
+      actionText: observable,
+      actionLoading: observable,
+      preview: observable,
+      title: observable,
+    });
+  }
+}
+
+export class BridgePending extends ActivityController {
+  readonly processingTask: Promise<BridgeReview>;
+  private toast?: ToastController;
+
+  constructor(readonly review: BridgeReview, readonly kit?: HotKit) {
+    super();
+
+    this.processingTask = this._processing();
+    this.title = this.getTitle();
+
+    this.toast = this.kit?.toast.pending(this.title);
+    this.preview = this.review.to;
+  }
+
+  serialize() {
+    return {};
+  }
+
+  getTitle() {
+    const from = `${this.review.from.readable(this.review.amountIn)} ${this.review.from.symbol}`;
+    const to = `${this.review.to.readable(this.review.amountOut)} ${this.review.to.symbol}`;
+
+    if (this.review.from.originalId === this.review.to.originalId) {
+      if (this.review.from.isOmni) return `Withdraw ${from}`;
+      if (this.review.to.isOmni) return `Deposit ${to}`;
+    }
+
+    const fromChain = this.review.from.chainName.toLowerCase();
+    const toChain = this.review.to.chainName.toLowerCase();
+    return `${from} (${fromChain}) → ${to} (${toChain})`;
+  }
+
+  updateStatus(status: "pending" | "success" | "failed", statusMessage: string | null) {
+    runInAction(() => {
+      this.status = status;
+      this.subtitle = statusMessage;
+      this.toast?.update({ type: status, progressText: statusMessage || "Processing..." });
+      this.review.statusMessage = "Swap successful";
+      this.review.status = "success";
+    });
+  }
+
+  processing() {
+    return this.processingTask;
+  }
+
+  async _processing() {
+    if (this.review.qoute === "deposit" || this.review.qoute === "withdraw") return this.review;
+
+    if (!(this.review.recipient instanceof OmniWallet)) return await this.waitStatus();
+    const beforeBalance = await this.review.recipient.fetchBalance(this.review.to.chain, this.review.to.address).catch(() => null);
+    if (!beforeBalance) return await this.waitStatus();
+
+    return await Promise.race([
+      this.waitBalance(this.review.to, this.review.recipient, beforeBalance, this.review), //
+      this.waitStatus(),
+    ]);
+  }
+
+  async waitBalance(to: Token, wallet: OmniWallet, beforeBalance: bigint, review: BridgeReview): Promise<BridgeReview> {
+    const afterBalance = await wallet.fetchBalance(to.chain, to.address).catch(() => beforeBalance);
+    if (afterBalance > beforeBalance) {
+      return runInAction(() => {
+        this.review.amountOut = afterBalance - beforeBalance;
+        this.updateStatus("success", "Swap successful");
+        this.toast?.update({ duration: 2000 });
+        return this.review;
+      });
+    }
+
+    await wait(2000);
+    return await this.waitBalance(to, wallet, beforeBalance, review);
+  }
+
+  getMessage(status: GetExecutionStatusResponse.status): string | null {
+    if (status === GetExecutionStatusResponse.status.PENDING_DEPOSIT) return "Waiting for deposit";
+    if (status === GetExecutionStatusResponse.status.INCOMPLETE_DEPOSIT) return "Incomplete deposit";
+    if (status === GetExecutionStatusResponse.status.KNOWN_DEPOSIT_TX) return "Known deposit tx";
+    if (status === GetExecutionStatusResponse.status.PROCESSING) return "Processing swap";
+    if (status === GetExecutionStatusResponse.status.SUCCESS) return "Swap successful";
+    if (status === GetExecutionStatusResponse.status.FAILED) return "Swap failed";
+    if (status === GetExecutionStatusResponse.status.REFUNDED) return "Swap refunded";
+    return null;
+  }
+
+  async checkStatus() {
+    if (this.review.qoute === "deposit" || this.review.qoute === "withdraw") return;
+    const status = await OneClickService.getExecutionStatus(this.review.qoute.depositAddress!, this.review.qoute.depositMemo);
+    const message = this.getMessage(status.status);
+
+    let state: "pending" | "success" | "failed" = "pending";
+    if (status.status === GetExecutionStatusResponse.status.SUCCESS) state = "success";
+    if (status.status === GetExecutionStatusResponse.status.FAILED) state = "failed";
+    if (status.status === GetExecutionStatusResponse.status.REFUNDED) state = "failed";
+
+    runInAction(() => {
+      if (status.swapDetails.amountOut) this.review.amountOut = BigInt(status.swapDetails.amountOut);
+      this.updateStatus(state, message);
+    });
+  }
+
+  async waitStatus(interval = 3000) {
+    while (this.status === "pending") {
+      await this.checkStatus();
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+
+    if (this.status === "success") return this.review;
+    if (this.status === "failed") throw this.subtitle || "Bridge failed";
+    throw new Error("Unknown status");
+  }
+}

package/src/core/telemetry.ts

@@ -1,5 +1,5 @@
 import { api } from "./api";
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 import { formatter } from "./utils";
 
 export interface ILogger {
@@ -8,7 +8,7 @@ export interface ILogger {
 
 export class Telemetry {
   events: { event: string; value_str?: string; value_float?: number; ts: number }[] = [];
-  constructor(readonly wibe3: HotConnector) {
+  constructor(readonly kit: HotKit) {
     this.flush();
   }
 
@@ -17,7 +17,7 @@ export class Telemetry {
 
     if (this.events.length > 0) {
       await api
-        .publishTelemetry(this.events, this.wibe3.priorityWallet?.address ?? "")
+        .publishTelemetry(this.events, this.kit.priorityWallet?.address ?? "")
         .then(() => (this.events = []))
         .catch(() => {});
     }

package/src/cosmos/connector.ts

@@ -11,7 +11,7 @@ import { chains, WalletType } from "../core/chains";
 import { OmniWallet } from "../core/OmniWallet";
 import { api } from "../core/api";
 
-import type { HotConnector } from "../HotConnector";
+import type { HotKit } from "../HotKit";
 import { signAndSendTx } from "./helpers";
 import CosmosWallet from "./wallet";
 
@@ -56,8 +56,8 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
   isSupported = true;
   id = "cosmos";
 
-  constructor(wibe3: HotConnector, readonly chainId = "gonka-mainnet") {
-    super(wibe3);
+  constructor(kit: HotKit, readonly chainId = "gonka-mainnet") {
+    super(kit);
 
     this.options = Object.values(wallets);
     Keplr.getKeplr().then((keplr) => {

package/src/cosmos/index.ts

@@ -1,10 +1,10 @@
 import CosmosConnector from "./connector";
 import CosmosWallet from "./wallet";
 
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 
 export { CosmosConnector, CosmosWallet };
 
 export default ({ chainId }: { chainId?: string } = {}) =>
-  async (wibe3: HotConnector) =>
-    new CosmosConnector(wibe3, chainId);
+  async (kit: HotKit) =>
+    new CosmosConnector(kit, chainId);

package/src/evm/connector.ts

@@ -1,7 +1,7 @@
 import { runInAction } from "mobx";
 
 import HOT from "../hot-wallet/iframe";
-import type { HotConnector } from "../HotConnector";
+import type { HotKit } from "../HotKit";
 
 import { Network, WalletType } from "../core/chains";
 import { ConnectorType, OmniConnector, WC_ICON } from "../core/OmniConnector";
@@ -15,8 +15,8 @@ class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
   name = "EVM Wallet";
   id = "evm";
 
-  constructor(wibe3: HotConnector) {
-    super(wibe3);
+  constructor(kit: HotKit) {
+    super(kit);
 
     window.addEventListener<any>("eip6963:announceProvider", async (provider) => {
       if (this.options.find((t) => t.name === provider.detail.info.name || t.id === provider.detail.info.uuid)) return;

package/src/evm/index.ts

@@ -1,8 +1,8 @@
 import EvmConnector from "./connector";
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 
 export { default as EvmConnector } from "./connector";
 export { default as EvmWallet } from "./wallet";
 import "./injected";
 
-export default () => async (wibe3: HotConnector) => new EvmConnector(wibe3);
+export default () => async (kit: HotKit) => new EvmConnector(kit);

package/src/hocraft/connector.ts

@@ -1,7 +1,7 @@
 import { ConnectorType, OmniConnector } from "../core/OmniConnector";
 import { Network, WalletType } from "../core/chains";
 import { OmniWallet } from "../core/OmniWallet";
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 import HotCraftWallet from "./wallet";
 
 export default class HotCraftConnector extends OmniConnector<HotCraftWallet> {
@@ -11,18 +11,18 @@ export default class HotCraftConnector extends OmniConnector<HotCraftWallet> {
   name = "HotCraft";
   id = "hotcraft";
 
-  constructor(readonly wibe3: HotConnector) {
-    super(wibe3);
+  constructor(readonly kit: HotKit) {
+    super(kit);
 
-    wibe3.onConnect(async ({ wallet }) => {
+    kit.onConnect(async ({ wallet }) => {
       if (wallet.type === WalletType.HotCraft) return;
-      const craftWallet = new HotCraftWallet(wallet, wibe3.storage);
+      const craftWallet = new HotCraftWallet(wallet, kit.storage);
       const balances = await craftWallet.fetchBalances(Network.HotCraft);
       if (Object.values(balances).some((balance) => balance === 0n)) return;
       this.setWallet({ wallet: craftWallet, isNew: false });
     });
 
-    wibe3.onDisconnect(async ({ wallet }) => {
+    kit.onDisconnect(async ({ wallet }) => {
       if (wallet.type === WalletType.HotCraft) return;
       const craftWallet = this.wallets.find((t) => t.wallet === wallet);
       if (craftWallet) this.removeWallet(craftWallet);

package/src/hocraft/index.ts

@@ -1,7 +1,7 @@
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 import HotCraftConnector from "./connector";
 import HotCraftWallet from "./wallet";
 
 export { HotCraftConnector, HotCraftWallet };
 
-export default () => async (wibe3: HotConnector) => new HotCraftConnector(wibe3);
+export default () => async (kit: HotKit) => new HotCraftConnector(kit);

package/src/hot-wallet/google.ts

@@ -12,7 +12,7 @@ import TonWallet from "../ton/wallet";
 import NearWallet from "../near/wallet";
 import SolanaWallet from "../solana/wallet";
 import StellarWallet from "../stellar/wallet";
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 
 export interface GoogleConnectorOptions {
   webWallet?: string;
@@ -26,8 +26,8 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
   id = "google";
   webWallet: string;
 
-  constructor(wibe3: HotConnector, options?: GoogleConnectorOptions) {
-    super(wibe3);
+  constructor(kit: HotKit, options?: GoogleConnectorOptions) {
+    super(kit);
 
     this.webWallet = options?.webWallet ?? "https://app.hot-labs.org";
     makeObservable(this, { connectWallet: action });
@@ -42,7 +42,7 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
     const height = 640;
     const x = (window.screen.width - width) / 2;
     const y = (window.screen.height - height) / 2;
-    return window.open(`${this.wibe3.settings.webWallet}`, "_blank", `popup=1,width=${width},height=${height},top=${y},left=${x}`);
+    return window.open(`${this.kit.settings.webWallet}`, "_blank", `popup=1,width=${width},height=${height},top=${y},left=${x}`);
   }
 
   connectWallet({ account, isNew }: { account: { type: number; address: string; publicKey: string }; isNew: boolean }) {
@@ -57,7 +57,7 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
       const signMessage = async (message: string) => request("stellar:signMessage", { message });
       const signTransaction = async (transaction: Transaction) => request("stellar:signTransaction", { transaction: transaction.toXDR() });
       const wallet = new StellarWallet({
-        rpc: this.wibe3.exchange.bridge.stellar,
+        rpc: this.kit.exchange.bridge.stellar,
         address: account.address,
         signTransaction,
         signMessage,
@@ -122,7 +122,7 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
 
       const id = uuid4();
       const handler = (event: MessageEvent) => {
-        if (event.origin !== this.wibe3.settings.webWallet) return;
+        if (event.origin !== this.kit.settings.webWallet) return;
 
         if (event.data === "hot:ready") {
           popup?.postMessage({ chain, address, method, request, id }, "*");

package/src/hot-wallet/index.ts

@@ -1,7 +1,7 @@
 import GoogleConnector, { GoogleConnectorOptions } from "./google";
-import { HotConnector } from "../HotConnector";
+import { HotKit } from "../HotKit";
 
 export type { GoogleConnectorOptions };
 export { GoogleConnector };
 
-export default (options?: GoogleConnectorOptions) => async (wibe3: HotConnector) => new GoogleConnector(wibe3, options);
+export default (options?: GoogleConnectorOptions) => async (kit: HotKit) => new GoogleConnector(kit, options);

package/src/index.ts

@@ -1,4 +1,9 @@
 import "@lottiefiles/dotlottie-wc";
 
 export * from "./core";
-export { HotConnector } from "./HotConnector";
+import { HotKit } from "./HotKit";
+
+export { HotKit };
+
+// Alias for backward compatibility
+export const HotConnector = HotKit;