@alchemy/wallet-apis 0.0.0-alpha.12

package/src/actions/signPreparedCalls.ts

@@ -0,0 +1,120 @@
+import { assertNever, BaseError } from "@alchemy/common";
+import type { PrepareCallsResult } from "./prepareCalls.ts";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import type { Prettify } from "viem";
+import type {
+  PreparedCall_Authorization,
+  PreparedCall_UserOpV060,
+  PreparedCall_UserOpV070,
+} from "@alchemy/wallet-api-types";
+import type { InnerWalletApiClient } from "../types.js";
+import { LOGGER } from "../logger.js";
+import type { SendPreparedCallsParams } from "./sendPreparedCalls.js";
+
+export type SignPreparedCallsParams = Prettify<PrepareCallsResult>;
+
+export type SignPreparedCallsResult = SendPreparedCallsParams;
+
+/**
+ * Signs prepared calls using the provided signer.
+ *
+ * @param {InnerWalletApiClient} client - The wallet client to use for signing
+ * @param {SignPreparedCallsParams} params - The prepared calls with signature requests
+ * @returns {Promise<SignPreparedCallsResult>} A Promise that resolves to the signed calls
+ *
+ * @example
+ * ```ts
+ * // Prepare a user operation call.
+ * const preparedCalls = await client.prepareCalls({
+ *   calls: [{
+ *     to: "0x1234...",
+ *     data: "0xabcdef...",
+ *     value: "0x0"
+ *   }],
+ * });
+ *
+ * // Sign the prepared calls.
+ * const signedCalls = await client.signPreparedCalls(preparedCalls);
+ *
+ * // Send the signed calls.
+ * const result = await client.sendPreparedCalls(signedCalls);
+ * ```
+ */
+export async function signPreparedCalls(
+  client: InnerWalletApiClient,
+  params: SignPreparedCallsParams,
+): Promise<SignPreparedCallsResult> {
+  LOGGER.debug("signPreparedCalls:start", { type: params.type });
+  const signAuthorizationCall = async (call: PreparedCall_Authorization) => {
+    const { signatureRequest: _signatureRequest, ...rest } = call;
+    const signature = await signSignatureRequest(client, {
+      type: "eip7702Auth",
+      data: {
+        ...rest.data,
+        chainId: call.chainId,
+      },
+    });
+    return {
+      ...rest,
+      signature,
+    };
+  };
+
+  const signUserOperationCall = async (
+    call: PreparedCall_UserOpV060 | PreparedCall_UserOpV070,
+  ) => {
+    const { signatureRequest, ...rest } = call;
+
+    if (!signatureRequest) {
+      LOGGER.warn("signPreparedCalls:missing-signatureRequest", {
+        type: call.type,
+      });
+      throw new BaseError(
+        "Signature request is required for signing user operation calls. Ensure `onlyEstimation` is set to `false` when calling `prepareCalls`.",
+      );
+    }
+
+    const signature = await signSignatureRequest(client, signatureRequest);
+    const res = {
+      ...rest,
+      signature,
+    } as const;
+    LOGGER.debug("signPreparedCalls:userOp:ok");
+    return res;
+  };
+
+  if (params.type === "array") {
+    const res = {
+      type: "array" as const,
+      data: await Promise.all(
+        params.data.map((call) =>
+          call.type === "authorization"
+            ? signAuthorizationCall(call)
+            : signUserOperationCall(call),
+        ),
+      ),
+    };
+    LOGGER.debug("signPreparedCalls:array:ok", { count: res.data.length });
+    return res;
+  } else if (
+    params.type === "user-operation-v060" ||
+    params.type === "user-operation-v070"
+  ) {
+    const res = await signUserOperationCall(params);
+    LOGGER.debug("signPreparedCalls:single-userOp:ok");
+    return res;
+  } else if (params.type === "paymaster-permit") {
+    LOGGER.warn("signPreparedCalls:invalid-call-type", { type: params.type });
+    throw new BaseError(
+      `Invalid call type ${params.type} for signing prepared calls`,
+    );
+  } else {
+    LOGGER.warn("signPreparedCalls:unexpected-call-type", {
+      type: (params as { type?: unknown }).type,
+    });
+    return assertNever(
+      params,
+      `Unexpected call type in ${params} for signing prepared calls`,
+    );
+  }
+}

package/src/actions/signSignatureRequest.ts

@@ -0,0 +1,135 @@
+import { type Hex, hexToNumber, type Prettify, serializeSignature } from "viem";
+import type {
+  PersonalSignSignatureRequest,
+  TypedDataSignatureRequest,
+  AuthorizationSignatureRequest,
+  Eip7702UnsignedAuth,
+} from "@alchemy/wallet-api-types";
+import { vToYParity } from "ox/Signature";
+import type { InnerWalletApiClient, WithoutRawPayload } from "../types";
+import { assertNever } from "@alchemy/common";
+import { getAction } from "viem/utils";
+import { signAuthorization, signMessage, signTypedData } from "viem/actions";
+import { LOGGER } from "../logger.js";
+
+export type SignSignatureRequestParams = Prettify<
+  WithoutRawPayload<
+    | PersonalSignSignatureRequest
+    | TypedDataSignatureRequest
+    | (AuthorizationSignatureRequest & {
+        data: Eip7702UnsignedAuth;
+      })
+  >
+>;
+
+export type SignSignatureRequestResult = Prettify<{
+  type: "secp256k1";
+  data: Hex;
+}>;
+
+/**
+ * Signs a signature request using the provided signer.
+ * This method handles different types of signature requests including personal_sign, eth_signTypedData_v4, and authorization.
+ *
+ * @param {SmartAccountSigner} signer - The signer to use for signing the request
+ * @param {SignSignatureRequestParams} params - The signature request parameters
+ * @param {string} params.type - The type of signature request ('personal_sign', 'eth_signTypedData_v4', or 'signature_with_authorization')
+ * @param {SignSignatureRequestParams["data"]} params.data - The data to sign, format depends on the signature type
+ * @returns {Promise<SignSignatureRequestResult>} A Promise that resolves to the signature result
+ *
+ * @example
+ * ```ts
+ * // Sign a personal message
+ * const result = await client.signSignatureRequest({
+ *   type: 'personal_sign',
+ *   data: 'Hello, world!'
+ * });
+ *
+ * // Sign typed data (EIP-712)
+ * const result = await client.signSignatureRequest({
+ *   type: 'eth_signTypedData_v4',
+ *   data: {
+ *     domain: { ... },
+ *     types: { ... },
+ *     primaryType: '...',
+ *     message: { ... }
+ *   }
+ * });
+ * ```
+ */
+
+export async function signSignatureRequest(
+  client: InnerWalletApiClient,
+  params: SignSignatureRequestParams,
+): Promise<SignSignatureRequestResult> {
+  LOGGER.debug("signSignatureRequest:start", { type: params.type });
+  const actions = {
+    signMessage: getAction(client.owner, signMessage, "signMessage"),
+    signTypedData: getAction(client.owner, signTypedData, "signTypedData"),
+    signAuthorization: getAction(
+      client.owner,
+      signAuthorization,
+      "signAuthorization",
+    ),
+  };
+
+  switch (params.type) {
+    case "personal_sign": {
+      const res = {
+        type: "secp256k1",
+        data: await actions.signMessage({
+          message: params.data,
+          account: client.owner.account,
+        }),
+      } as const;
+      LOGGER.debug("signSignatureRequest:personal_sign:ok");
+      return res;
+    }
+    case "eth_signTypedData_v4": {
+      const res = {
+        type: "secp256k1",
+        data: await actions.signTypedData({
+          ...params.data,
+          account: client.owner.account,
+        }),
+      } as const;
+      LOGGER.debug("signSignatureRequest:typedData:ok");
+      return res;
+    }
+    case "eip7702Auth": {
+      const {
+        r,
+        s,
+        v,
+        yParity: _yParity,
+      } = await actions.signAuthorization({
+        ...{
+          ...params.data,
+          chainId: hexToNumber(params.data.chainId),
+          nonce: hexToNumber(params.data.nonce),
+        },
+        account: client.owner.account,
+      });
+      // yParity *should* already be a number, but some 3rd
+      // party signers may mistakenly return it as a bigint.
+      const yParity =
+        _yParity != null ? Number(_yParity) : vToYParity(Number(v));
+
+      const res = {
+        type: "secp256k1",
+        data: serializeSignature({
+          r,
+          s,
+          yParity,
+        }),
+      } as const;
+      LOGGER.debug("signSignatureRequest:eip7702Auth:ok");
+      return res;
+    }
+    default:
+      LOGGER.warn("signSignatureRequest:unknown-type", {
+        type: (params as { type?: unknown }).type,
+      });
+      return assertNever(params, `Unexpected signature request type.`);
+  }
+}

package/src/actions/signTypedData.ts

@@ -0,0 +1,90 @@
+import {
+  type Address,
+  type Hex,
+  type Prettify,
+  type TypedDataDefinition,
+} from "viem";
+import type { InnerWalletApiClient } from "../types.ts";
+import { requestAccount } from "./requestAccount.js";
+import { prepareSign } from "./prepareSign.js";
+import { signSignatureRequest } from "./signSignatureRequest.js";
+import { formatSign } from "./formatSign.js";
+import { typedDataToJsonSafe } from "../utils/format.js";
+import { LOGGER } from "../logger.js";
+
+export type SignTypedDataParams = Prettify<
+  TypedDataDefinition & {
+    account?: Address;
+  }
+>;
+
+export type SignTypedDataResult = Prettify<Hex>;
+
+/**
+ * Signs typed data (EIP-712) using the smart account.
+ * This method requests the account associated with the signer and uses it to sign the typed data.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {SignerClient} signerClient - The wallet client to use for signing
+ * @param {TypedDataDefinition} params - The typed data to sign, following EIP-712 format
+ * @returns {Promise<SignTypedDataResult>} A Promise that resolves to the signature as a hex string
+ *
+ * @example
+ * ```ts
+ * // Sign typed data
+ * const signature = await client.signTypedData({
+ *   domain: {
+ *     name: 'Example DApp',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC'
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' }
+ *     ]
+ *   },
+ *   primaryType: 'Person',
+ *   message: {
+ *     name: 'John Doe',
+ *     wallet: '0xAaAaAaAaAaAaAaAaAaAAAAAAAAaaaAaAaAaaAaAa'
+ *   }
+ * });
+ * ```
+ */
+
+export async function signTypedData(
+  client: InnerWalletApiClient,
+  params: SignTypedDataParams,
+): Promise<SignTypedDataResult> {
+  LOGGER.debug("signTypedData:start", {
+    hasExplicitAccount: params.account != null,
+    primaryType: params.primaryType,
+  });
+  const accountAddress = params.account ?? client.account?.address;
+  const account = await requestAccount(
+    client,
+    accountAddress != null ? { accountAddress } : undefined,
+  );
+
+  const prepared = await prepareSign(client, {
+    from: account.address,
+    signatureRequest: {
+      type: "eth_signTypedData_v4",
+      data: typedDataToJsonSafe(params),
+    },
+  });
+
+  const signed = await signSignatureRequest(client, prepared.signatureRequest);
+
+  const formatted = await formatSign(client, {
+    from: account.address,
+    signature: {
+      type: "ecdsa",
+      data: signed.data,
+    },
+  });
+  LOGGER.debug("signTypedData:done", { from: account.address });
+  return formatted.signature;
+}

package/src/client.ts

@@ -0,0 +1,107 @@
+import {
+  createClient,
+  type Address,
+  type Chain,
+  type LocalAccount,
+  createWalletClient,
+} from "viem";
+import { smartWalletActions } from "./decorators/smartWalletActions.js";
+import { type AlchemyTransport } from "@alchemy/common";
+import type { SignerClient, SmartWalletClient } from "./types.js";
+import { createInternalState } from "./internal.js";
+import type { CreationOptionsBySignerAddress } from "@alchemy/wallet-api-types";
+
+export type CreateSmartWalletClientParams<
+  TAccount extends Address | undefined = Address | undefined,
+> = {
+  signer: LocalAccount | SignerClient;
+  transport: AlchemyTransport;
+  chain: Chain;
+  account?: TAccount;
+  // TODO(v5): Reconsider if the client store store the policyIds, especially as
+  // new paymaster fields (i.e. for erc-20 support) are introduced. It might make
+  // more sense for them to be stored at a higher level like in the wagmi config
+  // or hooks.
+  policyId?: string;
+  policyIds?: string[];
+};
+
+/**
+ * Creates a smart wallet client with wallet API actions.
+ *
+ * @param {CreateSmartWalletClientParams} params - Parameters for creating the smart wallet client.
+ * @param {LocalAccount | JsonRpcAccount} params.account - The account to use for signing.
+ * @param {AlchemyTransport} params.transport - The transport to use for RPC calls.
+ * @param {Chain} params.chain - The blockchain network to connect to.
+ * @param {string[]} params.policyIds - Optional policy IDs for paymaster service.
+ * @returns {WalletClient} A wallet client extended with smart wallet actions.
+ */
+export const createSmartWalletClient = <
+  TAccount extends Address | undefined = Address | undefined,
+>({
+  account,
+  transport,
+  chain,
+  signer,
+  policyId,
+  policyIds,
+}: CreateSmartWalletClientParams<TAccount>): SmartWalletClient<TAccount> => {
+  const _policyIds = [...(policyId ? [policyId] : []), ...(policyIds ?? [])];
+
+  // If the signer is a `LocalAccount` wrap it inside of a client now so
+  // downstream actions can just use `getAction` to get signing actions
+  // and `signerClient.account.address` to access the address.
+  const signerClient =
+    "request" in signer
+      ? signer
+      : createWalletClient({
+          account: signer,
+          transport,
+          chain,
+        });
+
+  return createClient({
+    account,
+    transport,
+    chain,
+    name: "alchemySmartWalletClient",
+  })
+    .extend(() => ({
+      policyIds: _policyIds,
+      internal: createInternalState(),
+      owner: signerClient,
+    }))
+    .extend(smartWalletActions<TAccount>);
+};
+
+/**
+ * Creates a smart wallet client and requests an account in a single operation.
+ * This is a convenience function that combines client creation with account initialization.
+ *
+ * @param {CreateSmartWalletClientParams<undefined>} clientParams - Parameters for creating the smart wallet client (without an account).
+ * @param {CreationOptionsBySignerAddress | { accountAddress: Address }} accountOptions - Options for requesting the account. Can either be creation options for a new account or an object with an existing account address.
+ * @returns {Promise<SmartWalletClient<Address>>} A promise that resolves to a smart wallet client with an initialized account.
+ */
+export const createSmartWalletClientAndRequestAccount = async (
+  clientParams: CreateSmartWalletClientParams<undefined>,
+  accountOptions:
+    | CreationOptionsBySignerAddress
+    | { accountAddress: Address } = {},
+): Promise<SmartWalletClient<Address>> => {
+  const clientWithoutAccount = createSmartWalletClient(clientParams);
+
+  const account = await clientWithoutAccount.requestAccount(
+    "accountAddress" in accountOptions
+      ? {
+          accountAddress: accountOptions.accountAddress,
+        }
+      : {
+          creationHint: accountOptions,
+        },
+  );
+
+  return createSmartWalletClient({
+    ...clientParams,
+    account: account.address,
+  });
+};

package/src/decorators/smartWalletActions.ts

@@ -0,0 +1,123 @@
+import { type Hex, type Address } from "viem";
+import {
+  requestAccount,
+  type RequestAccountParams,
+  type RequestAccountResult,
+} from "../actions/requestAccount.js";
+import {
+  prepareCalls,
+  type PrepareCallsParams,
+  type PrepareCallsResult,
+} from "../actions/prepareCalls.js";
+import {
+  sendPreparedCalls,
+  type SendPreparedCallsParams,
+  type SendPreparedCallsResult,
+} from "../actions/sendPreparedCalls.js";
+import {
+  sendCalls,
+  type SendCallsParams,
+  type SendCallsResult,
+} from "../actions/sendCalls.js";
+import {
+  listAccounts,
+  type ListAccountsParams,
+  type ListAccountsResult,
+} from "../actions/listAccounts.js";
+import {
+  signSignatureRequest,
+  type SignSignatureRequestParams,
+  type SignSignatureRequestResult,
+} from "../actions/signSignatureRequest.js";
+import {
+  signPreparedCalls,
+  type SignPreparedCallsParams,
+  type SignPreparedCallsResult,
+} from "../actions/signPreparedCalls.js";
+import { signMessage, type SignMessageParams } from "../actions/signMessage.js";
+import {
+  signTypedData,
+  type SignTypedDataParams,
+} from "../actions/signTypedData.js";
+import {
+  grantPermissions,
+  type GrantPermissionsParams,
+  type GrantPermissionsResult,
+} from "../actions/grantPermissions.js";
+import type { InnerWalletApiClient } from "../types.js";
+import {
+  getCallsStatus,
+  waitForCallsStatus,
+  getCapabilities,
+  type GetCallsStatusParameters,
+  type GetCallsStatusReturnType,
+  type WaitForCallsStatusParameters,
+  type WaitForCallsStatusReturnType,
+  type GetCapabilitiesParameters,
+  type GetCapabilitiesReturnType,
+} from "viem/actions";
+
+export type SmartWalletActions<
+  TAccount extends Address | undefined = Address | undefined,
+> = {
+  requestAccount: (
+    params?: RequestAccountParams,
+  ) => Promise<RequestAccountResult>;
+  prepareCalls: (
+    params: PrepareCallsParams<TAccount>,
+  ) => Promise<PrepareCallsResult>;
+  sendPreparedCalls: (
+    params: SendPreparedCallsParams,
+  ) => Promise<SendPreparedCallsResult>;
+  sendCalls: (params: SendCallsParams<TAccount>) => Promise<SendCallsResult>;
+  listAccounts: (params: ListAccountsParams) => Promise<ListAccountsResult>;
+  signSignatureRequest: (
+    params: SignSignatureRequestParams,
+  ) => Promise<SignSignatureRequestResult>;
+  signPreparedCalls: (
+    params: SignPreparedCallsParams,
+  ) => Promise<SignPreparedCallsResult>;
+  signMessage: (params: SignMessageParams) => Promise<Hex>;
+  signTypedData: (params: SignTypedDataParams) => Promise<Hex>;
+  grantPermissions: (
+    params: GrantPermissionsParams<TAccount>,
+  ) => Promise<GrantPermissionsResult>;
+  getCallsStatus: (
+    params: GetCallsStatusParameters,
+  ) => Promise<GetCallsStatusReturnType>;
+  waitForCallsStatus: (
+    params: WaitForCallsStatusParameters,
+  ) => Promise<WaitForCallsStatusReturnType>;
+  getCapabilities: (
+    params?: GetCapabilitiesParameters | undefined,
+  ) => Promise<GetCapabilitiesReturnType>;
+};
+
+/**
+ * Decorator that adds smart wallet actions to a wallet API client.
+ * Provides both Alchemy-specific methods and standard viem wallet actions.
+ *
+ * @param {InnerWalletApiClient} client The wallet API client instance
+ * @returns {SmartWalletActions<TAccount>} An object containing smart wallet action methods
+ */
+export const smartWalletActions = <
+  TAccount extends Address | undefined = Address | undefined,
+>(
+  client: InnerWalletApiClient,
+): SmartWalletActions<TAccount> => ({
+  // Alchemy methods.
+  requestAccount: (params) => requestAccount(client, params),
+  prepareCalls: (params) => prepareCalls(client, params),
+  listAccounts: (params) => listAccounts(client, params),
+  sendPreparedCalls: (params) => sendPreparedCalls(client, params),
+  sendCalls: (params) => sendCalls(client, params), // TODO(v5): adapt this to fit viem's exact interface?
+  signSignatureRequest: (params) => signSignatureRequest(client, params),
+  signPreparedCalls: (params) => signPreparedCalls(client, params),
+  signMessage: (params) => signMessage(client, params),
+  signTypedData: (params) => signTypedData(client, params),
+  grantPermissions: (params) => grantPermissions(client, params),
+  // Viem methods.
+  getCallsStatus: (params) => getCallsStatus(client, params),
+  waitForCallsStatus: (params) => waitForCallsStatus(client, params),
+  getCapabilities: (params) => getCapabilities(client, params),
+});

package/src/experimental/actions/requestQuoteV0.ts

@@ -0,0 +1,95 @@
+import {
+  toHex,
+  type Address,
+  type IsUndefined,
+  type Prettify,
+  type UnionOmit,
+} from "viem";
+import type { OptionalChainId, InnerWalletApiClient } from "../../types.ts";
+import type { WalletServerRpcSchemaType } from "@alchemy/wallet-api-types/rpc";
+import { AccountNotFoundError } from "@alchemy/common";
+import { mergeClientCapabilities } from "../../utils/capabilities.js";
+
+type RpcSchema = Extract<
+  WalletServerRpcSchemaType,
+  {
+    Request: {
+      method: "wallet_requestQuote_v0";
+    };
+  }
+>;
+
+export type RequestQuoteV0Params<
+  TAccount extends Address | undefined = Address | undefined,
+> = Prettify<
+  OptionalChainId<UnionOmit<RpcSchema["Request"]["params"][0], "from">>
+> &
+  (IsUndefined<TAccount> extends true ? { from: Address } : { from?: never });
+
+export type RequestQuoteV0Result = Prettify<RpcSchema["ReturnType"]>;
+
+/**
+ * Requests a quote for a token swap, returning either prepared calls for smart wallets
+ * or raw calls for EOA wallets depending on the returnRawCalls parameter.
+ *
+ * @param {InnerWalletApiClient} client - The wallet API client to use for the request
+ * @param {RequestQuoteV0Params<TAccount>} params - Parameters for requesting a swap quote
+ * @param {Address} params.fromToken - The address of the token to swap from
+ * @param {Address} params.toToken - The address of the token to swap to
+ * @param {Hex} [params.fromAmount] - The amount to swap from (mutually exclusive with minimumToAmount)
+ * @param {Hex} [params.minimumToAmount] - The minimum amount to receive (mutually exclusive with fromAmount)
+ * @param {Address} [params.from] - The address to execute the swap from (required if the client wasn't initialized with an account)
+ * @param {Hex} [params.slippage] - The maximum acceptable slippage percentage
+ * @param {boolean} [params.returnRawCalls] - Whether to return raw calls for EOA wallets (defaults to false for smart wallets)
+ * @param {object} [params.capabilities] - Optional capabilities to include with the request (only available when returnRawCalls is false)
+ * @param {Array<{to: Address, data?: Hex, value?: Hex}>} [params.postCalls] - Optional calls to execute after the swap
+ * @returns {Promise<RequestQuoteV0Result>} A Promise that resolves to either prepared calls or raw calls depending on returnRawCalls
+ *
+ * @example
+ * ```ts twoslash
+ * // Request a quote for smart wallet (prepared calls)
+ * const quote = await client.requestQuoteV0({
+ *   fromToken: "0xA0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
+ *   toToken: "0xB0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
+ *   fromAmount: "0x1000000000000000000", // 1 ETH
+ *   capabilities: {
+ *     paymasterService: { policyId: "your-policy-id" }
+ *   }
+ * });
+ *
+ * // Request a quote for EOA wallet (raw calls)
+ * const rawQuote = await client.requestQuoteV0({
+ *   fromToken: "0xA0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
+ *   toToken: "0xB0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
+ *   fromAmount: "0x1000000000000000000",
+ *   returnRawCalls: true
+ * });
+ * ```
+ */
+export async function requestQuoteV0<
+  TAccount extends Address | undefined = Address | undefined,
+>(
+  client: InnerWalletApiClient,
+  params: RequestQuoteV0Params<TAccount>,
+): Promise<RequestQuoteV0Result> {
+  const from = params.from ?? client.account?.address;
+  if (!from) {
+    throw new AccountNotFoundError();
+  }
+
+  const capabilities = params.returnRawCalls
+    ? undefined
+    : mergeClientCapabilities(client, params.capabilities);
+
+  return await client.request({
+    method: "wallet_requestQuote_v0",
+    params: [
+      {
+        ...params,
+        chainId: params.chainId ?? toHex(client.chain.id),
+        from,
+        ...(capabilities && { capabilities }),
+      },
+    ],
+  });
+}