@hot-labs/kit 1.0.56 → 1.0.57

package/src/evm/injected.ts

@@ -1,4 +1,4 @@
-import { isInjected, requestHot } from "../hot-wallet/iframe";
+import HOT from "../hot-wallet/iframe";
 
 class HotEvmProvider {
   _events = new Map<string, Set<any>>();
@@ -6,7 +6,7 @@ class HotEvmProvider {
   isHotWallet = true;
   isMetaMask = true;
 
-  request = (request: any) => requestHot("ethereum", request);
+  request = (request: any) => HOT.request("ethereum", request);
   removeListener() {}
   on() {}
 }
@@ -31,7 +31,7 @@ function announceProvider(provider: HotEvmProvider) {
   );
 }
 
-if (isInjected()) {
+if (HOT.isInjected) {
   const hotProvider = new HotEvmProvider();
   window.addEventListener("eip6963:requestProvider", () => announceProvider(hotProvider));
   announceProvider(hotProvider);

package/src/hot-wallet/iframe.ts

@@ -1,32 +1,159 @@
-const ancestorOrigins = new Set(["http://localhost:1234", "https://my.herewallet.app", "https://tgapp-dev.herewallet.app", "https://tgapp.herewallet.app", "https://beta.herewallet.app", "https://app.hot-labs.org"]);
+import uuid4 from "uuid4";
+import { createRequest, getResponse } from "./proxy";
+import { base58 } from "@scure/base";
 
-export const isInjected = () => {
-  if (typeof window === "undefined") return false;
-  if (window.self === window.top) return false;
-  return ancestorOrigins.has(window.location.ancestorOrigins?.[0]);
+declare global {
+  interface Window {
+    hotExtension?: {
+      autoRun: boolean;
+      request: (method: string, args: any) => any;
+      subscribe: (event: string, args: any) => () => void;
+      evm: any;
+    };
+  }
+}
+
+export const wait = (timeout: number) => {
+  return new Promise<void>((resolve) => setTimeout(resolve, timeout));
 };
 
-export const uuid4 = () => {
-  try {
-    return crypto.randomUUID();
-  } catch {
-    const temp_url = URL.createObjectURL(new Blob());
-    const uuid = temp_url.toString();
-    URL.revokeObjectURL(temp_url);
-    return uuid.split(/[:/]/g).pop()!.toLowerCase(); // remove prefixes
+export class RequestFailed extends Error {
+  name = "RequestFailed";
+  constructor(readonly payload: any) {
+    super();
   }
-};
+}
 
-export const requestHot = (method: string, request: any) => {
-  const id = uuid4();
-  return new Promise<any>((resolve, reject) => {
-    const handler = (e: any) => {
-      if (e.data.id !== id) return;
-      window?.removeEventListener("message", handler);
-      return e.data.success ? resolve(e.data.payload) : reject(e.data.payload);
-    };
+export const getExtension = () => {
+  if (typeof window === "undefined") return null;
+  return window.hotExtension;
+};
 
-    window?.parent.postMessage({ $hot: true, method, request, id }, "*");
-    window?.addEventListener("message", handler);
+let connector: HTMLDivElement | undefined;
+if (typeof window !== "undefined") {
+  window.addEventListener("message", (e: any) => {
+    if (e.data === "hot-close") {
+      connector?.remove();
+      connector = undefined;
+    }
   });
+}
+
+const createIframe = (widget: string) => {
+  connector?.remove();
+  connector = document.createElement("div");
+
+  const iframe = document.createElement("iframe");
+  connector?.appendChild(iframe);
+
+  iframe.src = widget;
+  iframe.allow = "usb";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "16px";
+  iframe.style.background = "#fff";
+  iframe.style.overflow = "hidden";
+  iframe.style.background = "#1D1F20";
+  iframe.style.border = "1px solid #2C3034";
+  iframe.style.width = "375px";
+  iframe.style.height = "560px";
+  iframe.onclick = (e) => e.stopPropagation();
+
+  connector.style.padding = "16px";
+  connector.style.zIndex = "100000000000000";
+  connector.style.position = "fixed";
+  connector.style.display = "flex";
+  connector.style.justifyContent = "center";
+  connector.style.alignItems = "center";
+  connector.style.top = "0";
+  connector.style.left = "0";
+  connector.style.width = "100%";
+  connector.style.height = "100%";
+  connector.style.background = "rgba(0, 0, 0, 0.1)";
+  connector.style.backdropFilter = "blur(24px)";
+  connector.onclick = () => {
+    connector?.remove();
+    connector = undefined;
+  };
+
+  document.body.appendChild(connector);
+  return connector;
 };
+
+class HOT {
+  walletId = "https://t.me/herewalletbot/app";
+  ancestorOrigins = ["http://localhost:1234", "https://my.herewallet.app", "https://tgapp-dev.herewallet.app", "https://tgapp.herewallet.app", "https://beta.herewallet.app"];
+
+  get isInjected() {
+    if (typeof window === "undefined") return false;
+    if (window.hotExtension != null) return window.hotExtension.autoRun;
+    return this.ancestorOrigins.includes(window.location.ancestorOrigins?.[0]);
+  }
+
+  openInHotBrowserUrl: string | null = null;
+  toggleOpenInHotBrowser(url: string | null) {
+    this.openInHotBrowserUrl = url;
+  }
+
+  customProvider?: (data: any, chain: number, address?: string | null) => Promise<any>;
+  setupEthProvider(provider?: (data: any, chain: number, address?: string | null) => Promise<any>) {
+    this.customProvider = provider;
+  }
+
+  async injectedRequest(method: string, request: any): Promise<any> {
+    const id = uuid4();
+    return new Promise((resolve, reject) => {
+      const handler = (e: any) => {
+        if (e.data.id !== id) return;
+        window?.removeEventListener("message", handler);
+        if (e.data.success) return resolve(e.data.payload);
+        else return reject(e.data.payload);
+      };
+
+      window?.parent.postMessage({ $hot: true, method, request, id }, "*");
+      window?.addEventListener("message", handler);
+    });
+  }
+
+  subscribe(event: string, cb: (e: any) => void) {
+    if (!window.hotExtension) return () => {};
+    return window.hotExtension.subscribe(event, cb);
+  }
+
+  async request(method: string, request: any): Promise<any> {
+    if (window.hotExtension != null) return window.hotExtension.request(method, request);
+    if (this.isInjected) return this.injectedRequest(method, request);
+
+    const id = uuid4();
+    const WebApp: any = (window as any)?.Telegram?.WebApp;
+
+    const requestId = await createRequest({
+      inside: !!this.openInHotBrowserUrl || (method === "ethereum" && this.customProvider == null),
+      origin: typeof this.openInHotBrowserUrl === "string" ? this.openInHotBrowserUrl : location.href,
+      $hot: true,
+      method,
+      request,
+      id,
+    });
+
+    const link = `${this.walletId}?startapp=hotconnect-${base58.encode(Buffer.from(requestId, "utf8"))}`;
+    if (WebApp) WebApp?.openTelegramLink(link);
+    else {
+      const origin = `https://hot-labs.org/hot-widget/index.html`;
+      createIframe(`${origin}?hotconnect-${base58.encode(Buffer.from(requestId, "utf8"))}`);
+    }
+
+    const poolResponse = async () => {
+      await wait(3000);
+      const data: any = await getResponse(requestId).catch(() => null);
+      if (data == null) return await poolResponse();
+      if (data.success) return data.payload;
+      throw new RequestFailed(data.payload);
+    };
+
+    const result = await poolResponse();
+    connector?.remove();
+    return result;
+  }
+}
+
+export default new HOT();

package/src/hot-wallet/proxy.ts

@@ -0,0 +1,54 @@
+import uuid4 from "uuid4";
+import { sha1 } from "@noble/hashes/legacy.js";
+import { base58 } from "@scure/base";
+
+export const proxyApi = "https://h4n.app";
+
+export const getResponse = async (id: string): Promise<object> => {
+  const res = await fetch(`${proxyApi}/${id}/response`, {
+    headers: { "content-type": "application/json" },
+    method: "GET",
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+
+  const { data } = await res.json();
+  return JSON.parse(data);
+};
+
+export const deleteRequest = async (id: string) => {
+  const res = await fetch(`${proxyApi}/${id}`, {
+    headers: { "content-type": "application/json" },
+    method: "DELETE",
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+};
+
+export const computeRequestId = async (request: object) => {
+  const query = base58.encode(Buffer.from(JSON.stringify({ ...request, _id: uuid4() }), "utf8"));
+  const hashsum = sha1(Buffer.from(query, "utf8"));
+  const id = Buffer.from(hashsum).toString("base64");
+  const requestId = id.replaceAll("/", "_").replaceAll("-", "+").slice(0, 13);
+  return { requestId, query };
+};
+
+export const createRequest = async (request: object, signal?: AbortSignal) => {
+  const { query, requestId } = await computeRequestId(request);
+  const res = await fetch(`${proxyApi}/${requestId}/request`, {
+    body: JSON.stringify({ data: query }),
+    headers: { "content-type": "application/json" },
+    method: "POST",
+    signal,
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+
+  return requestId;
+};

package/src/solana/connector.ts

@@ -6,8 +6,8 @@ import { runInAction } from "mobx";
 import { ConnectorType, OmniConnector, WC_ICON } from "../OmniConnector";
 import { HotConnector } from "../HotConnector";
 import { OmniWallet } from "../OmniWallet";
-import { isInjected } from "../hot-wallet/iframe";
 import { WalletType } from "../core/chains";
+import HOT from "../hot-wallet/iframe";
 
 import SolanaProtocolWallet from "./protocol";
 import { getWallets } from "./wallets";
@@ -117,7 +117,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
   }
 
   async getConnectedWallet() {
-    if (isInjected()) return { type: "wallet", id: "HOT Wallet" };
+    if (HOT.isInjected) return { type: "wallet", id: "HOT Wallet" };
     return this.getStorage();
   }
 

package/src/solana/injected/account.ts

@@ -1,9 +1,8 @@
-import { SolanaSignAndSendTransaction, SolanaSignMessage, SolanaSignTransaction } from "@solana/wallet-standard-features";
 import type { WalletAccount } from "@wallet-standard/base";
 import { SOLANA_CHAINS } from "./utils";
 
 const chains = SOLANA_CHAINS;
-const features = [SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage] as const;
+const features = ["solana:signAndSendTransaction", "solana:signMessage", "solana:signMessage"] as const;
 
 export class GhostWalletAccount implements WalletAccount {
   readonly #address: WalletAccount["address"];

package/src/solana/injected/index.ts

@@ -1,6 +1,6 @@
 import { Transaction, VersionedTransaction, PublicKey } from "@solana/web3.js";
 
-import { isInjected, requestHot } from "../../hot-wallet/iframe";
+import HOT from "../../hot-wallet/iframe";
 import { registerWallet } from "./register";
 import { GhostWallet } from "./solana-wallet";
 
@@ -25,17 +25,17 @@ const hotSolana = {
   publicKey: null as PublicKey | null,
 
   async connect(options: any) {
-    const { publicKey } = await requestHot("solana:connect", options);
+    const { publicKey } = await HOT.request("solana:connect", options);
     hotSolana.publicKey = new PublicKey(publicKey);
     return { publicKey: hotSolana.publicKey };
   },
 
   async disconnect() {
-    return await requestHot("solana:disconnect", {});
+    return await HOT.request("solana:disconnect", {});
   },
 
   async signAllTransactions(transactions: any[]) {
-    const result = await requestHot("solana:signAllTransactions", {
+    const result = await HOT.request("solana:signAllTransactions", {
       transactions: transactions.map((t) => t.serialize().toString("base64")),
     });
 
@@ -43,7 +43,7 @@ const hotSolana = {
   },
 
   async signTransaction(transaction: any) {
-    const result = await requestHot("solana:signAllTransactions", {
+    const result = await HOT.request("solana:signAllTransactions", {
       transactions: [transaction.serialize().toString("base64")],
     });
 
@@ -51,7 +51,7 @@ const hotSolana = {
   },
 
   async signAndSendTransaction(transaction: any, options: any) {
-    const result = await requestHot("solana:signAndSendTransaction", {
+    const result = await HOT.request("solana:signAndSendTransaction", {
       transaction: transaction.serialize().toString("base64"),
       options,
     });
@@ -61,11 +61,10 @@ const hotSolana = {
 
   async signIn(input: any) {
     throw "Not supported";
-    return await requestHot("solana:signIn", input);
   },
 
   async signMessage(message: string) {
-    const result = await requestHot("solana:signMessage", { message: Buffer.from(message).toString("base64") });
+    const result = await HOT.request("solana:signMessage", { message: Buffer.from(message).toString("base64") });
     return { signature: Buffer.from(result.signature, "base64") };
   },
 
@@ -84,15 +83,13 @@ HOT.subscribe("solana:accountChanged", (publicKey: string | null) => {
 });
 */
 
-if (isInjected()) {
-  registerWallet(new GhostWallet(hotSolana));
+registerWallet(new GhostWallet(hotSolana));
 
-  // New wallets no longer need to register wallet globals - and can
-  // ignore the code below. However if you have legacy apps relying on globals,
-  // this is the safest way to attach the reference to the window, guarding against errors.
-  try {
-    Object.defineProperty(window, "hotSolana", { value: hotSolana });
-  } catch (error) {
-    //
-  }
+// New wallets no longer need to register wallet globals - and can
+// ignore the code below. However if you have legacy apps relying on globals,
+// this is the safest way to attach the reference to the window, guarding against errors.
+try {
+  Object.defineProperty(window, "hotSolana", { value: hotSolana });
+} catch (error) {
+  //
 }

package/src/stellar/connector.ts

@@ -1,68 +1,81 @@
-import { sep43Modules, HotWalletModule, StellarWalletsKit, WalletNetwork, ISupportedWallet } from "@creit.tech/stellar-wallets-kit";
 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 { isInjected } from "../hot-wallet/iframe";
 import { OmniWallet } from "../OmniWallet";
-import StellarWallet from "./wallet";
 
-class StellarConnector extends OmniConnector<StellarWallet, ISupportedWallet> {
-  stellarKit: StellarWalletsKit;
+import { FreighterModule } from "./freigher";
+import { HotWalletModule } from "./hotWallet";
+import StellarWallet from "./wallet";
 
+class StellarConnector extends OmniConnector<StellarWallet> {
   icon = "https://storage.herewallet.app/upload/1469894e53ca248ac6adceb2194e6950a13a52d972beb378a20bce7815ba01a4.png";
   walletTypes = [WalletType.STELLAR, WalletType.OMNI];
   type = ConnectorType.WALLET;
   name = "Stellar Wallet";
   id = "stellar";
 
-  constructor(wibe3: HotConnector, stellarKit?: StellarWalletsKit) {
-    super(wibe3);
+  modules = {
+    hotWallet: new HotWalletModule(),
+    freighter: new FreighterModule(),
+  };
 
-    this.stellarKit = stellarKit || new StellarWalletsKit({ network: WalletNetwork.PUBLIC, modules: isInjected() ? [new HotWalletModule()] : sep43Modules() });
-    this.stellarKit.getSupportedWallets().then((wallets) => {
-      const hot = wallets.find((w) => w.id === "hot-wallet");
-      this.options = wallets.filter((w) => w.id !== "hot-wallet").map((w) => ({ ...w, name: w.name, icon: w.icon, download: w.url, type: "external" as const, id: w.id }));
-      if (hot) this.options.unshift({ ...hot, name: hot.name, icon: hot.icon, download: hot.url, type: "external" as const, id: hot.id });
-    });
+  constructor(wibe3: HotConnector) {
+    super(wibe3);
 
-    this.getConnectedWallet().then((data) => {
-      if (!data || !this.stellarKit) throw "No wallet";
+    this.options = Object.values(this.modules).map((module) => ({
+      type: "external" as const,
+      name: module.productName,
+      icon: module.productIcon,
+      download: module.productUrl,
+      id: module.productId,
+    }));
 
-      this.stellarKit.setWallet(data.id!);
-      const signMessage = async (message: string) => this.stellarKit.signMessage(message);
-      const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
-      this.setWallet(new StellarWallet(this, { address: data.address!, signMessage, signTransaction }));
+    this.getConnectedWallet().then(async ({ id, address }) => {
+      if (!id || !address) return;
+      const wallet = this.getWallet(id);
+      const isAvailable = await wallet?.isAvailable();
+      if (isAvailable && wallet) this.selectWallet(address, wallet);
     });
   }
 
+  getWallet(id: string): FreighterModule | HotWalletModule | null {
+    return Object.values(this.modules).find((module) => module.productId === id) || null;
+  }
+
   async createWallet(address: string): Promise<OmniWallet> {
     return new StellarWallet(this, { address });
   }
 
   async getConnectedWallet() {
-    if (isInjected()) {
-      this.stellarKit.setWallet("hot-wallet");
-      const { address } = await this.stellarKit.getAddress();
-      return { type: "wallet", id: "hot-wallet", address };
+    if (HOT.isInjected) {
+      const { address } = await this.modules.hotWallet.getAddress();
+      return { type: "wallet", id: this.modules.hotWallet.productId, address };
     }
 
     return await this.getStorage();
   }
 
+  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(this, { address, signMessage, signTransaction }));
+  }
+
   async connect(id: string) {
-    this.stellarKit.setWallet(id);
-    const { address } = await this.stellarKit.getAddress();
-    const signMessage = async (message: string) => this.stellarKit.signMessage(message);
-    const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
+    const wallet = this.getWallet(id);
+    if (!wallet) throw new Error("Wallet not found");
+
+    const { address } = await wallet.getAddress();
     this.setStorage({ type: "wallet", id, address });
-    return this.setWallet(new StellarWallet(this, { address, signMessage, signTransaction }));
+    return this.selectWallet(address, wallet);
   }
 
   async disconnect() {
     super.disconnect();
-    this.stellarKit.disconnect();
+    this.removeStorage();
   }
 }
 

package/src/stellar/freigher.ts

@@ -0,0 +1,119 @@
+import { isConnected, requestAccess, getAddress, signTransaction, signAuthEntry, signMessage, getNetwork } from "@stellar/freighter-api";
+
+declare global {
+  interface Window {
+    stellar?: {
+      provider: string;
+      platform: string;
+    };
+  }
+}
+
+function parseError(e: any) {
+  return {
+    code: e?.error?.code || e?.code || -1,
+    message: e?.error?.message || e?.message || (typeof e === "string" && e) || "Unhandled error from the wallet",
+    ext: e?.error?.ext || e?.ext,
+  };
+}
+
+const FREIGHTER_ID = "freighter";
+export class FreighterModule {
+  productId = FREIGHTER_ID;
+  productName = "Freighter";
+  productUrl = "https://freighter.app";
+  productIcon = "https://stellar.creit.tech/wallet-icons/freighter.png";
+
+  async runChecks() {
+    if (!(await this.isAvailable())) {
+      throw new Error("Freighter is not connected");
+    }
+  }
+
+  async isAvailable() {
+    if (window.stellar?.provider === "freighter" && window.stellar?.platform === "mobile") return false;
+    return isConnected()
+      .then(({ isConnected: isConnected2, error }) => !error && isConnected2)
+      .catch(() => false);
+  }
+
+  async getAddress(params?: { skipRequestAccess?: boolean }): Promise<{ address: string }> {
+    return this.runChecks()
+      .then(async () => {
+        if (params?.skipRequestAccess) return true;
+        return requestAccess();
+      })
+      .then(() => getAddress())
+      .then(({ address, error }) => {
+        if (error) throw error;
+        if (!address)
+          throw {
+            code: -3,
+            message: "Getting the address is not allowed, please request access first.",
+          };
+        return { address };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+  async signTransaction(xdr: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedTxXdr: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedTxXdr, signerAddress, error } = await signTransaction(xdr, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error) throw error;
+        return { signedTxXdr, signerAddress };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async signAuthEntry(authEntry: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedAuthEntry: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedAuthEntry, signerAddress, error } = await signAuthEntry(authEntry, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error || !signedAuthEntry) throw error;
+        return { signedAuthEntry: Buffer.from(signedAuthEntry).toString("base64"), signerAddress };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async signMessage(message: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedMessage: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedMessage, signerAddress, error } = await signMessage(message, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error || !signedMessage) throw error;
+        return {
+          signedMessage: typeof signedMessage === "string" ? signedMessage : Buffer.from(signedMessage).toString("base64"),
+          signerAddress,
+        };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async getNetwork(): Promise<{ network: string; networkPassphrase: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { network, networkPassphrase, error } = await getNetwork();
+        if (error) throw error;
+        return { network, networkPassphrase };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+}

package/src/stellar/{injected.ts → hotWallet.ts}

@@ -1,13 +1,9 @@
-import { type ModuleInterface, ModuleType, WalletNetwork } from "@creit.tech/stellar-wallets-kit";
-import { requestHot } from "../hot-wallet/iframe";
+import { Networks } from "@stellar/stellar-sdk";
+import HOT from "../hot-wallet/iframe";
 
 export const HOTWALLET_ID: string = "hot-wallet";
 
-/**
- * **IMPORTANT**: This module requires that you have a "global" and a "Buffer" polyfill in your app, if not provided then this module will break your app.
- */
-export class HotWalletModule implements ModuleInterface {
-  moduleType: ModuleType = ModuleType.HOT_WALLET;
+export class HotWalletModule {
   productId: string = HOTWALLET_ID;
   productName: string = "HOT Wallet";
   productUrl: string = "https://hot-labs.org/wallet";
@@ -18,22 +14,22 @@ export class HotWalletModule implements ModuleInterface {
   }
 
   async getAddress(): Promise<{ address: string }> {
-    return await requestHot("stellar:getAddress", {});
+    return await HOT.request("stellar:getAddress", {});
   }
 
   async signTransaction(xdr: string, opts?: { address?: string }): Promise<{ signedTxXdr: string; signerAddress?: string }> {
-    return await requestHot("stellar:signTransaction", { xdr, accountToSign: opts?.address });
+    return await HOT.request("stellar:signTransaction", { xdr, accountToSign: opts?.address });
   }
 
   async signAuthEntry(authEntry: string, opts?: { address?: string }): Promise<{ signedAuthEntry: string; signerAddress?: string }> {
-    return await requestHot("stellar:signAuthEntry", { authEntry, accountToSign: opts?.address });
+    return await HOT.request("stellar:signAuthEntry", { authEntry, accountToSign: opts?.address });
   }
 
   async signMessage(message: string, opts?: { address?: string }): Promise<{ signedMessage: string; signerAddress?: string }> {
-    return await requestHot("stellar:signMessage", { message, accountToSign: opts?.address });
+    return await HOT.request("stellar:signMessage", { message, accountToSign: opts?.address });
   }
 
   async getNetwork(): Promise<{ network: string; networkPassphrase: string }> {
-    return { network: "mainnet", networkPassphrase: WalletNetwork.PUBLIC };
+    return { network: "mainnet", networkPassphrase: Networks.PUBLIC };
   }
 }