@account-kit/smart-contracts 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/types/src/msca/plugins/session-key/permissions.d.ts

@@ -43,14 +43,160 @@ export declare class SessionKeyPermissionsBuilder {
     private _erc20TokenSpendLimits;
     private _gasSpendLimit?;
     private _requiredPaymaster?;
+    /**
+     * 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
+     */
     setContractAccessControlType(aclType: SessionKeyAccessListType): 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
+     */
     addContractAddressAccessEntry(entry: ContractAccessEntry): 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
+     */
     addContractFunctionAccessEntry(entry: ContractMethodEntry): 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
+     */
     setTimeRange(timeRange: TimeRange): 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
+     */
     setNativeTokenSpendLimit(limit: NativeTokenLimit): 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
+     */
     addErc20TokenSpendLimit(limit: Erc20TokenLimit): this;
-    setGasSpendLimit(limit: GasSpendLimit): this;
+    /**
+     * 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
+     */ setGasSpendLimit(limit: GasSpendLimit): 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
+     */
     setRequiredPaymaster(paymaster: Address): 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.
+     */
     encode(): Hex[];
     private encodeIfDefined;
 }

package/dist/types/src/msca/plugins/session-key/permissions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../../../src/msca/plugins/session-key/permissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAGlE,oBAAY,wBAAwB;IAClC,SAAS,IAAI;IACb,QAAQ,IAAI;IACZ,gBAAgB,IAAI;CACrB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAEhC,eAAe,EAAE,OAAO,CAAC;IAEzB,QAAQ,EAAE,OAAO,CAAC;IAElB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,eAAe,EAAE,OAAO,CAAC;IAEzB,cAAc,EAAE,GAAG,CAAC;IAEpB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAGF,MAAM,MAAM,aAAa,GAAG;IAI1B,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,0BAA0B,CACG;IACrC,OAAO,CAAC,4BAA4B,CAA6B;IACjE,OAAO,CAAC,2BAA2B,CAA6B;IAChE,OAAO,CAAC,UAAU,CAAC,CAAY;IAC/B,OAAO,CAAC,sBAAsB,CAAC,CAAmB;IAClD,OAAO,CAAC,sBAAsB,CAAyB;IACvD,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,kBAAkB,CAAC,CAAU;IAE9B,4BAA4B,CAAC,OAAO,EAAE,wBAAwB;IAK9D,6BAA6B,CAAC,KAAK,EAAE,mBAAmB;IAKxD,8BAA8B,CAAC,KAAK,EAAE,mBAAmB;IAKzD,YAAY,CAAC,SAAS,EAAE,SAAS;IAKjC,wBAAwB,CAAC,KAAK,EAAE,gBAAgB;IAKhD,uBAAuB,CAAC,KAAK,EAAE,eAAe;IAK9C,gBAAgB,CAAC,KAAK,EAAE,aAAa;IAKrC,oBAAoB,CAAC,SAAS,EAAE,OAAO;IAKvC,MAAM,IAAI,GAAG,EAAE;IA0EtB,OAAO,CAAC,eAAe;CAKxB"}
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../../../src/msca/plugins/session-key/permissions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAGlE,oBAAY,wBAAwB;IAClC,SAAS,IAAI;IACb,QAAQ,IAAI;IACZ,gBAAgB,IAAI;CACrB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAEhC,eAAe,EAAE,OAAO,CAAC;IAEzB,QAAQ,EAAE,OAAO,CAAC;IAElB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAEhC,eAAe,EAAE,OAAO,CAAC;IAEzB,cAAc,EAAE,GAAG,CAAC;IAEpB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAGF,MAAM,MAAM,aAAa,GAAG;IAI1B,UAAU,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,0BAA0B,CACG;IACrC,OAAO,CAAC,4BAA4B,CAA6B;IACjE,OAAO,CAAC,2BAA2B,CAA6B;IAChE,OAAO,CAAC,UAAU,CAAC,CAAY;IAC/B,OAAO,CAAC,sBAAsB,CAAC,CAAmB;IAClD,OAAO,CAAC,sBAAsB,CAAyB;IACvD,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,kBAAkB,CAAC,CAAU;IAErC;;;;;;;;;;;;;OAaG;IACI,4BAA4B,CAAC,OAAO,EAAE,wBAAwB;IAKrE;;;;;;;;;;;;;;;;;OAiBG;IACI,6BAA6B,CAAC,KAAK,EAAE,mBAAmB;IAK/D;;;;;;;;;;;;;;;;;OAiBG;IACI,8BAA8B,CAAC,KAAK,EAAE,mBAAmB;IAKhE;;;;;;;;;;;;;;;;OAgBG;IACI,YAAY,CAAC,SAAS,EAAE,SAAS;IAKxC;;;;;;;;;;;;;;;;OAgBG;IACI,wBAAwB,CAAC,KAAK,EAAE,gBAAgB;IAKvD;;;;;;;;;;;;;;;;;OAiBG;IACI,uBAAuB,CAAC,KAAK,EAAE,eAAe;IAKrD;;;;;;;;;;;;;;;;OAgBG,CAAQ,gBAAgB,CAAC,KAAK,EAAE,aAAa;IAKhD;;;;;;;;;;;;;OAaG;IACI,oBAAoB,CAAC,SAAS,EAAE,OAAO;IAK9C;;;;;;;;;;;;;OAaG;IACI,MAAM,IAAI,GAAG,EAAE;IA0EtB,OAAO,CAAC,eAAe;CAKxB"}

package/dist/types/src/msca/plugins/session-key/signer.d.ts

@@ -23,9 +23,71 @@ export declare class SessionKeySigner implements SmartAccountSigner<LocalAccount
     inner: LocalAccountSigner<PrivateKeyAccount>;
     private storageType;
     private storageKey;
+    /**
+     * 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);
+    /**
+     * 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}`>;
+    /**
+     * 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}`>;
+    /**
+     * 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: <const TTypedData extends {
         [x: string]: readonly import("viem").TypedDataParameter[];
         [x: `string[${string}]`]: undefined;
@@ -237,7 +299,15 @@ export declare class SessionKeySigner implements SmartAccountSigner<LocalAccount
     /**
      * 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: () => `0x${string}`;
 }

package/dist/types/src/msca/plugins/session-key/signer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../../../../../src/msca/plugins/session-key/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,KAAK,EAEV,iBAAiB,EACjB,eAAe,EAEf,mBAAmB,EACpB,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;EAMjC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,eAAO,MAAM,2BAA2B,wBAAwB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,gBACX,YAAW,kBAAkB,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAEpE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAC7C,OAAO,CAAC,WAAW,CAAgD;IACnE,OAAO,CAAC,UAAU,CAAS;gBAEf,OAAO,GAAE,sBAA2B;IA2BhD,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAEtC;IAEF,WAAW,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAI3D;IAEF,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HAOX;IAEF;;;;OAIG;IACH,cAAc,sBASZ;CACH"}
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../../../../../src/msca/plugins/session-key/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,KAAK,EAEV,iBAAiB,EACjB,eAAe,EAEf,mBAAmB,EACpB,MAAM,MAAM,CAAC;AAEd,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,sBAAsB;;;;;;;;;EAMjC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC5E,eAAO,MAAM,2BAA2B,wBAAwB,CAAC;AAEjE;;;;GAIG;AACH,qBAAa,gBACX,YAAW,kBAAkB,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAEpE,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;IAC7C,OAAO,CAAC,WAAW,CAAgD;IACnE,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;;;;;;;OAWG;gBACS,OAAO,GAAE,sBAA2B;IA2BhD;;;;;;;;;;;;OAYG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAEtC;IAEF;;;;;;;;;;;;;OAaG;IACH,WAAW,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC,CAI3D;IAEF;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8HAOX;IAEF;;;;;;;;;;;;OAYG;IACH,cAAc,sBASZ;CACH"}

package/dist/types/src/msca/utils.d.ts

@@ -2,18 +2,18 @@ import { type GetAccountParameter, type SmartAccountClient, type SmartAccountSig
 import type { Address, Chain, Transport } from "viem";
 import { type MultiOwnerModularAccount } from "./account/multiOwnerAccount.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 declare const getDefaultMultisigModularAccountFactoryAddress: (chain: Chain) => Address;
 /**
- * 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 declare const getDefaultMultiOwnerModularAccountFactoryAddress: (chain: Chain) => Address;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@account-kit/smart-contracts",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "description": "aa-sdk compatible interfaces for Alchemy Smart Accounts",
   "author": "Alchemy",
   "license": "MIT",
@@ -40,13 +40,14 @@
     "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
     "build:esm": "tsc --project tsconfig.build.json --module es2020 --outDir ./dist/esm --removeComments && echo > ./dist/esm/package.json '{\"type\":\"module\"}'",
     "build:types": "tsc --project tsconfig.build.json --module esnext --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
+    "docs:gen": "npx ak-docgen generate --in ./src/index.ts --out ../../site/pages/reference/account-kit/smart-contracts",
     "clean": "rm -rf ./dist",
     "test": "vitest",
     "test:run": "vitest run",
     "test:run-e2e": "vitest run --config vitest.config.e2e.ts"
   },
   "devDependencies": {
-    "@account-kit/plugingen": "^4.0.0-alpha.4",
+    "@account-kit/plugingen": "^4.0.0-alpha.6",
     "@wagmi/cli": "^1.5.2",
     "change-case": "^5.1.2",
     "dedent": "^1.5.1",
@@ -67,10 +68,10 @@
     "url": "https://github.com/alchemyplatform/aa-sdk/issues"
   },
   "homepage": "https://github.com/alchemyplatform/aa-sdk#readme",
-  "gitHead": "07d3a1a98377c9db41d7f48cd89747d9e881267c",
+  "gitHead": "2c35ec701f526c77ea5e00e2e6f147156c7ac0e4",
   "dependencies": {
-    "@aa-sdk/core": "^4.0.0-alpha.4",
-    "@account-kit/infra": "^4.0.0-alpha.4",
+    "@aa-sdk/core": "^4.0.0-alpha.6",
+    "@account-kit/infra": "^4.0.0-alpha.6",
     "viem": "2.8.6"
   },
   "peerDependencies": {

package/src/index.ts

@@ -24,7 +24,7 @@ export {
   LightAccountUnsupported1271Impls,
   defaultLightAccountVersion,
   getDefaultLightAccountFactoryAddress,
-  getLightAccountVersionDef,
+  getLightAccountVersionForAccount,
 } from "./light-account/utils.js";
 
 //multi-owner-light-account exports

package/src/light-account/accounts/account.ts

@@ -18,8 +18,8 @@ import { LightAccountAbi_v2 } from "../abis/LightAccountAbi_v2.js";
 import { LightAccountFactoryAbi_v1 } from "../abis/LightAccountFactoryAbi_v1.js";
 import { LightAccountFactoryAbi_v2 } from "../abis/LightAccountFactoryAbi_v2.js";
 import type {
-  GetEntryPointForLightAccountVersion,
-  GetLightAccountVersion,
+  LightAccountEntryPointVersion,
+  LightAccountVersion,
 } from "../types.js";
 import {
   AccountVersionRegistry,
@@ -35,17 +35,8 @@ import {
 
 export type LightAccount<
   TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    "LightAccount",
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
-> = LightAccountBase<
-  TSigner,
-  "LightAccount",
-  TLightAccountVersion,
-  TEntryPointVersion
-> & {
+  TLightAccountVersion extends LightAccountVersion<"LightAccount"> = LightAccountVersion<"LightAccount">
+> = LightAccountBase<TSigner, "LightAccount", TLightAccountVersion> & {
   encodeTransferOwnership: (newOwner: Address) => Hex;
   getOwnerAddress: () => Promise<Address>;
 };
@@ -54,55 +45,41 @@ export type LightAccount<
 export type CreateLightAccountParams<
   TTransport extends Transport = Transport,
   TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    "LightAccount",
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
+  TLightAccountVersion extends LightAccountVersion<"LightAccount"> = LightAccountVersion<"LightAccount">
 > = Omit<
   CreateLightAccountBaseParams<
-    TTransport,
-    TSigner,
     "LightAccount",
     TLightAccountVersion,
-    TEntryPointVersion
+    TTransport,
+    TSigner
   >,
-  "getAccountInitCode" | "entryPoint" | "version" | "abi" | "accountAddress"
+  | "getAccountInitCode"
+  | "entryPoint"
+  | "version"
+  | "abi"
+  | "accountAddress"
+  | "type"
 > & {
   salt?: bigint;
   initCode?: Hex;
   accountAddress?: Address;
   factoryAddress?: Address;
   version?: TLightAccountVersion;
-  entryPoint?: EntryPointDef<TEntryPointVersion, Chain>;
+  entryPoint?: EntryPointDef<
+    LightAccountEntryPointVersion<"LightAccount", TLightAccountVersion>,
+    Chain
+  >;
 };
 // [!endregion CreateLightAccountParams]
 
 export async function createLightAccount<
   TTransport extends Transport = Transport,
   TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = "v1.1.0"
+  TLightAccountVersion extends LightAccountVersion<"LightAccount"> = "v2.0.0"
 >(
   config: CreateLightAccountParams<TTransport, TSigner, TLightAccountVersion>
 ): Promise<LightAccount<TSigner, TLightAccountVersion>>;
 
-export async function createLightAccount<
-  TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountVersion extends GetLightAccountVersion<"LightAccount"> = GetLightAccountVersion<"LightAccount">,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    "LightAccount",
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<"LightAccount", TLightAccountVersion>
->(
-  config: CreateLightAccountParams<
-    TTransport,
-    TSigner,
-    TLightAccountVersion,
-    TEntryPointVersion
-  >
-): Promise<LightAccount<TSigner, TLightAccountVersion, TEntryPointVersion>>;
-
 /**
  * Creates a light account based on the provided parameters such as transport, chain, signer, init code, and more. Ensures that an account is configured and returned with various capabilities, such as transferring ownership and retrieving the owner's address.
  *
@@ -128,7 +105,7 @@ export async function createLightAccount({
   chain,
   signer,
   initCode,
-  version = defaultLightAccountVersion("LightAccount"),
+  version = defaultLightAccountVersion(),
   entryPoint = getEntryPoint(chain, {
     version: AccountVersionRegistry["LightAccount"][version]
       .entryPointVersion as any,
@@ -176,15 +153,17 @@ export async function createLightAccount({
   });
 
   const account = await createLightAccountBase<
+    "LightAccount",
+    LightAccountVersion<"LightAccount">,
     Transport,
-    SmartAccountSigner,
-    "LightAccount"
+    SmartAccountSigner
   >({
     transport,
     chain,
     signer,
     abi: accountAbi,
-    version: AccountVersionRegistry["LightAccount"][version],
+    type: "LightAccount",
+    version,
     entryPoint,
     accountAddress: address,
     getAccountInitCode,

package/src/light-account/accounts/base.ts

@@ -23,11 +23,9 @@ import {
   type Transport,
 } from "viem";
 import type {
-  AccountVersionDef,
-  GetEntryPointForLightAccountVersion,
-  GetLightAccountVersion,
+  LightAccountEntryPointVersion,
   LightAccountType,
-  LightAccountVersionDef,
+  LightAccountVersion,
 } from "../types.js";
 import { AccountVersionRegistry } from "../utils.js";
 
@@ -40,91 +38,60 @@ enum SignatureType {
 export type LightAccountBase<
   TSigner extends SmartAccountSigner = SmartAccountSigner,
   TLightAccountType extends LightAccountType = LightAccountType,
-  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  >
+  TLightAccountVersion extends LightAccountVersion<TLightAccountType> = LightAccountVersion<TLightAccountType>
 > = SmartContractAccountWithSigner<
   TLightAccountType,
   TSigner,
-  TEntryPointVersion
+  LightAccountEntryPointVersion<TLightAccountType, TLightAccountVersion>
 > & {
   getLightAccountVersion: () => TLightAccountVersion;
 };
 
 //#region CreateLightAccountBaseParams
 export type CreateLightAccountBaseParams<
+  TLightAccountType extends LightAccountType,
+  TLightAccountVersion extends LightAccountVersion<TLightAccountType> = LightAccountVersion<TLightAccountType>,
   TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountType extends LightAccountType = LightAccountType,
-  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  >
+  TSigner extends SmartAccountSigner = SmartAccountSigner
 > = Pick<
-  ToSmartContractAccountParams<
-    TLightAccountType,
-    TTransport,
-    Chain,
-    TEntryPointVersion
-  >,
+  ToSmartContractAccountParams<TLightAccountType, TTransport, Chain>,
   "transport" | "chain" | "getAccountInitCode"
 > & {
   abi: Abi;
   signer: TSigner;
   accountAddress: Address;
-  version: LightAccountVersionDef<TLightAccountType, TLightAccountVersion>;
-  entryPoint: EntryPointDef<TEntryPointVersion, Chain>;
+  type: TLightAccountType;
+  version: TLightAccountVersion;
+  entryPoint: EntryPointDef<
+    LightAccountEntryPointVersion<TLightAccountType, TLightAccountVersion>,
+    Chain
+  >;
 };
 //#endregion CreateLightAccountBaseParams
 
 export async function createLightAccountBase<
+  TLightAccountType extends LightAccountType,
+  TLightAccountVersion extends LightAccountVersion<TLightAccountType>,
   TTransport extends Transport = Transport,
-  TSigner extends SmartAccountSigner = SmartAccountSigner,
-  TLightAccountType extends LightAccountType = LightAccountType,
-  TLightAccountVersion extends GetLightAccountVersion<TLightAccountType> = GetLightAccountVersion<TLightAccountType>,
-  TEntryPointVersion extends GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  > = GetEntryPointForLightAccountVersion<
-    TLightAccountType,
-    TLightAccountVersion
-  >
->(
-  config: CreateLightAccountBaseParams<
-    TTransport,
-    TSigner,
-    TLightAccountType,
-    TLightAccountVersion,
-    TEntryPointVersion
-  >
-): Promise<
-  LightAccountBase<
-    TSigner,
-    TLightAccountType,
-    TLightAccountVersion,
-    TEntryPointVersion
-  >
->;
-
-export async function createLightAccountBase({
+  TSigner extends SmartAccountSigner = SmartAccountSigner
+>({
   transport,
   chain,
   signer,
   abi,
-  version: { version, type },
+  version,
+  type,
   entryPoint,
   accountAddress,
   getAccountInitCode,
-}: CreateLightAccountBaseParams): Promise<LightAccountBase> {
+}: CreateLightAccountBaseParams<
+  TLightAccountType,
+  TLightAccountVersion,
+  TTransport,
+  TSigner
+>): Promise<
+  LightAccountBase<TSigner, TLightAccountType, TLightAccountVersion>
+> {
   const client = createBundlerClient({
     transport,
     chain,
@@ -149,7 +116,9 @@ export async function createLightAccountBase({
 
     const implementationAddresses = Object.values(
       AccountVersionRegistry[type]
-    ).map((x: AccountVersionDef) => x.address[chain.id].impl);
+    ).map(
+      (x) => x.addresses.overrides?.[chain.id]?.impl ?? x.addresses.default.impl
+    );
 
     // only upgrade undeployed accounts (storage 0) or deployed light accounts, error otherwise
     if (
@@ -157,7 +126,9 @@ export async function createLightAccountBase({
       !implementationAddresses.some((x) => x === trim(storage))
     ) {
       throw new Error(
-        `could not determine if smart account implementation is ${type} ${version}`
+        `could not determine if smart account implementation is ${type} ${String(
+          version
+        )}`
       );
     }
 
@@ -234,7 +205,7 @@ export async function createLightAccountBase({
         case "v1.0.1":
           return signer.signMessage(message);
         case "v1.0.2":
-          throw new Error(`${type} ${version} doesn't support 1271`);
+          throw new Error(`${type} ${String(version)} doesn't support 1271`);
         case "v1.1.0":
           return signWith1271WrapperV1(hashMessage(message));
         case "v2.0.0":
@@ -242,7 +213,7 @@ export async function createLightAccountBase({
           // TODO: handle case where signer is an SCA.
           return concat([SignatureType.EOA, signature]);
         default:
-          throw new Error(`Unknown version ${type} of ${version}`);
+          throw new Error(`Unknown version ${type} of ${String(version)}`);
       }
     },
     async signTypedData(params) {
@@ -253,7 +224,7 @@ export async function createLightAccountBase({
           );
         case "v1.0.2":
           throw new Error(
-            `Version ${version} of LightAccount doesn't support 1271`
+            `Version ${String(version)} of LightAccount doesn't support 1271`
           );
         case "v1.1.0":
           return signWith1271WrapperV1(hashTypedData(params));
@@ -262,7 +233,7 @@ export async function createLightAccountBase({
           // TODO: handle case where signer is an SCA.
           return concat([SignatureType.EOA, signature]);
         default:
-          throw new Error(`Unknown version ${version} of LightAccount`);
+          throw new Error(`Unknown version ${String(version)} of LightAccount`);
       }
     },
     getDummySignature: (): Hex => {
@@ -276,7 +247,7 @@ export async function createLightAccountBase({
         case "v2.0.0":
           return concat([SignatureType.EOA, signature]);
         default:
-          throw new Error(`Unknown version ${type} of ${version}`);
+          throw new Error(`Unknown version ${type} of ${String(version)}`);
       }
     },
     encodeUpgradeToAndCall,