@hot-labs/kit 1.2.0-alpha.2 → 1.2.1

package/src/tron/connector.ts

@@ -0,0 +1,89 @@
+import { WalletType } from "../core/chains";
+import { ConnectorType, OmniConnector } from "../OmniConnector";
+import { HotConnector } from "../HotConnector";
+import TronWallet from "./wallet";
+
+declare global {
+  interface Window {
+    tronLink?: {
+      ready?: boolean;
+      request?: (args: { method: string; params?: any }) => Promise<any>;
+      tronWeb?: {
+        defaultAddress?: { base58?: string; hex?: string };
+        address?: { toHex?: (address: string) => string };
+        contract?: () => { at: (address: string) => Promise<any> };
+        trx?: {
+          getBalance?: (address: string) => Promise<number | string>;
+          sendTransaction?: (to: string, amount: number | string) => Promise<any>;
+          signMessageV2?: (message: string) => Promise<string>;
+          signMessage?: (message: string) => Promise<string>;
+        };
+      };
+    };
+  }
+}
+
+const TRONLINK = {
+  id: "tronlink",
+  name: "Tron Link",
+  type: window?.tronLink ? ("extension" as const) : ("external" as const),
+  icon: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/tron/info/logo.png",
+  download: "https://www.tronlink.org/",
+};
+
+class TronConnector extends OmniConnector<TronWallet> {
+  type = ConnectorType.WALLET;
+  walletTypes = [WalletType.Tron, WalletType.OMNI];
+  icon = "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/tron/info/logo.png";
+  name = "TRON Wallet";
+  options = [TRONLINK];
+  id = "tron";
+
+  constructor(wibe3: HotConnector) {
+    super(wibe3);
+
+    this.syncFromProvider().catch(() => this.removeStorage());
+    window.addEventListener("message", () => {
+      this.syncFromProvider().catch(() => {});
+    });
+  }
+
+  private async syncFromProvider() {
+    const stored = (await this.getStorage().catch(() => ({} as any))) as { type?: string; id?: string; address?: string };
+    if (stored.type !== "wallet" || stored.id !== TRONLINK.id) return;
+
+    const tronWeb = window?.tronLink?.tronWeb;
+    const address = tronWeb?.defaultAddress?.base58;
+    if (!window?.tronLink?.ready || !address) return;
+
+    const current = this.wallets[0]?.address;
+    if (current === address) return;
+
+    if (this.wallets.length > 0) this.removeWallet();
+    await this.setStorage({ type: "wallet", id: TRONLINK.id, address });
+    this.setWallet(new TronWallet(this, address, tronWeb as any));
+  }
+
+  async connect(id: string = TRONLINK.id) {
+    if (id !== TRONLINK.id) throw new Error("Wallet not found");
+
+    try {
+      if (this.wallets.length > 0) this.removeWallet();
+
+      const res = await window?.tronLink?.request?.({ method: "tron_requestAccounts" });
+      if (res?.code !== 200) throw new Error("Failed to connect to TronLink");
+      if (!window?.tronLink?.tronWeb) throw new Error("TronLink not found");
+
+      const address = window?.tronLink?.tronWeb?.defaultAddress?.base58;
+      if (!address) throw new Error("No account found");
+
+      await this.setStorage({ type: "wallet", id: TRONLINK.id, address });
+      return this.setWallet(new TronWallet(this, address, window.tronLink.tronWeb));
+    } catch (e) {
+      await this.removeStorage();
+      throw e;
+    }
+  }
+}
+
+export default TronConnector;

package/src/tron/index.ts

@@ -0,0 +1,7 @@
+import { HotConnector } from "../HotConnector";
+import TronConnector from "./connector";
+import TronWallet from "./wallet";
+
+export { TronConnector, TronWallet };
+
+export default () => async (wibe3: HotConnector) => new TronConnector(wibe3);

package/src/tron/wallet.ts

@@ -0,0 +1,146 @@
+import { base58, base64, hex } from "@scure/base";
+
+import { Network, WalletType } from "../core/chains";
+import { ReviewFee } from "../core/bridge";
+import { Token } from "../core/token";
+import { Commitment } from "../core";
+
+import type { OmniConnector } from "../OmniConnector";
+import { OmniWallet } from "../OmniWallet";
+
+interface TronWebLike {
+  ready?: boolean;
+  defaultAddress?: { base58?: string; hex?: string };
+  address?: { toHex?: (address: string) => string };
+  trx?: {
+    getBalance?: (address: string) => Promise<number | string>;
+    sendTransaction?: (to: string, amount: number | string) => Promise<any>;
+    signMessageV2?: (message: string) => Promise<string>;
+    signMessage?: (message: string) => Promise<string>;
+  };
+  contract?: () => { at: (address: string) => Promise<any> };
+}
+
+class TronWallet extends OmniWallet {
+  readonly publicKey?: string;
+  readonly type = WalletType.Tron;
+
+  constructor(readonly connector: OmniConnector, readonly address: string, readonly tronWeb: TronWebLike) {
+    super();
+  }
+
+  get icon() {
+    return this.connector.icon;
+  }
+
+  get omniAddress() {
+    // Convert TRON base58 address -> EVM-like hex (0x + 20 bytes) for signer_id.
+    const hexAddrRaw =
+      this.tronWeb.address?.toHex?.(this.address) || //
+      this.tronWeb.defaultAddress?.hex ||
+      "";
+
+    const clean = hexAddrRaw.startsWith("0x") ? hexAddrRaw.slice(2) : hexAddrRaw;
+    if (!clean) return this.address.toLowerCase();
+
+    // Tron addresses are typically: 41 + 20 bytes (hex).
+    if (clean.length >= 42 && clean.startsWith("41")) return `0x${clean.slice(2, 42)}`.toLowerCase();
+    if (clean.length === 40) return `0x${clean}`.toLowerCase();
+    return `0x${clean}`.toLowerCase();
+  }
+
+  private async trc20Balance(contractAddress: string): Promise<bigint> {
+    if (!this.tronWeb.contract) throw new Error("TronLink not available");
+    const contract = await this.tronWeb.contract().at(contractAddress);
+    const res = await contract.balanceOf(this.address).call();
+    const value = typeof res === "string" ? res : res?._hex ?? res?.toString?.() ?? "0";
+    return BigInt(value);
+  }
+
+  async fetchBalance(chain: number, address: string): Promise<bigint> {
+    if (chain !== Network.Tron) throw "Invalid chain";
+    if (!this.tronWeb.trx) throw new Error("TronLink not available");
+
+    if (address === "native") {
+      const balance = await this.tronWeb.trx.getBalance?.(this.address);
+      return BigInt(balance || 0);
+    }
+
+    return await this.trc20Balance(address);
+  }
+
+  async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
+    const native = await this.fetchBalance(chain, "native");
+
+    try {
+      const res = await fetch(`https://api0.herewallet.app/api/v1/user/balances/${chain}/${this.address}`, { body: JSON.stringify({ whitelist, chain_id: chain }), method: "POST" });
+      if (!res.ok) throw new Error("Failed to fetch balances");
+      const { balances } = await res.json();
+      return { ...balances, native };
+    } catch {
+      const balances = await Promise.all(
+        whitelist.map(async (token) => {
+          const balance = await this.fetchBalance(chain, token);
+          return [token, balance] as const;
+        })
+      );
+      return { ...Object.fromEntries(balances), native };
+    }
+  }
+
+  async transferFee(token: Token): Promise<ReviewFee> {
+    // Tron fees depend on bandwidth/energy; for UX we return "0" and let wallet handle it.
+    return new ReviewFee({ baseFee: 0n, gasLimit: 0n, chain: token.chain });
+  }
+
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    if (!this.tronWeb.trx) throw new Error("TronLink not available");
+
+    if (args.token.address === "native") {
+      const result = await this.tronWeb.trx.sendTransaction?.(args.receiver, args.amount.toString());
+      return result?.txid || result?.transaction?.txID || result?.txID || result?.id || "";
+    }
+
+    if (!this.tronWeb.contract) throw new Error("TronLink not available");
+    const contract = await this.tronWeb.contract().at(args.token.address);
+    const result = await contract.transfer(args.receiver, args.amount.toString()).send();
+    return typeof result === "string" ? result : result?.txid || result?.transaction?.txID || result?.txID || "";
+  }
+
+  private async signMessageTIP191(message: string): Promise<Uint8Array> {
+    if (!this.tronWeb.trx?.signMessageV2 && !this.tronWeb.trx?.signMessage) throw "not impl";
+    const signatureHex = (await (this.tronWeb.trx.signMessageV2?.(message) || this.tronWeb.trx.signMessage?.(message))) as string;
+    if (!signatureHex) throw new Error("Failed to sign message");
+
+    const clean = signatureHex.startsWith("0x") ? signatureHex.slice(2) : signatureHex;
+    if (clean.length < 130) throw new Error("Invalid signature");
+
+    const rsv = clean.slice(0, 130);
+    const v = parseInt(rsv.slice(128, 130), 16);
+    const parity = v === 27 || v === 0 ? 0 : v === 28 || v === 1 ? 1 : v % 2;
+    const normalized = rsv.slice(0, 128) + (parity === 0 ? "00" : "01");
+    return hex.decode(normalized);
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Commitment> {
+    const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+
+    const message = JSON.stringify({
+      deadline: options?.deadline ? new Date(options.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
+      verifying_contract: "intents.near",
+      signer_id: this.omniAddress,
+      nonce: base64.encode(nonce),
+      intents: intents,
+    });
+
+    // TronLink signs messages using TIP-191 ("\x19TRON Signed Message:\n").
+    const buffer = await this.signMessageTIP191(message);
+    return {
+      signature: `secp256k1:${base58.encode(buffer)}`,
+      payload: message,
+      standard: "tip191",
+    };
+  }
+}
+
+export default TronWallet;

package/src/ui/Popup.tsx

@@ -16,13 +16,18 @@ export const present = (render: (close: () => void) => React.ReactNode) => {
       div.remove();
     })
   );
+
+  return () => {
+    root.unmount();
+    div.remove();
+  };
 };
 
 interface PopupProps {
   widget?: boolean;
   children: React.ReactNode;
   header?: React.ReactNode;
-  onClose: () => void;
+  onClose?: () => void;
   style?: React.CSSProperties;
   mobileFullscreen?: boolean;
 }
@@ -57,9 +62,12 @@ const Popup = ({ widget, children, header, onClose, style, mobileFullscreen }: P
         <ModalContent ref={contentRef} $mobileFullscreen={mobileFullscreen} style={{ opacity: 0, transform: "translateY(20px)", transition: "all 0.2s ease-in-out" }}>
           {header && (
             <ModalHeader>
-              <button onClick={onClose} style={{ position: "absolute", right: 16, top: 16 }}>
-                <CloseIcon />
-              </button>
+              {onClose != null && (
+                <button onClick={onClose} style={{ position: "absolute", right: 16, top: 16 }}>
+                  <CloseIcon />
+                </button>
+              )}
+
               {header}
             </ModalHeader>
           )}