@hot-labs/kit 1.0.33

package/src/GoogleConnector.ts

@@ -0,0 +1,102 @@
+import { WalletManifest, SignAndSendTransactionParams, SignAndSendTransactionsParams, SignMessageParams } from "@hot-labs/near-connect";
+import { Transaction } from "@stellar/stellar-base";
+import { action, makeObservable } from "mobx";
+
+import { requestWebWallet } from "./hot-wallet/wallet";
+import { ConnectorType, OmniConnector } from "./OmniConnector";
+import { OmniWallet } from "./OmniWallet";
+import { WalletType } from "./omni/config";
+
+import EvmWallet from "./evm/wallet";
+import NearWallet from "./near/wallet";
+import SolanaWallet from "./solana/wallet";
+import TonWallet from "./ton/wallet";
+import StellarWallet from "./stellar/wallet";
+import { HotConnector } from "./HotConnector";
+
+class GoogleConnector extends OmniConnector<OmniWallet> {
+  walletTypes = [WalletType.EVM, WalletType.STELLAR, WalletType.TON, WalletType.NEAR, WalletType.SOLANA];
+  icon = "https://storage.herewallet.app/upload/0eb073753bd1ddabc3ceb5611ad80dd0cb5ca5a9c6ed066bf89ec4f1364c809d.svg";
+  type = ConnectorType.SOCIAL;
+  name = "Google Wallet";
+  id = "google";
+
+  constructor(wibe3: HotConnector) {
+    super(wibe3);
+
+    makeObservable(this, {
+      connectWallet: action,
+    });
+
+    this.getStorage().then((accounts: any) => {
+      accounts.forEach((account: any) => this.connectWallet(account));
+    });
+  }
+
+  connectWallet(account: { type: number; address: string; publicKey: string }) {
+    const request = requestWebWallet(account.type, account.address);
+
+    if (account.type === WalletType.EVM) {
+      this.setWallet(
+        new EvmWallet(this, account.address, {
+          request: (args: any) => request("evm:request", args),
+        })
+      );
+    }
+
+    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 }));
+    }
+
+    if (account.type === WalletType.TON) {
+      this.setWallet(
+        new TonWallet(this, {
+          sendTransaction: (params) => request("ton:sendTransaction", params),
+          signData: (params) => request("ton:signData", params),
+          account: { address: account.address, publicKey: account.publicKey },
+        })
+      );
+    }
+
+    if (account.type === WalletType.NEAR) {
+      this.setWallet(
+        new NearWallet(this, 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,
+        }) as NearWallet
+      );
+    }
+
+    if (account.type === WalletType.SOLANA) {
+      this.setWallet(
+        new SolanaWallet(this, {
+          sendTransaction: async (transaction: unknown, _: unknown, options?: unknown) => await request("solana:sendTransaction", { transaction, options }),
+          signMessage: async (message: string) => await request("solana:signMessage", { message }),
+          disconnect: async () => {},
+          address: account.address,
+        })
+      );
+    }
+  }
+
+  async connect() {
+    const accounts = await requestWebWallet()("connect:google", {});
+    accounts.forEach((account: { type: number; address: string; publicKey: string }) => this.connectWallet(account));
+    this.setStorage(accounts);
+    return this.wallets[0];
+  }
+
+  async silentDisconnect() {
+    this.removeAllWallets();
+    this.removeStorage();
+  }
+}
+
+export default GoogleConnector;

package/src/HotConnector.ts

@@ -0,0 +1,344 @@
+import { computed, makeObservable, observable, runInAction } from "mobx";
+
+import { openBridge, openConnector, openPayment, openProfile, openWalletPicker } from "./ui/router";
+import { ConnectorType, OmniConnector, OmniConnectorOptions } from "./OmniConnector";
+import { chainsMap, Network, WalletType } from "./omni/config";
+import { OmniWallet, SignedAuth } from "./OmniWallet";
+
+import NearConnector, { NearConnectorOptions } from "./near/connector";
+import EvmConnector, { EvmConnectorOptions } from "./evm/connector";
+import CosmosConnector, { CosmosConnectorOptions } from "./cosmos/connector";
+import TonConnector, { TonConnectorOptions } from "./ton/connector";
+import SolanaConnector from "./solana/connector";
+import StellarConnector from "./stellar/connector";
+import GoogleConnector from "./GoogleConnector";
+
+import { Exchange } from "./exchange";
+import { OmniToken } from "./omni/config";
+import { formatter } from "./omni/utils";
+import { Token } from "./omni/token";
+import { GlobalSettings } from "./settings";
+import { EventEmitter } from "./events";
+
+import NearWallet from "./near/wallet";
+import EvmWallet from "./evm/wallet";
+import SolanaWallet from "./solana/wallet";
+import StellarWallet from "./stellar/wallet";
+import TonWallet from "./ton/wallet";
+import CosmosWallet from "./cosmos/wallet";
+import { Intents } from "./omni/Intents";
+import { Recipient } from "./omni/recipient";
+import { openAuthPopup } from "./ui/connect/AuthPopup";
+import { tokens } from "./omni/tokens";
+
+export const near = (options?: NearConnectorOptions) => (wibe3: HotConnector) => new NearConnector(wibe3, options);
+export const evm = (options?: EvmConnectorOptions) => (wibe3: HotConnector) => new EvmConnector(wibe3, options);
+export const solana = (options?: OmniConnectorOptions) => (wibe3: HotConnector) => new SolanaConnector(wibe3, options);
+export const cosmos = (options?: CosmosConnectorOptions) => (wibe3: HotConnector) => new CosmosConnector(wibe3, options);
+export const ton = (options?: TonConnectorOptions) => (wibe3: HotConnector) => new TonConnector(wibe3, options);
+export const stellar = () => (wibe3: HotConnector) => new StellarConnector(wibe3);
+export const google = () => (wibe3: HotConnector) => new GoogleConnector(wibe3);
+
+interface HotConnectorOptions extends EvmConnectorOptions, OmniConnectorOptions, TonConnectorOptions, NearConnectorOptions, CosmosConnectorOptions {
+  connectors?: OmniConnector[];
+  webWallet?: string;
+  tonApi?: string;
+}
+
+export class HotConnector {
+  public connectors: OmniConnector[] = [];
+  public balances: Record<string, Record<string, bigint>> = {};
+  public exchange = new Exchange(this);
+
+  private events = new EventEmitter<{
+    connect: { wallet: OmniWallet };
+    disconnect: { wallet: OmniWallet };
+    tokensUpdate: { tokens: Token[] };
+  }>();
+
+  constructor(options?: HotConnectorOptions) {
+    makeObservable(this, {
+      balances: observable,
+      walletsTokens: computed,
+      wallets: computed,
+      tokens: computed,
+
+      near: computed,
+      evm: computed,
+      solana: computed,
+      stellar: computed,
+      ton: computed,
+      cosmos: computed,
+    });
+
+    if (typeof window !== "undefined") {
+      this.connectors = [near(), evm(options), solana(options), stellar(), ton(options), cosmos(options)].map((t) => t(this));
+    }
+
+    GlobalSettings.webWallet = options?.webWallet ?? GlobalSettings.webWallet;
+    GlobalSettings.tonApi = options?.tonApi ?? GlobalSettings.tonApi;
+
+    this.connectors.forEach((t) => {
+      t.onConnect((payload) => this.events.emit("connect", payload));
+      t.onDisconnect((payload) => this.events.emit("disconnect", payload));
+    });
+
+    this.onConnect((payload) => {
+      this.fetchTokens(payload.wallet);
+      this.fetchOmniTokens(payload.wallet);
+    });
+
+    this.onDisconnect(({ wallet }) => {
+      if (!wallet) return;
+      runInAction(() => (this.balances[`${wallet.type}:${wallet.address}`] = {}));
+    });
+  }
+
+  setOmniChainBranding(branding: { name: string; icon: string }) {
+    chainsMap[Network.Hot].name = branding.name;
+    chainsMap[Network.Hot].logo = branding.icon;
+  }
+
+  getWalletConnector(type: WalletType): OmniConnector | null {
+    return this.connectors.find((t) => t.type === ConnectorType.WALLET && t.walletTypes.includes(type)) ?? null;
+  }
+
+  omni(token: OmniToken) {
+    return tokens.get(token);
+  }
+
+  get tokens() {
+    return tokens.list;
+  }
+
+  get priorityWallet() {
+    if (this.near) return this.near;
+    if (this.evm) return this.evm;
+    if (this.solana) return this.solana;
+    if (this.ton) return this.ton;
+    if (this.stellar) return this.stellar;
+  }
+
+  get wallets(): OmniWallet[] {
+    return this.connectors.flatMap((t) => t.wallets);
+  }
+
+  get walletsTokens() {
+    return this.wallets
+      .flatMap((wallet) => {
+        return tokens.list.map((token) => ({ token, wallet, balance: this.balance(wallet, token) }));
+      })
+      .filter((t) => t.balance !== 0n)
+      .sort((a, b) => {
+        const balanceA = a.token.float(a.balance) * a.token.usd;
+        const balanceB = b.token.float(b.balance) * b.token.usd;
+        return balanceB - balanceA;
+      });
+  }
+
+  get near(): NearWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.NEAR) as NearWallet | null;
+  }
+
+  get evm(): EvmWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.EVM) as EvmWallet | null;
+  }
+
+  get solana(): SolanaWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.SOLANA) as SolanaWallet | null;
+  }
+
+  get stellar(): StellarWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.STELLAR) as StellarWallet | null;
+  }
+
+  get ton(): TonWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.TON) as TonWallet | null;
+  }
+
+  get cosmos(): CosmosWallet | null {
+    return this.wallets.find((w) => w.type === WalletType.COSMOS) as CosmosWallet | null;
+  }
+
+  getChainBalances(chain: number) {
+    return tokens.list
+      .filter((t) => t.chain === chain)
+      .reduce((acc: number, token: Token) => {
+        return this.wallets.reduce((acc: number, wallet) => {
+          if (token.chain === chain) return acc;
+          const balance = this.balances[`${wallet.type}:${wallet.address}`][token.id] ?? 0n;
+          return acc + token.float(balance) * token.usd;
+        }, acc);
+      }, 0);
+  }
+
+  balance(wallet?: OmniWallet, token?: Token) {
+    if (!wallet || !token) return 0n;
+    return this.balances[`${wallet.type}:${wallet.address}`]?.[token.id] ?? 0n;
+  }
+
+  omniBalance(token: OmniToken) {
+    const omni = tokens.get(token);
+    const omniToken = this.walletsTokens.find((t) => t.token.address === omni.address);
+    const onchainToken = this.walletsTokens.find((t) => t.token.address === omni.originalAddress);
+
+    const reseve = onchainToken ? onchainToken.token.int(onchainToken.token.reserve) : 0n;
+    const available = onchainToken ? formatter.bigIntMax(0n, onchainToken.balance - reseve) : 0n;
+
+    return {
+      token: omni,
+      onchain: available,
+      omni: omniToken?.balance ?? 0n,
+      total: +omni.float((omniToken?.balance ?? 0n) + available).toFixed(6),
+    };
+  }
+
+  async auth<T = SignedAuth>(wallet: OmniWallet, domain: string, intents?: Record<string, any>[], then?: (signed: SignedAuth) => Promise<T>): Promise<T> {
+    return openAuthPopup<T>(wallet, async () => {
+      const signed = await wallet.signIntentsWithAuth(domain, intents);
+      return (await then?.(signed)) ?? (signed as T);
+    });
+  }
+
+  async fetchToken(token: Token, wallet: OmniWallet) {
+    const key = `${wallet.type}:${wallet.address}`;
+
+    if (token.type === WalletType.OMNI) {
+      if (!wallet.omniAddress) return 0n;
+      const balances = await Intents.getIntentsBalances([token.address], wallet.omniAddress);
+      runInAction(() => (this.balances[key][token.id] = balances[token.address]));
+      return balances[token.address] ?? 0n;
+    }
+
+    if (token.type === wallet.type) {
+      const balance = await wallet.fetchBalance(token.chain, token.address);
+      runInAction(() => (this.balances[key][token.id] = balance));
+      return balance;
+    }
+
+    return 0n;
+  }
+
+  async fetchOmniTokens(wallet: OmniWallet) {
+    const key = `${wallet.type}:${wallet.address}`;
+    const assets = await wallet.getAssets();
+    runInAction(() => {
+      Object.keys(assets).forEach((id) => {
+        this.balances[key][`-4:${id}`] = assets[id];
+      });
+    });
+  }
+
+  async fetchTokens(wallet: OmniWallet) {
+    const key = `${wallet.type}:${wallet.address}`;
+    if (!this.balances[key]) runInAction(() => (this.balances[key] = {}));
+    const tokensList = (await tokens.getTokens()).filter((t) => t.type === wallet.type && t.type !== WalletType.OMNI);
+
+    // Group tokens by their chain
+    const groups: Record<number, string[]> = tokensList.reduce((acc, token) => {
+      if (!acc[token.chain]) acc[token.chain] = [];
+      acc[token.chain].push(token.address);
+      return acc;
+    }, {} as Record<number, string[]>);
+
+    Object.entries(groups).forEach(async ([chain, tokens]) => {
+      const balances = await wallet.fetchBalances(+chain, tokens);
+      runInAction(() => {
+        for (const [token, balance] of Object.entries(balances)) {
+          this.balances[key][`${chain}:${token}`] = balance;
+        }
+      });
+    });
+  }
+
+  async requestToken(token: OmniToken, amount: bigint | number): Promise<{ wallet: OmniWallet; token: Token; amount: bigint }> {
+    if (!token) throw new Error("Token not found");
+
+    const tokensList = await tokens.getTokens();
+    const ftToken = tokensList.find((t) => t.address === token)!;
+    const amountInt = typeof amount === "number" ? ftToken.int(amount) : amount;
+    const [existed] = this.walletsTokens.filter((t) => t.token.id === ftToken.id);
+
+    if (existed?.balance >= amountInt) return { token: ftToken, wallet: existed.wallet, amount: amountInt };
+
+    const needed = amountInt - (existed?.balance ?? 0n);
+    const result = await openPayment(this, ftToken, needed, Recipient.fromWallet(existed?.wallet));
+
+    const recipientWallet = this.wallets.find((w) => w.address === result.recipient.address);
+    if (!recipientWallet) throw new Error("Recipient not found");
+    const exist = await this.fetchToken(ftToken, recipientWallet);
+
+    return {
+      token: result.to,
+      wallet: recipientWallet,
+      amount: formatter.bigIntMin(exist, amountInt),
+    };
+  }
+
+  onConnect(handler: (payload: { wallet: OmniWallet }) => void) {
+    this.events.on("connect", handler);
+    return () => this.events.off("connect", handler);
+  }
+
+  onDisconnect(handler: (payload: { wallet: OmniWallet }) => void) {
+    this.events.on("disconnect", handler);
+    return () => this.events.off("disconnect", handler);
+  }
+
+  async withdraw(token: OmniToken, amount: number, settings?: { title?: string; sender?: OmniWallet }) {
+    const tokensList = await tokens.getTokens();
+    const omniToken = tokensList.find((t) => t.address === token)!;
+    const originalToken = tokensList.find((t) => t.chain === omniToken.originalChain && t.address === omniToken.originalAddress)!;
+    const recipient = Recipient.fromWallet(this.wallets.find((w) => w.type === originalToken.type));
+
+    const sender =
+      settings?.sender ||
+      this.wallets.sort((a, b) => {
+        const aBalance = omniToken.float(this.balance(a, omniToken));
+        const bBalance = omniToken.float(this.balance(b, omniToken));
+        return bBalance - aBalance;
+      })[0];
+
+    return openBridge(this, {
+      //  title: settings?.title,
+      sender: sender,
+      recipient: recipient,
+      to: originalToken,
+      from: omniToken,
+      amount: amount,
+    });
+  }
+
+  async deposit(token: OmniToken, amount: number, settings?: { title?: string }) {
+    const tokensList = await tokens.getTokens();
+    const omni = tokensList.find((t) => t.address === token)!;
+    const orig = tokensList.find((t) => t.chain === omni.originalChain && t.address === omni.originalAddress)!;
+    const sender = this.wallets.find((t) => t.type === orig.type)!;
+    const recipient = Recipient.fromWallet(this.wallets.find((w) => !!w.omniAddress));
+
+    return openBridge(this, {
+      sender: sender,
+      type: "exactOut",
+      readonlyAmount: true,
+      readonlyTo: true,
+      title: settings?.title,
+      recipient: recipient,
+      amount: amount,
+      from: orig,
+      to: omni,
+    });
+  }
+
+  async openBridge() {
+    await openBridge(this);
+  }
+
+  async connect(type?: WalletType) {
+    if (this.wallets.length > 0) return openProfile(this);
+    if (!type) return openConnector(this);
+
+    const connector = this.connectors.find((t) => t.type === ConnectorType.WALLET && t.walletTypes.includes(type));
+    if (!connector) throw new Error("Connector not found");
+    return openWalletPicker(connector);
+  }
+}

package/src/OmniConnector.ts

@@ -0,0 +1,161 @@
+import { makeObservable, observable, runInAction } from "mobx";
+import UniversalProvider, { NamespaceConfig } from "@walletconnect/universal-provider";
+
+import { EventEmitter } from "./events";
+import { LocalStorage } from "./storage";
+import { HotConnector } from "./HotConnector";
+
+import { OmniWallet } from "./OmniWallet";
+import { WalletType } from "./omni/config";
+import { openWCRequest } from "./ui/router";
+
+export enum ConnectorType {
+  WALLET = "wallet",
+  SOCIAL = "social",
+}
+
+export interface OmniConnectorOption {
+  name: string;
+  icon: string;
+  id: string;
+  download?: string;
+  type: "extension" | "external";
+}
+
+export interface OmniConnectorOptions {
+  projectId?: string;
+  metadata?: { name: string; description: string; url: string; icons: string[] };
+}
+
+export const WC_ICON = "https://raw.githubusercontent.com/WalletConnect/walletconnect-assets/refs/heads/master/Icon/Blue%20(Default)/Icon.svg";
+
+export abstract class OmniConnector<T extends OmniWallet = OmniWallet, O = {}> {
+  wallets: T[] = [];
+  options: (O & OmniConnectorOption)[] = [];
+
+  private storage = new LocalStorage();
+  protected events = new EventEmitter<{
+    connect: { wallet: T };
+    disconnect: { wallet: T };
+  }>();
+
+  protected wc: Promise<UniversalProvider> | null = null;
+
+  constructor(readonly wibe3: HotConnector, readonly settings?: OmniConnectorOptions) {
+    makeObservable(this, {
+      wallets: observable,
+      options: observable,
+    });
+  }
+
+  async initWalletConnect() {
+    if (!this.settings?.projectId) throw new Error("Project ID is required");
+    if (this.wc) return this.wc;
+    this.wc = UniversalProvider.init({
+      relayUrl: "wss://relay.walletconnect.org",
+      projectId: this.settings?.projectId,
+      metadata: this.settings?.metadata,
+      customStoragePrefix: `wibe3:${this.id}`,
+      name: this.name,
+    });
+
+    return this.wc;
+  }
+
+  async connectWalletConnect(args: { deeplink?: string; onConnect: () => Promise<OmniWallet>; namespaces: NamespaceConfig }): Promise<{ qrcode: string; deeplink?: string; task: Promise<OmniWallet> }> {
+    const provider = await this.wc;
+    if (!provider) throw new Error("No provider found");
+
+    return new Promise((resolve) => {
+      const session = provider.connect({ namespaces: args.namespaces });
+      const handler = (uri: string) => {
+        provider.off("display_uri", handler);
+        resolve({ qrcode: uri, deeplink: `${args.deeplink || "wc://"}${encodeURIComponent(uri)}`, task: session.then(args.onConnect) });
+      };
+      provider.on("display_uri", handler);
+    });
+  }
+
+  async disconnectWalletConnect() {
+    const provider = await this.wc;
+    if (provider?.session) await provider.disconnect();
+    provider?.cleanupPendingPairings();
+  }
+
+  async requestWalletConnect<T>(args: { chain?: string; request: any; deeplink?: string; name?: string; icon?: string }): Promise<T> {
+    return openWCRequest<T>({
+      deeplink: args.deeplink,
+      name: args.name || "WalletConnect",
+      icon: args.icon || WC_ICON,
+      request: args.request,
+      task: async () => {
+        const wc = await this.wc;
+        if (!wc) throw new Error("No provider found");
+        return await wc.request<T>(args.request, args.chain);
+      },
+    });
+  }
+
+  abstract connect(id?: string): Promise<OmniWallet | { qrcode: string; deeplink?: string; task: Promise<OmniWallet> }>;
+
+  abstract walletTypes: WalletType[];
+  abstract type: ConnectorType;
+  abstract name: string;
+  abstract icon: string;
+  abstract id: string;
+
+  protected setWallet(wallet: T) {
+    runInAction(() => this.wallets.push(wallet));
+    this.events.emit("connect", { wallet });
+    return wallet;
+  }
+
+  protected removeWallet() {
+    runInAction(() => {
+      const wallet = this.wallets.pop();
+      if (wallet) this.events.emit("disconnect", { wallet });
+    });
+  }
+
+  protected removeAllWallets(): void {
+    runInAction(() => {
+      const wallets = this.wallets;
+      this.wallets = [];
+      wallets.forEach((wallet) => this.events.emit("disconnect", { wallet }));
+    });
+  }
+
+  async setStorage(obj: { type?: string; id?: string; address?: string; publicKey?: string }) {
+    await this.storage.set(`wibe3:${this.id}`, JSON.stringify(obj));
+  }
+
+  async removeStorage() {
+    await this.storage.remove(`wibe3:${this.id}`);
+  }
+
+  async getStorage(): Promise<{ type?: string; id?: string; address?: string; publicKey?: string }> {
+    const data = await this.storage.get(`wibe3:${this.id}`);
+    if (!data) throw new Error("No storage found");
+    return JSON.parse(data);
+  }
+
+  removeAllListeners() {
+    this.events.removeAllListeners();
+  }
+
+  onConnect(handler: (payload: { wallet: T }) => void) {
+    this.events.on("connect", handler);
+    return () => this.events.off("connect", handler);
+  }
+
+  onDisconnect(handler: (payload: { wallet: T }) => void) {
+    this.events.on("disconnect", handler);
+    return () => this.events.off("disconnect", handler);
+  }
+
+  async disconnect() {
+    this.disconnectWalletConnect();
+    this.removeStorage();
+    this.removeWallet();
+  }
+}

package/src/OmniWallet.ts

@@ -0,0 +1,94 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+
+import { openAuthPopup } from "./ui/connect/AuthPopup";
+import { OmniToken, WalletType } from "./omni/config";
+import { OmniConnector } from "./OmniConnector";
+import { Intents } from "./omni/Intents";
+import { ReviewFee } from "./omni/bridge";
+import { Token } from "./omni/token";
+
+export interface AuthCommitment {
+  tradingAddress: string;
+  signed: Record<string, any>;
+  address: string;
+  publicKey: string;
+  chainId: WalletType;
+  seed: string;
+}
+
+export interface SignedAuth {
+  signed: Record<string, any>;
+  address: string;
+  publicKey: string;
+  chainId: WalletType;
+  seed: string;
+}
+
+export abstract class OmniWallet {
+  constructor(readonly connector: OmniConnector) {}
+
+  abstract address: string;
+  abstract publicKey?: string;
+  abstract omniAddress: string;
+  abstract type: WalletType;
+
+  async disconnect() {
+    if (!this.connector) throw new Error("Connector not implemented");
+    await this.connector.disconnect();
+  }
+
+  abstract transferFee(token: Token, receiver: string, amount: bigint): Promise<ReviewFee>;
+  abstract transfer(args: { token: Token; receiver: string; amount: bigint; comment?: string; gasFee?: ReviewFee }): Promise<string>;
+
+  abstract signIntentsWithAuth(domain: string, intents?: Record<string, any>[]): Promise<SignedAuth>;
+  abstract signIntents(intents: Record<string, any>[], options?: { nonce?: Uint8Array; deadline?: number }): Promise<Record<string, any>>;
+
+  abstract fetchBalance(chain: number, address: string): Promise<bigint>;
+  abstract fetchBalances(chain?: number, whitelist?: string[]): Promise<Record<string, bigint>>;
+
+  async executeIntents(intents: Record<string, any>[], hashes: string[] = []) {
+    const signed = await this.signIntents(intents);
+    return await Intents.publishSignedIntents([signed], hashes);
+  }
+
+  get icon() {
+    return this.connector?.icon;
+  }
+
+  get intents() {
+    return new Intents(this.connector.wibe3).attachWallet(this);
+  }
+
+  async auth<T = SignedAuth>(domain: string, intents?: Record<string, any>[], then?: (signed: SignedAuth) => Promise<T>): Promise<T> {
+    return openAuthPopup<T>(this, async () => {
+      const signed = await this.signIntentsWithAuth(domain, intents);
+      return (await then?.(signed)) ?? (signed as T);
+    });
+  }
+
+  async pay({ token, amount, recipient, paymentId }: { token: OmniToken; amount: number; recipient: string; paymentId: string }) {
+    const nonce = new Uint8Array(sha256(new TextEncoder().encode(paymentId))).slice(0, 32);
+    return this.intents.attachNonce(nonce).transfer({ recipient, token, amount }).execute();
+  }
+
+  async waitUntilBalance(need: Record<string, bigint>, receiver: string, attempts = 0) {
+    if (attempts > 120) throw "Balance is not enough";
+    const assets = Object.keys(need) as string[];
+    const balances = await Intents.getIntentsBalances(assets, receiver);
+    if (assets.every((asset) => (balances[asset] || 0n) >= (need[asset] || 0n))) return;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+    await this.waitUntilBalance(need, receiver, attempts + 1);
+  }
+
+  async getIntentsBalance(asset: string, receiver: string): Promise<bigint> {
+    const balances = await Intents.getIntentsBalances([asset], receiver);
+    return balances[asset] || 0n;
+  }
+
+  async getAssets() {
+    if (!this.omniAddress) return {};
+    const assets = await Intents.getIntentsAssets(this.omniAddress);
+    const balances = await Intents.getIntentsBalances(assets, this.omniAddress);
+    return balances;
+  }
+}