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

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 { TypeSerializedInitcode } from "../../schemas";
-import type { Capabilities } from "../../capabilities";
-import { parsePermissionsContext } from "./parsePermissionsContext";
+import { parsePermissionsContext } from "./parsePermissionsContext.js";
+import { assertNever } from "../../utils.js";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
+import { TypeSerializedInitcode } 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 TypeSerializedInitcode>; // 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 {
+  TypeEcdsaSig,
+  type TypeEcdsaSig as TypeEcdsaSigType,
+} from "@alchemy/wallet-api-types";
+import { assertNever } from "../../utils.js";
+
+export const decodeSignature = (
+  signature: TypeEcdsaSigType["signature"],
+): StaticDecode<typeof TypeEcdsaSig>["signature"] => {
+  switch (signature.type) {
+    case "ecdsa":
+    case "secp256k1":
+      return Value.Decode(TypeEcdsaSig, {
+        signature,
+      } satisfies TypeEcdsaSigType).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 type { PrepareCallsParams } from "../actions/prepareCalls";
-import type { TypeSerializedInitcode } from "../../schemas";
 import { InvalidRequestError } from "ox/RpcResponse";
-import { decodePermissionsContext } from "../../capabilities/permissions/mav2";
+import type { Address } from "viem";
+import { getAccountTypeForDelegationAddress7702 } from "./7702.js";
+import {
+  decodePermissionsContext,
+  PermissionsCapability,
+} from "@alchemy/wallet-api-types/capabilities";
+import { TypeSerializedInitcode } from "@alchemy/wallet-api-types";
 
 export function parsePermissionsContext(
-  capabilities: PrepareCallsParams["capabilities"],
-  parsedCi: StaticDecode<typeof TypeSerializedInitcode>,
+  permissions?: StaticDecode<typeof PermissionsCapability>,
+  parsedCi?: StaticDecode<typeof TypeSerializedInitcode> | 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 { TypeSerializedInitcode } from "@alchemy/wallet-api-types";
+
+export type Feature = "permissions";
+
+type FactoryType = StaticDecode<typeof TypeSerializedInitcode>["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 TypeSerializedInitcode>,
+  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,22 +1,23 @@
 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";
-import { signSignatureRequest } from "../client/actions/signSignatureRequest";
-import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls";
+} from "@alchemy/wallet-api-types/capabilities";
+import { signSignatureRequest } from "../client/actions/signSignatureRequest.js";
+import { internalStateDecorator } from "../internal/decorator.js";
+import type { PrepareCallsParams } from "../isomorphic/actions/prepareCalls.ts";
 import {
   createIsomorphicClient,
   type IsomorphicClient,
-} from "../isomorphic/client";
+} from "../isomorphic/client.js";
 import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
-} from "../types";
-import { assertNever } from "../utils";
+} from "../types.ts";
+import { assertNever } from "../utils.js";
 
 const localMethods = [
   "wallet_prepareCalls",
@@ -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 { WalletServerRpcSchema } from "../rpc/schema";
+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 { internalStateDecorator } from "../internal/decorator.js";
 import type {
   CreateInnerClientParams,
   InnerClientActions,
   InnerWalletApiClient,
   InnerWalletApiClientBase,
-} from "../types";
-import { signSignatureRequest } from "../client/actions/signSignatureRequest";
-import { encodePermissionsContext } from "../capabilities/permissions/mav2";
-
-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,
         }),
       };
     },

package/src/types.ts

@@ -1,47 +1,37 @@
+import type { SmartAccountSigner, SmartContractAccount } from "@aa-sdk/core";
 import type { AlchemyTransport } from "@account-kit/infra";
 import type {
   Address,
   Chain,
   Client,
   Hex,
-  IsUndefined,
   JsonRpcAccount,
   Transport,
 } from "viem";
-import type { WalletServerViemRpcSchema } from "./rpc/schema";
-import type { SmartAccountSigner } from "@aa-sdk/core";
 import type {
   GrantPermissionsParams,
   GrantPermissionsResult,
-} from "./client/actions/grantPermissions";
+} from "./client/actions/grantPermissions.ts";
+import type { RequestAccountParams } from "./client/actions/requestAccount.ts";
+import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
 
 export type CreateInnerClientParams<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
+  TAccount extends Address | undefined = Address | undefined,
 > = {
   chain: Chain;
   transport: AlchemyTransport;
   policyId?: string;
-} & (IsUndefined<TAccount> extends true
-  ? {
-      account?: never;
-    }
-  : {
-      account: Address;
-    });
+  account?: TAccount | Address | undefined;
+};
 
 export type InnerWalletApiClientBase<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
   TExtend extends { [key: string]: unknown } | undefined =
     | { [key: string]: unknown }
     | undefined,
 > = Client<
   Transport,
   Chain,
-  TAccount,
+  JsonRpcAccount<Address> | undefined,
   WalletServerViemRpcSchema,
   { policyId?: string } & TExtend
 >;
@@ -53,8 +43,24 @@ export type InnerClientActions = {
   ) => Promise<GrantPermissionsResult>;
 };
 
-export type InnerWalletApiClient<
-  TAccount extends JsonRpcAccount<Address> | undefined =
-    | JsonRpcAccount<Address>
-    | undefined,
-> = InnerWalletApiClientBase<TAccount, InnerClientActions>;
+export type CachedAccount = {
+  account: SmartContractAccount;
+  requestParams: RequestAccountParams;
+};
+
+export type InternalState = {
+  setAccount: (account: CachedAccount) => void;
+  getAccount: () => CachedAccount | undefined;
+};
+
+export type InnerWalletApiClient = InnerWalletApiClientBase<
+  InnerClientActions & { internal: InternalState }
+>;
+
+export type WithoutChainId<T> = T extends { chainId: Hex }
+  ? Omit<T, "chainId">
+  : T;
+
+export type WithoutRawPayload<T> = T extends { rawPayload: Hex }
+  ? Omit<T, "rawPayload">
+  : T;

package/src/utils.ts

@@ -1,5 +1,7 @@
 import { isHex, toHex, type Hex } from "viem";
 
+export type Expect<T extends true> = T;
+
 export const assertNever = (_val: never, msg: string): never => {
   throw new Error(msg);
 };

package/dist/esm/capabilities/index.d.ts

@@ -1,31 +0,0 @@
-export declare const Capabilities: import("@sinclair/typebox").TObject<{
-    permissions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        context: import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">;
-    }>>;
-    paymasterService: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        policyId: import("@sinclair/typebox").TString;
-    }>>;
-    gasParamsOverride: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
-        preVerificationGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        verificationGasLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        callGasLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        paymasterVerificationGasLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        paymasterPostOpGasLimit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        maxFeePerGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-        maxPriorityFeePerGas: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTemplateLiteralSyntax<"0x${string}">, import("@sinclair/typebox").TObject<{
-            multiplier: import("@sinclair/typebox").TNumber;
-        }>]>>;
-    }>>;
-}>;

package/dist/esm/capabilities/index.js

@@ -1,10 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { GasParamsOverrideCapability } from "./overrides";
-import { PaymasterCapability } from "./paymaster";
-import { PermissionsCapability } from "./permissions";
-export const Capabilities = Type.Object({
-    permissions: Type.Optional(PermissionsCapability),
-    paymasterService: Type.Optional(PaymasterCapability),
-    gasParamsOverride: Type.Optional(GasParamsOverrideCapability),
-}, { minProperties: 1 });
-//# sourceMappingURL=index.js.map