@rhinestone/sdk 1.0.0-alpha.9 → 1.0.0-beta.38

package/dist/src/accounts/index.js

@@ -1,17 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Eip7702NotSupportedForAccountError = exports.SignMessageNotSupportedByAccountError = exports.SigningNotSupportedForAccountError = exports.SmartSessionsNotEnabledError = exports.FactoryArgsNotAvailableError = exports.ExistingEip7702AccountsNotSupportedError = exports.Eip7702AccountMustHaveEoaError = exports.AccountError = exports.isAccountError = void 0;
+exports.WalletClientNoConnectedAccountError = exports.SmartSessionsNotEnabledError = exports.SigningNotSupportedForAccountError = exports.OwnersFieldRequiredError = exports.ModuleInstallationNotSupportedError = exports.FactoryArgsNotAvailableError = exports.ExistingEip7702AccountsNotSupportedError = exports.EoaSigningNotSupportedError = exports.EoaSigningMethodNotConfiguredError = exports.Eip7702NotSupportedForAccountError = exports.Eip7702AccountMustHaveEoaError = exports.AccountConfigurationNotSupportedError = exports.AccountError = exports.isAccountError = void 0;
 exports.getModuleInstallationCalls = getModuleInstallationCalls;
 exports.getModuleUninstallationCalls = getModuleUninstallationCalls;
 exports.getAddress = getAddress;
+exports.checkAddress = checkAddress;
 exports.getAccountProvider = getAccountProvider;
 exports.getInitCode = getInitCode;
+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.getSmartSessionSmartAccount = getSmartSessionSmartAccount;
 exports.getGuardianSmartAccount = getGuardianSmartAccount;
 exports.getPackedSignature = getPackedSignature;
+exports.getTypedDataPackedSignature = getTypedDataPackedSignature;
 const viem_1 = require("viem");
 const execution_1 = require("../execution");
 const smart_session_1 = require("../execution/smart-session");
@@ -19,18 +26,26 @@ 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, "Eip7702AccountMustHaveEoaError", { enumerable: true, get: function () { return error_1.Eip7702AccountMustHaveEoaError; } });
 Object.defineProperty(exports, "Eip7702NotSupportedForAccountError", { enumerable: true, get: function () { return error_1.Eip7702NotSupportedForAccountError; } });
+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, "SignMessageNotSupportedByAccountError", { enumerable: true, get: function () { return error_1.SignMessageNotSupportedByAccountError; } });
 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 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) {
@@ -48,12 +63,21 @@ function getDeployArgs(config) {
         case 'startale': {
             return (0, startale_1.getDeployArgs)(config);
         }
+        case 'eoa': {
+            throw new Error('EOA accounts do not have deploy args');
+        }
     }
 }
 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 { factory, factoryData } = getDeployArgs(config);
         if (!factory || !factoryData) {
@@ -65,6 +89,45 @@ function getInitCode(config) {
         };
     }
 }
+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);
+        }
+    }
+}
+async function getEip7702InitCall(config, signature) {
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'nexus': {
+            return await (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 getModuleInstallationCalls(config, module) {
     const address = getAddress(config);
     function getInstallData() {
@@ -82,6 +145,9 @@ function getModuleInstallationCalls(config, module) {
             case 'startale': {
                 return [(0, startale_1.getInstallData)(module)];
             }
+            case 'eoa': {
+                throw new error_1.ModuleInstallationNotSupportedError(account.type);
+            }
         }
     }
     const installData = getInstallData();
@@ -142,30 +208,93 @@ function getAddress(config) {
         case 'startale': {
             return (0, startale_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 getPackedSignature(config, signers, chain, validator, hash, transformSignature = (signature) => signature) {
-    signers = signers ?? convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => sign(signers, chain, hash);
+    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': {
-            return (0, safe_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            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 '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 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': {
-            return (0, nexus_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            const signature = await signFn(parameters);
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature, defaultValidatorAddress);
         }
         case 'kernel': {
-            return (0, kernel_1.getPackedSignature)(signFn, hash, validator, address, transformSignature);
+            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': {
-            return (0, startale_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            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(chain, config) {
+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),
@@ -184,10 +313,89 @@ async function isDeployed(chain, config) {
     return (0, viem_1.size)(code) > 0;
 }
 async function deploy(config, chain, session) {
-    await deployWithIntent(chain, config);
+    const account = getAccountProvider(config);
+    if (account.type === 'eoa') {
+        return false;
+    }
+    const deployed = await isDeployed(config, chain);
+    if (deployed) {
+        return false;
+    }
+    const asUserOp = config.initData && !config.initData.intentExecutorInstalled;
+    if (asUserOp) {
+        await deployWithBundler(chain, config);
+    }
+    else {
+        await deployWithIntent(chain, config);
+    }
     if (session) {
         await (0, smart_session_1.enableSmartSession)(chain, config, session);
     }
+    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, 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) {
     const publicClient = (0, viem_1.createPublicClient)({
@@ -200,7 +408,7 @@ async function deployWithIntent(chain, config) {
         // Already deployed
         return;
     }
-    await (0, execution_1.sendTransaction)(config, {
+    const result = await (0, execution_1.sendTransaction)(config, {
         targetChain: chain,
         calls: [
             {
@@ -209,19 +417,73 @@ async function deployWithIntent(chain, config) {
             },
         ],
     });
+    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 { factory, factoryData } = getDeployArgs(config);
+    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 { factory, factoryData } = initCode;
+    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 = convertOwnerSetToSignerSet(config.owners);
-    const signFn = (hash) => sign(signers, chain, hash);
+    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': {
-            return (0, nexus_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+            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);
@@ -242,14 +504,15 @@ async function getSmartSessionSmartAccount(config, client, chain, session, enabl
         session,
         enableData: enableData || undefined,
     };
-    const signFn = (hash) => sign(signers, chain, hash);
+    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.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn);
         }
         case 'nexus': {
-            return (0, nexus_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn);
+            const defaultValidatorAddress = (0, nexus_1.getDefaultValidatorAddress)(account.version);
+            return (0, nexus_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn, defaultValidatorAddress);
         }
         case 'kernel': {
             return (0, kernel_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn);
@@ -270,14 +533,15 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
         type: 'guardians',
         guardians: accounts,
     };
-    const signFn = (hash) => sign(signers, chain, hash);
+    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': {
-            return (0, nexus_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
+            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);
@@ -287,87 +551,9 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
         }
     }
 }
-async function sign(signers, chain, hash) {
-    switch (signers.type) {
-        case 'owner': {
-            switch (signers.kind) {
-                case 'ecdsa': {
-                    const signatures = await Promise.all(signers.accounts.map((account) => signEcdsa(account, hash)));
-                    return (0, viem_1.concat)(signatures);
-                }
-                case 'passkey': {
-                    return await signPasskey(signers.account, chain, hash);
-                }
-                case 'multi-factor': {
-                    const signatures = await Promise.all(signers.validators.map(async (validator) => {
-                        if (validator === null) {
-                            return '0x';
-                        }
-                        const validatorSigners = convertOwnerSetToSignerSet(validator);
-                        return sign(validatorSigners, chain, hash);
-                    }));
-                    const data = (0, viem_1.encodeAbiParameters)([
-                        {
-                            components: [
-                                {
-                                    internalType: 'bytes32',
-                                    name: 'packedValidatorAndId',
-                                    type: 'bytes32',
-                                },
-                                { internalType: 'bytes', name: 'data', type: 'bytes' },
-                            ],
-                            name: 'validators',
-                            type: 'tuple[]',
-                        },
-                    ], [
-                        signers.validators.map((validator, index) => {
-                            const validatorModule = (0, core_1.getValidator)(validator);
-                            return {
-                                packedValidatorAndId: (0, viem_1.concat)([
-                                    (0, viem_1.pad)((0, viem_1.toHex)(validator.id), {
-                                        size: 12,
-                                    }),
-                                    validatorModule.address,
-                                ]),
-                                data: signatures[index],
-                            };
-                        }),
-                    ]);
-                    return data;
-                }
-                default: {
-                    throw new Error('Unsupported owner kind');
-                }
-            }
-        }
-        case 'session': {
-            const sessionSigners = convertOwnerSetToSignerSet(signers.session.owners);
-            return sign(sessionSigners, chain, hash);
-        }
-        case 'guardians': {
-            const signatures = await Promise.all(signers.guardians.map((account) => signEcdsa(account, hash)));
-            return (0, viem_1.concat)(signatures);
-        }
-    }
-}
-async function signEcdsa(account, hash) {
-    if (!account.signMessage) {
-        throw new error_1.SigningNotSupportedForAccountError();
-    }
-    return await account.signMessage({ message: { raw: hash } });
-}
-async function signPasskey(account, chain, hash) {
-    const { webauthn, signature } = await account.sign({ hash });
-    const usePrecompiled = (0, modules_1.isRip7212SupportedNetwork)(chain);
-    const encodedSignature = (0, modules_1.getWebauthnValidatorSignature)({
-        webauthn,
-        signature,
-        usePrecompiled,
-    });
-    return encodedSignature;
-}
 function is7702(config) {
-    return config.eoa !== undefined;
+    const account = getAccountProvider(config);
+    return account.type !== 'eoa' && config.eoa !== undefined;
 }
 function getAccountProvider(config) {
     if (config.account) {
@@ -377,45 +563,3 @@ function getAccountProvider(config) {
         type: 'nexus',
     };
 }
-function convertOwnerSetToSignerSet(owners) {
-    switch (owners.type) {
-        case 'ecdsa': {
-            return {
-                type: 'owner',
-                kind: 'ecdsa',
-                accounts: owners.accounts,
-            };
-        }
-        case 'passkey': {
-            return {
-                type: 'owner',
-                kind: 'passkey',
-                account: owners.account,
-            };
-        }
-        case 'multi-factor': {
-            return {
-                type: 'owner',
-                kind: 'multi-factor',
-                validators: owners.validators.map((validator, index) => {
-                    switch (validator.type) {
-                        case 'ecdsa': {
-                            return {
-                                type: 'ecdsa',
-                                id: index,
-                                accounts: validator.accounts,
-                            };
-                        }
-                        case 'passkey': {
-                            return {
-                                type: 'passkey',
-                                id: index,
-                                account: validator.account,
-                            };
-                        }
-                    }
-                }),
-            };
-        }
-    }
-}

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

@@ -12,19 +12,17 @@ const _1 = require(".");
                     accounts: [consts_1.accountA, consts_1.accountB],
                     threshold: 1,
                 },
-                rhinestoneApiKey: consts_1.MOCK_API_KEY,
             });
-            (0, vitest_1.expect)(address).toEqual('0x0cd1c38d4cdffdbbd4ac192babf70110ad250668');
+            (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',
-                    account: consts_1.passkeyAccount,
+                    accounts: [consts_1.passkeyAccount],
                 },
-                rhinestoneApiKey: consts_1.MOCK_API_KEY,
             });
-            (0, vitest_1.expect)(address).toEqual('0x35e1c3f1ded30246aa2ca361342c3ee0d0749293');
+            (0, vitest_1.expect)(address).toEqual('0x894b88C04B4DE6AbDdcE81E8bdc91927E37d6ceD');
         });
     });
     (0, vitest_1.describe)('Sign', () => {

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,CAc3E;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = createTransport;
+const viem_1 = require("viem");
+const providers_1 = require("./providers");
+function createTransport(chain, provider) {
+    if (!provider) {
+        return (0, viem_1.http)();
+    }
+    switch (provider.type) {
+        case 'alchemy': {
+            const alchemyUrl = (0, providers_1.getAlchemyUrl)(chain.id, provider.apiKey);
+            return (0, viem_1.http)(alchemyUrl);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chains_1 = require("viem/chains");
+const vitest_1 = require("vitest");
+const index_1 = require("./index");
+(0, vitest_1.describe)('JSON-RPC', () => {
+    (0, vitest_1.describe)('createTransport', () => {
+        (0, vitest_1.test)('Alchemy', () => {
+            const transport = (0, index_1.createTransport)(chains_1.base, {
+                type: 'alchemy',
+                apiKey: '123',
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,4 @@
+import type { SupportedChain } from '../../orchestrator';
+declare function getAlchemyUrl(chainId: SupportedChain, apiKey: string): string;
+export { getAlchemyUrl };
+//# sourceMappingURL=providers.d.ts.map

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

@@ -0,0 +1 @@
+{"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,CAStE;AAED,OAAO,EAAE,aAAa,EAAE,CAAA"}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlchemyUrl = getAlchemyUrl;
+const shared_configs_1 = require("@rhinestone/shared-configs");
+function getAlchemyUrl(chainId, apiKey) {
+    const urlTemplate = shared_configs_1.providerRegistry.Alchemy.url_template;
+    const chainParam = shared_configs_1.providerRegistry.Alchemy.chain_mapping[chainId];
+    if (!chainParam) {
+        throw new Error(`Unsupported chain: ${chainId}`);
+    }
+    return urlTemplate
+        .replace('{{chain_param}}', chainParam)
+        .replace('\$\{ALCHEMY_API_KEY\}', apiKey);
+}