@hot-labs/kit 1.0.33

package/src/evm/wallet.ts

@@ -0,0 +1,156 @@
+import { base64, base58, hex } from "@scure/base";
+import { BrowserProvider, ethers, JsonRpcProvider, JsonRpcSigner, TransactionRequest } from "ethers";
+
+import { OmniConnector } from "../OmniConnector";
+import { OmniWallet } from "../OmniWallet";
+import { WalletType } from "../omni/config";
+import { ReviewFee } from "../omni/bridge";
+import { Token } from "../omni/token";
+import { erc20abi } from "./abi";
+
+export interface EvmProvider {
+  request: (args: any) => Promise<any>;
+  on?: (method: string, handler: (args: any) => void) => void;
+  off?: (method: string, handler: (args: any) => void) => void;
+}
+
+class EvmWallet extends OmniWallet {
+  readonly publicKey?: string;
+  readonly type = WalletType.EVM;
+
+  constructor(readonly connector: OmniConnector, readonly address: string, readonly provider: EvmProvider) {
+    super(connector);
+  }
+
+  private rpcs: Record<number, JsonRpcProvider> = {};
+  rpc(chain: number) {
+    if (chain < 1 || chain == null) throw "Invalid chain";
+    if (this.rpcs[chain]) return this.rpcs[chain];
+    const rpc = new JsonRpcProvider(`https://api0.herewallet.app/api/v1/evm/rpc/${chain}`, chain, { staticNetwork: true });
+    this.rpcs[chain] = rpc;
+    return rpc;
+  }
+
+  get omniAddress() {
+    return this.address.toLowerCase();
+  }
+
+  async disconnect() {
+    this.provider.request?.({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
+    await super.disconnect();
+  }
+
+  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];
+        })
+      );
+      return { ...Object.fromEntries(balances), native };
+    }
+  }
+
+  async fetchBalance(chain: number, address: string) {
+    const rpc = this.rpc(chain);
+    if (address === "native") {
+      const balance = await rpc.getBalance(this.address);
+      return BigInt(balance);
+    }
+
+    const erc20 = new ethers.Contract(address, erc20abi, rpc);
+    const balance = await erc20.balanceOf(this.address);
+    return BigInt(balance);
+  }
+
+  async signIntentsWithAuth(domain: string, intents?: Record<string, any>[]) {
+    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
+    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
+    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
+
+    return {
+      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
+      chainId: WalletType.EVM,
+      publicKey: this.address,
+      address: this.address,
+      seed,
+    };
+  }
+
+  async signMessage(msg: string) {
+    if (!this.provider.request) throw "not impl";
+    const result: string = await this.provider.request({ method: "personal_sign", params: [msg, this.address] });
+    const yInt = parseInt(result.slice(-2), 16);
+    const isZero = yInt === 27 || yInt === 0;
+    return hex.decode(result.slice(2, -2) + (isZero ? "00" : "01"));
+  }
+
+  async transferFee(token: Token, receiver: string, amount: bigint): Promise<ReviewFee> {
+    const rpc = this.rpc(token.chain);
+    const fee = ReviewFee.fromFeeData(await rpc.getFeeData(), token.chain);
+
+    if (token.address === "native") {
+      const gasLimit = await rpc.estimateGas({ to: receiver, value: 100n, ...fee.evmGas });
+      const extaLimit = BigInt(Math.floor(Number(gasLimit) * 1.3));
+      return fee.changeGasLimit(extaLimit);
+    }
+
+    const erc20 = new ethers.Contract(token.address, erc20abi, rpc);
+    const gasLimit = await erc20.transfer.estimateGas(receiver, amount, fee.evmGas);
+    const extaLimit = BigInt(Math.floor(Number(gasLimit) * 1.3));
+    return fee.changeGasLimit(extaLimit);
+  }
+
+  async sendTransaction(chain: number, request: TransactionRequest): Promise<string> {
+    if (!this.provider.request) throw "not impl";
+    const provider = new BrowserProvider(this.provider as any);
+    const signer = new JsonRpcSigner(provider, this.address);
+
+    await this.provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: `0x${chain.toString(16)}` }] });
+    const tx = await signer.sendTransaction(request);
+    return tx.hash;
+  }
+
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+    if (args.token.address === "native") {
+      return await this.sendTransaction(args.token.chain, {
+        ...args.gasFee?.evmGas,
+        from: this.address,
+        value: args.amount,
+        to: args.receiver,
+      });
+    }
+
+    const erc20 = new ethers.Contract(args.token.address, erc20abi, this.rpc(args.token.chain));
+    const tx = await erc20.transfer.populateTransaction(args.receiver, args.amount, { ...args.gasFee?.evmGas });
+    return await this.sendTransaction(args.token.chain, tx);
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Record<string, any>> {
+    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,
+    });
+
+    const buffer = await this.signMessage(message);
+    return {
+      signature: `secp256k1:${base58.encode(buffer)}`,
+      payload: message,
+      standard: "erc191",
+    };
+  }
+}
+
+export default EvmWallet;

package/src/exchange.ts

@@ -0,0 +1,426 @@
+import { GetExecutionStatusResponse, OneClickService, ApiError, OpenAPI, QuoteRequest, QuoteResponse } from "@defuse-protocol/one-click-sdk-typescript";
+import { utils } from "@hot-labs/omni-sdk";
+import { hex } from "@scure/base";
+
+import CosmosWallet from "./cosmos/wallet";
+import StellarWallet from "./stellar/wallet";
+import NearWallet from "./near/wallet";
+import EvmWallet from "./evm/wallet";
+
+import { HotConnector } from "./HotConnector";
+import { Network, OmniToken, WalletType } from "./omni/config";
+import { bridge, ReviewFee } from "./omni/bridge";
+import { Recipient } from "./omni/recipient";
+import { OmniWallet } from "./OmniWallet";
+import { tokens } from "./omni/tokens";
+import { Token } from "./omni/token";
+
+OpenAPI.BASE = "https://1click.chaindefuser.com";
+OpenAPI.TOKEN = "";
+
+export class UnsupportedDexError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export class ReadableDexError extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}
+
+export type BridgeReview = {
+  amountIn: bigint;
+  amountOut: bigint;
+  slippage: number;
+  fee: ReviewFee | null;
+  qoute: QuoteResponse["quote"] | "withdraw" | "deposit";
+  status: "pending" | "success" | "failed";
+  statusMessage: string | null;
+  sender: OmniWallet | "qr";
+  recipient: Recipient;
+  from: Token;
+  to: Token;
+};
+
+interface BridgeRequest {
+  refund: OmniWallet;
+  sender: OmniWallet | "qr";
+  type?: "exactIn" | "exactOut";
+  recipient: Recipient;
+  slippage: number;
+  amount: bigint;
+  from: Token;
+  to: Token;
+}
+
+const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export class Exchange {
+  constructor(readonly wibe3: HotConnector) {}
+
+  async getToken(chain: number, address: string): Promise<string | null> {
+    if (chain === Network.Hot) return address;
+    const tokensList = await tokens.getTokens();
+    const token = tokensList.find((t) => {
+      if (t.chain !== chain) return false;
+      if (t.address?.toLowerCase() === address.toLowerCase()) return true;
+      if (address === "native" && t.address == "native") return true;
+      if (address === "native" && t.address == "wrap.near") return true;
+      return false;
+    });
+
+    return token?.omniAddress || null;
+  }
+
+  async deposit(args: { sender: OmniWallet; token: Token; amount: bigint; recipient: Recipient; onMessage: (message: string) => void }) {
+    const { sender, token, amount, recipient, onMessage } = args;
+    onMessage("Sending deposit transaction");
+
+    if (token.type === WalletType.COSMOS && sender instanceof CosmosWallet) {
+      const cosmosBridge = await bridge.cosmos();
+      const hash = await cosmosBridge.deposit({
+        sendTransaction: async (tx) => sender.sendTransaction(tx),
+        senderPublicKey: hex.decode(sender.publicKey),
+        intentAccount: recipient.omniAddress,
+        sender: sender.address,
+        token: token.address,
+        chain: token.chain,
+        amount: amount,
+      });
+
+      onMessage("Waiting for deposit");
+      const deposit = await bridge.waitPendingDeposit(token.chain, hash, recipient.omniAddress);
+      onMessage("Finishing deposit");
+      await bridge.finishDeposit(deposit);
+      onMessage("Deposit finished");
+      return;
+    }
+
+    if (token.type === WalletType.EVM && sender instanceof EvmWallet) {
+      const hash = await bridge.evm.deposit({
+        sendTransaction: async (tx) => sender.sendTransaction(token.chain, tx),
+        intentAccount: recipient.omniAddress,
+        sender: sender.address,
+        token: token.address,
+        chain: token.chain,
+        amount: amount,
+      });
+
+      if (!hash) throw new Error("Failed to deposit");
+      onMessage("Waiting for deposit");
+      const deposit = await bridge.waitPendingDeposit(token.chain, hash, recipient.omniAddress);
+      onMessage("Finishing deposit");
+      await bridge.finishDeposit(deposit);
+      onMessage("Deposit finished");
+      return;
+    }
+
+    if (token.type === WalletType.NEAR && sender instanceof NearWallet) {
+      return await bridge.near.deposit({
+        sendTransaction: async (tx: any) => sender.sendTransaction(tx),
+        intentAccount: recipient.omniAddress,
+        sender: sender.address,
+        token: token.address,
+        amount: amount,
+      });
+    }
+
+    throw new Error("Unsupported token");
+  }
+
+  async withdraw(args: { sender: OmniWallet; token: Token; amount: bigint; recipient: Recipient }) {
+    const { sender, token, amount, recipient } = args;
+
+    const receipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+    if (receipientWallet instanceof NearWallet && token.type === WalletType.NEAR) {
+      await receipientWallet.registerToken(token.address);
+    }
+
+    await bridge.withdrawToken({
+      signIntents: async (intents) => sender.signIntents(intents),
+      intentAccount: sender.omniAddress,
+      receiver: recipient.address,
+      token: token.address,
+      chain: token.chain,
+      gasless: true,
+      amount: amount,
+    });
+  }
+
+  async withdrawFee(request: BridgeRequest) {
+    if (request.sender === "qr") throw new Error("Sender is QR");
+    if (request.to.chain === Network.Near || request.to.chain === Network.Hot) return 0n;
+    const gaslessFee = await bridge.getGaslessWithdrawFee({
+      receiver: request.recipient.address,
+      token: request.to.address,
+      chain: request.to.chain,
+    });
+
+    if (gaslessFee.gasPrice === 0n) return 0n;
+    if (request.to.address === "native") return 0n;
+
+    // if withdraw token is not native, we need to swap a bit of it to native to cover the withdraw fee
+    const swap = await bridge.buildSwapExectOutIntent({
+      intentAccount: request.sender.omniAddress,
+      intentFrom: utils.toOmniIntent(request.to.chain, request.to.address),
+      intentTo: utils.toOmniIntent(request.to.chain, "native"),
+      amountOut: gaslessFee.gasPrice,
+    });
+
+    // if swap is successful and the amount out is greater than the amount in, we need to subtract the amount in from the amount out
+    return BigInt(swap.amount_in);
+  }
+
+  async reviewSwap(request: BridgeRequest): Promise<BridgeReview> {
+    const { sender, refund, from, to, amount, recipient, slippage, type } = request;
+    const intentFrom = await this.getToken(from.chain, from.address);
+    const intentTo = await this.getToken(to.chain, to.address);
+
+    if (!intentFrom) throw new Error("Unsupported token");
+    if (!intentTo) throw new Error("Unsupported token");
+
+    const deadlineTime = 20 * 60 * 1000;
+    const directChains = [Network.Near, Network.Juno, Network.Gonka, Network.ADI];
+    const deadline = new Date(Date.now() + deadlineTime).toISOString();
+    const noFee = from.symbol === to.symbol;
+
+    if (sender !== "qr" && directChains.includes(from.chain) && to.chain === Network.Hot && from.omniAddress === to.omniAddress) {
+      const fee = await bridge.getDepositFee({
+        intentAccount: sender.omniAddress,
+        sender: sender.address,
+        token: from.address,
+        chain: from.chain,
+        amount: amount,
+      });
+
+      return {
+        from: from,
+        to: to,
+        sender: sender,
+        recipient,
+        amountIn: amount,
+        amountOut: amount,
+        slippage: slippage,
+        statusMessage: null,
+        status: "pending",
+        qoute: "deposit",
+        fee,
+      };
+    }
+
+    if (sender !== "qr" && directChains.includes(to.chain) && from.chain === Network.Hot && from.omniAddress === to.omniAddress) {
+      const fee = await this.withdrawFee(request);
+      if (fee >= amount) throw "Withdraw fee is greater than amount";
+      return {
+        from: from,
+        to: to,
+        amountIn: amount,
+        sender: sender,
+        fee: new ReviewFee({ chain: -4 }),
+        amountOut: amount - fee,
+        slippage: slippage,
+        recipient: recipient,
+        statusMessage: null,
+        status: "pending",
+        qoute: "withdraw",
+      };
+    }
+
+    const refundParams = { refundType: QuoteRequest.refundType.ORIGIN_CHAIN, refundTo: refund.address };
+    if (refund.type !== from.type) {
+      if (!refund.omniAddress) throw "Setup refund address";
+      refundParams.refundType = QuoteRequest.refundType.INTENTS;
+      refundParams.refundTo = refund.omniAddress;
+    }
+
+    if (recipient.type === WalletType.STELLAR) {
+      const isTokenActivated = await StellarWallet.isTokenActivated(recipient.address, request.to.address);
+      const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+      if (!isTokenActivated && !recipientWallet) throw "Token not activated for recipient";
+    }
+
+    let qoute: QuoteResponse | null = null;
+    try {
+      qoute = await OneClickService.getQuote({
+        originAsset: intentFrom,
+        destinationAsset: intentTo,
+        slippageTolerance: Math.round(slippage * 10_000),
+        swapType: type === "exactIn" ? QuoteRequest.swapType.EXACT_INPUT : QuoteRequest.swapType.EXACT_OUTPUT,
+        depositType: from.chain === Network.Hot ? QuoteRequest.depositType.INTENTS : QuoteRequest.depositType.ORIGIN_CHAIN,
+        depositMode: from.chain === Network.Stellar ? QuoteRequest.depositMode.MEMO : QuoteRequest.depositMode.SIMPLE,
+        recipientType: to.chain === Network.Hot ? QuoteRequest.recipientType.INTENTS : QuoteRequest.recipientType.DESTINATION_CHAIN,
+        recipient: to.chain === Network.Hot ? recipient.omniAddress : recipient.address,
+        appFees: noFee ? [] : [{ recipient: "intents.tg", fee: 25 }],
+        amount: request.amount.toString(),
+        referral: "intents.tg",
+        deadline: deadline,
+        ...refundParams,
+        dry: false,
+      });
+    } catch (e) {
+      console.log({ e });
+      if (e instanceof ApiError && e.body.message.includes("Amount is too low")) {
+        const minAmount = e.body.message.match(/try at least (\d+)/)?.[1];
+        if (minAmount) throw `Minimum amount is ${from.readable(minAmount)} ${from.symbol}`;
+        throw "Amount is too low";
+      }
+
+      if (e instanceof ApiError && e.body.message.includes("is not valid")) {
+        throw "This pair is not supported yet";
+      }
+
+      throw e;
+    }
+
+    let fee: ReviewFee | null = null;
+    if (request.from.chain !== Network.Hot && sender !== "qr") {
+      const amount = BigInt(qoute.quote.amountIn);
+      const depositAddress = qoute.quote.depositAddress!;
+      fee = await sender.transferFee(request.from, depositAddress, amount).catch(() => null);
+    }
+
+    return {
+      from: request.from,
+      to: request.to,
+      amountIn: BigInt(qoute.quote.amountIn),
+      amountOut: BigInt(qoute.quote.amountOut),
+      slippage: request.slippage,
+      recipient: request.recipient,
+      statusMessage: null,
+      qoute: qoute.quote,
+      status: "pending",
+      sender: sender,
+      fee: fee,
+    };
+  }
+
+  async makeSwap(review: BridgeReview, pending: { log: (message: string) => void }) {
+    const { sender, recipient } = review;
+
+    if (review.qoute === "withdraw") {
+      if (sender === "qr") throw new Error("Sender is QR");
+      await this.withdraw({ sender, token: review.to, amount: review.amountIn, recipient });
+      this.wibe3.fetchToken(review.from, sender);
+
+      const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+      if (recipientWallet) this.wibe3.fetchToken(review.to, recipientWallet);
+      return review;
+    }
+
+    if (review.qoute === "deposit") {
+      if (sender === "qr") throw new Error("Sender is QR");
+      await this.deposit({ sender, token: review.from, amount: review.amountIn, recipient, onMessage: pending.log });
+      this.wibe3.fetchToken(review.from, sender);
+
+      const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+      if (recipientWallet) this.wibe3.fetchToken(review.to, recipientWallet);
+      return review;
+    }
+
+    if (sender !== "qr") {
+      if (recipient.type === WalletType.STELLAR) {
+        const isTokenActivated = await StellarWallet.isTokenActivated(recipient.address, review.to.address);
+        const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+        if (!isTokenActivated && !recipientWallet) throw "Token not activated for recipient";
+        if (!isTokenActivated && recipientWallet instanceof StellarWallet) {
+          await recipientWallet.changeTrustline(review.to.address);
+        }
+      }
+
+      const depositAddress = review.qoute.depositAddress!;
+      let hash = "";
+      if (review.from.chain === Network.Hot) {
+        hash = await sender.intents
+          .transfer({
+            amount: review.amountIn,
+            token: review.from.address as OmniToken,
+            recipient: depositAddress,
+          })
+          .execute();
+      } else {
+        hash = await sender.transfer({
+          receiver: depositAddress,
+          amount: review.amountIn,
+          comment: review.qoute.depositMemo,
+          token: review.from,
+          gasFee: review.fee ?? undefined,
+        });
+      }
+
+      pending.log("Submitting tx");
+      this.wibe3.fetchToken(review.from, sender);
+      await OneClickService.submitDepositTx({ txHash: hash, depositAddress }).catch(() => {});
+    }
+
+    if (sender !== "qr") {
+      wait(1000).then(() => this.wibe3.fetchToken(review.to, sender));
+    }
+
+    pending.log("Processing...");
+    const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+    if (!recipientWallet) return await this.processing(review);
+
+    const beforeBalance = await this.wibe3.fetchToken(review.to, recipientWallet).catch(() => null);
+    if (!beforeBalance) return await this.processing(review);
+
+    return await Promise.race([
+      this.waitBalance(review.to, recipientWallet, beforeBalance, review),
+      this.processing(review), //
+    ]);
+  }
+
+  async waitBalance(to: Token, wallet: OmniWallet, beforeBalance: bigint, review: BridgeReview): Promise<BridgeReview> {
+    const afterBalance = await this.wibe3.fetchToken(to, wallet).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");
+  }
+}

package/src/hot-wallet/evm.ts

@@ -0,0 +1,38 @@
+import { isInjected, requestHot } from "./hot";
+
+class HotEvmProvider {
+  _events = new Map<string, Set<any>>();
+  isConnected = () => true;
+  isHotWallet = true;
+  isMetaMask = true;
+
+  request = (request: any) => requestHot("ethereum", request);
+  removeListener() {}
+  on() {}
+}
+
+function announceProvider(provider: HotEvmProvider) {
+  // @ts-expect-error: window.ethereum is not typed
+  window.ethereum = undefined;
+  // @ts-expect-error: window.ethereum is not typed
+  window.ethereum = provider;
+  window?.dispatchEvent(
+    new CustomEvent("eip6963:announceProvider", {
+      detail: Object.freeze({
+        provider: provider,
+        info: {
+          icon: "https://storage.herewallet.app/logo.png",
+          rdns: "org.hot-labs",
+          uuid: "cc8e962c-1f42-425c-8845-e8bd2e136fff",
+          name: "HOT Wallet",
+        },
+      }),
+    })
+  );
+}
+
+if (isInjected()) {
+  const hotProvider = new HotEvmProvider();
+  window.addEventListener("eip6963:requestProvider", () => announceProvider(hotProvider));
+  announceProvider(hotProvider);
+}

package/src/hot-wallet/hot.ts

@@ -0,0 +1,39 @@
+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",
+]);
+
+export const isInjected = () => {
+  if (typeof window === "undefined") return false;
+  if (window.self === window.top) return false;
+  return ancestorOrigins.has(window.location.ancestorOrigins?.[0]);
+};
+
+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 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);
+    };
+
+    window?.parent.postMessage({ $hot: true, method, request, id }, "*");
+    window?.addEventListener("message", handler);
+  });
+};

package/src/hot-wallet/index.ts

@@ -0,0 +1,4 @@
+import "./evm";
+import "./solana";
+import "./ton";
+import "./solana";