cruzo-web3 0.1.0

package/lib/providers/tron.provider.ts

@@ -0,0 +1,142 @@
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { toMessageBytes } from "./message-bytes";
+
+export interface TronWeb {
+  ready?: boolean;
+  defaultAddress?: { base58: string };
+  request?(args: { method: string; params?: unknown }): Promise<unknown>;
+  trx?: {
+    signMessageV2(message: string): Promise<string>;
+  };
+  toHex?(value: string): string;
+}
+
+export interface TronLink {
+  ready?: boolean;
+  tronWeb?: TronWeb;
+  request(args: { method: string; params?: unknown }): Promise<unknown>;
+}
+
+declare global {
+  interface Window {
+    tronWeb?: TronWeb;
+    tronLink?: TronLink;
+  }
+}
+
+function toHexMessage(message: string | Uint8Array, tronWeb?: TronWeb) {
+  const text = message instanceof Uint8Array
+    ? new TextDecoder().decode(message)
+    : message;
+
+  if (tronWeb?.toHex) return tronWeb.toHex(text);
+
+  const bytes = toMessageBytes(message);
+  let hex = "";
+
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+
+  return hex;
+}
+
+export function getInjectedTronLink() {
+  return globalThis.window?.tronLink ?? null;
+}
+
+export function getInjectedTronWeb() {
+  return globalThis.window?.tronWeb ?? globalThis.window?.tronLink?.tronWeb ?? null;
+}
+
+export class TronProvider implements Web3Provider {
+  readonly id = "tron";
+
+  constructor(
+    private tronLink: TronLink,
+    private onAccountChange?: (pubKey: PubKey) => void,
+  ) {}
+
+  static fromInjected(onAccountChange?: (pubKey: PubKey) => void) {
+    const tronLink = getInjectedTronLink();
+
+    if (!tronLink) {
+      throw new Error("No injected Tron wallet found (install TronLink)");
+    }
+
+    return new TronProvider(tronLink, onAccountChange);
+  }
+
+  async connect() {
+    await this.requestAccounts();
+    const address = this.readAddress();
+    this.onAccountChange?.(this.toPubKey(address));
+    return this.toPubKey(address);
+  }
+
+  async disconnect() {
+    // TronLink does not expose a standard disconnect for dApps.
+  }
+
+  async signMessage(message: string | Uint8Array) {
+    const tronWeb = await this.requireTronWeb();
+    const signMessage = tronWeb.trx?.signMessageV2;
+
+    if (!signMessage) {
+      throw new Error("Tron wallet does not support signMessageV2");
+    }
+
+    const address = this.readAddress();
+    const signature = await signMessage.call(tronWeb.trx, toHexMessage(message, tronWeb));
+
+    if (typeof signature !== "string" || !signature.length) {
+      throw new Error("Wallet returned an invalid signature");
+    }
+
+    if (this.readAddress() !== address) {
+      throw new Error("Connected Tron wallet account changed before signing");
+    }
+
+    return signature.startsWith("0x") ? signature : signature;
+  }
+
+  private async requestAccounts() {
+    const response = await this.tronLink.request({ method: "tron_requestAccounts" });
+
+    if (response && typeof response === "object" && "code" in response) {
+      const result = response as { code: number; message?: string };
+
+      if (result.code !== 200) {
+        throw new Error(result.message || "Tron wallet rejected the connection request");
+      }
+    }
+  }
+
+  private async requireTronWeb() {
+    const tronWeb = getInjectedTronWeb();
+
+    if (!tronWeb?.trx) {
+      throw new Error("Tron wallet is not ready");
+    }
+
+    return tronWeb;
+  }
+
+  private readAddress() {
+    const address = getInjectedTronWeb()?.defaultAddress?.base58;
+
+    if (!address) {
+      throw new Error("Tron wallet is not connected");
+    }
+
+    return address;
+  }
+
+  private toPubKey(address: string): PubKey {
+    return {
+      type: "secp256k1",
+      value: address,
+      encoding: "base58",
+    };
+  }
+}

package/lib/providers/wallet-transport.ts

@@ -0,0 +1 @@
+export type WalletTransport = "extension" | "app" | "auto";

package/lib/providers/wallet.ts

@@ -0,0 +1,92 @@
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { Eip1193Provider, getInjectedEthereum } from "./eip1193.provider";
+import { createInjectedProvider, hasInjectedWallet, type InjectedWalletKind } from "./injected";
+import { SolanaProvider } from "./solana.provider";
+import { TonConnectProvider } from "./tonconnect.provider";
+import { TronProvider } from "./tron.provider";
+import { WalletConnectEthereumProvider } from "./walletconnect-ethereum.provider";
+import type { WalletTransport } from "./wallet-transport";
+
+export type { WalletTransport } from "./wallet-transport";
+
+export type WalletProviderOptions = {
+  tonManifestUrl?: string;
+  walletConnectProjectId?: string;
+};
+
+export type WalletKind = InjectedWalletKind;
+
+function resolveTransport(kind: WalletKind, transport: WalletTransport): WalletTransport {
+  if (transport !== "auto") return transport;
+
+  if (kind === "ethereum") {
+    return getInjectedEthereum() ? "extension" : "app";
+  }
+
+  if (kind === "ton") {
+    return hasInjectedWallet("ton") ? "extension" : "app";
+  }
+
+  return hasInjectedWallet(kind) ? "extension" : "extension";
+}
+
+export async function createWalletProvider(
+  kind: WalletKind,
+  transport: WalletTransport,
+  onAccountChange?: (pubKey: PubKey) => void,
+  options: WalletProviderOptions = {},
+): Promise<Web3Provider> {
+  const resolved = resolveTransport(kind, transport);
+
+  if (kind === "ethereum" && resolved === "app") {
+    const projectId = options.walletConnectProjectId;
+
+    if (!projectId) {
+      throw new Error("Ethereum mobile wallet requires walletConnectProjectId");
+    }
+
+    return WalletConnectEthereumProvider.create({ projectId }, onAccountChange);
+  }
+
+  if (kind === "ton") {
+    const manifestUrl = options.tonManifestUrl;
+
+    if (!manifestUrl) {
+      throw new Error("TON wallet requires tonManifestUrl (Ton Connect manifest)");
+    }
+
+    return TonConnectProvider.create(
+      { manifestUrl, transport: resolved },
+      onAccountChange,
+    );
+  }
+
+  if (resolved === "app") {
+    throw new Error(`${kind} mobile wallet is not supported yet`);
+  }
+
+  return createInjectedProvider(kind, onAccountChange, {
+    tonManifestUrl: options.tonManifestUrl,
+  });
+}
+
+export function getWalletModeLabel(kind: WalletKind, transport: WalletTransport = "auto") {
+  const resolved = resolveTransport(kind, transport);
+
+  if (kind === "ethereum") {
+    return resolved === "app"
+      ? "Ethereum app (WalletConnect)"
+      : "Ethereum extension (MetaMask and EIP-1193 wallets)";
+  }
+
+  if (kind === "ton") {
+    return resolved === "app"
+      ? "TON app (Tonkeeper and other TON wallets)"
+      : "TON extension (Tonkeeper and other TON wallets)";
+  }
+
+  if (kind === "solana") return "Solana extension (Phantom and other Solana wallets)";
+  if (kind === "tron") return "Tron extension (TronLink)";
+
+  return kind;
+}

package/lib/providers/walletconnect-ethereum.provider.ts

@@ -0,0 +1,49 @@
+import EthereumProvider from "@walletconnect/ethereum-provider";
+
+import type { PubKey, Web3Provider } from "../types/web3-types";
+import { Eip1193Provider, type Eip1193Like } from "./eip1193.provider";
+
+export type WalletConnectEthereumConfig = {
+  projectId: string;
+  chains?: number[];
+};
+
+export class WalletConnectEthereumProvider implements Web3Provider {
+  readonly id = "walletconnect";
+
+  private constructor(private inner: Eip1193Provider) {}
+
+  static async create(
+    config: WalletConnectEthereumConfig,
+    onAccountChange?: (pubKey: PubKey) => void,
+  ) {
+    const wc = await EthereumProvider.init({
+      projectId: config.projectId,
+      chains: config.chains ?? [1],
+      optionalChains: [137, 10, 42161],
+      showQrModal: true,
+      metadata: {
+        name: document.title || "cruzo-web3",
+        description: "cruzo-web3 wallet signing",
+        url: window.location.origin,
+        icons: [],
+      },
+    });
+
+    return new WalletConnectEthereumProvider(
+      Eip1193Provider.fromEthereum(wc as Eip1193Like, onAccountChange),
+    );
+  }
+
+  connect() {
+    return this.inner.connect();
+  }
+
+  disconnect() {
+    return this.inner.disconnect();
+  }
+
+  signMessage(message: string | Uint8Array) {
+    return this.inner.signMessage(message);
+  }
+}

package/lib/pub-key.ts

@@ -0,0 +1,144 @@
+import { normalizeSecp256k1Signature } from "./crypto/ecdsa-signature";
+import { decodeEncodedBytes } from "./crypto/decode-bytes";
+import { Web3Error } from "./errors/web3-error";
+import type { PubKey, PubKeyAlgorithm, PubKeyEncoding } from "./types/web3-types";
+
+const ALGORITHMS = new Set<PubKeyAlgorithm>(["secp256k1", "Ed25519", "sr25519"]);
+const ENCODINGS = new Set<PubKeyEncoding>(["hex", "base64", "base58"]);
+
+const ALGORITHM_LIST = [...ALGORITHMS].join(", ");
+const ENCODING_LIST = [...ENCODINGS].join(", ");
+
+const ENCODING_RE: Record<PubKeyEncoding, RegExp> = {
+  hex: /^[0-9a-fA-F]+$/,
+  base64: /^[A-Za-z0-9+/]+={0,2}$/,
+  base58: /^[1-9A-HJ-NP-Za-km-z]+$/,
+};
+
+type ByteCheck = (bytes: Uint8Array) => string | null;
+
+const PUBLIC_KEY_CHECKS: Record<PubKeyAlgorithm, ByteCheck> = {
+  Ed25519: (bytes) =>
+    bytes.length === 32 ? null : `Ed25519 public key must be 32 bytes, got ${bytes.length}`,
+  secp256k1: (bytes) =>
+    isSecp256k1PublicKey(bytes)
+      ? null
+      : "secp256k1 public key must be 33-byte compressed or 65-byte uncompressed",
+  sr25519: () => "sr25519 public key verification is not supported yet",
+};
+
+const SIGNATURE_CHECKS: Record<PubKeyAlgorithm, ByteCheck> = {
+  Ed25519: (bytes) =>
+    bytes.length === 64 ? null : `Ed25519 signature must be 64 bytes, got ${bytes.length}`,
+  secp256k1: (bytes) =>
+    normalizeSecp256k1Signature(bytes)
+      ? null
+      : "secp256k1 signature must be 64/65-byte raw or DER encoded",
+  sr25519: () => "sr25519 signature verification is not supported yet",
+};
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+function isSecp256k1PublicKey(bytes: Uint8Array) {
+  const compressed = bytes.length === 33 && (bytes[0] === 2 || bytes[0] === 3);
+  const uncompressed = bytes.length === 65 && bytes[0] === 4;
+  return compressed || uncompressed;
+}
+
+function readEncoding(encoding: string): PubKeyEncoding {
+  if (!ENCODINGS.has(encoding as PubKeyEncoding)) {
+    throw Web3Error.invalidPubKey(`Encoding must be one of: ${ENCODING_LIST}`);
+  }
+
+  return encoding as PubKeyEncoding;
+}
+
+function isValidEncodedValue(value: string, encoding: PubKeyEncoding) {
+  return isNonEmptyString(value) && ENCODING_RE[encoding].test(value);
+}
+
+export function isPubKey(value: unknown): value is PubKey {
+  if (!value || typeof value !== "object") return false;
+
+  const pubKey = value as PubKey;
+
+  return (
+    ALGORITHMS.has(pubKey.type) &&
+    isNonEmptyString(pubKey.value) &&
+    ENCODINGS.has(pubKey.encoding)
+  );
+}
+
+export function isValidPubKeyValue(value: string, encoding: PubKeyEncoding) {
+  return isValidEncodedValue(value, encoding);
+}
+
+export function isValidPubKey(pubKey: PubKey) {
+  return isPubKey(pubKey) && isValidPubKeyValue(pubKey.value, pubKey.encoding);
+}
+
+export function parsePubKey(value: unknown): PubKey {
+  if (!value || typeof value !== "object") {
+    throw Web3Error.invalidPubKey("PubKey must be an object");
+  }
+
+  const pubKey = value as PubKey;
+
+  if (!ALGORITHMS.has(pubKey.type)) {
+    throw Web3Error.invalidPubKey(`PubKey.type must be one of: ${ALGORITHM_LIST}`);
+  }
+
+  if (!isNonEmptyString(pubKey.value)) {
+    throw Web3Error.invalidPubKey("PubKey.value must be a non-empty string");
+  }
+
+  readEncoding(pubKey.encoding);
+
+  if (!isValidEncodedValue(pubKey.value, pubKey.encoding)) {
+    throw Web3Error.invalidPubKey(`PubKey.value is not valid ${pubKey.encoding}`);
+  }
+
+  return {
+    type: pubKey.type,
+    value: pubKey.value,
+    encoding: pubKey.encoding,
+  };
+}
+
+export function decodePubKeyBytes(pubKey: PubKey) {
+  const key = parsePubKey(pubKey);
+  const bytes = decodeEncodedBytes(key.value, key.encoding);
+
+  if (!bytes) {
+    throw Web3Error.invalidPubKey(`Cannot decode PubKey.value as ${key.encoding}`);
+  }
+
+  assertPublicKeyBytes(key.type, bytes);
+  return bytes;
+}
+
+export function decodeSignatureBytes(signature: string, encoding: PubKeyEncoding) {
+  if (!isValidEncodedValue(signature, encoding)) {
+    throw Web3Error.invalidSignature(`Signature is not valid ${encoding}`);
+  }
+
+  const bytes = decodeEncodedBytes(signature, encoding);
+
+  if (!bytes) {
+    throw Web3Error.invalidSignature(`Cannot decode signature as ${encoding}`);
+  }
+
+  return bytes;
+}
+
+export function assertPublicKeyBytes(type: PubKeyAlgorithm, bytes: Uint8Array) {
+  const message = PUBLIC_KEY_CHECKS[type](bytes);
+  if (message) throw Web3Error.invalidPubKey(message);
+}
+
+export function assertSignatureBytes(type: PubKeyAlgorithm, bytes: Uint8Array) {
+  const message = SIGNATURE_CHECKS[type](bytes);
+  if (message) throw Web3Error.invalidSignature(message);
+}