@hot-labs/kit 1.0.33

package/src/hot-wallet/solana/account.ts

@@ -0,0 +1,52 @@
+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;
+
+export class GhostWalletAccount implements WalletAccount {
+  readonly #address: WalletAccount["address"];
+  readonly #publicKey: WalletAccount["publicKey"];
+  readonly #chains: WalletAccount["chains"];
+  readonly #features: WalletAccount["features"];
+  readonly #label: WalletAccount["label"];
+  readonly #icon: WalletAccount["icon"];
+
+  get address() {
+    return this.#address;
+  }
+
+  get publicKey() {
+    return this.#publicKey.slice();
+  }
+
+  get chains() {
+    return this.#chains.slice();
+  }
+
+  get features() {
+    return this.#features.slice();
+  }
+
+  get label() {
+    return this.#label;
+  }
+
+  get icon() {
+    return this.#icon;
+  }
+
+  constructor({ address, publicKey, label, icon }: Omit<WalletAccount, "chains" | "features">) {
+    if (new.target === GhostWalletAccount) {
+      Object.freeze(this);
+    }
+
+    this.#address = address;
+    this.#publicKey = publicKey;
+    this.#chains = chains;
+    this.#features = features;
+    this.#label = label;
+    this.#icon = icon;
+  }
+}

package/src/hot-wallet/solana/index.ts

@@ -0,0 +1,98 @@
+import { Transaction, VersionedTransaction, PublicKey } from "@solana/web3.js";
+
+import { isInjected, requestHot } from "../hot";
+import { registerWallet } from "./register";
+import { GhostWallet } from "./solana-wallet";
+
+const deserializeTransaction = (base64: string | Buffer) => {
+  let buf = Buffer.alloc(0);
+  if (Buffer.isBuffer(base64)) {
+    buf = Buffer.from(base64);
+  } else {
+    const parts = base64.split(",");
+    if (parts.every((t) => !isNaN(Number(t)))) buf = Buffer.from(new Uint8Array(parts.map((t) => Number(t))));
+    else buf = Buffer.from(base64, "base64");
+  }
+
+  try {
+    return VersionedTransaction.deserialize(buf);
+  } catch (e) {
+    return Transaction.from(buf);
+  }
+};
+
+const hotSolana = {
+  publicKey: null as PublicKey | null,
+
+  async connect(options: any) {
+    const { publicKey } = await requestHot("solana:connect", options);
+    hotSolana.publicKey = new PublicKey(publicKey);
+    return { publicKey: hotSolana.publicKey };
+  },
+
+  async disconnect() {
+    return await requestHot("solana:disconnect", {});
+  },
+
+  async signAllTransactions(transactions: any[]) {
+    const result = await requestHot("solana:signAllTransactions", {
+      transactions: transactions.map((t) => t.serialize().toString("base64")),
+    });
+
+    return result.transactions.map((t: any) => deserializeTransaction(t));
+  },
+
+  async signTransaction(transaction: any) {
+    const result = await requestHot("solana:signAllTransactions", {
+      transactions: [transaction.serialize().toString("base64")],
+    });
+
+    return deserializeTransaction(result.transactions[0]) as any;
+  },
+
+  async signAndSendTransaction(transaction: any, options: any) {
+    const result = await requestHot("solana:signAndSendTransaction", {
+      transaction: transaction.serialize().toString("base64"),
+      options,
+    });
+
+    return { signature: result.signature };
+  },
+
+  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") });
+    return { signature: Buffer.from(result.signature, "base64") };
+  },
+
+  off() {
+    //HOT.unsubscribe(`solana:${event}`, listener);
+  },
+
+  on() {
+    // HOT.subscribe(`solana:${event}`, listener);
+  },
+};
+
+/*
+HOT.subscribe("solana:accountChanged", (publicKey: string | null) => {
+  hotSolana.publicKey = publicKey ? new PublicKey(publicKey) : null;
+});
+*/
+
+if (isInjected()) {
+  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) {
+    //
+  }
+}

package/src/hot-wallet/solana/register.ts

@@ -0,0 +1,48 @@
+import type { Wallet, WalletEventsWindow, WindowRegisterWalletEvent, WindowRegisterWalletEventCallback } from "@wallet-standard/base";
+
+export function registerWallet(wallet: Wallet): void {
+  const callback: WindowRegisterWalletEventCallback = ({ register }) => register(wallet);
+  try {
+    (window as WalletEventsWindow).dispatchEvent(new RegisterWalletEvent(callback));
+  } catch (error) {
+    console.error(error);
+  }
+
+  try {
+    (window as WalletEventsWindow).addEventListener("wallet-standard:app-ready", ({ detail: api }) => callback(api));
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+class RegisterWalletEvent extends Event implements WindowRegisterWalletEvent {
+  readonly #detail: WindowRegisterWalletEventCallback;
+
+  get detail() {
+    return this.#detail;
+  }
+
+  get type() {
+    return "wallet-standard:register-wallet" as const;
+  }
+
+  constructor(callback: WindowRegisterWalletEventCallback) {
+    super("wallet-standard:register-wallet", { bubbles: false, cancelable: false, composed: false });
+    this.#detail = callback;
+  }
+
+  /** @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");
+  }
+}

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

@@ -0,0 +1,280 @@
+import {
+  SolanaSignAndSendTransaction,
+  type SolanaSignAndSendTransactionFeature,
+  type SolanaSignAndSendTransactionMethod,
+  type SolanaSignAndSendTransactionOutput,
+  SolanaSignIn,
+  type SolanaSignInFeature,
+  type SolanaSignInMethod,
+  type SolanaSignInOutput,
+  SolanaSignMessage,
+  type SolanaSignMessageFeature,
+  type SolanaSignMessageMethod,
+  type SolanaSignMessageOutput,
+  SolanaSignTransaction,
+  type SolanaSignTransactionFeature,
+  type SolanaSignTransactionMethod,
+  type SolanaSignTransactionOutput,
+} from "@solana/wallet-standard-features";
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+import type { Wallet } from "@wallet-standard/base";
+import {
+  StandardConnect,
+  type StandardConnectFeature,
+  type StandardConnectMethod,
+  StandardDisconnect,
+  type StandardDisconnectFeature,
+  type StandardDisconnectMethod,
+  StandardEvents,
+  type StandardEventsFeature,
+  type StandardEventsListeners,
+  type StandardEventsNames,
+  type StandardEventsOnMethod,
+} from "@wallet-standard/features";
+import { base58 } from "@scure/base";
+
+import { GhostWalletAccount } from "./account";
+import { SOLANA_CHAINS, GhostFeature, GhostNamespace, isVersionedTransaction, SolanaChain, isSolanaChain, bytesEqual } from "./utils";
+
+export class GhostWallet implements Wallet {
+  _account: GhostWalletAccount | null = null;
+  readonly _listeners: { [E in StandardEventsNames]?: StandardEventsListeners[E][] } = {};
+  readonly _version = "1.0.0" as const;
+  readonly _name = "HOT Wallet" as const;
+  readonly _icon = "https://storage.herewallet.app/logo.png";
+  readonly _ghost: any;
+
+  get version() {
+    return this._version;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  get icon() {
+    return this._icon as any;
+  }
+
+  get chains() {
+    return SOLANA_CHAINS.slice();
+  }
+
+  get features(): StandardConnectFeature & StandardDisconnectFeature & StandardEventsFeature & SolanaSignAndSendTransactionFeature & SolanaSignTransactionFeature & SolanaSignMessageFeature & SolanaSignInFeature & GhostFeature {
+    return {
+      [StandardConnect]: {
+        version: "1.0.0",
+        connect: this._connect,
+      },
+      [StandardDisconnect]: {
+        version: "1.0.0",
+        disconnect: this._disconnect,
+      },
+      [StandardEvents]: {
+        version: "1.0.0",
+        on: this._on,
+      },
+      [SolanaSignAndSendTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signAndSendTransaction: this._signAndSendTransaction,
+      },
+      [SolanaSignTransaction]: {
+        version: "1.0.0",
+        supportedTransactionVersions: ["legacy", 0],
+        signTransaction: this._signTransaction,
+      },
+      [SolanaSignMessage]: {
+        version: "1.0.0",
+        signMessage: this._signMessage,
+      },
+      [SolanaSignIn]: {
+        version: "1.0.0",
+        signIn: this._signIn,
+      },
+      [GhostNamespace]: {
+        ghost: this._ghost,
+      },
+    };
+  }
+
+  get accounts() {
+    return this._account ? [this._account] : [];
+  }
+
+  constructor(ghost: any) {
+    this._ghost = ghost;
+    ghost.on("connect", this._connected, this);
+    ghost.on("disconnect", this._disconnected, this);
+    ghost.on("accountChanged", this._reconnected, this);
+    this._connected();
+  }
+
+  _on: StandardEventsOnMethod = (event, listener) => {
+    this._listeners[event]?.push(listener) || (this._listeners[event] = [listener]);
+    return (): void => this._off(event, listener);
+  };
+
+  _emit<E extends StandardEventsNames>(event: E, ...args: Parameters<StandardEventsListeners[E]>): void {
+    // eslint-disable-next-line prefer-spread
+    this._listeners[event]?.forEach((listener) => listener.apply(null, args));
+  }
+
+  _off<E extends StandardEventsNames>(event: E, listener: StandardEventsListeners[E]): void {
+    this._listeners[event] = this._listeners[event]?.filter((existingListener) => listener !== existingListener);
+  }
+
+  _connected = () => {
+    const address = this._ghost.publicKey?.toBase58();
+    if (address) {
+      const publicKey = this._ghost.publicKey!.toBytes();
+
+      const account = this._account;
+      if (!account || account.address !== address || !bytesEqual(account.publicKey, publicKey)) {
+        this._account = new GhostWalletAccount({ address, publicKey });
+        this._emit("change", { accounts: this.accounts });
+      }
+    }
+  };
+
+  _disconnected = () => {
+    if (this._account) {
+      this._account = null;
+      this._emit("change", { accounts: this.accounts });
+    }
+  };
+
+  _reconnected = () => {
+    if (this._ghost.publicKey) {
+      this._connected();
+    } else {
+      this._disconnected();
+    }
+  };
+
+  _connect: StandardConnectMethod = async ({ silent } = {}) => {
+    if (!this._account) await this._ghost.connect(silent ? { onlyIfTrusted: true } : undefined);
+    this._connected();
+    return { accounts: this.accounts };
+  };
+
+  _disconnect: StandardDisconnectMethod = async () => {
+    await this._ghost.disconnect();
+  };
+
+  _signAndSendTransaction: SolanaSignAndSendTransactionMethod = async (...inputs) => {
+    if (!this._account) throw new Error("not connected");
+
+    const outputs: SolanaSignAndSendTransactionOutput[] = [];
+
+    if (inputs.length === 1) {
+      const { transaction, account, options } = inputs[0]!;
+      const { minContextSlot, preflightCommitment, skipPreflight, maxRetries } = options || {};
+      if (account !== this._account) throw new Error("invalid account");
+
+      const { signature } = await this._ghost.signAndSendTransaction(VersionedTransaction.deserialize(transaction), {
+        preflightCommitment,
+        minContextSlot,
+        maxRetries,
+        skipPreflight,
+      });
+
+      outputs.push({ signature: base58.decode(signature) });
+    } else if (inputs.length > 1) {
+      for (const input of inputs) {
+        outputs.push(...(await this._signAndSendTransaction(input)));
+      }
+    }
+
+    return outputs;
+  };
+
+  _signTransaction: SolanaSignTransactionMethod = async (...inputs) => {
+    if (!this._account) throw new Error("not connected");
+
+    const outputs: SolanaSignTransactionOutput[] = [];
+
+    if (inputs.length === 1) {
+      const { transaction, account, chain } = inputs[0]!;
+      if (account !== this._account) throw new Error("invalid account");
+      if (chain && !isSolanaChain(chain)) throw new Error("invalid chain");
+
+      const signedTransaction = await this._ghost.signTransaction(VersionedTransaction.deserialize(transaction));
+
+      const serializedTransaction = isVersionedTransaction(signedTransaction)
+        ? signedTransaction.serialize()
+        : (signedTransaction as Transaction).serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+          });
+
+      outputs.push({ signedTransaction: serializedTransaction });
+    } else if (inputs.length > 1) {
+      let chain: SolanaChain | undefined = undefined;
+      for (const input of inputs) {
+        if (input.account !== this._account) throw new Error("invalid account");
+        if (input.chain) {
+          if (!isSolanaChain(input.chain)) throw new Error("invalid chain");
+          if (chain) {
+            if (input.chain !== chain) throw new Error("conflicting chain");
+          } else {
+            chain = input.chain;
+          }
+        }
+      }
+
+      const transactions = inputs.map(({ transaction }) => VersionedTransaction.deserialize(transaction));
+      const signedTransactions = await this._ghost.signAllTransactions(transactions);
+
+      outputs.push(
+        ...signedTransactions.map((signedTransaction: any) => {
+          const serializedTransaction = isVersionedTransaction(signedTransaction)
+            ? signedTransaction.serialize()
+            : (signedTransaction as Transaction).serialize({
+                requireAllSignatures: false,
+                verifySignatures: false,
+              });
+
+          return { signedTransaction: serializedTransaction };
+        })
+      );
+    }
+
+    return outputs;
+  };
+
+  _signMessage: SolanaSignMessageMethod = async (...inputs) => {
+    if (!this._account) throw new Error("not connected");
+
+    const outputs: SolanaSignMessageOutput[] = [];
+
+    if (inputs.length === 1) {
+      const { message, account } = inputs[0]!;
+      if (account !== this._account) throw new Error("invalid account");
+
+      const { signature } = await this._ghost.signMessage(message);
+
+      outputs.push({ signedMessage: message, signature });
+    } else if (inputs.length > 1) {
+      for (const input of inputs) {
+        outputs.push(...(await this._signMessage(input)));
+      }
+    }
+
+    return outputs;
+  };
+
+  _signIn: SolanaSignInMethod = async (...inputs) => {
+    const outputs: SolanaSignInOutput[] = [];
+
+    if (inputs.length > 1) {
+      for (const input of inputs) {
+        outputs.push(await this._ghost.signIn(input));
+      }
+    } else {
+      return [await this._ghost.signIn(inputs[0])];
+    }
+
+    return outputs;
+  };
+}

package/src/hot-wallet/solana/utils.ts

@@ -0,0 +1,56 @@
+import { Transaction, VersionedTransaction } from "@solana/web3.js";
+import type { IdentifierString } from "@wallet-standard/base";
+
+interface Indexed<T> {
+  length: number;
+  [index: number]: T;
+}
+
+export function bytesEqual(a: Uint8Array, b: Uint8Array): boolean {
+  return arraysEqual(a, b);
+}
+
+export function arraysEqual<T>(a: Indexed<T>, b: Indexed<T>): boolean {
+  if (a === b) return true;
+
+  const length = a.length;
+  if (length !== b.length) return false;
+
+  for (let i = 0; i < length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+
+  return true;
+}
+
+export const GhostNamespace = "hot:";
+export type GhostFeature = { [GhostNamespace]: { ghost: any } };
+
+/** Solana Mainnet (beta) cluster, e.g. https://api.mainnet-beta.solana.com */
+export const SOLANA_MAINNET_CHAIN = "solana:mainnet";
+
+/** Solana Devnet cluster, e.g. https://api.devnet.solana.com */
+export const SOLANA_DEVNET_CHAIN = "solana:devnet";
+
+/** Solana Testnet cluster, e.g. https://api.testnet.solana.com */
+export const SOLANA_TESTNET_CHAIN = "solana:testnet";
+
+/** Solana Localnet cluster, e.g. http://localhost:8899 */
+export const SOLANA_LOCALNET_CHAIN = "solana:localnet";
+
+/** Array of all Solana clusters */
+export const SOLANA_CHAINS = ["solana:mainnet", "solana:mainnet-beta"] as const;
+
+/** Type of all Solana clusters */
+export type SolanaChain = (typeof SOLANA_CHAINS)[number];
+
+/**
+ * Check if a chain corresponds with one of the Solana clusters.
+ */
+export function isSolanaChain(chain: IdentifierString): chain is SolanaChain {
+  return SOLANA_CHAINS.includes(chain as SolanaChain);
+}
+
+export function isVersionedTransaction(transaction: Transaction | VersionedTransaction): transaction is VersionedTransaction {
+  return "version" in transaction;
+}

package/src/hot-wallet/stellar.ts

@@ -0,0 +1,39 @@
+import { type ModuleInterface, ModuleType, WalletNetwork } from "@creit.tech/stellar-wallets-kit";
+import { requestHot } from "./hot";
+
+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;
+  productId: string = HOTWALLET_ID;
+  productName: string = "HOT Wallet";
+  productUrl: string = "https://hot-labs.org/wallet";
+  productIcon: string = "https://storage.herewallet.app/logo.png";
+
+  async isAvailable(): Promise<boolean> {
+    return true;
+  }
+
+  async getAddress(): Promise<{ address: string }> {
+    return await requestHot("stellar:getAddress", {});
+  }
+
+  async signTransaction(xdr: string, opts?: { address?: string }): Promise<{ signedTxXdr: string; signerAddress?: string }> {
+    return await requestHot("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 });
+  }
+
+  async signMessage(message: string, opts?: { address?: string }): Promise<{ signedMessage: string; signerAddress?: string }> {
+    return await requestHot("stellar:signMessage", { message, accountToSign: opts?.address });
+  }
+
+  async getNetwork(): Promise<{ network: string; networkPassphrase: string }> {
+    return { network: "mainnet", networkPassphrase: WalletNetwork.PUBLIC };
+  }
+}

package/src/hot-wallet/ton.ts

@@ -0,0 +1,56 @@
+import { isInjected, requestHot } from "./hot";
+
+if (isInjected()) {
+  // @ts-expect-error: hotWallet is not defined
+  window.hotWallet = {
+    tonconnect: {
+      deviceInfo: {
+        appName: "hot",
+        appVersion: "1",
+        maxProtocolVersion: 2,
+        platform: "ios",
+        features: [
+          "SendTransaction",
+          {
+            name: "SendTransaction",
+            maxMessages: 255,
+            extraCurrencySupported: false,
+          },
+          {
+            name: "SignData",
+            types: ["text", "binary", "cell"],
+          },
+        ],
+      },
+
+      walletInfo: {
+        name: "hotWallet",
+        image: "https://storage.herewallet.app/logo.png",
+        about_url: "https://hot-labs.org",
+      },
+
+      protocolVersion: 2,
+      isWalletBrowser: true,
+
+      connect: (_: number, request: any) => {
+        return requestHot("ton:connect", request);
+      },
+
+      restoreConnection: () => {
+        return requestHot("ton:restoreConnection", {});
+      },
+
+      disconnect: () => {
+        return requestHot("ton:disconnect", {});
+      },
+
+      send: async (request: any) => {
+        return requestHot("ton:send", request);
+      },
+
+      listen: () => {
+        return function () {};
+      },
+    },
+  };
+}

package/src/hot-wallet/wallet.ts

@@ -0,0 +1,44 @@
+import { GlobalSettings } from "../settings";
+import { uuid4 } from "./hot";
+
+export const requestWebWallet = (chain?: number, address?: string) => (method: string, request: any) => {
+  const width = 480;
+  const height = 640;
+  const wallet = GlobalSettings.webWallet;
+  const x = (window.screen.width - width) / 2;
+  const y = (window.screen.height - height) / 2;
+
+  const popup = window.open(`${wallet}`, "_blank", `popup=1,width=${width},height=${height},top=${y},left=${x}`);
+
+  return new Promise<any>(async (resolve, reject) => {
+    const interval = setInterval(() => {
+      if (!popup?.closed) return;
+      clearInterval(interval);
+      reject(new Error("User rejected"));
+    }, 100);
+
+    const id = uuid4();
+    const handler = (event: MessageEvent) => {
+      if (event.origin !== wallet) return;
+
+      if (event.data === "hot:ready") {
+        popup?.postMessage({ chain, address, method, request, id }, "*");
+        return;
+      }
+
+      if (event.data.id !== id) return;
+      if (event.data.success === false) {
+        clearInterval(interval);
+        reject(new Error(event.data.payload));
+        window.removeEventListener("message", handler);
+      }
+
+      window.removeEventListener("message", handler);
+      resolve(event.data.payload);
+      clearInterval(interval);
+      popup?.close();
+    };
+
+    window.addEventListener("message", handler);
+  });
+};