@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.45

package/dist/src/modules/read.js

@@ -1,219 +0,0 @@
-import { createPublicClient } from 'viem';
-import { createTransport } from '../accounts/utils.js';
-import { ENS_HCA_MODULE, 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 'hca':
-        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(accountType, account, chain, provider, hcaFactory) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, provider),
-    });
-    // HCA accounts hold owner state under the HCA module (the factory's init-data
-    // parser), which is OwnableValidator-based, so the getOwners/threshold reads
-    // are identical. A custom factory defines its own module, so resolve it from
-    // the factory; otherwise fall back to the canonical module.
-    let moduleAddress = OWNABLE_VALIDATOR_ADDRESS;
-    if (accountType === 'hca') {
-        moduleAddress = hcaFactory
-            ? await publicClient.readContract({
-                abi: [
-                    {
-                        name: 'initDataParser',
-                        type: 'function',
-                        stateMutability: 'view',
-                        inputs: [],
-                        outputs: [{ name: '', type: 'address' }],
-                    },
-                ],
-                functionName: 'initDataParser',
-                address: hcaFactory,
-            })
-            : ENS_HCA_MODULE;
-    }
-    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 'hca':
-        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');
-        }
-    }
-}
-async function isValidatorInitialized(account, chain, validatorAddress, provider) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, provider),
-    });
-    // `isInitialized` is a plain storage read on the validator singleton and
-    // returns `false` for an uninitialized (or undeployed) account without
-    // reverting. We deliberately let real read failures (provider/ABI errors)
-    // propagate rather than coercing them to `false`, which could otherwise
-    // produce an `onInstall` call for an already-initialized account.
-    return publicClient.readContract({
-        abi: [
-            {
-                name: 'isInitialized',
-                type: 'function',
-                stateMutability: 'view',
-                inputs: [{ name: 'smartAccount', type: 'address' }],
-                outputs: [{ name: '', type: 'bool' }],
-            },
-        ],
-        functionName: 'isInitialized',
-        address: validatorAddress,
-        args: [account],
-    });
-}
-export { getValidators, getExecutors, getOwners, isValidatorInitialized };

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

@@ -1,31 +0,0 @@
-import { 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_HCA_MODULE: Address;
-declare const WEBAUTHN_VALIDATOR_ADDRESS: Address;
-declare const MULTI_FACTOR_VALIDATOR_ADDRESS: Address;
-declare const WEBAUTHN_V0_VALIDATOR_ADDRESS: Address;
-declare function ownerSetUsesEns(owners: OwnerSet): boolean;
-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[], expirations: (Date | undefined)[]): Module;
-declare function getWebAuthnValidator(threshold: number, webAuthnCredentials: WebauthnCredential[], address?: Address): Module;
-declare function getMultiFactorValidator(threshold: number, validators: (OwnableValidatorConfig | ENSValidatorConfig | WebauthnValidatorConfig | null)[], address?: Address): Module;
-declare function supportsEip712(validator: Module): boolean;
-export { OWNABLE_VALIDATOR_ADDRESS, ENS_HCA_MODULE, 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, getValidator, getMockSignature, supportsEip712, ownerSetUsesEns, };
-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,EAKZ,KAAK,GAAG,EAKT,MAAM,MAAM,CAAA;AAMb,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,cAAc,EAAE,OAAsD,CAAA;AAC5E,QAAA,MAAM,0BAA0B,EAAE,OACY,CAAA;AAC9C,QAAA,MAAM,8BAA8B,EAAE,OACQ,CAAA;AAO9C,QAAA,MAAM,6BAA6B,EAAE,OACS,CAAA;AAU9C,iBAAS,eAAe,CAAC,MAAM,EAAE,QAAQ,GAAG,OAAO,CAMlD;AAED,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,UAazD;AAED,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAsDjD;AAED,iBAAS,YAAY,CAAC,MAAM,EAAE,QAAQ,UAiCrC;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,WAAW,EAAE,CAAC,IAAI,GAAG,SAAS,CAAC,EAAE,GAChC,MAAM,CA4CR;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,EACH,OAAO,CAAC,EAAE,OAAO,GAChB,MAAM,CAgDR;AAeD,iBAAS,cAAc,CAAC,SAAS,EAAE,MAAM,WAUxC;AAED,OAAO,EACL,yBAAyB,EACzB,cAAc,EACd,0BAA0B,EAC1B,8BAA8B,EAC9B,6BAA6B,EAC7B,8BAA8B,EAC9B,kCAAkC,EAClC,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,uBAAuB,EACvB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,eAAe,GAChB,CAAA;AACD,YAAY,EAAE,kBAAkB,EAAE,CAAA"}

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

@@ -1,269 +0,0 @@
-import { bytesToHex, concat, encodeAbiParameters, encodePacked, hexToBytes, maxUint48, pad, toHex, } from 'viem';
-import { AccountConfigurationNotSupportedError, 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_HCA_MODULE = '0x5049ecBd4d961aE6DFEED9b7ccCe7f026454970E';
-const WEBAUTHN_VALIDATOR_ADDRESS = '0x0000000000578c4cb0e472a5462da43c495c3f33';
-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';
-// ENS validation is only available on HCA accounts (its validator default is
-// the HCA module). True for a direct ENS owner set or an ENS sub-validator
-// nested in a multi-factor config.
-function ownerSetUsesEns(owners) {
-    return (owners.type === 'ens' ||
-        (owners.type === 'multi-factor' &&
-            owners.validators.some((validator) => validator.type === 'ens')));
-}
-function getOwnerValidator(config) {
-    if (!config.owners) {
-        throw new OwnersFieldRequiredError();
-    }
-    // ENS owners resolve to the HCA module, which is only valid for HCA accounts.
-    // Other account types would silently install/sign against the wrong validator.
-    if (ownerSetUsesEns(config.owners) && config.account?.type !== 'hca') {
-        throw new AccountConfigurationNotSupportedError('ENS owners are only supported on HCA accounts', config.account?.type ?? 'nexus');
-    }
-    return getValidator(config.owners);
-}
-function getMockSignature(ownerSet) {
-    switch (ownerSet.type) {
-        case 'ecdsa': {
-            const owners = ownerSet.accounts.map((account) => account.address);
-            const signatures = owners.map(() => ECDSA_MOCK_SIGNATURE);
-            return concat(signatures);
-        }
-        case 'ens': {
-            // ENS validator uses same mock signature format as ECDSA for UserOps
-            const signatures = ownerSet.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':
-            // ENS validation is baked into the HCA account implementation, so the
-            // module address is fixed (no override).
-            return getENSValidator(owners.threshold ?? 1, owners.owners.map((o) => o.account.address), owners.owners.map((o) => o.expiration));
-        case 'passkey':
-            return getWebAuthnValidator(owners.threshold ?? 1, owners.accounts.map((account) => ({
-                pubKey: account.publicKey,
-                authenticatorId: account.id,
-            })), owners.module);
-        case 'multi-factor': {
-            return getMultiFactorValidator(owners.threshold ?? 1, owners.validators, owners.module);
-        }
-    }
-}
-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, expirations) {
-    // format: (uint256 threshold, Owner[] owners)
-    // where Owner is a tuple of (address addr, uint48 expiration)
-    const ownerPairs = owners.map((owner, index) => {
-        const expiration = expirations[index];
-        return {
-            addr: owner.toLowerCase(),
-            // maxUint48 is the on-chain "never expires" sentinel; it's outside the
-            // representable Date range, so an omitted expiry maps to it directly.
-            expiration: expiration !== undefined
-                ? Math.floor(expiration.getTime() / 1000)
-                : Number(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]);
-    return {
-        address: ENS_HCA_MODULE,
-        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, address) {
-    return {
-        address: 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 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_HCA_MODULE, 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, getValidator, getMockSignature, supportsEip712, ownerSetUsesEns, };

package/dist/src/modules/validators/cross-chain-permits.d.ts

@@ -1,22 +0,0 @@
-import type { CrossChainPermissionInput, CrossChainPermit } from '../../types.js';
-/**
- * Resolve a {@link CrossChainPermissionInput} into a {@link CrossChainPermit}:
- * normalise single/array legs and convert `Date` validity bounds to
- * unix-seconds. Token fields are per-chain ERC-20 addresses (v2 no longer
- * accepts symbols).
- *
- * @internal Used by `expandCrossChainPermit`; not part of the public API.
- */
-declare function resolveCrossChainPermission(input: CrossChainPermissionInput): CrossChainPermit;
-/**
- * Convert a resolved {@link CrossChainPermit} back into the
- * {@link CrossChainPermissionInput} shape accepted by
- * `SessionDefinition.crossChainPermits`.
- *
- * Useful when a permit was persisted in its resolved (unix-seconds) form and
- * has to be re-supplied as session input: converts `bigint` deadlines to
- * `Date` and maps `recipientIsAccount` to the inverse `allowRecipientNotAccount`.
- */
-declare function toCrossChainPermissionInput(permit: CrossChainPermit): CrossChainPermissionInput;
-export { resolveCrossChainPermission, toCrossChainPermissionInput };
-//# sourceMappingURL=cross-chain-permits.d.ts.map

package/dist/src/modules/validators/cross-chain-permits.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cross-chain-permits.d.ts","sourceRoot":"","sources":["../../../../modules/validators/cross-chain-permits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAkB9E;;;;;;;GAOG;AACH,iBAAS,2BAA2B,CAClC,KAAK,EAAE,yBAAyB,GAC/B,gBAAgB,CA0DlB;AAQD;;;;;;;;GAQG;AACH,iBAAS,2BAA2B,CAClC,MAAM,EAAE,gBAAgB,GACvB,yBAAyB,CAuB3B;AAED,OAAO,EAAE,2BAA2B,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/src/modules/validators/cross-chain-permits.js

@@ -1,107 +0,0 @@
-function dateToUnixSeconds(input) {
-    // Date.getTime() returns milliseconds since epoch; the on-chain policy
-    // expects unix-seconds. Integer division matches the Permit2 deadline
-    // convention.
-    return BigInt(Math.floor(input.getTime() / 1000));
-}
-// Normalise the single-object / array / omitted shapes into arrays. An
-// omitted side stays `undefined` (no restriction), mirroring how the
-// underlying Permit2 policy treats an absent token list.
-function normalizeLegs(legs) {
-    if (legs === undefined)
-        return undefined;
-    const arr = Array.isArray(legs) ? legs : [legs];
-    return arr.length ? arr : undefined;
-}
-/**
- * Resolve a {@link CrossChainPermissionInput} into a {@link CrossChainPermit}:
- * normalise single/array legs and convert `Date` validity bounds to
- * unix-seconds. Token fields are per-chain ERC-20 addresses (v2 no longer
- * accepts symbols).
- *
- * @internal Used by `expandCrossChainPermit`; not part of the public API.
- */
-function resolveCrossChainPermission(input) {
-    const fromLegs = normalizeLegs(input.from);
-    const toLegs = normalizeLegs(input.to);
-    const from = fromLegs?.map((leg) => ({
-        chain: leg.chain,
-        token: leg.token,
-        maxAmount: leg.maxAmount,
-    }));
-    const to = toLegs?.map((leg) => ({
-        chain: leg.chain,
-        token: leg.token,
-        recipient: leg.recipient,
-    }));
-    const validUntil = input.validUntil !== undefined
-        ? dateToUnixSeconds(input.validUntil)
-        : undefined;
-    const validAfter = input.validAfter !== undefined
-        ? dateToUnixSeconds(input.validAfter)
-        : undefined;
-    // Detect an obviously-broken time window early. The on-chain policy
-    // would reject any intent in this state anyway; surfacing it at build
-    // time saves a round-trip to chain.
-    if (validUntil !== undefined &&
-        validAfter !== undefined &&
-        validAfter > validUntil) {
-        throw new Error(`crossChainPermits: validAfter (${validAfter}) is greater than validUntil (${validUntil})`);
-    }
-    const fillDeadline = input.fillDeadline?.map(({ chain, min, max }) => ({
-        chain,
-        min: min !== undefined ? dateToUnixSeconds(min) : undefined,
-        max: max !== undefined ? dateToUnixSeconds(max) : undefined,
-    }));
-    return {
-        from,
-        to,
-        validUntil,
-        validAfter,
-        fillDeadline,
-        // Inverted default: callers must opt out of bridge-to-self
-        // explicitly. This stops a session key from quietly bridging to an
-        // attacker-controlled recipient.
-        recipientIsAccount: !input.allowRecipientNotAccount,
-        // Passed through verbatim. `getArbitersForSettlementLayers` expands
-        // undefined/empty to "all supported layers" at session-data build
-        // time.
-        settlementLayers: input.settlementLayers,
-    };
-}
-function unixSecondsToDate(seconds) {
-    // Inverse of dateToUnixSeconds: on-chain deadlines are unix-seconds; Date
-    // expects milliseconds.
-    return new Date(Number(seconds) * 1000);
-}
-/**
- * Convert a resolved {@link CrossChainPermit} back into the
- * {@link CrossChainPermissionInput} shape accepted by
- * `SessionDefinition.crossChainPermits`.
- *
- * Useful when a permit was persisted in its resolved (unix-seconds) form and
- * has to be re-supplied as session input: converts `bigint` deadlines to
- * `Date` and maps `recipientIsAccount` to the inverse `allowRecipientNotAccount`.
- */
-function toCrossChainPermissionInput(permit) {
-    return {
-        from: permit.from,
-        to: permit.to,
-        validUntil: permit.validUntil !== undefined
-            ? unixSecondsToDate(permit.validUntil)
-            : undefined,
-        validAfter: permit.validAfter !== undefined
-            ? unixSecondsToDate(permit.validAfter)
-            : undefined,
-        fillDeadline: permit.fillDeadline?.map(({ chain, min, max }) => ({
-            chain,
-            min: min !== undefined ? unixSecondsToDate(min) : undefined,
-            max: max !== undefined ? unixSecondsToDate(max) : undefined,
-        })),
-        allowRecipientNotAccount: permit.recipientIsAccount !== undefined
-            ? !permit.recipientIsAccount
-            : undefined,
-        settlementLayers: permit.settlementLayers,
-    };
-}
-export { resolveCrossChainPermission, toCrossChainPermissionInput };

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, };