cruzo-web3 0.1.0

package/lib/crypto/verify-signature.ts

@@ -0,0 +1,54 @@
+import { toBytes } from "./decode-bytes";
+import { hashEvmPersonalMessage, keccak256 } from "./keccak256";
+import { verifySecp256k1 } from "./secp256k1-verify";
+
+async function verifyEd25519(
+  publicKey: Uint8Array,
+  signature: Uint8Array,
+  message: Uint8Array
+) {
+  if (!globalThis.crypto?.subtle) return false;
+
+  try {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      publicKey as BufferSource,
+      { name: "Ed25519" },
+      false,
+      ["verify"]
+    );
+
+    return crypto.subtle.verify(
+      { name: "Ed25519" },
+      key,
+      signature as BufferSource,
+      message as BufferSource
+    );
+  } catch {
+    return false;
+  }
+}
+
+export async function verifySignedBytes(
+  content: Uint8Array,
+  signature: Uint8Array,
+  publicKey: Uint8Array,
+  algorithm: "secp256k1" | "Ed25519" | "sr25519",
+  options?: { evmPersonalSign?: boolean }
+) {
+  if (algorithm === "Ed25519") {
+    return verifyEd25519(publicKey, signature, content);
+  }
+
+  const messageHash = options?.evmPersonalSign
+    ? hashEvmPersonalMessage(content)
+    : content.length === 32
+      ? content
+      : keccak256(content);
+
+  return verifySecp256k1(signature, messageHash, publicKey);
+}
+
+export function normalizeContent(content: string | Uint8Array) {
+  return toBytes(content);
+}

package/lib/env.d.ts

@@ -0,0 +1,4 @@
+declare module "*.module.css" {
+  const classes: Record<string, string>;
+  export default classes;
+}

package/lib/errors/web3-error.ts

@@ -0,0 +1,49 @@
+export type Web3ErrorCode =
+  | "NO_PROVIDER"
+  | "NO_WALLET"
+  | "INVALID_MESSAGE"
+  | "INVALID_PUB_KEY"
+  | "INVALID_SIGNATURE"
+  | "UNSUPPORTED_ALGORITHM";
+
+export class Web3Error extends Error {
+  readonly name = "Web3Error";
+
+  constructor(
+    readonly code: Web3ErrorCode,
+    message: string,
+  ) {
+    super(message);
+  }
+
+  static noProvider() {
+    return new Web3Error("NO_PROVIDER", "Web3 provider is not set");
+  }
+
+  static noWallet() {
+    return new Web3Error(
+      "NO_WALLET",
+      "No injected wallet found (install MetaMask or another EIP-1193 wallet)",
+    );
+  }
+
+  static invalidMessage(detail: string) {
+    return new Web3Error("INVALID_MESSAGE", `Message must be a non-empty string or Uint8Array (${detail})`);
+  }
+
+  static invalidPubKey(message: string) {
+    return new Web3Error("INVALID_PUB_KEY", message);
+  }
+
+  static invalidSignature(message: string) {
+    return new Web3Error("INVALID_SIGNATURE", message);
+  }
+
+  static unsupportedAlgorithm(message: string) {
+    return new Web3Error("UNSUPPORTED_ALGORITHM", message);
+  }
+
+  static customProviderNotFound(providerId: string) {
+    return new Web3Error("NO_PROVIDER", `Custom Web3 provider "${providerId}" is not configured`);
+  }
+}

package/lib/index.ts

@@ -0,0 +1,20 @@
+export {
+  web3Service,
+  ALL_BUILTIN_WALLET_SLOTS,
+} from "./web3.service";
+export type {
+  Web3Config,
+  Web3CustomProviderConfig,
+  Web3CustomProviderFactory,
+  Web3CustomProviderOption,
+} from "./web3.service";
+export type {
+  Web3BuiltinWallet,
+  Web3CustomWallet,
+  Web3WalletSlot,
+  Web3WalletTarget,
+} from "./web3-wallet";
+export { isBuiltinWallet, isCustomWallet } from "./web3-wallet";
+
+export { Web3SignerComponent } from "./components/web3-signer/web3-signer.component";
+export { Web3SigningComponent } from "./components/web3-signing/web3-signing.component";

package/lib/providers/eip1193.provider.ts

@@ -0,0 +1,152 @@
+import type { PubKey, Web3Provider } from "../types/web3-types";
+
+export interface Eip1193Like {
+  request(args: { method: string; params?: unknown[] }): Promise<unknown>;
+  on?(event: string, listener: (...args: unknown[]) => void): void;
+  removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+
+declare global {
+  interface Window {
+    ethereum?: Eip1193Like;
+  }
+}
+
+function toHexMessage(message: string | Uint8Array) {
+  const bytes = message instanceof Uint8Array ? message : new TextEncoder().encode(message);
+  let hex = "0x";
+
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+
+  return hex;
+}
+
+function normalizeAddress(address: string) {
+  return address.toLowerCase();
+}
+
+export function getInjectedEthereum() {
+  return globalThis.window?.ethereum ?? null;
+}
+
+export class Eip1193Provider implements Web3Provider {
+  readonly id = "eip1193";
+
+  private account: string | null = null;
+  private onAccountsChanged: ((accounts: unknown) => void) | null = null;
+
+  constructor(
+    private ethereum: Eip1193Like,
+    private onAccountChange?: (pubKey: PubKey) => void
+  ) {}
+
+  static fromInjected(onAccountChange?: (pubKey: PubKey) => void) {
+    const ethereum = getInjectedEthereum();
+
+    if (!ethereum) {
+      throw new Error("No injected EIP-1193 wallet found (MetaMask and others)");
+    }
+
+    return new Eip1193Provider(ethereum, onAccountChange);
+  }
+
+  static fromEthereum(ethereum: Eip1193Like, onAccountChange?: (pubKey: PubKey) => void) {
+    return new Eip1193Provider(ethereum, onAccountChange);
+  }
+
+  async connect() {
+    const accounts = await this.requestAccounts();
+    const account = accounts[0];
+
+    if (!account) {
+      throw new Error("Wallet returned no accounts");
+    }
+
+    this.account = normalizeAddress(account);
+    this.watchAccounts();
+
+    return this.toPubKey(this.account);
+  }
+
+  async disconnect() {
+    this.unwatchAccounts();
+    this.account = null;
+  }
+
+  async signMessage(message: string | Uint8Array) {
+    const account = await this.getAccount();
+
+    const signature = await this.ethereum.request({
+      method: "personal_sign",
+      params: [toHexMessage(message), account],
+    });
+
+    if (typeof signature !== "string" || !signature.length) {
+      throw new Error("Wallet returned an invalid signature");
+    }
+
+    return signature.startsWith("0x") ? signature : `0x${signature}`;
+  }
+
+  getAccount() {
+    if (this.account) return Promise.resolve(this.account);
+
+    return this.requestAccounts().then((accounts) => {
+      const account = accounts[0];
+
+      if (!account) {
+        throw new Error("Wallet is not connected");
+      }
+
+      this.account = normalizeAddress(account);
+      this.watchAccounts();
+
+      return this.account;
+    });
+  }
+
+  private async requestAccounts() {
+    const accounts = await this.ethereum.request({
+      method: "eth_requestAccounts",
+    });
+
+    if (!Array.isArray(accounts)) {
+      throw new Error("Wallet returned an invalid accounts list");
+    }
+
+    return accounts.filter((account): account is string => typeof account === "string");
+  }
+
+  private toPubKey(address: string): PubKey {
+    return {
+      type: "secp256k1",
+      value: address,
+      encoding: "hex",
+    };
+  }
+
+  private watchAccounts() {
+    if (!this.ethereum.on || this.onAccountsChanged) return;
+
+    this.onAccountsChanged = (accounts: unknown) => {
+      if (!Array.isArray(accounts) || typeof accounts[0] !== "string") {
+        this.account = null;
+        return;
+      }
+
+      this.account = normalizeAddress(accounts[0]);
+      this.onAccountChange?.(this.toPubKey(this.account));
+    };
+
+    this.ethereum.on("accountsChanged", this.onAccountsChanged);
+  }
+
+  private unwatchAccounts() {
+    if (!this.onAccountsChanged || !this.ethereum.removeListener) return;
+
+    this.ethereum.removeListener("accountsChanged", this.onAccountsChanged);
+    this.onAccountsChanged = null;
+  }
+}

package/lib/providers/injected.ts

@@ -0,0 +1,71 @@
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { Eip1193Provider, getInjectedEthereum } from "./eip1193.provider";
+import { SolanaProvider, getInjectedSolana } from "./solana.provider";
+import { TonConnectProvider, getInjectedTonBridgeKey, hasInjectedTonWallet } from "./tonconnect.provider";
+import { TronProvider, getInjectedTronLink } from "./tron.provider";
+
+export type InjectedWalletKind = "ethereum" | "solana" | "tron" | "ton";
+
+export type InjectedProviderOptions = {
+  tonManifestUrl?: string;
+};
+
+const WALLET_LABELS: Record<InjectedWalletKind, string> = {
+  ethereum: "Ethereum (MetaMask and EIP-1193 wallets)",
+  solana: "Solana (Phantom and other Solana wallets)",
+  tron: "Tron (TronLink)",
+  ton: "TON (Tonkeeper and other TON wallets)",
+};
+
+export function getInjectedWalletLabel(kind: InjectedWalletKind) {
+  return WALLET_LABELS[kind];
+}
+
+export function hasInjectedWallet(kind: InjectedWalletKind) {
+  switch (kind) {
+    case "ethereum":
+      return !!getInjectedEthereum();
+    case "solana":
+      return !!getInjectedSolana();
+    case "tron":
+      return !!getInjectedTronLink();
+    case "ton":
+      return hasInjectedTonWallet();
+  }
+}
+
+export function detectInjectedWallets() {
+  const kinds: InjectedWalletKind[] = ["ethereum", "solana", "tron", "ton"];
+  return kinds.filter(hasInjectedWallet);
+}
+
+export function createInjectedProvider(
+  kind: InjectedWalletKind,
+  onAccountChange?: (pubKey: PubKey) => void,
+  options: InjectedProviderOptions = {},
+) {
+  switch (kind) {
+    case "ethereum":
+      return Eip1193Provider.fromInjected(onAccountChange);
+    case "solana":
+      return SolanaProvider.fromInjected(onAccountChange);
+    case "tron":
+      return TronProvider.fromInjected(onAccountChange);
+    case "ton": {
+      const manifestUrl = options.tonManifestUrl;
+
+      if (!manifestUrl) {
+        throw new Error("TON wallet requires tonManifestUrl (Ton Connect manifest)");
+      }
+
+      return TonConnectProvider.create(
+        { manifestUrl, transport: "extension", jsBridgeKey: getInjectedTonBridgeKey() ?? undefined },
+        onAccountChange,
+      );
+    }
+  }
+}
+
+export function asWeb3Provider(provider: Web3Provider) {
+  return provider;
+}

package/lib/providers/message-bytes.ts

@@ -0,0 +1,13 @@
+export function toMessageBytes(message: string | Uint8Array) {
+  return message instanceof Uint8Array ? message : new TextEncoder().encode(message);
+}
+
+export function bytesToBase64(bytes: Uint8Array) {
+  let binary = "";
+
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+
+  return btoa(binary);
+}

package/lib/providers/solana.provider.ts

@@ -0,0 +1,116 @@
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { bytesToBase64, toMessageBytes } from "./message-bytes";
+
+export interface SolanaPublicKey {
+  toBase58(): string;
+}
+
+export interface SolanaWallet {
+  isPhantom?: boolean;
+  isConnected?: boolean;
+  publicKey?: SolanaPublicKey | null;
+  connect(): Promise<{ publicKey: SolanaPublicKey }>;
+  disconnect(): Promise<void>;
+  signMessage(
+    message: Uint8Array,
+    display?: "utf8" | "hex",
+  ): Promise<{ signature: Uint8Array }>;
+  on?(event: "accountChanged", listener: (publicKey: SolanaPublicKey | null) => void): void;
+  removeListener?(
+    event: "accountChanged",
+    listener: (publicKey: SolanaPublicKey | null) => void,
+  ): void;
+}
+
+declare global {
+  interface Window {
+    solana?: SolanaWallet;
+    phantom?: { solana?: SolanaWallet };
+  }
+}
+
+export function getInjectedSolana() {
+  return globalThis.window?.phantom?.solana ?? globalThis.window?.solana ?? null;
+}
+
+export class SolanaProvider implements Web3Provider {
+  readonly id = "solana";
+
+  private accountListener: ((publicKey: SolanaPublicKey | null) => void) | null = null;
+
+  constructor(
+    private wallet: SolanaWallet,
+    private onAccountChange?: (pubKey: PubKey) => void,
+  ) {}
+
+  static fromInjected(onAccountChange?: (pubKey: PubKey) => void) {
+    const wallet = getInjectedSolana();
+
+    if (!wallet) {
+      throw new Error("No injected Solana wallet found (install Phantom or another Solana wallet)");
+    }
+
+    return new SolanaProvider(wallet, onAccountChange);
+  }
+
+  async connect() {
+    const { publicKey } = await this.wallet.connect();
+    this.watchAccount();
+    return this.toPubKey(publicKey);
+  }
+
+  async disconnect() {
+    this.unwatchAccount();
+    await this.wallet.disconnect();
+  }
+
+  async signMessage(message: string | Uint8Array) {
+    const publicKey = await this.requirePublicKey();
+    const bytes = toMessageBytes(message);
+
+    const { signature } = await this.wallet.signMessage(bytes, "utf8");
+
+    if (!(signature instanceof Uint8Array) || !signature.length) {
+      throw new Error("Wallet returned an invalid signature");
+    }
+
+    if (publicKey.toBase58() !== (this.wallet.publicKey?.toBase58() ?? "")) {
+      throw new Error("Connected Solana wallet account changed before signing");
+    }
+
+    return bytesToBase64(signature);
+  }
+
+  private async requirePublicKey() {
+    if (this.wallet.publicKey) return this.wallet.publicKey;
+
+    const { publicKey } = await this.wallet.connect();
+    return publicKey;
+  }
+
+  private toPubKey(publicKey: SolanaPublicKey): PubKey {
+    return {
+      type: "Ed25519",
+      value: publicKey.toBase58(),
+      encoding: "base58",
+    };
+  }
+
+  private watchAccount() {
+    if (!this.wallet.on || this.accountListener) return;
+
+    this.accountListener = (publicKey) => {
+      if (!publicKey) return;
+      this.onAccountChange?.(this.toPubKey(publicKey));
+    };
+
+    this.wallet.on("accountChanged", this.accountListener);
+  }
+
+  private unwatchAccount() {
+    if (!this.accountListener || !this.wallet.removeListener) return;
+
+    this.wallet.removeListener("accountChanged", this.accountListener);
+    this.accountListener = null;
+  }
+}

package/lib/providers/tonconnect.provider.ts

@@ -0,0 +1,161 @@
+import { TonConnect } from "@tonconnect/sdk";
+import { TonConnectUI } from "@tonconnect/ui";
+import type { Account } from "@tonconnect/sdk";
+
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { toMessageBytes } from "./message-bytes";
+import type { WalletTransport } from "./wallet-transport";
+
+export type TonConnectProviderConfig = {
+  manifestUrl: string;
+  transport?: WalletTransport;
+  jsBridgeKey?: string;
+};
+
+const INJECTED_TON_WALLETS = ["tonkeeper", "mytonwallet", "tonhub"] as const;
+
+export function getInjectedTonBridgeKey() {
+  for (const key of INJECTED_TON_WALLETS) {
+    if (TonConnect.isWalletInjected(key)) return key;
+  }
+
+  return null;
+}
+
+export function hasInjectedTonWallet() {
+  return !!getInjectedTonBridgeKey();
+}
+
+export class TonConnectProvider implements Web3Provider {
+  readonly id = "tonconnect";
+
+  private ui: TonConnectUI;
+  private unsubscribeStatus: (() => void) | null = null;
+
+  constructor(
+    private config: TonConnectProviderConfig,
+    private onAccountChange?: (pubKey: PubKey) => void,
+  ) {
+    this.ui = new TonConnectUI({ manifestUrl: config.manifestUrl });
+    this.watchStatus();
+  }
+
+  static create(
+    config: TonConnectProviderConfig,
+    onAccountChange?: (pubKey: PubKey) => void,
+  ) {
+    return new TonConnectProvider(config, onAccountChange);
+  }
+
+  async connect() {
+    await this.ui.connectionRestored;
+
+    if (this.ui.account) {
+      const pubKey = this.toPubKey(this.ui.account);
+      this.onAccountChange?.(pubKey);
+      return pubKey;
+    }
+
+    const transport = this.resolveTransport();
+
+    if (transport === "extension") {
+      const jsBridgeKey = this.config.jsBridgeKey ?? getInjectedTonBridgeKey();
+
+      if (!jsBridgeKey) {
+        throw new Error("No injected TON wallet found (install Tonkeeper or another TON wallet)");
+      }
+
+      return this.waitForAccount(() => {
+        void this.ui.connector.connect({ jsBridgeKey });
+      });
+    }
+
+    return this.waitForAccount(() => {
+      void this.ui.openModal();
+    });
+  }
+
+  async disconnect() {
+    await this.ui.disconnect();
+  }
+
+  async signMessage(message: string | Uint8Array) {
+    const account = this.requireAccount();
+    const text = new TextDecoder().decode(toMessageBytes(message));
+
+    const response = await this.ui.signData({
+      type: "text",
+      text,
+      from: account.address,
+    });
+
+    if (!response.signature) {
+      throw new Error("Wallet returned an invalid signature");
+    }
+
+    return response.signature;
+  }
+
+  private resolveTransport(): WalletTransport {
+    const transport = this.config.transport ?? "auto";
+
+    if (transport !== "auto") return transport;
+
+    return getInjectedTonBridgeKey() ? "extension" : "app";
+  }
+
+  private requireAccount() {
+    const account = this.ui.account;
+
+    if (!account) {
+      throw new Error("TON wallet is not connected");
+    }
+
+    return account;
+  }
+
+  private waitForAccount(start: () => void) {
+    return new Promise<PubKey>((resolve, reject) => {
+      const unsubscribe = this.ui.onStatusChange(
+        (wallet) => {
+          if (!wallet?.account) return;
+
+          unsubscribe();
+          const pubKey = this.toPubKey(wallet.account);
+          this.onAccountChange?.(pubKey);
+          resolve(pubKey);
+        },
+        (error) => {
+          unsubscribe();
+          reject(error);
+        },
+      );
+
+      try {
+        start();
+      } catch (error) {
+        unsubscribe();
+        reject(error);
+      }
+    });
+  }
+
+  private toPubKey(account: Account): PubKey {
+    if (!account.publicKey) {
+      throw new Error("TON wallet did not return a public key");
+    }
+
+    return {
+      type: "Ed25519",
+      value: account.publicKey,
+      encoding: "hex",
+    };
+  }
+
+  private watchStatus() {
+    this.unsubscribeStatus = this.ui.onStatusChange((wallet) => {
+      if (!wallet?.account) return;
+      this.onAccountChange?.(this.toPubKey(wallet.account));
+    });
+  }
+}