@rhinestone/sdk 0.0.0-dev-20260204114155

package/dist/src/accounts/index.js

@@ -0,0 +1,643 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletClientNoConnectedAccountError = exports.SmartSessionsNotEnabledError = exports.SigningNotSupportedForAccountError = exports.OwnersFieldRequiredError = exports.ModuleInstallationNotSupportedError = exports.FactoryArgsNotAvailableError = exports.ExistingEip7702AccountsNotSupportedError = exports.EoaSigningNotSupportedError = exports.EoaSigningMethodNotConfiguredError = exports.EoaAccountMustHaveAccountError = exports.Eip7702NotSupportedForAccountError = exports.Eip7702AccountMustHaveEoaError = exports.Eip712DomainNotAvailableError = exports.AccountConfigurationNotSupportedError = exports.AccountError = exports.isAccountError = void 0;
+exports.getEip712Domain = getEip712Domain;
+exports.getModuleInstallationCalls = getModuleInstallationCalls;
+exports.getModuleUninstallationCalls = getModuleUninstallationCalls;
+exports.getAddress = getAddress;
+exports.checkAddress = checkAddress;
+exports.getAccountProvider = getAccountProvider;
+exports.getInitCode = getInitCode;
+exports.getV0InitCode = getV0InitCode;
+exports.signEip7702InitData = signEip7702InitData;
+exports.getEip7702InitCall = getEip7702InitCall;
+exports.is7702 = is7702;
+exports.isDeployed = isDeployed;
+exports.deploy = deploy;
+exports.setup = setup;
+exports.toErc6492Signature = toErc6492Signature;
+exports.getSmartAccount = getSmartAccount;
+exports.getGuardianSmartAccount = getGuardianSmartAccount;
+exports.getEip1271Signature = getEip1271Signature;
+exports.getEmissarySignature = getEmissarySignature;
+exports.getTypedDataPackedSignature = getTypedDataPackedSignature;
+const viem_1 = require("viem");
+const execution_1 = require("../execution");
+const modules_1 = require("../modules");
+const validators_1 = require("../modules/validators");
+const core_1 = require("../modules/validators/core");
+const error_1 = require("./error");
+Object.defineProperty(exports, "AccountConfigurationNotSupportedError", { enumerable: true, get: function () { return error_1.AccountConfigurationNotSupportedError; } });
+Object.defineProperty(exports, "AccountError", { enumerable: true, get: function () { return error_1.AccountError; } });
+Object.defineProperty(exports, "Eip712DomainNotAvailableError", { enumerable: true, get: function () { return error_1.Eip712DomainNotAvailableError; } });
+Object.defineProperty(exports, "Eip7702AccountMustHaveEoaError", { enumerable: true, get: function () { return error_1.Eip7702AccountMustHaveEoaError; } });
+Object.defineProperty(exports, "Eip7702NotSupportedForAccountError", { enumerable: true, get: function () { return error_1.Eip7702NotSupportedForAccountError; } });
+Object.defineProperty(exports, "EoaAccountMustHaveAccountError", { enumerable: true, get: function () { return error_1.EoaAccountMustHaveAccountError; } });
+Object.defineProperty(exports, "EoaSigningMethodNotConfiguredError", { enumerable: true, get: function () { return error_1.EoaSigningMethodNotConfiguredError; } });
+Object.defineProperty(exports, "EoaSigningNotSupportedError", { enumerable: true, get: function () { return error_1.EoaSigningNotSupportedError; } });
+Object.defineProperty(exports, "ExistingEip7702AccountsNotSupportedError", { enumerable: true, get: function () { return error_1.ExistingEip7702AccountsNotSupportedError; } });
+Object.defineProperty(exports, "FactoryArgsNotAvailableError", { enumerable: true, get: function () { return error_1.FactoryArgsNotAvailableError; } });
+Object.defineProperty(exports, "isAccountError", { enumerable: true, get: function () { return error_1.isAccountError; } });
+Object.defineProperty(exports, "ModuleInstallationNotSupportedError", { enumerable: true, get: function () { return error_1.ModuleInstallationNotSupportedError; } });
+Object.defineProperty(exports, "OwnersFieldRequiredError", { enumerable: true, get: function () { return error_1.OwnersFieldRequiredError; } });
+Object.defineProperty(exports, "SigningNotSupportedForAccountError", { enumerable: true, get: function () { return error_1.SigningNotSupportedForAccountError; } });
+Object.defineProperty(exports, "SmartSessionsNotEnabledError", { enumerable: true, get: function () { return error_1.SmartSessionsNotEnabledError; } });
+Object.defineProperty(exports, "WalletClientNoConnectedAccountError", { enumerable: true, get: function () { return error_1.WalletClientNoConnectedAccountError; } });
+const kernel_1 = require("./kernel");
+const nexus_1 = require("./nexus");
+const passport_1 = require("./passport");
+const safe_1 = require("./safe");
+const common_1 = require("./signing/common");
+const message_1 = require("./signing/message");
+const typedData_1 = require("./signing/typedData");
+const startale_1 = require("./startale");
+const utils_1 = require("./utils");
+function getDeployArgs(config) {
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getDeployArgs)(config);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getDeployArgs)(config);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getDeployArgs)(config);
+        }
+        case 'startale': {
+            return (0, startale_1.getDeployArgs)(config);
+        }
+        case 'passport': {
+            // Mocked data; will be overridden by the actual deploy args
+            return {
+                factory: viem_1.zeroAddress,
+                factoryData: viem_1.zeroHash,
+                salt: viem_1.zeroHash,
+                implementation: viem_1.zeroAddress,
+                initializationCallData: '0x',
+                initData: '0x',
+            };
+        }
+        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 (0, safe_1.getV0DeployArgs)(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 error_1.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 error_1.FactoryArgsNotAvailableError();
+        }
+        const { factory, factoryData } = deployArgs;
+        return {
+            factory,
+            factoryData,
+        };
+    }
+}
+async function signEip7702InitData(config) {
+    const eoa = config.eoa;
+    if (!eoa) {
+        throw new error_1.Eip7702AccountMustHaveEoaError();
+    }
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'nexus': {
+            return await (0, nexus_1.signEip7702InitData)(config, eoa);
+        }
+        case 'eoa': {
+            throw new error_1.Eip7702NotSupportedForAccountError(account.type);
+        }
+        case 'safe':
+        case 'kernel':
+        case 'startale': {
+            throw new error_1.Eip7702NotSupportedForAccountError(account.type);
+        }
+        default: {
+            throw new error_1.Eip7702NotSupportedForAccountError(account.type);
+        }
+    }
+}
+function getEip7702InitCall(config, signature) {
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'nexus': {
+            return (0, nexus_1.getEip7702InitCall)(config, signature);
+        }
+        case 'safe':
+        case 'kernel':
+        case 'startale': {
+            throw new error_1.Eip7702NotSupportedForAccountError(account.type);
+        }
+        default: {
+            throw new error_1.Eip7702NotSupportedForAccountError(account.type);
+        }
+    }
+}
+function getEip712Domain(config, chain) {
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'nexus': {
+            return (0, nexus_1.getEip712Domain)(config, chain);
+        }
+        case 'safe': {
+            return (0, safe_1.getEip712Domain)(config, chain);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getEip712Domain)(config, chain);
+        }
+        case 'startale': {
+            return (0, startale_1.getEip712Domain)(config, chain);
+        }
+        case 'eoa': {
+            throw new error_1.Eip712DomainNotAvailableError('EOA accounts do not have an EIP-712 domain');
+        }
+        default: {
+            throw new error_1.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 [(0, safe_1.getInstallData)(module)];
+            }
+            case 'nexus': {
+                return [(0, nexus_1.getInstallData)(module)];
+            }
+            case 'kernel': {
+                return (0, kernel_1.getInstallData)(module);
+            }
+            case 'startale': {
+                return [(0, startale_1.getInstallData)(module)];
+            }
+            case 'passport': {
+                return [(0, passport_1.getInstallData)(module)];
+            }
+            case 'eoa': {
+                throw new error_1.ModuleInstallationNotSupportedError(account.type);
+            }
+        }
+    }
+    const installData = getInstallData();
+    return installData.map((data) => ({
+        to: address,
+        value: 0n,
+        data,
+    }));
+}
+function getModuleUninstallationCalls(config, module) {
+    const address = getAddress(config);
+    const data = (0, viem_1.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, module.deInitData],
+    });
+    return [{ to: address, data, value: 0n }];
+}
+function getAddress(config) {
+    if (is7702(config)) {
+        if (!config.eoa) {
+            throw new error_1.Eip7702AccountMustHaveEoaError();
+        }
+        return config.eoa.address;
+    }
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getAddress)(config);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getAddress)(config);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getAddress)(config);
+        }
+        case 'startale': {
+            return (0, startale_1.getAddress)(config);
+        }
+        case 'passport': {
+            return (0, passport_1.getAddress)(config);
+        }
+        case 'eoa': {
+            if (!config.eoa) {
+                throw new error_1.AccountError({
+                    message: 'EOA account must have an EOA configured',
+                });
+            }
+            return config.eoa.address;
+        }
+    }
+}
+function checkAddress(config) {
+    if (!config.initData) {
+        return true;
+    }
+    return (config.initData.address.toLowerCase() === getAddress(config).toLowerCase());
+}
+// Signs and packs a signature to be EIP-1271 compatible
+async function getEip1271Signature(config, signers, chain, validator, hash, transformSignature = (signature) => signature) {
+    if (config.account?.type === 'eoa') {
+        throw new error_1.EoaSigningNotSupportedError('packed signatures');
+    }
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash, false);
+    const account = getAccountProvider(config);
+    const address = getAddress(config);
+    switch (account.type) {
+        case 'safe': {
+            const signature = await signFn(hash);
+            return (0, safe_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'nexus': {
+            const signature = await signFn(hash);
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature, defaultValidatorAddress);
+        }
+        case 'passport': {
+            const signature = await signFn(hash);
+            return (0, passport_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'kernel': {
+            const signature = await signFn((0, kernel_1.wrapMessageHash)(hash, address));
+            return (0, kernel_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'startale': {
+            const signature = await signFn(hash);
+            return (0, startale_1.packSignature)(signature, validator, transformSignature);
+        }
+        default: {
+            throw new Error(`Unsupported account type: ${account.type}`);
+        }
+    }
+}
+// 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 error_1.EoaSigningNotSupportedError('packed signatures');
+    }
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const address = getAddress(config);
+    const signFn = (hash) => (0, message_1.sign)(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 error_1.EoaSigningNotSupportedError('packed signatures');
+    }
+    const address = getAddress(config);
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (parameters) => (0, typedData_1.sign)(signers, chain, address, parameters);
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            const signature = await signFn(parameters);
+            return (0, safe_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'nexus': {
+            const signature = await signFn(parameters);
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature, defaultValidatorAddress);
+        }
+        case 'passport': {
+            const signature = await signFn(parameters);
+            return (0, passport_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'kernel': {
+            const address = getAddress(config);
+            const signMessageFn = (hash) => (0, message_1.sign)(signers, chain, address, hash, false);
+            const signature = await signMessageFn((0, kernel_1.wrapMessageHash)((0, viem_1.hashTypedData)(parameters), address));
+            return (0, kernel_1.packSignature)(signature, validator, transformSignature);
+        }
+        case 'startale': {
+            const signature = await signFn(parameters);
+            return (0, startale_1.packSignature)(signature, validator, transformSignature);
+        }
+        default: {
+            throw new Error(`Unsupported account type: ${account.type}`);
+        }
+    }
+}
+async function isDeployed(config, chain) {
+    const account = getAccountProvider(config);
+    if (account.type === 'eoa') {
+        return true;
+    }
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const address = getAddress(config);
+    const code = await publicClient.getCode({
+        address,
+    });
+    if (!code) {
+        return false;
+    }
+    return (0, viem_1.size)(code) > 0;
+}
+async function deploy(config, chain, params) {
+    const account = getAccountProvider(config);
+    const deployArgs = getDeployArgs(config);
+    if (!deployArgs) {
+        throw new error_1.FactoryArgsNotAvailableError();
+    }
+    if (account.type === 'eoa') {
+        return false;
+    }
+    const deployed = await isDeployed(config, chain);
+    if (deployed) {
+        return false;
+    }
+    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);
+    }
+    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);
+    if (account.type === 'eoa') {
+        return false;
+    }
+    const modules = (0, modules_1.getSetup)(config);
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const address = getAddress(config);
+    const allModules = [
+        ...modules.validators,
+        ...modules.executors,
+        ...modules.fallbacks,
+        ...modules.hooks,
+    ];
+    // 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 = (0, modules_1.getIntentExecutor)(config);
+    const hasIntentExecutor = modulesToInstall.every((module) => module.address !== intentExecutor.address);
+    let result;
+    if (hasIntentExecutor) {
+        result = await (0, execution_1.sendTransactionInternal)(config, [chain], chain, {
+            callInputs: calls,
+        });
+    }
+    else {
+        result = await (0, execution_1.sendUserOperationInternal)(config, chain, calls);
+    }
+    await (0, execution_1.waitForExecution)(config, result, true);
+    return true;
+}
+async function deployWithIntent(chain, config, sponsored) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const address = getAddress(config);
+    const code = await publicClient.getCode({ address });
+    if (code) {
+        // Already deployed
+        return;
+    }
+    const result = await (0, execution_1.sendTransaction)(config, {
+        sourceChains: [chain],
+        targetChain: chain,
+        calls: [],
+        sponsored,
+    });
+    await (0, execution_1.waitForExecution)(config, result, true);
+}
+async function deployWithBundler(chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const smartAccount = await getSmartAccount(config, publicClient, chain);
+    const deployArgs = getDeployArgs(config);
+    if (!deployArgs) {
+        throw new error_1.FactoryArgsNotAvailableError();
+    }
+    const { factory, factoryData } = deployArgs;
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        factory,
+        factoryData,
+        calls: [
+            {
+                to: viem_1.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 error_1.FactoryArgsNotAvailableError();
+    }
+    const deployArgs = getDeployArgs(config);
+    if (!deployArgs) {
+        throw new error_1.FactoryArgsNotAvailableError();
+    }
+    const { factory, factoryData } = deployArgs;
+    const magicBytes = '0x6492649264926492649264926492649264926492649264926492649264926492';
+    return (0, viem_1.concat)([
+        (0, viem_1.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 error_1.OwnersFieldRequiredError();
+    }
+    const account = getAccountProvider(config);
+    const address = getAddress(config);
+    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const signers = (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash, true);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+        }
+        case 'nexus': {
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn, defaultValidatorAddress);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+        }
+        case 'startale': {
+            return (0, startale_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+        }
+    }
+}
+async function getGuardianSmartAccount(config, client, chain, guardians) {
+    const address = getAddress(config);
+    const accounts = guardians.type === 'ecdsa' ? guardians.accounts : [];
+    const socialRecoveryValidator = (0, core_1.getSocialRecoveryValidator)(accounts);
+    if (!socialRecoveryValidator) {
+        throw new Error('Social recovery is not available');
+    }
+    const signers = {
+        type: 'guardians',
+        guardians: accounts,
+    };
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash, true);
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
+        }
+        case 'nexus': {
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn, defaultValidatorAddress);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
+        }
+        case 'startale': {
+            return (0, startale_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.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',
+    };
+}

package/dist/src/accounts/index.test.d.ts

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

package/dist/src/accounts/index.test.d.ts.map

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

package/dist/src/accounts/index.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const _1 = require(".");
+(0, vitest_1.describe)('Accounts', () => {
+    (0, vitest_1.describe)('Get Address', () => {
+        (0, vitest_1.test)('Nexus, ECDSA owner', () => {
+            const address = (0, _1.getAddress)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                    threshold: 1,
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0x0681de31e060b384F0b08A3bAC99E9bDFf302474');
+        });
+        (0, vitest_1.test)('Safe, passkey owner with a session', () => {
+            const address = (0, _1.getAddress)({
+                owners: {
+                    type: 'passkey',
+                    accounts: [consts_1.passkeyAccount],
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0x894b88C04B4DE6AbDdcE81E8bdc91927E37d6ceD');
+        });
+    });
+    (0, vitest_1.describe)('Sign', () => {
+        vitest_1.test.todo('With ECDSA, single key');
+        vitest_1.test.todo('With ECDSA, multisig');
+        vitest_1.test.todo('With Passkey');
+    });
+});

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

@@ -0,0 +1,5 @@
+import { type Chain, type Transport } from 'viem';
+import type { ProviderConfig } from '../../types';
+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

@@ -0,0 +1 @@
+{"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;AAEvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAGjD,iBAAS,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAkB3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}