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

package/src/core/types.ts

@@ -40,9 +40,30 @@ export interface AuthCallIntent {
   intent: "auth_call";
 }
 
+export interface AddPublicKeyIntent {
+  intent: "add_public_key";
+  public_key: string;
+}
+
+export interface RemovePublicKeyIntent {
+  intent: "remove_public_key";
+  public_key: string;
+}
+
+export interface NftWithdrawIntent {
+  intent: "nft_withdraw";
+  token_id: string;
+  receiver_id: string;
+  memo?: string;
+  msg?: string;
+  min_gas?: string;
+}
+
 export interface Commitment {
   signature: string;
   public_key?: string;
   payload: Record<string, any> | string;
   standard: string;
 }
+
+export type Intent = TransferIntent | MtWithdrawIntent | FtWithdrawIntent | TokenDiffIntent | AuthCallIntent | AddPublicKeyIntent | RemovePublicKeyIntent | NftWithdrawIntent;

package/src/core/utils.ts

@@ -160,4 +160,15 @@ export const formatter = {
   wait(ms: number) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   },
+
+  chunk(array: any[], size: number) {
+    return array.reduce((acc, item, index) => {
+      const chunkIndex = Math.floor(index / size);
+      if (!acc[chunkIndex]) {
+        acc[chunkIndex] = [];
+      }
+      acc[chunkIndex].push(item);
+      return acc;
+    }, []);
+  },
 };

package/src/cosmos/connector.ts

@@ -125,7 +125,7 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
     const address = account.bech32Address;
 
     this.setStorage({ type: "walletconnect", id });
-    const wallet = new CosmosWallet(this, {
+    const wallet = new CosmosWallet({
       address: address,
       publicKeyHex: publicKey,
       disconnect: () => this.disconnectWalletConnect(),
@@ -170,7 +170,7 @@ export default class CosmosConnector extends OmniConnector<CosmosWallet> {
 
   async setKeplrWallet(keplr: Keplr, address: string, publicKey: string) {
     return this.setWallet(
-      new CosmosWallet(this, {
+      new CosmosWallet({
         address: address,
         publicKeyHex: publicKey,
         disconnect: () => keplr.disable(),

package/src/cosmos/wallet.ts

@@ -13,10 +13,11 @@ interface ProtocolWallet {
 }
 
 export default class CosmosWallet extends OmniWallet {
+  readonly icon = "https://legacy.cosmos.network/presskit/cosmos-brandmark-dynamic-dark.svg";
   readonly type = WalletType.COSMOS;
 
-  constructor(readonly connector: CosmosConnector, readonly wallet: ProtocolWallet) {
-    super(connector);
+  constructor(readonly wallet: ProtocolWallet) {
+    super();
   }
 
   get address() {
@@ -31,11 +32,6 @@ export default class CosmosWallet extends OmniWallet {
     return "";
   }
 
-  async disconnect() {
-    super.disconnect();
-    this.wallet.disconnect?.();
-  }
-
   sendTransaction(signDoc: any): Promise<string> {
     if (!this.wallet.sendTransaction) throw "Not impl";
     return this.wallet.sendTransaction(signDoc);

package/src/evm/connector.ts

@@ -1,10 +1,10 @@
-import MetaMaskSDK from "@metamask/sdk";
 import { runInAction } from "mobx";
 
-import { ConnectorType, OmniConnector, WC_ICON } from "../OmniConnector";
+import HOT from "../hot-wallet/iframe";
 import { Network, WalletType } from "../core/chains";
-import { isInjected } from "../hot-wallet/iframe";
+import { ConnectorType, OmniConnector, WC_ICON } from "../OmniConnector";
 import { HotConnector } from "../HotConnector";
+
 import EvmWallet, { EvmProvider } from "./wallet";
 
 class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
@@ -14,14 +14,6 @@ class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
   name = "EVM Wallet";
   id = "evm";
 
-  MMSDK = new MetaMaskSDK({
-    dappMetadata: {
-      name: "Wibe3",
-      url: window.location.href,
-      // iconUrl: "https://mydapp.com/icon.png" // Optional
-    },
-  });
-
   constructor(wibe3: HotConnector) {
     super(wibe3);
 
@@ -104,7 +96,7 @@ class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
   }
 
   async getConnectedWallet() {
-    if (isInjected()) return { type: "wallet", id: "org.hot-labs" };
+    if (HOT.isInjected) return { type: "wallet", id: "org.hot-labs" };
     return await this.getStorage();
   }
 
@@ -129,6 +121,11 @@ class EvmConnector extends OmniConnector<EvmWallet, { provider: EvmProvider }> {
 
     return await this.connectWallet(id, wallet.provider);
   }
+
+  async disconnect() {
+    this.wallets.forEach((w) => w.disconnect());
+    super.disconnect();
+  }
 }
 
 export default EvmConnector;

package/src/evm/injected.ts

@@ -1,4 +1,4 @@
-import { isInjected, requestHot } from "../hot-wallet/iframe";
+import HOT from "../hot-wallet/iframe";
 
 class HotEvmProvider {
   _events = new Map<string, Set<any>>();
@@ -6,7 +6,7 @@ class HotEvmProvider {
   isHotWallet = true;
   isMetaMask = true;
 
-  request = (request: any) => requestHot("ethereum", request);
+  request = (request: any) => HOT.request("ethereum", request);
   removeListener() {}
   on() {}
 }
@@ -31,7 +31,7 @@ function announceProvider(provider: HotEvmProvider) {
   );
 }
 
-if (isInjected()) {
+if (HOT.isInjected) {
   const hotProvider = new HotEvmProvider();
   window.addEventListener("eip6963:requestProvider", () => announceProvider(hotProvider));
   announceProvider(hotProvider);

package/src/evm/wallet.ts

@@ -22,7 +22,15 @@ class EvmWallet extends OmniWallet {
   readonly type = WalletType.EVM;
 
   constructor(readonly connector: OmniConnector, readonly address: string, readonly provider: EvmProvider) {
-    super(connector);
+    super();
+  }
+
+  async disconnect() {
+    await this.provider.request?.({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
+  }
+
+  get icon() {
+    return this.connector.icon;
   }
 
   private rpcs: Record<number, JsonRpcProvider> = {};
@@ -42,11 +50,6 @@ class EvmWallet extends OmniWallet {
     return this.address.toLowerCase();
   }
 
-  async disconnect() {
-    this.provider.request?.({ method: "wallet_revokePermissions", params: [{ eth_accounts: {} }] });
-    await super.disconnect();
-  }
-
   async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
     const native = await this.fetchBalance(chain, "native");
     try {

package/src/exchange.ts

@@ -300,7 +300,7 @@ export class Exchange {
     };
   }
 
-  async makeSwap(review: BridgeReview, pending: { log: (message: string) => void }) {
+  async makeSwap(review: BridgeReview, pending: { log: (message: string) => void }): Promise<{ review: BridgeReview; processing?: () => Promise<BridgeReview> }> {
     const { sender, recipient } = review;
 
     if (review.qoute === "withdraw") {
@@ -309,7 +309,7 @@ export class Exchange {
       const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
       if (recipientWallet) this.wibe3.fetchToken(review.to, recipientWallet);
       this.wibe3.fetchToken(review.from, sender);
-      return review;
+      return { review };
     }
 
     if (review.qoute === "deposit") {
@@ -319,7 +319,7 @@ export class Exchange {
 
       const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
       if (recipientWallet) this.wibe3.fetchToken(review.to, recipientWallet);
-      return review;
+      return { review };
     }
 
     if (sender !== "qr") {
@@ -335,7 +335,8 @@ export class Exchange {
       const depositAddress = review.qoute.depositAddress!;
       let hash = "";
       if (review.from.chain === Network.Hot) {
-        hash = await sender.intents
+        hash = await this.wibe3
+          .intentsBuilder(sender)
           .transfer({
             amount: review.amountIn,
             token: review.from.address as OmniToken,
@@ -347,31 +348,30 @@ export class Exchange {
           receiver: depositAddress,
           amount: review.amountIn,
           comment: review.qoute.depositMemo,
-          token: review.from,
           gasFee: review.fee ?? undefined,
+          token: review.from,
         });
       }
 
-      pending.log("Submitting tx");
       this.wibe3.fetchToken(review.from, sender);
-      await OneClickService.submitDepositTx({ txHash: hash, depositAddress }).catch(() => {});
-    }
-
-    if (sender !== "qr") {
-      wait(1000).then(() => this.wibe3.fetchToken(review.to, sender));
+      OneClickService.submitDepositTx({ txHash: hash, depositAddress }).catch(() => {});
     }
 
-    pending.log("Processing...");
-    const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
-    if (!recipientWallet) return await this.processing(review);
+    return {
+      review,
+      processing: async () => {
+        const recipientWallet = this.wibe3.wallets.find((w) => w.address === recipient.address);
+        if (!recipientWallet) return await this.processing(review);
 
-    const beforeBalance = await this.wibe3.fetchToken(review.to, recipientWallet).catch(() => null);
-    if (!beforeBalance) return await this.processing(review);
+        const beforeBalance = await this.wibe3.fetchToken(review.to, recipientWallet).catch(() => null);
+        if (!beforeBalance) return await this.processing(review);
 
-    return await Promise.race([
-      this.waitBalance(review.to, recipientWallet, beforeBalance, review),
-      this.processing(review), //
-    ]);
+        return await Promise.race([
+          this.waitBalance(review.to, recipientWallet, beforeBalance, review),
+          this.processing(review), //
+        ]);
+      },
+    };
   }
 
   async waitBalance(to: Token, wallet: OmniWallet, beforeBalance: bigint, review: BridgeReview): Promise<BridgeReview> {

package/src/hot-wallet/google.ts

@@ -50,12 +50,19 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
     if (account.type === WalletType.STELLAR) {
       const signMessage = async (message: string) => request("stellar:signMessage", { message });
       const signTransaction = async (transaction: Transaction) => request("stellar:signTransaction", { transaction: transaction.toXDR() });
-      this.wallets.push(new StellarWallet(this, { address: account.address, signMessage, signTransaction }));
+      this.wallets.push(
+        new StellarWallet({
+          rpc: this.wibe3.hotBridge.stellar,
+          address: account.address,
+          signMessage,
+          signTransaction,
+        })
+      );
     }
 
     if (account.type === WalletType.TON) {
       this.setWallet(
-        new TonWallet(this, {
+        new TonWallet({
           sendTransaction: (params) => request("ton:sendTransaction", params),
           signData: (params) => request("ton:signData", params),
           account: { address: account.address, publicKey: account.publicKey },
@@ -65,21 +72,21 @@ class GoogleConnector extends OmniConnector<OmniWallet> {
 
     if (account.type === WalletType.NEAR) {
       this.setWallet(
-        new NearWallet(this, account.address, account.publicKey, {
+        new NearWallet(account.address, account.publicKey, {
           signAndSendTransaction: (params: SignAndSendTransactionParams) => request("near:signAndSendTransaction", params),
           signAndSendTransactions: (params: SignAndSendTransactionsParams) => request("near:signAndSendTransactions", params),
           signMessage: (params: SignMessageParams) => request("near:signMessage", params),
           getAccounts: async () => [{ accountId: account.address, publicKey: account.publicKey }],
           signIn: () => request("near:signIn", {}),
-          signOut: async () => {},
           manifest: {} as unknown as WalletManifest,
+          signOut: async () => {},
         }) as NearWallet
       );
     }
 
     if (account.type === WalletType.SOLANA) {
       this.setWallet(
-        new SolanaWallet(this, {
+        new SolanaWallet({
           sendTransaction: async (transaction: unknown, _: unknown, options?: unknown) => await request("solana:sendTransaction", { transaction, options }),
           signMessage: async (message: string) => await request("solana:signMessage", { message }),
           disconnect: async () => {},

package/src/hot-wallet/iframe.ts

@@ -1,32 +1,159 @@
-const ancestorOrigins = new Set(["http://localhost:1234", "https://my.herewallet.app", "https://tgapp-dev.herewallet.app", "https://tgapp.herewallet.app", "https://beta.herewallet.app", "https://app.hot-labs.org"]);
+import uuid4 from "uuid4";
+import { createRequest, getResponse } from "./proxy";
+import { base58 } from "@scure/base";
 
-export const isInjected = () => {
-  if (typeof window === "undefined") return false;
-  if (window.self === window.top) return false;
-  return ancestorOrigins.has(window.location.ancestorOrigins?.[0]);
+declare global {
+  interface Window {
+    hotExtension?: {
+      autoRun: boolean;
+      request: (method: string, args: any) => any;
+      subscribe: (event: string, args: any) => () => void;
+      evm: any;
+    };
+  }
+}
+
+export const wait = (timeout: number) => {
+  return new Promise<void>((resolve) => setTimeout(resolve, timeout));
 };
 
-export const uuid4 = () => {
-  try {
-    return crypto.randomUUID();
-  } catch {
-    const temp_url = URL.createObjectURL(new Blob());
-    const uuid = temp_url.toString();
-    URL.revokeObjectURL(temp_url);
-    return uuid.split(/[:/]/g).pop()!.toLowerCase(); // remove prefixes
+export class RequestFailed extends Error {
+  name = "RequestFailed";
+  constructor(readonly payload: any) {
+    super();
   }
-};
+}
 
-export const requestHot = (method: string, request: any) => {
-  const id = uuid4();
-  return new Promise<any>((resolve, reject) => {
-    const handler = (e: any) => {
-      if (e.data.id !== id) return;
-      window?.removeEventListener("message", handler);
-      return e.data.success ? resolve(e.data.payload) : reject(e.data.payload);
-    };
+export const getExtension = () => {
+  if (typeof window === "undefined") return null;
+  return window.hotExtension;
+};
 
-    window?.parent.postMessage({ $hot: true, method, request, id }, "*");
-    window?.addEventListener("message", handler);
+let connector: HTMLDivElement | undefined;
+if (typeof window !== "undefined") {
+  window.addEventListener("message", (e: any) => {
+    if (e.data === "hot-close") {
+      connector?.remove();
+      connector = undefined;
+    }
   });
+}
+
+const createIframe = (widget: string) => {
+  connector?.remove();
+  connector = document.createElement("div");
+
+  const iframe = document.createElement("iframe");
+  connector?.appendChild(iframe);
+
+  iframe.src = widget;
+  iframe.allow = "usb";
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "16px";
+  iframe.style.background = "#fff";
+  iframe.style.overflow = "hidden";
+  iframe.style.background = "#1D1F20";
+  iframe.style.border = "1px solid #2C3034";
+  iframe.style.width = "375px";
+  iframe.style.height = "560px";
+  iframe.onclick = (e) => e.stopPropagation();
+
+  connector.style.padding = "16px";
+  connector.style.zIndex = "100000000000000";
+  connector.style.position = "fixed";
+  connector.style.display = "flex";
+  connector.style.justifyContent = "center";
+  connector.style.alignItems = "center";
+  connector.style.top = "0";
+  connector.style.left = "0";
+  connector.style.width = "100%";
+  connector.style.height = "100%";
+  connector.style.background = "rgba(0, 0, 0, 0.1)";
+  connector.style.backdropFilter = "blur(24px)";
+  connector.onclick = () => {
+    connector?.remove();
+    connector = undefined;
+  };
+
+  document.body.appendChild(connector);
+  return connector;
 };
+
+class HOT {
+  walletId = "https://t.me/herewalletbot/app";
+  ancestorOrigins = ["http://localhost:1234", "https://my.herewallet.app", "https://tgapp-dev.herewallet.app", "https://tgapp.herewallet.app", "https://beta.herewallet.app"];
+
+  get isInjected() {
+    if (typeof window === "undefined") return false;
+    if (window.hotExtension != null) return window.hotExtension.autoRun;
+    return this.ancestorOrigins.includes(window.location.ancestorOrigins?.[0]);
+  }
+
+  openInHotBrowserUrl: string | null = null;
+  toggleOpenInHotBrowser(url: string | null) {
+    this.openInHotBrowserUrl = url;
+  }
+
+  customProvider?: (data: any, chain: number, address?: string | null) => Promise<any>;
+  setupEthProvider(provider?: (data: any, chain: number, address?: string | null) => Promise<any>) {
+    this.customProvider = provider;
+  }
+
+  async injectedRequest(method: string, request: any): Promise<any> {
+    const id = uuid4();
+    return new Promise((resolve, reject) => {
+      const handler = (e: any) => {
+        if (e.data.id !== id) return;
+        window?.removeEventListener("message", handler);
+        if (e.data.success) return resolve(e.data.payload);
+        else return reject(e.data.payload);
+      };
+
+      window?.parent.postMessage({ $hot: true, method, request, id }, "*");
+      window?.addEventListener("message", handler);
+    });
+  }
+
+  subscribe(event: string, cb: (e: any) => void) {
+    if (!window.hotExtension) return () => {};
+    return window.hotExtension.subscribe(event, cb);
+  }
+
+  async request(method: string, request: any): Promise<any> {
+    if (window.hotExtension != null) return window.hotExtension.request(method, request);
+    if (this.isInjected) return this.injectedRequest(method, request);
+
+    const id = uuid4();
+    const WebApp: any = (window as any)?.Telegram?.WebApp;
+
+    const requestId = await createRequest({
+      inside: !!this.openInHotBrowserUrl || (method === "ethereum" && this.customProvider == null),
+      origin: typeof this.openInHotBrowserUrl === "string" ? this.openInHotBrowserUrl : location.href,
+      $hot: true,
+      method,
+      request,
+      id,
+    });
+
+    const link = `${this.walletId}?startapp=hotconnect-${base58.encode(Buffer.from(requestId, "utf8"))}`;
+    if (WebApp) WebApp?.openTelegramLink(link);
+    else {
+      const origin = `https://hot-labs.org/hot-widget/index.html`;
+      createIframe(`${origin}?hotconnect-${base58.encode(Buffer.from(requestId, "utf8"))}`);
+    }
+
+    const poolResponse = async () => {
+      await wait(3000);
+      const data: any = await getResponse(requestId).catch(() => null);
+      if (data == null) return await poolResponse();
+      if (data.success) return data.payload;
+      throw new RequestFailed(data.payload);
+    };
+
+    const result = await poolResponse();
+    connector?.remove();
+    return result;
+  }
+}
+
+export default new HOT();

package/src/hot-wallet/proxy.ts

@@ -0,0 +1,54 @@
+import uuid4 from "uuid4";
+import { sha1 } from "@noble/hashes/legacy.js";
+import { base58 } from "@scure/base";
+
+export const proxyApi = "https://h4n.app";
+
+export const getResponse = async (id: string): Promise<object> => {
+  const res = await fetch(`${proxyApi}/${id}/response`, {
+    headers: { "content-type": "application/json" },
+    method: "GET",
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+
+  const { data } = await res.json();
+  return JSON.parse(data);
+};
+
+export const deleteRequest = async (id: string) => {
+  const res = await fetch(`${proxyApi}/${id}`, {
+    headers: { "content-type": "application/json" },
+    method: "DELETE",
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+};
+
+export const computeRequestId = async (request: object) => {
+  const query = base58.encode(Buffer.from(JSON.stringify({ ...request, _id: uuid4() }), "utf8"));
+  const hashsum = sha1(Buffer.from(query, "utf8"));
+  const id = Buffer.from(hashsum).toString("base64");
+  const requestId = id.replaceAll("/", "_").replaceAll("-", "+").slice(0, 13);
+  return { requestId, query };
+};
+
+export const createRequest = async (request: object, signal?: AbortSignal) => {
+  const { query, requestId } = await computeRequestId(request);
+  const res = await fetch(`${proxyApi}/${requestId}/request`, {
+    body: JSON.stringify({ data: query }),
+    headers: { "content-type": "application/json" },
+    method: "POST",
+    signal,
+  });
+
+  if (res.ok === false) {
+    throw Error(await res.text());
+  }
+
+  return requestId;
+};

package/src/index.ts

@@ -1,3 +1,5 @@
+import "@lottiefiles/dotlottie-wc";
+
 export { OmniWallet } from "./OmniWallet";
 export { OmniConnector } from "./OmniConnector";
 export { HotConnector } from "./HotConnector";

package/src/near/connector.ts

@@ -28,7 +28,7 @@ class Connector extends OmniConnector<NearWallet> {
     this.connector.on("wallet:signOut", () => this.removeWallet());
     this.connector.getConnectedWallet().then(async ({ wallet }) => {
       const [account] = await wallet.getAccounts();
-      if (account) this.setWallet(new NearWallet(this, account.accountId, account.publicKey, wallet));
+      if (account) this.setWallet(new NearWallet(account.accountId, account.publicKey, wallet));
     });
 
     this.connector.whenManifestLoaded.then(() => {
@@ -49,7 +49,7 @@ class Connector extends OmniConnector<NearWallet> {
     if (!wallet) throw new Error("Wallet not found");
     const [account] = await wallet.getAccounts();
     if (!account) throw new Error("No account found");
-    return this.setWallet(new NearWallet(this, account.accountId, account.publicKey, wallet));
+    return this.setWallet(new NearWallet(account.accountId, account.publicKey, wallet));
   }
 
   async disconnect() {

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

@@ -1,6 +1,8 @@
 import { JsonRpcProvider } from "@near-js/providers";
 import { getErrorTypeFromErrorMessage, parseRpcError } from "@near-js/utils";
 import { TypedError, FinalExecutionOutcome } from "@near-js/types";
+import { api } from "../core/api";
+import { Network } from "../core";
 
 let _nextId = 123;
 
@@ -22,22 +24,13 @@ 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: "" });
+  constructor(providers = [api.getRpcUrl(Network.Near)], private timeout = 30_000, private triesCountForEveryProvider = 3, private incrementTimout = true) {
+    super({ url: api.getRpcUrl(Network.Near) });
     this.currentProviderIndex = 0;
     this.providers = providers;
     this.startTimeout = timeout;

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) => {