@account-kit/wallet-client 0.0.1-alpha.1

package/src/client/decorator.ts

@@ -0,0 +1,102 @@
+import type { SmartAccountSigner } from "@aa-sdk/core";
+import type {
+  Hex,
+  JsonRpcAccount,
+  SignableMessage,
+  TypedDataDefinition,
+} from "viem";
+import type {
+  SendPreparedCallsParams,
+  SendPreparedCallsResult,
+} from "../isomorphic/actions/sendPreparedCalls";
+import type { InnerWalletApiClient } from "../types";
+import {
+  createAccount,
+  type CreateAccountParams,
+  type CreateAccountResult,
+} from "./actions/createAccount";
+import {
+  listAccounts,
+  type ListAccountsParams,
+  type ListAccountsResult,
+} from "./actions/listAccounts";
+import {
+  prepareCalls,
+  type PrepareCallsParams,
+  type PrepareCallsResult,
+} from "./actions/prepareCalls";
+import {
+  requestAccount,
+  type RequestAccountParams,
+  type RequestAccountResult,
+} from "./actions/requestAccount";
+import {
+  getCallsStatus,
+  type GetCallsStatusParams,
+  type GetCallsStatusResult,
+} from "./actions/getCallsStatus";
+import {
+  signSignatureRequest,
+  type SignSignatureRequestParams,
+  type SignSignatureRequestResult,
+} from "./actions/signSignatureRequest";
+import { signMessage } from "./actions/signMessage";
+import { signTypedData } from "./actions/signTypedData";
+import {
+  grantPermissions,
+  type GrantPermissionsParams,
+  type GrantPermissionsResult,
+} from "./actions/grantPermissions";
+import { sendPreparedCalls } from "./actions/sendPreparedCalls";
+
+export type SmartWalletActions<
+  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+> = {
+  requestAccount: (
+    params?: RequestAccountParams<TAccount>,
+  ) => Promise<RequestAccountResult>;
+  prepareCalls: (
+    params: PrepareCallsParams<TAccount>,
+  ) => Promise<PrepareCallsResult>;
+  sendPreparedCalls: (
+    params: SendPreparedCallsParams,
+  ) => Promise<SendPreparedCallsResult>;
+  createAccount: (params: CreateAccountParams) => Promise<CreateAccountResult>;
+  listAccounts: (params: ListAccountsParams) => Promise<ListAccountsResult>;
+  getCallsStatus: (
+    params: GetCallsStatusParams,
+  ) => Promise<GetCallsStatusResult>;
+  signSignatureRequest: (
+    params: SignSignatureRequestParams,
+  ) => Promise<SignSignatureRequestResult>;
+  signMessage: (params: SignableMessage) => Promise<Hex>;
+  signTypedData: (params: TypedDataDefinition) => Promise<Hex>;
+  grantPermissions: (
+    params: GrantPermissionsParams,
+  ) => Promise<GrantPermissionsResult>;
+};
+
+export function smartWalletClientActions<
+  TAccount extends JsonRpcAccount | undefined = JsonRpcAccount | undefined,
+>(
+  client: InnerWalletApiClient<TAccount>,
+  signer: SmartAccountSigner,
+): SmartWalletActions<TAccount>;
+
+export function smartWalletClientActions(
+  client: InnerWalletApiClient,
+  signer: SmartAccountSigner,
+): SmartWalletActions {
+  return {
+    requestAccount: (params) => requestAccount(client, signer, params),
+    createAccount: (params) => createAccount(client, signer, params),
+    prepareCalls: (params) => prepareCalls(client, params),
+    listAccounts: (params) => listAccounts(client, params),
+    sendPreparedCalls: (params) => sendPreparedCalls(client, params),
+    getCallsStatus: (params) => getCallsStatus(client, params),
+    signSignatureRequest: (params) => signSignatureRequest(signer, params),
+    signMessage: (params) => signMessage(client, signer, params),
+    signTypedData: (params) => signTypedData(client, signer, params),
+    grantPermissions: (params) => grantPermissions(client, signer, params),
+  };
+}

package/src/client/index.ts

@@ -0,0 +1,93 @@
+import { type SmartAccountSigner } from "@aa-sdk/core";
+import { type AlchemyTransport } from "@account-kit/infra";
+import {
+  type Address,
+  type Chain,
+  type IsUndefined,
+  type JsonRpcAccount,
+  type Prettify,
+} from "viem";
+import { createLocalClient } from "../local/client";
+import { createRemoteClient } from "../remote/client";
+import type { InnerWalletApiClient } from "../types";
+import { smartWalletClientActions, type SmartWalletActions } from "./decorator";
+
+export type SmartWalletClientParams<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+> = Prettify<
+  {
+    transport: AlchemyTransport;
+    chain: Chain;
+    signer: SmartAccountSigner;
+    mode: "local" | "remote";
+    policyId?: string;
+  } & (IsUndefined<TAccount> extends true
+    ? {
+        account?: never;
+      }
+    : {
+        account: Address;
+      })
+>;
+
+export function createSmartWalletClient<
+  TAccount extends JsonRpcAccount<Address> | undefined =
+    | JsonRpcAccount<Address>
+    | undefined,
+>(
+  params: SmartWalletClientParams<TAccount>,
+): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+
+export function createSmartWalletClient<
+  TAccount extends JsonRpcAccount<Address> = JsonRpcAccount<Address>,
+>(
+  params: SmartWalletClientParams<TAccount>,
+): InnerWalletApiClient<TAccount> & SmartWalletActions<TAccount>;
+
+export function createSmartWalletClient(params: SmartWalletClientParams) {
+  const { transport, chain, policyId, mode, account, signer } = params;
+
+  const innerClient =
+    mode === "local"
+      ? createLocalClient({
+          transport,
+          chain,
+          policyId,
+          account,
+        })
+      : createRemoteClient({
+          transport,
+          chain,
+          policyId,
+          account,
+        });
+
+  // TODO: we need to do a few things here:
+  // 1. decorate the client with the wallet api actions
+  // 2. potentially we might want to make this client async and have it use `requestAccount` so that it can create a SCA client with an account attached to it
+  return innerClient.extend((client) =>
+    smartWalletClientActions(client, signer),
+  );
+}
+
+// Example usage:
+// const clientWithoutAccount = createSmartWalletClient({
+//   transport: alchemy({ apiKey: "123" }),
+//   chain: baseSepolia,
+//   signer: createDummySigner(zeroAddress),
+//   mode: "local",
+// });
+
+// const account1 = await clientWithoutAccount.requestAccount();
+
+// const clientWithAccount = createSmartWalletClient({
+//   transport: alchemy({ apiKey: "123" }),
+//   chain: baseSepolia,
+//   signer: createDummySigner(zeroAddress),
+//   mode: "local",
+//   account: zeroAddress,
+// });
+
+// const account2 = await clientWithAccount.requestAccount();

package/src/exports/index.ts

@@ -0,0 +1,32 @@
+// TODO: anything that we want to expose publicly should be exported from `index.ts` files in the subdirectories
+// and we shouldn't export * for the sake of tree-shaking
+export {
+  createSmartWalletClient,
+  type SmartWalletClientParams,
+} from "../client";
+
+export {
+  WalletServerRpcSchema,
+  type WalletServerRpcSchemaType,
+  type WalletServerViemRpcSchema,
+} from "../rpc/schema";
+
+// capabilities: TODO: should these actually just have the types exported?
+export { Capabilities } from "../capabilities";
+export { PaymasterCapability } from "../capabilities/paymaster";
+export {
+  PermissionsArray,
+  PermissionsCapability,
+  PermissionsContext,
+  PermissionsData,
+} from "../capabilities/permissions";
+
+// client actions
+export { createAccount } from "../client/actions/createAccount";
+export { listAccounts } from "../client/actions/listAccounts";
+export { prepareCalls } from "../client/actions/prepareCalls";
+export { requestAccount } from "../client/actions/requestAccount";
+export { getCallsStatus } from "../client/actions/getCallsStatus";
+export { signSignatureRequest } from "../client/actions/signSignatureRequest";
+export { signMessage } from "../client/actions/signMessage";
+export { signTypedData } from "../client/actions/signTypedData";

package/src/exports/internal.ts

@@ -0,0 +1,16 @@
+// exports from this file are meant to be imported by our packages in the monorepo
+// we will expose this in the package.json as a named export like `this-pkg/internal`
+// TODO: name `this-pkg`
+export * from "../capabilities";
+export * from "../capabilities/paymaster";
+export * from "../capabilities/permissions";
+export * from "../capabilities/permissions/mav2";
+export type * from "../isomorphic/client";
+export { createIsomorphicClient } from "../isomorphic/client";
+export { createDummySigner } from "../isomorphic/utils/createDummySigner";
+export * from "../rpc/request";
+export * as RpcSchemas from "../rpc/request";
+export * from "../rpc/schema";
+export * from "../schemas";
+export type * from "../types";
+export * from "../utils";

package/src/isomorphic/actions/createSession.ts

@@ -0,0 +1,116 @@
+import {
+  createSmartAccountClient,
+  type SmartAccountClient,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import {
+  ChainNotFoundError,
+  type Chain,
+  type Transport,
+  custom,
+  hexToNumber,
+  type Hex,
+  toHex,
+} from "viem";
+import type { wallet_createSession } from "../../rpc/request";
+import type { WalletServerViemRpcSchema } from "../../rpc/schema";
+import type { Static } from "@sinclair/typebox";
+import { isGlobalValidation } from "../../capabilities/permissions/mav2";
+import {
+  deferralActions,
+  PermissionBuilder,
+} from "@account-kit/smart-contracts/experimental";
+import { createDummySigner } from "../utils/createDummySigner";
+import { createAccount, isModularAccountV2 } from "../utils/createAccount";
+
+export type CreateSessionParams = Omit<
+  Static<
+    (typeof wallet_createSession)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "chainId"
+> & {
+  entityId?: Hex;
+};
+
+export type CreateSessionResult = Omit<
+  Static<(typeof wallet_createSession)["properties"]["ReturnType"]>,
+  "sessionId"
+> & {
+  sessionId: Hex | null;
+  entityId: Hex;
+  fullPreSignatureDeferredActionDigest: Hex;
+};
+
+export async function createSession(
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: CreateSessionParams,
+): Promise<CreateSessionResult> {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  const { counterfactualInfo } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      {
+        includeCounterfactualInfo: true,
+        accountAddress: params.account,
+      },
+    ],
+  });
+  if (!counterfactualInfo) {
+    throw new Error("No counterfactual info found.");
+  }
+
+  const account = await createAccount({
+    chain: client.chain,
+    transport: custom(client.transport),
+    signer: createDummySigner(params.account),
+    accountAddress: params.account,
+    counterfactualInfo,
+  });
+
+  if (!isModularAccountV2(account)) {
+    throw new Error("Sessions are currently only supported by MAv2 accounts.");
+  }
+
+  const _client = createSmartAccountClient({
+    chain: client.chain,
+    transport: custom(client.transport),
+    account,
+  }).extend(deferralActions);
+
+  const { entityId, nonce } = await _client.getEntityIdAndNonce({
+    entityId: params.entityId ? hexToNumber(params.entityId) : undefined,
+    isGlobalValidation: isGlobalValidation(params),
+  });
+
+  const { typedData, fullPreSignatureDeferredActionDigest } =
+    await new PermissionBuilder({
+      client: _client,
+      key: params.key,
+      entityId,
+      nonce,
+      deadline: params.expiry,
+    })
+      .addPermissions({
+        permissions: params.permissions,
+      })
+      .compileDeferred();
+
+  return {
+    sessionId: null, // In remote mode, the server will set this later.
+    entityId: toHex(entityId),
+    signatureRequest: {
+      type: "eth_signTypedData_v4",
+      data: typedData,
+    },
+    fullPreSignatureDeferredActionDigest,
+  };
+}

package/src/isomorphic/actions/getCallsStatus.ts

@@ -0,0 +1,98 @@
+import {
+  type SmartAccountClient,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import {
+  ChainNotFoundError,
+  type Chain,
+  type Hex,
+  type TransactionReceipt,
+  type Transport,
+  isHex,
+} from "viem";
+import type { wallet_getCallsStatus } from "../../rpc/request";
+import type { WalletServerViemRpcSchema } from "../../rpc/schema";
+import { TypeCallId } from "../../schemas";
+import { castToHex } from "../../utils";
+import { Value } from "@sinclair/typebox/value";
+
+export type GetCallsStatusParams = Static<
+  (typeof wallet_getCallsStatus)["properties"]["Request"]["properties"]["params"]
+>[0];
+
+export type GetCallsStatusResponse = Static<
+  (typeof wallet_getCallsStatus)["properties"]["ReturnType"]
+>;
+
+const ReceiptStatus: Record<TransactionReceipt["status"], Hex> = {
+  reverted: "0x0",
+  success: "0x1",
+};
+
+/** EIP-5792 call status codes */
+export const CallStatusCode = {
+  /** Batch has been received by the wallet but has not completed execution onchain */
+  PENDING: 100,
+  /** Batch has been included onchain without reverts, receipts array contains info of all calls */
+  CONFIRMED: 200,
+  /** Batch has not been included onchain and wallet will not retry */
+  OFFCHAIN_FAILURE: 400,
+  /** Batch reverted *completely* and only changes related to gas charge may have been included onchain */
+  CHAIN_RULES_FAILURE: 500,
+  /** Batch reverted *partially* and some changes related to batch calls may have been included onchain */
+  PARTIAL_CHAIN_RULES_FAILURE: 600,
+} as const;
+
+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 result = await client.getUserOperationReceipt(hash);
+
+  return {
+    id: callId,
+    chainId,
+    atomic: true,
+    status: !result?.receipt
+      ? CallStatusCode.PENDING
+      : result.success
+        ? CallStatusCode.CONFIRMED
+        : CallStatusCode.CHAIN_RULES_FAILURE,
+    receipts: !result?.receipt ? undefined : [transformReceipt(result.receipt)],
+  };
+}
+
+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

@@ -0,0 +1,99 @@
+import {
+  deepHexlify,
+  type SmartAccountClient,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import type { Static } from "@sinclair/typebox";
+import {
+  custom,
+  fromHex,
+  zeroAddress,
+  type Chain,
+  type Transport,
+  ChainNotFoundError,
+  toHex,
+} from "viem";
+import type { wallet_prepareCalls } from "../../rpc/request";
+import type { WalletServerViemRpcSchema } from "../../rpc/schema";
+import { createAccount } from "../utils/createAccount";
+import { createDummySigner } from "../utils/createDummySigner";
+
+export type PrepareCallsParams = Omit<
+  Static<
+    (typeof wallet_prepareCalls)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "chainId"
+>;
+
+export type PrepareCallsResult = Static<
+  (typeof wallet_prepareCalls)["properties"]["ReturnType"]
+>;
+
+// TODO: handle capabilities like permissions and paymaster here
+export async function prepareCalls(
+  client: SmartAccountClient<
+    Transport,
+    Chain,
+    SmartContractAccount | undefined,
+    Record<string, unknown>,
+    WalletServerViemRpcSchema
+  >,
+  params: PrepareCallsParams,
+): Promise<PrepareCallsResult> {
+  if (!client.chain) {
+    throw new ChainNotFoundError();
+  }
+
+  // in local mode, we probably want some kind of caching for this
+  const { counterfactualInfo } = await client.request({
+    method: "wallet_requestAccount",
+    params: [
+      {
+        accountAddress: params.from,
+        includeCounterfactualInfo: true,
+      },
+    ],
+  });
+  if (!counterfactualInfo) {
+    throw new Error("No counterfactual info found.");
+  }
+
+  const account = await createAccount({
+    chain: client.chain,
+    transport: custom(client.transport),
+    signer: createDummySigner(zeroAddress),
+    accountAddress: params.from,
+    counterfactualInfo,
+    capabilities: params.capabilities,
+  });
+
+  // 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,
+  });
+
+  const uoRequest = deepHexlify(builtUo);
+
+  const hash = account.getEntryPoint().getUserOperationHash(uoRequest);
+
+  return {
+    type:
+      account.getEntryPoint().version === "0.7.0"
+        ? "user-operation-v070"
+        : "user-operation-v060",
+    data: uoRequest,
+    chainId: toHex(client.chain.id),
+    signatureRequest: {
+      type: "personal_sign",
+      data: {
+        raw: hash,
+      },
+    },
+  };
+}

package/src/isomorphic/actions/sendPreparedCalls.ts

@@ -0,0 +1,95 @@
+import {
+  getEntryPoint,
+  type SmartAccountClient,
+  type SmartContractAccount,
+} from "@aa-sdk/core";
+import {
+  ChainNotFoundError,
+  concat,
+  concatHex,
+  toHex,
+  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 { Value } from "@sinclair/typebox/value";
+import { TypeCallId } from "../../schemas";
+import type { Static } from "@sinclair/typebox";
+
+export type SendPreparedCallsParams = Omit<
+  Static<
+    (typeof wallet_sendPreparedCalls)["properties"]["Request"]["properties"]["params"]
+  >[0],
+  "chainId"
+>;
+
+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?.context) {
+      return;
+    }
+
+    const decodedContext = decodePermissionsContext(
+      params.capabilities.permissions.context,
+    );
+
+    if (decodedContext.contextVersion === "REMOTE_MODE_DEFERRED_ACTION") {
+      throw new Error(
+        "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 callId = Value.Encode(TypeCallId, {
+    chainId: toHex(client.chain.id),
+    hash,
+  });
+
+  return {
+    preparedCallIds: [callId],
+  };
+}