@account-kit/wallet-client 0.1.0-alpha.0 → 0.1.0-alpha.10

package/src/isomorphic/actions/prepareSign.ts

@@ -0,0 +1,91 @@
+import type { Static } from "@sinclair/typebox";
+import type {
+  SignatureRequest,
+  SmartAccountClient,
+  SmartContractAccount,
+} from "@aa-sdk/core";
+import {
+  ChainNotFoundError,
+  custom,
+  toHex,
+  type Chain,
+  type Transport,
+} from "viem";
+import type {
+  wallet_prepareSign,
+  WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
+import {
+  TypeSignableMessage,
+  jsonSafeTypedData,
+} from "@alchemy/wallet-api-types";
+import { createAccount } from "../utils/createAccount.js";
+import { createDummySigner } from "../utils/createDummySigner.js";
+import { Value } from "@sinclair/typebox/value";
+
+export type PrepareSignParams = Static<
+  (typeof wallet_prepareSign)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+export type PrepareSignResult = Static<
+  (typeof wallet_prepareSign)["properties"]["ReturnType"]
+>;
+
+export async function prepareSign(
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: PrepareSignParams,
+): Promise<PrepareSignResult> {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const { counterfactualInfo, delegation } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      {
+        accountAddress: params.from,
+        includeCounterfactualInfo: true,
+      },
+    ],
+  });
+
+  const account = await createAccount({
+    chain: client.chain,
+    transport: custom(client.transport),
+    signer: createDummySigner(params.from),
+    accountAddress: params.from,
+    counterfactualInfo,
+    permissions: params.capabilities?.permissions,
+    delegation,
+  });
+
+  const signatureRequest = await account.prepareSign(
+    params.signatureRequest as SignatureRequest,
+  );
+
+  if (signatureRequest.type === "personal_sign") {
+    return {
+      chainId: toHex(client.chain.id),
+      signatureRequest: {
+        type: signatureRequest.type,
+        data: Value.Encode(TypeSignableMessage, signatureRequest.data),
+      },
+    };
+  } else {
+    const typedData = signatureRequest.data;
+
+    return {
+      chainId: toHex(client.chain.id),
+      signatureRequest: {
+        type: signatureRequest.type,
+        data: jsonSafeTypedData(typedData),
+      },
+    };
+  }
+}

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -3,28 +3,35 @@ import {
   type SmartAccountClient,
   type SmartContractAccount,
 } from "@aa-sdk/core";
-import type { Static, StaticDecode } from "@sinclair/typebox";
 import { Value } from "@sinclair/typebox/value";
 import {
+  BaseError,
   ChainNotFoundError,
   concat,
   concatHex,
+  numberToHex,
+  parseSignature,
   toHex,
+  type Address,
   type Chain,
   type Hex,
   type Transport,
 } from "viem";
-import { decodePermissionsContext } from "../../capabilities/permissions/mav2";
-import type { wallet_sendPreparedCalls } from "../../rpc/request";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema";
-import { TypeCallId } from "../../schemas";
-
-export type SendPreparedCallsParams = Omit<
-  StaticDecode<
-    (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
-  >[0],
-  "chainId"
->;
+import type {
+  wallet_sendPreparedCalls,
+  WalletServerViemRpcSchema,
+} from "@alchemy/wallet-api-types/rpc";
+import { decodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
+import { TypeCallId } from "@alchemy/wallet-api-types";
+import { isSupportedDelegationAddress7702 } from "../utils/7702.js";
+import { InvalidRequestError } from "ox/RpcResponse";
+import { assertNever } from "../../utils.js";
+import type { Static } from "@sinclair/typebox";
+import { decodeSignature } from "../utils/decodeSignature.js";
+
+export type SendPreparedCallsParams = Static<
+  (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+>[0];
 
 export type SendPreparedCallsResult = Static<
   (typeof wallet_sendPreparedCalls)["properties"]["ReturnType"]
@@ -46,50 +53,182 @@ export async function sendPreparedCalls(
   }
 
   const deferredAction: Hex | undefined = (() => {
-    if (!params.capabilities?.permissions?.context) {
+    if (!params.capabilities?.permissions) {
       return;
     }
 
     const decodedContext = decodePermissionsContext(
-      params.capabilities.permissions.context,
+      params.capabilities.permissions,
     );
 
     if (decodedContext.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
-      throw new Error(
-        "Remote mode deferred action not supported in isomorphic client",
-      );
+      throw new InvalidRequestError({
+        message:
+          "Remote mode deferred action not supported in isomorphic client",
+      });
     }
 
     return decodedContext.deferredAction;
   })();
 
-  const entryPoint =
-    params.type === "user-operation-v060"
-      ? getEntryPoint(client.chain, { version: "0.6.0" })
-      : getEntryPoint(client.chain, { version: "0.7.0" });
-
-  const hash = await client.sendRawUserOperation(
-    {
-      ...params.data,
-      signature:
-        deferredAction != null
-          ? concatHex([
-              `0x${deferredAction.slice(68)}`, // Cuts off stuff preprended to the digest (nonce, etc. that we had previously).
-              "0xff",
-              "0x00",
-              params.signature.signature,
-            ])
-          : concat(["0xFF", "0x00", params.signature.signature]),
-    },
-    entryPoint.address,
-  );
+  const userOps =
+    params.type === "array"
+      ? params.data.filter((it) => {
+          const isUserOp =
+            it.type === "user-operation-v060" ||
+            it.type === "user-operation-v070";
+          if (isUserOp && it.chainId !== toHex(client.chain.id)) {
+            throw new InvalidRequestError({
+              message:
+                "Multiple chain IDs in a single request are not currently supported.",
+            });
+          }
+          return isUserOp;
+        })
+      : [params];
+
+  if (!userOps.length) {
+    throw new InvalidRequestError({
+      message: "Calls must include at least one user operation",
+    });
+  }
+
+  const authorizations =
+    params.type === "array"
+      ? params.data.filter((it) => it.type === "authorization")
+      : [];
+
+  if (authorizations.length > 1) {
+    throw new InvalidRequestError({
+      message:
+        "Multiple authorizations in a single request are not currently supported",
+    });
+  }
+  const [authorization] = authorizations;
 
-  const callId = Value.Encode(TypeCallId, {
-    chainId: toHex(client.chain.id),
-    hash,
-  });
+  // One last safety check to be sure the UO wasn't modified to include an unsupported 7702 delegation address.
+  if (
+    authorization &&
+    !isSupportedDelegationAddress7702(authorization.data.address)
+  ) {
+    throw new InvalidRequestError({
+      message: `Unsupported 7702 delegation address: ${authorization.data.address}`,
+    });
+  }
+
+  const hashes = await Promise.all(
+    userOps.map(async (userOp, idx) => {
+      const ep: { address: Address } =
+        userOp.type === "user-operation-v060"
+          ? getEntryPoint(client.chain, { version: "0.6.0" })
+          : userOp.type === "user-operation-v070"
+            ? getEntryPoint(client.chain, { version: "0.7.0" })
+            : assertNever(userOp, "Unexpected user op type");
+      const authSig = authorization
+        ? parseSignature(decodeSignature(authorization.signature).data)
+        : undefined;
+      const uoSigHex = decodeSignature(userOp.signature).data;
+
+      const { counterfactualInfo, delegation } = await client.request({
+        method: "wallet_requestAccount",
+        params: [
+          {
+            accountAddress: userOp.data.sender,
+            includeCounterfactualInfo: true,
+          },
+        ],
+      });
+
+      if (!counterfactualInfo && !delegation) {
+        throw new InvalidRequestError({
+          message:
+            "No counterfactual info or delegated implementation address found.",
+        });
+      }
+
+      const factoryType = counterfactualInfo?.factoryType;
+
+      // build signature based on account type
+      const signature = (() => {
+        switch (factoryType) {
+          // light accounts
+          case "LightAccountV1.0.1":
+          case "LightAccountV1.0.2":
+          case "LightAccountV1.1.0":
+          case "MAv1.0.0-MultiOwner":
+            // For LAv1 and MAv1-MultiOwner, we always just pass the signature.
+            return uoSigHex;
+          case "LightAccountV2.0.0":
+            // for LAv2, we need to prepend the "SignatureType.EOA" byte.
+            // TODO: Once we support nested smart accounts, switch this byte depending on the signature type.
+            return concat(["0x00", uoSigHex]);
+          case undefined: // undefined defaults to sma-b
+          case "MAv2.0.0-sma-b":
+            // For sma-b, we need to handle deferred actions if needed and prepend the "Reserved
+            // Signature Segment" and "SignatureType.EOA" bytes
+            return deferredAction != null
+              ? concatHex([
+                  `0x${deferredAction.slice(68)}`, // Cuts off stuff prepended to the digest (nonce, etc.).
+                  "0xFF",
+                  "0x00",
+                  uoSigHex,
+                ])
+              : concat(["0xFF", "0x00", uoSigHex]);
+          case "LightAccountV2.0.0-MultiOwner":
+            // for LAv2-MultiOwner, we need to prepend the "SignatureType.EOA" byte
+            // TODO: Once we support nested smart accounts, switch this byte depending on the signature type, and add the smart account signer's address.
+            return concat(["0x00", uoSigHex]);
+          case "MAv2.0.0-ma-ssv":
+          case "MAv2.0.0-ma-webauthn":
+          case "MAv1.0.0-MultiSig":
+          case "unknown":
+            throw new InvalidRequestError({
+              message: `Unsupported factory type: ${factoryType}`,
+            });
+          default:
+            return assertNever(factoryType, "Unsupported factory type");
+        }
+      })();
+
+      return client
+        .sendRawUserOperation(
+          {
+            ...userOp.data,
+            signature,
+            eip7702Auth:
+              idx === 0 && authorization && authSig
+                ? {
+                    ...authorization.data,
+                    chainId: authorization.chainId,
+                    ...{
+                      ...authSig,
+                      yParity: numberToHex(authSig.yParity),
+                    },
+                  }
+                : undefined,
+          },
+          ep.address,
+        )
+        .catch((err) => {
+          if (
+            err instanceof BaseError &&
+            err.details.endsWith("is not a contract and initCode is empty")
+          ) {
+            throw new BaseError(
+              `${err.details} (If using 7702, be sure you include the signed authorization in the request parameters)`,
+            );
+          }
+          throw err;
+        });
+    }),
+  );
 
   return {
-    preparedCallIds: [callId],
+    preparedCallIds: hashes.map((hash) =>
+      Value.Encode(TypeCallId, {
+        chainId: toHex(client.chain.id),
+        hash,
+      }),
+    ),
   };
 }

package/src/isomorphic/client.ts

@@ -1,5 +1,6 @@
 import {
   createSmartAccountClient,
+  type ClientMiddlewareFn,
   type SmartAccountClient,
   type SmartAccountClientRpcSchema,
   type SmartContractAccount,
@@ -11,20 +12,25 @@ import {
   type AlchemyTransport,
 } from "@account-kit/infra";
 import { type Chain, type Transport } from "viem";
-import type { WalletServerViemRpcSchema } from "../rpc/schema";
+import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
 import {
   createSession,
   type CreateSessionParams,
-} from "./actions/createSession";
+} from "./actions/createSession.js";
 import {
   getCallsStatus,
   type GetCallsStatusParams,
-} from "./actions/getCallsStatus";
-import { prepareCalls, type PrepareCallsParams } from "./actions/prepareCalls";
+} from "./actions/getCallsStatus.js";
+import {
+  prepareCalls,
+  type PrepareCallsParams,
+} from "./actions/prepareCalls.js";
 import {
   sendPreparedCalls,
   type SendPreparedCallsParams,
-} from "./actions/sendPreparedCalls";
+} from "./actions/sendPreparedCalls.js";
+import { prepareSign, type PrepareSignParams } from "./actions/prepareSign.js";
+import { formatSign, type FormatSignParams } from "./actions/formatSign.js";
 
 // let's start with something that takes in as many params as possible, then we can eliminate them as we don't need them
 type ClientParams = {
@@ -32,6 +38,7 @@ type ClientParams = {
   transport: Transport;
   policyId?: string;
   useErc7677middleware?: boolean;
+  feeEstimator?: ClientMiddlewareFn;
 };
 
 export function isomorphicClientActions(
@@ -51,6 +58,8 @@ export function isomorphicClientActions(
       getCallsStatus(client, params),
     createSession: (params: CreateSessionParams) =>
       createSession(client, params),
+    prepareSign: (params: PrepareSignParams) => prepareSign(client, params),
+    formatSign: (params: FormatSignParams) => formatSign(client, params),
   };
 }
 
@@ -61,6 +70,7 @@ export function createIsomorphicClient({
   transport,
   policyId,
   useErc7677middleware = true,
+  feeEstimator,
 }: ClientParams): SmartAccountClient<
   Transport,
   Chain,
@@ -73,7 +83,8 @@ export function createIsomorphicClient({
     transport,
     chain,
     // TODO: we will want to enforce alchemy transport here probably
-    feeEstimator: alchemyFeeEstimator(transport as AlchemyTransport),
+    feeEstimator:
+      feeEstimator ?? alchemyFeeEstimator(transport as AlchemyTransport),
     ...(policyId
       ? useErc7677middleware
         ? alchemyGasManagerMiddleware(policyId)

package/src/isomorphic/utils/7702.ts

@@ -0,0 +1,135 @@
+import type { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
+import {
+  concatHex,
+  numberToHex,
+  type Address,
+  type Chain,
+  type Transport,
+  isAddress,
+  hexToNumber,
+} from "viem";
+import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
+import {
+  Eip7702AccountTypeToDelegationAddress,
+  SUPPORTED_DELEGATION_ADDRESSES,
+  type Supported7702AccountType,
+  type Eip7702AuthCapability,
+} from "@alchemy/wallet-api-types/capabilities";
+import type { PreparedCall_Authorization } from "@alchemy/wallet-api-types";
+import { InvalidRequestError } from "ox/RpcResponse";
+import { hashAuthorization } from "viem/utils";
+
+/** Checks if an address is actively delegated on-chain. */
+export const isDelegated = async (
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: { address: Address; delegation: Address },
+): Promise<boolean> => {
+  const expectedCode = concatHex(["0xef0100", params.delegation]);
+  const code = (await client.getCode({ address: params.address })) ?? "0x";
+  return code.toLowerCase() === expectedCode.toLowerCase();
+};
+
+export const createAuthorizationRequest = async (
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: { address: Address; delegation: Address },
+): Promise<PreparedCall_Authorization> => {
+  const data = {
+    address: params.delegation,
+    nonce: numberToHex(
+      await client.getTransactionCount({
+        address: params.address,
+      }),
+    ),
+  };
+  return {
+    type: "authorization" as const,
+    data,
+    chainId: numberToHex(client.chain.id),
+    signatureRequest: {
+      type: "eip7702Auth" as const,
+      rawPayload: hashAuthorization({
+        chainId: client.chain.id,
+        nonce: hexToNumber(data.nonce),
+        address: params.delegation,
+      }),
+    },
+  };
+};
+
+export const DelegationAddressToAccountType: Record<
+  Address,
+  Supported7702AccountType
+> = Object.fromEntries(
+  Object.entries(Eip7702AccountTypeToDelegationAddress).map(([key, value]) => [
+    value,
+    key,
+  ]),
+) as Record<Address, Supported7702AccountType>;
+
+export const isSupportedDelegationAddress7702 = (address: Address): boolean => {
+  return (SUPPORTED_DELEGATION_ADDRESSES as Address[]).includes(address);
+};
+
+export const getAccountTypeForDelegationAddress7702 = (
+  address: Address,
+): Supported7702AccountType | undefined => {
+  return DelegationAddressToAccountType[address];
+};
+
+const getDelegationAddressForAccountType7702 = (
+  accountType: Supported7702AccountType,
+): (typeof SUPPORTED_DELEGATION_ADDRESSES)[number] => {
+  return Eip7702AccountTypeToDelegationAddress[accountType];
+};
+
+const DEFAULT_7702_DELEGATION_ADDR =
+  Eip7702AccountTypeToDelegationAddress["ModularAccountV2"];
+
+export const parseDelegation = (
+  eip7702AuthCapability: Eip7702AuthCapability,
+) => {
+  return eip7702AuthCapability === true
+    ? DEFAULT_7702_DELEGATION_ADDR
+    : isAddress(eip7702AuthCapability.delegation)
+      ? eip7702AuthCapability.delegation
+      : getDelegationAddressForAccountType7702(
+          eip7702AuthCapability.delegation,
+        );
+};
+
+export const assertValid7702AccountAddress = (
+  fromAddress: Address,
+  eip7702AuthCapability: Eip7702AuthCapability | undefined,
+) => {
+  if (eip7702AuthCapability) {
+    if (
+      typeof eip7702AuthCapability === "object" &&
+      "account" in eip7702AuthCapability &&
+      eip7702AuthCapability?.account !== fromAddress
+    ) {
+      throw new InvalidRequestError({
+        message: `EIP-7702 delegation account ${eip7702AuthCapability.account} must match 'from' address ${fromAddress}.`,
+      });
+    }
+
+    const delegation = parseDelegation(eip7702AuthCapability);
+
+    if (!isSupportedDelegationAddress7702(delegation)) {
+      throw new InvalidRequestError({
+        message: `Unsupported 7702 delegation address: ${delegation}`,
+      });
+    }
+  }
+};