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

package/src/isomorphic/actions/getCallsStatus.ts

@@ -1,112 +0,0 @@
-import {
-  type SmartAccountClient,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
-import {
-  ChainNotFoundError,
-  isHex,
-  type Chain,
-  type Hex,
-  type TransactionReceipt,
-  type Transport,
-} from "viem";
-import { BaseError } from "ox/RpcResponse";
-import {
-  CallStatusCode,
-  CallStatusErrorCode,
-  type wallet_getCallsStatus,
-  type WalletServerViemRpcSchema,
-} from "@alchemy/wallet-api-types/rpc";
-import { TypeCallId } from "@alchemy/wallet-api-types";
-import { castToHex } from "../../utils.js";
-
-export type GetCallsStatusParams = Static<
-  (typeof wallet_getCallsStatus)["properties"]["Request"]["properties"]["params"]
->[0];
-
-export type GetCallsStatusResponse = Static<
-  (typeof wallet_getCallsStatus)["properties"]["ReturnType"]
->;
-
-export async function getCallsStatus(
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-  callId: GetCallsStatusParams,
-): Promise<GetCallsStatusResponse> {
-  if (!client.chain) {
-    throw new ChainNotFoundError();
-  }
-  const { chainId, hash } = Value.Decode(TypeCallId, callId);
-
-  const baseResp = {
-    id: callId,
-    chainId,
-    atomic: true,
-  };
-
-  const result = await client.getUserOperationByHash(hash);
-  if (!result) {
-    throw new BaseError({
-      message: `callId ${callId} not found`,
-      code: CallStatusErrorCode.UNKNOWN_BUNDLE_ID,
-    });
-  }
-  if (result && !result.transactionHash) {
-    // A result but no txn hash means it's valid but pending.
-    return {
-      ...baseResp,
-      status: CallStatusCode.PENDING,
-    };
-  }
-
-  const receipt = await client.getUserOperationReceipt(hash);
-  if (!receipt) {
-    // Handles edge case of hash being retrieved immediately before the 150 block limit falloff.
-    throw new BaseError({
-      message: `callId ${callId} not found`,
-      code: CallStatusErrorCode.UNKNOWN_BUNDLE_ID,
-    });
-  }
-
-  return {
-    ...baseResp,
-    status: receipt.success
-      ? CallStatusCode.CONFIRMED
-      : CallStatusCode.CHAIN_RULES_FAILURE,
-    receipts: [transformReceipt(receipt.receipt)],
-  };
-}
-
-const ReceiptStatus: Record<TransactionReceipt["status"], Hex> = {
-  reverted: "0x0",
-  success: "0x1",
-};
-
-function transformReceipt(
-  receipt: TransactionReceipt,
-): NonNullable<GetCallsStatusResponse["receipts"]>[number] {
-  return {
-    // viem's type for status is "success" | "reverted", but the actual value seems to already be 0x0 or 0x1
-    status: isHex(receipt.status)
-      ? receipt.status
-      : ReceiptStatus[receipt.status],
-    blockHash: receipt.blockHash,
-    // viem's type for blockNumber is bigint, but the actual value seems to already be a hex string
-    blockNumber: castToHex(receipt.blockNumber),
-    // viem's type for gasUsed is bigint, but the actual value seems to already be a hex string
-    gasUsed: castToHex(receipt.gasUsed),
-    transactionHash: receipt.transactionHash,
-    logs: receipt.logs.map((log) => ({
-      address: log.address,
-      data: log.data,
-      topics: log.topics,
-    })),
-  };
-}

package/src/isomorphic/actions/prepareCalls.ts

@@ -1,172 +0,0 @@
-import {
-  deepHexlify,
-  default7702GasEstimator,
-  type SmartAccountClient,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
-import type { Static } from "@sinclair/typebox";
-import {
-  ChainNotFoundError,
-  custom,
-  fromHex,
-  hashMessage,
-  toHex,
-  type Chain,
-  type Transport,
-} from "viem";
-import type {
-  wallet_prepareCalls,
-  WalletServerViemRpcSchema,
-} from "@alchemy/wallet-api-types/rpc";
-import { createAccount } from "../utils/createAccount.js";
-import { createDummySigner } from "../utils/createDummySigner.js";
-import { createAuthorizationRequest, isDelegated } from "../utils/7702.js";
-import { InvalidRequestError } from "ox/RpcResponse";
-import { assertNever } from "../../utils.js";
-import { assertValid7702AccountAddress } from "../utils/7702.js";
-
-export type PrepareCallsParams = Omit<
-  Static<
-    (typeof wallet_prepareCalls)["properties"]["Request"]["properties"]["params"]
-  >[0],
-  "chainId"
->;
-
-export type PrepareCallsResult = Static<
-  (typeof wallet_prepareCalls)["properties"]["ReturnType"]
->;
-
-export async function prepareCalls(
-  client: SmartAccountClient<
-    Transport,
-    Chain,
-    SmartContractAccount | undefined,
-    Record<string, unknown>,
-    WalletServerViemRpcSchema
-  >,
-  params: PrepareCallsParams,
-): Promise<PrepareCallsResult> {
-  if (!client.chain) {
-    throw new ChainNotFoundError();
-  }
-
-  assertValid7702AccountAddress(params.from, params.capabilities?.eip7702Auth);
-
-  // in local mode, we probably want some kind of caching for this
-  const { counterfactualInfo, delegation } = await client.request({
-    method: "wallet_requestAccount",
-    params: [
-      params.capabilities?.eip7702Auth
-        ? {
-            signerAddress: params.from,
-            creationHint: {
-              accountType: "7702",
-            },
-            includeCounterfactualInfo: true,
-          }
-        : {
-            accountAddress: params.from,
-            includeCounterfactualInfo: true,
-          },
-    ],
-  });
-
-  if (!counterfactualInfo && !delegation) {
-    throw new InvalidRequestError({
-      message:
-        "No counterfactual info or delegated implementation address found.",
-    });
-  }
-
-  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 authorizationRequest =
-    delegation &&
-    !(await isDelegated(client, {
-      address: account.address,
-      delegation,
-    }))
-      ? await createAuthorizationRequest(client, {
-          address: account.address,
-          delegation,
-        })
-      : undefined;
-
-  if (params.capabilities?.permissions && authorizationRequest) {
-    // The user shouldn't see this in most cases since we require
-    // the account to be delegated before creating the session.
-    throw new InvalidRequestError({
-      message:
-        "When using a 7702 account with a session key, the account must be delegated before preparing calls.",
-    });
-  }
-
-  if (authorizationRequest) {
-    // @ts-expect-error - this is available but not typed as public
-    client.middleware.gasEstimator = default7702GasEstimator();
-  }
-
-  // TODO: oops we don't actually support setting the policyId as an override here
-  // if we assume that the the isomorphic client is never used directly, then we can assume that this is handled upstream correctly
-  const builtUo = await client.buildUserOperation({
-    uo: params.calls.map((x) => ({
-      target: x.to,
-      data: x.data ?? "0x",
-      value: x.value ? fromHex(x.value, "bigint") : undefined,
-    })),
-    account,
-    overrides: {
-      ...params.capabilities?.gasParamsOverride,
-      nonceKey: params.capabilities?.nonceOverride?.nonceKey
-        ? fromHex(params.capabilities.nonceOverride.nonceKey, "bigint")
-        : undefined,
-    },
-  });
-
-  // The eip7702Auth field should never be included in the UO sig
-  // request. It's handled by a separate authorization request.
-  if ("eip7702Auth" in builtUo) {
-    builtUo.eip7702Auth = undefined;
-  }
-
-  const hexlifiedUo = deepHexlify(builtUo);
-
-  const ep = account.getEntryPoint();
-
-  const uoHash = ep.getUserOperationHash(hexlifiedUo);
-
-  const uoRequest = {
-    type:
-      ep.version === "0.7.0"
-        ? ("user-operation-v070" as const)
-        : ep.version === "0.6.0"
-          ? ("user-operation-v060" as const)
-          : assertNever(ep.version, "Unexpected entry point version"),
-    data: hexlifiedUo,
-    chainId: toHex(client.chain.id),
-    signatureRequest: {
-      type: "personal_sign" as const,
-      data: {
-        raw: uoHash,
-      },
-      rawPayload: hashMessage({
-        raw: uoHash,
-      }),
-    },
-  };
-
-  return authorizationRequest
-    ? {
-        type: "array" as const,
-        data: [authorizationRequest, uoRequest],
-      }
-    : uoRequest;
-}

package/src/isomorphic/actions/prepareSign.ts

@@ -1,91 +0,0 @@
-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

@@ -1,234 +0,0 @@
-import {
-  getEntryPoint,
-  type SmartAccountClient,
-  type SmartContractAccount,
-} from "@aa-sdk/core";
-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 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"]
->;
-
-// 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 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: hashes.map((hash) =>
-      Value.Encode(TypeCallId, {
-        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>;