@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

package/dist/src/accounts/index.js

@@ -1,589 +0,0 @@
-import { concat, createPublicClient, encodeAbiParameters, encodeFunctionData, hashTypedData, size, zeroAddress, } from 'viem';
-import { sendTransactionInternal, sendUserOperationInternal, waitForExecution, } from '../execution/index.js';
-import { getIntentExecutor, getSetup } from '../modules/index.js';
-import { getOwnerValidator } from '../modules/validators/index.js';
-import { getSocialRecoveryValidator } from '../modules/validators/core.js';
-import { AccountConfigurationNotSupportedError, AccountError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, EoaAccountMustHaveAccountError, EoaSigningMethodNotConfiguredError, EoaSigningNotSupportedError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, isAccountError, ModuleInstallationNotSupportedError, OwnersFieldRequiredError, SigningNotSupportedForAccountError, SmartSessionsNotEnabledError, WalletClientNoConnectedAccountError, } from './error.js';
-import { getAddress as getKernelAddress, getDeployArgs as getKernelDeployArgs, getEip712Domain as getKernelEip712Domain, getGuardianSmartAccount as getKernelGuardianSmartAccount, getInstallData as getKernelInstallData, getSmartAccount as getKernelSmartAccount, packSignature as packKernelSignature, wrapMessageHash as wrapKernelMessageHash, } from './kernel.js';
-import { getAddress as getNexusAddress, getDefaultValidatorAddress as getNexusDefaultValidatorAddress, getDeployArgs as getNexusDeployArgs, getEip712Domain as getNexusEip712Domain, getEip7702InitCall as getNexusEip7702InitCall, getGuardianSmartAccount as getNexusGuardianSmartAccount, getInstallData as getNexusInstallData, getSmartAccount as getNexusSmartAccount, packSignature as packNexusSignature, signEip7702InitData as signNexusEip7702InitData, } from './nexus.js';
-import { getAddress as getSafeAddress, getDeployArgs as getSafeDeployArgs, getEip712Domain as getSafeEip712Domain, getGuardianSmartAccount as getSafeGuardianSmartAccount, 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, getGuardianSmartAccount as getStartaleGuardianSmartAccount, getInstallData as getStartaleInstallData, getSmartAccount as getStartaleSmartAccount, packSignature as packStartaleSignature, } 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 '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': {
-            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': {
-            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 '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 'eoa': {
-                throw new 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 = 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 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 '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();
-}
-// 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 EoaSigningNotSupportedError('packed signatures');
-    }
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => signMessage(signers, chain, address, hash, false);
-    const account = getAccountProvider(config);
-    const address = getAddress(config);
-    switch (account.type) {
-        case 'safe': {
-            const signature = await signFn(hash);
-            return packSafeSignature(signature, validator, transformSignature);
-        }
-        case 'nexus': {
-            const signature = await signFn(hash);
-            const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-            return packNexusSignature(signature, validator, transformSignature, defaultValidatorAddress);
-        }
-        case 'kernel': {
-            const signature = await signFn(wrapKernelMessageHash(hash, address));
-            return packKernelSignature(signature, validator, transformSignature);
-        }
-        case 'startale': {
-            const signature = await signFn(hash);
-            return packStartaleSignature(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 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 signFn = (parameters) => signTypedData(signers, chain, address, parameters);
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            const signature = await signFn(parameters);
-            return packSafeSignature(signature, validator, transformSignature);
-        }
-        case 'nexus': {
-            const signature = await signFn(parameters);
-            const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-            return packNexusSignature(signature, validator, transformSignature, defaultValidatorAddress);
-        }
-        case 'kernel': {
-            const address = getAddress(config);
-            const signMessageFn = (hash) => signMessage(signers, chain, address, hash, false);
-            const signature = await signMessageFn(wrapKernelMessageHash(hashTypedData(parameters), address));
-            return packKernelSignature(signature, validator, transformSignature);
-        }
-        case 'startale': {
-            const signature = await signFn(parameters);
-            return packStartaleSignature(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 = 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);
-    if (account.type === 'eoa') {
-        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,
-    ];
-    // 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);
-        }
-    }
-}
-async function getGuardianSmartAccount(config, client, chain, guardians) {
-    const address = getAddress(config);
-    const accounts = guardians.type === 'ecdsa' ? guardians.accounts : [];
-    const socialRecoveryValidator = getSocialRecoveryValidator(accounts);
-    if (!socialRecoveryValidator) {
-        throw new Error('Social recovery is not available');
-    }
-    const signers = {
-        type: 'guardians',
-        guardians: accounts,
-    };
-    const signFn = (hash) => signMessage(signers, chain, address, hash, true);
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return getSafeGuardianSmartAccount(client, address, guardians, socialRecoveryValidator.address, signFn);
-        }
-        case 'nexus': {
-            const defaultValidatorAddress = getNexusDefaultValidatorAddress(account.version);
-            return getNexusGuardianSmartAccount(client, address, guardians, socialRecoveryValidator.address, signFn, defaultValidatorAddress);
-        }
-        case 'kernel': {
-            return getKernelGuardianSmartAccount(client, address, guardians, socialRecoveryValidator.address, signFn);
-        }
-        case 'startale': {
-            return getStartaleGuardianSmartAccount(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',
-    };
-}
-export { getEip712Domain, getModuleInstallationCalls, getModuleUninstallationCalls, getAddress, checkAddress, getAccountProvider, getInitCode, getV0InitCode, signEip7702InitData, getEip7702InitCall, is7702, isDeployed, deploy, setup, toErc6492Signature, getSmartAccount, getGuardianSmartAccount, getEip1271Signature, getEmissarySignature, getTypedDataPackedSignature, 
-// Errors
-isAccountError, AccountError, AccountConfigurationNotSupportedError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, EoaAccountMustHaveAccountError, EoaSigningMethodNotConfiguredError, EoaSigningNotSupportedError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, ModuleInstallationNotSupportedError, OwnersFieldRequiredError, SigningNotSupportedForAccountError, SmartSessionsNotEnabledError, 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;AAEvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAGjD,iBAAS,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAmB3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/src/accounts/json-rpc/index.js

@@ -1,19 +0,0 @@
-import { http } from 'viem';
-import { getAlchemyUrl, getCustomUrl } from './providers.js';
-function createTransport(chain, provider) {
-    if (!provider) {
-        return http();
-    }
-    switch (provider.type) {
-        case 'alchemy': {
-            const alchemyUrl = getAlchemyUrl(chain.id, provider.apiKey);
-            return http(alchemyUrl);
-        }
-        case 'custom': {
-            const customUrl = getCustomUrl(chain.id, provider.urls);
-            // Fall back to default provider if no custom URL configured for this chain
-            return http(customUrl);
-        }
-    }
-}
-export { createTransport };

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

@@ -1,5 +0,0 @@
-import type { SupportedChain } from '../../orchestrator/index.js';
-declare function getAlchemyUrl(chainId: SupportedChain, apiKey: string): string;
-declare function getCustomUrl(chainId: number, urls: Record<number, string>): string | undefined;
-export { getAlchemyUrl, getCustomUrl };
-//# sourceMappingURL=providers.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../accounts/json-rpc/providers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAExD,iBAAS,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAYtE;AAED,iBAAS,YAAY,CACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,MAAM,GAAG,SAAS,CAEpB;AAED,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,CAAA"}

package/dist/src/accounts/json-rpc/providers.js

@@ -1,16 +0,0 @@
-import { providerRegistry as providers } from '@rhinestone/shared-configs';
-function getAlchemyUrl(chainId, apiKey) {
-    const urlTemplate = providers.Alchemy.url_template;
-    const chainParam = providers.Alchemy.chain_mapping[chainId];
-    if (!chainParam) {
-        throw new Error(`Unsupported chain: ${chainId}`);
-    }
-    return (urlTemplate
-        .replace('{{chain_param}}', chainParam)
-        // biome-ignore lint/suspicious/noTemplateCurlyInString: literal placeholder token in the upstream shared-configs url_template
-        .replace('${ALCHEMY_API_KEY}', apiKey));
-}
-function getCustomUrl(chainId, urls) {
-    return urls[chainId];
-}
-export { getAlchemyUrl, getCustomUrl };

package/dist/src/accounts/kernel.d.ts

@@ -1,27 +0,0 @@
-import { type Abi, type Address, type Chain, type Hex, type PublicClient } from 'viem';
-import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
-import { type Module } from '../modules/common.js';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types.js';
-import { type ValidatorConfig } from './utils.js';
-declare function getDeployArgs(config: RhinestoneAccountConfig): {
-    factory: `0x${string}`;
-    factoryData: `0x${string}`;
-    implementation: `0x${string}`;
-    initializationCallData: `0x${string}`;
-    salt: `0x${string}`;
-} | null;
-declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
-declare function getEip712Domain(config: RhinestoneAccountConfig, chain: Chain): {
-    name: string;
-    version: string;
-    chainId: number;
-    verifyingContract: `0x${string}`;
-    salt: "0x0000000000000000000000000000000000000000000000000000000000000000";
-};
-declare function getInstallData(module: Module): Hex[];
-declare function packSignature(signature: Hex, validator: ValidatorConfig, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
-declare function wrapMessageHash(messageHash: Hex, accountAddress: Hex): Hex;
-declare function getSmartAccount(client: PublicClient, address: Address, owners: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
-declare function getGuardianSmartAccount(client: PublicClient, address: Address, guardians: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
-export { getEip712Domain, getInstallData, getAddress, getDeployArgs, getSmartAccount, getGuardianSmartAccount, packSignature, wrapMessageHash, };
-//# sourceMappingURL=kernel.d.ts.map

package/dist/src/accounts/kernel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../accounts/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EACR,KAAK,OAAO,EACZ,KAAK,KAAK,EASV,KAAK,GAAG,EAER,KAAK,YAAY,EAMlB,MAAM,MAAM,CAAA;AACb,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EAKL,KAAK,MAAM,EACZ,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAiB,QAAQ,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAKhF,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAgBhF,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;SAmFrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAalD;AAED,iBAAS,eAAe,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,KAAK;;;;;;EAarE;AAED,iBAAS,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,CAsE7C;AAED,iBAAe,aAAa,CAC1B,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,eAAe,EAC1B,kBAAkB,GAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAA8B,0BAYvE;AAED,iBAAS,eAAe,CAAC,WAAW,EAAE,GAAG,EAAE,cAAc,EAAE,GAAG,GAAG,GAAG,CAoBnE;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,QAAQ,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEAYlC;AAED,iBAAe,uBAAuB,CACpC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,QAAQ,EACnB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEAclC;AA+ED,OAAO,EACL,eAAe,EACf,cAAc,EACd,UAAU,EACV,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,aAAa,EACb,eAAe,GAChB,CAAA"}