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

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.js";
-import type { wallet_sendPreparedCalls } from "../../rpc/request.js";
-import type { WalletServerViemRpcSchema } from "../../rpc/schema.js";
-import { TypeCallId } from "../../schemas.js";
-
-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,7 +12,7 @@ import {
   type AlchemyTransport,
 } from "@account-kit/infra";
 import { type Chain, type Transport } from "viem";
-import type { WalletServerViemRpcSchema } from "../rpc/schema.js";
+import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
 import {
   createSession,
   type CreateSessionParams,
@@ -28,6 +29,8 @@ import {
   sendPreparedCalls,
   type SendPreparedCallsParams,
 } 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 = {
@@ -35,6 +38,7 @@ type ClientParams = {
   transport: Transport;
   policyId?: string;
   useErc7677middleware?: boolean;
+  feeEstimator?: ClientMiddlewareFn;
 };
 
 export function isomorphicClientActions(
@@ -54,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),
   };
 }
 
@@ -64,6 +70,7 @@ export function createIsomorphicClient({
   transport,
   policyId,
   useErc7677middleware = true,
+  feeEstimator,
 }: ClientParams): SmartAccountClient<
   Transport,
   Chain,
@@ -76,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}`,
+      });
+    }
+  }
+};

package/src/isomorphic/utils/createAccount.ts

@@ -1,22 +1,29 @@
 import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import {
+  createLightAccount,
   createModularAccountV2,
+  createMultiOwnerLightAccount,
+  createMultiOwnerModularAccount,
   type ModularAccountV2,
 } from "@account-kit/smart-contracts";
 import type { StaticDecode } from "@sinclair/typebox";
 import type { Address, Chain, Transport } from "viem";
 import { concatHex, hexToNumber } from "viem";
-import type { Capabilities } from "../../capabilities/index.js";
-import type { TypeSerializedInitcode } from "../../schemas.js";
 import { parsePermissionsContext } from "./parsePermissionsContext.js";
+import { assertNever } from "../../utils.js";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
+import { TypeSerializedInitcode } from "@alchemy/wallet-api-types";
+import { PermissionsCapability } from "@alchemy/wallet-api-types/capabilities";
+import { InternalError, InvalidRequestError } from "ox/RpcResponse";
 
 type CreateAccountParams = {
   chain: Chain;
   transport: Transport;
   signer: SmartAccountSigner;
   accountAddress: Address;
-  counterfactualInfo: StaticDecode<typeof TypeSerializedInitcode>;
-  capabilities?: StaticDecode<typeof Capabilities>;
+  counterfactualInfo?: StaticDecode<typeof TypeSerializedInitcode>; // undefined for 7702 accounts
+  permissions?: StaticDecode<typeof PermissionsCapability>;
+  delegation?: Address;
 };
 
 /**
@@ -28,12 +35,14 @@ export async function createAccount(
   params: CreateAccountParams,
 ): Promise<SmartContractAccount> {
   const { counterfactualInfo: ci, ...accountParams } = params;
-  // TODO: Implement support for other account types.
-  if (ci.factoryType !== "MAv2.0.0-sma-b") {
-    throw new Error("Only MAv2 SMA-B accounts are currently supported");
-  }
 
-  const parsedContext = parsePermissionsContext(params.capabilities, ci);
+  // This throws if we pass a permission context and the account is not MA-v2
+  // TODO: test that this edge case is handled correctly
+  const parsedContext = parsePermissionsContext(
+    params.permissions,
+    ci,
+    params.delegation,
+  );
 
   const signerEntity =
     parsedContext?.contextVersion === "NON_DEFERRED_ACTION"
@@ -43,12 +52,91 @@ export async function createAccount(
         }
       : undefined;
 
-  return createModularAccountV2({
+  const mode = params.delegation ? "7702" : "default";
+
+  if (mode === "7702") {
+    const accountType = getAccountTypeForDelegationAddress7702(
+      params.delegation!,
+    );
+    if (accountType !== "ModularAccountV2") {
+      throw new Error("7702 mode currently only supports ModularAccountV2");
+    }
+    return createModularAccountV2({
+      ...accountParams,
+      signerEntity,
+      deferredAction: parsedContext?.deferredAction,
+      mode,
+    });
+  }
+
+  if (mode !== "default") {
+    return assertNever(mode, "Unexpected mode in createAccount");
+  }
+
+  // At this point, we are guaranteed to be in default mode, where ci
+  // (counterfactualInfo) must be defined
+
+  if (!ci) {
+    throw new InternalError({
+      message: "Counterfactual info not found",
+    });
+  }
+
+  const factoryType = ci.factoryType;
+  const commonParams = {
     ...accountParams,
-    signerEntity,
-    deferredAction: parsedContext?.deferredAction,
     initCode: concatHex([ci.factoryAddress, ci.factoryData]),
-  });
+  };
+
+  // Return the account created based on the factory type
+  switch (factoryType) {
+    case "MAv2.0.0-sma-b":
+      return createModularAccountV2({
+        ...commonParams,
+        signerEntity,
+        deferredAction: parsedContext?.deferredAction,
+        mode,
+      });
+    case "LightAccountV2.0.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v2.0.0",
+      });
+    case "LightAccountV1.0.1":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.1",
+      });
+    case "LightAccountV1.0.2":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.0.2",
+      });
+    case "LightAccountV1.1.0":
+      return createLightAccount({
+        ...commonParams,
+        version: "v1.1.0",
+      });
+    case "MAv1.0.0-MultiOwner":
+      return createMultiOwnerModularAccount({
+        ...commonParams,
+      });
+    case "LightAccountV2.0.0-MultiOwner":
+      return createMultiOwnerLightAccount({
+        ...commonParams,
+        version: "v2.0.0",
+      });
+    case "MAv1.0.0-MultiSig":
+    case "MAv2.0.0-ma-ssv":
+    case "MAv2.0.0-ma-webauthn":
+    case "unknown":
+    case undefined:
+      throw new InvalidRequestError({
+        message: `Account type currently unsupported: ${factoryType}`,
+      });
+    default:
+      return assertNever(factoryType, "Unsupported factory type");
+  }
 }
 
 export function isModularAccountV2(

package/src/isomorphic/utils/createDummySigner.ts

@@ -1,6 +1,7 @@
 import { type SmartAccountSigner } from "@aa-sdk/core";
 import type { TypedData } from "abitype";
 import {
+  BaseError,
   type Address,
   type Hex,
   type SignableMessage,
@@ -15,12 +16,12 @@ export const createDummySigner = (address: Address): SmartAccountSigner => ({
   },
   // Not supported on the server
   signMessage: function (_message: SignableMessage): Promise<Hex> {
-    throw new Error("Function not implemented.");
+    throw new BaseError("signMessage not implemented by dummy signer.");
   },
   signTypedData: function <
     const TTypedData extends TypedData | Record<string, unknown>,
     TPrimaryType extends keyof TTypedData | "EIP712Domain" = keyof TTypedData,
   >(_params: TypedDataDefinition<TTypedData, TPrimaryType>): Promise<Hex> {
-    throw new Error("Function not implemented.");
+    throw new BaseError("signTypedData not implemented by dummy signer.");
   },
 });

package/src/isomorphic/utils/decodeSignature.ts

@@ -0,0 +1,21 @@
+import { Value } from "@sinclair/typebox/value";
+import type { StaticDecode } from "@sinclair/typebox";
+import {
+  TypeEcdsaSig,
+  type TypeEcdsaSig as TypeEcdsaSigType,
+} from "@alchemy/wallet-api-types";
+import { assertNever } from "../../utils.js";
+
+export const decodeSignature = (
+  signature: TypeEcdsaSigType["signature"],
+): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
+  switch (signature.type) {
+    case "ecdsa":
+    case "secp256k1":
+      return Value.Decode(TypeEcdsaSig, {
+        signature,
+      } satisfies TypeEcdsaSigType).signature;
+    default:
+      return assertNever(signature, "Unexpected signature type");
+  }
+};