feat: adds 7702 support to alchemy signer

account-kit/signer/src/base.ts

@@ -36,6 +36,7 @@ import {
 } from "./types.js";
 import { assertNever } from "./utils/typeAssertions.js";
 import type { SessionManagerEvents } from "./session/types";
+import { hashAuthorization, type Authorization } from "viem/experimental";
 
 export interface BaseAlchemySignerParams<TClient extends BaseSignerClient> {
   client: TClient;
@@ -51,6 +52,12 @@ type AlchemySignerStore = {
   isNewUser?: boolean;
 };
 
+type UnpackedSignature = {
+  r: `0x${string}`;
+  s: `0x${string}`;
+  v: bigint;
+};
+
 type InternalStore = Mutate<
   StoreApi<AlchemySignerStore>,
   [["zustand/subscribeWithSelector", never]]
@@ -524,16 +531,64 @@ export abstract class BaseAlchemySigner<TClient extends BaseSignerClient>
         keccak256(serializedTx)
       );
 
-      const signature = {
-        r: takeBytes(signatureHex, { count: 32 }),
-        s: takeBytes(signatureHex, { count: 32, offset: 32 }),
-        v: BigInt(takeBytes(signatureHex, { count: 1, offset: 64 })),
-      };
+      const signature = this.unpackSignRawMessageBytes(signatureHex);
 
       return serializeFn(tx, signature);
     }
   );
 
+  /**
+   * Signs an EIP-7702 Authorization and then returns the authorization with the signature.
+   *
+   * @example
+   * ```ts
+   * import { AlchemyWebSigner } from "@account-kit/signer";
+   *
+   * const signer = new AlchemyWebSigner({
+   *  client: {
+   *    connection: {
+   *      rpcUrl: "/api/rpc",
+   *    },
+   *    iframeConfig: {
+   *      iframeContainerId: "alchemy-signer-iframe-container",
+   *    },
+   *  },
+   * });
+   *
+   * const tx = await signer.signAuthorization({
+   *  contractAddress: "0x1234",
+   *  chainId: 1,
+   *  nonce: 0,
+   * });
+   * ```
+   *
+   * @param {Authorization<number, false>} unsignedAuthorization the authorization to be signed
+   * @returns {Promise<Authorization<number, true>> | undefined} a promise that resolves to the authorization with the signature
+   */
+  signAuthorization: (
+    unsignedAuthorization: Authorization<number, false>
+  ) => Promise<Authorization<number, true>> | undefined = SignerLogger.profiled(
+    "BaseAlchemySigner.signAuthorization",
+    async (unsignedAuthorization) => {
+      const hashedAuthorization = hashAuthorization(unsignedAuthorization);
+      const signedAuthorizationHex = await this.inner.signRawMessage(
+        hashedAuthorization
+      );
+      const signature = this.unpackSignRawMessageBytes(signedAuthorizationHex);
+      return { ...unsignedAuthorization, ...signature };
+    }
+  );
+
+  private unpackSignRawMessageBytes = (
+    hex: `0x${string}`
+  ): UnpackedSignature => {
+    return {
+      r: takeBytes(hex, { count: 32 }),
+      s: takeBytes(hex, { count: 32, offset: 32 }),
+      v: BigInt(takeBytes(hex, { count: 1, offset: 64 })),
+    };
+  };
+
   /**
    * Unauthenticated call to look up a user's organizationId by email
    *