@rhinestone/sdk 0.0.0-dev-20260204114155

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

@@ -0,0 +1,20 @@
+"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);
+        }
+        case 'custom': {
+            const customUrl = (0, providers_1.getCustomUrl)(chain.id, provider.urls);
+            return (0, viem_1.http)(customUrl);
+        }
+    }
+}

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,33 @@
+"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();
+        });
+        (0, vitest_1.test)('Custom', () => {
+            const transport = (0, index_1.createTransport)(chains_1.mainnet, {
+                type: 'custom',
+                urls: {
+                    [chains_1.mainnet.id]: 'https://my-rpc.example.com',
+                },
+            });
+            (0, vitest_1.expect)(transport).toBeDefined();
+        });
+        (0, vitest_1.test)('Custom throws error when URL not configured for chain', () => {
+            (0, vitest_1.expect)(() => (0, index_1.createTransport)(chains_1.mainnet, {
+                type: 'custom',
+                urls: {
+                    [chains_1.base.id]: 'https://my-rpc.example.com',
+                },
+            })).toThrow('No custom provider URL configured for chain 1');
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+import type { SupportedChain } from '../../orchestrator';
+declare function getAlchemyUrl(chainId: SupportedChain, apiKey: string): string;
+declare function getCustomUrl(chainId: number, urls: Record<number, string>): string;
+export { getAlchemyUrl, getCustomUrl };
+//# 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,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAM3E;AAED,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,CAAA"}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlchemyUrl = getAlchemyUrl;
+exports.getCustomUrl = getCustomUrl;
+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);
+}
+function getCustomUrl(chainId, urls) {
+    const url = urls[chainId];
+    if (!url) {
+        throw new Error(`No custom provider URL configured for chain ${chainId}`);
+    }
+    return url;
+}

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,43 @@
+"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.arbitrum.id, mockApiKey)).toBe('https://arb-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');
+        });
+    });
+    (0, vitest_1.describe)('Custom', () => {
+        (0, vitest_1.test)('Returns URL for configured chain', () => {
+            const urls = {
+                [chains_1.arbitrum.id]: 'https://my-rpc.example.com/mainnet',
+                [chains_1.sepolia.id]: 'https://my-rpc.example.com/sepolia',
+            };
+            (0, vitest_1.expect)((0, providers_1.getCustomUrl)(chains_1.arbitrum.id, urls)).toBe('https://my-rpc.example.com/mainnet');
+            (0, vitest_1.expect)((0, providers_1.getCustomUrl)(chains_1.sepolia.id, urls)).toBe('https://my-rpc.example.com/sepolia');
+        });
+        (0, vitest_1.test)('Throws error when chain not configured', () => {
+            const urls = {
+                [chains_1.arbitrum.id]: 'https://my-rpc.example.com/mainnet',
+            };
+            (0, vitest_1.expect)(() => (0, providers_1.getCustomUrl)(chains_1.sepolia.id, urls)).toThrow('No custom provider URL configured for chain 11155111');
+        });
+        (0, vitest_1.test)('Accepts HTTP URLs', () => {
+            const urls = {
+                [chains_1.arbitrum.id]: 'http://localhost:8545',
+            };
+            (0, vitest_1.expect)((0, providers_1.getCustomUrl)(chains_1.arbitrum.id, urls)).toBe('http://localhost:8545');
+        });
+        (0, vitest_1.test)('Accepts HTTPS URLs', () => {
+            const urls = {
+                [chains_1.arbitrum.id]: 'https://my-rpc.example.com',
+            };
+            (0, vitest_1.expect)((0, providers_1.getCustomUrl)(chains_1.arbitrum.id, urls)).toBe('https://my-rpc.example.com');
+        });
+    });
+});

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

@@ -0,0 +1,27 @@
+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';
+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

@@ -0,0 +1 @@
+{"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"}

package/dist/src/accounts/kernel.js

@@ -0,0 +1,281 @@
+"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");
+const KERNEL_META_FACTORY_ADDRESS = '0xd703aae79538628d27099b8c4f621be4ccd142d5';
+const KERNEL_IMPLEMENTATION_ADDRESS = '0xd6CEDDe84be40893d153Be9d467CD6aD37875b28';
+const KERNEL_FACTORY_ADDRESS = '0x2577507b78c2008Ff367261CB6285d44ba5eF2E9';
+const KERNEL_BYTECODE = '0x603d3d8160223d3973d6cedde84be40893d153be9d467cd6ad37875b2860095155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3';
+const KERNEL_VERSION = '0.3.3';
+function getDeployArgs(config) {
+    if (config.initData) {
+        if (!('factory' in config.initData)) {
+            return null;
+        }
+        const factoryData = (0, viem_1.decodeFunctionData)({
+            abi: (0, viem_1.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');
+        }
+        const factory = factoryData.args[0];
+        const createData = factoryData.args[1];
+        const salt = factoryData.args[2];
+        const implementation = factory === KERNEL_FACTORY_ADDRESS
+            ? KERNEL_IMPLEMENTATION_ADDRESS
+            : viem_1.zeroAddress;
+        if (implementation === viem_1.zeroAddress) {
+            throw new error_1.AccountConfigurationNotSupportedError('Unsupported Kernel implementation', 'kernel');
+        }
+        return {
+            factory: config.initData.factory,
+            factoryData: config.initData.factoryData,
+            implementation,
+            initializationCallData: createData,
+            salt,
+        };
+    }
+    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 validatorData = moduleSetup.validators[0].initData;
+    const hookData = '0x';
+    // Install modules via init config
+    const spareValidators = moduleSetup.validators.slice(1);
+    const initConfig = [];
+    for (const module of spareValidators) {
+        initConfig.push(...getInstallData(module));
+    }
+    for (const module of moduleSetup.executors) {
+        initConfig.push(...getInstallData(module));
+    }
+    for (const module of moduleSetup.fallbacks) {
+        initConfig.push(...getInstallData(module));
+    }
+    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[])']),
+        functionName: 'initialize',
+        args: [rootValidator, hook, validatorData, hookData, initConfig],
+    });
+    const factoryData = (0, viem_1.encodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(['function deployWithFactory(address,bytes,bytes32)']),
+        functionName: 'deployWithFactory',
+        args: [KERNEL_FACTORY_ADDRESS, initializationCallData, salt],
+    });
+    return {
+        factory: KERNEL_META_FACTORY_ADDRESS,
+        factoryData,
+        salt,
+        implementation: KERNEL_IMPLEMENTATION_ADDRESS,
+        initializationCallData,
+    };
+}
+function getAddress(config) {
+    const deployArgs = getDeployArgs(config);
+    if (!deployArgs) {
+        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)({
+        from: KERNEL_FACTORY_ADDRESS,
+        opcode: 'CREATE2',
+        bytecode: KERNEL_BYTECODE,
+        salt: actualSalt,
+    });
+}
+function getEip712Domain(config, chain) {
+    if (config.initData) {
+        throw new error_1.Eip712DomainNotAvailableError('Existing Kernel accounts are not yet supported');
+    }
+    return {
+        name: 'Kernel',
+        version: KERNEL_VERSION,
+        chainId: chain.id,
+        verifyingContract: getAddress(config),
+        salt: viem_1.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]);
+            return [
+                (0, viem_1.encodeFunctionData)({
+                    abi: (0, viem_1.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)']),
+                    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]);
+            return [
+                (0, viem_1.encodeFunctionData)({
+                    abi: (0, viem_1.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)([
+                { 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]);
+            return [
+                (0, viem_1.encodeFunctionData)({
+                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                    functionName: 'installModule',
+                    args: [module.type, module.address, initData],
+                }),
+            ];
+        }
+        case common_1.MODULE_TYPE_ID_HOOK: {
+            return [
+                (0, viem_1.encodeFunctionData)({
+                    abi: (0, viem_1.parseAbi)(['function installModule(uint256,address,bytes)']),
+                    functionName: 'installModule',
+                    args: [module.type, module.address, module.initData],
+                }),
+            ];
+        }
+    }
+}
+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)([
+        vId,
+        magicValueSigReplayable,
+        transformSignature(signature),
+    ]);
+    return packedSig;
+}
+function wrapMessageHash(messageHash, accountAddress) {
+    const _domainSeparator = (0, viem_1.domainSeparator)({
+        domain: {
+            name: 'Kernel',
+            version: KERNEL_VERSION,
+            chainId: 0,
+            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]));
+    return digest;
+}
+async function getSmartAccount(client, address, owners, validatorAddress, sign) {
+    return getBaseSmartAccount(address, client, validatorAddress, 'root', async () => {
+        return (0, validators_1.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);
+    }, async (hash) => {
+        return await sign(hash);
+    });
+}
+async function getBaseSmartAccount(address, client, validatorAddress, validatorType, getStubSignature, signUserOperation) {
+    return await (0, account_abstraction_1.toSmartAccount)({
+        client,
+        entryPoint: {
+            abi: account_abstraction_1.entryPoint07Abi,
+            address: account_abstraction_1.entryPoint07Address,
+            version: '0.7',
+        },
+        async decodeCalls() {
+            throw new Error('Not implemented');
+        },
+        async encodeCalls(calls) {
+            return (0, utils_1.encode7579Calls)({
+                mode: {
+                    type: calls.length > 1 ? 'batchcall' : 'call',
+                    revertOnError: false,
+                    selector: '0x',
+                    context: '0x',
+                },
+                callData: calls,
+            });
+        },
+        async getAddress() {
+            return address;
+        },
+        async getFactoryArgs() {
+            return {};
+        },
+        async getNonce() {
+            // Default mode
+            const mode = '0x00';
+            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, {
+                address,
+                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                key: BigInt(key),
+            });
+        },
+        async getStubSignature() {
+            return getStubSignature();
+        },
+        async signMessage() {
+            throw new Error('Not implemented');
+        },
+        async signTypedData() {
+            throw new Error('Not implemented');
+        },
+        async signUserOperation(parameters) {
+            const { chainId = client.chain?.id, ...userOperation } = parameters;
+            if (!chainId)
+                throw new Error('Chain id not found');
+            const hash = (0, account_abstraction_1.getUserOperationHash)({
+                userOperation: {
+                    ...userOperation,
+                    sender: userOperation.sender ?? (await this.getAddress()),
+                    signature: '0x',
+                },
+                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointVersion: '0.7',
+                chainId: chainId,
+            });
+            return await signUserOperation(hash);
+        },
+    });
+}

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

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

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

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

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const utils_1 = require("../../test/utils/utils");
+const common_1 = require("../modules/common");
+const kernel_1 = require("./kernel");
+const MOCK_MODULE_ADDRESS = '0x28de6501fa86f2e6cd0b33c3aabdaeb4a1b93f3f';
+(0, vitest_1.describe)('Accounts: Kernel', () => {
+    (0, vitest_1.describe)('Deploy Args', () => {
+        (0, vitest_1.test)('ECDSA owners', () => {
+            const deployArgs = (0, kernel_1.getDeployArgs)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+            });
+            (0, utils_1.assertNotNull)(deployArgs);
+            const { factory, factoryData, salt, implementation, initializationCallData, } = deployArgs;
+            (0, vitest_1.expect)(factory).toEqual('0xd703aae79538628d27099b8c4f621be4ccd142d5');
+            (0, vitest_1.expect)(factoryData).toEqual('0xc5265d5d0000000000000000000000002577507b78c2008ff367261cb6285d44ba5ef2e90000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003243c3b752b01000000000013fdb5234e4e3162a810f54d9f7e980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da09948693600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001249517e29f000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000094000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(salt).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(implementation).toEqual('0xd6CEDDe84be40893d153Be9d467CD6aD37875b28');
+            (0, vitest_1.expect)(initializationCallData).toEqual('0x3c3b752b01000000000013fdb5234e4e3162a810f54d9f7e980000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da09948693600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001249517e29f000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+        });
+        (0, vitest_1.test)('Passkey owner', () => {
+            const deployArgs = (0, kernel_1.getDeployArgs)({
+                owners: {
+                    type: 'passkey',
+                    accounts: [consts_1.passkeyAccount],
+                },
+            });
+            (0, utils_1.assertNotNull)(deployArgs);
+            const { factory, factoryData, salt, implementation, initializationCallData, } = deployArgs;
+            (0, vitest_1.expect)(factory).toEqual('0xd703aae79538628d27099b8c4f621be4ccd142d5');
+            (0, vitest_1.expect)(factoryData).toEqual('0xc5265d5d0000000000000000000000002577507b78c2008ff367261cb6285d44ba5ef2e90000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003443c3b752b010000000000578c4cb0e472a5462da43c495c3f330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001249517e29f000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000094000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(salt).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(implementation).toEqual('0xd6CEDDe84be40893d153Be9d467CD6aD37875b28');
+            (0, vitest_1.expect)(initializationCallData).toEqual('0x3c3b752b010000000000578c4cb0e472a5462da43c495c3f330000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001249517e29f000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000940000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+        });
+        (0, vitest_1.test)('Existing account', () => {
+            const deployArgs = (0, kernel_1.getDeployArgs)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+                initData: {
+                    address: '0x86c4b9c9eA5df80D4e080e285015Cda47A503B51',
+                    factory: '0xd703aaE79538628d27099B8c4f621bE4CCd142d5',
+                    factoryData: '0xc5265d5d0000000000000000000000002577507b78c2008ff367261cb6285d44ba5ef2e90000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001243c3b752b01845ADb2C711129d4f3966735eD98a9F09fC4cE570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001460098F8D98a9c55F21D17C26c78bF3D71Edc0E740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+                    intentExecutorInstalled: false,
+                },
+            });
+            (0, utils_1.assertNotNull)(deployArgs);
+            const { factory, factoryData } = deployArgs;
+            (0, vitest_1.expect)(factory).toEqual('0xd703aaE79538628d27099B8c4f621bE4CCd142d5');
+            (0, vitest_1.expect)(factoryData).toEqual('0xc5265d5d0000000000000000000000002577507b78c2008ff367261cb6285d44ba5ef2e90000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001243c3b752b01845ADb2C711129d4f3966735eD98a9F09fC4cE570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001460098F8D98a9c55F21D17C26c78bF3D71Edc0E740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+    (0, vitest_1.describe)('Get Address', () => {
+        (0, vitest_1.test)('ECDSA owners', () => {
+            const address = (0, kernel_1.getAddress)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0xC3733a544f5246a25405c7446e4D0C6b5762B22e');
+        });
+        (0, vitest_1.test)('Passkey owner', () => {
+            const address = (0, kernel_1.getAddress)({
+                owners: {
+                    type: 'passkey',
+                    accounts: [consts_1.passkeyAccount],
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0xE48268B1C69528366d8eFaC5DB6fA947a7B52E55');
+        });
+        (0, vitest_1.test)('Existing account', () => {
+            const address = (0, kernel_1.getAddress)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+                initData: {
+                    address: '0x86c4b9c9eA5df80D4e080e285015Cda47A503B51',
+                    factory: '0xd703aaE79538628d27099B8c4f621bE4CCd142d5',
+                    factoryData: '0xc5265d5d0000000000000000000000002577507b78c2008ff367261cb6285d44ba5ef2e90000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001243c3b752b01845ADb2C711129d4f3966735eD98a9F09fC4cE570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000001460098F8D98a9c55F21D17C26c78bF3D71Edc0E740000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+                    intentExecutorInstalled: false,
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0x86c4b9c9eA5df80D4e080e285015Cda47A503B51');
+        });
+    });
+    (0, vitest_1.describe)('Get Install Data', () => {
+        (0, vitest_1.test)('Module', () => {
+            const installData = (0, kernel_1.getInstallData)({
+                address: MOCK_MODULE_ADDRESS,
+                initData: '0xabcd',
+                type: common_1.MODULE_TYPE_ID_VALIDATOR,
+                deInitData: '0x0000',
+                additionalContext: '0x0000',
+            });
+            (0, vitest_1.expect)(installData).toEqual([
+                '0x9517e29f000000000000000000000000000000000000000000000000000000000000000100000000000000000000000028de6501fa86f2e6cd0b33c3aabdaeb4a1b93f3f000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000f40000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000002abcd00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+                '0xb9b829410128de6501fa86f2e6cd0b33c3aabdaeb4a1b93f3f0000000000000000000000e9ae5c53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001',
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Get Packed Signature', () => {
+        (0, vitest_1.describe)('Mock signature', () => {
+            (0, vitest_1.test)('Root validator', async () => {
+                const mockSignature = '0x1234';
+                const validator = {
+                    address: '0xe35b75e5ec3c04e9cefa8e581fbee859f56edeb4',
+                    isRoot: true,
+                };
+                const signature = await (0, kernel_1.packSignature)(mockSignature, validator);
+                (0, vitest_1.expect)(signature).toEqual('0x000555ad2729e8da1777a4e5020806f8bf7601c3db6bfe402f410a34958363a95a1234');
+            });
+            (0, vitest_1.test)('Non-root validator', async () => {
+                const mockSignature = '0x1234';
+                const validator = {
+                    address: '0xe35b75e5ec3c04e9cefa8e581fbee859f56edeb4',
+                    isRoot: false,
+                };
+                const signature = await (0, kernel_1.packSignature)(mockSignature, validator);
+                (0, vitest_1.expect)(signature).toEqual('0x01e35b75e5ec3c04e9cefa8e581fbee859f56edeb40555ad2729e8da1777a4e5020806f8bf7601c3db6bfe402f410a34958363a95a1234');
+            });
+        });
+    });
+});