kentucky-signer-viem 0.1.4 → 0.1.5

package/dist/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALCHEMY_SEMI_MODULAR_ACCOUNT_7702: () => ALCHEMY_SEMI_MODULAR_ACCOUNT_7702,
   EphemeralKeyManager: () => EphemeralKeyManager,
   IndexedDBEphemeralKeyStorage: () => IndexedDBEphemeralKeyStorage,
   KentuckySignerClient: () => KentuckySignerClient,
@@ -27,6 +28,7 @@ __export(index_exports, {
   LocalStorageTokenStorage: () => LocalStorageTokenStorage,
   MemoryEphemeralKeyStorage: () => MemoryEphemeralKeyStorage,
   MemoryTokenStorage: () => MemoryTokenStorage,
+  RelayerClient: () => RelayerClient,
   SecureKentuckySignerClient: () => SecureKentuckySignerClient,
   authenticateWithPasskey: () => authenticateWithPasskey,
   authenticateWithPassword: () => authenticateWithPassword,
@@ -36,12 +38,16 @@ __export(index_exports, {
   bytesToHex: () => bytesToHex,
   createAccountWithPassword: () => createAccountWithPassword,
   createClient: () => createClient,
+  createExecutionIntent: () => createExecutionIntent,
   createKentuckySignerAccount: () => createKentuckySignerAccount,
+  createRelayerClient: () => createRelayerClient,
   createSecureClient: () => createSecureClient,
   createServerAccount: () => createServerAccount,
   formatError: () => formatError,
   generateEphemeralKeyPair: () => generateEphemeralKeyPair,
   getJwtExpiration: () => getJwtExpiration,
+  hashBatchIntents: () => hashBatchIntents,
+  hashIntent: () => hashIntent,
   hexToBytes: () => hexToBytes,
   isSessionValid: () => isSessionValid,
   isValidAccountId: () => isValidAccountId,
@@ -51,6 +57,8 @@ __export(index_exports, {
   parseJwt: () => parseJwt,
   refreshSessionIfNeeded: () => refreshSessionIfNeeded,
   registerPasskey: () => registerPasskey,
+  signBatchIntents: () => signBatchIntents,
+  signIntent: () => signIntent,
   signPayload: () => signPayload,
   verifyPayload: () => verifyPayload,
   withRetry: () => withRetry
@@ -205,9 +213,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", {
@@ -222,13 +230,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;
@@ -645,6 +652,15 @@ function createClient(options) {
 }
 
 // src/account.ts
+var EIP7702_MAGIC = "0x05";
+function hashAuthorization(params) {
+  const rlpEncoded = (0, import_viem.toRlp)([
+    params.chainId === 0 ? "0x" : (0, import_viem.numberToHex)(params.chainId),
+    params.contractAddress,
+    params.nonce === 0n ? "0x" : (0, import_viem.numberToHex)(params.nonce)
+  ]);
+  return (0, import_viem.keccak256)((0, import_viem.concat)([EIP7702_MAGIC, rlpEncoded]));
+}
 function createKentuckySignerAccount(options) {
   const { config, defaultChainId = 1, onSessionExpired, secureClient, on2FARequired } = options;
   let session = options.session;
@@ -663,14 +679,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);
@@ -681,24 +700,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) {
@@ -711,12 +730,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
         };
       }
@@ -732,29 +751,36 @@ function createKentuckySignerAccount(options) {
      */
     async signMessage({ message }) {
       const messageHash = (0, import_viem.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 = (0, import_viem.serializeTransaction)(transaction);
       const txHash = (0, import_viem.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 = (0, import_viem.serializeTransaction)(transaction, {
         r,
         s,
-        v: BigInt(yParity),
+        v: signatureV,
         yParity
       });
       return serializedSigned;
@@ -764,7 +790,7 @@ function createKentuckySignerAccount(options) {
      */
     async signTypedData(typedData) {
       const hash = (0, import_viem.hashTypedData)(typedData);
-      return signHash(hash, defaultChainId);
+      return signHash(hash);
     }
   });
   account.source = "kentuckySigner";
@@ -777,6 +803,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;
 }
 function createServerAccount(baseUrl, accountId, token, evmAddress, chainId = 1) {
@@ -1309,9 +1354,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;
@@ -1647,8 +1692,212 @@ async function createAccountWithPassword(options) {
     confirmation: options.confirmation
   });
 }
+
+// src/intent.ts
+var import_viem2 = require("viem");
+var INTENT_TYPEHASH = (0, import_viem2.keccak256)(
+  (0, import_viem2.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 = (0, import_viem2.keccak256)(intent.data);
+  return (0, import_viem2.keccak256)(
+    (0, import_viem2.encodeAbiParameters)(
+      (0, import_viem2.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
+  };
+}
+function hashBatchIntents(intents) {
+  const intentHashes = intents.map(hashIntent);
+  return (0, import_viem2.keccak256)((0, import_viem2.encodePacked)(["bytes32[]"], [intentHashes]));
+}
+async function signBatchIntents(account, intents) {
+  const signedIntents = [];
+  for (const intent of intents) {
+    const signed = await signIntent(account, intent);
+    signedIntents.push(signed);
+  }
+  return signedIntents;
+}
+
+// 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/index.ts
+var ALCHEMY_SEMI_MODULAR_ACCOUNT_7702 = "0x69007702764179f14F51cdce752f4f775d74E139";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALCHEMY_SEMI_MODULAR_ACCOUNT_7702,
   EphemeralKeyManager,
   IndexedDBEphemeralKeyStorage,
   KentuckySignerClient,
@@ -1656,6 +1905,7 @@ async function createAccountWithPassword(options) {
   LocalStorageTokenStorage,
   MemoryEphemeralKeyStorage,
   MemoryTokenStorage,
+  RelayerClient,
   SecureKentuckySignerClient,
   authenticateWithPasskey,
   authenticateWithPassword,
@@ -1665,12 +1915,16 @@ async function createAccountWithPassword(options) {
   bytesToHex,
   createAccountWithPassword,
   createClient,
+  createExecutionIntent,
   createKentuckySignerAccount,
+  createRelayerClient,
   createSecureClient,
   createServerAccount,
   formatError,
   generateEphemeralKeyPair,
   getJwtExpiration,
+  hashBatchIntents,
+  hashIntent,
   hexToBytes,
   isSessionValid,
   isValidAccountId,
@@ -1680,6 +1934,8 @@ async function createAccountWithPassword(options) {
   parseJwt,
   refreshSessionIfNeeded,
   registerPasskey,
+  signBatchIntents,
+  signIntent,
   signPayload,
   verifyPayload,
   withRetry