kentucky-signer-viem 0.1.4 → 0.1.5

package/dist/react/index.mjs

@@ -153,9 +153,9 @@ var KentuckySignerClient = class {
   /**
    * Sign an EVM transaction hash
    *
-   * @param request - Sign request with tx_hash and chain_id
+   * @param request - Sign request with tx_hash
    * @param token - JWT token
-   * @returns Signature response with r, s, v components
+   * @returns Signature response with r, s, v components (v is always 27 or 28)
    */
   async signEvmTransaction(request, token) {
     return this.request("/api/sign/evm", {
@@ -170,13 +170,12 @@ var KentuckySignerClient = class {
    * Convenience method that wraps signEvmTransaction.
    *
    * @param hash - 32-byte hash to sign (hex encoded with 0x prefix)
-   * @param chainId - Chain ID
    * @param token - JWT token
    * @returns Full signature (hex encoded with 0x prefix)
    */
-  async signHash(hash, chainId, token) {
+  async signHash(hash, token) {
     const response = await this.signEvmTransaction(
-      { tx_hash: hash, chain_id: chainId },
+      { tx_hash: hash },
       token
     );
     return response.signature.full;
@@ -1010,9 +1009,9 @@ var SecureKentuckySignerClient = class {
   /**
    * Sign a raw hash for EVM (signed request)
    */
-  async signHash(hash, chainId, token) {
+  async signHash(hash, token) {
     const response = await this.signEvmTransaction(
-      { tx_hash: hash, chain_id: chainId },
+      { tx_hash: hash },
       token
     );
     return response.signature.full;
@@ -1234,9 +1233,21 @@ import {
   hashMessage,
   hashTypedData,
   keccak256,
-  serializeTransaction
+  serializeTransaction,
+  toRlp,
+  concat,
+  numberToHex
 } from "viem";
 import { toAccount } from "viem/accounts";
+var EIP7702_MAGIC = "0x05";
+function hashAuthorization(params) {
+  const rlpEncoded = toRlp([
+    params.chainId === 0 ? "0x" : numberToHex(params.chainId),
+    params.contractAddress,
+    params.nonce === 0n ? "0x" : numberToHex(params.nonce)
+  ]);
+  return keccak256(concat([EIP7702_MAGIC, rlpEncoded]));
+}
 function createKentuckySignerAccount(options) {
   const { config, defaultChainId = 1, onSessionExpired, secureClient, on2FARequired } = options;
   let session = options.session;
@@ -1255,14 +1266,17 @@ function createKentuckySignerAccount(options) {
     }
     return session.token;
   }
-  async function signHash(hash, chainId) {
+  function ensureHexPrefix(value) {
+    return value.startsWith("0x") ? value : `0x${value}`;
+  }
+  async function signHash(hash) {
     const token = await getToken();
     try {
       const response = await client.signEvmTransaction(
-        { tx_hash: hash, chain_id: chainId },
+        { tx_hash: hash },
         token
       );
-      return response.signature.full;
+      return ensureHexPrefix(response.signature.full);
     } catch (err) {
       if (err instanceof KentuckySignerError && err.code === "2FA_REQUIRED" && on2FARequired) {
         const totpRequired = err.message.includes("TOTP") || (err.details?.includes("totp_code") ?? false);
@@ -1273,24 +1287,24 @@ function createKentuckySignerAccount(options) {
           throw new KentuckySignerError("2FA verification cancelled", "2FA_CANCELLED", "User cancelled 2FA input");
         }
         const response = await client.signEvmTransactionWith2FA(
-          { tx_hash: hash, chain_id: chainId, totp_code: codes.totpCode, pin: codes.pin },
+          { tx_hash: hash, totp_code: codes.totpCode, pin: codes.pin },
           token
         );
-        return response.signature.full;
+        return ensureHexPrefix(response.signature.full);
       }
       throw err;
     }
   }
-  async function signHashWithComponents(hash, chainId) {
+  async function signHashWithComponents(hash) {
     const token = await getToken();
     try {
       const response = await client.signEvmTransaction(
-        { tx_hash: hash, chain_id: chainId },
+        { tx_hash: hash },
         token
       );
       return {
-        r: response.signature.r,
-        s: response.signature.s,
+        r: ensureHexPrefix(response.signature.r),
+        s: ensureHexPrefix(response.signature.s),
         v: response.signature.v
       };
     } catch (err) {
@@ -1303,12 +1317,12 @@ function createKentuckySignerAccount(options) {
           throw new KentuckySignerError("2FA verification cancelled", "2FA_CANCELLED", "User cancelled 2FA input");
         }
         const response = await client.signEvmTransactionWith2FA(
-          { tx_hash: hash, chain_id: chainId, totp_code: codes.totpCode, pin: codes.pin },
+          { tx_hash: hash, totp_code: codes.totpCode, pin: codes.pin },
           token
         );
         return {
-          r: response.signature.r,
-          s: response.signature.s,
+          r: ensureHexPrefix(response.signature.r),
+          s: ensureHexPrefix(response.signature.s),
           v: response.signature.v
         };
       }
@@ -1324,29 +1338,36 @@ function createKentuckySignerAccount(options) {
      */
     async signMessage({ message }) {
       const messageHash = hashMessage(message);
-      return signHash(messageHash, defaultChainId);
+      return signHash(messageHash);
     },
     /**
      * Sign a transaction
      *
      * Serializes the transaction, hashes it, signs via Kentucky Signer,
      * and returns the signed serialized transaction.
+     *
+     * For legacy transactions, applies EIP-155 encoding (v = chainId * 2 + 35 + recoveryId)
+     * For modern transactions (EIP-1559, EIP-2930, etc.), uses yParity (0 or 1)
      */
     async signTransaction(transaction) {
       const chainId = transaction.chainId ?? defaultChainId;
       const serializedUnsigned = serializeTransaction(transaction);
       const txHash = keccak256(serializedUnsigned);
-      const { r, s, v } = await signHashWithComponents(txHash, chainId);
+      const { r, s, v } = await signHashWithComponents(txHash);
+      const recoveryId = v - 27;
+      let signatureV;
       let yParity;
       if (transaction.type === "eip1559" || transaction.type === "eip2930" || transaction.type === "eip4844" || transaction.type === "eip7702") {
-        yParity = v >= 27 ? v - 27 : v;
+        yParity = recoveryId;
+        signatureV = BigInt(yParity);
       } else {
-        yParity = v;
+        signatureV = BigInt(chainId * 2 + 35 + recoveryId);
+        yParity = recoveryId;
       }
       const serializedSigned = serializeTransaction(transaction, {
         r,
         s,
-        v: BigInt(yParity),
+        v: signatureV,
         yParity
       });
       return serializedSigned;
@@ -1356,7 +1377,7 @@ function createKentuckySignerAccount(options) {
      */
     async signTypedData(typedData) {
       const hash = hashTypedData(typedData);
-      return signHash(hash, defaultChainId);
+      return signHash(hash);
     }
   });
   account.source = "kentuckySigner";
@@ -1369,6 +1390,25 @@ function createKentuckySignerAccount(options) {
       account.address = newSession.evmAddress;
     }
   };
+  account.sign7702Authorization = async (params, currentNonce) => {
+    const authNonce = params.executor === "self" ? currentNonce + 1n : params.nonce ?? currentNonce;
+    const chainId = params.chainId ?? defaultChainId;
+    const authHash = hashAuthorization({
+      contractAddress: params.contractAddress,
+      chainId,
+      nonce: authNonce
+    });
+    const { r, s, v } = await signHashWithComponents(authHash);
+    const yParity = v - 27;
+    return {
+      chainId,
+      contractAddress: params.contractAddress,
+      nonce: authNonce,
+      yParity,
+      r,
+      s
+    };
+  };
   return account;
 }
 
@@ -1890,16 +1930,341 @@ function useAddress() {
   const { account } = useKentuckySignerContext();
   return account?.address;
 }
+
+// src/react/relayer-hooks.ts
+import { useState as useState3, useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2 } from "react";
+function useRelayIntent(client) {
+  const [isRelaying, setIsRelaying] = useState3(false);
+  const [response, setResponse] = useState3(null);
+  const [error, setError] = useState3(null);
+  const relay = useCallback3(
+    async (chainId, accountAddress, signedIntent, paymentMode, authorization) => {
+      setIsRelaying(true);
+      setError(null);
+      try {
+        const result = await client.relay(chainId, accountAddress, signedIntent, paymentMode, authorization);
+        setResponse(result);
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Relay failed");
+        setError(error2);
+        return { success: false, error: error2.message };
+      } finally {
+        setIsRelaying(false);
+      }
+    },
+    [client]
+  );
+  const reset = useCallback3(() => {
+    setResponse(null);
+    setError(null);
+  }, []);
+  return { relay, isRelaying, response, error, reset };
+}
+function useTransactionStatus(client, chainId, txHash, pollInterval = 3e3) {
+  const [status, setStatus] = useState3(null);
+  const [statusResponse, setStatusResponse] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const intervalRef = useRef2(null);
+  const fetchStatus = useCallback3(async () => {
+    if (!txHash) return;
+    setIsLoading(true);
+    try {
+      const response = await client.getStatus(chainId, txHash);
+      setStatusResponse(response);
+      setStatus(response.status);
+      setError(null);
+      if (response.status === "confirmed" || response.status === "failed") {
+        if (intervalRef.current) {
+          clearInterval(intervalRef.current);
+          intervalRef.current = null;
+        }
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch status"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, chainId, txHash]);
+  useEffect2(() => {
+    if (!txHash) {
+      setStatus(null);
+      setStatusResponse(null);
+      return;
+    }
+    fetchStatus();
+    intervalRef.current = setInterval(fetchStatus, pollInterval);
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [txHash, pollInterval, fetchStatus]);
+  return { status, statusResponse, isLoading, error, refresh: fetchStatus };
+}
+function useEstimate(client) {
+  const [estimateResponse, setEstimateResponse] = useState3(null);
+  const [isEstimating, setIsEstimating] = useState3(false);
+  const [error, setError] = useState3(null);
+  const estimate = useCallback3(
+    async (chainId, accountAddress, intent) => {
+      setIsEstimating(true);
+      setError(null);
+      try {
+        const response = await client.estimate(chainId, accountAddress, intent);
+        setEstimateResponse(response);
+        return response;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Estimate failed");
+        setError(error2);
+        return null;
+      } finally {
+        setIsEstimating(false);
+      }
+    },
+    [client]
+  );
+  return { estimate, estimateResponse, isEstimating, error };
+}
+function useNonce(client, chainId, address) {
+  const [nonce, setNonce] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const fetchNonce = useCallback3(async () => {
+    if (!address) return;
+    setIsLoading(true);
+    try {
+      const result = await client.getNonce(chainId, address);
+      setNonce(result);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch nonce"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, chainId, address]);
+  useEffect2(() => {
+    if (address) {
+      fetchNonce();
+    } else {
+      setNonce(null);
+    }
+  }, [address, fetchNonce]);
+  return { nonce, isLoading, error, refresh: fetchNonce };
+}
+
+// src/relayer-client.ts
+var RelayerClient = class {
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.timeout = options.timeout ?? 3e4;
+  }
+  /**
+   * Check if the relayer is healthy
+   */
+  async health() {
+    const response = await this.fetch("/health");
+    return response;
+  }
+  /**
+   * Get the current nonce for an account
+   *
+   * @param chainId - Chain ID
+   * @param address - Account address
+   * @returns Current nonce as bigint
+   */
+  async getNonce(chainId, address) {
+    const response = await this.fetch(`/nonce/${chainId}/${address}`);
+    return BigInt(response.nonce);
+  }
+  /**
+   * Estimate gas and fees for an intent
+   *
+   * @param chainId - Chain ID
+   * @param accountAddress - Account address (the delegated EOA)
+   * @param intent - Execution intent
+   * @returns Estimate response
+   */
+  async estimate(chainId, accountAddress, intent) {
+    const response = await this.fetch("/estimate", {
+      method: "POST",
+      body: JSON.stringify({
+        chainId,
+        accountAddress,
+        intent: {
+          nonce: intent.nonce.toString(),
+          deadline: intent.deadline.toString(),
+          target: intent.target,
+          value: intent.value.toString(),
+          data: intent.data
+        }
+      })
+    });
+    return response;
+  }
+  /**
+   * Relay a signed intent
+   *
+   * @param chainId - Chain ID
+   * @param accountAddress - Account address (the delegated EOA)
+   * @param signedIntent - Signed execution intent
+   * @param paymentMode - Payment mode ('sponsored' or { token: Address })
+   * @param authorization - Optional EIP-7702 authorization for gasless onboarding
+   * @returns Relay response with transaction hash
+   *
+   * @example Gasless onboarding (delegate + execute in one tx)
+   * ```typescript
+   * // Get current nonce for authorization
+   * const txNonce = await publicClient.getTransactionCount({ address: accountAddress })
+   *
+   * // Sign EIP-7702 authorization
+   * const authorization = await account.sign7702Authorization({
+   *   contractAddress: delegateAddress,
+   *   chainId: 42161,
+   * }, txNonce)
+   *
+   * // Relay with authorization
+   * const result = await relayer.relay(
+   *   42161,
+   *   accountAddress,
+   *   signedIntent,
+   *   'sponsored',
+   *   authorization
+   * )
+   * ```
+   */
+  async relay(chainId, accountAddress, signedIntent, paymentMode, authorization) {
+    const body = {
+      chainId,
+      accountAddress,
+      intent: {
+        nonce: signedIntent.intent.nonce.toString(),
+        deadline: signedIntent.intent.deadline.toString(),
+        target: signedIntent.intent.target,
+        value: signedIntent.intent.value.toString(),
+        data: signedIntent.intent.data
+      },
+      ownerSignature: signedIntent.signature,
+      paymentMode
+    };
+    if (authorization) {
+      body.authorization = {
+        chainId: authorization.chainId,
+        contractAddress: authorization.contractAddress,
+        nonce: authorization.nonce.toString(),
+        yParity: authorization.yParity,
+        r: authorization.r,
+        s: authorization.s
+      };
+    }
+    const response = await this.fetch("/relay", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    return response;
+  }
+  /**
+   * Get transaction status
+   *
+   * @param chainId - Chain ID
+   * @param txHash - Transaction hash
+   * @returns Status response
+   */
+  async getStatus(chainId, txHash) {
+    const response = await this.fetch(`/status/${chainId}/${txHash}`);
+    return response;
+  }
+  /**
+   * Make a fetch request to the relayer API
+   */
+  async fetch(path, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        },
+        signal: controller.signal
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(data.error || `Request failed: ${response.status}`);
+      }
+      return data;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function createRelayerClient(baseUrl) {
+  return new RelayerClient({ baseUrl });
+}
+
+// src/intent.ts
+import {
+  keccak256 as keccak2562,
+  encodeAbiParameters,
+  parseAbiParameters,
+  encodePacked
+} from "viem";
+var INTENT_TYPEHASH = keccak2562(
+  encodePacked(
+    ["string"],
+    ["ExecutionIntent(uint256 nonce,uint256 deadline,address target,uint256 value,bytes data)"]
+  )
+);
+function createExecutionIntent(params) {
+  return {
+    nonce: params.nonce,
+    deadline: params.deadline ?? BigInt(Math.floor(Date.now() / 1e3) + 3600),
+    // 1 hour default
+    target: params.target,
+    value: params.value ?? 0n,
+    data: params.data ?? "0x"
+  };
+}
+function hashIntent(intent) {
+  const dataHash = keccak2562(intent.data);
+  return keccak2562(
+    encodeAbiParameters(
+      parseAbiParameters("bytes32, uint256, uint256, address, uint256, bytes32"),
+      [INTENT_TYPEHASH, intent.nonce, intent.deadline, intent.target, intent.value, dataHash]
+    )
+  );
+}
+async function signIntent(account, intent) {
+  const intentHash = hashIntent(intent);
+  const signature = await account.signMessage({
+    message: { raw: intentHash }
+  });
+  return {
+    intent,
+    signature
+  };
+}
 export {
   KentuckySignerProvider,
+  RelayerClient,
+  createExecutionIntent,
+  createRelayerClient,
+  signIntent,
   useAddress,
+  useEstimate,
   useIsReady,
   useKentuckySigner,
   useKentuckySignerAccount,
   useKentuckySignerContext,
+  useNonce,
   usePasskeyAuth,
+  useRelayIntent,
   useSignMessage,
   useSignTypedData,
+  useTransactionStatus,
   useWalletClient
 };
 //# sourceMappingURL=index.mjs.map