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

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -1,271 +0,0 @@
-import {
-  getEntryPoint,
-  type SmartAccountClient,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
-import { Value } from "@sinclair/typebox/value";
-import {
-  BaseError,
-  ChainNotFoundError,
-  concat,
-  concatHex,
-  getContract,
-  numberToHex,
-  parseSignature,
-  toHex,
-  type Address,
-  type Chain,
-  type Hex,
-  type Transport,
-} from "viem";
-import type {
-  wallet_sendPreparedCalls,
-  WalletServerViemRpcSchema,
-} from "@alchemy/wallet-api-types/rpc";
-import { decodePermissionsContext } from "@alchemy/wallet-api-types/capabilities";
-import { CallId } 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"]
->;
-
-// TODO: this only supports MAv2 right now, we need to fix this
-export async function sendPreparedCalls(
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-  params: SendPreparedCallsParams,
-): Promise<SendPreparedCallsResult> {
-  if (!client.chain) {
-    throw new ChainNotFoundError();
-  }
-
-  const deferredAction: Hex | undefined = (() => {
-    if (!params.capabilities?.permissions) {
-      return;
-    }
-
-    const decodedContext = decodePermissionsContext(
-      params.capabilities.permissions,
-    );
-
-    if (decodedContext.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
-      throw new InvalidRequestError({
-        message:
-          "Remote mode deferred action not supported in isomorphic client",
-      });
-    }
-
-    return decodedContext.deferredAction;
-  })();
-
-  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;
-
-  // 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 deferredActionData: Hex | undefined = deferredAction
-        ? await (async () => {
-            // determine whether the data should be appended to the signature.
-            // logic ported from @account-kit/smart-contracts `modularAccountV2Base.ts`
-
-            const deferredActionNonce = BigInt(
-              `0x${deferredAction.slice(4, 68)}`,
-            );
-
-            const entryPoint = getEntryPoint(client.chain, {
-              version: "0.7.0",
-            });
-
-            const entryPointContract = getContract({
-              address: entryPoint.address,
-              abi: entryPoint.abi,
-              client,
-            });
-
-            // Set these values if the deferred action has not been consumed. We check this with the EP
-            const nextNonceForDeferredAction: bigint =
-              (await entryPointContract.read.getNonce([
-                userOp.data.sender,
-                deferredActionNonce >> 64n,
-              ])) as bigint;
-
-            if (deferredActionNonce === nextNonceForDeferredAction) {
-              return `0x${deferredAction.slice(68)}`;
-            } else if (deferredActionNonce > nextNonceForDeferredAction) {
-              // if nonce is greater than the next nonce, its invalid, so we throw
-              throw new InvalidRequestError({
-                message: "Invalid session nonce",
-              });
-            }
-
-            // In this case, the deferred action has already been consumed, so no data should be appended to the signature.
-            // The signer entity should already be accounted for in `userOp.nonce`.
-            return undefined;
-          })()
-        : undefined;
-
-      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 deferredActionData != null
-              ? concatHex([deferredActionData, "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: hashes.map((hash) =>
-      Value.Encode(CallId, {
-        chainId: toHex(client.chain.id),
-        hash,
-      }),
-    ),
-  };
-}

package/src/isomorphic/client.ts

@@ -1,102 +0,0 @@
-import {
-  createSmartAccountClient,
-  type ClientMiddlewareFn,
-  type SmartAccountClient,
-  type SmartAccountClientRpcSchema,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
-import {
-  alchemyFeeEstimator,
-  alchemyGasAndPaymasterAndDataMiddleware,
-  alchemyGasManagerMiddleware,
-  type AlchemyTransport,
-} from "@account-kit/infra";
-import { type Chain, type Transport } from "viem";
-import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
-import {
-  createSession,
-  type CreateSessionParams,
-} from "./actions/createSession.js";
-import {
-  getCallsStatus,
-  type GetCallsStatusParams,
-} from "./actions/getCallsStatus.js";
-import {
-  prepareCalls,
-  type PrepareCallsParams,
-} from "./actions/prepareCalls.js";
-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 = {
-  chain: Chain;
-  transport: Transport;
-  policyId?: string;
-  useErc7677middleware?: boolean;
-  feeEstimator?: ClientMiddlewareFn;
-};
-
-export function isomorphicClientActions(
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-) {
-  return {
-    prepareCalls: (params: PrepareCallsParams) => prepareCalls(client, params),
-    sendPreparedCalls: (params: SendPreparedCallsParams) =>
-      sendPreparedCalls(client, params),
-    getCallsStatus: (params: GetCallsStatusParams) =>
-      getCallsStatus(client, params),
-    createSession: (params: CreateSessionParams) =>
-      createSession(client, params),
-    prepareSign: (params: PrepareSignParams) => prepareSign(client, params),
-    formatSign: (params: FormatSignParams) => formatSign(client, params),
-  };
-}
-
-// the isomorphic client likely won't be exposed directly. This client contains the business logic that can be run on the wallet server or on the client
-// if the dev chooses to run the client in "local" mode.
-export function createIsomorphicClient({
-  chain,
-  transport,
-  policyId,
-  useErc7677middleware = true,
-  feeEstimator,
-}: ClientParams): SmartAccountClient<
-  Transport,
-  Chain,
-  SmartContractAccount | undefined,
-  ReturnType<typeof isomorphicClientActions>,
-  WalletServerViemRpcSchema & SmartAccountClientRpcSchema
-> {
-  // This must be a smart account client since as of now we use it to build UOs under the hood
-  const client = createSmartAccountClient({
-    transport,
-    chain,
-    // TODO: we will want to enforce alchemy transport here probably
-    feeEstimator:
-      feeEstimator ?? alchemyFeeEstimator(transport as AlchemyTransport),
-    ...(policyId
-      ? useErc7677middleware
-        ? alchemyGasManagerMiddleware(policyId)
-        : // NOTE: DO NOT USE THIS MIDDLEWARE in the server, currently we require using the erc7677 middleware
-          alchemyGasAndPaymasterAndDataMiddleware({
-            policyId,
-            transport: transport as AlchemyTransport,
-          })
-      : {}),
-  }).extend(isomorphicClientActions);
-
-  return client;
-}
-
-export type IsomorphicClient = ReturnType<typeof createIsomorphicClient>;

package/src/isomorphic/utils/7702.ts

@@ -1,135 +0,0 @@
-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/createDummySigner.ts

@@ -1,27 +0,0 @@
-import { type SmartAccountSigner } from "@aa-sdk/core";
-import type { TypedData } from "abitype";
-import {
-  BaseError,
-  type Address,
-  type Hex,
-  type SignableMessage,
-  type TypedDataDefinition,
-} from "viem";
-
-export const createDummySigner = (address: Address): SmartAccountSigner => ({
-  signerType: "",
-  inner: undefined,
-  getAddress: async function (): Promise<`0x${string}`> {
-    return address;
-  },
-  // Not supported on the server
-  signMessage: function (_message: SignableMessage): Promise<Hex> {
-    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 BaseError("signTypedData not implemented by dummy signer.");
-  },
-});

package/src/isomorphic/utils/decodeSignature.ts

@@ -1,21 +0,0 @@
-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,51 +0,0 @@
-import type { StaticDecode } from "@sinclair/typebox";
-import { InvalidRequestError } from "ox/RpcResponse";
-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(
-  permissions?: StaticDecode<typeof PermissionsCapability>,
-  parsedCi?: StaticDecode<typeof SerializedInitcode> | undefined,
-  delegation7702?: Address,
-) {
-  if (!permissions) {
-    return undefined;
-  }
-
-  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(permissions);
-
-  if (context?.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
-    throw new InvalidRequestError({
-      message: "Remote mode deferred action not supported in isomorphic client",
-    });
-  }
-
-  return context;
-}

package/src/isomorphic/utils/supportsFeature.ts

@@ -1,34 +0,0 @@
-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);
-}