@hfunlabs/hypurr-connect 0.1.11 → 0.1.12

package/README.md

@@ -220,6 +220,24 @@ connectEoa(address); // no signer — only L1 actions after manual approval
 await approveAgent(signTypedDataAsync, chainId);
 ```
 
+### EVM Transaction Signing
+
+`signEvmTransaction(transaction)` signs a JSON-RPC-style EVM transaction and returns the raw serialized transaction. In Telegram mode it calls the `EVMSignTransaction` gRPC endpoint for the selected private-key wallet; in EOA mode it calls the `signTransaction` or EIP-1193 `request` function supplied to `connectEoa`.
+
+```tsx
+const { signEvmTransaction } = useHypurrConnect();
+
+const raw = await signEvmTransaction({
+  to: "0x0000000000000000000000000000000000000000",
+  data: "0x",
+  value: "0x0",
+  chainId: "0x66eee",
+  nonce: "0x1",
+  gas: "0x5208",
+  gasPrice: "0x3b9aca00",
+});
+```
+
 ### Using the Exchange Client
 
 Once authenticated, the `exchange` object from `useHypurrConnect()` is a fully functional `ExchangeClient` from `@hfunlabs/hyperliquid`. For EOA users with a signer, it handles **both** L1 and user-signed actions transparently:
@@ -381,6 +399,7 @@ Returns the full auth and exchange state. Throws if used outside `HypurrConnectP
 | `openLoginModal`     | `() => void`                                                              | Show the login modal                                                                       |
 | `closeLoginModal`    | `() => void`                                                              | Hide the login modal                                                                       |
 | `connectEoa`         | `(address: \`0x\${string}\`, signer?: EoaSigner) => void`                 | Connect EOA wallet (sync); pass signer to enable user-signed actions and auto-provisioning |
+| `signEvmTransaction` | `(transaction: EvmTransactionRequest) => Promise<\`0x\${string}\`>`       | Sign an EVM transaction through EOA wallet provider or Telegram RPC                        |
 | `approveAgent`       | `(signTypedDataAsync: SignTypedDataFn, chainId: number) => Promise<void>` | Approve a named agent key (async, triggers wallet prompt)                                  |
 | `logout`             | `() => void`                                                              | Clear all auth state and localStorage                                                      |
 | `agent`              | `StoredAgent \| null`                                                     | Current agent key (EOA flow only)                                                          |
@@ -473,11 +492,13 @@ Encapsulates the master wallet's EIP-712 signing function and chain ID. Pass to
 ```typescript
 interface EoaSigner {
   signTypedData: SignTypedDataFn;
+  signTransaction?: (transaction: EvmTransactionRequest) => Promise<unknown>;
+  request?: (args: { method: string; params?: unknown[] }) => Promise<unknown>;
   chainId: number;
 }
 ```
 
-#### `createEoaSigner(signTypedData, chainId): EoaSigner`
+#### `createEoaSigner(signTypedData, chainId, options?): EoaSigner`
 
 Helper to create an `EoaSigner` from wagmi's `signTypedDataAsync` (or any compatible function). Accepts either a direct function or a `{ current: Function }` ref to avoid stale closures with React hooks:
 
@@ -489,6 +510,11 @@ const signer = createEoaSigner(signerRef, chainId);
 
 // With a direct function (fine for stable references)
 const signer = createEoaSigner(signTypedDataAsync, chainId);
+
+// With an EIP-1193 provider for EVM transaction signing
+const signer = createEoaSigner(signTypedDataAsync, chainId, {
+  request: provider.request.bind(provider),
+});
 ```
 
 #### `SignTypedDataFn`

package/dist/index.d.ts

@@ -11,6 +11,7 @@ import { TelegramChatWalletPack } from 'hypurr-grpc/ts/hypurr/user';
 export { TelegramChatWalletPack } from 'hypurr-grpc/ts/hypurr/user';
 import { HyperliquidWallet } from 'hypurr-grpc/ts/hypurr/wallet';
 export { HyperliquidWallet } from 'hypurr-grpc/ts/hypurr/wallet';
+import { AbstractViemLocalAccount } from '@hfunlabs/hyperliquid/signing';
 
 interface HypurrConnectConfig {
     /** gRPC-web base URL. Defaults to https://grpc.hypurr.fun. */
@@ -73,11 +74,41 @@ type SignTypedDataFn = (params: {
     primaryType: string;
     message: Record<string, unknown>;
 }) => Promise<`0x${string}`>;
+type Hex = `0x${string}`;
+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;
+}
+type EvmRequestFn = (args: {
+    method: string;
+    params?: unknown[];
+}) => Promise<unknown>;
+type SignEvmTransactionFn = (transaction: EvmTransactionRequest) => Promise<Hex>;
+type EoaSignTransactionFn = (transaction: EvmTransactionRequest) => Promise<unknown>;
 /** Wallet signer provided at EOA connect time for user-signed actions. */
 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;
 }
+interface EoaSignerOptions {
+    signTransaction?: EoaSignTransactionFn;
+    request?: EvmRequestFn;
+}
 /**
  * Create an {@link EoaSigner} from any EIP-712 signing function.
  *
@@ -103,7 +134,7 @@ interface EoaSigner {
  */
 declare function createEoaSigner(signTypedDataAsync: ((args: Record<string, unknown>) => Promise<`0x${string}`>) | {
     current: (args: Record<string, unknown>) => Promise<`0x${string}`>;
-}, chainId: number): EoaSigner;
+}, chainId: number, options?: EoaSignerOptions): EoaSigner;
 type TwapCreateParams = Omit<HyperliquidTwapCreateRequest, "authData" | "walletId">;
 type TwapModifyParams = Omit<HyperliquidTwapModifyRequest, "authData" | "walletId">;
 type ScaleCreateParams = Omit<HyperliquidScaleCreateRequest, "authData" | "walletId">;
@@ -145,6 +176,7 @@ interface HypurrConnectState {
     openLoginModal: () => void;
     closeLoginModal: () => void;
     connectEoa: (address: `0x${string}`, signer?: EoaSigner) => void;
+    signEvmTransaction: SignEvmTransactionFn;
     approveAgent: (signTypedDataAsync: SignTypedDataFn, chainId: number) => Promise<void>;
     logout: () => void;
     agent: StoredAgent | null;
@@ -201,4 +233,17 @@ declare class GrpcExchangeTransport implements IRequestTransport {
 declare function createTelegramClient(config: HypurrConnectConfig): TelegramClient;
 declare function createStaticClient(config: HypurrConnectConfig): StaticClient;
 
-export { type AuthMethod, type EoaSigner, GrpcExchangeTransport, type GrpcExchangeTransportConfig, type HypurrConnectConfig, HypurrConnectProvider, type HypurrConnectState, type HypurrUser, LoginModal, type LoginModalProps, type ScaleCreateParams, type SignTypedDataFn, type StoredAgent, type TelegramLoginData, type TwapCreateParams, type TwapModifyParams, createEoaSigner, createStaticClient, createTelegramClient, useHypurrConnect };
+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.
+ */
+declare class PrivateKeySigner implements AbstractViemLocalAccount {
+    #private;
+    readonly address: Hex;
+    constructor(privateKey: string);
+    signTypedData(params: SignTypedDataParams): Promise<Hex>;
+}
+
+export { type AuthMethod, type EoaSignTransactionFn, type EoaSigner, type EoaSignerOptions, type EvmRequestFn, type EvmTransactionRequest, GrpcExchangeTransport, type GrpcExchangeTransportConfig, type Hex, type HypurrConnectConfig, HypurrConnectProvider, type HypurrConnectState, type HypurrUser, LoginModal, type LoginModalProps, PrivateKeySigner, type ScaleCreateParams, type SignEvmTransactionFn, type SignTypedDataFn, type StoredAgent, type TelegramLoginData, type TwapCreateParams, type TwapModifyParams, createEoaSigner, createStaticClient, createTelegramClient, useHypurrConnect };

package/dist/index.js

@@ -4,7 +4,6 @@ import {
   HttpTransport
 } from "@hfunlabs/hyperliquid";
 import {
-  PrivateKeySigner,
   signUserSignedAction
 } from "@hfunlabs/hyperliquid/signing";
 import {
@@ -17,6 +16,25 @@ import {
   useState
 } from "react";
 
+// src/privateKeySigner.ts
+import { privateKeyToAccount } from "viem/accounts";
+var PrivateKeySigner = class {
+  #account;
+  address;
+  constructor(privateKey) {
+    this.#account = privateKeyToAccount(normalizePrivateKey(privateKey));
+    this.address = this.#account.address;
+  }
+  signTypedData(params) {
+    return this.#account.signTypedData(
+      params
+    );
+  }
+};
+function normalizePrivateKey(privateKey) {
+  return privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+}
+
 // src/agent.ts
 var AGENT_NAME = "hypurr-connect";
 var AGENT_STORAGE_PREFIX = "hypurr-connect-agent";
@@ -41,8 +59,7 @@ async function generateAgentKey() {
   const bytes = crypto.getRandomValues(new Uint8Array(32));
   const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
   const privateKey = `0x${hex}`;
-  const { PrivateKeySigner: PrivateKeySigner2 } = await import("@hfunlabs/hyperliquid/signing");
-  const signer = new PrivateKeySigner2(privateKey);
+  const signer = new PrivateKeySigner(privateKey);
   return { privateKey, address: signer.address };
 }
 async function fetchActiveAgent(userAddress, isTestnet) {
@@ -188,6 +205,7 @@ var TELEGRAM_AUTH_STATE_KEY = "hypurr-connect-auth-state";
 var TELEGRAM_AUTH_MESSAGE = "hypurr-connect:telegram-auth";
 var DEFAULT_AUTH_HUB_URL = "https://auth.hypurr.fun/login";
 var DEFAULT_MEDIA_URL = "https://media.hypurr.fun";
+var IGNORED_EXTERNAL_SIGNATURE = "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001b";
 var DEFAULT_TELEGRAM_SCOPES = [
   "telegram:user:read",
   "telegram:wallet:read",
@@ -196,8 +214,19 @@ var DEFAULT_TELEGRAM_SCOPES = [
   "telegram:trade:write",
   "telegram:cabal:read",
   "telegram:cabal:write",
-  "telegram:agent:write"
+  "telegram:agent:write",
+  "telegram:support:read",
+  "telegram:support:write"
 ];
+function createExternalSigningWallet(address) {
+  return {
+    address,
+    signTypedData(params) {
+      void params;
+      return Promise.resolve(IGNORED_EXTERNAL_SIGNATURE);
+    }
+  };
+}
 function isInvalidTelegramAuthError(err) {
   const msg = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : String(err);
   return /invalid telegram auth data|invalid auth token|missing authorization token/i.test(
@@ -207,6 +236,47 @@ function isInvalidTelegramAuthError(err) {
 function normalizeMediaUrl(mediaUrl) {
   return (mediaUrl?.trim() || DEFAULT_MEDIA_URL).replace(/\/+$/, "");
 }
+function isAddress(value) {
+  return !!value && /^0x[a-fA-F0-9]{40}$/.test(value);
+}
+function getRawSignedTransaction(result) {
+  if (typeof result === "string" && result.startsWith("0x")) {
+    return result;
+  }
+  if (!result || typeof result !== "object") return null;
+  const record = result;
+  const candidates = [
+    record.raw,
+    record.rawTransaction,
+    record.signedTransaction,
+    record.serializedTransaction,
+    record.result
+  ];
+  const raw = candidates.find(
+    (value) => typeof value === "string" && value.startsWith("0x")
+  );
+  return raw ? raw : null;
+}
+function decodeJsonBytes(bytes) {
+  const text = new TextDecoder().decode(bytes);
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function encodeJsonBytes(value) {
+  return new TextEncoder().encode(JSON.stringify(value));
+}
+function withExpectedFrom(transaction, address) {
+  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() {
   const url = new URL(window.location.href);
   for (const param of [
@@ -525,8 +595,7 @@ function HypurrConnectProvider({
       });
       return new ExchangeClient({
         transport,
-        externalSigning: true,
-        userAddress: user.address
+        wallet: createExternalSigningWallet(user.address)
       });
     }
     if (authMethod === "eoa" && eoaAddress) {
@@ -542,8 +611,7 @@ function HypurrConnectProvider({
         };
         return new ExchangeClient({
           transport: noAgentTransport,
-          externalSigning: true,
-          userAddress: eoaAddress
+          wallet: createExternalSigningWallet(eoaAddress)
         });
       }
       const isTestnet = config.isTestnet ?? false;
@@ -684,6 +752,81 @@ function HypurrConnectProvider({
       setAgent(null);
     }
   }, [eoaAddress]);
+  const signEvmTransaction = useCallback(
+    async (transaction) => {
+      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]
+  );
   const createWallet = useCallback(
     async (name) => {
       const { response } = await tgClient.hyperliquidWalletCreate(
@@ -949,7 +1092,13 @@ function HypurrConnectProvider({
           "[HypurrConnect] Cannot approve agent: no EOA wallet connected. Call connectEoa(address) first."
         );
       }
-      eoaSignerRef.current = { signTypedData: signTypedDataAsync, chainId };
+      const currentSigner = eoaSignerRef.current;
+      eoaSignerRef.current = {
+        signTypedData: signTypedDataAsync,
+        signTransaction: currentSigner?.signTransaction,
+        request: currentSigner?.request,
+        chainId
+      };
       setEoaLoading(true);
       setEoaError(null);
       try {
@@ -1068,6 +1217,7 @@ function HypurrConnectProvider({
       closeLoginModal,
       loginTelegram,
       connectEoa,
+      signEvmTransaction,
       approveAgent: approveAgentFn,
       logout,
       agent,
@@ -1111,6 +1261,7 @@ function HypurrConnectProvider({
       closeLoginModal,
       loginTelegram,
       connectEoa,
+      signEvmTransaction,
       approveAgentFn,
       logout,
       agent,
@@ -1533,10 +1684,12 @@ function MobileDrawer({
 }
 
 // src/types.ts
-function createEoaSigner(signTypedDataAsync, chainId) {
+function createEoaSigner(signTypedDataAsync, chainId, options = {}) {
   const resolve = typeof signTypedDataAsync === "function" ? signTypedDataAsync : (args) => signTypedDataAsync.current(args);
   return {
     signTypedData: (params) => resolve(params),
+    signTransaction: options.signTransaction,
+    request: options.request,
     chainId
   };
 }
@@ -1544,6 +1697,7 @@ export {
   GrpcExchangeTransport,
   HypurrConnectProvider,
   LoginModal,
+  PrivateKeySigner,
   createEoaSigner,
   createStaticClient,
   createTelegramClient,