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

package/src/{core/nearRpc.ts → near/rpc.ts}

@@ -1,42 +1,27 @@
 import { JsonRpcProvider } from "@near-js/providers";
 import { getErrorTypeFromErrorMessage, parseRpcError } from "@near-js/utils";
 import { TypedError, FinalExecutionOutcome } from "@near-js/types";
+import { base64 } from "@scure/base";
+
+import { api, NetworkError, TimeoutNetworkError } from "../core/api";
+import { Network } from "../core";
 
 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",
-];
+const rpcUrls = [api.getRpcUrl(Network.Near), "https://relmn.aurora.dev", "https://archival-rpc.mainnet.near.org", "https://rpc-near.hapi.mobi", "https://nearrpc.aurora.dev"];
 
 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) {
+  constructor(providers = rpcUrls, private timeout = 30_000, private triesCountForEveryProvider = 3, private incrementTimout = true) {
     super({ url: "" });
     this.currentProviderIndex = 0;
     this.providers = providers;
@@ -44,7 +29,7 @@ export class NearRpc extends JsonRpcProvider {
   }
 
   async viewMethod(args: { contractId: string; methodName: string; args: any }) {
-    const payload = Buffer.from(JSON.stringify(args.args), "utf8").toString("base64");
+    const payload = base64.encode(new TextEncoder().encode(JSON.stringify(args.args)));
     const data: any = await rpc.query({
       args_base64: payload,
       finality: "optimistic",
@@ -97,7 +82,7 @@ export class NearRpc extends JsonRpcProvider {
 
     const req = await fetch(url, {
       body: JSON.stringify({ method, params, id: _nextId++, jsonrpc: "2.0" }),
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", "Api-Key": api.apiKey },
       signal: controller.signal,
       method: "POST",
     }).catch(() => {
@@ -136,6 +121,7 @@ export class NearRpc extends JsonRpcProvider {
       if (isTimeout) {
         throw new TypedError(errorMessage, "TimeoutError");
       }
+
       const type = getErrorTypeFromErrorMessage(response.error.data, response.error.name);
       throw new TypedError(errorMessage, type);
     }

package/src/near/wallet.ts

@@ -1,30 +1,25 @@
 import { NearWalletBase, SignMessageParams, SignedMessage, SignAndSendTransactionParams } from "@hot-labs/near-connect";
 import { base64, base58 } from "@scure/base";
 
-import { OmniConnector } from "../OmniConnector";
 import { OmniWallet } from "../OmniWallet";
 import { WalletType } from "../core/chains";
 import { ReviewFee } from "../core/bridge";
-import { rpc, TGAS } from "../core/nearRpc";
+import { rpc, TGAS } from "./rpc";
 import { Token } from "../core/token";
 import { Commitment } from "../core";
 
 export default class NearWallet extends OmniWallet {
+  readonly icon = "https://storage.herewallet.app/upload/73a44e583769f11112b0eff1f2dd2a560c05eed5f6d92f0c03484fa047c31668.png";
   readonly type = WalletType.NEAR;
 
-  constructor(readonly connector: OmniConnector, readonly address: string, readonly publicKey?: string, readonly wallet?: NearWalletBase) {
-    super(connector);
+  constructor(readonly address: string, readonly publicKey?: string, readonly wallet?: NearWalletBase) {
+    super();
   }
 
   get omniAddress() {
     return this.address;
   }
 
-  async disconnect() {
-    await this.wallet?.signOut();
-    super.disconnect();
-  }
-
   async fetchBalances(_: number, whitelist: string[]): Promise<Record<string, bigint>> {
     const balances = await Promise.all(
       whitelist.map(async (token) => {
@@ -167,6 +162,40 @@ export default class NearWallet extends OmniWallet {
     return await this.sendTransaction({ receiverId: args.token.address, actions });
   }
 
+  async isIntentAccountRegistered() {
+    const keys = await rpc.viewMethod({
+      contractId: "intents.near",
+      methodName: "public_keys_of",
+      args: { account_id: this.address },
+    });
+    return keys.includes(this.publicKey);
+  }
+
+  async registerIntentAccountIfNeeded() {
+    let isRegistered = await this.isIntentAccountRegistered();
+    if (isRegistered) return;
+
+    await this.sendTransaction({
+      receiverId: "intents.near",
+      actions: [
+        {
+          type: "FunctionCall",
+          params: {
+            methodName: "add_public_key",
+            args: { public_key: this.publicKey },
+            gas: String(80n * TGAS),
+            deposit: String(1n),
+          },
+        },
+      ],
+    }).catch(() => null);
+
+    isRegistered = await this.isIntentAccountRegistered();
+    if (isRegistered) return;
+
+    throw new Error("Failed to register intent account");
+  }
+
   async signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Commitment> {
     if (!this.wallet) throw "not impl";
 
@@ -181,28 +210,7 @@ export default class NearWallet extends OmniWallet {
     if (!result) throw new Error("Failed to sign message");
     const { signature, publicKey } = result;
 
-    const keys = await rpc.viewMethod({
-      contractId: "intents.near",
-      methodName: "public_keys_of",
-      args: { account_id: this.address },
-    });
-
-    if (!keys.includes(publicKey)) {
-      await this.sendTransaction({
-        receiverId: "intents.near",
-        actions: [
-          {
-            type: "FunctionCall",
-            params: {
-              methodName: "add_public_key",
-              args: { public_key: publicKey },
-              gas: String(80n * TGAS),
-              deposit: String(1n),
-            },
-          },
-        ],
-      });
-    }
+    await this.registerIntentAccountIfNeeded();
 
     return {
       standard: "nep413",

package/src/solana/{protocol.ts → WalletStandard.ts}

@@ -1,7 +1,5 @@
 import type { Connection, Transaction, VersionedTransaction } from "@solana/web3.js";
-import { SolanaSignAndSendTransactionMethod, SolanaSignMessageMethod, SolanaSignTransactionMethod } from "@solana/wallet-standard-features";
 import type { Wallet } from "@wallet-standard/base";
-import { base58 } from "@scure/base";
 
 export interface ISolanaProtocolWallet {
   address: string;
@@ -41,7 +39,7 @@ class SolanaProtocolWallet implements ISolanaProtocolWallet {
   async sendTransaction(transaction: Transaction | VersionedTransaction, connection: Connection, options?: any): Promise<string> {
     const account = await this.getAccount();
     const features = this.wallet.features as any;
-    const signTx = features["solana:signTransaction"]?.signTransaction as SolanaSignTransactionMethod;
+    const signTx = features["solana:signTransaction"]?.signTransaction;
     const [signed] = await signTx({ account, chain: account.chains[0], transaction: transaction.serialize() });
     const signedTx = signed.signedTransaction as Transaction | VersionedTransaction | Uint8Array;
     const raw = signedTx instanceof Uint8Array ? signedTx : (signedTx as any).serialize();
@@ -52,7 +50,7 @@ class SolanaProtocolWallet implements ISolanaProtocolWallet {
   async signMessage(message: string) {
     const account = await this.getAccount();
     const features = this.wallet.features as any;
-    const signMessageFeature = features["solana:signMessage"]?.signMessage as SolanaSignMessageMethod;
+    const signMessageFeature = features["solana:signMessage"]?.signMessage;
 
     if (!signMessageFeature) throw new Error("Wallet does not support solana:signMessage");
     const [result] = await signMessageFeature({ account, message: new TextEncoder().encode(message) });

package/src/solana/connector.ts

@@ -9,8 +9,8 @@ import { OmniWallet } from "../OmniWallet";
 import { WalletType } from "../core/chains";
 import HOT from "../hot-wallet/iframe";
 
-import SolanaProtocolWallet from "./protocol";
-import { getWallets } from "./wallets";
+import SolanaProtocolWallet from "./WalletStandard";
+import { getWallets } from "./walletStandartList";
 import SolanaWallet from "./wallet";
 
 const wallets = getWallets();
@@ -36,7 +36,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
         const wallet = this.options.find((w) => w.id === id);
         if (!wallet) return;
         const protocolWallet = await SolanaProtocolWallet.connect(wallet.wallet, { silent: true });
-        this.setWallet(new SolanaWallet(this, protocolWallet));
+        this.setWallet(new SolanaWallet(protocolWallet));
       } catch {
         this.removeStorage();
       }
@@ -59,7 +59,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
         const connected = await this.getConnectedWallet();
         if (connected !== wallet.name) return;
         const protocolWallet = await SolanaProtocolWallet.connect(wallet, { silent: true });
-        this.setWallet(new SolanaWallet(this, protocolWallet));
+        this.setWallet(new SolanaWallet(protocolWallet));
       } catch {
         this.removeStorage();
       }
@@ -88,7 +88,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
 
     this.setStorage({ type: "walletconnect" });
     return this.setWallet(
-      new SolanaWallet(this, {
+      new SolanaWallet({
         address: account,
         sendTransaction: async (tx: Transaction | VersionedTransaction, connection: Connection, options?: any) => {
           const transaction = Buffer.from(tx.serialize()).toString("base64");
@@ -112,8 +112,9 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
     );
   }
 
-  async createWallet(address: string): Promise<OmniWallet> {
-    return new SolanaWallet(this, { address });
+  async disconnect() {
+    this.wallets.forEach((w) => w.wallet.disconnect?.());
+    super.disconnect();
   }
 
   async getConnectedWallet() {
@@ -142,7 +143,7 @@ class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
     try {
       this.setStorage({ type: "wallet", id });
       const protocolWallet = await SolanaProtocolWallet.connect(wallet.wallet, { silent: false });
-      return this.setWallet(new SolanaWallet(this, protocolWallet));
+      return this.setWallet(new SolanaWallet(protocolWallet));
     } catch (e) {
       this.removeStorage();
       throw e;

package/src/solana/injected/solana-wallet.ts

@@ -110,7 +110,7 @@ export class GhostWallet implements Wallet {
     this._connected();
   }
 
-  _on: StandardEventsOnMethod = (event, listener) => {
+  _on: StandardEventsOnMethod = (event: StandardEventsNames, listener: StandardEventsListeners[StandardEventsNames]) => {
     this._listeners[event]?.push(listener) || (this._listeners[event] = [listener]);
     return (): void => this._off(event, listener);
   };
@@ -152,7 +152,7 @@ export class GhostWallet implements Wallet {
     }
   };
 
-  _connect: StandardConnectMethod = async ({ silent } = {}) => {
+  _connect: StandardConnectMethod = async ({ silent }: { silent?: boolean } = {}) => {
     if (!this._account) await this._ghost.connect(silent ? { onlyIfTrusted: true } : undefined);
     this._connected();
     return { accounts: this.accounts };
@@ -162,7 +162,7 @@ export class GhostWallet implements Wallet {
     await this._ghost.disconnect();
   };
 
-  _signAndSendTransaction: SolanaSignAndSendTransactionMethod = async (...inputs) => {
+  _signAndSendTransaction: SolanaSignAndSendTransactionMethod = async (...inputs: any[]) => {
     if (!this._account) throw new Error("not connected");
 
     const outputs: SolanaSignAndSendTransactionOutput[] = [];
@@ -189,7 +189,7 @@ export class GhostWallet implements Wallet {
     return outputs;
   };
 
-  _signTransaction: SolanaSignTransactionMethod = async (...inputs) => {
+  _signTransaction: SolanaSignTransactionMethod = async (...inputs: any[]) => {
     if (!this._account) throw new Error("not connected");
 
     const outputs: SolanaSignTransactionOutput[] = [];
@@ -243,7 +243,7 @@ export class GhostWallet implements Wallet {
     return outputs;
   };
 
-  _signMessage: SolanaSignMessageMethod = async (...inputs) => {
+  _signMessage: SolanaSignMessageMethod = async (...inputs: any[]) => {
     if (!this._account) throw new Error("not connected");
 
     const outputs: SolanaSignMessageOutput[] = [];
@@ -264,7 +264,7 @@ export class GhostWallet implements Wallet {
     return outputs;
   };
 
-  _signIn: SolanaSignInMethod = async (...inputs) => {
+  _signIn: SolanaSignInMethod = async (...inputs: any[]) => {
     const outputs: SolanaSignInOutput[] = [];
 
     if (inputs.length > 1) {

package/src/solana/wallet.ts

@@ -14,7 +14,6 @@ import {
 } from "@solana/spl-token";
 
 import { Network, WalletType } from "../core/chains";
-import { OmniConnector } from "../OmniConnector";
 import { OmniWallet } from "../OmniWallet";
 
 import { Token } from "../core/token";
@@ -23,13 +22,14 @@ import { ReviewFee } from "../core/bridge";
 import { Commitment } from "../core";
 import { api } from "../core/api";
 
-import { ISolanaProtocolWallet } from "./protocol";
+import { ISolanaProtocolWallet } from "./WalletStandard";
 
 class SolanaWallet extends OmniWallet {
+  readonly icon = "https://storage.herewallet.app/upload/8700f33153ad813e133e5bf9b791b5ecbeea66edca6b8d17aeccb8048eb29ef7.png";
   readonly type = WalletType.SOLANA;
 
-  constructor(readonly connector: OmniConnector, readonly wallet: ISolanaProtocolWallet) {
-    super(connector);
+  constructor(readonly wallet: ISolanaProtocolWallet) {
+    super();
   }
 
   getConnection() {
@@ -63,12 +63,7 @@ class SolanaWallet extends OmniWallet {
     return BigInt(meta.value.amount);
   }
 
-  async disconnect() {
-    await this.wallet.disconnect?.();
-    super.disconnect();
-  }
-
-  async buildTranferInstructions(token: Token, amount: bigint, receiver: string, fee?: ReviewFee) {
+  async buildTranferInstructions(token: Token, amount: bigint, receiver: string, fee: ReviewFee) {
     const destination = new PublicKey(receiver);
     const owner = new PublicKey(this.address);
     const connection = this.getConnection();
@@ -81,10 +76,10 @@ class SolanaWallet extends OmniWallet {
         reserve,
         additionalFee,
         instructions: [
-          fee ? ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.priorityFee) }) : undefined,
-          fee ? ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) }) : undefined,
+          ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.priorityFee) }),
+          ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) }),
           SystemProgram.transfer({ fromPubkey: owner, toPubkey: destination, lamports: amount }),
-        ].filter(Boolean) as TransactionInstruction[],
+        ],
       };
     }
 
@@ -95,11 +90,7 @@ class SolanaWallet extends OmniWallet {
     const tokenFrom = getAssociatedTokenAddressSync(mint, owner, false, tokenProgramId);
     const tokenTo = getAssociatedTokenAddressSync(mint, destination, false, tokenProgramId);
 
-    const instructions: TransactionInstruction[] = [];
-    if (fee) {
-      instructions.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.baseFee) }));
-      instructions.push(ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) }));
-    }
+    const instructions: TransactionInstruction[] = [ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.baseFee) }), ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) })];
 
     const isRegistered = await getAccount(connection, tokenTo, "confirmed", tokenProgramId).catch(() => null);
     if (isRegistered == null) {
@@ -156,7 +147,7 @@ class SolanaWallet extends OmniWallet {
   }
 
   async getPriorityFeeEstimate(params: any): Promise<any> {
-    const response = await fetch("https://api0.herewallet.app/api/v1/evm/helius/staked", {
+    const response = await fetch(api.baseUrl + "/api/v1/evm/helius/staked", {
       body: JSON.stringify({ jsonrpc: "2.0", id: "helius-sdk", method: "getPriorityFeeEstimate", params: [params] }),
       headers: { "Content-Type": "application/json" },
       method: "POST",
@@ -169,7 +160,7 @@ class SolanaWallet extends OmniWallet {
     return result;
   }
 
-  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string> {
+  async transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee: ReviewFee }): Promise<string> {
     const { instructions } = await this.buildTranferInstructions(args.token, args.amount, args.receiver, args.gasFee);
     return await this.sendTransaction(instructions);
   }

package/src/stellar/connector.ts

@@ -4,7 +4,6 @@ import HOT from "../hot-wallet/iframe";
 import { WalletType } from "../core/chains";
 import { HotConnector } from "../HotConnector";
 import { ConnectorType, OmniConnector } from "../OmniConnector";
-import { OmniWallet } from "../OmniWallet";
 
 import { FreighterModule } from "./freigher";
 import { HotWalletModule } from "./hotWallet";
@@ -45,10 +44,6 @@ class StellarConnector extends OmniConnector<StellarWallet> {
     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 (HOT.isInjected) {
       const { address } = await this.modules.hotWallet.getAddress();
@@ -61,7 +56,7 @@ class StellarConnector extends OmniConnector<StellarWallet> {
   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 }));
+    return this.setWallet(new StellarWallet({ address, rpc: this.wibe3.hotBridge.stellar, signMessage, signTransaction }));
   }
 
   async connect(id: string) {

package/src/stellar/wallet.ts

@@ -4,7 +4,6 @@ import { rpc } from "@stellar/stellar-sdk";
 
 import { WalletType } from "../core/chains";
 import { OmniWallet } from "../OmniWallet";
-import { OmniConnector } from "../OmniConnector";
 import { ReviewFee } from "../core/bridge";
 import { formatter } from "../core/utils";
 import { Network } from "../core/chains";
@@ -12,9 +11,13 @@ import { Token } from "../core/token";
 import { Commitment } from "../core";
 
 interface ProtocolWallet {
+  address: string;
   signTransaction?: (transaction: Transaction) => Promise<{ signedTxXdr: string }>;
   signMessage?: (message: string) => Promise<{ signedMessage: string }>;
-  address: string;
+  rpc: {
+    callSoroban: (callback: (s: any) => Promise<any>) => Promise<any>;
+    callHorizon: (callback: (h: any) => Promise<any>) => Promise<any>;
+  };
 }
 
 export const ACCOUNT_FOR_SIMULATE = "GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7";
@@ -28,14 +31,11 @@ export enum ASSET_CONTRACT_METHOD {
 }
 
 class StellarWallet extends OmniWallet {
+  readonly icon = "https://storage.herewallet.app/upload/1469894e53ca248ac6adceb2194e6950a13a52d972beb378a20bce7815ba01a4.png";
   readonly type = WalletType.STELLAR;
 
-  constructor(readonly connector: OmniConnector, readonly wallet: ProtocolWallet) {
-    super(connector);
-  }
-
-  get rpc() {
-    return this.connector.wibe3.hotBridge.stellar;
+  constructor(readonly wallet: ProtocolWallet) {
+    super();
   }
 
   get address() {
@@ -86,8 +86,8 @@ class StellarWallet extends OmniWallet {
     const asset = await this.getAssetFromContractId(token);
     const sendAmount = formatter.formatAmount(amount, 7);
 
-    const account = await this.connector.wibe3.hotBridge.stellar.callSoroban((s) => s.getAccount(this.address));
-    const baseFee = await this.connector.wibe3.hotBridge.stellar.callHorizon((h) => h.fetchBaseFee()).catch(() => +BASE_FEE);
+    const account = await this.wallet.rpc.callSoroban((s) => s.getAccount(this.address));
+    const baseFee = await this.wallet.rpc.callHorizon((h) => h.fetchBaseFee()).catch(() => +BASE_FEE);
     const builder = new TransactionBuilder(account, {
       memo: memo ? Memo.text(memo) : undefined,
       networkPassphrase: Networks.PUBLIC,
@@ -106,13 +106,13 @@ class StellarWallet extends OmniWallet {
         )
       );
 
-      const tx = await this.rpc.callSoroban((s) => s.prepareTransaction(builder.build() as any));
+      const tx = await this.wallet.rpc.callSoroban((s) => s.prepareTransaction(builder.build() as any));
       const fee = BigInt(Math.floor(baseFee * tx.operations.length));
       return { fee: new ReviewFee({ baseFee: fee, priorityFee: 0n, gasLimit: 1n, chain: Network.Stellar }), tx: tx as unknown as Transaction };
     }
 
     let needXlm = 0;
-    const receiverAccount = await this.rpc.callHorizon((h) => h.loadAccount(receiver)).catch(() => null);
+    const receiverAccount = await this.wallet.rpc.callHorizon((h) => h.loadAccount(receiver)).catch(() => null);
     const claimableBalance = Operation.createClaimableBalance({ amount: amount.toString(), claimants: [new Claimant(receiver)], asset });
 
     if (receiverAccount == null) {
@@ -154,7 +154,7 @@ class StellarWallet extends OmniWallet {
     if (!this.wallet.signTransaction) throw "not impl";
     const result = await this.wallet.signTransaction(transaction);
     const txObject = new Transaction(result.signedTxXdr, Networks.PUBLIC);
-    const { hash } = await this.rpc.callHorizon((t) => t.submitTransaction(txObject as any));
+    const { hash } = await this.wallet.rpc.callHorizon((t) => t.submitTransaction(txObject as any));
     return hash;
   }
 
@@ -197,7 +197,7 @@ class StellarWallet extends OmniWallet {
   async changeTrustline(address: string) {
     if (address === "native") return;
     const asset = await this.getAssetFromContractId(address);
-    const account = await this.rpc.callHorizon((h) => h.loadAccount(this.address));
+    const account = await this.wallet.rpc.callHorizon((h) => h.loadAccount(this.address));
     const trustlineOp = Operation.changeTrust({ asset: asset, source: this.address });
     const trustlineTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: Networks.PUBLIC }) //
       .addOperation(trustlineOp)
@@ -215,7 +215,7 @@ class StellarWallet extends OmniWallet {
     }
 
     const tx = await this.buildSmartContactTx(ACCOUNT_FOR_SIMULATE, id, ASSET_CONTRACT_METHOD.NAME);
-    const result = (await this.rpc.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
+    const result = (await this.wallet.rpc.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
 
     const value = result?.result?.retval?.value();
     if (!value) throw "Asset not found";
@@ -227,7 +227,7 @@ class StellarWallet extends OmniWallet {
   }
 
   async buildSmartContactTx(publicKey: string, contactId: string, method: string, ...args: any[]) {
-    const account = await this.rpc.callSoroban((s) => s.getAccount(publicKey));
+    const account = await this.wallet.rpc.callSoroban((s) => s.getAccount(publicKey));
     const contract = new Contract(contactId);
     const builtTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: Networks.PUBLIC });
 
@@ -244,7 +244,7 @@ class StellarWallet extends OmniWallet {
       Address.fromString(contract).toScVal()
     );
 
-    const result = (await this.rpc.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
+    const result = (await this.wallet.rpc.callSoroban((s) => s.simulateTransaction(tx as any))) as unknown as rpc.Api.SimulateTransactionSuccessResponse;
     if (result) return BigInt(this.i128ToInt(result.result?.retval.value() as xdr.Int128Parts));
     return 0n;
   }

package/src/ton/connector.ts

@@ -69,7 +69,7 @@ class TonConnector extends OmniConnector<TonWallet> {
     tonConnect.onStatusChange(async (wallet) => {
       if (!wallet) return this.removeWallet();
       this.setWallet(
-        new TonWallet(this, {
+        new TonWallet({
           sendTransaction: (params) => tonConnect.sendTransaction(params),
           signData: (params) => tonConnect.signData(params),
           account: wallet.account,
@@ -108,10 +108,6 @@ class TonConnector extends OmniConnector<TonWallet> {
     return tonConnect;
   }
 
-  async createWallet(address: string) {
-    return new TonWallet(this, { account: { address } });
-  }
-
   async connect(id: string) {
     const connector = await this.tonConnect;
     connector.openSingleWalletModal(id);

package/src/ton/wallet.ts

@@ -6,7 +6,6 @@ import { base58, base64, hex } from "@scure/base";
 
 import { OmniWallet } from "../OmniWallet";
 import { WalletType } from "../core/chains";
-import { OmniConnector } from "../OmniConnector";
 import { ReviewFee } from "../core/bridge";
 import { Token } from "../core/token";
 
@@ -19,10 +18,11 @@ interface ProtocolWallet {
 }
 
 class TonWallet extends OmniWallet {
+  readonly icon = "https://storage.herewallet.app/upload/3ffa61e237f8e38d390abd60200db8edff3ec2b20aad0cc0a8c7a8ba9c318124.png";
   readonly type = WalletType.TON;
 
-  constructor(readonly connector: OmniConnector, readonly wallet: ProtocolWallet) {
-    super(connector);
+  constructor(readonly wallet: ProtocolWallet) {
+    super();
   }
 
   get address() {

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;