@hot-labs/kit 1.0.33

package/src/omni/index.ts

@@ -0,0 +1,8 @@
+export { OmniToken, WalletType, Network, chainsMap, reverseChainsMap } from "./config";
+export { Intents } from "./Intents";
+export { Token } from "./token";
+export { tokens } from "./tokens";
+export { bridge } from "./bridge";
+export { Recipient } from "./recipient";
+export { formatter } from "./utils";
+export * from "./types";

package/src/omni/nearRpc.ts

@@ -0,0 +1,187 @@
+import { JsonRpcProvider } from "@near-js/providers";
+import { getErrorTypeFromErrorMessage, parseRpcError } from "@near-js/utils";
+import { TypedError, FinalExecutionOutcome } from "@near-js/types";
+
+let _nextId = 123;
+
+export const TGAS = 1_000_000_000_000n;
+
+class NetworkError extends Error {
+  constructor(status: number, title: string, message: string) {
+    super(`${status} ${title}: ${message}`);
+  }
+}
+
+class TimeoutNetworkError extends NetworkError {
+  constructor(title: string) {
+    super(0, title, "Timeout error");
+  }
+}
+
+const wait = (timeout: number) => {
+  return new Promise<void>((resolve) => setTimeout(resolve, timeout));
+};
+
+const c1 = Math.random() > 0.5;
+export const rpcProviders = [
+  c1 ? "https://c1.rpc.fastnear.com" : "https://c2.rpc.fastnear.com",
+  c1 ? "https://c2.rpc.fastnear.com" : "https://c1.rpc.fastnear.com",
+  "https://relmn.aurora.dev",
+  "https://nearrpc.aurora.dev",
+  "https://archival-rpc.mainnet.near.org",
+];
+
+export class NearRpc extends JsonRpcProvider {
+  public providers: string[];
+  public currentProviderIndex = 0;
+  public startTimeout;
+
+  constructor(providers = rpcProviders, private timeout = 30_000, private triesCountForEveryProvider = 3, private incrementTimout = true) {
+    super({ url: "" });
+    this.currentProviderIndex = 0;
+    this.providers = providers;
+    this.startTimeout = timeout;
+  }
+
+  async viewMethod(args: { contractId: string; methodName: string; args: any }) {
+    const payload = Buffer.from(JSON.stringify(args.args), "utf8").toString("base64");
+    const data: any = await rpc.query({
+      args_base64: payload,
+      finality: "optimistic",
+      request_type: "call_function",
+      method_name: args.methodName,
+      account_id: args.contractId,
+    });
+
+    return JSON.parse(Buffer.from(data.result).toString("utf8"));
+  }
+
+  async sendJsonRpc<T>(method: string, params: any, attempts = 0): Promise<T> {
+    const url = this.providers[this.currentProviderIndex];
+    const requestStart = Date.now();
+
+    try {
+      const result = await this.send<T>(method, params, url, this.timeout);
+      this.timeout = Math.max(this.startTimeout, this.timeout / 1.2);
+      return result;
+    } catch (error: any) {
+      if (error instanceof TimeoutNetworkError && this.incrementTimout) {
+        this.timeout = Math.min(60_000, this.timeout * 1.2);
+      }
+
+      if (error instanceof NetworkError) {
+        this.currentProviderIndex += 1;
+        if (this.providers[this.currentProviderIndex] == null) {
+          this.currentProviderIndex = 0;
+        }
+        if (attempts + 1 > this.providers.length * this.triesCountForEveryProvider) {
+          throw error;
+        }
+
+        const needTime = 500 * attempts;
+        const spent = Date.now() - requestStart;
+
+        if (spent < needTime) {
+          await wait(needTime - spent);
+        }
+        return await this.sendJsonRpc(method, params, attempts + 1);
+      }
+
+      throw error;
+    }
+  }
+
+  async send<T>(method: string, params: any, url: string, timeout: number): Promise<T> {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+
+    const req = await fetch(url, {
+      body: JSON.stringify({ method, params, id: _nextId++, jsonrpc: "2.0" }),
+      headers: { "Content-Type": "application/json" },
+      signal: controller.signal,
+      method: "POST",
+    }).catch(() => {
+      clearInterval(timer);
+      if (controller.signal.aborted) {
+        throw new TimeoutNetworkError("RPC Network Error");
+      }
+      if (!window.navigator.onLine) {
+        throw new NetworkError(0, "RPC Network Error", "No internet connection");
+      }
+      throw new NetworkError(0, "RPC Network Error", "Unknown Near RPC Error, maybe connection unstable, try VPN");
+    });
+
+    clearInterval(timer);
+    if (!req.ok) {
+      const text = await req.text().catch(() => "Unknown error");
+      throw new NetworkError(req.status, "RPC Network Error", text);
+    }
+
+    const response = await req.json();
+
+    if (response.error) {
+      if (typeof response.error.data === "object") {
+        const isReadable = typeof response.error.data.error_message === "string" && typeof response.error.data.error_type === "string";
+        if (isReadable) {
+          throw new TypedError(response.error.data.error_message, response.error.data.error_type);
+        }
+        throw parseRpcError(response.error.data);
+      }
+
+      // NOTE: All this hackery is happening because structured errors not implemented
+      // TODO: Fix when https://github.com/nearprotocol/nearcore/issues/1839 gets resolved
+      const errorMessage = `[${response.error.code}] ${response.error.message}: ${response.error.data}`;
+      const isTimeout = response.error.data === "Timeout" || errorMessage.includes("Timeout error") || errorMessage.includes("query has timed out");
+
+      if (isTimeout) {
+        throw new TypedError(errorMessage, "TimeoutError");
+      }
+      const type = getErrorTypeFromErrorMessage(response.error.data, response.error.name);
+      throw new TypedError(errorMessage, type);
+    }
+
+    return response.result;
+  }
+
+  async hasNearAccount(accountId: string): Promise<boolean> {
+    const keys = await rpc.viewAccessKeyList(accountId);
+    return keys.keys.length > 0;
+  }
+
+  parseReceipts = (logs: FinalExecutionOutcome) => {
+    const errors: any[] = [];
+
+    logs.receipts_outcome?.forEach((t) => {
+      const status = t.outcome.status;
+      if (typeof status === "string" && status === "Failure") errors.push(status);
+      else if (typeof status === "object" && "Failure" in status) errors.push(status.Failure);
+    });
+
+    if (errors.length > 0) {
+      const ExecutionError = errors[0]?.ActionError?.kind?.FunctionCallError?.ExecutionError;
+      if (ExecutionError) throw ExecutionError;
+      const err = JSON.stringify(errors, null, 2);
+      throw new Error(err);
+    }
+
+    return logs;
+  };
+
+  waitTransactionResult = async (txHash: string, accountId: string, attemps = 0, signal?: AbortSignal, total = 30): Promise<FinalExecutionOutcome> => {
+    if (signal?.aborted) throw new Error("Aborted");
+    if (attemps > total) throw new Error("Transaction not found");
+
+    const options = { tx_hash: txHash, sender_account_id: accountId, wait_until: "EXECUTED" };
+    const logs: any = await rpc.sendJsonRpc("EXPERIMENTAL_tx_status", options).catch(() => null);
+    if (signal?.aborted) throw new Error("Aborted");
+
+    if (logs == null || logs.status === "NotStarted" || logs.transaction == null) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      return await this.waitTransactionResult(txHash, accountId, attemps + 1, signal);
+    }
+
+    return this.parseReceipts(logs);
+  };
+}
+
+export const rpc = new NearRpc();

package/src/omni/recipient.ts

@@ -0,0 +1,41 @@
+import { Address } from "@ton/core";
+import { hex, base32, base58 } from "@scure/base";
+
+import { type OmniWallet } from "../OmniWallet";
+import { tonApi } from "../ton/utils";
+import { WalletType } from "./config";
+
+export class Recipient {
+  constructor(readonly type: WalletType, readonly address: string, readonly omniAddress: string) {}
+
+  static fromWallet(wallet?: OmniWallet) {
+    if (!wallet) return undefined;
+    return new Recipient(wallet.type, wallet.address, wallet.omniAddress);
+  }
+
+  static async fromAddress(type: WalletType, address: string) {
+    if (type === WalletType.TON) {
+      const data = await tonApi.accounts.getAccountPublicKey(Address.parse(address));
+      return new Recipient(WalletType.TON, address, data.publicKey.toLowerCase());
+    }
+
+    if (type === WalletType.EVM) {
+      return new Recipient(WalletType.EVM, address, address.toLowerCase());
+    }
+
+    if (type === WalletType.NEAR) {
+      return new Recipient(WalletType.NEAR, address, address.toLowerCase());
+    }
+
+    if (type === WalletType.STELLAR) {
+      const payload = base32.decode(address);
+      return new Recipient(WalletType.STELLAR, address, hex.encode(payload.slice(1, -2)).toLowerCase());
+    }
+
+    if (type === WalletType.SOLANA) {
+      return new Recipient(WalletType.SOLANA, address, hex.encode(base58.decode(address)).toLowerCase());
+    }
+
+    return new Recipient(type, address, "");
+  }
+}

package/src/omni/token.ts

@@ -0,0 +1,125 @@
+import { TokenResponse } from "@defuse-protocol/one-click-sdk-typescript";
+import { Asset, Networks } from "@stellar/stellar-base";
+
+import { Network, OmniToken, WalletType, chainsMap, reverseChainsMap } from "./config";
+import { formatter } from "./utils";
+
+export interface IToken {
+  chain: number;
+  address: string;
+  decimals: number;
+  symbol: string;
+}
+
+export class Token {
+  chain: number;
+  address: string;
+  decimals: number;
+  symbol: string;
+  usd: number;
+  omniAddress: string;
+  originalChain: number;
+  originalAddress: string;
+  originalChainSymbol: string;
+
+  constructor(readonly info: TokenResponse & { omni?: true }) {
+    this.originalChainSymbol = info.blockchain;
+    this.originalChain = reverseChainsMap[info.blockchain];
+    this.chain = info.omni ? -4 : reverseChainsMap[info.blockchain];
+
+    if (this.chain === Network.Near) {
+      this.address = info.contractAddress === "wrap.near" ? "native" : info.contractAddress || "native";
+      this.originalAddress = this.address;
+    } else if (this.chain === Network.Stellar) {
+      this.address = info.contractAddress ? new Asset(info.symbol, info.contractAddress).contractId(Networks.PUBLIC) : "native";
+      this.originalAddress = this.address;
+    } else {
+      this.address = info.omni ? info.assetId : info.contractAddress || "native";
+      this.originalAddress = info.contractAddress || "native";
+    }
+
+    this.decimals = info.decimals;
+    this.symbol = info.symbol === "wNEAR" ? "NEAR" : info.symbol;
+    this.usd = info.price;
+    this.omniAddress = info.assetId;
+  }
+
+  get chainIcon() {
+    return chainsMap[this.chain]?.logo || `https://storage.herewallet.app/ft/${this.chain}:native.png`;
+  }
+
+  get originalChainIcon() {
+    if (this.originalChain === Network.Juno) return "https://legacy.cosmos.network/presskit/cosmos-brandmark-dynamic-dark.svg";
+    return `https://storage.herewallet.app/ft/${this.originalChain}:native.png`;
+  }
+
+  get chainName() {
+    return chainsMap[this.chain]?.name || this.originalChainSymbol;
+  }
+
+  get id() {
+    return `${this.chain}:${this.address}`;
+  }
+
+  get isMainOmni() {
+    if (this.chain !== Network.Hot) return false;
+    return Object.values(OmniToken).some((token) => this.address === token);
+  }
+
+  get type() {
+    if (this.chain === Network.Hot) return WalletType.OMNI;
+    if (this.chain === Network.Near) return WalletType.NEAR;
+    if (this.chain === Network.Solana) return WalletType.SOLANA;
+    if (this.chain === Network.OmniTon) return WalletType.TON;
+    if (this.chain === Network.Ton) return WalletType.TON;
+    if (this.chain === Network.Stellar) return WalletType.STELLAR;
+    if (this.chain === Network.Juno) return WalletType.COSMOS;
+    if (this.chain === Network.Gonka) return WalletType.COSMOS;
+    if (this.chain === Network.Btc) return WalletType.Btc;
+    if (this.chain === Network.Tron) return WalletType.Tron;
+    if (this.chain === Network.Zcash) return WalletType.Zcash;
+    if (this.chain === Network.Xrp) return WalletType.Xrp;
+    if (this.chain === Network.Doge) return WalletType.Doge;
+    if (this.chain === Network.Ada) return WalletType.Ada;
+    if (this.chain === Network.Aptos) return WalletType.Aptos;
+    if (this.chain === Network.Sui) return WalletType.Sui;
+    if (this.chain === Network.Litecoin) return WalletType.Litecoin;
+    if (this.chain === Network.Cardano) return WalletType.Cardano;
+    if (this.chain > 0) return WalletType.EVM;
+    return WalletType.unknown;
+  }
+
+  get reserve() {
+    if (this.chain === Network.Gonka) return 0.001;
+    if (this.chain === Network.Juno) return 0.001;
+
+    if (this.address !== "native") return 0;
+    if (this.chain === Network.Hot) return 0;
+    if (this.chain === Network.Ton) return 0.01;
+    if (this.chain === Network.Stellar) return 0;
+    if (this.chain === Network.Solana) return 0.001;
+    if (this.chain === Network.Near) return 0.01;
+    if (this.usd === 0) return 0;
+
+    if (this.chain === Network.Eth) return 2 / this.usd;
+    return 0.1 / this.usd;
+  }
+
+  get icon() {
+    if (this.chain === Network.Hot) return `https://storage.herewallet.app/ft/${this.originalChain}:${this.originalAddress.toLowerCase()}.png`;
+    return `https://storage.herewallet.app/ft/${this.id.toLowerCase()}.png`;
+  }
+
+  float(t: number | bigint | string) {
+    return formatter.formatAmount(t, this.decimals);
+  }
+
+  int(t: number | bigint | string) {
+    return BigInt(formatter.parseAmount(t.toString(), this.decimals));
+  }
+
+  readable(t: number | bigint | string, rate = 1) {
+    const n = typeof t === "number" ? t : formatter.formatAmount(t ?? 0, this.decimals);
+    return formatter.amount(n * rate);
+  }
+}

package/src/omni/tokens.ts

@@ -0,0 +1,68 @@
+import { makeObservable, observable, runInAction } from "mobx";
+
+import { OneClickService } from "@defuse-protocol/one-click-sdk-typescript";
+import { defaultTokens } from "./defaultTokens";
+import { Network, OmniToken } from "./config";
+import { Token } from "./token";
+
+class TokensStorage {
+  public list = defaultTokens.flatMap((t: any) => [new Token(t), new Token({ ...t, omni: true })]);
+  private initialTokensLoader = this.refreshTokens().catch(() => {});
+
+  constructor() {
+    makeObservable(this, {
+      list: observable,
+    });
+  }
+
+  get(id: OmniToken | string, chain = Network.Hot): Token {
+    return this.list.find((t) => t.chain === chain && t.address === id)!;
+  }
+
+  async getToken(chain: number, address: string): Promise<Token> {
+    const tokens = await this.getTokens();
+    return tokens.find((t) => t.chain === chain && t.address === address)!;
+  }
+
+  async startTokenPolling() {
+    await new Promise((resolve) => setTimeout(resolve, 10_000));
+    await this.refreshTokens().catch(() => {});
+    await this.startTokenPolling();
+  }
+
+  async refreshTokens() {
+    await this.initialTokensLoader;
+    const list = await OneClickService.getTokens();
+    list.unshift({
+      blockchain: "gonka-mainnet" as any,
+      priceUpdatedAt: "2025-11-23T18:01:00.349Z",
+      assetId: OmniToken.GONKA,
+      contractAddress: "ngonka",
+      symbol: "GNK",
+      decimals: 9,
+      price: 0,
+    });
+
+    list.unshift({
+      blockchain: "adi" as any,
+      priceUpdatedAt: "2025-11-23T18:01:00.349Z",
+      assetId: OmniToken.ADI,
+      symbol: "ADI",
+      decimals: 18,
+      price: 0,
+    });
+
+    runInAction(() => {
+      this.list = list.flatMap((t) => [new Token(t), new Token({ ...t, omni: true })]);
+    });
+
+    return this.list;
+  }
+
+  async getTokens(): Promise<Token[]> {
+    await this.initialTokensLoader;
+    return this.list;
+  }
+}
+
+export const tokens = new TokensStorage();

package/src/omni/types.ts

@@ -0,0 +1,46 @@
+export interface TransferIntent {
+  intent: "transfer";
+  tokens: Record<string, string>;
+  receiver_id: string;
+  msg?: string;
+  min_gas?: string;
+}
+
+export interface TokenDiffIntent {
+  intent: "token_diff";
+  diff: Record<string, string>;
+}
+
+export interface MtWithdrawIntent {
+  intent: "mt_withdraw";
+  amounts: string[];
+  receiver_id: string;
+  token_ids: string[];
+  token: string;
+  memo?: string;
+  msg?: string;
+  min_gas?: string;
+}
+
+export interface FtWithdrawIntent {
+  intent: "ft_withdraw";
+  memo?: string;
+  receiver_id: string;
+  token: string;
+  amount: string;
+  msg?: string;
+}
+
+export interface AuthCallIntent {
+  min_gas: string;
+  attached_deposit: string;
+  contract_id: string;
+  msg: string;
+  intent: "auth_call";
+}
+
+export interface Commitment {
+  deadline: string;
+  signer_id: string;
+  intents: TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent[];
+}

package/src/omni/utils.ts

@@ -0,0 +1,163 @@
+type Value = number | bigint | string;
+export const formatter = {
+  toReadableNumber(decimals: number | bigint, number: bigint | string = "0"): string {
+    number = number.toString();
+    if (!decimals) return number;
+
+    decimals = Number(decimals);
+    const wholeStr = number.substring(0, number.length - decimals) || "0";
+    const fractionStr = number
+      .substring(number.length - decimals)
+      .padStart(decimals, "0")
+      .substring(0, decimals);
+
+    return `${wholeStr}.${fractionStr}`.replace(/\.?0+$/, "");
+  },
+
+  truncateAddress(address: string, length = 16) {
+    return address.length > length ? `${address.slice(0, length / 2)}...${address.slice(-length / 2)}` : address;
+  },
+
+  toNonDivisibleNumber(decimals: number | bigint, number: string): string {
+    if (decimals === null || decimals === undefined) return number;
+    decimals = Number(decimals);
+    const [wholePart, fracPart = ""] = number.includes("e") ? Number(number).toFixed(24).split(".") : number.split(".");
+    return `${wholePart}${fracPart.padEnd(decimals, "0").slice(0, decimals)}`.replace(/^0+/, "").padStart(1, "0");
+  },
+
+  formatAmount(n: number | string | bigint, d: number, r?: number) {
+    const int = formatter.toReadableNumber(d, n?.toString() || "0");
+    return r ? formatter.round(int, r) : +int;
+  },
+
+  parseAmount(n: string | number | bigint, d: number) {
+    return formatter.toNonDivisibleNumber(d, (n || 0).toString());
+  },
+
+  bigIntMax(...args: bigint[]) {
+    return args.reduce((m, e) => (e > m ? e : m));
+  },
+
+  bigIntMin(...args: bigint[]) {
+    return args.reduce((m, e) => (e < m ? e : m));
+  },
+
+  formatNumberWithSubscriptZeros(numberStr: string, presiction = 3, min = 0.000_01): string {
+    const number = Number.parseFloat(numberStr);
+    if (!numberStr.startsWith("0.")) return String(+number.toFixed(presiction));
+
+    const leadingZerosMatch = numberStr.match(/^0\.(0+)/);
+    if (!leadingZerosMatch) return String(+number.toFixed(presiction));
+
+    const leadingZerosCount = leadingZerosMatch[1].length;
+    if (leadingZerosCount > 2) {
+      const remainingDigits = numberStr.slice(leadingZerosMatch[0].length);
+      const smallCount = String(leadingZerosCount)
+        .split("")
+        .map((digit) => String.fromCharCode(8320 + Number.parseInt(digit)))
+        .join("");
+
+      return `0.0${smallCount}${remainingDigits.slice(0, presiction)}`;
+    }
+
+    return String(+number.toFixed(presiction));
+  },
+
+  formatNumberWithZeros(numberStr: Value, presiction = 3, min = 0.000_01): string {
+    const number = Number.parseFloat(numberStr.toString());
+    numberStr = formatter.fixed(numberStr, 24);
+
+    if (number >= min) {
+      const [part0, part1] = numberStr.split(".");
+      if (part1) {
+        const leadingZeros = part1?.match?.(/^0+/)?.[0] || "";
+        return `${part0}.${leadingZeros}${part1.replace(leadingZeros, "").slice(0, presiction)}`;
+      }
+      return part1 ? [part0, part1.slice(0, presiction)].join(".") : part0;
+    }
+
+    const leadingZerosMatch = numberStr.match(/^0\.(0+)/);
+    if (!leadingZerosMatch) return numberStr;
+
+    const remainingDigits = numberStr.slice(leadingZerosMatch[0].length);
+    return `0.0${leadingZerosMatch[1] || ""}${remainingDigits.slice(0, presiction)}`;
+  },
+
+  isBig(n: number) {
+    return formatter.readableBigParts(n)[1] !== "";
+  },
+
+  round(value: Value, dec = 2) {
+    const decimal = Math.pow(10, dec);
+    return Math.floor(formatter.num(value) * decimal) / decimal;
+  },
+
+  readableBig(n: number) {
+    if (n < 10_000) return formatter.amount(n);
+    if (n < 1_000_000) return `${formatter.round(n / 1000, 2)}K`;
+    if (n < 1_000_000_000) return `${formatter.round(n / 1_000_000, 2)}M`;
+    if (n < 1_000_000_000_000) return `${formatter.round(n / 1_000_000_000, 2)}B`;
+    if (n < 1_000_000_000_000_000) return `${formatter.round(n / 1_000_000_000_000, 2)}T`;
+    return `${formatter.round(n / 1_000_000_000_000_000, 2)}Q`;
+  },
+
+  readableBigParts(n: number): [number, string] {
+    if (n < 10_000) return [formatter.round(n, 4), ""];
+    if (n < 1_000_000) return [formatter.round(n / 1000, 2), "K"];
+    if (n < 1_000_000_000_000) return [formatter.round(n / 1_000_000, 2), "M"];
+    return [formatter.round(n / 1_000_000_000, 2), "B"];
+  },
+  formatNumber(num: string) {
+    let useDelimeter = false;
+    let right = "";
+    let left = "";
+
+    if (num.startsWith("0") && num.length > 1 && !num.startsWith("0.")) {
+      num = num.slice(1);
+    }
+
+    const chars = num.split("");
+    chars.forEach((char) => {
+      const isNumber = char >= "0" && char <= "9";
+      if (isNumber && useDelimeter) right += char;
+      else if (isNumber && !useDelimeter) left += char;
+      else if (char === "." || char.toLowerCase() === "б" || char.toLowerCase() === "ю") {
+        if (left == "") left = "0";
+        useDelimeter = true;
+      }
+    });
+
+    return useDelimeter ? `${left}.${right}` : `${left}`;
+  },
+
+  fixed(v: Value, dec = 20) {
+    return new Intl.NumberFormat("en-US", {
+      style: "decimal",
+      minimumFractionDigits: 0,
+      maximumFractionDigits: Math.min(12, Math.max(0, Math.floor(dec))),
+      useGrouping: true,
+    }).format(formatter.num(v));
+  },
+
+  fromInput(value: Value) {
+    return formatter.formatNumber(value?.toString() ?? "0");
+  },
+
+  trim(value: Value) {
+    return formatter.fromInput(formatter.formatNumberWithZeros(formatter.fromInput(value?.toString() ?? "0")));
+  },
+
+  amount(value: Value, decimals = 24) {
+    const num = String(+formatter.num(value).toFixed(decimals));
+    return formatter.formatNumberWithSubscriptZeros(num, 3, 0.0001);
+  },
+
+  num(value: Value) {
+    if (value == null) return 0;
+    return Number.isNaN(Number(value)) ? 0 : Number(value);
+  },
+
+  wait(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  },
+};

package/src/settings.ts

@@ -0,0 +1,5 @@
+export const GlobalSettings = {
+  webWallet: "https://app.hot-labs.org",
+  rpcs: {} as Record<number, string[]>,
+  tonApi: "",
+};