@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/modules/erc7579-abi.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleKind } from './types.js';
+export type ModuleTypeId = 1n | 2n | 3n | 4n;
+export declare function moduleTypeId(kind: ModuleKind): ModuleTypeId;
+//# sourceMappingURL=erc7579-abi.d.ts.map

package/dist/src/modules/erc7579-abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc7579-abi.d.ts","sourceRoot":"","sources":["../../../modules/erc7579-abi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,MAAM,MAAM,YAAY,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAA;AAE5C,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,CAW3D"}

package/dist/src/modules/erc7579-abi.js

@@ -0,0 +1,12 @@
+export function moduleTypeId(kind) {
+    switch (kind) {
+        case 'validator':
+            return 1n;
+        case 'executor':
+            return 2n;
+        case 'fallback':
+            return 3n;
+        case 'hook':
+            return 4n;
+    }
+}

package/dist/src/modules/intent-executor.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from 'viem';
+import type { ResolvedModule } from './types.js';
+export declare const INTENT_EXECUTOR_ADDRESS: Address;
+export declare const INTENT_EXECUTOR_ADDRESS_DEV: Address;
+export declare function getIntentExecutorModule(environment: 'production' | 'development'): ResolvedModule;
+//# sourceMappingURL=intent-executor.d.ts.map

package/dist/src/modules/intent-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-executor.d.ts","sourceRoot":"","sources":["../../../modules/intent-executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,eAAO,MAAM,uBAAuB,EAAE,OACQ,CAAA;AAC9C,eAAO,MAAM,2BAA2B,EAAE,OACI,CAAA;AAE9C,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,YAAY,GAAG,aAAa,GACxC,cAAc,CAWhB"}

package/dist/src/modules/intent-executor.js

@@ -0,0 +1,13 @@
+export const INTENT_EXECUTOR_ADDRESS = '0x00000000005aD9ce1f5035FD62CA96CEf16AdAAF';
+export const INTENT_EXECUTOR_ADDRESS_DEV = '0xbf9b5b917a83f8adac17b0752846d41d8d7b7e17';
+export function getIntentExecutorModule(environment) {
+    return {
+        kind: 'executor',
+        address: environment === 'development'
+            ? INTENT_EXECUTOR_ADDRESS_DEV
+            : INTENT_EXECUTOR_ADDRESS,
+        initData: '0x',
+        deInitData: '0x',
+        additionalContext: '0x',
+    };
+}

package/dist/src/modules/legacy-core.d.ts

@@ -0,0 +1,29 @@
+import { type Address, type Hex } from 'viem';
+import type { ModuleSetup, ResolvedModule } from './types.js';
+declare const MODULE_TYPE_ID_VALIDATOR = 1n;
+declare const MODULE_TYPE_ID_EXECUTOR = 2n;
+declare const MODULE_TYPE_ID_FALLBACK = 3n;
+declare const MODULE_TYPE_ID_HOOK = 4n;
+export type ModuleTypeId = typeof MODULE_TYPE_ID_VALIDATOR | typeof MODULE_TYPE_ID_EXECUTOR | typeof MODULE_TYPE_ID_FALLBACK | typeof MODULE_TYPE_ID_HOOK;
+export interface Module {
+    address: Address;
+    initData: Hex;
+    deInitData: Hex;
+    additionalContext: Hex;
+    type: ModuleTypeId;
+}
+export interface ModeleSetup {
+    validators: Module[];
+    executors: Module[];
+    fallbacks: Module[];
+    hooks: Module[];
+}
+export declare function toLegacyModule(module: ResolvedModule): Module;
+export declare function toLegacyModuleSetup(setup: ModuleSetup): ModeleSetup;
+export declare function getV0Attesters(): {
+    readonly addresses: readonly `0x${string}`[];
+    readonly threshold: number;
+};
+export declare function planV0ModuleSetup(setup: ModuleSetup): ModuleSetup;
+export {};
+//# sourceMappingURL=legacy-core.d.ts.map

package/dist/src/modules/legacy-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-core.d.ts","sourceRoot":"","sources":["../../../modules/legacy-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AAClE,OAAO,KAAK,EAAc,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAKtE,QAAA,MAAM,wBAAwB,KAAK,CAAA;AACnC,QAAA,MAAM,uBAAuB,KAAK,CAAA;AAClC,QAAA,MAAM,uBAAuB,KAAK,CAAA;AAClC,QAAA,MAAM,mBAAmB,KAAK,CAAA;AAE9B,MAAM,MAAM,YAAY,GACpB,OAAO,wBAAwB,GAC/B,OAAO,uBAAuB,GAC9B,OAAO,uBAAuB,GAC9B,OAAO,mBAAmB,CAAA;AAE9B,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,GAAG,CAAA;IACb,UAAU,EAAE,GAAG,CAAA;IACf,iBAAiB,EAAE,GAAG,CAAA;IACtB,IAAI,EAAE,YAAY,CAAA;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB;AAyBD,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAQ7D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAOnE;AAED,wBAAgB,cAAc,IAAI;IAChC,QAAQ,CAAC,SAAS,EAAE,SAAS,KAAK,MAAM,EAAE,EAAE,CAAA;IAC5C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,CAQA;AAgBD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CA0BjE"}

package/dist/src/modules/legacy-core.js

@@ -0,0 +1,80 @@
+import { encodeAbiParameters } from 'viem';
+// Legacy module-setup shapes preserved for the `experimental_getModuleSetup`
+// compatibility surface (note the historical `ModeleSetup` spelling, which is
+// part of the published type name).
+const MODULE_TYPE_ID_VALIDATOR = 1n;
+const MODULE_TYPE_ID_EXECUTOR = 2n;
+const MODULE_TYPE_ID_FALLBACK = 3n;
+const MODULE_TYPE_ID_HOOK = 4n;
+const RHINESTONE_ATTESTER_ADDRESS = '0x000000333034E9f539ce08819E12c1b8Cb29084d';
+const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS = '0x6D0515e8E499468DCe9583626f0cA15b887f9d03';
+const HOOK_ADDRESS = '0x0000000000f6Ed8Be424d673c63eeFF8b9267420';
+const TARGET_MODULE_ADDRESS = '0x0000000000E5a37279A001301A837a91b5de1D5E';
+const SAME_CHAIN_MODULE_ADDRESS = '0x000000000043ff16d5776c7F0f65Ec485C17Ca04';
+const moduleType = (kind) => {
+    switch (kind) {
+        case 'validator':
+            return 1n;
+        case 'executor':
+            return 2n;
+        case 'fallback':
+            return 3n;
+        case 'hook':
+            return 4n;
+    }
+};
+export function toLegacyModule(module) {
+    return {
+        address: module.address,
+        initData: module.initData,
+        deInitData: module.deInitData,
+        additionalContext: module.additionalContext,
+        type: moduleType(module.kind),
+    };
+}
+export function toLegacyModuleSetup(setup) {
+    return {
+        validators: setup.validators.map(toLegacyModule),
+        executors: setup.executors.map(toLegacyModule),
+        fallbacks: setup.fallbacks.map(toLegacyModule),
+        hooks: setup.hooks.map(toLegacyModule),
+    };
+}
+export function getV0Attesters() {
+    return {
+        addresses: [
+            RHINESTONE_ATTESTER_ADDRESS,
+            OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS,
+        ],
+        threshold: 1,
+    };
+}
+function v0Module(kind, address, initData = '0x') {
+    return {
+        kind,
+        address,
+        initData,
+        deInitData: '0x',
+        additionalContext: '0x',
+    };
+}
+export function planV0ModuleSetup(setup) {
+    return {
+        validators: setup.validators,
+        executors: [
+            v0Module('executor', SAME_CHAIN_MODULE_ADDRESS),
+            v0Module('executor', TARGET_MODULE_ADDRESS),
+            v0Module('executor', HOOK_ADDRESS),
+            ...setup.executors,
+        ],
+        fallbacks: [
+            v0Module('fallback', TARGET_MODULE_ADDRESS, encodeAbiParameters([
+                { name: 'selector', type: 'bytes4' },
+                { name: 'flags', type: 'bytes1' },
+                { name: 'data', type: 'bytes' },
+            ], ['0x3a5be8cb', '0x00', '0x'])),
+            ...setup.fallbacks,
+        ],
+        hooks: setup.hooks,
+    };
+}

package/dist/src/modules/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { ConfiguredModule, ResolvedModule } from './types.js';
+export declare function normalizeModule(module: ConfiguredModule): ResolvedModule;
+export declare function normalizeModules(modules: readonly ConfiguredModule[]): readonly ResolvedModule[];
+//# sourceMappingURL=normalize.d.ts.map

package/dist/src/modules/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../modules/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAQ/D,wBAAgB,eAAe,CAAC,MAAM,EAAE,gBAAgB,GAAG,cAAc,CAQxE;AAED,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,SAAS,cAAc,EAAE,CAE3B"}

package/dist/src/modules/normalize.js

@@ -0,0 +1,15 @@
+function materializeData(selection) {
+    return selection.source === 'explicit' ? selection.value : '0x';
+}
+export function normalizeModule(module) {
+    return {
+        kind: module.kind,
+        address: module.address,
+        initData: materializeData(module.initData),
+        deInitData: materializeData(module.deInitData),
+        additionalContext: materializeData(module.additionalContext),
+    };
+}
+export function normalizeModules(modules) {
+    return modules.map(normalizeModule);
+}

package/dist/src/modules/plan.d.ts

@@ -0,0 +1,16 @@
+import { type Hex } from 'viem';
+import type { ConfiguredModule, ModuleInstallationPlan, ModuleSetup, ResolvedModule } from './types.js';
+export type ModuleCallEncoder = (module: ResolvedModule, operation: ModuleInstallationPlan['operation']) => Hex;
+export declare function planModuleOperation(module: ResolvedModule, operation: ModuleInstallationPlan['operation'], encodeAccountCall: ModuleCallEncoder): ModuleInstallationPlan;
+export declare function planModuleSetup(input: {
+    readonly accountKind: string;
+    readonly owner: ResolvedModule;
+    readonly configured: readonly ConfiguredModule[];
+    readonly environment: 'production' | 'development';
+    readonly sessions: {
+        readonly enabled: boolean;
+        readonly module?: `0x${string}`;
+        readonly compatibilityFallback?: `0x${string}`;
+    };
+}): ModuleSetup;
+//# sourceMappingURL=plan.d.ts.map

package/dist/src/modules/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../modules/plan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AAGpD,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACtB,WAAW,EACX,cAAc,EACf,MAAM,SAAS,CAAA;AAGhB,MAAM,MAAM,iBAAiB,GAAG,CAC9B,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,sBAAsB,CAAC,WAAW,CAAC,KAC3C,GAAG,CAAA;AAER,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,sBAAsB,CAAC,WAAW,CAAC,EAC9C,iBAAiB,EAAE,iBAAiB,GACnC,sBAAsB,CAMxB;AAKD,wBAAgB,eAAe,CAAC,KAAK,EAAE;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAA;IAC9B,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAChD,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;IAClD,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;QACzB,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;QAC/B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;KAC/C,CAAA;CACF,GAAG,WAAW,CA0Cd"}

package/dist/src/modules/plan.js

@@ -0,0 +1,51 @@
+import { encodeAbiParameters } from 'viem';
+import { getIntentExecutorModule } from './intent-executor.js';
+import { normalizeModules } from './normalize.js';
+import { resolveSmartSessionModule } from './validators/smart-sessions/module.js';
+export function planModuleOperation(module, operation, encodeAccountCall) {
+    return {
+        module,
+        operation,
+        accountCallData: encodeAccountCall(module, operation),
+    };
+}
+const SAFE_SESSION_COMPATIBILITY_FALLBACK_ADDRESS = '0x000000000052e9685932845660777DF43C2dC496';
+export function planModuleSetup(input) {
+    const custom = normalizeModules(input.configured);
+    const session = resolveSmartSessionModule({
+        enabled: input.sessions.enabled,
+        address: input.sessions.module,
+        environment: input.environment,
+    });
+    const validators = [
+        input.owner,
+        ...(session ? [session] : []),
+        ...custom.filter((module) => module.kind === 'validator'),
+    ];
+    const executors = [
+        getIntentExecutorModule(input.environment),
+        ...custom.filter((module) => module.kind === 'executor'),
+    ];
+    const fallbacks = [];
+    if (input.sessions.enabled && input.accountKind === 'safe') {
+        fallbacks.push({
+            kind: 'fallback',
+            address: input.sessions.compatibilityFallback ??
+                SAFE_SESSION_COMPATIBILITY_FALLBACK_ADDRESS,
+            initData: encodeAbiParameters([
+                { name: 'selector', type: 'bytes4' },
+                { name: 'flags', type: 'bytes1' },
+                { name: 'data', type: 'bytes' },
+            ], ['0x84b0196e', '0xfe', '0x']),
+            deInitData: '0x',
+            additionalContext: '0x',
+        });
+    }
+    fallbacks.push(...custom.filter((module) => module.kind === 'fallback'));
+    return {
+        validators,
+        executors,
+        fallbacks,
+        hooks: custom.filter((module) => module.kind === 'hook'),
+    };
+}

package/dist/src/modules/read-core.d.ts

@@ -0,0 +1,39 @@
+import { type Address, type Hex } from 'viem';
+import type { EvmChainReference } from '../chains/types.js';
+import type { RpcReadPort } from '../clients/rpc/port.js';
+import type { ModuleKind, ResolvedModule } from './types.js';
+export declare function readInstalledModules(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly accountKind: string;
+    readonly account: Address;
+    readonly kind: Extract<ModuleKind, 'validator' | 'executor'>;
+}): Promise<readonly Address[]>;
+export declare function readValidatorInitialized(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly account: Address;
+    readonly validator: Address;
+}): Promise<boolean>;
+export declare function readModuleInstallations(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly account: Address;
+    readonly modules: readonly ResolvedModule[];
+}): Promise<readonly boolean[]>;
+export declare function readOwners(input: {
+    readonly rpc: RpcReadPort;
+    readonly chain: EvmChainReference;
+    readonly accountKind: string;
+    readonly account: Address;
+    readonly hcaFactory?: Address;
+}): Promise<{
+    readonly accounts: readonly Address[];
+    readonly threshold: number;
+} | null>;
+export declare function encodeAccountModuleDeInitData(input: {
+    readonly accountKind: string;
+    readonly module: ResolvedModule;
+    readonly installed: readonly Address[];
+}): Hex;
+//# sourceMappingURL=read-core.d.ts.map

package/dist/src/modules/read-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-core.d.ts","sourceRoot":"","sources":["../../../modules/read-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAyBzD,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW,GAAG,UAAU,CAAC,CAAA;CAC7D,GAAG,OAAO,CAAC,SAAS,OAAO,EAAE,CAAC,CAmB9B;AAED,wBAAsB,wBAAwB,CAAC,KAAK,EAAE;IACpD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B,GAAG,OAAO,CAAC,OAAO,CAAC,CAkBnB;AAgBD,wBAAsB,uBAAuB,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAA;CAC5C,GAAG,OAAO,CAAC,SAAS,OAAO,EAAE,CAAC,CAiB9B;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE;IACtC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,GAAG,OAAO,CAAC;IACV,QAAQ,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;IACrC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B,GAAG,IAAI,CAAC,CAmER;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,OAAO,EAAE,CAAA;CACvC,GAAG,GAAG,CAkBN"}

package/dist/src/modules/read-core.js

@@ -0,0 +1,149 @@
+import { encodeAbiParameters } from 'viem';
+import { moduleTypeId } from './erc7579-abi.js';
+import { ENS_HCA_MODULE } from './validators/ens.js';
+import { OWNABLE_VALIDATOR_ADDRESS } from './validators/ownable.js';
+const sentinel = '0x0000000000000000000000000000000000000001';
+const paginationAbi = (name) => [
+    {
+        name,
+        type: 'function',
+        inputs: [
+            { name: 'cursor', type: 'address' },
+            { name: 'size', type: 'uint256' },
+        ],
+        outputs: [
+            { name: 'array', type: 'address[]' },
+            { name: 'next', type: 'address' },
+        ],
+        stateMutability: 'view',
+    },
+];
+export async function readInstalledModules(input) {
+    if (input.accountKind === 'eoa')
+        return [];
+    if (input.accountKind === 'kernel')
+        throw new Error('Kernel not supported');
+    const functionName = input.kind === 'validator'
+        ? 'getValidatorsPaginated'
+        : 'getExecutorsPaginated';
+    const result = await input.rpc.readContract({ chain: input.chain }, {
+        address: input.account,
+        abi: paginationAbi(functionName),
+        functionName,
+        args: [sentinel, 100n],
+    });
+    return result[0];
+}
+export async function readValidatorInitialized(input) {
+    return input.rpc.readContract({ chain: input.chain }, {
+        address: input.validator,
+        abi: [
+            {
+                name: 'isInitialized',
+                type: 'function',
+                stateMutability: 'view',
+                inputs: [{ name: 'smartAccount', type: 'address' }],
+                outputs: [{ name: '', type: 'bool' }],
+            },
+        ],
+        functionName: 'isInitialized',
+        args: [input.account],
+    });
+}
+const moduleInstalledAbi = [
+    {
+        type: 'function',
+        name: 'isModuleInstalled',
+        inputs: [
+            { type: 'uint256', name: 'moduleTypeId' },
+            { type: 'address', name: 'module' },
+            { type: 'bytes', name: 'additionalContext' },
+        ],
+        outputs: [{ type: 'bool', name: 'isInstalled' }],
+        stateMutability: 'view',
+    },
+];
+export async function readModuleInstallations(input) {
+    const results = await input.rpc.multicall({ chain: input.chain }, input.modules.map((module) => ({
+        address: input.account,
+        abi: moduleInstalledAbi,
+        functionName: 'isModuleInstalled',
+        args: [
+            moduleTypeId(module.kind),
+            module.address,
+            module.additionalContext,
+        ],
+    })));
+    return results.map(({ result }) => result === true);
+}
+export async function readOwners(input) {
+    let validator = OWNABLE_VALIDATOR_ADDRESS;
+    if (input.accountKind === 'hca') {
+        validator = input.hcaFactory
+            ? await input.rpc.readContract({ chain: input.chain }, {
+                address: input.hcaFactory,
+                abi: [
+                    {
+                        name: 'initDataParser',
+                        type: 'function',
+                        stateMutability: 'view',
+                        inputs: [],
+                        outputs: [{ name: '', type: 'address' }],
+                    },
+                ],
+                functionName: 'initDataParser',
+            })
+            : ENS_HCA_MODULE;
+    }
+    const results = await input.rpc.multicall({ chain: input.chain }, [
+        {
+            address: validator,
+            abi: [
+                {
+                    name: 'getOwners',
+                    type: 'function',
+                    inputs: [{ name: 'account', type: 'address' }],
+                    outputs: [{ name: '', type: 'address[]' }],
+                    stateMutability: 'view',
+                },
+            ],
+            functionName: 'getOwners',
+            args: [input.account],
+        },
+        {
+            address: validator,
+            abi: [
+                {
+                    name: 'threshold',
+                    type: 'function',
+                    inputs: [{ name: 'module', type: 'address' }],
+                    outputs: [{ name: '', type: 'uint256' }],
+                    stateMutability: 'view',
+                },
+            ],
+            functionName: 'threshold',
+            args: [input.account],
+        },
+    ]);
+    const [owners, threshold] = results;
+    if (owners.error ||
+        threshold.error ||
+        !owners.result ||
+        threshold.result === undefined) {
+        return null;
+    }
+    return { accounts: owners.result, threshold: Number(threshold.result) };
+}
+export function encodeAccountModuleDeInitData(input) {
+    if (input.module.kind !== 'validator' ||
+        !['nexus', 'safe', 'startale'].includes(input.accountKind)) {
+        return input.module.deInitData;
+    }
+    const index = input.installed.findIndex((address) => address.toLowerCase() === input.module.address.toLowerCase());
+    if (index < 0)
+        return input.module.deInitData;
+    return encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [
+        index === 0 ? sentinel : input.installed[index - 1],
+        input.module.deInitData,
+    ]);
+}

package/dist/src/modules/types.d.ts

@@ -0,0 +1,46 @@
+import type { Address, Hex } from 'viem';
+export type ModuleKind = 'validator' | 'executor' | 'fallback' | 'hook';
+export interface ModuleInput {
+    type: ModuleKind;
+    address: Address;
+    initData?: Hex;
+    deInitData?: Hex;
+    additionalContext?: Hex;
+}
+export type ModuleDataSelection = {
+    readonly source: 'explicit';
+    readonly value: Hex;
+} | {
+    readonly source: 'omitted';
+};
+export interface ConfiguredModule extends ModuleId {
+    readonly initData: ModuleDataSelection;
+    readonly deInitData: ModuleDataSelection;
+    readonly additionalContext: ModuleDataSelection;
+}
+export interface ModuleId {
+    readonly kind: ModuleKind;
+    readonly address: Address;
+}
+export interface ResolvedModule extends ModuleId {
+    readonly initData: Hex;
+    readonly deInitData: Hex;
+    readonly additionalContext: Hex;
+}
+export interface ModuleCapabilities {
+    readonly installable: boolean;
+    readonly uninstallable: boolean;
+    readonly supportsInitializationRead: boolean;
+}
+export interface ModuleInstallationPlan {
+    readonly module: ResolvedModule;
+    readonly operation: 'install' | 'uninstall';
+    readonly accountCallData: Hex;
+}
+export interface ModuleSetup {
+    readonly validators: readonly ResolvedModule[];
+    readonly executors: readonly ResolvedModule[];
+    readonly hooks: readonly ResolvedModule[];
+    readonly fallbacks: readonly ResolvedModule[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/modules/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../modules/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAExC,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAA;AAEvE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,UAAU,CAAC,EAAE,GAAG,CAAA;IAChB,iBAAiB,CAAC,EAAE,GAAG,CAAA;CACxB;AAED,MAAM,MAAM,mBAAmB,GAC3B;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAElC,MAAM,WAAW,gBAAiB,SAAQ,QAAQ;IAChD,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAA;IACxC,QAAQ,CAAC,iBAAiB,EAAE,mBAAmB,CAAA;CAChD;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,MAAM,WAAW,cAAe,SAAQ,QAAQ;IAC9C,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAE,GAAG,CAAA;IACxB,QAAQ,CAAC,iBAAiB,EAAE,GAAG,CAAA;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,0BAA0B,EAAE,OAAO,CAAA;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,GAAG,WAAW,CAAA;IAC3C,QAAQ,CAAC,eAAe,EAAE,GAAG,CAAA;CAC9B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,SAAS,cAAc,EAAE,CAAA;IAC9C,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAA;IAC7C,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAA;IACzC,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAA;CAC9C"}

package/dist/src/modules/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/validators/capabilities.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedModule } from '../types.js';
+import type { ResolvedValidatorDefinition, ValidatorCapabilities, ValidatorSigningPurpose } from './types.js';
+export declare function getValidatorCapabilities(definition: ResolvedValidatorDefinition, module: ResolvedModule, accountProfile: string, purpose: ValidatorSigningPurpose, supportsOriginReuse: boolean): ValidatorCapabilities;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/src/modules/validators/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../modules/validators/capabilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAQ9C,OAAO,KAAK,EACV,2BAA2B,EAC3B,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAEhB,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,2BAA2B,EACvC,MAAM,EAAE,cAAc,EACtB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,uBAAuB,EAChC,mBAAmB,EAAE,OAAO,GAC3B,qBAAqB,CAwDvB"}

package/dist/src/modules/validators/capabilities.js

@@ -0,0 +1,58 @@
+import { ENS_HCA_MODULE } from './ens.js';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from './k1.js';
+import { OWNABLE_BETA_VALIDATOR_ADDRESS, OWNABLE_V0_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, } from './ownable.js';
+export function getValidatorCapabilities(definition, module, accountProfile, purpose, supportsOriginReuse) {
+    const nested = definition.kind === 'multi-factor';
+    const legacyOwnable = [
+        OWNABLE_V0_VALIDATOR_ADDRESS.toLowerCase(),
+        OWNABLE_BETA_VALIDATOR_ADDRESS.toLowerCase(),
+    ].includes(module.address.toLowerCase());
+    const validatorRecovery = purpose !== 'user-operation' &&
+        [OWNABLE_VALIDATOR_ADDRESS, ENS_HCA_MODULE]
+            .map((address) => address.toLowerCase())
+            .includes(module.address.toLowerCase())
+        ? 'validator-offset-4'
+        : 'ethereum';
+    return {
+        compatibilityKey: {
+            validatorKind: definition.kind,
+            moduleAddress: module.address,
+            accountProfile,
+            purpose,
+        },
+        payloadKinds: [
+            'message',
+            'typed-data',
+            'intent',
+            'user-operation',
+            'session-enable',
+        ],
+        signatureModes: ['owner'],
+        signerTopology: nested
+            ? 'nested-threshold'
+            : definition.owners.length === 1
+                ? 'single'
+                : 'threshold',
+        supportsIndependentSigning: definition.kind !== 'smart-session' &&
+            module.address.toLowerCase() !==
+                K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase(),
+        supportsOriginReuse,
+        supportsMockSignature: true,
+        supportsEip712: !legacyOwnable,
+        recoveryEncoding: validatorRecovery,
+        contributionCodec: nested
+            ? {
+                kind: 'nested-threshold',
+                validator: module,
+                factorOrder: definition.validators.map((factor) => factor.id),
+                threshold: definition.threshold,
+            }
+            : {
+                kind: 'ordered-threshold',
+                validator: module,
+                ownerOrder: definition.owners.map((owner) => owner.id),
+                threshold: definition.threshold,
+                recoveryEncoding: validatorRecovery,
+            },
+    };
+}

package/dist/src/modules/validators/contribution.d.ts

@@ -0,0 +1,4 @@
+import type { Hex } from 'viem';
+import type { ValidatorContributionCodec, ValidatorContributionInput } from './types.js';
+export declare function encodeValidatorContribution(codec: ValidatorContributionCodec, contributions: readonly ValidatorContributionInput[]): Hex;
+//# sourceMappingURL=contribution.d.ts.map

package/dist/src/modules/validators/contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contribution.d.ts","sourceRoot":"","sources":["../../../../modules/validators/contribution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAI/B,OAAO,KAAK,EACV,0BAA0B,EAC1B,0BAA0B,EAC3B,MAAM,SAAS,CAAA;AAGhB,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,0BAA0B,EACjC,aAAa,EAAE,SAAS,0BAA0B,EAAE,GACnD,GAAG,CAgEL"}

package/dist/src/modules/validators/contribution.js

@@ -0,0 +1,64 @@
+import { encodeMultiFactorContribution } from './multi-factor.js';
+import { encodeEcdsaValidatorContribution } from './ownable.js';
+import { encodeSmartSessionContribution } from './smart-sessions/signature.js';
+import { encodeWebauthnValidatorContribution } from './webauthn.js';
+export function encodeValidatorContribution(codec, contributions) {
+    switch (codec.kind) {
+        case 'ordered-threshold': {
+            const ecdsa = contributions.filter((contribution) => contribution.kind === 'ecdsa');
+            const webauthn = contributions.filter((contribution) => contribution.kind === 'webauthn');
+            if (ecdsa.length > 0 && webauthn.length > 0) {
+                throw new Error('Atomic validators cannot mix signer result kinds');
+            }
+            if (webauthn.length > 0) {
+                if (!codec.webauthn) {
+                    throw new Error('WebAuthn contribution codec context is missing');
+                }
+                return encodeWebauthnValidatorContribution({
+                    ownerOrder: codec.ownerOrder,
+                    threshold: codec.threshold,
+                    ...codec.webauthn,
+                    contributions: webauthn,
+                });
+            }
+            if (ecdsa.length !== contributions.length) {
+                throw new Error('Ordered validator received an incompatible result');
+            }
+            return encodeEcdsaValidatorContribution({
+                ownerOrder: codec.ownerOrder,
+                threshold: codec.threshold,
+                recoveryEncoding: codec.recoveryEncoding,
+                contributions: ecdsa,
+            });
+        }
+        case 'nested-threshold': {
+            const factors = contributions.filter((contribution) => contribution.kind === 'factor');
+            if (factors.length !== contributions.length) {
+                throw new Error('Nested validator received a non-factor contribution');
+            }
+            return encodeMultiFactorContribution({
+                factorOrder: codec.factorOrder,
+                threshold: codec.threshold,
+                contributions: factors,
+            });
+        }
+        case 'smart-session': {
+            const signature = codec.signerCodec
+                ? encodeValidatorContribution(codec.signerCodec, contributions)
+                : contributions.length === 1 && contributions[0]?.kind === 'session'
+                    ? contributions[0].signature
+                    : undefined;
+            if (!signature)
+                throw new Error('Smart Session signer result is missing');
+            return encodeSmartSessionContribution({
+                mode: codec.mode,
+                permissionId: codec.permissionId,
+                signature,
+                ...(codec.claimPolicyData
+                    ? { claimPolicyData: codec.claimPolicyData }
+                    : {}),
+                ...(codec.enableData ? { enableData: codec.enableData } : {}),
+            });
+        }
+    }
+}