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

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 { SerializedInitcode } 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 SerializedInitcode>; // 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 {
+  EcdsaSig,
+  type EcdsaSig as EcdsaSigType,
+} from "@alchemy/wallet-api-types";
+import { assertNever } from "../../utils.js";
+
+export const decodeSignature = (
+  signature: EcdsaSigType["signature"],
+): StaticDecode<typeof EcdsaSig>["signature"] => {
+  switch (signature.type) {
+    case "ecdsa":
+    case "secp256k1":
+      return Value.Decode(EcdsaSig, {
+        signature,
+      } satisfies EcdsaSigType).signature;
+    default:
+      return assertNever(signature, "Unexpected signature type");
+  }
+};

package/src/isomorphic/utils/parsePermissionsContext.ts

@@ -1,27 +1,45 @@
 import type { StaticDecode } from "@sinclair/typebox";
 import { InvalidRequestError } from "ox/RpcResponse";
-import { decodePermissionsContext } from "../../capabilities/permissions/mav2.js";
-import type { TypeSerializedInitcode } from "../../schemas.js";
-import type { PrepareCallsParams } from "../actions/prepareCalls.js";
+import type { Address } from "viem";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
+import {
+  decodePermissionsContext,
+  PermissionsCapability,
+} from "@alchemy/wallet-api-types/capabilities";
+import { SerializedInitcode } from "@alchemy/wallet-api-types";
 
 export function parsePermissionsContext(
-  capabilities: PrepareCallsParams["capabilities"],
-  parsedCi: StaticDecode<typeof TypeSerializedInitcode>,
+  permissions?: StaticDecode<typeof PermissionsCapability>,
+  parsedCi?: StaticDecode<typeof SerializedInitcode> | undefined,
+  delegation7702?: Address,
 ) {
-  if (!capabilities?.permissions?.context) {
+  if (!permissions) {
     return undefined;
   }
 
-  if (
-    capabilities?.permissions?.context &&
-    parsedCi.factoryType !== "MAv2.0.0-sma-b"
-  ) {
+  if ("sessionId" in permissions) {
+    throw new InvalidRequestError({
+      message: "Remote permissions are not supported in isomorphic client",
+    });
+  }
+
+  if (!("context" in permissions)) {
+    return undefined;
+  }
+
+  const isMAV2 =
+    (parsedCi && parsedCi.factoryType === "MAv2.0.0-sma-b") ||
+    (delegation7702 &&
+      getAccountTypeForDelegationAddress7702(delegation7702) ===
+        "ModularAccountV2");
+
+  if (!isMAV2) {
     throw new InvalidRequestError({
       message: "Permissions are currently only supported by MAv2 accounts",
     });
   }
 
-  const context = decodePermissionsContext(capabilities.permissions.context);
+  const context = decodePermissionsContext(permissions);
 
   if (context?.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
     throw new InvalidRequestError({

package/src/isomorphic/utils/supportsFeature.ts

@@ -0,0 +1,34 @@
+import type { StaticDecode } from "@sinclair/typebox";
+import type { SerializedInitcode } from "@alchemy/wallet-api-types";
+
+export type Feature = "permissions";
+
+type FactoryType = StaticDecode<typeof SerializedInitcode>["factoryType"];
+
+const supportedFeatures: Record<FactoryType, Feature[]> = {
+  "LightAccountV1.0.1": [],
+  "LightAccountV1.0.2": [],
+  "LightAccountV1.1.0": [],
+  "LightAccountV2.0.0": [],
+  "LightAccountV2.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiOwner": [],
+  "MAv1.0.0-MultiSig": [],
+  "MAv2.0.0-sma-b": ["permissions"],
+  "MAv2.0.0-ma-ssv": ["permissions"],
+  "MAv2.0.0-ma-webauthn": [],
+  unknown: [],
+};
+
+export function supportsFeature(
+  counterfactualInfo: StaticDecode<typeof SerializedInitcode>,
+  feature: Feature,
+): boolean {
+  const factorySupportedFeatures =
+    supportedFeatures[counterfactualInfo.factoryType];
+  if (factorySupportedFeatures === undefined) {
+    throw new Error(
+      "Unsupported FactoryType: " + counterfactualInfo.factoryType,
+    );
+  }
+  return factorySupportedFeatures.includes(feature);
+}

package/src/local/client.ts

@@ -1,12 +1,13 @@
 import { split } from "@aa-sdk/core";
 import { buildDeferredActionDigest } from "@account-kit/smart-contracts/experimental";
-import { createClient, custom, type Address, type JsonRpcAccount } from "viem";
+import { createClient, custom, type Address } from "viem";
 import {
   encodePermissionsContext,
   prefixSignatureKeyType,
-} from "../capabilities/permissions/mav2.js";
+} from "@alchemy/wallet-api-types/capabilities";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls";
+import { internalStateDecorator } from "../internal/decorator.js";
+import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls.ts";
 import {
   createIsomorphicClient,
   type IsomorphicClient,
@@ -15,7 +16,7 @@ import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
-} from "../types";
+} from "../types.ts";
 import { assertNever } from "../utils.js";
 
 const localMethods = [
@@ -27,10 +28,8 @@ const localMethods = [
 type LocalMethod = (typeof localMethods)[number];
 
 export function createLocalClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient<TAccount>;
+  TAccount extends Address | undefined = Address | undefined,
+>(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
 
 export function createLocalClient(
   params: CreateInnerClientParams,
@@ -51,46 +50,51 @@ export function createLocalClient(
     overrides: [
       {
         methods: localMethods,
-        transport: custom({
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          async request(args: { method: LocalMethod; params: any }) {
-            switch (args.method) {
-              case "wallet_prepareCalls": {
-                const params = args.params[0] as PrepareCallsParams;
-                const capabilityPolicyId =
-                  params.capabilities?.paymasterService?.policyId;
+        transport: custom(
+          {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            async request(args: { method: LocalMethod; params: any }) {
+              switch (args.method) {
+                case "wallet_prepareCalls": {
+                  const params = args.params[0] as PrepareCallsParams;
+                  const capabilityPolicyId =
+                    params.capabilities?.paymasterService?.policyId;
 
-                if (
-                  capabilityPolicyId != null &&
-                  policyId !== capabilityPolicyId &&
-                  !clientMap[capabilityPolicyId]
-                ) {
-                  clientMap[capabilityPolicyId] = createIsomorphicClient({
-                    transport,
-                    chain,
-                    policyId: capabilityPolicyId,
-                  });
-                }
+                  if (
+                    capabilityPolicyId != null &&
+                    policyId !== capabilityPolicyId &&
+                    !clientMap[capabilityPolicyId]
+                  ) {
+                    clientMap[capabilityPolicyId] = createIsomorphicClient({
+                      transport,
+                      chain,
+                      policyId: capabilityPolicyId,
+                    });
+                  }
 
-                const client =
-                  clientMap[capabilityPolicyId ?? policyId ?? "default"];
-                return client.prepareCalls(params);
-              }
-              case "wallet_sendPreparedCalls":
-                return isomorphicClient.sendPreparedCalls(args.params[0]);
-              case "wallet_getCallsStatus":
-                return isomorphicClient.getCallsStatus(args.params[0]);
-              case "wallet_createSession": {
-                return isomorphicClient.createSession(args.params[0]);
+                  const client =
+                    clientMap[capabilityPolicyId ?? policyId ?? "default"];
+                  return client.prepareCalls(params);
+                }
+                case "wallet_sendPreparedCalls":
+                  return isomorphicClient.sendPreparedCalls(args.params[0]);
+                case "wallet_getCallsStatus":
+                  return isomorphicClient.getCallsStatus(args.params[0]);
+                case "wallet_createSession": {
+                  return isomorphicClient.createSession(args.params[0]);
+                }
+                default:
+                  return assertNever(
+                    args.method,
+                    `Unexpected method: ${args.method}`,
+                  );
               }
-              default:
-                return assertNever(
-                  args.method,
-                  `Unexpected method: ${args.method}`,
-                );
-            }
+            },
           },
-        }),
+          {
+            retryCount: 0,
+          },
+        ),
       },
     ],
     fallback: transport,
@@ -100,10 +104,14 @@ export function createLocalClient(
     transport: innerTransport,
     chain,
     account,
-  }).extend(() => ({
-    policyId,
-    ...innerClientActions(isomorphicClient),
-  }));
+  })
+    .extend(() => ({
+      policyId,
+      ...innerClientActions(isomorphicClient),
+    }))
+    .extend(() => ({
+      internal: internalStateDecorator(),
+    }));
 }
 
 const innerClientActions = (
@@ -113,18 +121,13 @@ const innerClientActions = (
     grantPermissions: async (signer, params) => {
       const { signatureRequest, fullPreSignatureDeferredActionDigest } =
         await isomorphicClient.createSession(params);
-
-      const { signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
-
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "LOCAL_MODE_DEFERRED_ACTION",
           deferredAction: buildDeferredActionDigest({
             fullPreSignatureDeferredActionDigest,
-            sig: prefixSignatureKeyType(signature, "secp256k1"),
+            sig: prefixSignatureKeyType(signature.data, signature.type),
           }),
         }),
       };

package/src/remote/client.ts

@@ -1,20 +1,15 @@
 import { Provider } from "ox";
-import { createClient, custom, type Address, type JsonRpcAccount } from "viem";
-import { encodePermissionsContext } from "../capabilities/permissions/mav2.js";
+import { createClient, custom, type Address } from "viem";
+import { encodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
+import { WalletServerRpcSchema } from "@alchemy/wallet-api-types/rpc";
 import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
-import { WalletServerRpcSchema } from "../rpc/schema.js";
+import { internalStateDecorator } from "../internal/decorator.js";
 import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
   InnerWalletApiClientBase,
-} from "../types";
-
-export function createRemoteClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
->(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient<TAccount>;
+} from "../types.ts";
 
 /**
  * This is a low-level client just used to make RPC requests in remote mode
@@ -22,6 +17,10 @@ export function createRemoteClient<
  * that uses this client under the hood
  * @returns
  */
+export function createRemoteClient<
+  TAccount extends Address | undefined = Address | undefined,
+>(params: CreateInnerClientParams<TAccount>): InnerWalletApiClient;
+
 export function createRemoteClient(
   params: CreateInnerClientParams,
 ): InnerWalletApiClient {
@@ -34,10 +33,14 @@ export function createRemoteClient(
       ),
     chain,
     account,
-  }).extend((_client) => ({
-    policyId: params.policyId,
-    ...innerClientActions(_client),
-  }));
+  })
+    .extend((_client) => ({
+      policyId: params.policyId,
+      ...innerClientActions(_client),
+    }))
+    .extend(() => ({
+      internal: internalStateDecorator(),
+    }));
 
   return client;
 }
@@ -51,15 +54,12 @@ const innerClientActions = (
         method: "wallet_createSession",
         params: [params],
       });
-      const { signature } = await signSignatureRequest(
-        signer,
-        signatureRequest,
-      );
+      const signature = await signSignatureRequest(signer, signatureRequest);
       return {
         context: encodePermissionsContext({
           contextVersion: "REMOTE_MODE_DEFERRED_ACTION",
           sessionId,
-          signature,
+          signature: signature.data,
         }),
       };
     },