@hot-labs/kit 1.0.56 → 1.1.0-beta.1

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

@@ -6,11 +6,11 @@ import { runInAction } from "mobx";
 import { ConnectorType, OmniConnector, WC_ICON } from "../OmniConnector";
 import { HotConnector } from "../HotConnector";
 import { OmniWallet } from "../OmniWallet";
-import { isInjected } from "../hot-wallet/iframe";
 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,12 +112,13 @@ 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() {
-    if (isInjected()) return { type: "wallet", id: "HOT Wallet" };
+    if (HOT.isInjected) return { type: "wallet", id: "HOT Wallet" };
     return this.getStorage();
   }
 
@@ -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/account.ts

@@ -1,9 +1,8 @@
-import { SolanaSignAndSendTransaction, SolanaSignMessage, SolanaSignTransaction } from "@solana/wallet-standard-features";
 import type { WalletAccount } from "@wallet-standard/base";
 import { SOLANA_CHAINS } from "./utils";
 
 const chains = SOLANA_CHAINS;
-const features = [SolanaSignAndSendTransaction, SolanaSignTransaction, SolanaSignMessage] as const;
+const features = ["solana:signAndSendTransaction", "solana:signMessage", "solana:signMessage"] as const;
 
 export class GhostWalletAccount implements WalletAccount {
   readonly #address: WalletAccount["address"];

package/src/solana/injected/index.ts

@@ -1,6 +1,6 @@
 import { Transaction, VersionedTransaction, PublicKey } from "@solana/web3.js";
 
-import { isInjected, requestHot } from "../../hot-wallet/iframe";
+import HOT from "../../hot-wallet/iframe";
 import { registerWallet } from "./register";
 import { GhostWallet } from "./solana-wallet";
 
@@ -25,17 +25,17 @@ const hotSolana = {
   publicKey: null as PublicKey | null,
 
   async connect(options: any) {
-    const { publicKey } = await requestHot("solana:connect", options);
+    const { publicKey } = await HOT.request("solana:connect", options);
     hotSolana.publicKey = new PublicKey(publicKey);
     return { publicKey: hotSolana.publicKey };
   },
 
   async disconnect() {
-    return await requestHot("solana:disconnect", {});
+    return await HOT.request("solana:disconnect", {});
   },
 
   async signAllTransactions(transactions: any[]) {
-    const result = await requestHot("solana:signAllTransactions", {
+    const result = await HOT.request("solana:signAllTransactions", {
       transactions: transactions.map((t) => t.serialize().toString("base64")),
     });
 
@@ -43,7 +43,7 @@ const hotSolana = {
   },
 
   async signTransaction(transaction: any) {
-    const result = await requestHot("solana:signAllTransactions", {
+    const result = await HOT.request("solana:signAllTransactions", {
       transactions: [transaction.serialize().toString("base64")],
     });
 
@@ -51,7 +51,7 @@ const hotSolana = {
   },
 
   async signAndSendTransaction(transaction: any, options: any) {
-    const result = await requestHot("solana:signAndSendTransaction", {
+    const result = await HOT.request("solana:signAndSendTransaction", {
       transaction: transaction.serialize().toString("base64"),
       options,
     });
@@ -61,11 +61,10 @@ const hotSolana = {
 
   async signIn(input: any) {
     throw "Not supported";
-    return await requestHot("solana:signIn", input);
   },
 
   async signMessage(message: string) {
-    const result = await requestHot("solana:signMessage", { message: Buffer.from(message).toString("base64") });
+    const result = await HOT.request("solana:signMessage", { message: Buffer.from(message).toString("base64") });
     return { signature: Buffer.from(result.signature, "base64") };
   },
 
@@ -84,15 +83,13 @@ HOT.subscribe("solana:accountChanged", (publicKey: string | null) => {
 });
 */
 
-if (isInjected()) {
-  registerWallet(new GhostWallet(hotSolana));
+registerWallet(new GhostWallet(hotSolana));
 
-  // New wallets no longer need to register wallet globals - and can
-  // ignore the code below. However if you have legacy apps relying on globals,
-  // this is the safest way to attach the reference to the window, guarding against errors.
-  try {
-    Object.defineProperty(window, "hotSolana", { value: hotSolana });
-  } catch (error) {
-    //
-  }
+// New wallets no longer need to register wallet globals - and can
+// ignore the code below. However if you have legacy apps relying on globals,
+// this is the safest way to attach the reference to the window, guarding against errors.
+try {
+  Object.defineProperty(window, "hotSolana", { value: hotSolana });
+} catch (error) {
+  //
 }

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

@@ -23,13 +23,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,11 +64,6 @@ 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) {
     const destination = new PublicKey(receiver);
     const owner = new PublicKey(this.address);

package/src/stellar/connector.ts

@@ -1,68 +1,76 @@
-import { sep43Modules, HotWalletModule, StellarWalletsKit, WalletNetwork, ISupportedWallet } from "@creit.tech/stellar-wallets-kit";
 import { Transaction } from "@stellar/stellar-base";
 
+import HOT from "../hot-wallet/iframe";
 import { WalletType } from "../core/chains";
 import { HotConnector } from "../HotConnector";
 import { ConnectorType, OmniConnector } from "../OmniConnector";
-import { isInjected } from "../hot-wallet/iframe";
-import { OmniWallet } from "../OmniWallet";
-import StellarWallet from "./wallet";
 
-class StellarConnector extends OmniConnector<StellarWallet, ISupportedWallet> {
-  stellarKit: StellarWalletsKit;
+import { FreighterModule } from "./freigher";
+import { HotWalletModule } from "./hotWallet";
+import StellarWallet from "./wallet";
 
+class StellarConnector extends OmniConnector<StellarWallet> {
   icon = "https://storage.herewallet.app/upload/1469894e53ca248ac6adceb2194e6950a13a52d972beb378a20bce7815ba01a4.png";
   walletTypes = [WalletType.STELLAR, WalletType.OMNI];
   type = ConnectorType.WALLET;
   name = "Stellar Wallet";
   id = "stellar";
 
-  constructor(wibe3: HotConnector, stellarKit?: StellarWalletsKit) {
-    super(wibe3);
+  modules = {
+    hotWallet: new HotWalletModule(),
+    freighter: new FreighterModule(),
+  };
 
-    this.stellarKit = stellarKit || new StellarWalletsKit({ network: WalletNetwork.PUBLIC, modules: isInjected() ? [new HotWalletModule()] : sep43Modules() });
-    this.stellarKit.getSupportedWallets().then((wallets) => {
-      const hot = wallets.find((w) => w.id === "hot-wallet");
-      this.options = wallets.filter((w) => w.id !== "hot-wallet").map((w) => ({ ...w, name: w.name, icon: w.icon, download: w.url, type: "external" as const, id: w.id }));
-      if (hot) this.options.unshift({ ...hot, name: hot.name, icon: hot.icon, download: hot.url, type: "external" as const, id: hot.id });
-    });
+  constructor(wibe3: HotConnector) {
+    super(wibe3);
 
-    this.getConnectedWallet().then((data) => {
-      if (!data || !this.stellarKit) throw "No wallet";
+    this.options = Object.values(this.modules).map((module) => ({
+      type: "external" as const,
+      name: module.productName,
+      icon: module.productIcon,
+      download: module.productUrl,
+      id: module.productId,
+    }));
 
-      this.stellarKit.setWallet(data.id!);
-      const signMessage = async (message: string) => this.stellarKit.signMessage(message);
-      const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
-      this.setWallet(new StellarWallet(this, { address: data.address!, signMessage, signTransaction }));
+    this.getConnectedWallet().then(async ({ id, address }) => {
+      if (!id || !address) return;
+      const wallet = this.getWallet(id);
+      const isAvailable = await wallet?.isAvailable();
+      if (isAvailable && wallet) this.selectWallet(address, wallet);
     });
   }
 
-  async createWallet(address: string): Promise<OmniWallet> {
-    return new StellarWallet(this, { address });
+  getWallet(id: string): FreighterModule | HotWalletModule | null {
+    return Object.values(this.modules).find((module) => module.productId === id) || null;
   }
 
   async getConnectedWallet() {
-    if (isInjected()) {
-      this.stellarKit.setWallet("hot-wallet");
-      const { address } = await this.stellarKit.getAddress();
-      return { type: "wallet", id: "hot-wallet", address };
+    if (HOT.isInjected) {
+      const { address } = await this.modules.hotWallet.getAddress();
+      return { type: "wallet", id: this.modules.hotWallet.productId, address };
     }
 
     return await this.getStorage();
   }
 
+  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({ address, rpc: this.wibe3.hotBridge.stellar, signMessage, signTransaction }));
+  }
+
   async connect(id: string) {
-    this.stellarKit.setWallet(id);
-    const { address } = await this.stellarKit.getAddress();
-    const signMessage = async (message: string) => this.stellarKit.signMessage(message);
-    const signTransaction = async (transaction: Transaction) => this.stellarKit.signTransaction(transaction.toXDR());
+    const wallet = this.getWallet(id);
+    if (!wallet) throw new Error("Wallet not found");
+
+    const { address } = await wallet.getAddress();
     this.setStorage({ type: "wallet", id, address });
-    return this.setWallet(new StellarWallet(this, { address, signMessage, signTransaction }));
+    return this.selectWallet(address, wallet);
   }
 
   async disconnect() {
     super.disconnect();
-    this.stellarKit.disconnect();
+    this.removeStorage();
   }
 }
 

package/src/stellar/freigher.ts

@@ -0,0 +1,119 @@
+import { isConnected, requestAccess, getAddress, signTransaction, signAuthEntry, signMessage, getNetwork } from "@stellar/freighter-api";
+
+declare global {
+  interface Window {
+    stellar?: {
+      provider: string;
+      platform: string;
+    };
+  }
+}
+
+function parseError(e: any) {
+  return {
+    code: e?.error?.code || e?.code || -1,
+    message: e?.error?.message || e?.message || (typeof e === "string" && e) || "Unhandled error from the wallet",
+    ext: e?.error?.ext || e?.ext,
+  };
+}
+
+const FREIGHTER_ID = "freighter";
+export class FreighterModule {
+  productId = FREIGHTER_ID;
+  productName = "Freighter";
+  productUrl = "https://freighter.app";
+  productIcon = "https://stellar.creit.tech/wallet-icons/freighter.png";
+
+  async runChecks() {
+    if (!(await this.isAvailable())) {
+      throw new Error("Freighter is not connected");
+    }
+  }
+
+  async isAvailable() {
+    if (window.stellar?.provider === "freighter" && window.stellar?.platform === "mobile") return false;
+    return isConnected()
+      .then(({ isConnected: isConnected2, error }) => !error && isConnected2)
+      .catch(() => false);
+  }
+
+  async getAddress(params?: { skipRequestAccess?: boolean }): Promise<{ address: string }> {
+    return this.runChecks()
+      .then(async () => {
+        if (params?.skipRequestAccess) return true;
+        return requestAccess();
+      })
+      .then(() => getAddress())
+      .then(({ address, error }) => {
+        if (error) throw error;
+        if (!address)
+          throw {
+            code: -3,
+            message: "Getting the address is not allowed, please request access first.",
+          };
+        return { address };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+  async signTransaction(xdr: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedTxXdr: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedTxXdr, signerAddress, error } = await signTransaction(xdr, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error) throw error;
+        return { signedTxXdr, signerAddress };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async signAuthEntry(authEntry: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedAuthEntry: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedAuthEntry, signerAddress, error } = await signAuthEntry(authEntry, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error || !signedAuthEntry) throw error;
+        return { signedAuthEntry: Buffer.from(signedAuthEntry).toString("base64"), signerAddress };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async signMessage(message: string, opts?: { address?: string; networkPassphrase?: string }): Promise<{ signedMessage: string; signerAddress?: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { signedMessage, signerAddress, error } = await signMessage(message, {
+          address: opts?.address,
+          networkPassphrase: opts?.networkPassphrase,
+        });
+        if (error || !signedMessage) throw error;
+        return {
+          signedMessage: typeof signedMessage === "string" ? signedMessage : Buffer.from(signedMessage).toString("base64"),
+          signerAddress,
+        };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+
+  async getNetwork(): Promise<{ network: string; networkPassphrase: string }> {
+    return this.runChecks()
+      .then(async () => {
+        const { network, networkPassphrase, error } = await getNetwork();
+        if (error) throw error;
+        return { network, networkPassphrase };
+      })
+      .catch((e) => {
+        throw parseError(e);
+      });
+  }
+}

package/src/stellar/{injected.ts → hotWallet.ts}

@@ -1,13 +1,9 @@
-import { type ModuleInterface, ModuleType, WalletNetwork } from "@creit.tech/stellar-wallets-kit";
-import { requestHot } from "../hot-wallet/iframe";
+import { Networks } from "@stellar/stellar-sdk";
+import HOT from "../hot-wallet/iframe";
 
 export const HOTWALLET_ID: string = "hot-wallet";
 
-/**
- * **IMPORTANT**: This module requires that you have a "global" and a "Buffer" polyfill in your app, if not provided then this module will break your app.
- */
-export class HotWalletModule implements ModuleInterface {
-  moduleType: ModuleType = ModuleType.HOT_WALLET;
+export class HotWalletModule {
   productId: string = HOTWALLET_ID;
   productName: string = "HOT Wallet";
   productUrl: string = "https://hot-labs.org/wallet";
@@ -18,22 +14,22 @@ export class HotWalletModule implements ModuleInterface {
   }
 
   async getAddress(): Promise<{ address: string }> {
-    return await requestHot("stellar:getAddress", {});
+    return await HOT.request("stellar:getAddress", {});
   }
 
   async signTransaction(xdr: string, opts?: { address?: string }): Promise<{ signedTxXdr: string; signerAddress?: string }> {
-    return await requestHot("stellar:signTransaction", { xdr, accountToSign: opts?.address });
+    return await HOT.request("stellar:signTransaction", { xdr, accountToSign: opts?.address });
   }
 
   async signAuthEntry(authEntry: string, opts?: { address?: string }): Promise<{ signedAuthEntry: string; signerAddress?: string }> {
-    return await requestHot("stellar:signAuthEntry", { authEntry, accountToSign: opts?.address });
+    return await HOT.request("stellar:signAuthEntry", { authEntry, accountToSign: opts?.address });
   }
 
   async signMessage(message: string, opts?: { address?: string }): Promise<{ signedMessage: string; signerAddress?: string }> {
-    return await requestHot("stellar:signMessage", { message, accountToSign: opts?.address });
+    return await HOT.request("stellar:signMessage", { message, accountToSign: opts?.address });
   }
 
   async getNetwork(): Promise<{ network: string; networkPassphrase: string }> {
-    return { network: "mainnet", networkPassphrase: WalletNetwork.PUBLIC };
+    return { network: "mainnet", networkPassphrase: Networks.PUBLIC };
   }
 }

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;
   }