@hfunlabs/hypurr-connect 0.1.11 → 0.1.12

package/src/HypurrConnectProvider.tsx

@@ -4,8 +4,8 @@ import {
   type IRequestTransport,
 } from "@hfunlabs/hyperliquid";
 import {
-  PrivateKeySigner,
   signUserSignedAction,
+  type AbstractViemLocalAccount,
 } from "@hfunlabs/hyperliquid/signing";
 import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 import type { TelegramUserResponse } from "hypurr-grpc/ts/hypurr/telegram/telegram_service";
@@ -36,9 +36,12 @@ import {
 } from "./agent";
 import { createStaticClient, createTelegramClient } from "./grpc";
 import { GrpcExchangeTransport } from "./GrpcExchangeTransport";
+import { PrivateKeySigner } from "./privateKeySigner";
 import type {
   AuthMethod,
   EoaSigner,
+  EvmTransactionRequest,
+  Hex,
   HypurrConnectConfig,
   HypurrConnectState,
   HypurrUser,
@@ -59,6 +62,8 @@ const TELEGRAM_AUTH_STATE_KEY = "hypurr-connect-auth-state";
 const TELEGRAM_AUTH_MESSAGE = "hypurr-connect:telegram-auth";
 const DEFAULT_AUTH_HUB_URL = "https://auth.hypurr.fun/login";
 const DEFAULT_MEDIA_URL = "https://media.hypurr.fun";
+const IGNORED_EXTERNAL_SIGNATURE =
+  "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001b" as const;
 const DEFAULT_TELEGRAM_SCOPES = [
   "telegram:user:read",
   "telegram:wallet:read",
@@ -68,8 +73,20 @@ const DEFAULT_TELEGRAM_SCOPES = [
   "telegram:cabal:read",
   "telegram:cabal:write",
   "telegram:agent:write",
+  "telegram:support:read",
+  "telegram:support:write",
 ];
 
+function createExternalSigningWallet(address: Hex): AbstractViemLocalAccount {
+  return {
+    address,
+    signTypedData(params) {
+      void params;
+      return Promise.resolve(IGNORED_EXTERNAL_SIGNATURE);
+    },
+  };
+}
+
 function isInvalidTelegramAuthError(err: unknown): boolean {
   const msg =
     err instanceof Error
@@ -86,6 +103,60 @@ function normalizeMediaUrl(mediaUrl?: string): string {
   return (mediaUrl?.trim() || DEFAULT_MEDIA_URL).replace(/\/+$/, "");
 }
 
+function isAddress(value?: string | null): value is Hex {
+  return !!value && /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+
+function getRawSignedTransaction(result: unknown): Hex | null {
+  if (typeof result === "string" && result.startsWith("0x")) {
+    return result as Hex;
+  }
+  if (!result || typeof result !== "object") return null;
+
+  const record = result as Record<string, unknown>;
+  const candidates = [
+    record.raw,
+    record.rawTransaction,
+    record.signedTransaction,
+    record.serializedTransaction,
+    record.result,
+  ];
+  const raw = candidates.find(
+    (value): value is string =>
+      typeof value === "string" && value.startsWith("0x"),
+  );
+  return raw ? (raw as Hex) : null;
+}
+
+function decodeJsonBytes(bytes: Uint8Array): unknown {
+  const text = new TextDecoder().decode(bytes);
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function encodeJsonBytes(value: unknown): Uint8Array {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+
+function withExpectedFrom(
+  transaction: EvmTransactionRequest,
+  address: Hex,
+): EvmTransactionRequest {
+  if (
+    transaction.from &&
+    transaction.from.toLowerCase() !== address.toLowerCase()
+  ) {
+    throw new Error(
+      "[HypurrConnect] EVM transaction `from` does not match the connected wallet.",
+    );
+  }
+  return transaction.from ? transaction : { ...transaction, from: address };
+}
+
 function currentReturnTo(): string {
   const url = new URL(window.location.href);
   for (const param of [
@@ -113,9 +184,7 @@ function normalizeScopes(scope?: string | string[]): string {
   return scope?.trim() || DEFAULT_TELEGRAM_SCOPES.join(" ");
 }
 
-function isTelegramAuthMessage(
-  data: unknown,
-): data is {
+function isTelegramAuthMessage(data: unknown): data is {
   type: typeof TELEGRAM_AUTH_MESSAGE;
   token: string;
   state: string;
@@ -463,7 +532,7 @@ export function HypurrConnectProvider({
   ]);
 
   // ── Exchange client ──────────────────────────────────────────
-  // Telegram: GrpcExchangeTransport → HyperliquidCoreAction (server signs)
+  // Telegram: dummy local wallet → GrpcExchangeTransport → HyperliquidCoreAction (server signs)
   // EOA: dual wallet — agent key for L1 actions, master signer for user-signed
   //   actions (transfers, withdrawals, etc.). The dual wallet inspects the
   //   EIP-712 domain name to decide which key signs each request.
@@ -509,8 +578,7 @@ export function HypurrConnectProvider({
       });
       return new ExchangeClient({
         transport,
-        externalSigning: true,
-        userAddress: user.address as `0x${string}`,
+        wallet: createExternalSigningWallet(user.address as Hex),
       });
     }
 
@@ -530,8 +598,7 @@ export function HypurrConnectProvider({
         };
         return new ExchangeClient({
           transport: noAgentTransport,
-          externalSigning: true,
-          userAddress: eoaAddress,
+          wallet: createExternalSigningWallet(eoaAddress),
         });
       }
 
@@ -671,20 +738,9 @@ export function HypurrConnectProvider({
       // Dual wallet: routes signing based on the EIP-712 domain.
       // "Exchange" domain → L1 action → agent key signs (auto-provisions if needed).
       // "HyperliquidSignTransaction" domain → user-signed → master wallet (popup).
-      const dualWallet = {
+      const dualWallet: AbstractViemLocalAccount = {
         address: ownerAddress,
-        async signTypedData(params: {
-          domain: {
-            name?: string;
-            version?: string;
-            chainId?: number;
-            verifyingContract?: `0x${string}`;
-            salt?: `0x${string}`;
-          };
-          types: Record<string, { name: string; type: string }[]>;
-          primaryType: string;
-          message: Record<string, unknown>;
-        }): Promise<`0x${string}`> {
+        async signTypedData(params): Promise<`0x${string}`> {
           if (params.domain.name === "HyperliquidSignTransaction") {
             const signer = signerRef.current;
             if (!signer) {
@@ -731,6 +787,95 @@ export function HypurrConnectProvider({
     }
   }, [eoaAddress]);
 
+  const signEvmTransaction = useCallback(
+    async (transaction: EvmTransactionRequest): Promise<Hex> => {
+      if (authMethod === "eoa") {
+        if (!eoaAddress) {
+          throw new Error("[HypurrConnect] No EOA wallet connected.");
+        }
+
+        const signer = eoaSignerRef.current;
+        if (!signer) {
+          throw new Error(
+            "[HypurrConnect] No EOA signer available. Pass a signer to connectEoa(address, signer).",
+          );
+        }
+
+        const tx = withExpectedFrom(transaction, eoaAddress);
+        const result = signer.signTransaction
+          ? await signer.signTransaction(tx)
+          : signer.request
+            ? await signer.request({
+                method: "eth_signTransaction",
+                params: [tx],
+              })
+            : null;
+        const rawTransaction = getRawSignedTransaction(result);
+        if (!rawTransaction) {
+          throw new Error(
+            "[HypurrConnect] EOA signer did not return a raw transaction.",
+          );
+        }
+        return rawTransaction;
+      }
+
+      if (authMethod === "telegram") {
+        if (!telegramRpcOptions) {
+          throw new Error("[HypurrConnect] No Telegram RPC session available.");
+        }
+        if (!selectedWallet) {
+          throw new Error("[HypurrConnect] No Telegram wallet selected.");
+        }
+        if (
+          selectedWallet.id <= 0 ||
+          selectedWallet.isReadOnly ||
+          selectedWallet.isAgent
+        ) {
+          throw new Error(
+            "[HypurrConnect] Select a Telegram private-key wallet to sign EVM transactions.",
+          );
+        }
+        if (!isAddress(selectedWallet.ethereumAddress)) {
+          throw new Error(
+            "[HypurrConnect] Selected Telegram wallet does not have a valid EVM address.",
+          );
+        }
+
+        const tx = withExpectedFrom(
+          transaction,
+          selectedWallet.ethereumAddress,
+        );
+        try {
+          const signResponse = await tgClient.eVMSignTransaction(
+            {
+              authData: {},
+              walletId: selectedWallet.id,
+              params: encodeJsonBytes(tx),
+            },
+            telegramRpcOptions,
+          );
+          const rawTransaction = getRawSignedTransaction(
+            decodeJsonBytes(signResponse.response.result),
+          );
+          if (!rawTransaction) {
+            throw new Error(
+              "[HypurrConnect] Telegram signer did not return a raw transaction.",
+            );
+          }
+          return rawTransaction;
+        } catch (err) {
+          if (isInvalidTelegramAuthError(err)) {
+            onInvalidAuthRef.current?.();
+          }
+          throw err;
+        }
+      }
+
+      throw new Error("[HypurrConnect] No wallet connected.");
+    },
+    [authMethod, eoaAddress, selectedWallet, telegramRpcOptions, tgClient],
+  );
+
   // ── Wallet management (Telegram only) ───────────────────────
   const createWallet = useCallback(
     async (name: string): Promise<HyperliquidWallet> => {
@@ -1058,7 +1203,13 @@ export function HypurrConnectProvider({
         );
       }
 
-      eoaSignerRef.current = { signTypedData: signTypedDataAsync, chainId };
+      const currentSigner = eoaSignerRef.current;
+      eoaSignerRef.current = {
+        signTypedData: signTypedDataAsync,
+        signTransaction: currentSigner?.signTransaction,
+        request: currentSigner?.request,
+        chainId,
+      };
 
       setEoaLoading(true);
       setEoaError(null);
@@ -1203,6 +1354,7 @@ export function HypurrConnectProvider({
 
       loginTelegram,
       connectEoa,
+      signEvmTransaction,
       approveAgent: approveAgentFn,
       logout,
 
@@ -1249,6 +1401,7 @@ export function HypurrConnectProvider({
       closeLoginModal,
       loginTelegram,
       connectEoa,
+      signEvmTransaction,
       approveAgentFn,
       logout,
       agent,

package/src/agent.ts

@@ -1,4 +1,5 @@
 import type { StoredAgent } from "./types";
+import { PrivateKeySigner } from "./privateKeySigner";
 
 export const AGENT_NAME = "hypurr-connect";
 
@@ -27,7 +28,7 @@ export function clearAgent(masterAddress: string): void {
 
 /**
  * Generate a random 32-byte private key and derive its address using the
- * SDK's PrivateKeySigner (no viem dependency needed).
+ * local PrivateKeySigner compatibility wrapper.
  */
 export async function generateAgentKey(): Promise<{
   privateKey: `0x${string}`;
@@ -39,7 +40,6 @@ export async function generateAgentKey(): Promise<{
     .join("");
   const privateKey = `0x${hex}` as `0x${string}`;
 
-  const { PrivateKeySigner } = await import("@hfunlabs/hyperliquid/signing");
   const signer = new PrivateKeySigner(privateKey);
   return { privateKey, address: signer.address };
 }

package/src/index.ts

@@ -7,14 +7,21 @@ export type { LoginModalProps } from "./LoginModal";
 export { GrpcExchangeTransport } from "./GrpcExchangeTransport";
 export type { GrpcExchangeTransportConfig } from "./GrpcExchangeTransport";
 export { createTelegramClient, createStaticClient } from "./grpc";
+export { PrivateKeySigner } from "./privateKeySigner";
 export { createEoaSigner } from "./types";
 export type {
   AuthMethod,
+  EoaSignerOptions,
+  EoaSignTransactionFn,
   EoaSigner,
+  EvmRequestFn,
+  EvmTransactionRequest,
+  Hex,
   HypurrConnectConfig,
   HypurrConnectState,
   HypurrUser,
   ScaleCreateParams,
+  SignEvmTransactionFn,
   SignTypedDataFn,
   StoredAgent,
   TelegramLoginData,

package/src/privateKeySigner.ts

@@ -0,0 +1,32 @@
+import type { AbstractViemLocalAccount } from "@hfunlabs/hyperliquid/signing";
+import { privateKeyToAccount, type PrivateKeyAccount } from "viem/accounts";
+import type { Hex } from "./types";
+
+type SignTypedDataParams = Parameters<
+  AbstractViemLocalAccount["signTypedData"]
+>[0];
+
+/**
+ * Compatibility wrapper for SDK versions that removed PrivateKeySigner.
+ *
+ * It exposes the viem local-account shape accepted by the Hyperliquid SDK.
+ */
+export class PrivateKeySigner implements AbstractViemLocalAccount {
+  #account: PrivateKeyAccount;
+  readonly address: Hex;
+
+  constructor(privateKey: string) {
+    this.#account = privateKeyToAccount(normalizePrivateKey(privateKey));
+    this.address = this.#account.address;
+  }
+
+  signTypedData(params: SignTypedDataParams): Promise<Hex> {
+    return this.#account.signTypedData(
+      params as Parameters<PrivateKeyAccount["signTypedData"]>[0],
+    );
+  }
+}
+
+function normalizePrivateKey(privateKey: string): Hex {
+  return (privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`) as Hex;
+}

package/src/types.ts

@@ -86,12 +86,52 @@ export type SignTypedDataFn = (params: {
   message: Record<string, unknown>;
 }) => Promise<`0x${string}`>;
 
+export type Hex = `0x${string}`;
+
+export interface EvmTransactionRequest {
+  from?: Hex;
+  to?: Hex;
+  gas?: Hex;
+  gasPrice?: Hex;
+  value?: Hex;
+  data?: Hex;
+  nonce?: Hex;
+  chainId?: Hex;
+  maxFeePerGas?: Hex;
+  maxPriorityFeePerGas?: Hex;
+  type?: Hex;
+  accessList?: unknown;
+  [key: string]: unknown;
+}
+
+export type EvmRequestFn = (args: {
+  method: string;
+  params?: unknown[];
+}) => Promise<unknown>;
+
+export type SignEvmTransactionFn = (
+  transaction: EvmTransactionRequest,
+) => Promise<Hex>;
+
+export type EoaSignTransactionFn = (
+  transaction: EvmTransactionRequest,
+) => Promise<unknown>;
+
 /** Wallet signer provided at EOA connect time for user-signed actions. */
 export interface EoaSigner {
   signTypedData: SignTypedDataFn;
+  /** Optional raw EVM transaction signer. Used by `signEvmTransaction()` in EOA mode. */
+  signTransaction?: EoaSignTransactionFn;
+  /** Optional EIP-1193 provider request function. Used as a fallback for `eth_signTransaction`. */
+  request?: EvmRequestFn;
   chainId: number;
 }
 
+export interface EoaSignerOptions {
+  signTransaction?: EoaSignTransactionFn;
+  request?: EvmRequestFn;
+}
+
 /**
  * Create an {@link EoaSigner} from any EIP-712 signing function.
  *
@@ -120,6 +160,7 @@ export function createEoaSigner(
     | ((args: Record<string, unknown>) => Promise<`0x${string}`>)
     | { current: (args: Record<string, unknown>) => Promise<`0x${string}`> },
   chainId: number,
+  options: EoaSignerOptions = {},
 ): EoaSigner {
   const resolve =
     typeof signTypedDataAsync === "function"
@@ -127,6 +168,8 @@ export function createEoaSigner(
       : (args: Record<string, unknown>) => signTypedDataAsync.current(args);
   return {
     signTypedData: (params) => resolve(params),
+    signTransaction: options.signTransaction,
+    request: options.request,
     chainId,
   };
 }
@@ -216,6 +259,7 @@ export interface HypurrConnectState {
 
   // Auth actions
   connectEoa: (address: `0x${string}`, signer?: EoaSigner) => void;
+  signEvmTransaction: SignEvmTransactionFn;
   approveAgent: (
     signTypedDataAsync: SignTypedDataFn,
     chainId: number,