@rhinestone/sdk 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/src/accounts/index.js

@@ -5,19 +5,23 @@ exports.getModuleInstallationCalls = getModuleInstallationCalls;
 exports.getModuleUninstallationCalls = getModuleUninstallationCalls;
 exports.getAddress = getAddress;
 exports.getAccountProvider = getAccountProvider;
+exports.getInitCode = getInitCode;
+exports.signEip7702InitData = signEip7702InitData;
+exports.getEip7702InitCall = getEip7702InitCall;
 exports.isDeployed = isDeployed;
 exports.deploy = deploy;
-exports.deploySource = deploySource;
-exports.deployTarget = deployTarget;
+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");
-const modules_1 = require("../modules");
 const validators_1 = require("../modules/validators");
 const core_1 = require("../modules/validators/core");
+const custom_1 = require("./custom");
 const error_1 = require("./error");
 Object.defineProperty(exports, "AccountError", { enumerable: true, get: function () { return error_1.AccountError; } });
 Object.defineProperty(exports, "Eip7702AccountMustHaveEoaError", { enumerable: true, get: function () { return error_1.Eip7702AccountMustHaveEoaError; } });
@@ -31,6 +35,10 @@ Object.defineProperty(exports, "SmartSessionsNotEnabledError", { enumerable: tru
 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) {
     const account = getAccountProvider(config);
@@ -44,6 +52,63 @@ function getDeployArgs(config) {
         case 'kernel': {
             return (0, kernel_1.getDeployArgs)(config);
         }
+        case 'startale': {
+            return (0, startale_1.getDeployArgs)(config);
+        }
+        case 'custom': {
+            return (0, custom_1.getDeployArgs)(config);
+        }
+    }
+}
+function getInitCode(config) {
+    if (is7702(config)) {
+        return undefined;
+    }
+    else {
+        const { factory, factoryData } = getDeployArgs(config);
+        if (!factory || !factoryData) {
+            throw new error_1.FactoryArgsNotAvailableError();
+        }
+        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 'safe':
+        case 'kernel':
+        case 'startale': {
+            throw new Error(`7702 is not supported for account type ${account.type}`);
+        }
+        case 'custom': {
+            throw new Error('7702 is not supported for custom account');
+        }
+    }
+}
+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(`7702 is not supported for account type ${account.type}`);
+        }
+        case 'custom': {
+            throw new Error('7702 is not supported for custom account');
+        }
     }
 }
 function getModuleInstallationCalls(config, module) {
@@ -60,11 +125,18 @@ function getModuleInstallationCalls(config, module) {
             case 'kernel': {
                 return (0, kernel_1.getInstallData)(module);
             }
+            case 'startale': {
+                return [(0, startale_1.getInstallData)(module)];
+            }
+            case 'custom': {
+                return (0, custom_1.getInstallData)(config, module);
+            }
         }
     }
     const installData = getInstallData();
     return installData.map((data) => ({
         to: address,
+        value: 0n,
         data,
     }));
 }
@@ -96,7 +168,7 @@ function getModuleUninstallationCalls(config, module) {
         functionName: 'uninstallModule',
         args: [module.type, module.address, module.deInitData],
     });
-    return [{ to: address, data }];
+    return [{ to: address, data, value: 0n }];
 }
 function getAddress(config) {
     if (is7702(config)) {
@@ -116,29 +188,78 @@ function getAddress(config) {
         case 'kernel': {
             return (0, kernel_1.getAddress)(config);
         }
+        case 'startale': {
+            return (0, startale_1.getAddress)(config);
+        }
+        case 'custom': {
+            return (0, custom_1.getAddress)(config);
+        }
     }
 }
-// Signs and packs a signature to be EIP-1271 compatibleAdd commentMore actions
-async function getPackedSignature(config, owners, chain, validator, hash, transformSignature = (signature) => signature) {
-    const signFn = (hash) => sign(owners, chain, hash);
+// Signs and packs a signature to be EIP-1271 compatible
+async function getPackedSignature(config, signers, chain, validator, hash, transformSignature = (signature) => signature) {
+    signers = signers ?? (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash);
     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);
+            return (0, nexus_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);
+        }
+        case 'custom': {
+            const signature = await signFn(hash);
+            return (0, custom_1.getPackedSignature)(config, signature, validator, transformSignature);
+        }
+    }
+}
+// Signs and packs a signature to be EIP-1271 compatible
+async function getTypedDataPackedSignature(config, signers, chain, validator, parameters, transformSignature = (signature) => signature) {
+    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 'custom': {
+            const signature = await signFn(parameters);
+            return (0, custom_1.getPackedSignature)(config, signature, validator, transformSignature);
         }
         case 'nexus': {
-            return (0, nexus_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+            const signature = await signFn(parameters);
+            return (0, nexus_1.packSignature)(signature, validator, transformSignature);
         }
         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);
+            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);
         }
     }
 }
-async function isDeployed(chain, config) {
+async function isDeployed(config, chain) {
     const publicClient = (0, viem_1.createPublicClient)({
         chain: chain,
-        transport: (0, viem_1.http)(),
+        transport: (0, utils_1.createTransport)(chain, config.provider),
     });
     const address = getAddress(config);
     const code = await publicClient.getCode({
@@ -154,141 +275,60 @@ async function isDeployed(chain, config) {
     return (0, viem_1.size)(code) > 0;
 }
 async function deploy(config, chain, session) {
-    await deploySource(chain, config);
+    await deployWithIntent(chain, config);
     if (session) {
         await (0, smart_session_1.enableSmartSession)(chain, config, session);
     }
 }
-async function deploySource(chain, config) {
-    if (is7702(config)) {
-        return deploy7702Self(chain, config);
-    }
-    else {
-        return deployStandalone(chain, config);
-    }
-}
-async function deployTarget(chain, config, asUserOp) {
-    if (is7702(config)) {
-        return deploy7702WithBundler(chain, config);
-    }
-    if (asUserOp) {
-        return deployStandalone(chain, config);
-    }
-    // No need to deploy manually for the intent flow
-}
-async function deployStandalone(chain, config) {
-    const deployer = config.deployerAccount;
-    if (deployer) {
-        return deployStandaloneWithEoa(chain, config, deployer);
-    }
-    return deployStandaloneWithBundler(chain, config);
-}
-async function deploy7702Self(chain, config) {
-    if (!config.eoa) {
-        throw new error_1.Eip7702AccountMustHaveEoaError();
-    }
-    const account = getAccountProvider(config);
-    const { implementation, initializationCallData } = getDeployArgs(config);
-    if (!initializationCallData) {
-        throw new Error(`Initialization call data not available for ${account.type}`);
-    }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, viem_1.http)(),
-    });
-    const accountClient = (0, viem_1.createWalletClient)({
-        account: config.eoa,
-        chain,
-        transport: (0, viem_1.http)(),
-    });
-    const authorization = await accountClient.signAuthorization({
-        contractAddress: implementation,
-        executor: 'self',
-    });
-    const hash = await accountClient.sendTransaction({
-        chain,
-        authorizationList: [authorization],
-        to: config.eoa.address,
-        data: initializationCallData,
-    });
-    await publicClient.waitForTransactionReceipt({ hash });
-}
-async function deployStandaloneWithEoa(chain, config, deployer) {
-    const { factory, factoryData } = getDeployArgs(config);
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain,
-        transport: (0, viem_1.http)(),
-    });
-    const client = (0, viem_1.createWalletClient)({
-        account: deployer,
-        chain: chain,
-        transport: (0, viem_1.http)(),
-    });
-    const tx = await client.sendTransaction({
-        to: factory,
-        data: factoryData,
-    });
-    await publicClient.waitForTransactionReceipt({ hash: tx });
-}
-async function deployStandaloneWithBundler(chain, config) {
+async function deployWithIntent(chain, config) {
     const publicClient = (0, viem_1.createPublicClient)({
         chain,
-        transport: (0, viem_1.http)(),
+        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,
+    const address = getAddress(config);
+    const code = await publicClient.getCode({ address });
+    if (code) {
+        // Already deployed
+        return;
+    }
+    const result = await (0, execution_1.sendTransaction)(config, {
+        targetChain: chain,
         calls: [
             {
-                to: viem_1.zeroHash,
-                value: 0n,
+                to: viem_1.zeroAddress,
                 data: '0x',
             },
         ],
     });
-    await bundlerClient.waitForUserOperationReceipt({
-        hash: opHash,
-    });
+    await (0, execution_1.waitForExecution)(config, result, true);
 }
-async function deploy7702WithBundler(chain, config) {
-    if (!config.eoa) {
-        throw new error_1.Eip7702AccountMustHaveEoaError();
+async function toErc6492Signature(config, signature, chain) {
+    const deployed = await isDeployed(config, chain);
+    if (deployed) {
+        return signature;
     }
-    const { implementation } = getDeployArgs(config);
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, viem_1.http)(),
-    });
-    const accountClient = (0, viem_1.createWalletClient)({
-        account: config.eoa,
-        chain,
-        transport: (0, viem_1.http)(),
-    });
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const authorization = await accountClient.signAuthorization({
-        contractAddress: implementation,
-    });
-    // Init the account
-    const smartAccount = await get7702SmartAccount(config, publicClient);
-    const initCalls = await get7702InitCalls(config);
-    const opHash = await bundlerClient.sendUserOperation({
-        account: smartAccount,
-        calls: initCalls,
-        authorization,
-    });
-    await bundlerClient.waitForUserOperationReceipt({
-        hash: opHash,
-    });
+    // 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) {
     const account = getAccountProvider(config);
     const address = getAddress(config);
     const ownerValidator = (0, validators_1.getOwnerValidator)(config);
-    const signFn = (hash) => sign(config.owners, chain, hash);
+    const signers = (0, common_1.convertOwnerSetToSignerSet)(config.owners);
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash);
     switch (account.type) {
         case 'safe': {
             return (0, safe_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
@@ -299,6 +339,12 @@ async function getSmartAccount(config, client, chain) {
         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);
+        }
+        case 'custom': {
+            return (0, custom_1.getSmartAccount)(config, client, address, ownerValidator.address, signFn);
+        }
     }
 }
 async function getSmartSessionSmartAccount(config, client, chain, session, enableData) {
@@ -307,7 +353,12 @@ async function getSmartSessionSmartAccount(config, client, chain, session, enabl
     if (!smartSessionValidator) {
         throw new error_1.SmartSessionsNotEnabledError();
     }
-    const signFn = (hash) => sign(session.owners, chain, hash);
+    const signers = {
+        type: 'session',
+        session,
+        enableData: enableData || undefined,
+    };
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash);
     const account = getAccountProvider(config);
     switch (account.type) {
         case 'safe': {
@@ -319,6 +370,12 @@ async function getSmartSessionSmartAccount(config, client, chain, session, enabl
         case 'kernel': {
             return (0, kernel_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn);
         }
+        case 'startale': {
+            return (0, startale_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, enableData, signFn);
+        }
+        case 'custom': {
+            return (0, custom_1.getSessionSmartAccount)(config, client, address, session, smartSessionValidator.address, enableData);
+        }
     }
 }
 async function getGuardianSmartAccount(config, client, chain, guardians) {
@@ -328,7 +385,11 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
     if (!socialRecoveryValidator) {
         throw new Error('Social recovery is not available');
     }
-    const signFn = (hash) => sign(guardians, chain, hash);
+    const signers = {
+        type: 'guardians',
+        guardians: accounts,
+    };
+    const signFn = (hash) => (0, message_1.sign)(signers, chain, address, hash);
     const account = getAccountProvider(config);
     switch (account.type) {
         case 'safe': {
@@ -340,63 +401,8 @@ async function getGuardianSmartAccount(config, client, chain, guardians) {
         case 'kernel': {
             return (0, kernel_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
         }
-    }
-}
-async function sign(validators, chain, hash) {
-    switch (validators.type) {
-        case 'ecdsa': {
-            const signatures = await Promise.all(validators.accounts.map((account) => signEcdsa(account, hash)));
-            return (0, viem_1.concat)(signatures);
-        }
-        case 'passkey': {
-            return await signPasskey(validators.account, chain, hash);
-        }
-    }
-}
-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;
-}
-async function get7702SmartAccount(config, client) {
-    if (!config.eoa) {
-        throw new error_1.Eip7702AccountMustHaveEoaError();
-    }
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return (0, safe_1.get7702SmartAccount)();
-        }
-        case 'nexus': {
-            return (0, nexus_1.get7702SmartAccount)(config.eoa, client);
-        }
-        case 'kernel': {
-            return (0, kernel_1.get7702SmartAccount)();
-        }
-    }
-}
-async function get7702InitCalls(config) {
-    const account = getAccountProvider(config);
-    switch (account.type) {
-        case 'safe': {
-            return (0, safe_1.get7702InitCalls)();
-        }
-        case 'nexus': {
-            return (0, nexus_1.get7702InitCalls)(config);
-        }
-        case 'kernel': {
-            return (0, kernel_1.get7702InitCalls)();
+        case 'startale': {
+            return (0, startale_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
         }
     }
 }

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

@@ -14,17 +14,17 @@ const _1 = require(".");
                 },
                 rhinestoneApiKey: consts_1.MOCK_API_KEY,
             });
-            (0, vitest_1.expect)(address).toEqual('0x31ab511fb2f2f816273cb4daccc3b5a7051d7de9');
+            (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('0x381c656b20526f5be15d7a908b2743d5ec51bd04');
+            (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

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

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);
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chains_1 = require("viem/chains");
+const vitest_1 = require("vitest");
+const providers_1 = require("./providers");
+(0, vitest_1.describe)('Providers', () => {
+    (0, vitest_1.describe)('Alchemy', () => {
+        (0, vitest_1.test)('Network', () => {
+            const mockApiKey = '123';
+            (0, vitest_1.expect)((0, providers_1.getAlchemyUrl)(chains_1.mainnet.id, mockApiKey)).toBe('https://eth-mainnet.g.alchemy.com/v2/123');
+            (0, vitest_1.expect)((0, providers_1.getAlchemyUrl)(chains_1.sepolia.id, mockApiKey)).toBe('https://eth-sepolia.g.alchemy.com/v2/123');
+            (0, vitest_1.expect)((0, providers_1.getAlchemyUrl)(chains_1.polygon.id, mockApiKey)).toBe('https://polygon-mainnet.g.alchemy.com/v2/123');
+        });
+    });
+});

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

@@ -1,9 +1,9 @@
-import { Abi, Address, Hex, PublicClient } from 'viem';
-import { SmartAccount, SmartAccountImplementation } from 'viem/account-abstraction';
-import { Module } from '../modules/common';
-import { EnableSessionData } from '../modules/validators/smart-sessions';
-import { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
-import { ValidatorConfig } from './utils';
+import { type Abi, type Address, type Hex, type PublicClient } from 'viem';
+import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
+import { type Module } from '../modules/common';
+import type { EnableSessionData } from '../modules/validators/smart-sessions';
+import type { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
+import { type ValidatorConfig } from './utils';
 declare function getDeployArgs(config: RhinestoneAccountConfig): {
     factory: `0x${string}`;
     factoryData: `0x${string}`;
@@ -13,11 +13,10 @@ declare function getDeployArgs(config: RhinestoneAccountConfig): {
 };
 declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
 declare function getInstallData(module: Module): Hex[];
-declare function get7702InitCalls(): never;
-declare function get7702SmartAccount(): never;
-declare function getPackedSignature(signFn: (message: Hex) => Promise<Hex>, hash: Hex, validator: ValidatorConfig, accountAddress: Address, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
+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 getSessionSmartAccount(client: PublicClient, address: Address, session: Session, validatorAddress: Address, enableData: EnableSessionData | null, 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 { getInstallData, getAddress, getDeployArgs, getSmartAccount, getSessionSmartAccount, getGuardianSmartAccount, get7702InitCalls, get7702SmartAccount, getPackedSignature, };
+export { getInstallData, getAddress, getDeployArgs, getSmartAccount, getSessionSmartAccount, getGuardianSmartAccount, packSignature, wrapMessageHash, };
 //# sourceMappingURL=kernel.d.ts.map