@hot-labs/kit 1.0.33

package/src/omni/Intents.ts

@@ -0,0 +1,454 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+import { ed25519 } from "@noble/curves/ed25519";
+import { base58, base64, hex } from "@scure/base";
+
+import type { HotConnector } from "../HotConnector";
+import type { OmniWallet } from "../OmniWallet";
+import type { TransferIntent, MtWithdrawIntent, FtWithdrawIntent, TokenDiffIntent, AuthCallIntent } from "./types";
+
+import { OmniToken } from "./config";
+import { tokens } from "./tokens";
+import { rpc } from "./nearRpc";
+
+export const TGAS = 1000000000000n;
+
+export class Intents {
+  constructor(readonly wibe3?: HotConnector) {}
+
+  static get builder() {
+    return new Intents();
+  }
+
+  hashes: string[] = [];
+  intents: (TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent)[] = [];
+  nonce?: Uint8Array;
+  deadline?: Date;
+  signer?: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string };
+
+  commitments: Record<string, any>[] = [];
+  need = new Map<OmniToken, bigint>();
+
+  addNeed(token: OmniToken, amount: bigint) {
+    if (!this.need.has(token)) this.need.set(token, 0n);
+    this.need.set(token, this.need.get(token)! + amount);
+    return this;
+  }
+
+  authCall(args: { contractId: string; msg: string; attachNear: bigint; tgas: number }) {
+    this.addNeed(OmniToken.NEAR, args.attachNear);
+    this.intents.push({
+      min_gas: (BigInt(args.tgas) * TGAS).toString(),
+      attached_deposit: args.attachNear.toString(),
+      contract_id: args.contractId,
+      intent: "auth_call",
+      msg: args.msg,
+    });
+
+    return this;
+  }
+
+  transfer(args: { recipient: string; token: OmniToken; amount: number | bigint; msg?: string; tgas?: number }) {
+    const omniToken = tokens.get(args.token);
+    const amount = (typeof args.amount === "number" ? omniToken.int(args.amount) : args.amount).toString();
+    const intent: TransferIntent = {
+      min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
+      tokens: { [omniToken.omniAddress]: amount },
+      receiver_id: args.recipient.toLowerCase(),
+      intent: "transfer",
+      msg: args.msg,
+    };
+
+    this.addNeed(args.token, BigInt(amount));
+    this.intents.push(intent);
+    return this;
+  }
+
+  batchTransfer(args: { recipient: string; tokens: Record<OmniToken, number | bigint>; msg?: string; tgas?: number }) {
+    const tokensList: Record<string, string> = {};
+    for (const [token, amount] of Object.entries(args.tokens)) {
+      const omniToken = tokens.get(token);
+      const amountStr = typeof amount === "number" ? omniToken.int(amount).toString() : amount.toString();
+      tokensList[omniToken.omniAddress] = amountStr;
+      this.addNeed(token as OmniToken, BigInt(amountStr));
+    }
+
+    const intent: TransferIntent = {
+      intent: "transfer",
+      receiver_id: args.recipient.toLowerCase(),
+      min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
+      tokens: tokensList,
+      msg: args.msg,
+    };
+
+    this.intents.push(intent);
+    return this;
+  }
+
+  tokenDiff(args: Record<OmniToken, bigint | number>) {
+    const parse = (token: OmniToken, amount: bigint | number): [string, string] => {
+      if (typeof amount === "number") return [token.toString(), tokens.get(token).int(amount).toString()];
+      return [token.toString(), amount.toString()];
+    };
+
+    const intent: TokenDiffIntent = {
+      diff: Object.fromEntries(Object.entries(args).map(([token, amount]) => parse(token as OmniToken, amount))),
+      intent: "token_diff",
+    };
+
+    for (const [token, amountStr] of Object.entries(intent.diff)) {
+      const amount = BigInt(amountStr);
+      if (amount < 0n) {
+        const tokenKey = token as OmniToken;
+        this.addNeed(tokenKey, -amount);
+      }
+    }
+
+    this.intents.push(intent);
+    return this;
+  }
+
+  addRawIntent(rawIntent: Record<string, any>) {
+    if (!rawIntent.intent) throw new Error("Intent must have 'intent' field");
+    const intentType = rawIntent.intent;
+
+    if (intentType === "token_diff") {
+      const diff = rawIntent.diff || rawIntent.token_diff;
+      if (!diff) throw new Error("token_diff intent must have 'diff' or 'token_diff' field");
+
+      const tokenDiffArgs: Record<OmniToken, bigint> = {} as Record<OmniToken, bigint>;
+      for (const [token, amountStr] of Object.entries(diff)) {
+        tokenDiffArgs[token as OmniToken] = BigInt(amountStr as string);
+      }
+      return this.tokenDiff(tokenDiffArgs);
+    }
+
+    if (intentType === "transfer") {
+      if (!rawIntent.tokens || !rawIntent.receiver_id) {
+        throw new Error("transfer intent must have 'tokens' and 'receiver_id' fields");
+      }
+
+      const tokens: Record<OmniToken, bigint> = {} as Record<OmniToken, bigint>;
+      for (const [token, amount] of Object.entries(rawIntent.tokens)) {
+        tokens[token as OmniToken] = BigInt(amount as string);
+      }
+      return this.batchTransfer({
+        recipient: rawIntent.receiver_id,
+        tokens,
+        msg: rawIntent.msg,
+        tgas: rawIntent.min_gas ? Number(BigInt(rawIntent.min_gas) / TGAS) : undefined,
+      });
+    }
+
+    if (intentType === "mt_withdraw") {
+      const intent: MtWithdrawIntent = {
+        intent: "mt_withdraw",
+        amounts: rawIntent.amounts,
+        receiver_id: rawIntent.receiver_id,
+        token_ids: rawIntent.token_ids,
+        token: rawIntent.token,
+        memo: rawIntent.memo,
+        msg: rawIntent.msg,
+        min_gas: rawIntent.min_gas,
+      };
+
+      for (let i = 0; i < rawIntent.amounts.length; i++) {
+        const token = `nep245:${rawIntent.token}:${rawIntent.token_ids[i]}` as OmniToken;
+        this.addNeed(token, BigInt(rawIntent.amounts[i]));
+      }
+
+      this.intents.push(intent);
+      return this;
+    }
+
+    if (intentType === "ft_withdraw") {
+      if (!rawIntent.token || !rawIntent.receiver_id || !rawIntent.amount) {
+        throw new Error("ft_withdraw intent must have 'token', 'receiver_id', and 'amount' fields");
+      }
+
+      const token = `nep141:${rawIntent.token}` as OmniToken;
+      return this.withdraw({
+        amount: BigInt(rawIntent.amount),
+        receiver: rawIntent.receiver_id,
+        memo: rawIntent.memo,
+        msg: rawIntent.msg,
+        token,
+      });
+    }
+
+    if (intentType === "auth_call") {
+      if (!rawIntent.contract_id || !rawIntent.msg || !rawIntent.attached_deposit || !rawIntent.min_gas) {
+        throw new Error("auth_call intent must have 'contract_id', 'msg', 'attached_deposit', and 'min_gas' fields");
+      }
+
+      return this.authCall({
+        contractId: rawIntent.contract_id,
+        msg: rawIntent.msg,
+        attachNear: BigInt(rawIntent.attached_deposit),
+        tgas: Number(BigInt(rawIntent.min_gas) / TGAS),
+      });
+    }
+
+    throw new Error(`Unsupported intent type: ${intentType}`);
+  }
+
+  withdraw(args: { token: OmniToken; amount: number | bigint; receiver: string; memo?: string; msg?: string; tgas?: number }) {
+    const omniToken = tokens.get(args.token);
+    const amount = (typeof args.amount === "number" ? omniToken.int(args.amount) : args.amount).toString();
+    const [standart, ...tokenParts] = args.token.split(":");
+    this.addNeed(args.token, BigInt(amount));
+
+    if (standart === "nep245") {
+      const mtContract = tokenParts[0];
+      const tokenId = tokenParts.slice(1).join(":");
+      const intent: MtWithdrawIntent = {
+        intent: "mt_withdraw",
+        amounts: [amount],
+        receiver_id: args.receiver,
+        token_ids: [tokenId],
+        token: mtContract,
+        memo: args.memo,
+        msg: args.msg,
+        min_gas: args.tgas ? (BigInt(args.tgas) * TGAS).toString() : undefined,
+      };
+
+      this.intents.push(intent);
+      return this;
+    }
+
+    if (standart === "nep141") {
+      const intent: FtWithdrawIntent = {
+        intent: "ft_withdraw",
+        receiver_id: args.receiver,
+        token: tokenParts.join(":"),
+        amount: amount,
+        memo: args.memo,
+        msg: args.msg,
+      };
+
+      this.intents.push(intent);
+      return this;
+    }
+
+    throw new Error(`Unsupported token: ${args.token}`);
+  }
+
+  attachHashes(hashes: string[]) {
+    this.hashes.push(...hashes);
+    return this;
+  }
+
+  attachWallet(wallet: OmniWallet) {
+    this.signer = wallet;
+    return this;
+  }
+
+  attachDeadline(deadline: Date) {
+    this.deadline = deadline;
+    return this;
+  }
+
+  attachNonce(nonce: Uint8Array) {
+    this.nonce = nonce;
+    return this;
+  }
+
+  attachTimeout(seconds: number) {
+    this.deadline = new Date(Date.now() + seconds * 1000);
+    return this;
+  }
+
+  attachSeed(seed: string) {
+    this.nonce = new Uint8Array(sha256(new TextEncoder().encode(seed))).slice(0, 32);
+    return this;
+  }
+
+  take(token: OmniToken, amount: number | bigint) {
+    const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
+
+    this.addNeed(token, intAmount);
+    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
+
+    if (tokenDiff) tokenDiff.diff[token.toString()] = intAmount.toString();
+    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: intAmount.toString() } });
+    return this;
+  }
+
+  give(token: OmniToken, amount: number | bigint) {
+    const intAmount = typeof amount === "number" ? tokens.get(token).int(amount) : amount;
+
+    this.addNeed(token, -intAmount);
+    const tokenDiff = this.intents.find((intent) => intent.intent === "token_diff");
+
+    if (tokenDiff) tokenDiff.diff[token.toString()] = (-intAmount).toString();
+    else this.intents.push({ intent: "token_diff", diff: { [token.toString()]: (-intAmount).toString() } });
+    return this;
+  }
+
+  async signRaw({ ed25519PrivateKey, intentsAddress, checkTokens }: { ed25519PrivateKey: Uint8Array; intentsAddress?: string; checkTokens?: boolean }) {
+    if (checkTokens) {
+      await this.checkRequiredTokens();
+    }
+
+    const publicKey = ed25519.getPublicKey(ed25519PrivateKey);
+    const nonce = new Uint8Array(this.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+
+    const message = JSON.stringify({
+      deadline: this.deadline ? new Date(this.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
+      nonce: base64.encode(nonce),
+      verifying_contract: "intents.near",
+      signer_id: intentsAddress || hex.encode(publicKey).toLowerCase(),
+      intents: this.intents,
+    });
+
+    return {
+      signature: `ed25519:${base58.encode(ed25519.sign(message, ed25519PrivateKey))}`,
+      public_key: `ed25519:${base58.encode(publicKey)}`,
+      standard: "raw_ed25519",
+      payload: message,
+    };
+  }
+
+  async attachCommitment(commitment: Record<string, any>) {
+    this.commitments.push(commitment);
+    return this;
+  }
+
+  async attachSigner(signer: OmniWallet | { ed25519PrivateKey: Uint8Array; omniAddress?: string }) {
+    this.signer = signer;
+    return this;
+  }
+
+  async checkRequiredTokens() {
+    if (this.wibe3 == null) return;
+    for (const [token, needAmount] of this.need.entries()) {
+      if (needAmount <= 0n) continue;
+      await this.wibe3.requestToken(token, needAmount);
+    }
+  }
+
+  async sign(params = { checkTokens: true }) {
+    const signer = this.signer;
+    if (!signer) throw new Error("No signer attached");
+    if (!signer.omniAddress) throw new Error("No omni address");
+
+    if ("ed25519PrivateKey" in signer) {
+      return await this.signRaw({
+        ed25519PrivateKey: signer.ed25519PrivateKey,
+        intentsAddress: signer.omniAddress,
+        checkTokens: params.checkTokens,
+      });
+    }
+
+    if (params.checkTokens) {
+      await this.checkRequiredTokens();
+    }
+
+    return await signer.signIntents(this.intents, {
+      deadline: this.deadline ? +this.deadline : undefined,
+      nonce: this.nonce,
+    });
+  }
+
+  async simulate(params = { checkTokens: true }) {
+    const signed = await this.sign(params);
+    return await Intents.simulateIntents([signed]);
+  }
+
+  async execute(params = { checkTokens: true }) {
+    const signed = await this.sign(params);
+    const hash = await Intents.publishSignedIntents([...this.commitments, signed], this.hashes);
+    await rpc.waitTransactionResult(hash, "intents.near");
+    return hash;
+  }
+
+  static async publishSignedIntents(signed: Record<string, any>[], hashes: string[] = []): Promise<string> {
+    const res = await fetch("https://api0.herewallet.app/api/v1/evm/intent-solver", {
+      headers: { "Content-Type": "application/json" },
+      method: "POST",
+      body: JSON.stringify({
+        params: [{ signed_datas: signed, quote_hashes: hashes }],
+        method: "publish_intents",
+        id: "dontcare",
+        jsonrpc: "2.0",
+      }),
+    });
+
+    const { result } = await res.json();
+    if (result.status === "FAILED") throw result.reason;
+    const intentResult = result.intent_hashes[0];
+
+    const getStatus = async () => {
+      const statusRes = await fetch("https://api0.herewallet.app/api/v1/evm/intent-solver", {
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+        body: JSON.stringify({
+          params: [{ intent_hash: intentResult }],
+          method: "get_status",
+          id: "dontcare",
+          jsonrpc: "2.0",
+        }),
+      });
+
+      const { result } = await statusRes.json();
+      return result;
+    };
+
+    const fetchResult = async () => {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const result = await getStatus().catch(() => null);
+      if (result == null) return await fetchResult();
+      if (result.status === "SETTLED") return result.data.hash;
+      if (result.status === "FAILED") throw result.reason || "Failed to publish intents";
+      return await fetchResult();
+    };
+
+    const hash = await fetchResult();
+    return hash;
+  }
+
+  static async hasPublicKey(accountId: string, publicKey: string): Promise<boolean> {
+    return await rpc.viewMethod({
+      args: { account_id: accountId, public_key: publicKey },
+      methodName: "has_public_key",
+      contractId: "intents.near",
+    });
+  }
+
+  static async simulateIntents(signed: Record<string, any>[]) {
+    return await rpc.viewMethod({
+      args: { signed: signed },
+      methodName: "simulate_intents",
+      contractId: "intents.near",
+    });
+  }
+
+  static async getIntentsBalances(assets: string[], accountId: string): Promise<Record<string, bigint>> {
+    const balances = await rpc.viewMethod({
+      args: { token_ids: assets, account_id: accountId },
+      methodName: "mt_batch_balance_of",
+      contractId: "intents.near",
+    });
+
+    return Object.fromEntries(assets.map((asset, index) => [asset, BigInt(balances[index] || 0n)]));
+  }
+
+  static async getIntentsAssets(accountId: string): Promise<string[]> {
+    const assets: string[] = [];
+    const limit = 250;
+    let fromIndex = 0n;
+
+    for (;;) {
+      const balances = await rpc.viewMethod({
+        args: { account_id: accountId, from_index: fromIndex.toString(), limit },
+        methodName: "mt_tokens_for_owner",
+        contractId: "intents.near",
+      });
+
+      assets.push(...balances.map((b: any) => b.token_id));
+      if (balances.length < limit) break;
+      fromIndex += BigInt(limit);
+    }
+
+    return assets;
+  }
+}

package/src/omni/bridge.ts

@@ -0,0 +1,38 @@
+import { HotBridge, Network, ReviewFee } from "@hot-labs/omni-sdk";
+import { Intents } from "./Intents";
+
+export { ReviewFee };
+
+export const bridge = new HotBridge({
+  api: ["https://dev.herewallet.app"],
+  solanaRpc: ["https://api0.herewallet.app/api/v1/solana/rpc/1001"],
+
+  publishIntents: async (signed: Record<string, any>[], hashes: string[] = []) => {
+    const hash = await Intents.publishSignedIntents(signed, hashes);
+    return { sender: "intents.near", hash };
+  },
+
+  evmRpc: {
+    [Network.ADI]: ["https://dev.herewallet.app/api/v1/evm/rpc/36900"],
+  },
+
+  logger: console,
+  cosmos: {
+    [Network.Juno]: {
+      contract: "juno1va9q7gma6l62aqq988gghv4r7u4hnlgm85ssmsdf9ypw77qfwa0qaz7ea4",
+      rpc: "https://juno-rpc.publicnode.com",
+      gasLimit: 200000n,
+      nativeToken: "ujuno",
+      chainId: "juno-1",
+      prefix: "juno",
+    },
+    [Network.Gonka]: {
+      contract: "gonka15wng2302rhq5w8ddy3l3jslrhfcpufzfs6wc3zc6cxt8cpwrfp4qqgenkc",
+      rpc: "https://dev.herewallet.app/api/v1/evm/rpc/4444119",
+      gasLimit: 200000n,
+      nativeToken: "ngonka",
+      chainId: "gonka-mainnet",
+      prefix: "gonka",
+    },
+  },
+});

package/src/omni/config.ts

@@ -0,0 +1,130 @@
+export enum OmniToken {
+  USDT = "nep141:usdt.tether-token.near",
+  USDC = "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+  GONKA = "nep245:v2_1.omni.hot.tg:4444119_wyixUKCL",
+  NEAR = "nep141:wrap.near",
+  ETH = "nep141:eth.bridge.near",
+  AURORA = "nep141:aaaaaa20d9e0e2461697782ef11675f668207961.factory.bridge.near",
+  SOL = "nep141:sol.omft.near",
+  BNB = "nep245:v2_1.omni.hot.tg:56_11111111111111111111",
+  ADI = "nep245:v2_1.omni.hot.tg:36900_11111111111111111111",
+}
+
+export enum WalletType {
+  NEAR = 1010,
+  EVM = 1,
+  OMNI = -4,
+  SOLANA = 1001,
+  STELLAR = 1100,
+  TON = 1111,
+  COSMOS = 4444118,
+  Tron = 333,
+
+  Zcash = -5,
+  Btc = -6,
+  Xrp = -7,
+  Doge = -8,
+  Ada = -9,
+  Aptos = -10,
+  Sui = -11,
+  Cardano = -12,
+  Litecoin = -14,
+  unknown = -1000000,
+}
+
+export enum Network {
+  Omni_v1 = 0,
+  Hot = -4,
+
+  Zcash = -5,
+  Btc = -6,
+  Xrp = -7,
+  Doge = -8,
+  Ada = -9,
+  Aptos = -10,
+  Sui = -11,
+  Cardano = -12,
+  Litecoin = -14,
+
+  Juno = 4444118,
+  Gonka = 4444119,
+  OmniTon = 1117,
+  ADI = 36900,
+
+  Eth = 1,
+  Tron = 333,
+  Solana = 1001,
+  Stellar = 1100,
+  Near = 1010,
+  Polygon = 137,
+  Arbitrum = 42_161,
+  Aurora = 1_313_161_554,
+  Avalanche = 43_114,
+  Linea = 59_144,
+  Xlayer = 196,
+  Base = 8453,
+  Ton = 1111,
+  Bnb = 56,
+  OpBnb = 204,
+  BnbTestnet = 97,
+  Optimism = 10,
+  Scroll = 534_352,
+  EbiChain = 98_881,
+  Sei = 1329,
+  Blast = 81_457,
+  Taiko = 167_000,
+  Mantle = 5000,
+  Manta = 169,
+  Kava = 2222,
+  ZkSync = 324,
+  Monad = 10_143,
+  Metis = 1088,
+  Gnosis = 100,
+  Fantom = 250,
+  Cronos = 25,
+  Chiliz = 88_888,
+  Moonbeam = 1284,
+  Ronin = 2020,
+  Lisk = 1135,
+  Sonic = 146,
+  Zora = 7_777_777,
+  Mode = 34_443,
+  Berachain = 80_094,
+  Unichain = 130,
+  Soneium = 1868,
+  Ink = 57_073,
+  Apechain = 2741,
+}
+
+export const chainsMap: Record<number, { id: string; name: string; logo?: string }> = {
+  [Network.Juno]: { id: "juno-1", name: "Juno", logo: "https://storage.herewallet.app/ft/4444118:ujuno.png" },
+  [Network.Gonka]: { id: "gonka-mainnet", name: "Gonka", logo: "https://storage.herewallet.app/ft/4444119:ngonka.png" },
+  [Network.Monad]: { id: "monad", name: "Monad", logo: "https://storage.herewallet.app/upload/8f6bdf0d04494dc7157704cf3a7e623aeba7188120d93535d3b9330fa82fc200.JPG" },
+  [Network.Near]: { id: "near", name: "NEAR", logo: "https://storage.herewallet.app/ft/1010:native.png" },
+  [Network.Eth]: { id: "eth", name: "Ethereum", logo: "https://storage.herewallet.app/upload/80978f3676fc2dfbd3d874a9421004fb7dea7616481bda53bf68f44e21c3ce0c.png" },
+  [Network.Solana]: { id: "sol", name: "Solana", logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/solana/info/logo.png" },
+  [Network.Arbitrum]: { id: "arb", name: "Arbitrum", logo: "https://storage.herewallet.app/upload/1606b00068f729f48de00d2575940484f6a0dc83351702a9fb8b0139e41dc00b.jpeg" },
+  [Network.Base]: { id: "base", name: "Base", logo: "https://storage.herewallet.app/upload/c6cf6513fba97c22192d0b96ffd2be74608559017a4c41ebf4457b65224a7070.jpg" },
+  [Network.Bnb]: { id: "bsc", name: "BNB Chain", logo: "https://storage.herewallet.app/upload/b82ec85a318b8d8f1f12b25a0e21cd475208014f15952daf317b876812562530.png" },
+  [Network.Polygon]: { id: "pol", name: "Polygon", logo: "https://storage.herewallet.app/upload/e51b9ec8d0ed17792cca05be487f5dbc1d0a1b9113cf7e3465310de48c0acc2f.jpg" },
+  [Network.Avalanche]: { id: "avax", name: "Avalanche", logo: "https://storage.herewallet.app/upload/fa027e81ebb6957ebd8feada21b5374b15aa090e1747fae131a1e061d3d7e6da.jpg" },
+  [Network.Optimism]: { id: "op", name: "Optimism", logo: "https://storage.herewallet.app/upload/d183a3c76b584552888cb8b5a4dfb849572592d7c7f473fe43bcc5c2adae9a50.jpg" },
+  [Network.Gnosis]: { id: "gnosis", name: "Gnosis", logo: "https://storage.herewallet.app/upload/fc4945be03eec20c68ae19920f012afef7204b2c04d39b5cff6ab3a6d99b5981.jpg" },
+  [Network.Ton]: { id: "ton", name: "TON", logo: "https://tgapp.herewallet.app/images/chains/ton.svg" },
+  [Network.Stellar]: { id: "stellar", name: "Stellar", logo: "https://tgapp.herewallet.app/images/chains/xlm.svg" },
+  [Network.Btc]: { id: "btc", name: "Bitcoin", logo: "https://storage.herewallet.app/ft/-6:native.png" },
+  [Network.Berachain]: { id: "bera", name: "Berachain", logo: "https://storage.herewallet.app/upload/f5c15875b85ca57447ec031930dbdac1f85799a4ca83ae8ecc204142ff433d60.png" },
+  [Network.Tron]: { id: "tron", name: "TRON", logo: "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/tron/info/logo.png" },
+  [Network.Zcash]: { id: "zec", name: "Zcash", logo: "https://storage.herewallet.app/ft/-5:native.png" },
+  [Network.Xrp]: { id: "xrp", name: "XRP", logo: "https://cryptologos.cc/logos/xrp-xrp-logo.svg?v=040" },
+  [Network.Doge]: { id: "doge", name: "Doge", logo: "https://cryptologos.cc/logos/dogecoin-doge-logo.svg?v=040" },
+  [Network.Ada]: { id: "ada", name: "ADA", logo: "https://cryptologos.cc/logos/cardano-ada-logo.svg?v=040" },
+  [Network.Aptos]: { id: "aptos", name: "Aptos", logo: "https://cryptologos.cc/logos/aptos-apt-logo.svg?v=040" },
+  [Network.Sui]: { id: "sui", name: "SUI", logo: "https://cryptologos.cc/logos/sui-sui-logo.svg?v=040" },
+  [Network.Hot]: { id: "hot", name: "Omni", logo: "https://tgapp.herewallet.app/images/hot/hot-icon.png" },
+  [Network.Cardano]: { id: "cardano", name: "Cardano", logo: "https://cryptologos.cc/logos/cardano-ada-logo.svg?v=040" },
+  [Network.Litecoin]: { id: "ltc", name: "Litecoin", logo: "https://cryptologos.cc/logos/litecoin-ltc-logo.svg?v=040" },
+  [Network.ADI]: { id: "adi", name: "ADI" },
+};
+
+export const reverseChainsMap = Object.fromEntries(Object.entries(chainsMap).map(([key, value]) => [value.id, +key]));