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

package/dist/src/accounts/index.js

@@ -1,680 +0,0 @@
-import { concat, createPublicClient, encodeAbiParameters, encodeFunctionData, hashTypedData, isAddressEqual, size, zeroAddress, } from 'viem';
-import { sendTransactionInternal, sendUserOperationInternal, waitForExecution, } from '../execution/index.js';
-import { getIntentExecutor, getSetup } from '../modules/index.js';
-import { MODULE_TYPE_ID_VALIDATOR } from '../modules/common.js';
-import { getValidators as getValidatorsInternal, isValidatorInitialized, } from '../modules/read.js';
-import { getOwnerValidator } from '../modules/validators/index.js';
-import { AccountConfigurationNotSupportedError, AccountError, DefaultValidatorAlreadyInitializedError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, EoaAccountMustHaveAccountError, EoaSigningMethodNotConfiguredError, EoaSigningNotSupportedError, FactoryArgsNotAvailableError, isAccountError, ModuleInstallationNotSupportedError, OwnersFieldRequiredError, SigningNotSupportedForAccountError, WalletClientNoConnectedAccountError, } from './error.js';
-import { getAddress as getHcaAddress, getDeployArgs as getHcaDeployArgs, getEip712Domain as getHcaEip712Domain, getSmartAccount as getHcaSmartAccount, packSignature as packHcaSignature, } from './hca.js';
-import { getAddress as getKernelAddress, getDeployArgs as getKernelDeployArgs, getEip712Domain as getKernelEip712Domain, getInstallData as getKernelInstallData, getSmartAccount as getKernelSmartAccount, packSignature as packKernelSignature, wrapMessageHash as wrapKernelMessageHash, } from './kernel.js';
-import { getAddress as getNexusAddress, getDefaultValidatorAddress as getNexusDefaultValidatorAddress, getDefaultValidatorInitData as getNexusDefaultValidatorInitData, getDeployArgs as getNexusDeployArgs, getEip712Domain as getNexusEip712Domain, getEip7702InitCall as getNexusEip7702InitCall, getInstallData as getNexusInstallData, getSmartAccount as getNexusSmartAccount, isDefaultValidatorConfigured as isNexusDefaultValidatorConfigured, packSignature as packNexusSignature, signEip7702InitData as signNexusEip7702InitData, } from './nexus.js';
-import { getAddress as getSafeAddress, getDeployArgs as getSafeDeployArgs, getEip712Domain as getSafeEip712Domain, getInstallData as getSafeInstallData, getSmartAccount as getSafeSmartAccount, getV0DeployArgs as getSafeV0DeployArgs, packSignature as packSafeSignature, } from './safe.js';
-import { convertOwnerSetToSignerSet } from './signing/common.js';
-import { sign as signMessage } from './signing/message.js';
-import { sign as signTypedData } from './signing/typedData.js';
-import { getAddress as getStartaleAddress, getDeployArgs as getStartaleDeployArgs, getEip712Domain as getStartaleEip712Domain, getInstallData as getStartaleInstallData, getSmartAccount as getStartaleSmartAccount, packSignature as packStartaleSignature, K1_DEFAULT_VALIDATOR_ADDRESS as STARTALE_K1_VALIDATOR_ADDRESS, } from './startale.js';
-import { createTransport, getBundlerClient, } from './utils.js';
-function getDeployArgs(config) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return getSafeDeployArgs(config);
-        }
-        case 'nexus': {
-            return getNexusDeployArgs(config);
-        }
-        case 'kernel': {
-            return getKernelDeployArgs(config);
-        }
-        case 'startale': {
-            return getStartaleDeployArgs(config);
-        }
-        case 'hca': {
-            return getHcaDeployArgs(config);
-        }
-        case 'eoa': {
-            throw new Error('EOA accounts do not have deploy args');
-        }
-    }
-}
-function getV0DeployArgs(config) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return getSafeV0DeployArgs(config);
-        }
-        default: {
-            throw new Error(`Unsupported account type: ${account.type}`);
-        }
-    }
-}
-function getInitCode(config) {
-    if (is7702(config)) {
-        return undefined;
-    }
-    else if (config.account?.type === 'eoa') {
-        return undefined;
-    }
-    else if (config.initData) {
-        return config.initData;
-    }
-    else {
-        const deployArgs = getDeployArgs(config);
-        if (!deployArgs) {
-            throw new FactoryArgsNotAvailableError();
-        }
-        const { factory, factoryData } = deployArgs;
-        return {
-            factory,
-            factoryData,
-        };
-    }
-}
-function getV0InitCode(config) {
-    if (is7702(config)) {
-        return undefined;
-    }
-    else if (config.account?.type === 'eoa') {
-        return undefined;
-    }
-    else if (config.initData) {
-        return config.initData;
-    }
-    else {
-        const deployArgs = getV0DeployArgs(config);
-        if (!deployArgs) {
-            throw new FactoryArgsNotAvailableError();
-        }
-        const { factory, factoryData } = deployArgs;
-        return {
-            factory,
-            factoryData,
-        };
-    }
-}
-async function signEip7702InitData(config) {
-    const eoa = config.eoa;
-    if (!eoa) {
-        throw new Eip7702AccountMustHaveEoaError();
-    }
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'nexus': {
-            return await signNexusEip7702InitData(config, eoa);
-        }
-        case 'eoa': {
-            throw new Eip7702NotSupportedForAccountError(account.type);
-        }
-        case 'safe':
-        case 'kernel':
-        case 'startale':
-        case 'hca': {
-            throw new Eip7702NotSupportedForAccountError(account.type);
-        }
-        default: {
-            throw new Eip7702NotSupportedForAccountError(account.type);
-        }
-    }
-}
-function getEip7702InitCall(config, signature) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'nexus': {
-            return getNexusEip7702InitCall(config, signature);
-        }
-        case 'safe':
-        case 'kernel':
-        case 'startale':
-        case 'hca': {
-            throw new Eip7702NotSupportedForAccountError(account.type);
-        }
-        default: {
-            throw new Eip7702NotSupportedForAccountError(account.type);
-        }
-    }
-}
-function getEip712Domain(config, chain) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'nexus': {
-            return getNexusEip712Domain(config, chain);
-        }
-        case 'safe': {
-            return getSafeEip712Domain(config, chain);
-        }
-        case 'kernel': {
-            return getKernelEip712Domain(config, chain);
-        }
-        case 'startale': {
-            return getStartaleEip712Domain(config, chain);
-        }
-        case 'hca': {
-            return getHcaEip712Domain(config, chain);
-        }
-        case 'eoa': {
-            throw new Eip712DomainNotAvailableError('EOA accounts do not have an EIP-712 domain');
-        }
-        default: {
-            throw new Eip712DomainNotAvailableError(`Account type ${account.type} not yet supported`);
-        }
-    }
-}
-function getModuleInstallationCalls(config, module) {
-    const address = getAddress(config);
-    function getInstallData() {
-        const account = getAccountProvider(config);
-        switch (account.type) {
-            case 'safe': {
-                return [getSafeInstallData(module)];
-            }
-            case 'nexus': {
-                return [getNexusInstallData(module)];
-            }
-            case 'kernel': {
-                return getKernelInstallData(module);
-            }
-            case 'startale': {
-                return [getStartaleInstallData(module)];
-            }
-            case 'hca': {
-                throw new ModuleInstallationNotSupportedError(account.type);
-            }
-            case 'eoa': {
-                throw new ModuleInstallationNotSupportedError(account.type);
-            }
-        }
-    }
-    const installData = getInstallData();
-    return installData.map((data) => ({
-        to: address,
-        value: 0n,
-        data,
-    }));
-}
-// Like `getModuleInstallationCalls`, but aware of the Nexus default validator.
-// On Nexus the OwnableValidator is the hardwired default validator: it can't be
-// added via `installModule` (reverts `DefaultValidatorAlreadyInstalled`), and
-// passkey-bootstrapped accounts never initialize it, so `addOwner` reverts with
-// `NotInitialized`. For that case we initialize it directly via `onInstall`.
-async function getValidatorInstallationCalls(config, chain, module) {
-    const account = getAccountProvider(config);
-    if (account.type === 'nexus') {
-        const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-        if (module.address.toLowerCase() === defaultValidatorAddress.toLowerCase()) {
-            // Treat the validator as initialized if the account's deployment will
-            // initialize it (config check, covers not-yet-deployed accounts) or if
-            // it is already initialized on-chain (covers accounts where ECDSA was
-            // enabled separately after deployment).
-            const initialized = isNexusDefaultValidatorConfigured(config) ||
-                (await isValidatorInitialized(getAddress(config), chain, defaultValidatorAddress, config.provider));
-            if (initialized) {
-                throw new DefaultValidatorAlreadyInitializedError();
-            }
-            return [
-                {
-                    to: defaultValidatorAddress,
-                    value: 0n,
-                    data: getNexusDefaultValidatorInitData(module),
-                },
-            ];
-        }
-    }
-    return getModuleInstallationCalls(config, module);
-}
-// SentinelList head pointer used by ERC-7579 module managers (Nexus, Safe7579,
-// Startale). Validator/executor uninstall on these accounts decodes the
-// `deInitData` slot as `(address prev, bytes moduleDeInit)`, where `prev`
-// identifies the preceding linked-list entry to repair on removal.
-const SENTINEL_LIST_HEAD = '0x0000000000000000000000000000000000000001';
-async function getModuleUninstallationCalls(config, chain, module) {
-    const address = getAddress(config);
-    const onChainDeInitData = await resolveOnChainDeInitData(config, chain, address, module);
-    const data = encodeFunctionData({
-        abi: [
-            {
-                type: 'function',
-                name: 'uninstallModule',
-                inputs: [
-                    {
-                        type: 'uint256',
-                        name: 'moduleTypeId',
-                    },
-                    {
-                        type: 'address',
-                        name: 'module',
-                    },
-                    {
-                        type: 'bytes',
-                        name: 'deInitData',
-                    },
-                ],
-                outputs: [],
-                stateMutability: 'nonpayable',
-            },
-        ],
-        functionName: 'uninstallModule',
-        args: [module.type, module.address, onChainDeInitData],
-    });
-    return [{ to: address, data, value: 0n }];
-}
-/**
- * Build the value the account expects in `uninstallModule`'s third argument.
- *
- * `Module.deInitData` carries module-level bytes (mirroring `Module.initData`,
- * what the module's `onUninstall` sees). ERC-7579 accounts that store
- * validators / executors in a SentinelList — Nexus, Safe7579, Startale —
- * require an account-level wrapper `abi.encode(prev, moduleDeInit)` so they
- * can pop the entry from the linked list. Kernel uses different storage and
- * treats this slot as raw module bytes, so we pass `module.deInitData` through
- * unchanged.
- *
- * Scope: validator type only — there are no public actions to disable
- * executor modules today.
- */
-async function resolveOnChainDeInitData(config, chain, account, module) {
-    if (module.type !== MODULE_TYPE_ID_VALIDATOR) {
-        return module.deInitData;
-    }
-    const accountType = getAccountProvider(config).type;
-    if (accountType !== 'nexus' &&
-        accountType !== 'safe' &&
-        accountType !== 'startale') {
-        return module.deInitData;
-    }
-    const validators = await getValidatorsInternal(accountType, account, chain, config.provider);
-    const targetLower = module.address.toLowerCase();
-    const index = validators.findIndex((v) => v.toLowerCase() === targetLower);
-    if (index === -1) {
-        // Not installed; pass through unchanged. The account's `uninstallModule`
-        // will surface a `ModuleNotInstalled` revert with the original module
-        // address, which is more useful than a silent abi.decode mismatch.
-        return module.deInitData;
-    }
-    const prev = index === 0 ? SENTINEL_LIST_HEAD : validators[index - 1];
-    return encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [prev, module.deInitData]);
-}
-function getAddress(config) {
-    if (is7702(config)) {
-        if (!config.eoa) {
-            throw new Eip7702AccountMustHaveEoaError();
-        }
-        return config.eoa.address;
-    }
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return getSafeAddress(config);
-        }
-        case 'nexus': {
-            return getNexusAddress(config);
-        }
-        case 'kernel': {
-            return getKernelAddress(config);
-        }
-        case 'startale': {
-            return getStartaleAddress(config);
-        }
-        case 'hca': {
-            return getHcaAddress(config);
-        }
-        case 'eoa': {
-            if (!config.eoa) {
-                throw new AccountError({
-                    message: 'EOA account must have an EOA configured',
-                });
-            }
-            return config.eoa.address;
-        }
-    }
-}
-function checkAddress(config) {
-    const initData = config.initData;
-    if (!initData) {
-        return true;
-    }
-    if (!('factory' in initData)) {
-        return true;
-    }
-    return initData.address.toLowerCase() === getAddress(config).toLowerCase();
-}
-async function packAccountSignature(config, signature, validator, transformSignature = (signature) => signature) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return packSafeSignature(signature, validator, transformSignature);
-        }
-        case 'nexus': {
-            const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-            return packNexusSignature(signature, validator, transformSignature, defaultValidatorAddress);
-        }
-        case 'kernel': {
-            return packKernelSignature(signature, validator, transformSignature);
-        }
-        case 'startale': {
-            return packStartaleSignature(signature, validator, transformSignature);
-        }
-        case 'hca': {
-            return packHcaSignature(signature, validator, transformSignature);
-        }
-        default: {
-            throw new Error(`Unsupported account type: ${account.type}`);
-        }
-    }
-}
-async function getEip1271Signature(config, signers, chain, validator, hash, transformSignature = (signature) => signature) {
-    if (config.account?.type === 'eoa') {
-        throw new EoaSigningNotSupportedError('packed signatures');
-    }
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const account = getAccountProvider(config);
-    const address = getAddress(config);
-    const signedHash = account.type === 'kernel' ? wrapKernelMessageHash(hash, address) : hash;
-    const signature = await signMessage(signers, chain, address, signedHash, false);
-    return packAccountSignature(config, signature, validator, transformSignature);
-}
-// Signs and packs a signature to be used by the emissary validator
-async function getEmissarySignature(config, signers, chain, hash, transformSignature = (signature) => signature) {
-    if (config.account?.type === 'eoa') {
-        throw new EoaSigningNotSupportedError('packed signatures');
-    }
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const address = getAddress(config);
-    const signFn = (hash) => signMessage(signers, chain, address, hash, false);
-    const signature = await signFn(hash);
-    return transformSignature(signature);
-}
-// Signs and packs a signature to be EIP-1271 compatible
-async function getTypedDataPackedSignature(config, signers, chain, validator, parameters, transformSignature = (signature) => signature) {
-    if (config.account?.type === 'eoa') {
-        throw new EoaSigningNotSupportedError('packed signatures');
-    }
-    const address = getAddress(config);
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const account = getAccountProvider(config);
-    const signature = account.type === 'kernel'
-        ? await signMessage(signers, chain, address, wrapKernelMessageHash(hashTypedData(parameters), address), false)
-        : await signTypedData(signers, chain, address, parameters);
-    return packAccountSignature(config, signature, validator, transformSignature);
-}
-async function getOwnerEcdsaSignature(config, chain, parameters, owner, module, validatorSupportsEip712) {
-    if (config.account?.type === 'eoa') {
-        throw new EoaSigningNotSupportedError('packed signatures');
-    }
-    const address = getAddress(config);
-    const signers = {
-        type: 'owner',
-        kind: 'ecdsa',
-        accounts: [owner],
-        module,
-    };
-    const accountProvider = getAccountProvider(config);
-    if (accountProvider.type === 'kernel') {
-        return signMessage(signers, chain, address, wrapKernelMessageHash(hashTypedData(parameters), address), false);
-    }
-    if (!validatorSupportsEip712) {
-        return signMessage(signers, chain, address, hashTypedData(parameters), false);
-    }
-    return signTypedData(signers, chain, address, parameters);
-}
-async function getOwnerPasskeySignature(config, parameters, owner, validatorSupportsEip712) {
-    if (config.account?.type === 'eoa') {
-        throw new EoaSigningNotSupportedError('packed signatures');
-    }
-    const address = getAddress(config);
-    const accountProvider = getAccountProvider(config);
-    if (accountProvider.type === 'kernel') {
-        const { webauthn, signature } = await owner.sign({
-            hash: wrapKernelMessageHash(hashTypedData(parameters), address),
-        });
-        return { webauthn, signature };
-    }
-    if (!validatorSupportsEip712) {
-        const { webauthn, signature } = await owner.sign({
-            hash: hashTypedData(parameters),
-        });
-        return { webauthn, signature };
-    }
-    const { webauthn, signature } = await owner.signTypedData(parameters);
-    return { webauthn, signature };
-}
-async function isDeployed(config, chain) {
-    const account = getAccountProvider(config);
-    if (account.type === 'eoa') {
-        return true;
-    }
-    const publicClient = createPublicClient({
-        chain: chain,
-        transport: createTransport(chain, config.provider),
-    });
-    const address = getAddress(config);
-    const code = await publicClient.getCode({
-        address,
-    });
-    if (!code) {
-        return false;
-    }
-    return size(code) > 0;
-}
-async function deploy(config, chain, params) {
-    const deployed = await isDeployed(config, chain);
-    if (deployed) {
-        return false;
-    }
-    const account = getAccountProvider(config);
-    if (account.type === 'eoa') {
-        return false;
-    }
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        throw new FactoryArgsNotAvailableError();
-    }
-    const intentExecutorInstalled = 'intentExecutorInstalled' in deployArgs
-        ? deployArgs.intentExecutorInstalled
-        : false;
-    // Use bundler directly when:
-    // (account has initData and intent executor is not installed) || (custom bundler is configured)
-    const useCustomBundler = config.bundler?.type === 'custom';
-    const asUserOp = (config.initData && !intentExecutorInstalled) || useCustomBundler;
-    if (asUserOp) {
-        await deployWithBundler(chain, config);
-    }
-    else {
-        await deployWithIntent(chain, config, params?.sponsored ?? false, params?.eip7702InitSignature);
-    }
-    return true;
-}
-// Installs the missing modules
-// Checks if the provided modules are already installed
-// Useful for existing (already deployed) accounts
-async function setup(config, chain) {
-    const account = getAccountProvider(config);
-    // HCA accounts are locked and cannot install modules, so there is nothing to set up.
-    if (account.type === 'eoa' || account.type === 'hca') {
-        return false;
-    }
-    const modules = getSetup(config);
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, config.provider),
-    });
-    const address = getAddress(config);
-    const allModules = [
-        ...modules.validators,
-        ...modules.executors,
-        ...modules.fallbacks,
-        ...modules.hooks,
-    ].filter(
-    // Startale's K1 validator is the account's built-in default validator, set
-    // at deployment — it is never a regular 7579 module, so isModuleInstalled
-    // reports false and trying to install it reverts. Skip it.
-    (module) => !(account.type === 'startale' &&
-        isAddressEqual(module.address, STARTALE_K1_VALIDATOR_ADDRESS)));
-    // Check if the modules are already installed
-    const installedResults = await publicClient.multicall({
-        contracts: allModules.map((module) => ({
-            address: address,
-            abi: [
-                {
-                    type: 'function',
-                    name: 'isModuleInstalled',
-                    inputs: [
-                        { type: 'uint256', name: 'moduleTypeId' },
-                        { type: 'address', name: 'module' },
-                        { type: 'bytes', name: 'additionalContext' },
-                    ],
-                    outputs: [{ type: 'bool', name: 'isInstalled' }],
-                    stateMutability: 'view',
-                },
-            ],
-            functionName: 'isModuleInstalled',
-            args: [module.type, module.address, module.additionalContext],
-        })),
-    });
-    const isInstalled = installedResults.map((result) => result.result);
-    const modulesToInstall = allModules.filter((_, index) => !isInstalled[index]);
-    if (modulesToInstall.length === 0) {
-        // Nothing to install
-        return false;
-    }
-    const calls = [];
-    for (const module of modulesToInstall) {
-        calls.push(...getModuleInstallationCalls(config, module));
-    }
-    // Select the transaction infra layer based on the intent executor status
-    const intentExecutor = getIntentExecutor(config);
-    const hasIntentExecutor = modulesToInstall.every((module) => module.address !== intentExecutor.address);
-    let result;
-    if (hasIntentExecutor) {
-        result = await sendTransactionInternal(config, [chain], chain, {
-            callInputs: calls,
-        });
-    }
-    else {
-        result = await sendUserOperationInternal(config, chain, calls);
-    }
-    await waitForExecution(config, result);
-    return true;
-}
-async function deployWithIntent(chain, config, sponsored, eip7702InitSignature) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, config.provider),
-    });
-    const address = getAddress(config);
-    const code = await publicClient.getCode({ address });
-    if (code) {
-        // Already deployed
-        return;
-    }
-    // For EIP-7702 accounts, auto-sign if no signature was provided
-    let initSignature = eip7702InitSignature;
-    if (!initSignature && is7702(config)) {
-        initSignature = await signEip7702InitData(config);
-    }
-    const result = await sendTransactionInternal(config, [chain], chain, {
-        callInputs: [],
-        sponsored,
-        eip7702InitSignature: initSignature,
-    });
-    await waitForExecution(config, result);
-}
-async function deployWithBundler(chain, config) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: createTransport(chain, config.provider),
-    });
-    const bundlerClient = getBundlerClient(config, publicClient);
-    const smartAccount = await getSmartAccount(config, publicClient, chain);
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        throw new FactoryArgsNotAvailableError();
-    }
-    const { factory, factoryData } = deployArgs;
-    const opHash = await bundlerClient.sendUserOperation({
-        account: smartAccount,
-        factory,
-        factoryData,
-        calls: [
-            {
-                to: zeroAddress,
-                value: 0n,
-                data: '0x',
-            },
-        ],
-    });
-    await bundlerClient.waitForUserOperationReceipt({
-        hash: opHash,
-    });
-}
-async function toErc6492Signature(config, signature, chain) {
-    const deployed = await isDeployed(config, chain);
-    if (deployed) {
-        return signature;
-    }
-    // Account is not deployed, use ERC-6492
-    const initCode = getInitCode(config);
-    if (!initCode) {
-        throw new FactoryArgsNotAvailableError();
-    }
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        throw new FactoryArgsNotAvailableError();
-    }
-    const { factory, factoryData } = deployArgs;
-    const magicBytes = '0x6492649264926492649264926492649264926492649264926492649264926492';
-    return concat([
-        encodeAbiParameters([
-            { name: 'create2Factory', type: 'address' },
-            { name: 'factoryCalldata', type: 'bytes' },
-            { name: 'originalERC1271Signature', type: 'bytes' },
-        ], [factory, factoryData, signature]),
-        magicBytes,
-    ]);
-}
-async function getSmartAccount(config, client, chain) {
-    // EOA accounts don't need smart account functionality
-    if (config.account?.type === 'eoa') {
-        throw new Error('getSmartAccount is not supported for EOA accounts');
-    }
-    if (!config.owners) {
-        throw new OwnersFieldRequiredError();
-    }
-    const account = getAccountProvider(config);
-    const address = getAddress(config);
-    const ownerValidator = getOwnerValidator(config);
-    const signers = convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => signMessage(signers, chain, address, hash, true);
-    switch (account.type) {
-        case 'safe': {
-            return getSafeSmartAccount(client, address, config.owners, ownerValidator.address, signFn);
-        }
-        case 'nexus': {
-            const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-            return getNexusSmartAccount(client, address, config.owners, ownerValidator.address, signFn, defaultValidatorAddress);
-        }
-        case 'kernel': {
-            return getKernelSmartAccount(client, address, config.owners, ownerValidator.address, signFn);
-        }
-        case 'startale': {
-            return getStartaleSmartAccount(client, address, config.owners, ownerValidator.address, signFn);
-        }
-        case 'hca': {
-            return getHcaSmartAccount(client, address, config.owners, ownerValidator.address, signFn);
-        }
-    }
-}
-function is7702(config) {
-    const account = getAccountProvider(config);
-    return account.type !== 'eoa' && config.eoa !== undefined;
-}
-function getAccountProvider(config) {
-    if (config.account) {
-        return config.account;
-    }
-    return {
-        type: 'nexus',
-    };
-}
-export { getEip712Domain, getModuleInstallationCalls, getValidatorInstallationCalls, getModuleUninstallationCalls, getAddress, checkAddress, getAccountProvider, getInitCode, getV0InitCode, signEip7702InitData, getEip7702InitCall, is7702, isDeployed, deploy, setup, toErc6492Signature, getSmartAccount, getEip1271Signature, getEmissarySignature, getOwnerEcdsaSignature, getOwnerPasskeySignature, getTypedDataPackedSignature, packAccountSignature, 
-// Errors
-isAccountError, AccountError, AccountConfigurationNotSupportedError, DefaultValidatorAlreadyInitializedError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, EoaAccountMustHaveAccountError, EoaSigningMethodNotConfiguredError, EoaSigningNotSupportedError, FactoryArgsNotAvailableError, ModuleInstallationNotSupportedError, OwnersFieldRequiredError, SigningNotSupportedForAccountError, WalletClientNoConnectedAccountError, };

package/dist/src/accounts/json-rpc/index.d.ts

@@ -1,5 +0,0 @@
-import { type Chain, type Transport } from 'viem';
-import type { ProviderConfig } from '../../types.js';
-declare function createTransport(chain: Chain, provider?: ProviderConfig): Transport;
-export { createTransport };
-//# sourceMappingURL=index.d.ts.map

package/dist/src/accounts/json-rpc/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../accounts/json-rpc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAQ,KAAK,SAAS,EAAE,MAAM,MAAM,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAGjD,iBAAS,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAS3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}