@charterlabs/rhinestone-sdk 0.1.1 → 0.1.2

package/dist/src/accounts/index.js

@@ -0,0 +1,469 @@
+"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.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.getSmartAccount = getSmartAccount;
+exports.getSmartSessionSmartAccount = getSmartSessionSmartAccount;
+exports.getGuardianSmartAccount = getGuardianSmartAccount;
+exports.getPackedSignature = getPackedSignature;
+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 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; } });
+Object.defineProperty(exports, "Eip7702NotSupportedForAccountError", { enumerable: true, get: function () { return error_1.Eip7702NotSupportedForAccountError; } });
+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, "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; } });
+const kernel_1 = require("./kernel");
+const nexus_1 = require("./nexus");
+const safe_1 = require("./safe");
+const startale_1 = require("./startale");
+const utils_1 = require("./utils");
+function getDeployArgs(config) {
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getDeployArgs)(config);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getDeployArgs)(config);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getDeployArgs)(config);
+        }
+        case 'startale': {
+            return (0, startale_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}`);
+        }
+    }
+}
+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}`);
+        }
+    }
+}
+function getModuleInstallationCalls(config, module) {
+    const address = getAddress(config);
+    function getInstallData() {
+        const account = getAccountProvider(config);
+        switch (account.type) {
+            case 'safe': {
+                return [(0, safe_1.getInstallData)(module)];
+            }
+            case 'nexus': {
+                return [(0, nexus_1.getInstallData)(module)];
+            }
+            case 'kernel': {
+                return (0, kernel_1.getInstallData)(module);
+            }
+            case 'startale': {
+                return [(0, startale_1.getInstallData)(module)];
+            }
+        }
+    }
+    const installData = getInstallData();
+    return installData.map((data) => ({
+        to: address,
+        value: 0n,
+        data,
+    }));
+}
+function getModuleUninstallationCalls(config, module) {
+    const address = getAddress(config);
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: [
+            {
+                type: 'function',
+                name: 'uninstallModule',
+                inputs: [
+                    {
+                        type: 'uint256',
+                        name: 'moduleTypeId',
+                    },
+                    {
+                        type: 'address',
+                        name: 'module',
+                    },
+                    {
+                        type: 'bytes',
+                        name: 'deInitData',
+                    },
+                ],
+                outputs: [],
+                stateMutability: 'nonpayable',
+            },
+        ],
+        functionName: 'uninstallModule',
+        args: [module.type, module.address, module.deInitData],
+    });
+    return [{ to: address, data, value: 0n }];
+}
+function getAddress(config) {
+    if (is7702(config)) {
+        if (!config.eoa) {
+            throw new error_1.Eip7702AccountMustHaveEoaError();
+        }
+        return config.eoa.address;
+    }
+    const account = getAccountProvider(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getAddress)(config);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getAddress)(config);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getAddress)(config);
+        }
+        case 'startale': {
+            return (0, startale_1.getAddress)(config);
+        }
+    }
+}
+// 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);
+    const account = getAccountProvider(config);
+    const address = getAddress(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getPackedSignature)(signFn, hash, validator, address, transformSignature);
+        }
+        case 'startale': {
+            return (0, startale_1.getPackedSignature)(signFn, hash, validator, transformSignature);
+        }
+    }
+}
+async function isDeployed(chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const address = getAddress(config);
+    const code = await publicClient.getCode({
+        address,
+    });
+    if (!code) {
+        return false;
+    }
+    if (code.startsWith('0xef0100') && code.length === 48) {
+        // Defensive check to ensure there's no storage conflict; can be lifted in the future
+        throw new error_1.ExistingEip7702AccountsNotSupportedError();
+    }
+    return (0, viem_1.size)(code) > 0;
+}
+async function deploy(config, chain, session) {
+    await deployWithIntent(chain, config);
+    if (session) {
+        await (0, smart_session_1.enableSmartSession)(chain, config, session);
+    }
+}
+async function deployWithIntent(chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, utils_1.createTransport)(chain, config.provider),
+    });
+    const address = getAddress(config);
+    const code = await publicClient.getCode({ address });
+    if (code) {
+        // Already deployed
+        return;
+    }
+    await (0, execution_1.sendTransaction)(config, {
+        targetChain: chain,
+        calls: [
+            {
+                to: viem_1.zeroAddress,
+                data: '0x',
+            },
+        ],
+    });
+}
+async function getSmartAccount(config, client, chain) {
+    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);
+    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);
+        }
+        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);
+        }
+    }
+}
+async function getSmartSessionSmartAccount(config, client, chain, session, enableData) {
+    const address = getAddress(config);
+    const smartSessionValidator = (0, validators_1.getSmartSessionValidator)(config);
+    if (!smartSessionValidator) {
+        throw new error_1.SmartSessionsNotEnabledError();
+    }
+    const signers = {
+        type: 'session',
+        session,
+        enableData: enableData || undefined,
+    };
+    const signFn = (hash) => sign(signers, chain, hash);
+    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);
+        }
+        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);
+        }
+    }
+}
+async function getGuardianSmartAccount(config, client, chain, guardians) {
+    const address = getAddress(config);
+    const accounts = guardians.type === 'ecdsa' ? guardians.accounts : [];
+    const socialRecoveryValidator = (0, core_1.getSocialRecoveryValidator)(accounts);
+    if (!socialRecoveryValidator) {
+        throw new Error('Social recovery is not available');
+    }
+    const signers = {
+        type: 'guardians',
+        guardians: accounts,
+    };
+    const signFn = (hash) => sign(signers, chain, hash);
+    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);
+        }
+        case 'kernel': {
+            return (0, kernel_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
+        }
+        case 'startale': {
+            return (0, startale_1.getGuardianSmartAccount)(client, address, guardians, socialRecoveryValidator.address, signFn);
+        }
+    }
+}
+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': {
+                    // Convert OwnerSignerSet to WebauthnValidatorConfig
+                    const webAuthnConfig = {
+                        type: 'passkey',
+                        account: signers.account,
+                        credentialIds: [] // This should be passed from config
+                    };
+                    return await signPasskey(webAuthnConfig, chain, hash);
+                }
+                case 'multi-factor': {
+                    const signatures = await Promise.all(signers.validators.map(async (validator) => {
+                        if (validator === null) {
+                            return '0x';
+                        }
+                        // Convert to proper validator format
+                        const validatorConfig = validator.type === 'ecdsa'
+                            ? { type: 'ecdsa', accounts: validator.accounts, threshold: 1 }
+                            : { type: 'passkey', account: validator.account, credentialIds: [] };
+                        const validatorSigners = convertOwnerSetToSignerSet(validatorConfig);
+                        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) => {
+                            // Convert to proper validator format for getValidator
+                            const validatorConfig = validator.type === 'ecdsa'
+                                ? { type: 'ecdsa', accounts: validator.accounts, threshold: 1 }
+                                : { type: 'passkey', account: validator.account, credentialIds: [] };
+                            const validatorModule = (0, core_1.getValidator)(validatorConfig);
+                            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(validators, chain, hash) {
+    const { account, credentialIds } = validators;
+    const { webauthn: rawWebauthn, signature } = await account.sign({ hash });
+    const { authenticatorData, clientDataJSON, challengeIndex, typeIndex } = rawWebauthn;
+    const usePrecompiled = (0, modules_1.isRip7212SupportedNetwork)(chain);
+    return (0, modules_1.getWebauthnValidatorSignature)({
+        credentialIds,
+        usePrecompiled,
+        webauthn: { authenticatorData, clientDataJSON, challengeIndex, typeIndex },
+        signature,
+    });
+}
+function is7702(config) {
+    return config.eoa !== undefined;
+}
+function getAccountProvider(config) {
+    if (config.account) {
+        return config.account;
+    }
+    return {
+        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.d.ts

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

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

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

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const _1 = require(".");
+(0, vitest_1.describe)('Accounts', () => {
+    (0, vitest_1.describe)('Get Address', () => {
+        (0, vitest_1.test)('Nexus, ECDSA owner', () => {
+            const address = (0, _1.getAddress)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                    threshold: 1,
+                },
+                rhinestoneApiKey: consts_1.MOCK_API_KEY,
+            });
+            (0, vitest_1.expect)(address).toEqual('0xa32fa78416f6c68ce4f75f702e07849a269feffb');
+        });
+        (0, vitest_1.test)('Safe, passkey owner with a session', () => {
+            const address = (0, _1.getAddress)({
+                owners: {
+                    type: 'passkey',
+                    account: consts_1.passkeyAccount,
+                    credentialIds: ['0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef'],
+                },
+                rhinestoneApiKey: consts_1.MOCK_API_KEY,
+            });
+            (0, vitest_1.expect)(address).toEqual('0xfbda4e576b2a300cd1b7e8748c9a7577ab3a503e');
+        });
+    });
+    (0, vitest_1.describe)('Sign', () => {
+        vitest_1.test.todo('With ECDSA, single key');
+        vitest_1.test.todo('With ECDSA, multisig');
+        vitest_1.test.todo('With Passkey');
+    });
+});

package/dist/{accounts → 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,9 @@ 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 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, getPackedSignature, };
 //# 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,EAQZ,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;AAQ1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAC7E,OAAO,KAAK,EAAE,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAC1E,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAgBhF,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;EA4CrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBASlD;AAED,iBAAS,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,EAAE,CAsE7C;AAED,iBAAe,kBAAkB,CAC/B,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACtC,IAAI,EAAE,GAAG,EACT,SAAS,EAAE,eAAe,EAC1B,cAAc,EAAE,OAAO,EACvB,kBAAkB,GAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAA8B,0BAevE;AAwBD,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,sBAAsB,CACnC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,OAAO,EACzB,UAAU,EAAE,iBAAiB,GAAG,IAAI,EACpC,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEA0ClC;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,cAAc,EACd,UAAU,EACV,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACvB,kBAAkB,GACnB,CAAA"}

package/dist/{accounts → src/accounts}/kernel.js

@@ -6,8 +6,6 @@ exports.getDeployArgs = getDeployArgs;
 exports.getSmartAccount = getSmartAccount;
 exports.getSessionSmartAccount = getSessionSmartAccount;
 exports.getGuardianSmartAccount = getGuardianSmartAccount;
-exports.get7702InitCalls = get7702InitCalls;
-exports.get7702SmartAccount = get7702SmartAccount;
 exports.getPackedSignature = getPackedSignature;
 const viem_1 = require("viem");
 const account_abstraction_1 = require("viem/account-abstraction");
@@ -128,12 +126,6 @@ function getInstallData(module) {
         }
     }
 }
-function get7702InitCalls() {
-    throw new Error('EIP-7702 is not yet supported for Kernel accounts');
-}
-function get7702SmartAccount() {
-    throw new Error('EIP-7702 is not yet supported for Kernel accounts');
-}
 async function getPackedSignature(signFn, hash, validator, accountAddress, transformSignature = (signature) => signature) {
     const vId = validator.isRoot ? '0x00' : (0, viem_1.concat)(['0x01', validator.address]);
     const signature = validator.isRoot

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":""}