@rhinestone/sdk 0.0.0-dev-20260204114155

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

@@ -0,0 +1,31 @@
+import { type Account, type Address, type Hex } from 'viem';
+import type { ENSValidatorConfig, OwnableValidatorConfig, OwnerSet, RhinestoneAccountConfig, WebauthnValidatorConfig } from '../../types';
+import { type Module } from '../common';
+declare const SMART_SESSION_EMISSARY_ADDRESS_DEV: Address;
+declare const SMART_SESSION_EMISSARY_ADDRESS: Address;
+interface PublicKey {
+    prefix?: number | undefined;
+    x: bigint;
+    y: bigint;
+}
+interface WebauthnCredential {
+    pubKey: PublicKey | Hex | Uint8Array;
+    authenticatorId: string;
+}
+declare const OWNABLE_VALIDATOR_ADDRESS: Address;
+declare const ENS_VALIDATOR_ADDRESS: Address;
+declare const WEBAUTHN_VALIDATOR_ADDRESS: Address;
+declare const MULTI_FACTOR_VALIDATOR_ADDRESS: Address;
+declare const WEBAUTHN_V0_VALIDATOR_ADDRESS: Address;
+declare function getOwnerValidator(config: RhinestoneAccountConfig): Module;
+declare function getMockSignature(ownerSet: OwnerSet): Hex;
+declare function getValidator(owners: OwnerSet): Module;
+declare function getOwnableValidator(threshold: number, owners: Address[], address?: Address): Module;
+declare function getENSValidator(threshold: number, owners: Address[], ownerExpirations: number[], address?: Address): Module;
+declare function getWebAuthnValidator(threshold: number, webAuthnCredentials: WebauthnCredential[], address?: Address): Module;
+declare function getMultiFactorValidator(threshold: number, validators: (OwnableValidatorConfig | ENSValidatorConfig | WebauthnValidatorConfig | null)[]): Module;
+declare function getSocialRecoveryValidator(guardians: Account[], threshold?: number): Module;
+declare function supportsEip712(validator: Module): boolean;
+export { OWNABLE_VALIDATOR_ADDRESS, ENS_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, WEBAUTHN_V0_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, getOwnerValidator, getOwnableValidator, getENSValidator, getWebAuthnValidator, getMultiFactorValidator, getSocialRecoveryValidator, getValidator, getMockSignature, supportsEip712, };
+export type { WebauthnCredential };
+//# sourceMappingURL=core.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../modules/validators/core.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,OAAO,EAKZ,KAAK,GAAG,EAKT,MAAM,MAAM,CAAA;AAGb,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,QAAQ,EACR,uBAAuB,EACvB,uBAAuB,EACxB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAA;AAEjE,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAC9C,QAAA,MAAM,8BAA8B,EAAE,OACQ,CAAA;AAE9C,UAAU,SAAS;IACjB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,UAAU,kBAAkB;IAC1B,MAAM,EAAE,SAAS,GAAG,GAAG,GAAG,UAAU,CAAA;IACpC,eAAe,EAAE,MAAM,CAAA;CACxB;AAED,QAAA,MAAM,yBAAyB,EAAE,OACa,CAAA;AAC9C,QAAA,MAAM,qBAAqB,EAAE,OACiB,CAAA;AAC9C,QAAA,MAAM,0BAA0B,EAAE,OACY,CAAA;AAG9C,QAAA,MAAM,8BAA8B,EAAE,OACQ,CAAA;AAO9C,QAAA,MAAM,6BAA6B,EAAE,OACS,CAAA;AAO9C,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,UAKzD;AAED,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAmDjD;AAED,iBAAS,YAAY,CAAC,MAAM,EAAE,QAAQ,UA2BrC;AAED,iBAAS,mBAAmB,CAC1B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EAAE,EACjB,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CAiBR;AAED,iBAAS,eAAe,CACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EAAE,EACjB,gBAAgB,EAAE,MAAM,EAAE,EAC1B,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CAsCR;AAED,iBAAS,oBAAoB,CAC3B,SAAS,EAAE,MAAM,EACjB,mBAAmB,EAAE,kBAAkB,EAAE,EACzC,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CA4DR;AAED,iBAAS,uBAAuB,CAC9B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,CACR,sBAAsB,GACtB,kBAAkB,GAClB,uBAAuB,GACvB,IAAI,CACP,EAAE,GACF,MAAM,CAgDR;AAED,iBAAS,0BAA0B,CACjC,SAAS,EAAE,OAAO,EAAE,EACpB,SAAS,SAAI,GACZ,MAAM,CAsBR;AAeD,iBAAS,cAAc,CAAC,SAAS,EAAE,MAAM,WAUxC;AAED,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,8BAA8B,EAC9B,6BAA6B,EAC7B,8BAA8B,EAC9B,kCAAkC,EAClC,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EACvB,0BAA0B,EAC1B,YAAY,EACZ,gBAAgB,EAChB,cAAc,GACf,CAAA;AACD,YAAY,EAAE,kBAAkB,EAAE,CAAA"}

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

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMART_SESSION_EMISSARY_ADDRESS_DEV = exports.SMART_SESSION_EMISSARY_ADDRESS = exports.WEBAUTHN_V0_VALIDATOR_ADDRESS = exports.MULTI_FACTOR_VALIDATOR_ADDRESS = exports.WEBAUTHN_VALIDATOR_ADDRESS = exports.ENS_VALIDATOR_ADDRESS = exports.OWNABLE_VALIDATOR_ADDRESS = void 0;
+exports.getOwnerValidator = getOwnerValidator;
+exports.getOwnableValidator = getOwnableValidator;
+exports.getENSValidator = getENSValidator;
+exports.getWebAuthnValidator = getWebAuthnValidator;
+exports.getMultiFactorValidator = getMultiFactorValidator;
+exports.getSocialRecoveryValidator = getSocialRecoveryValidator;
+exports.getValidator = getValidator;
+exports.getMockSignature = getMockSignature;
+exports.supportsEip712 = supportsEip712;
+const viem_1 = require("viem");
+const error_1 = require("../../accounts/error");
+const common_1 = require("../common");
+const SMART_SESSION_EMISSARY_ADDRESS_DEV = '0x60731de80d78548875f8a67c4fec2a8660194e0c';
+exports.SMART_SESSION_EMISSARY_ADDRESS_DEV = SMART_SESSION_EMISSARY_ADDRESS_DEV;
+const SMART_SESSION_EMISSARY_ADDRESS = '0xad568b3f825a8d5ffc06dd3253526b64d810ae89';
+exports.SMART_SESSION_EMISSARY_ADDRESS = SMART_SESSION_EMISSARY_ADDRESS;
+const OWNABLE_VALIDATOR_ADDRESS = '0x000000000013fdb5234e4e3162a810f54d9f7e98';
+exports.OWNABLE_VALIDATOR_ADDRESS = OWNABLE_VALIDATOR_ADDRESS;
+const ENS_VALIDATOR_ADDRESS = '0xdc38f07b060374b6480c4bf06231e7d10955bca4';
+exports.ENS_VALIDATOR_ADDRESS = ENS_VALIDATOR_ADDRESS;
+const WEBAUTHN_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
+exports.WEBAUTHN_VALIDATOR_ADDRESS = WEBAUTHN_VALIDATOR_ADDRESS;
+const SOCIAL_RECOVERY_VALIDATOR_ADDRESS = '0xa04d053b3c8021e8d5bf641816c42daa75d8b597';
+const MULTI_FACTOR_VALIDATOR_ADDRESS = '0xf6bdf42c9be18ceca5c06c42a43daf7fbbe7896b';
+exports.MULTI_FACTOR_VALIDATOR_ADDRESS = MULTI_FACTOR_VALIDATOR_ADDRESS;
+// Legacy
+const OWNABLE_V0_VALIDATOR_ADDRESS = '0x2483da3a338895199e5e538530213157e931bf06';
+const OWNABLE_BETA_VALIDATOR_ADDRESS = '0x0000000000e9e6e96bcaa3c113187cdb7e38aed9';
+const WEBAUTHN_V0_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
+exports.WEBAUTHN_V0_VALIDATOR_ADDRESS = WEBAUTHN_V0_VALIDATOR_ADDRESS;
+const ECDSA_MOCK_SIGNATURE = '0x81d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b';
+const WEBAUTHN_MOCK_SIGNATURE = '0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001b9b86eb98fda3ed4d797d9e690588dfadf17b329a76a47cec935bebf92d7ddc80000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000001700000000000000000000000000000000000000000000000000000000000000019b2e9410bb6850f9f660a03d609d5a844fb96bcdc87a15139b03ee22c70f469100d2b865a215c3bf786387064effa8fcedcb1d625b5148f8a1236d5e3ff11acf000000000000000000000000000000000000000000000000000000000000002549960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d9763050000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000867b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22396a4546696a75684557724d34534f572d7443684a625545484550343456636a634a2d42716f3166544d38222c226f726967696e223a22687474703a2f2f6c6f63616c686f73743a38303830222c2263726f73734f726967696e223a66616c73657d0000000000000000000000000000000000000000000000000000';
+function getOwnerValidator(config) {
+    if (!config.owners) {
+        throw new error_1.OwnersFieldRequiredError();
+    }
+    return getValidator(config.owners);
+}
+function getMockSignature(ownerSet) {
+    switch (ownerSet.type) {
+        case 'ecdsa':
+        case 'ens': {
+            // ENS validator uses same mock signature format as ECDSA for UserOps
+            const owners = ownerSet.accounts.map((account) => account.address);
+            const signatures = owners.map(() => ECDSA_MOCK_SIGNATURE);
+            return (0, viem_1.concat)(signatures);
+        }
+        case 'passkey':
+            return WEBAUTHN_MOCK_SIGNATURE;
+        case 'multi-factor': {
+            const mockValidators = ownerSet.validators.map((validator, index) => {
+                const validatorModule = getValidator(validator);
+                const signature = getMockSignature(validator);
+                return {
+                    packedValidatorAndId: (0, viem_1.encodePacked)(['bytes12', 'address'], [
+                        (0, viem_1.pad)((0, viem_1.toHex)(index), {
+                            size: 12,
+                        }),
+                        validatorModule.address,
+                    ]),
+                    data: signature,
+                };
+            });
+            return (0, viem_1.encodeAbiParameters)([
+                {
+                    components: [
+                        {
+                            internalType: 'bytes32',
+                            name: 'packedValidatorAndId',
+                            type: 'bytes32',
+                        },
+                        { internalType: 'bytes', name: 'data', type: 'bytes' },
+                    ],
+                    name: 'validators',
+                    type: 'tuple[]',
+                },
+            ], [mockValidators]);
+        }
+    }
+}
+function getValidator(owners) {
+    switch (owners.type) {
+        case 'ecdsa':
+            return getOwnableValidator(owners.threshold ?? 1, owners.accounts.map((account) => account.address), owners.module);
+        case 'ens':
+            return getENSValidator(owners.threshold ?? 1, owners.accounts.map((account) => account.address), owners.ownerExpirations, owners.module);
+        case 'passkey':
+            return getWebAuthnValidator(owners.threshold ?? 1, owners.accounts.map((account) => ({
+                pubKey: account.publicKey,
+                authenticatorId: account.id,
+            })));
+        case 'multi-factor': {
+            return getMultiFactorValidator(owners.threshold ?? 1, owners.validators);
+        }
+    }
+}
+function getOwnableValidator(threshold, owners, address) {
+    return {
+        address: address ?? OWNABLE_VALIDATOR_ADDRESS,
+        initData: (0, viem_1.encodeAbiParameters)([
+            { name: 'threshold', type: 'uint256' },
+            { name: 'owners', type: 'address[]' },
+        ], [
+            BigInt(threshold),
+            owners.map((owner) => owner.toLowerCase()).sort(),
+        ]),
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
+}
+function getENSValidator(threshold, owners, ownerExpirations, address) {
+    // format: (uint256 threshold, Owner[] owners)
+    // where Owner is a tuple of (address addr, uint48 expiration)
+    const ownerPairs = owners.map((owner, index) => ({
+        addr: owner.toLowerCase(),
+        expiration: ownerExpirations[index] ?? viem_1.maxUint48,
+    }));
+    // Sort by address to match ENS validator's expectations
+    const sortedPairs = ownerPairs.sort((a, b) => a.addr.localeCompare(b.addr));
+    const ownersWithExpiration = sortedPairs;
+    const initData = (0, viem_1.encodeAbiParameters)([
+        { name: 'threshold', type: 'uint256' },
+        {
+            name: 'owners',
+            type: 'tuple[]',
+            components: [
+                { name: 'addr', type: 'address' },
+                { name: 'expiration', type: 'uint48' },
+            ],
+        },
+    ], [BigInt(threshold), ownersWithExpiration]);
+    const moduleAddress = address ?? ENS_VALIDATOR_ADDRESS;
+    return {
+        address: moduleAddress,
+        initData,
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
+}
+function getWebAuthnValidator(threshold, webAuthnCredentials, address) {
+    function getPublicKey(webAuthnCredential) {
+        if (typeof webAuthnCredential.pubKey === 'string' ||
+            webAuthnCredential.pubKey instanceof Uint8Array) {
+            // It's a P256Credential
+            const { x, y, prefix } = parsePublicKey(webAuthnCredential.pubKey);
+            if (prefix && prefix !== 4) {
+                throw new Error('Only uncompressed public keys are supported');
+            }
+            return {
+                x,
+                y,
+            };
+        }
+        else {
+            // It's already a PublicKey
+            return webAuthnCredential.pubKey;
+        }
+    }
+    const publicKeys = webAuthnCredentials.map(getPublicKey);
+    return {
+        address: address ?? WEBAUTHN_VALIDATOR_ADDRESS,
+        initData: (0, viem_1.encodeAbiParameters)([
+            { name: 'threshold', type: 'uint256' },
+            {
+                name: 'credentials',
+                type: 'tuple[]',
+                components: [
+                    {
+                        name: 'pubKeyX',
+                        type: 'uint256',
+                    },
+                    {
+                        name: 'pubKeyY',
+                        type: 'uint256',
+                    },
+                    {
+                        name: 'requireUV',
+                        type: 'bool',
+                    },
+                ],
+            },
+        ], [
+            BigInt(threshold),
+            publicKeys.map((publicKey) => ({
+                pubKeyX: publicKey.x,
+                pubKeyY: publicKey.y,
+                requireUV: false,
+            })),
+        ]),
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
+}
+function getMultiFactorValidator(threshold, validators) {
+    return {
+        address: MULTI_FACTOR_VALIDATOR_ADDRESS,
+        initData: (0, viem_1.encodePacked)(['uint8', 'bytes'], [
+            threshold,
+            (0, viem_1.encodeAbiParameters)([
+                {
+                    components: [
+                        {
+                            internalType: 'bytes32',
+                            name: 'packedValidatorAndId',
+                            type: 'bytes32',
+                        },
+                        { internalType: 'bytes', name: 'data', type: 'bytes' },
+                    ],
+                    name: 'validators',
+                    type: 'tuple[]',
+                },
+            ], [
+                validators
+                    .map((validator, index) => {
+                    if (validator === null) {
+                        return null;
+                    }
+                    const validatorModule = getValidator(validator);
+                    return {
+                        packedValidatorAndId: (0, viem_1.concat)([
+                            (0, viem_1.pad)((0, viem_1.toHex)(index), {
+                                size: 12,
+                            }),
+                            validatorModule.address,
+                        ]),
+                        data: validatorModule.initData,
+                    };
+                })
+                    .filter((validator) => validator !== null),
+            ]),
+        ]),
+        deInitData: '0x',
+        additionalContext: '0x',
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+    };
+}
+function getSocialRecoveryValidator(guardians, threshold = 1) {
+    const guardianAddresses = guardians.map((guardian) => guardian.address);
+    guardianAddresses.sort();
+    return {
+        type: common_1.MODULE_TYPE_ID_VALIDATOR,
+        address: SOCIAL_RECOVERY_VALIDATOR_ADDRESS,
+        initData: (0, viem_1.encodeAbiParameters)([
+            {
+                type: 'uint256',
+                name: 'threshold',
+            },
+            {
+                type: 'address[]',
+                name: 'guardians',
+            },
+        ], [BigInt(threshold), guardianAddresses]),
+        deInitData: '0x',
+        additionalContext: '0x',
+    };
+}
+function parsePublicKey(publicKey) {
+    const bytes = typeof publicKey === 'string' ? (0, viem_1.hexToBytes)(publicKey) : publicKey;
+    const offset = bytes.length === 65 ? 1 : 0;
+    const x = bytes.slice(offset, 32 + offset);
+    const y = bytes.slice(32 + offset, 64 + offset);
+    return {
+        prefix: bytes.length === 65 ? bytes[0] : undefined,
+        x: BigInt((0, viem_1.bytesToHex)(x)),
+        y: BigInt((0, viem_1.bytesToHex)(y)),
+    };
+}
+function supportsEip712(validator) {
+    switch (validator.address.toLowerCase()) {
+        case OWNABLE_BETA_VALIDATOR_ADDRESS: // Ownable Validator V1-beta
+        case OWNABLE_V0_VALIDATOR_ADDRESS: // Ownable Validator V0
+        case SMART_SESSION_EMISSARY_ADDRESS: // Smart Sessions (not yet supported)
+        case SMART_SESSION_EMISSARY_ADDRESS_DEV: // Smart Sessions (not yet supported)
+            return false;
+        default:
+            return true;
+    }
+}

package/dist/src/modules/validators/core.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=core.test.d.ts.map

package/dist/src/modules/validators/core.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.test.d.ts","sourceRoot":"","sources":["../../../../modules/validators/core.test.ts"],"names":[],"mappings":""}

package/dist/src/modules/validators/core.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const vitest_1 = require("vitest");
+const consts_1 = require("../../../test/consts");
+const common_1 = require("../common");
+const core_1 = require("./core");
+(0, vitest_1.describe)('Validators Core', () => {
+    (0, vitest_1.describe)('Validator', () => {
+        (0, vitest_1.test)('ECDSA: single address', () => {
+            const validator = (0, core_1.getValidator)({
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            });
+            (0, vitest_1.expect)(validator.type).toEqual(common_1.MODULE_TYPE_ID_VALIDATOR);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(validator.address)).toEqual(true);
+            (0, vitest_1.expect)(validator.address).toEqual('0x000000000013fdb5234e4e3162a810f54d9f7e98');
+            (0, vitest_1.expect)(validator.initData).toEqual('0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936');
+        });
+        (0, vitest_1.test)('ECDSA: two addresses', () => {
+            const validator = (0, core_1.getValidator)({
+                type: 'ecdsa',
+                accounts: [consts_1.accountA, consts_1.accountB],
+            });
+            (0, vitest_1.expect)(validator.type).toEqual(common_1.MODULE_TYPE_ID_VALIDATOR);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(validator.address)).toEqual(true);
+            (0, vitest_1.expect)(validator.address).toEqual('0x000000000013fdb5234e4e3162a810f54d9f7e98');
+            (0, vitest_1.expect)(validator.initData).toEqual('0x0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936');
+        });
+        (0, vitest_1.test)('ECDSA: three addresses, custom threshold', () => {
+            const validator = (0, core_1.getValidator)({
+                type: 'ecdsa',
+                accounts: [consts_1.accountA, consts_1.accountB, consts_1.accountC],
+                threshold: 2,
+            });
+            (0, vitest_1.expect)(validator.type).toEqual(common_1.MODULE_TYPE_ID_VALIDATOR);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(validator.address)).toEqual(true);
+            (0, vitest_1.expect)(validator.address).toEqual('0x000000000013fdb5234e4e3162a810f54d9f7e98');
+            (0, vitest_1.expect)(validator.initData).toEqual('0x0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000030000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000c27b7578151c5ef713c62c65db09763d57ac3596000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936');
+        });
+        (0, vitest_1.test)('Passkey', () => {
+            const validator = (0, core_1.getValidator)({
+                type: 'passkey',
+                accounts: [consts_1.passkeyAccount],
+            });
+            (0, vitest_1.expect)(validator.type).toEqual(common_1.MODULE_TYPE_ID_VALIDATOR);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(validator.address)).toEqual(true);
+            (0, vitest_1.expect)(validator.address).toEqual('0x0000000000578c4cb0e472a5462da43c495c3f33');
+            (0, vitest_1.expect)(validator.initData).toEqual('0x000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d10000000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+    (0, vitest_1.describe)('Mock Signature', () => {
+        (0, vitest_1.test)('ECDSA: single address', () => {
+            const signature = (0, core_1.getMockSignature)({
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            });
+            (0, vitest_1.expect)((0, viem_1.size)(signature)).toEqual(65);
+        });
+        (0, vitest_1.test)('ECDSA: multiple addresses', () => {
+            const signature = (0, core_1.getMockSignature)({
+                type: 'ecdsa',
+                accounts: [consts_1.accountA, consts_1.accountB, consts_1.accountC],
+            });
+            (0, vitest_1.expect)((0, viem_1.size)(signature)).toEqual(3 * 65);
+        });
+        (0, vitest_1.test)('Passkey', () => {
+            const signature = (0, core_1.getMockSignature)({
+                type: 'passkey',
+                accounts: [consts_1.passkeyAccount],
+            });
+            // Should have the proper schema
+            (0, viem_1.decodeAbiParameters)([
+                {
+                    type: 'bytes',
+                    name: 'authenticatorData',
+                },
+                {
+                    type: 'string',
+                    name: 'clientDataJSON',
+                },
+                {
+                    type: 'uint256',
+                    name: 'challengeIndex',
+                },
+                {
+                    type: 'uint256',
+                    name: 'typeIndex',
+                },
+                {
+                    type: 'uint256',
+                    name: 'r',
+                },
+                {
+                    type: 'uint256',
+                    name: 's',
+                },
+            ], signature);
+        });
+    });
+});

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

@@ -0,0 +1,4 @@
+import { getMockSignature, getOwnerValidator } from './core';
+import { getEnableSessionCall, getPermissionId, getSmartSessionValidator } from './smart-sessions';
+export { getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, getPermissionId, getMockSignature, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../modules/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,wBAAwB,EACzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,GACjB,CAAA"}

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMockSignature = exports.getPermissionId = exports.getEnableSessionCall = exports.getSmartSessionValidator = exports.getOwnerValidator = void 0;
+const core_1 = require("./core");
+Object.defineProperty(exports, "getMockSignature", { enumerable: true, get: function () { return core_1.getMockSignature; } });
+Object.defineProperty(exports, "getOwnerValidator", { enumerable: true, get: function () { return core_1.getOwnerValidator; } });
+const smart_sessions_1 = require("./smart-sessions");
+Object.defineProperty(exports, "getEnableSessionCall", { enumerable: true, get: function () { return smart_sessions_1.getEnableSessionCall; } });
+Object.defineProperty(exports, "getPermissionId", { enumerable: true, get: function () { return smart_sessions_1.getPermissionId; } });
+Object.defineProperty(exports, "getSmartSessionValidator", { enumerable: true, get: function () { return smart_sessions_1.getSmartSessionValidator; } });

package/dist/src/modules/validators/smart-sessions.d.ts

@@ -0,0 +1,185 @@
+import { type Address, type Hex, type TypedDataDefinition } from 'viem';
+import type { ProviderConfig, RhinestoneAccountConfig, RhinestoneConfig, Session, SignerSet } from '../../types';
+import { type Module } from '../common';
+import { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV } from './core';
+interface SessionData {
+    sessionValidator: Address;
+    sessionValidatorInitData: Hex;
+    salt: Hex;
+    erc7739Policies: {
+        allowedERC7739Content: readonly AllowedERC7739Content[];
+        erc1271Policies: readonly ERC1271Policy[];
+    };
+    actions: readonly ActionData[];
+    claimPolicies: readonly PolicyData[];
+}
+interface ERC1271Policy {
+    policy: Address;
+    initData: Hex;
+}
+interface AllowedERC7739Content {
+    appDomainSeparator: Hex;
+    contentNames: readonly string[];
+}
+interface ActionData {
+    actionTargetSelector: Hex;
+    actionTarget: Address;
+    actionPolicies: readonly PolicyData[];
+}
+interface PolicyData {
+    policy: Address;
+    initData: Hex;
+}
+type SmartSessionModeType = typeof SMART_SESSION_MODE_USE | typeof SMART_SESSION_MODE_ENABLE;
+interface ChainDigest {
+    chainId: bigint;
+    sessionDigest: Hex;
+}
+interface SignedPermissions {
+    permitGenericPolicy: boolean;
+    permitAdminAccess: boolean;
+    ignoreSecurityAttestations: boolean;
+    permitERC4337Paymaster: boolean;
+    userOpPolicies: readonly PolicyData[];
+    erc7739Policies: ERC7739Data;
+    actions: readonly ActionData[];
+}
+interface SignedSession {
+    account: Address;
+    permissions: SignedPermissions;
+    sessionValidator: Address;
+    sessionValidatorInitData: Hex;
+    salt: Hex;
+    smartSession: Address;
+    nonce: bigint;
+}
+interface ChainSession {
+    chainId: bigint;
+    session: SignedSession;
+}
+interface ERC7739Data {
+    allowedERC7739Content: readonly ERC7739Context[];
+    erc1271Policies: readonly PolicyData[];
+}
+interface ERC7739Context {
+    appDomainSeparator: Hex;
+    contentName: readonly string[];
+}
+interface SessionDetails {
+    nonces: bigint[];
+    hashesAndChainIds: ChainDigest[];
+    data: TypedDataDefinition<typeof types, 'MultiChainSession'>;
+}
+declare const types: {
+    readonly PolicyData: readonly [{
+        readonly name: "policy";
+        readonly type: "address";
+    }, {
+        readonly name: "initData";
+        readonly type: "bytes";
+    }];
+    readonly ActionData: readonly [{
+        readonly name: "actionTargetSelector";
+        readonly type: "bytes4";
+    }, {
+        readonly name: "actionTarget";
+        readonly type: "address";
+    }, {
+        readonly name: "actionPolicies";
+        readonly type: "PolicyData[]";
+    }];
+    readonly ERC7739Context: readonly [{
+        readonly name: "appDomainSeparator";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "contentName";
+        readonly type: "string[]";
+    }];
+    readonly ERC7739Data: readonly [{
+        readonly name: "allowedERC7739Content";
+        readonly type: "ERC7739Context[]";
+    }, {
+        readonly name: "erc1271Policies";
+        readonly type: "PolicyData[]";
+    }];
+    readonly LockTagData: readonly [{
+        readonly name: "lockTag";
+        readonly type: "bytes12";
+    }, {
+        readonly name: "claimPolicies";
+        readonly type: "PolicyData[]";
+    }];
+    readonly SignedPermissions: readonly [{
+        readonly name: "actions";
+        readonly type: "ActionData[]";
+    }, {
+        readonly name: "erc7739Policies";
+        readonly type: "ERC7739Data";
+    }, {
+        readonly name: "lockTagPolicies";
+        readonly type: "LockTagData";
+    }, {
+        readonly name: "permitGenericPolicy";
+        readonly type: "bool";
+    }];
+    readonly SignedSession: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }, {
+        readonly name: "expires";
+        readonly type: "uint256";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "permissions";
+        readonly type: "SignedPermissions";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "sessionValidator";
+        readonly type: "address";
+    }, {
+        readonly name: "sessionValidatorInitData";
+        readonly type: "bytes";
+    }, {
+        readonly name: "smartSessionEmissary";
+        readonly type: "address";
+    }];
+    readonly ChainSession: readonly [{
+        readonly name: "chainId";
+        readonly type: "uint64";
+    }, {
+        readonly name: "session";
+        readonly type: "SignedSession";
+    }];
+    readonly MultiChainSession: readonly [{
+        readonly name: "sessionsAndChainIds";
+        readonly type: "ChainSession[]";
+    }];
+};
+declare const SMART_SESSION_MODE_USE = "0x00";
+declare const SMART_SESSION_MODE_ENABLE = "0x01";
+declare const SMART_SESSIONS_FALLBACK_TARGET_FLAG: Address;
+declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG: Hex;
+declare const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION: Hex;
+declare function packSignature(signers: SignerSet & {
+    type: 'experimental_session';
+}, validatorSignature: Hex): Hex;
+declare function getSessionDetails(account: Address, sessions: Session[], useDevContracts?: boolean): Promise<SessionDetails>;
+declare function isSessionEnabled(account: Address, provider: ProviderConfig | undefined, session: Session, useDevContracts?: boolean): Promise<boolean>;
+declare function signEnableSession(config: RhinestoneAccountConfig, details: SessionDetails): Promise<Hex>;
+declare function getEnableSessionCall(account: Address, session: Session, enableSessionSignature: Hex, hashesAndChainIds: {
+    chainId: bigint;
+    sessionDigest: Hex;
+}[], sessionToEnableIndex: number, useDevContracts?: boolean): Promise<{
+    to: `0x${string}`;
+    data: `0x${string}`;
+}>;
+declare function getSessionData(session: Session): SessionData;
+declare function getPermissionId(session: Session): `0x${string}`;
+declare function getSmartSessionValidator(config: RhinestoneConfig): Module | null;
+export { SMART_SESSION_EMISSARY_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS_DEV, SMART_SESSIONS_FALLBACK_TARGET_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG, SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG_PERMITTED_TO_CALL_SMARTSESSION, packSignature, getSessionData, getEnableSessionCall, getPermissionId, getSmartSessionValidator, getSessionDetails, isSessionEnabled, signEnableSession, };
+export type { ChainSession, ChainDigest, SessionData, SmartSessionModeType, SessionDetails, };
+//# sourceMappingURL=smart-sessions.d.ts.map

package/dist/src/modules/validators/smart-sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../../modules/validators/smart-sessions.ts"],"names":[],"mappings":"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"}