@hot-labs/kit 1.0.33

package/src/solana/connector.ts

@@ -0,0 +1,151 @@
+import { Wallet } from "@wallet-standard/base";
+import { Transaction, PublicKey, VersionedTransaction, Connection } from "@solana/web3.js";
+import { base58 } from "@scure/base";
+import { runInAction } from "mobx";
+
+import { ConnectorType, OmniConnector, OmniConnectorOptions, WC_ICON } from "../OmniConnector";
+import { HotConnector } from "../HotConnector";
+import { OmniWallet } from "../OmniWallet";
+import { isInjected } from "../hot-wallet/hot";
+import { WalletType } from "../omni/config";
+
+import SolanaProtocolWallet from "./protocol";
+import { getWallets } from "./wallets";
+import SolanaWallet from "./wallet";
+
+const wallets = getWallets();
+
+class SolanaConnector extends OmniConnector<SolanaWallet, { wallet: Wallet }> {
+  type = ConnectorType.WALLET;
+  walletTypes = [WalletType.SOLANA, WalletType.OMNI];
+
+  icon = "https://storage.herewallet.app/upload/8700f33153ad813e133e5bf9b791b5ecbeea66edca6b8d17aeccb8048eb29ef7.png";
+  name = "Solana Wallet";
+  id = "solana";
+
+  constructor(wibe3: HotConnector, readonly args?: OmniConnectorOptions) {
+    super(wibe3, args);
+
+    wallets.get().forEach((t) => {
+      if (this.options.find((w) => w.name === t.name)) return;
+      this.options.push({ type: "extension", wallet: t, name: t.name, icon: t.icon, id: t.name, download: t.url });
+    });
+
+    this.getConnectedWallet().then(async ({ id }) => {
+      try {
+        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));
+      } catch {
+        this.removeStorage();
+      }
+    });
+
+    wallets.on("register", async (wallet: Wallet & { url?: string }) => {
+      if (this.options.find((w) => w.id === wallet.name)) return;
+      runInAction(() => {
+        this.options.push({
+          wallet: wallet,
+          name: wallet.name,
+          icon: wallet.icon,
+          id: wallet.name,
+          download: wallet.url,
+          type: "extension",
+        });
+      });
+
+      try {
+        const connected = await this.getConnectedWallet();
+        if (connected !== wallet.name) return;
+        const protocolWallet = await SolanaProtocolWallet.connect(wallet, { silent: true });
+        this.setWallet(new SolanaWallet(this, protocolWallet));
+      } catch {
+        this.removeStorage();
+      }
+    });
+
+    wallets.on("unregister", (wallet) => {
+      this.options = this.options.filter((w) => w.id !== wallet.name);
+    });
+
+    this.initWalletConnect().then(async (wc) => {
+      this.options.unshift({ type: "external", download: "https://www.walletconnect.com/get", wallet: {} as Wallet, name: "WalletConnect", id: "walletconnect", icon: WC_ICON });
+      const selected = await this.getConnectedWallet();
+      if (selected.type !== "walletconnect") return;
+      this.setupWalletConnect();
+    });
+  }
+
+  async setupWalletConnect(): Promise<SolanaWallet> {
+    const wc = await this.wc;
+    if (!wc) throw new Error("WalletConnect not found");
+
+    const account = wc.session?.namespaces.solana?.accounts[0]?.split(":")[2];
+    if (!account) throw new Error("Account not found");
+
+    this.setStorage({ type: "walletconnect" });
+    return this.setWallet(
+      new SolanaWallet(this, {
+        address: account,
+        sendTransaction: async (tx: Transaction | VersionedTransaction, connection: Connection, options?: any) => {
+          const transaction = Buffer.from(tx.serialize()).toString("base64");
+          const { signature } = await this.requestWalletConnect<{ signature: string }>({
+            request: { params: { transaction, options }, method: "solana_signTransaction" },
+          });
+          tx.addSignature(new PublicKey(account), Buffer.from(base58.decode(signature)));
+          return await connection.sendRawTransaction(tx.serialize(), options);
+        },
+
+        signMessage: async (msg: string) => {
+          const message = base58.encode(Buffer.from(msg, "utf8"));
+          const { signature } = await this.requestWalletConnect<{ signature: string }>({
+            request: { method: "solana_signMessage", params: { message, pubkey: account } },
+          });
+          return base58.decode(signature);
+        },
+
+        disconnect: () => this.disconnectWalletConnect(),
+      })
+    );
+  }
+
+  async createWallet(address: string): Promise<OmniWallet> {
+    return new SolanaWallet(this, { address });
+  }
+
+  async getConnectedWallet() {
+    if (isInjected()) return { type: "wallet", id: "HOT Wallet" };
+    return this.getStorage();
+  }
+
+  async connect(id: string) {
+    if (id === "walletconnect") {
+      return await this.connectWalletConnect({
+        onConnect: () => this.setupWalletConnect(),
+        namespaces: {
+          solana: {
+            methods: ["solana_signTransaction", "solana_signMessage"],
+            chains: ["solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", "solana:4sGjMW1sUnHzSxGspuhpqLDx6wiyjNtZ"],
+            events: [],
+          },
+        },
+      });
+    }
+
+    this.disconnectWalletConnect();
+    const wallet = this.options.find((t) => t.id === id);
+    if (!wallet) throw new Error("Wallet not found");
+
+    try {
+      this.setStorage({ type: "wallet", id });
+      const protocolWallet = await SolanaProtocolWallet.connect(wallet.wallet, { silent: false });
+      return this.setWallet(new SolanaWallet(this, protocolWallet));
+    } catch (e) {
+      this.removeStorage();
+      throw e;
+    }
+  }
+}
+
+export default SolanaConnector;

package/src/solana/protocol.ts

@@ -0,0 +1,66 @@
+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;
+  sendTransaction?: (transaction: Transaction | VersionedTransaction, connection: Connection, options?: any) => Promise<string>;
+  signMessage?: (message: string) => Promise<Uint8Array>;
+  disconnect?: (data?: { silent?: boolean }) => Promise<void>;
+}
+
+class SolanaProtocolWallet implements ISolanaProtocolWallet {
+  constructor(readonly wallet: Wallet, readonly address: string) {}
+
+  static async connect(wallet: Wallet, { silent = false }: { silent?: boolean } = {}): Promise<ISolanaProtocolWallet> {
+    const a = new SolanaProtocolWallet(wallet, "");
+    const account = await a.getAccount({ silent });
+    return new SolanaProtocolWallet(wallet, account.address);
+  }
+
+  async getAccount({ silent = false }: { silent?: boolean } = {}) {
+    let accounts = this.wallet.accounts || [];
+
+    if (!accounts.length) {
+      const connect = (this.wallet.features as any)["standard:connect"]?.connect;
+      if (!connect) throw new Error("Wallet does not support standard:connect");
+      const { accounts: connectedAccounts } = await connect({ silent });
+      accounts = connectedAccounts || [];
+    }
+
+    if (!accounts.length) throw new Error("No account found");
+    return accounts[0];
+  }
+
+  async disconnect() {
+    const disconnect = (this.wallet.features as any)["standard:disconnect"]?.disconnect as (() => Promise<void>) | undefined;
+    if (disconnect) await disconnect();
+  }
+
+  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 [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();
+    const sig = await connection.sendRawTransaction(raw as Uint8Array, options as any);
+    return sig;
+  }
+
+  async signMessage(message: string) {
+    const account = await this.getAccount();
+    const features = this.wallet.features as any;
+    const signMessageFeature = features["solana:signMessage"]?.signMessage as SolanaSignMessageMethod;
+
+    if (!signMessageFeature) throw new Error("Wallet does not support solana:signMessage");
+    const [result] = await signMessageFeature({ account, message: new TextEncoder().encode(message) });
+
+    if (result.signature) return result.signature;
+    if (Array.isArray(result) && result[0]?.signature) return result[0].signature as Uint8Array;
+    throw new Error("Unexpected signMessage result");
+  }
+}
+
+export default SolanaProtocolWallet;

package/src/solana/wallet.ts

@@ -0,0 +1,230 @@
+import { Connection, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey, SystemProgram, TransactionMessage } from "@solana/web3.js";
+import { base64, base58, hex } from "@scure/base";
+import {
+  TOKEN_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID,
+  getMinimumBalanceForRentExemptAccount,
+  createAssociatedTokenAccountInstruction,
+  createTransferInstruction,
+  getAccount,
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  getAssociatedTokenAddressSync,
+  createTransferCheckedInstruction,
+} from "@solana/spl-token";
+
+import { Network, WalletType } from "../omni/config";
+import { OmniConnector } from "../OmniConnector";
+import { OmniWallet } from "../OmniWallet";
+
+import { Token } from "../omni/token";
+import { formatter } from "../omni/utils";
+import { ReviewFee } from "../omni/bridge";
+
+import { ISolanaProtocolWallet } from "./protocol";
+
+const connection = new Connection("https://api0.herewallet.app/api/v1/evm/rpc/1001");
+
+class SolanaWallet extends OmniWallet {
+  readonly type = WalletType.SOLANA;
+
+  constructor(readonly connector: OmniConnector, readonly wallet: ISolanaProtocolWallet) {
+    super(connector);
+  }
+
+  get address() {
+    return this.wallet.address;
+  }
+
+  get publicKey() {
+    return this.wallet.address;
+  }
+
+  get omniAddress() {
+    return hex.encode(base58.decode(this.address)).toLowerCase();
+  }
+
+  async fetchBalance(_: number, address: string) {
+    if (address === "native") {
+      const balance = await connection.getBalance(new PublicKey(this.address));
+      return BigInt(balance);
+    }
+
+    const ATA = getAssociatedTokenAddressSync(new PublicKey(address), new PublicKey(this.address));
+    const meta = await connection.getTokenAccountBalance(ATA);
+    return BigInt(meta.value.amount);
+  }
+
+  async disconnect() {
+    await this.wallet.disconnect?.();
+    super.disconnect();
+  }
+
+  async signIntentsWithAuth(domain: string, intents?: Record<string, any>[]) {
+    const seed = hex.encode(window.crypto.getRandomValues(new Uint8Array(32)));
+    const msgBuffer = new TextEncoder().encode(`${domain}_${seed}`);
+    const nonce = await window.crypto.subtle.digest("SHA-256", new Uint8Array(msgBuffer));
+
+    return {
+      signed: await this.signIntents(intents || [], { nonce: new Uint8Array(nonce) }),
+      publicKey: `ed25519:${this.address}`,
+      chainId: WalletType.SOLANA,
+      address: this.address,
+      seed,
+    };
+  }
+
+  async buildTranferInstructions(token: Token, amount: bigint, receiver: string, fee: ReviewFee) {
+    const destination = new PublicKey(receiver);
+    const owner = new PublicKey(this.address);
+
+    const reserve = await connection.getMinimumBalanceForRentExemption(0);
+    let additionalFee = 0n;
+
+    if (token.address === "native") {
+      return {
+        reserve,
+        additionalFee,
+        instructions: [
+          ComputeBudgetProgram.setComputeUnitPrice({ microLamports: Number(fee.priorityFee) }),
+          ComputeBudgetProgram.setComputeUnitLimit({ units: Number(fee.gasLimit) }),
+          SystemProgram.transfer({ fromPubkey: owner, toPubkey: destination, lamports: amount }),
+        ],
+      };
+    }
+
+    const mint = new PublicKey(token.address);
+    const mintAccount = await connection.getAccountInfo(mint);
+    const tokenProgramId = mintAccount?.owner.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+
+    const tokenFrom = getAssociatedTokenAddressSync(mint, owner, false, tokenProgramId);
+    const tokenTo = getAssociatedTokenAddressSync(mint, destination, false, tokenProgramId);
+
+    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) {
+      const inst = createAssociatedTokenAccountInstruction(new PublicKey(this.address), tokenTo, destination, mint, tokenProgramId, ASSOCIATED_TOKEN_PROGRAM_ID);
+      instructions.push(inst);
+      additionalFee += BigInt(await getMinimumBalanceForRentExemptAccount(connection));
+    }
+
+    if (tokenProgramId === TOKEN_2022_PROGRAM_ID) {
+      instructions.push(createTransferCheckedInstruction(tokenFrom, mint, tokenTo, owner, amount, token.decimals, [], tokenProgramId));
+    } else {
+      instructions.push(createTransferInstruction(tokenFrom, tokenTo, owner, amount, [], tokenProgramId));
+    }
+
+    return { instructions, additionalFee, reserve };
+  }
+
+  async transferFee(token: Token, receiver: string): Promise<ReviewFee> {
+    const { blockhash } = await connection.getLatestBlockhash();
+    const fee = new ReviewFee({ chain: Network.Solana, gasLimit: 1_400_000n, baseFee: 100n });
+    const { instructions, additionalFee, reserve } = await this.buildTranferInstructions(token, 1n, receiver, fee);
+
+    const msgForEstimate = new TransactionMessage({ payerKey: new PublicKey(this.address), recentBlockhash: blockhash, instructions }).compileToV0Message();
+    const tx = new VersionedTransaction(msgForEstimate);
+
+    const priorityFeeData = await this.getPriorityFeeEstimate({
+      options: { includeAllPriorityFeeLevels: true },
+      transaction: base58.encode(tx.serialize()),
+    });
+
+    if (priorityFeeData?.priorityFeeLevels == null) throw "Failed to fetch gas";
+    const simulate = await connection.simulateTransaction(tx).catch(() => null);
+    const unitsConsumed = formatter.bigIntMax(BigInt(simulate?.value.unitsConsumed || 10_000n), 10_000n);
+
+    const msgFee = await connection.getFeeForMessage(msgForEstimate);
+    const medium = BigInt(priorityFeeData.priorityFeeLevels.medium);
+    const high = BigInt(priorityFeeData.priorityFeeLevels.high);
+    const veryHigh = BigInt(priorityFeeData.priorityFeeLevels.veryHigh);
+    const baseFee = BigInt(msgFee.value || 0);
+
+    return new ReviewFee({
+      chain: Network.Solana,
+      reserve: BigInt(reserve) + additionalFee,
+      gasLimit: unitsConsumed,
+      baseFee,
+      priorityFee: medium,
+      options: [
+        { priorityFee: medium, baseFee },
+        { priorityFee: high, baseFee },
+        { priorityFee: veryHigh, baseFee },
+      ],
+    });
+  }
+
+  async getPriorityFeeEstimate(params: any): Promise<any> {
+    const response = await fetch("https://api0.herewallet.app/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",
+    });
+
+    if (!response.ok) throw "Server error";
+    const { result, error } = await response.json();
+    if (error) throw error.message;
+    if (result.error) throw result.error.message;
+    return result;
+  }
+
+  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);
+  }
+
+  async sendTransaction(instructions: TransactionInstruction[]): Promise<string> {
+    if (!this.wallet.sendTransaction) throw "not impl";
+    const { blockhash } = await connection.getLatestBlockhash();
+    const message = new TransactionMessage({ payerKey: new PublicKey(this.address), recentBlockhash: blockhash, instructions });
+    const transaction = new VersionedTransaction(message.compileToV0Message());
+    return await this.wallet.sendTransaction(transaction, connection, { preflightCommitment: "confirmed" });
+  }
+
+  async fetchBalances(chain: number, whitelist: string[]): Promise<Record<string, bigint>> {
+    const native = await this.fetchBalance(chain, "native");
+    try {
+      const res = await fetch(`https://api0.herewallet.app/api/v1/user/balances/${chain}/${this.address}`, { body: JSON.stringify({ whitelist }), method: "POST" });
+      const { balances } = await res.json();
+      return { ...balances, native };
+    } catch {
+      const tokenAccounts = await connection.getParsedTokenAccountsByOwner(new PublicKey(this.address), { programId: TOKEN_PROGRAM_ID });
+      const balances = Object.fromEntries(
+        tokenAccounts.value.map((account) => {
+          const { mint, tokenAmount } = account.account.data.parsed.info;
+          return [mint, tokenAmount.amount];
+        })
+      );
+
+      return { ...balances, native };
+    }
+  }
+
+  async signMessage(message: string) {
+    if (!this.wallet.signMessage) throw "not impl";
+    return this.wallet.signMessage(message);
+  }
+
+  async signIntents(intents: Record<string, any>[], options?: { deadline?: number; nonce?: Uint8Array }): Promise<Record<string, any>> {
+    const nonce = new Uint8Array(options?.nonce || window.crypto.getRandomValues(new Uint8Array(32)));
+
+    const message = JSON.stringify({
+      deadline: options?.deadline ? new Date(options.deadline).toISOString() : "2100-01-01T00:00:00.000Z",
+      nonce: base64.encode(nonce),
+      verifying_contract: "intents.near",
+      signer_id: this.omniAddress,
+      intents: intents,
+    });
+
+    const signature = await this.signMessage(message);
+    return {
+      signature: `ed25519:${base58.encode(signature)}`,
+      public_key: `ed25519:${this.publicKey}`,
+      standard: "raw_ed25519",
+      payload: message,
+    };
+  }
+}
+
+export default SolanaWallet;

package/src/solana/wallets.ts

@@ -0,0 +1,243 @@
+import type { DEPRECATED_WalletsCallback, DEPRECATED_WalletsWindow, Wallet, WalletEventsWindow, WindowAppReadyEvent, WindowAppReadyEventAPI } from "@wallet-standard/base";
+
+let wallets: Wallets | undefined = undefined;
+const registeredWalletsSet = new Set<Wallet>();
+function addRegisteredWallet(wallet: Wallet) {
+  cachedWalletsArray = undefined;
+  registeredWalletsSet.add(wallet);
+}
+
+function removeRegisteredWallet(wallet: Wallet) {
+  cachedWalletsArray = undefined;
+  registeredWalletsSet.delete(wallet);
+}
+
+const listeners: { [E in WalletsEventNames]?: WalletsEventsListeners[E][] } = {};
+
+/**
+ * Get an API for {@link Wallets.get | getting}, {@link Wallets.on | listening for}, and
+ * {@link Wallets.register | registering} {@link "@wallet-standard/base".Wallet | Wallets}.
+ *
+ * When called for the first time --
+ *
+ * This dispatches a {@link "@wallet-standard/base".WindowAppReadyEvent} to notify each Wallet that the app is ready
+ * to register it.
+ *
+ * This also adds a listener for {@link "@wallet-standard/base".WindowRegisterWalletEvent} to listen for a notification
+ * from each Wallet that the Wallet is ready to be registered by the app.
+ *
+ * This combination of event dispatch and listener guarantees that each Wallet will be registered synchronously as soon
+ * as the app is ready whether the app loads before or after each Wallet.
+ *
+ * @return API for getting, listening for, and registering Wallets.
+ *
+ * @group App
+ */
+export function getWallets(): Wallets {
+  if (wallets) return wallets;
+  wallets = Object.freeze({ register, get, on });
+  if (typeof window === "undefined") return wallets;
+
+  const api = Object.freeze({ register });
+  try {
+    (window as WalletEventsWindow).addEventListener("wallet-standard:register-wallet", ({ detail: callback }) => callback(api));
+  } catch (error) {
+    console.error("wallet-standard:register-wallet event listener could not be added\n", error);
+  }
+  try {
+    (window as WalletEventsWindow).dispatchEvent(new AppReadyEvent(api));
+  } catch (error) {
+    console.error("wallet-standard:app-ready event could not be dispatched\n", error);
+  }
+
+  return wallets;
+}
+
+/**
+ * API for {@link Wallets.get | getting}, {@link Wallets.on | listening for}, and
+ * {@link Wallets.register | registering} {@link "@wallet-standard/base".Wallet | Wallets}.
+ *
+ * @group App
+ */
+export interface Wallets {
+  /**
+   * Get all Wallets that have been registered.
+   *
+   * @return Registered Wallets.
+   */
+  get(): readonly (Wallet & { url?: string })[];
+
+  /**
+   * Add an event listener and subscribe to events for Wallets that are
+   * {@link WalletsEventsListeners.register | registered} and
+   * {@link WalletsEventsListeners.unregister | unregistered}.
+   *
+   * @param event    Event type to listen for. {@link WalletsEventsListeners.register | `register`} and
+   * {@link WalletsEventsListeners.unregister | `unregister`} are the only event types.
+   * @param listener Function that will be called when an event of the type is emitted.
+   *
+   * @return
+   * `off` function which may be called to remove the event listener and unsubscribe from events.
+   *
+   * As with all event listeners, be careful to avoid memory leaks.
+   */
+  on<E extends WalletsEventNames>(event: E, listener: WalletsEventsListeners[E]): () => void;
+
+  /**
+   * Register Wallets. This can be used to programmatically wrap non-standard wallets as Standard Wallets.
+   *
+   * Apps generally do not need to, and should not, call this.
+   *
+   * @param wallets Wallets to register.
+   *
+   * @return
+   * `unregister` function which may be called to programmatically unregister the registered Wallets.
+   *
+   * Apps generally do not need to, and should not, call this.
+   */
+  register(...wallets: Wallet[]): () => void;
+}
+
+/**
+ * Types of event listeners of the {@link Wallets} API.
+ *
+ * @group App
+ */
+export interface WalletsEventsListeners {
+  /**
+   * Emitted when Wallets are registered.
+   *
+   * @param wallets Wallets that were registered.
+   */
+  register(...wallets: Wallet[]): void;
+
+  /**
+   * Emitted when Wallets are unregistered.
+   *
+   * @param wallets Wallets that were unregistered.
+   */
+  unregister(...wallets: Wallet[]): void;
+}
+
+/**
+ * Names of {@link WalletsEventsListeners} that can be listened for.
+ *
+ * @group App
+ */
+export type WalletsEventNames = keyof WalletsEventsListeners;
+
+/**
+ * @deprecated Use {@link WalletsEventsListeners} instead.
+ *
+ * @group Deprecated
+ */
+export type WalletsEvents = WalletsEventsListeners;
+
+function register(...wallets: Wallet[]): () => void {
+  // Filter out wallets that have already been registered.
+  // This prevents the same wallet from being registered twice, but it also prevents wallets from being
+  // unregistered by reusing a reference to the wallet to obtain the unregister function for it.
+  wallets = wallets.filter((wallet) => !registeredWalletsSet.has(wallet));
+  // If there are no new wallets to register, just return a no-op unregister function.
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  if (!wallets.length) return () => {};
+
+  wallets.forEach((wallet) => addRegisteredWallet(wallet));
+  listeners["register"]?.forEach((listener) => guard(() => listener(...wallets)));
+  // Return a function that unregisters the registered wallets.
+  return function unregister(): void {
+    wallets.forEach((wallet) => removeRegisteredWallet(wallet));
+    listeners["unregister"]?.forEach((listener) => guard(() => listener(...wallets)));
+  };
+}
+
+let cachedWalletsArray: readonly Wallet[] | undefined;
+function get(): readonly Wallet[] {
+  if (!cachedWalletsArray) {
+    cachedWalletsArray = [...registeredWalletsSet];
+  }
+  return cachedWalletsArray;
+}
+
+function on<E extends WalletsEventNames>(event: E, listener: WalletsEventsListeners[E]): () => void {
+  listeners[event]?.push(listener) || (listeners[event] = [listener]);
+  // Return a function that removes the event listener.
+  return function off(): void {
+    listeners[event] = listeners[event]?.filter((existingListener) => listener !== existingListener);
+  };
+}
+
+function guard(callback: () => void) {
+  try {
+    callback();
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+class AppReadyEvent extends Event implements WindowAppReadyEvent {
+  readonly #detail: WindowAppReadyEventAPI;
+
+  get detail() {
+    return this.#detail;
+  }
+
+  get type() {
+    return "wallet-standard:app-ready" as const;
+  }
+
+  constructor(api: WindowAppReadyEventAPI) {
+    super("wallet-standard:app-ready", {
+      bubbles: false,
+      cancelable: false,
+      composed: false,
+    });
+    this.#detail = api;
+  }
+
+  /** @deprecated */
+  preventDefault(): never {
+    throw new Error("preventDefault cannot be called");
+  }
+
+  /** @deprecated */
+  stopImmediatePropagation(): never {
+    throw new Error("stopImmediatePropagation cannot be called");
+  }
+
+  /** @deprecated */
+  stopPropagation(): never {
+    throw new Error("stopPropagation cannot be called");
+  }
+}
+
+/**
+ * @deprecated Use {@link getWallets} instead.
+ *
+ * @group Deprecated
+ */
+export function DEPRECATED_getWallets(): Wallets {
+  if (wallets) return wallets;
+  wallets = getWallets();
+  if (typeof window === "undefined") return wallets;
+
+  const callbacks = (window as DEPRECATED_WalletsWindow).navigator.wallets || [];
+  if (!Array.isArray(callbacks)) {
+    console.error("window.navigator.wallets is not an array");
+    return wallets;
+  }
+
+  const { register } = wallets;
+  const push = (...callbacks: DEPRECATED_WalletsCallback[]): void => callbacks.forEach((callback) => guard(() => callback({ register })));
+  try {
+    Object.defineProperty((window as DEPRECATED_WalletsWindow).navigator, "wallets", {
+      value: Object.freeze({ push }),
+    });
+  } catch (error) {
+    console.error("window.navigator.wallets could not be set");
+    return wallets;
+  }
+
+  push(...callbacks);
+  return wallets;
+}