@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

package/dist/src/modules/read.js

@@ -1,171 +0,0 @@
-import { createPublicClient } from 'viem';
-import { createTransport } from '../accounts/utils.js';
-import { OWNABLE_VALIDATOR_ADDRESS } from './validators/core.js';
-async function getValidators(accountType, account, chain, provider) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, provider),
-    });
-    switch (accountType) {
-        case 'safe':
-        case 'startale':
-        case 'nexus': {
-            const validators = await publicClient.readContract({
-                abi: [
-                    {
-                        name: 'getValidatorsPaginated',
-                        type: 'function',
-                        inputs: [
-                            {
-                                name: 'cursor',
-                                type: 'address',
-                            },
-                            {
-                                name: 'pageSize',
-                                type: 'uint256',
-                            },
-                        ],
-                        outputs: [
-                            {
-                                name: 'array',
-                                type: 'address[]',
-                            },
-                            {
-                                name: 'next',
-                                type: 'address',
-                            },
-                        ],
-                    },
-                ],
-                functionName: 'getValidatorsPaginated',
-                address: account,
-                args: ['0x0000000000000000000000000000000000000001', 100n],
-            });
-            return validators[0];
-        }
-        case 'eoa': {
-            return [];
-        }
-        case 'kernel': {
-            throw new Error('Kernel not supported');
-        }
-    }
-}
-async function getOwners(account, chain, provider) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, provider),
-    });
-    const moduleAddress = OWNABLE_VALIDATOR_ADDRESS;
-    const [ownerResult, thresholdResult] = await publicClient.multicall({
-        contracts: [
-            {
-                abi: [
-                    {
-                        name: 'getOwners',
-                        type: 'function',
-                        inputs: [
-                            {
-                                name: 'account',
-                                type: 'address',
-                            },
-                        ],
-                        outputs: [
-                            {
-                                name: '',
-                                type: 'address[]',
-                            },
-                        ],
-                    },
-                ],
-                functionName: 'getOwners',
-                address: moduleAddress,
-                args: [account],
-            },
-            {
-                abi: [
-                    {
-                        name: 'threshold',
-                        type: 'function',
-                        inputs: [
-                            {
-                                name: 'module',
-                                type: 'address',
-                            },
-                        ],
-                        outputs: [
-                            {
-                                name: '',
-                                type: 'uint256',
-                            },
-                        ],
-                    },
-                ],
-                functionName: 'threshold',
-                address: moduleAddress,
-                args: [account],
-            },
-        ],
-    });
-    if (ownerResult.error) {
-        return null;
-    }
-    if (thresholdResult.error) {
-        return null;
-    }
-    return {
-        accounts: ownerResult.result,
-        threshold: thresholdResult.result,
-    };
-}
-async function getExecutors(accountType, account, chain, provider) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, provider),
-    });
-    switch (accountType) {
-        case 'safe':
-        case 'startale':
-        case 'nexus': {
-            const executors = await publicClient.readContract({
-                abi: [
-                    {
-                        name: 'getExecutorsPaginated',
-                        type: 'function',
-                        inputs: [
-                            {
-                                name: 'cursor',
-                                type: 'address',
-                            },
-                            {
-                                name: 'size',
-                                type: 'uint256',
-                            },
-                        ],
-                        outputs: [
-                            {
-                                name: 'array',
-                                type: 'address[]',
-                            },
-                            {
-                                name: 'next',
-                                type: 'address',
-                            },
-                        ],
-                    },
-                ],
-                functionName: 'getExecutorsPaginated',
-                address: account,
-                args: ['0x0000000000000000000000000000000000000001', 100n],
-            });
-            return executors[0];
-        }
-        case 'eoa': {
-            return [];
-        }
-        case 'kernel': {
-            throw new Error('Kernel not supported');
-        }
-    }
-}
-export { getValidators, getExecutors, getOwners };

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

@@ -1,31 +0,0 @@
-import { type Account, type Address, type Hex } from 'viem';
-import type { ENSValidatorConfig, OwnableValidatorConfig, OwnerSet, RhinestoneAccountConfig, WebauthnValidatorConfig } from '../../types.js';
-import { type Module } from '../common.js';
-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

@@ -1 +0,0 @@
-{"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

@@ -1,266 +0,0 @@
-import { bytesToHex, concat, encodeAbiParameters, encodePacked, hexToBytes, maxUint48, pad, toHex, } from 'viem';
-import { OwnersFieldRequiredError } from '../../accounts/error.js';
-import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
-const SMART_SESSION_EMISSARY_ADDRESS_DEV = '0x60731de80d78548875f8a67c4fec2a8660194e0c';
-const SMART_SESSION_EMISSARY_ADDRESS = '0xad568b3f825a8d5ffc06dd3253526b64d810ae89';
-const OWNABLE_VALIDATOR_ADDRESS = '0x000000000013fdb5234e4e3162a810f54d9f7e98';
-const ENS_VALIDATOR_ADDRESS = '0xdc38f07b060374b6480c4bf06231e7d10955bca4';
-const WEBAUTHN_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
-const SOCIAL_RECOVERY_VALIDATOR_ADDRESS = '0xa04d053b3c8021e8d5bf641816c42daa75d8b597';
-const MULTI_FACTOR_VALIDATOR_ADDRESS = '0xf6bdf42c9be18ceca5c06c42a43daf7fbbe7896b';
-// Legacy
-const OWNABLE_V0_VALIDATOR_ADDRESS = '0x2483da3a338895199e5e538530213157e931bf06';
-const OWNABLE_BETA_VALIDATOR_ADDRESS = '0x0000000000e9e6e96bcaa3c113187cdb7e38aed9';
-const WEBAUTHN_V0_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
-const ECDSA_MOCK_SIGNATURE = '0x81d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b';
-const WEBAUTHN_MOCK_SIGNATURE = '0x0000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001b9b86eb98fda3ed4d797d9e690588dfadf17b329a76a47cec935bebf92d7ddc80000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000001700000000000000000000000000000000000000000000000000000000000000019b2e9410bb6850f9f660a03d609d5a844fb96bcdc87a15139b03ee22c70f469100d2b865a215c3bf786387064effa8fcedcb1d625b5148f8a1236d5e3ff11acf000000000000000000000000000000000000000000000000000000000000002549960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d9763050000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000867b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a22396a4546696a75684557724d34534f572d7443684a625545484550343456636a634a2d42716f3166544d38222c226f726967696e223a22687474703a2f2f6c6f63616c686f73743a38303830222c2263726f73734f726967696e223a66616c73657d0000000000000000000000000000000000000000000000000000';
-function getOwnerValidator(config) {
-    if (!config.owners) {
-        throw new 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 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: encodePacked(['bytes12', 'address'], [
-                        pad(toHex(index), {
-                            size: 12,
-                        }),
-                        validatorModule.address,
-                    ]),
-                    data: signature,
-                };
-            });
-            return 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: encodeAbiParameters([
-            { name: 'threshold', type: 'uint256' },
-            { name: 'owners', type: 'address[]' },
-        ], [
-            BigInt(threshold),
-            owners.map((owner) => owner.toLowerCase()).sort(),
-        ]),
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: 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] ?? 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 = 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: 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: 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: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getMultiFactorValidator(threshold, validators) {
-    return {
-        address: MULTI_FACTOR_VALIDATOR_ADDRESS,
-        initData: encodePacked(['uint8', 'bytes'], [
-            threshold,
-            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: concat([
-                            pad(toHex(index), {
-                                size: 12,
-                            }),
-                            validatorModule.address,
-                        ]),
-                        data: validatorModule.initData,
-                    };
-                })
-                    .filter((validator) => validator !== null),
-            ]),
-        ]),
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getSocialRecoveryValidator(guardians, threshold = 1) {
-    const guardianAddresses = guardians.map((guardian) => guardian.address);
-    guardianAddresses.sort();
-    return {
-        type: MODULE_TYPE_ID_VALIDATOR,
-        address: SOCIAL_RECOVERY_VALIDATOR_ADDRESS,
-        initData: encodeAbiParameters([
-            {
-                type: 'uint256',
-                name: 'threshold',
-            },
-            {
-                type: 'address[]',
-                name: 'guardians',
-            },
-        ], [BigInt(threshold), guardianAddresses]),
-        deInitData: '0x',
-        additionalContext: '0x',
-    };
-}
-function parsePublicKey(publicKey) {
-    const bytes = typeof publicKey === 'string' ? 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(bytesToHex(x)),
-        y: BigInt(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;
-    }
-}
-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, };

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

@@ -1,4 +0,0 @@
-import { getMockSignature, getOwnerValidator, MULTI_FACTOR_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS } from './core.js';
-import { buildMockSignature, DUMMY_PRECLAIMOP_SELECTOR, DUMMY_PRECLAIMOP_TARGET, getEnableSessionCall, getPermissionId, getSmartSessionValidator, isSessionEnabled, packSignature, toSession } from './smart-sessions.js';
-export { OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, getPermissionId, getMockSignature, buildMockSignature, isSessionEnabled, packSignature, toSession, };
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../modules/validators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,8BAA8B,EAC9B,yBAAyB,EACzB,8BAA8B,EAC9B,0BAA0B,EAC3B,MAAM,QAAQ,CAAA;AACf,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,uBAAuB,EACvB,oBAAoB,EACpB,eAAe,EACf,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACV,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,yBAAyB,EACzB,0BAA0B,EAC1B,8BAA8B,EAC9B,8BAA8B,EAC9B,uBAAuB,EACvB,yBAAyB,EACzB,iBAAiB,EACjB,wBAAwB,EACxB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,aAAa,EACb,SAAS,GACV,CAAA"}

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

@@ -1,3 +0,0 @@
-import { getMockSignature, getOwnerValidator, MULTI_FACTOR_VALIDATOR_ADDRESS, OWNABLE_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, } from './core.js';
-import { buildMockSignature, DUMMY_PRECLAIMOP_SELECTOR, DUMMY_PRECLAIMOP_TARGET, getEnableSessionCall, getPermissionId, getSmartSessionValidator, isSessionEnabled, packSignature, toSession, } from './smart-sessions.js';
-export { OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, MULTI_FACTOR_VALIDATOR_ADDRESS, SMART_SESSION_EMISSARY_ADDRESS, DUMMY_PRECLAIMOP_TARGET, DUMMY_PRECLAIMOP_SELECTOR, getOwnerValidator, getSmartSessionValidator, getEnableSessionCall, getPermissionId, getMockSignature, buildMockSignature, isSessionEnabled, packSignature, toSession, };