@account-kit/smart-contracts 4.0.0-alpha.0 → 4.0.0-alpha.10

package/src/msca/plugins/multisig/utils/splitAggregatedSignature.ts

@@ -19,15 +19,23 @@ export type SplitAggregateSignatureParams<
   account: SmartContractAccount;
   request: UserOperationRequest<TEntryPointVersion>;
 };
+
+export type SplitAggregateSignatureResult = {
+  upperLimitPvg: Hex;
+  upperLimitMaxFeePerGas: Hex;
+  upperLimitMaxPriorityFeePerGas: Hex;
+  signatures: Signature[];
+};
+
 /**
  * Takes an aggregated signature and threshold and splits it into its components
  *
- * @param args - the arguments for the split
- * @param args.aggregateSignature - the aggregated signature to split
- * @param args.threshold - the threshold for the signature
- * @param args.account - the account which the signature is valid for
- * @param args.request - the user operation request that the signature is for
- * @returns the signature split into its upper limits and current signatures
+ * @param {SplitAggregateSignatureParams<TAccount>} args - the arguments for the split
+ * @param {Hex} args.aggregateSignature - the aggregated signature to split
+ * @param {number} args.threshold - the threshold for the signature
+ * @param {SmartContractAccount} args.account - the account which the signature is valid for
+ * @param {UserOperationRequest<TEntryPointVersion>} args.request - the user operation request that the signature is for
+ * @returns {Promise<SplitAggregateSignatureResult>} the signature split into its upper limits and current signatures
  */
 export const splitAggregatedSignature = async <
   TAccount extends SmartContractAccount | undefined =
@@ -35,12 +43,7 @@ export const splitAggregatedSignature = async <
     | undefined
 >(
   args: SplitAggregateSignatureParams<TAccount>
-): Promise<{
-  upperLimitPvg: Hex;
-  upperLimitMaxFeePerGas: Hex;
-  upperLimitMaxPriorityFeePerGas: Hex;
-  signatures: Signature[];
-}> => {
+): Promise<SplitAggregateSignatureResult> => {
   const { aggregatedSignature, threshold, account, request } = args;
   if (aggregatedSignature.length < 192 + (65 * threshold - 1)) {
     throw new InvalidAggregatedSignatureError();

package/src/msca/plugins/session-key/extension.ts

@@ -82,6 +82,19 @@ export type SessionKeyPluginActions<
       }
     : {});
 
+/**
+ * Creates actions for managing session keys in a smart contract associated with a client, including adding, removing, rotating, and updating session key permissions.
+ *
+ * @example
+ * ```ts
+ * import { createModularAccountAlchemyClient, sessionKeyPluginActions } from "@account-kit/smart-contracts";
+ *
+ * const client = createModularAccountAlchemyClient(...).extend(sessionKeyPluginActions);
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance to use for managing session keys
+ * @returns {SessionKeyPluginActions<TAccount>} An object containing methods for session key management and interaction with the smart contract
+ */
 export const sessionKeyPluginActions: <
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,

package/src/msca/plugins/session-key/index.ts

@@ -1,3 +1,9 @@
 export type * from "./extension.js";
 export { sessionKeyPluginActions } from "./extension.js";
-export { SessionKeyPlugin } from "./plugin.js";
+
+export {
+  SessionKeyPlugin,
+  SessionKeyPluginAbi,
+  SessionKeyPluginExecutionFunctionAbi,
+  type InstallSessionKeyPluginParams,
+} from "./plugin.js";

package/src/msca/plugins/session-key/permissions.ts

@@ -56,6 +56,9 @@ export type GasSpendLimit = {
   refreshInterval?: number;
 };
 
+/**
+ * A builder for creating the hex-encoded data for updating session key permissions.
+ */
 export class SessionKeyPermissionsBuilder {
   private _contractAccessControlType: SessionKeyAccessListType =
     SessionKeyAccessListType.ALLOWLIST;
@@ -67,46 +70,192 @@ export class SessionKeyPermissionsBuilder {
   private _gasSpendLimit?: GasSpendLimit;
   private _requiredPaymaster?: Address;
 
+  /**
+   * Sets the access control type for the contract and returns the current instance for method chaining.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setContractAccessControlType(SessionKeyAccessListType.ALLOWLIST);
+   * ```
+   *
+   * @param {SessionKeyAccessListType} aclType The access control type for the session key
+   * @returns {SessionKeyPermissionsBuilder} The current instance for method chaining
+   */
   public setContractAccessControlType(aclType: SessionKeyAccessListType) {
     this._contractAccessControlType = aclType;
     return this;
   }
 
+  /**
+   * Adds a contract access entry to the internal list of contract address access entries.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.addContractAddressAccessEntry({
+   *  contractAddress: "0x1234",
+   *  isOnList: true,
+   *  checkSelectors: true,
+   * });
+   * ```
+   *
+   * @param {ContractAccessEntry} entry the contract access entry to be added
+   * @returns {SessionKeyPermissionsBuilder} the instance of the current class for chaining
+   */
   public addContractAddressAccessEntry(entry: ContractAccessEntry) {
     this._contractAddressAccessEntrys.push(entry);
     return this;
   }
 
+  /**
+   * Adds a contract method entry to the `_contractMethodAccessEntrys` array.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.addContractAddressAccessEntry({
+   *  contractAddress: "0x1234",
+   *  methodSelector: "0x45678",
+   *  isOnList: true,
+   * });
+   * ```
+   *
+   * @param {ContractMethodEntry} entry The contract method entry to be added
+   * @returns {SessionKeyPermissionsBuilder} The instance of the class for method chaining
+   */
   public addContractFunctionAccessEntry(entry: ContractMethodEntry) {
     this._contractMethodAccessEntrys.push(entry);
     return this;
   }
 
+  /**
+   * Sets the time range for an object and returns the object itself for chaining.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setTimeRange({
+   *  validFrom: Date.now(),
+   *  validUntil: Date.now() + (15 * 60 * 1000),
+   * });
+   * ```
+   *
+   * @param {TimeRange} timeRange The time range to be set
+   * @returns {SessionKeyPermissionsBuilder} The current object for method chaining
+   */
   public setTimeRange(timeRange: TimeRange) {
     this._timeRange = timeRange;
     return this;
   }
 
+  /**
+   * Sets the native token spend limit and returns the instance for chaining.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setNativeTokenSpendLimit({
+   *  spendLimit: 1000000000000000000n,
+   *  refreshInterval: 3600,
+   * });
+   * ```
+   *
+   * @param {NativeTokenLimit} limit The limit to set for native token spending
+   * @returns {SessionKeyPermissionsBuilder} The instance for chaining
+   */
   public setNativeTokenSpendLimit(limit: NativeTokenLimit) {
     this._nativeTokenSpendLimit = limit;
     return this;
   }
 
+  /**
+   * Adds an ERC20 token spend limit to the list of limits and returns the updated object.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.addErc20TokenSpendLimit({
+   *  tokenAddress: "0x1234",
+   *  spendLimit: 1000000000000000000n,
+   *  refreshInterval: 3600,
+   * });
+   * ```
+   *
+   * @param {Erc20TokenLimit} limit The ERC20 token spend limit to be added
+   * @returns {object} The updated object with the new ERC20 token spend limit
+   */
   public addErc20TokenSpendLimit(limit: Erc20TokenLimit) {
     this._erc20TokenSpendLimits.push(limit);
     return this;
   }
 
-  public setGasSpendLimit(limit: GasSpendLimit) {
+  /**
+   * Sets the gas spend limit and returns the current instance for method chaining.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setGasSpendLimit({
+   *  spendLimit: 1000000000000000000n,
+   *  refreshInterval: 3600,
+   * });
+   * ```
+   *
+   * @param {GasSpendLimit} limit - The gas spend limit to be set
+   * @returns {SessionKeyPermissionsBuilder} The current instance for chaining
+   */ public setGasSpendLimit(limit: GasSpendLimit) {
     this._gasSpendLimit = limit;
     return this;
   }
 
+  /**
+   * Sets the required paymaster address.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setRequiredPaymaster("0x1234");
+   * ```
+   *
+   * @param {Address} paymaster the address of the paymaster to be set
+   * @returns {SessionKeyPermissionsBuilder} the current instance for method chaining
+   */
   public setRequiredPaymaster(paymaster: Address) {
     this._requiredPaymaster = paymaster;
     return this;
   }
 
+  /**
+   * Encodes various function calls into an array of hexadecimal strings based on the provided permissions and limits.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeyPermissionsBuilder } from "@account-kit/smart-contracts";
+   *
+   * const builder = new SessionKeyPermissionsBuilder();
+   * builder.setRequiredPaymaster("0x1234");
+   * const encoded = builder.encode();
+   * ```
+   *
+   * @returns {Hex[]} An array of encoded hexadecimal strings representing the function calls for setting access control, permissions, and limits.
+   */
   public encode(): Hex[] {
     return [
       encodeFunctionData({

package/src/msca/plugins/session-key/signer.ts

@@ -18,14 +18,13 @@ export const SessionKeySignerSchema = z.object({
 });
 
 export type SessionKeySignerConfig = z.input<typeof SessionKeySignerSchema>;
+export const SESSION_KEY_SIGNER_TYPE_PFX = "alchemy:session-key";
 
 /**
  * A simple session key signer that uses localStorage or sessionStorage to store
  * a private key. If the key is not found, it will generate a new one and store
  * it in the storage.
  */
-
-export const SESSION_KEY_SIGNER_TYPE_PFX = "alchemy:session-key";
 export class SessionKeySigner
   implements SmartAccountSigner<LocalAccountSigner<PrivateKeyAccount>>
 {
@@ -34,6 +33,18 @@ export class SessionKeySigner
   private storageType: "local-storage" | "session-storage" | Storage;
   private storageKey: string;
 
+  /**
+   * Initializes a new instance of a session key signer with the provided configuration. This will set the `signerType`, `storageKey`, and `storageType`. It will also manage the session key, either fetching it from storage or generating a new one if it doesn't exist.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeySigner } from "@account-kit/smart-contracts";
+   *
+   * const signer = new SessionKeySigner();
+   * ```
+   *
+   * @param {SessionKeySignerConfig} config_ the configuration for initializing the session key signer
+   */
   constructor(config_: SessionKeySignerConfig = {}) {
     const config = SessionKeySignerSchema.parse(config_);
     this.signerType = `${SESSION_KEY_SIGNER_TYPE_PFX}`;
@@ -61,16 +72,66 @@ export class SessionKeySigner
     this.inner = LocalAccountSigner.privateKeyToAccountSigner(sessionKey);
   }
 
+  /**
+   * An async function that retrieves the address using the inner object's `getAddress` method.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeySigner } from "@account-kit/smart-contracts";
+   *
+   * const signer = new SessionKeySigner();
+   * const sessionKeyAddress = await signer.getAddress();
+   * ```
+   *
+   * @returns {Promise<string>} A promise that resolves to the address as a string
+   */
   getAddress: () => Promise<`0x${string}`> = async () => {
     return this.inner.getAddress();
   };
 
+  /**
+   * Signs a message using the inner signer.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeySigner } from "@account-kit/smart-contracts";
+   *
+   * const signer = new SessionKeySigner();
+   * const sessionKeyAddress = await signer.signMessage("hello");
+   * ```
+   *
+   * @param {SignableMessage} msg The message to sign
+   * @returns {Promise<Hex>} A promise that resolves to the signed message
+   */
   signMessage: (msg: SignableMessage) => Promise<`0x${string}`> = async (
     msg
   ) => {
     return this.inner.signMessage(msg);
   };
 
+  /**
+   * Signs the provided typed data using the inner signer.
+   *
+   * @example
+   * ```ts
+   * import { SessionKeySigner } from "@account-kit/smart-contracts";
+   *
+   * const signer = new SessionKeySigner();
+   * console.log(await signer.signTypedData({
+   *  types: {
+   *    "Message": [{ name: "content", type: "string" }]
+   *  },
+   *  primaryType: "Message",
+   *  message: { content: "Hello" },
+   * }));
+   * ```
+   *
+   * @template TTypedData - The typed data type, which extends `TypedData` or a record of unknown keys to unknown values.
+   * @template TPrimaryType - The primary type of the typed data.
+   *
+   * @param {TypedDataDefinition<TTypedData, TPrimaryType>} params The parameters containing the typed data definition and primary type.
+   * @returns {Promise<string>} A promise that resolves to the signed typed data as a string.
+   */
   signTypedData = async <
     const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string = string
@@ -83,7 +144,15 @@ export class SessionKeySigner
   /**
    * Generates a new private key and stores it in the storage.
    *
-   * @returns The public address of the new key.
+   * @example
+   * ```ts
+   * import { SessionKeySigner } from "@account-kit/smart-contracts";
+   *
+   * const signer = new SessionKeySigner();
+   * const newSessionKey = signer.generateNewKey();
+   * ```
+   *
+   * @returns {Address} The public address of the new key.
    */
   generateNewKey = () => {
     const storage =

package/src/msca/plugins/session-key/utils.ts

@@ -3,9 +3,34 @@ import { AccountNotFoundError } from "@aa-sdk/core";
 import type { Address, Chain, Client, Transport } from "viem";
 import { SessionKeyPlugin } from "./plugin.js";
 
-// find predecessors for each keys and returned the struct `ISessionKeyPlugin.SessionKeyToRemove[]`
-// where SessionKeyToRemove = { sessionKey: Address, predecessor: Hex }
-export const buildSessionKeysToRemoveStruct: <
+type BuildSessionKeysToRemoveStructParams<
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = {
+  keys: ReadonlyArray<Address>;
+  pluginAddress?: Address;
+} & GetAccountParameter<TAccount>;
+
+/**
+ * Finds predecessors for each provided key and returns them in the struct `ISessionKeyPlugin.SessionKeyToRemove[]`.
+ *
+ * @example
+ * ```ts
+ * import { buildSessionKeysToRemoveStruct } from "@account-kit/smart-contracts";
+ *
+ * const client = createSmartAccountClient(...);
+ *
+ * const keysToRemove = await buildSessionKeysToRemoveStruct(client, {
+ *  keys: ["0x...", "0x..."],
+ * });
+ * ```
+ *
+ * @param {Client<TTransport, TChain, TAccount>} client The client instance used to interact with the smart account
+ * @param {BuildSessionKeysToRemoveStructParams<TAccount>} args Arguments to configure the session key removal process
+ * @returns {Promise<{ sessionKey: Address; predecessor: Address }[]>} A promise that resolves to an array of objects each containing a session key and its predecessor
+ */
+export async function buildSessionKeysToRemoveStruct<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends SmartContractAccount | undefined =
@@ -13,14 +38,10 @@ export const buildSessionKeysToRemoveStruct: <
     | undefined
 >(
   client: Client<TTransport, TChain, TAccount>,
-  args: {
-    keys: ReadonlyArray<Address>;
-    pluginAddress?: Address;
-  } & GetAccountParameter<TAccount>
-) => Promise<{ sessionKey: Address; predecessor: Address }[]> = async (
-  client,
-  { keys, pluginAddress, account = client.account }
-) => {
+  args: BuildSessionKeysToRemoveStructParams
+): Promise<{ sessionKey: Address; predecessor: Address }[]> {
+  const { keys, pluginAddress, account = client.account } = args;
+
   if (!account) throw new AccountNotFoundError();
 
   const contract = SessionKeyPlugin.getContract(client, pluginAddress);
@@ -37,4 +58,4 @@ export const buildSessionKeysToRemoveStruct: <
     sessionKey: key,
     predecessor,
   }));
-};
+}

package/src/msca/utils.ts

@@ -1,6 +1,14 @@
 import {
   AccountNotFoundError,
   ChainNotFoundError,
+  type GetAccountParameter,
+  type SmartAccountClient,
+  type SmartAccountSigner,
+  type SmartContractAccount,
+  type SmartContractAccountWithSigner,
+  type UpgradeToData,
+} from "@aa-sdk/core";
+import {
   arbitrum,
   arbitrumSepolia,
   base,
@@ -11,13 +19,7 @@ import {
   polygon,
   polygonAmoy,
   sepolia,
-  type GetAccountParameter,
-  type SmartAccountClient,
-  type SmartAccountSigner,
-  type SmartContractAccount,
-  type SmartContractAccountWithSigner,
-  type UpgradeToData,
-} from "@aa-sdk/core";
+} from "@account-kit/infra";
 import type { Address, Chain, Transport } from "viem";
 import {
   custom,
@@ -37,10 +39,10 @@ import {
 import { MultiOwnerPlugin } from "./plugins/multi-owner/plugin.js";
 
 /**
- * Utility method returning the default multi sig msca factory address given a {@link Chain} object
+ * Utility method returning the default multi sig msca factory address given a chain
  *
- * @param chain - a {@link Chain} object
- * @returns a {@link Address} for the given chain
+ * @param {Chain} chain the chain object for which to get the address
+ * @returns {Address} the address for the given chain
  * @throws if the chain doesn't have an address currently deployed
  */
 export const getDefaultMultisigModularAccountFactoryAddress = (
@@ -63,10 +65,10 @@ export const getDefaultMultisigModularAccountFactoryAddress = (
 };
 
 /**
- * Utility method returning the default multi owner msca factory address given a {@link Chain} object
+ * Utility method returning the default multi owner msca factory address given a chain
  *
- * @param chain - a {@link Chain} object
- * @returns a {@link Address} for the given chain
+ * @param {Chain} chain the chain object for which to get the address
+ * @returns {Address} the address for the given chain
  * @throws if the chain doesn't have an address currently deployed
  */
 export const getDefaultMultiOwnerModularAccountFactoryAddress = (
@@ -78,6 +80,30 @@ export const getDefaultMultiOwnerModularAccountFactoryAddress = (
   }
 };
 
+export type GetMSCAUpgradeToData<
+  TSigner extends SmartAccountSigner = SmartAccountSigner,
+  TAccount extends
+    | SmartContractAccountWithSigner<string, TSigner>
+    | undefined = SmartContractAccountWithSigner<string, TSigner> | undefined
+> = {
+  multiOwnerPluginAddress?: Address;
+} & GetAccountParameter<TAccount>;
+
+/**
+ * Retrieves the data necessary to upgrade to a Multi-Signature Contract Account (MSCA) and provides a method to create a Multi-Owner Modular Account.
+ *
+ * @example
+ * ```ts
+ * import { createLightAccountClient, getMSCAUpgradeToData } from "@account-kit/smart-contracts";
+ *
+ * const client = createLightAccountClient(...);
+ * const upgradeData = await getMSCAUpgradeToData(client, {});
+ * ```
+ *
+ * @param {SmartAccountClient<TTransport, TChain, TAccount>} client The smart account client
+ * @param {GetMSCAUpgradeToData<TSigner, TAccount>} args The arguments required for the upgrade
+ * @returns {Promise<UpgradeToData & { createMAAccount: () => Promise<MultiOwnerModularAccount<TSigner>>}>} A promise that resolves to upgrade data augmented with a function to create a Multi-Owner Modular Account
+ */
 export async function getMSCAUpgradeToData<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
@@ -87,9 +113,7 @@ export async function getMSCAUpgradeToData<
     | undefined = SmartContractAccountWithSigner<string, TSigner> | undefined
 >(
   client: SmartAccountClient<TTransport, TChain, TAccount>,
-  args: {
-    multiOwnerPluginAddress?: Address;
-  } & GetAccountParameter<TAccount>
+  args: GetMSCAUpgradeToData<TSigner, TAccount>
 ): Promise<
   UpgradeToData & {
     createMAAccount: () => Promise<MultiOwnerModularAccount<TSigner>>;
@@ -125,6 +149,39 @@ export async function getMSCAUpgradeToData<
   };
 }
 
+export type GetMAInitializationDataParams<
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends SmartContractAccount | undefined =
+    | SmartContractAccount
+    | undefined
+> = {
+  multiOwnerPluginAddress?: Address;
+  client: SmartAccountClient<TTransport, TChain, TAccount>;
+  signerAddress: Address | Address[];
+};
+
+/**
+ * Retrieves the initialization data for a multi-owner modular account. Throws an error if the client's chain is not found or if the multi-owner plugin address is not retrievable.
+ *
+ * @example
+ * ```ts
+ * import { getMAInitializationData } from "@account-kit/smart-contracts";
+ * import { createSmartAccountClient } from "@aa-sdk/core";
+ *
+ * const client = createSmartAccountClient(...);
+ * const initializationData = await getMAInitializationData({
+ *  client,
+ *  signerAddress: "0x...", // or array of signers
+ * });
+ * ```
+ *
+ * @param {GetMAInitializationDataParams<TTransport, TChain, TAccount>} params the parameters for getting initialization data
+ * @param {SmartAccountClient<TTransport, TChain, TAccount>} params.client the smart account client
+ * @param {Address | Address[]} params.signerAddress the address of the signer or an array of signer addresses
+ * @param {Address} [params.multiOwnerPluginAddress] optional address of the multi-owner plugin
+ * @returns {Promise<UpgradeToData>} a promise that resolves to the initialization data required for upgrading to a multi-owner modular account
+ */
 export async function getMAInitializationData<
   TTransport extends Transport = Transport,
   TChain extends Chain | undefined = Chain | undefined,
@@ -135,11 +192,11 @@ export async function getMAInitializationData<
   client,
   multiOwnerPluginAddress,
   signerAddress,
-}: {
-  multiOwnerPluginAddress?: Address;
-  client: SmartAccountClient<TTransport, TChain, TAccount>;
-  signerAddress: Address | Address[];
-}): Promise<UpgradeToData> {
+}: GetMAInitializationDataParams<
+  TTransport,
+  TChain,
+  TAccount
+>): Promise<UpgradeToData> {
   if (!client.chain) {
     throw new ChainNotFoundError();
   }

package/dist/cjs/src/light-account/schema.d.ts

@@ -1,21 +0,0 @@
-import { z } from "zod";
-import type { LightAccountVersion } from "./types.js";
-export declare const LightAccountFactoryConfigSchema: z.ZodObject<{
-    signer: z.ZodType<import("@aa-sdk/core").SmartAccountSigner<any>, z.ZodTypeDef, import("@aa-sdk/core").SmartAccountSigner<any>>;
-    accountAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
-    initCode: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
-    factoryAddress: z.ZodOptional<z.ZodEffects<z.ZodString, `0x${string}`, string>>;
-    version: z.ZodOptional<z.ZodEffects<z.ZodString, LightAccountVersion, string>>;
-}, "strip", z.ZodTypeAny, {
-    signer: import("@aa-sdk/core").SmartAccountSigner<any>;
-    accountAddress?: `0x${string}` | undefined;
-    initCode?: `0x${string}` | undefined;
-    factoryAddress?: `0x${string}` | undefined;
-    version?: LightAccountVersion | undefined;
-}, {
-    signer: import("@aa-sdk/core").SmartAccountSigner<any>;
-    accountAddress?: string | undefined;
-    initCode?: string | undefined;
-    factoryAddress?: string | undefined;
-    version?: string | undefined;
-}>;

package/dist/cjs/src/light-account/schema.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightAccountFactoryConfigSchema = void 0;
-const core_1 = require("@aa-sdk/core");
-const zod_1 = require("abitype/zod");
-const viem_1 = require("viem");
-const zod_2 = require("zod");
-const utils_js_1 = require("./utils.js");
-const isLightAccountVersion = (x) => {
-    if (typeof x === "string" &&
-        Object.keys(Object.values(utils_js_1.AccountVersionRegistry).flat()).includes(x)) {
-        return true;
-    }
-    return false;
-};
-exports.LightAccountFactoryConfigSchema = zod_2.z.object({
-    signer: core_1.SignerSchema,
-    accountAddress: zod_1.Address.optional().describe("Optional override for the account address."),
-    initCode: zod_2.z
-        .string()
-        .refine(viem_1.isHex, "initCode must be a valid hex.")
-        .optional()
-        .describe("Optional override for the account init code."),
-    factoryAddress: zod_1.Address.optional().describe("Optional override for the factory address which deploys the smart account."),
-    version: zod_2.z
-        .string()
-        .refine(isLightAccountVersion, "Version must be a valid Light Account version.")
-        .optional(),
-});
-//# sourceMappingURL=schema.js.map

package/dist/cjs/src/light-account/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../src/light-account/schema.ts"],"names":[],"mappings":";;;AAAA,uCAA4C;AAC5C,qCAAsC;AACtC,+BAA6B;AAC7B,6BAAwB;AAExB,yCAAoD;AAEpD,MAAM,qBAAqB,GAAG,CAAC,CAAU,EAA4B,EAAE;IACrE,IACE,OAAO,CAAC,KAAK,QAAQ;QACrB,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,iCAAsB,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EACrE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEW,QAAA,+BAA+B,GAAG,OAAC,CAAC,MAAM,CAAC;IACtD,MAAM,EAAE,mBAAY;IACpB,cAAc,EAAE,aAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACzC,4CAA4C,CAC7C;IACD,QAAQ,EAAE,OAAC;SACR,MAAM,EAAE;SACR,MAAM,CAAC,YAAK,EAAE,+BAA+B,CAAC;SAC9C,QAAQ,EAAE;SACV,QAAQ,CAAC,8CAA8C,CAAC;IAC3D,cAAc,EAAE,aAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,CACzC,4EAA4E,CAC7E;IACD,OAAO,EAAE,OAAC;SACP,MAAM,EAAE;SACR,MAAM,CACL,qBAAqB,EACrB,gDAAgD,CACjD;SACA,QAAQ,EAAE;CACd,CAAC,CAAC","sourcesContent":["import { SignerSchema } from \"@aa-sdk/core\";\nimport { Address } from \"abitype/zod\";\nimport { isHex } from \"viem\";\nimport { z } from \"zod\";\nimport type { LightAccountVersion } from \"./types.js\";\nimport { AccountVersionRegistry } from \"./utils.js\";\n\nconst isLightAccountVersion = (x: unknown): x is LightAccountVersion => {\n  if (\n    typeof x === \"string\" &&\n    Object.keys(Object.values(AccountVersionRegistry).flat()).includes(x)\n  ) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const LightAccountFactoryConfigSchema = z.object({\n  signer: SignerSchema,\n  accountAddress: Address.optional().describe(\n    \"Optional override for the account address.\"\n  ),\n  initCode: z\n    .string()\n    .refine(isHex, \"initCode must be a valid hex.\")\n    .optional()\n    .describe(\"Optional override for the account init code.\"),\n  factoryAddress: Address.optional().describe(\n    \"Optional override for the factory address which deploys the smart account.\"\n  ),\n  version: z\n    .string()\n    .refine<LightAccountVersion>(\n      isLightAccountVersion,\n      \"Version must be a valid Light Account version.\"\n    )\n    .optional(),\n});\n"]}