@rhinestone/sdk 1.4.2 → 2.0.0-beta.0

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

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAlchemyUrl = getAlchemyUrl;
-exports.getCustomUrl = getCustomUrl;
-const shared_configs_1 = require("@rhinestone/shared-configs");
+import { providerRegistry as providers } from '@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];
+    const urlTemplate = providers.Alchemy.url_template;
+    const chainParam = providers.Alchemy.chain_mapping[chainId];
     if (!chainParam) {
         throw new Error(`Unsupported chain: ${chainId}`);
     }
@@ -16,3 +12,4 @@ function getAlchemyUrl(chainId, apiKey) {
 function getCustomUrl(chainId, urls) {
     return urls[chainId];
 }
+export { getAlchemyUrl, getCustomUrl };

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

@@ -1,8 +1,8 @@
 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';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types';
-import { type ValidatorConfig } from './utils';
+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}`;

package/dist/src/accounts/kernel.js

@@ -1,20 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEip712Domain = getEip712Domain;
-exports.getInstallData = getInstallData;
-exports.getAddress = getAddress;
-exports.getDeployArgs = getDeployArgs;
-exports.getSmartAccount = getSmartAccount;
-exports.getGuardianSmartAccount = getGuardianSmartAccount;
-exports.packSignature = packSignature;
-exports.wrapMessageHash = wrapMessageHash;
-const viem_1 = require("viem");
-const account_abstraction_1 = require("viem/account-abstraction");
-const modules_1 = require("../modules");
-const common_1 = require("../modules/common");
-const validators_1 = require("../modules/validators");
-const error_1 = require("./error");
-const utils_1 = require("./utils");
+import { concat, concatHex, decodeAbiParameters, decodeFunctionData, domainSeparator, encodeAbiParameters, encodeFunctionData, getContractAddress, keccak256, parseAbi, stringToHex, toHex, zeroAddress, zeroHash, } from 'viem';
+import { entryPoint07Abi, entryPoint07Address, getUserOperationHash, toSmartAccount, } from 'viem/account-abstraction';
+import { getSetup as getModuleSetup } from '../modules/index.js';
+import { MODULE_TYPE_ID_EXECUTOR, MODULE_TYPE_ID_FALLBACK, MODULE_TYPE_ID_HOOK, MODULE_TYPE_ID_VALIDATOR, } from '../modules/common.js';
+import { getMockSignature } from '../modules/validators/index.js';
+import { AccountConfigurationNotSupportedError, Eip712DomainNotAvailableError, } from './error.js';
+import { encode7579Calls, getAccountNonce } from './utils.js';
 const KERNEL_META_FACTORY_ADDRESS = '0xd703aae79538628d27099b8c4f621be4ccd142d5';
 const KERNEL_IMPLEMENTATION_ADDRESS = '0xd6cedde84be40893d153be9d467cd6ad37875b28';
 const KERNEL_FACTORY_ADDRESS = '0x2577507b78c2008ff367261cb6285d44ba5ef2e9';
@@ -25,23 +15,23 @@ function getDeployArgs(config) {
         if (!('factory' in config.initData)) {
             return null;
         }
-        const factoryData = (0, viem_1.decodeFunctionData)({
-            abi: (0, viem_1.parseAbi)([
+        const factoryData = decodeFunctionData({
+            abi: parseAbi([
                 'function deployWithFactory(address factory,bytes createData,bytes32 salt)',
             ]),
             data: config.initData.factoryData,
         });
         if (factoryData.functionName !== 'deployWithFactory') {
-            throw new error_1.AccountConfigurationNotSupportedError('Invalid factory data', 'kernel');
+            throw new AccountConfigurationNotSupportedError('Invalid factory data', 'kernel');
         }
         const factory = factoryData.args[0];
         const createData = factoryData.args[1];
         const salt = factoryData.args[2];
         const implementation = factory.toLowerCase() === KERNEL_FACTORY_ADDRESS
             ? KERNEL_IMPLEMENTATION_ADDRESS
-            : viem_1.zeroAddress;
-        if (implementation === viem_1.zeroAddress) {
-            throw new error_1.AccountConfigurationNotSupportedError('Unsupported Kernel implementation', 'kernel');
+            : zeroAddress;
+        if (implementation === zeroAddress) {
+            throw new AccountConfigurationNotSupportedError('Unsupported Kernel implementation', 'kernel');
         }
         return {
             factory: config.initData.factory,
@@ -52,10 +42,10 @@ function getDeployArgs(config) {
         };
     }
     const account = config.account;
-    const salt = account?.salt ?? viem_1.zeroHash;
-    const moduleSetup = (0, modules_1.getSetup)(config);
-    const rootValidator = (0, viem_1.concat)(['0x01', moduleSetup.validators[0].address]);
-    const hook = viem_1.zeroAddress;
+    const salt = account?.salt ?? zeroHash;
+    const moduleSetup = getModuleSetup(config);
+    const rootValidator = concat(['0x01', moduleSetup.validators[0].address]);
+    const hook = zeroAddress;
     const validatorData = moduleSetup.validators[0].initData;
     const hookData = '0x';
     // Install modules via init config
@@ -73,13 +63,13 @@ function getDeployArgs(config) {
     for (const module of moduleSetup.hooks) {
         initConfig.push(...getInstallData(module));
     }
-    const initializationCallData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)(['function initialize(bytes21,address,bytes,bytes,bytes[])']),
+    const initializationCallData = encodeFunctionData({
+        abi: parseAbi(['function initialize(bytes21,address,bytes,bytes,bytes[])']),
         functionName: 'initialize',
         args: [rootValidator, hook, validatorData, hookData, initConfig],
     });
-    const factoryData = (0, viem_1.encodeFunctionData)({
-        abi: (0, viem_1.parseAbi)(['function deployWithFactory(address,bytes,bytes32)']),
+    const factoryData = encodeFunctionData({
+        abi: parseAbi(['function deployWithFactory(address,bytes,bytes32)']),
         functionName: 'deployWithFactory',
         args: [KERNEL_FACTORY_ADDRESS, initializationCallData, salt],
     });
@@ -97,8 +87,8 @@ function getAddress(config) {
         throw new Error('Cannot derive address: deploy args not available');
     }
     const { salt, initializationCallData } = deployArgs;
-    const actualSalt = (0, viem_1.keccak256)((0, viem_1.concat)([initializationCallData, salt]));
-    return (0, viem_1.getContractAddress)({
+    const actualSalt = keccak256(concat([initializationCallData, salt]));
+    return getContractAddress({
         from: KERNEL_FACTORY_ADDRESS,
         opcode: 'CREATE2',
         bytecode: KERNEL_BYTECODE,
@@ -107,67 +97,67 @@ function getAddress(config) {
 }
 function getEip712Domain(config, chain) {
     if (config.initData) {
-        throw new error_1.Eip712DomainNotAvailableError('Existing Kernel accounts are not yet supported');
+        throw new Eip712DomainNotAvailableError('Existing Kernel accounts are not yet supported');
     }
     return {
         name: 'Kernel',
         version: KERNEL_VERSION,
         chainId: chain.id,
         verifyingContract: getAddress(config),
-        salt: viem_1.zeroHash,
+        salt: zeroHash,
     };
 }
 function getInstallData(module) {
     const HOOK_INSTALLED_ADDRESS = '0x0000000000000000000000000000000000000001';
     switch (module.type) {
-        case common_1.MODULE_TYPE_ID_VALIDATOR: {
-            const data = (0, viem_1.encodeAbiParameters)([{ type: 'bytes' }, { type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x', '0x']);
-            const initData = (0, viem_1.concat)([HOOK_INSTALLED_ADDRESS, data]);
-            const validatorId = (0, viem_1.concat)(['0x01', module.address]);
+        case MODULE_TYPE_ID_VALIDATOR: {
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x', '0x']);
+            const initData = concat([HOOK_INSTALLED_ADDRESS, data]);
+            const validatorId = concat(['0x01', module.address]);
             return [
-                (0, viem_1.encodeFunctionData)({
-                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                encodeFunctionData({
+                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
                     functionName: 'installModule',
                     args: [module.type, module.address, initData],
                 }),
-                (0, viem_1.encodeFunctionData)({
-                    abi: (0, viem_1.parseAbi)(['function grantAccess(bytes21,bytes4,bool)']),
+                encodeFunctionData({
+                    abi: parseAbi(['function grantAccess(bytes21,bytes4,bool)']),
                     functionName: 'grantAccess',
                     args: [validatorId, '0xe9ae5c53', true],
                 }),
             ];
         }
-        case common_1.MODULE_TYPE_ID_EXECUTOR: {
-            const data = (0, viem_1.encodeAbiParameters)([{ type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x']);
-            const initData = (0, viem_1.concat)([viem_1.zeroAddress, data]);
+        case MODULE_TYPE_ID_EXECUTOR: {
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x']);
+            const initData = concat([zeroAddress, data]);
             return [
-                (0, viem_1.encodeFunctionData)({
-                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                encodeFunctionData({
+                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
                     functionName: 'installModule',
                     args: [module.type, module.address, initData],
                 }),
             ];
         }
-        case common_1.MODULE_TYPE_ID_FALLBACK: {
-            const [selector, flags, selectorData] = (0, viem_1.decodeAbiParameters)([
+        case MODULE_TYPE_ID_FALLBACK: {
+            const [selector, flags, selectorData] = decodeAbiParameters([
                 { name: 'selector', type: 'bytes4' },
                 { name: 'flags', type: 'bytes1' },
                 { name: 'data', type: 'bytes' },
             ], module.initData);
-            const data = (0, viem_1.encodeAbiParameters)([{ type: 'bytes' }, { type: 'bytes' }], [(0, viem_1.concat)([flags, selectorData]), '0x']);
-            const initData = (0, viem_1.concat)([selector, HOOK_INSTALLED_ADDRESS, data]);
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [concat([flags, selectorData]), '0x']);
+            const initData = concat([selector, HOOK_INSTALLED_ADDRESS, data]);
             return [
-                (0, viem_1.encodeFunctionData)({
-                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                encodeFunctionData({
+                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
                     functionName: 'installModule',
                     args: [module.type, module.address, initData],
                 }),
             ];
         }
-        case common_1.MODULE_TYPE_ID_HOOK: {
+        case MODULE_TYPE_ID_HOOK: {
             return [
-                (0, viem_1.encodeFunctionData)({
-                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                encodeFunctionData({
+                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
                     functionName: 'installModule',
                     args: [module.type, module.address, module.initData],
                 }),
@@ -176,9 +166,9 @@ function getInstallData(module) {
     }
 }
 async function packSignature(signature, validator, transformSignature = (signature) => signature) {
-    const vId = validator.isRoot ? '0x00' : (0, viem_1.concat)(['0x01', validator.address]);
-    const magicValueSigReplayable = (0, viem_1.keccak256)((0, viem_1.toHex)('kernel.replayable.signature'));
-    const packedSig = (0, viem_1.concat)([
+    const vId = validator.isRoot ? '0x00' : concat(['0x01', validator.address]);
+    const magicValueSigReplayable = keccak256(toHex('kernel.replayable.signature'));
+    const packedSig = concat([
         vId,
         magicValueSigReplayable,
         transformSignature(signature),
@@ -186,7 +176,7 @@ async function packSignature(signature, validator, transformSignature = (signatu
     return packedSig;
 }
 function wrapMessageHash(messageHash, accountAddress) {
-    const _domainSeparator = (0, viem_1.domainSeparator)({
+    const _domainSeparator = domainSeparator({
         domain: {
             name: 'Kernel',
             version: KERNEL_VERSION,
@@ -194,36 +184,36 @@ function wrapMessageHash(messageHash, accountAddress) {
             verifyingContract: accountAddress,
         },
     });
-    const kernelTypeHash = (0, viem_1.keccak256)((0, viem_1.stringToHex)('Kernel(bytes32 hash)'));
-    const wrappedMessageHash = (0, viem_1.keccak256)((0, viem_1.encodeAbiParameters)([{ type: 'bytes32' }, { type: 'bytes32' }], [kernelTypeHash, messageHash]));
-    const digest = (0, viem_1.keccak256)((0, viem_1.concatHex)(['0x1901', _domainSeparator, wrappedMessageHash]));
+    const kernelTypeHash = keccak256(stringToHex('Kernel(bytes32 hash)'));
+    const wrappedMessageHash = keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [kernelTypeHash, messageHash]));
+    const digest = keccak256(concatHex(['0x1901', _domainSeparator, wrappedMessageHash]));
     return digest;
 }
 async function getSmartAccount(client, address, owners, validatorAddress, sign) {
     return getBaseSmartAccount(address, client, validatorAddress, 'root', async () => {
-        return (0, validators_1.getMockSignature)(owners);
+        return getMockSignature(owners);
     }, sign);
 }
 async function getGuardianSmartAccount(client, address, guardians, validatorAddress, sign) {
     return await getBaseSmartAccount(address, client, validatorAddress, 'validator', async () => {
-        return (0, validators_1.getMockSignature)(guardians);
+        return getMockSignature(guardians);
     }, async (hash) => {
         return await sign(hash);
     });
 }
 async function getBaseSmartAccount(address, client, validatorAddress, validatorType, getStubSignature, signUserOperation) {
-    return await (0, account_abstraction_1.toSmartAccount)({
+    return await toSmartAccount({
         client,
         entryPoint: {
-            abi: account_abstraction_1.entryPoint07Abi,
-            address: account_abstraction_1.entryPoint07Address,
+            abi: entryPoint07Abi,
+            address: entryPoint07Address,
             version: '0.7',
         },
         async decodeCalls() {
             throw new Error('Not implemented');
         },
         async encodeCalls(calls) {
-            return (0, utils_1.encode7579Calls)({
+            return encode7579Calls({
                 mode: {
                     type: calls.length > 1 ? 'batchcall' : 'call',
                     revertOnError: false,
@@ -245,10 +235,10 @@ async function getBaseSmartAccount(address, client, validatorAddress, validatorT
             const type = validatorType === 'root' ? '0x00' : '0x01';
             const identifier = validatorAddress;
             const nonceKey = '0x0000';
-            const key = (0, viem_1.concat)([mode, type, identifier, nonceKey]);
-            return (0, utils_1.getAccountNonce)(client, {
+            const key = concat([mode, type, identifier, nonceKey]);
+            return getAccountNonce(client, {
                 address,
-                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointAddress: entryPoint07Address,
                 key: BigInt(key),
             });
         },
@@ -265,13 +255,13 @@ async function getBaseSmartAccount(address, client, validatorAddress, validatorT
             const { chainId = client.chain?.id, ...userOperation } = parameters;
             if (!chainId)
                 throw new Error('Chain id not found');
-            const hash = (0, account_abstraction_1.getUserOperationHash)({
+            const hash = getUserOperationHash({
                 userOperation: {
                     ...userOperation,
                     sender: userOperation.sender ?? (await this.getAddress()),
                     signature: '0x',
                 },
-                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointAddress: entryPoint07Address,
                 entryPointVersion: '0.7',
                 chainId: chainId,
             });
@@ -279,3 +269,4 @@ async function getBaseSmartAccount(address, client, validatorAddress, validatorT
         },
     });
 }
+export { getEip712Domain, getInstallData, getAddress, getDeployArgs, getSmartAccount, getGuardianSmartAccount, packSignature, wrapMessageHash, };

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

@@ -1,8 +1,8 @@
 import type { Abi, Account, Address, Chain, Hex, PublicClient } from 'viem';
 import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
-import type { Module } from '../modules/common';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types';
-import { type ValidatorConfig } from './utils';
+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): {
     salt: `0x${string}`;
     factory: `0x${string}`;