@rhinestone/sdk 0.0.0-dev-20260723231959 → 0.0.0-dev-20260724131100

package/README.md

@@ -138,12 +138,12 @@ const account = await rhinestone.createAccount({
 Send a crosschain transaction:
 
 ```ts
-const transaction = await account.sendTransaction({
+const prepared = await account.prepareTransaction({
   sourceChains: [baseSepolia],
   targetChain: arbitrumSepolia,
   calls: [
     {
-      to: 'USDC',
+      to: usdc,
       value: 0n,
       data: encodeFunctionData({
         abi: erc20Abi,
@@ -152,17 +152,58 @@ const transaction = await account.sendTransaction({
       }),
     },
   ],
-  tokenRequests: [{ address: 'USDC', amount }],
+  tokenRequests: [{ address: usdc, amount }],
 })
 
+const signed = await account.signTransaction(prepared)
+const transaction = await account.submitTransaction(signed)
 const result = await account.waitForExecution(transaction)
 ```
 
+Create a smart session from ABI-driven permissions:
+
+```ts
+import { toSession } from '@rhinestone/sdk/smart-sessions'
+
+const session = toSession({
+  chain: base,
+  owners: {
+    type: 'ecdsa',
+    accounts: [sessionSigner],
+  },
+  permissions: [
+    {
+      abi: erc20Abi,
+      address: usdc,
+      functions: {
+        transfer: {
+          params: {
+            recipient: { condition: 'equal', value: recipient },
+            amount: { condition: 'lessThanOrEqual', value: 1000n },
+          },
+        },
+      },
+    },
+  ],
+  claimPolicies: [
+    {
+      type: 'permit2',
+      spenders: [permit2Spender],
+      sourceTokens: [{ chain: base, address: usdc }],
+      destinationTokens: [{ chain: optimism, address: usdc }],
+      recipients: [{ chain: optimism, address: recipient }],
+      permitDeadline: { max: permitDeadline },
+      fillDeadline: [{ chain: optimism, max: fillDeadline }],
+    },
+  ],
+})
+```
+
 For a complete walkthrough, see the [Quickstart guide](https://docs.rhinestone.dev/smart-wallet/quickstart).
 
 ## Migrating from Orchestrator SDK
 
-To migrate from the [Orchestrator SDK](https://github.com/rhinestonewtf/orchestrator-sdk), replace all imports of `@rhinestone/orchestrator-sdk` with `@rhinestone/sdk/orchestrator`.
+To migrate from the [Orchestrator SDK](https://github.com/rhinestonewtf/orchestrator-sdk), replace all imports of `@rhinestone/orchestrator-sdk` with `@rhinestone/sdk`.
 
 Let us know if you encounter any issues!
 

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

@@ -0,0 +1,31 @@
+import type { Hex } from 'viem';
+import type { EvmChainReference } from '../chains/types.js';
+import type { ResolvedModule } from '../modules/types.js';
+import type { AccountCallEncodingInput, AccountCapabilities, AccountConstruction, AccountDefinition, AccountDeploymentPlan, AccountEip7702AdoptionPlan, AccountIdentity, AccountSignatureEnvelope } from './types.js';
+export interface AccountSignatureEnvelopeInput {
+    readonly account: AccountIdentity;
+    readonly envelope: AccountSignatureEnvelope;
+    readonly validatorContribution: Hex;
+    readonly purpose: 'erc1271' | 'intent' | 'user-operation';
+}
+export interface AccountAdapter {
+    readonly account: AccountDefinition;
+    readonly capabilities: AccountCapabilities;
+    readonly getIdentity: (input: AccountConstruction) => AccountIdentity;
+    readonly getDeploymentPlan: (input: AccountConstruction) => AccountDeploymentPlan;
+    readonly getEip7702AdoptionPlan?: (input: AccountConstruction) => AccountEip7702AdoptionPlan;
+    readonly getEip7702InitCall?: (input: AccountConstruction, eip7702InitSignature: Hex) => Hex;
+    readonly encodeCalls: (input: AccountCallEncodingInput) => Hex;
+    readonly encodeModuleInstallation: (module: ResolvedModule) => readonly Hex[];
+    readonly encodeModuleUninstallation: (module: ResolvedModule) => Hex;
+    readonly encodeSignatureEnvelope: (input: AccountSignatureEnvelopeInput) => Hex;
+}
+export interface AccountRuntime {
+    readonly adapter: AccountAdapter;
+    readonly construction: AccountConstruction;
+    readonly identity: AccountIdentity;
+}
+export interface AccountRuntimePort {
+    readonly forChain: (chain: EvmChainReference) => Promise<AccountRuntime>;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/dist/src/accounts/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../accounts/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,0BAA0B,EAC1B,eAAe,EACf,wBAAwB,EACzB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAA;IACjC,QAAQ,CAAC,QAAQ,EAAE,wBAAwB,CAAA;IAC3C,QAAQ,CAAC,qBAAqB,EAAE,GAAG,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,SAAS,GAAG,QAAQ,GAAG,gBAAgB,CAAA;CAC1D;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAA;IAC1C,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,eAAe,CAAA;IACrE,QAAQ,CAAC,iBAAiB,EAAE,CAC1B,KAAK,EAAE,mBAAmB,KACvB,qBAAqB,CAAA;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,CAChC,KAAK,EAAE,mBAAmB,KACvB,0BAA0B,CAAA;IAK/B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAC5B,KAAK,EAAE,mBAAmB,EAC1B,oBAAoB,EAAE,GAAG,KACtB,GAAG,CAAA;IACR,QAAQ,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,GAAG,CAAA;IAC9D,QAAQ,CAAC,wBAAwB,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,SAAS,GAAG,EAAE,CAAA;IAC7E,QAAQ,CAAC,0BAA0B,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,GAAG,CAAA;IACpE,QAAQ,CAAC,uBAAuB,EAAE,CAChC,KAAK,EAAE,6BAA6B,KACjC,GAAG,CAAA;CACT;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAA;IAC1C,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,cAAc,CAAC,CAAA;CACzE"}

package/dist/src/accounts/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/src/accounts/adapters/eoa.d.ts

@@ -0,0 +1,4 @@
+import type { AccountAdapter } from '../adapter.js';
+import type { AccountConstruction } from '../types.js';
+export declare function createEoaAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=eoa.d.ts.map

package/dist/src/accounts/adapters/eoa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eoa.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/eoa.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAQnD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAmChB"}

package/dist/src/accounts/adapters/eoa.js

@@ -0,0 +1,45 @@
+import { deploymentPlan } from '../deployment.js';
+import { ModuleInstallationNotSupportedError } from '../error.js';
+function eoaAddress(input) {
+    if (input.account.kind !== 'eoa')
+        throw new Error('Expected EOA account');
+    if (!input.eoa)
+        throw new Error('EOA account is required');
+    return input.eoa.address;
+}
+export function createEoaAdapter(construction) {
+    if (construction.account.kind !== 'eoa') {
+        throw new Error('Expected EOA account');
+    }
+    return {
+        account: construction.account,
+        capabilities: {
+            modular: false,
+            supportsDeployment: false,
+            supportsUserOperations: false,
+            supportsEip7702Adoption: false,
+            supportsSmartSessions: false,
+            supportsOriginSignatureReuse: true,
+            signatureEnvelope: { kind: 'none' },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: eoaAddress(input),
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, { address: eoaAddress(input) }, true),
+        encodeCalls: () => {
+            throw new Error('EOA calls do not use ERC-7579 encoding');
+        },
+        encodeModuleInstallation: () => {
+            throw new ModuleInstallationNotSupportedError('eoa');
+        },
+        encodeModuleUninstallation: () => {
+            throw new ModuleInstallationNotSupportedError('eoa');
+        },
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'none')
+                throw new Error('Expected EOA envelope');
+            return validatorContribution;
+        },
+    };
+}

package/dist/src/accounts/adapters/hca.d.ts

@@ -0,0 +1,5 @@
+import type { AccountAdapter } from '../adapter.js';
+import type { AccountConstruction } from '../types.js';
+export declare const HCA_IMPLEMENTATION_ADDRESS: "0x7c2cC1e499a87ab480Df154e05164cD56D05d570";
+export declare function createHcaAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=hca.d.ts.map

package/dist/src/accounts/adapters/hca.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hca.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/hca.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAIhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAGnD,eAAO,MAAM,0BAA0B,EACrC,4CAAqD,CAAA;AAwFvD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAqChB"}

package/dist/src/accounts/adapters/hca.js

@@ -0,0 +1,118 @@
+import { concat, decodeAbiParameters, decodeFunctionData, encodeFunctionData, encodePacked, keccak256, pad, parseAbi, slice, } from 'viem';
+import { ENS_HCA_MODULE } from '../../modules/validators/ens.js';
+import { deploymentPlan } from '../deployment.js';
+import { encodeErc7579Calls } from '../erc7579-calls.js';
+import { ModuleInstallationNotSupportedError } from '../error.js';
+import { encodeAddressEnvelope } from './shared.js';
+export const HCA_IMPLEMENTATION_ADDRESS = '0x7c2cC1e499a87ab480Df154e05164cD56D05d570';
+const HCA_FACTORY_ADDRESS = '0x358680728dedb552adaa9f5eb5d4395b291cf943';
+const CREATE3_PROXY_HASH = '0x21c35dbe1b344a2488cf3321d6ce542f8e9f305544ff09e4993a62319a497c1f';
+function primaryOwner(factoryData) {
+    const decoded = decodeFunctionData({
+        abi: parseAbi(['function createAccount(bytes)']),
+        data: factoryData,
+    });
+    const [, owners] = decodeAbiParameters([
+        { type: 'uint256' },
+        {
+            type: 'tuple[]',
+            components: [
+                { name: 'addr', type: 'address' },
+                { name: 'expiration', type: 'uint48' },
+            ],
+        },
+    ], decoded.args[0]);
+    const owner = owners[0];
+    if (!owner)
+        throw new Error('HCA primary owner is required');
+    return owner.addr;
+}
+function predictCreate3Address(factory, owner) {
+    const salt = pad(owner, { size: 32, dir: 'right' });
+    const proxyHash = keccak256(encodePacked(['bytes1', 'address', 'bytes32', 'bytes32'], ['0xff', factory, salt, CREATE3_PROXY_HASH]));
+    const proxyAddress = slice(proxyHash, 12, 32);
+    return slice(keccak256(concat(['0xd694', proxyAddress, '0x01'])), 12, 32);
+}
+function hcaMaterial(input) {
+    if (input.account.kind !== 'hca')
+        throw new Error('Expected HCA account');
+    if (input.eoa)
+        return { address: input.eoa.address };
+    if (input.sessions.enabled || input.modules.length > 0) {
+        throw new Error('HCA accounts cannot install sessions or additional modules');
+    }
+    if (!input.owner || input.owner.kind !== 'ens') {
+        throw new Error('HCA accounts require ENS owners');
+    }
+    if (input.initData && !('factory' in input.initData)) {
+        return { address: input.initData.address };
+    }
+    let factory;
+    let factoryData;
+    if (input.initData && 'factory' in input.initData) {
+        factory = input.initData.factory;
+        factoryData = input.initData.factoryData;
+        try {
+            decodeFunctionData({
+                abi: parseAbi(['function createAccount(bytes)']),
+                data: factoryData,
+            });
+        }
+        catch {
+            return { address: input.initData.address };
+        }
+    }
+    else {
+        factory =
+            input.account.factory.source === 'explicit'
+                ? input.account.factory.value
+                : HCA_FACTORY_ADDRESS;
+        const validator = input.setup.validators[0];
+        if (!validator)
+            throw new Error('HCA owner validator is required');
+        factoryData = encodeFunctionData({
+            abi: parseAbi(['function createAccount(bytes)']),
+            functionName: 'createAccount',
+            args: [validator.initData],
+        });
+    }
+    return {
+        address: predictCreate3Address(factory, primaryOwner(factoryData)),
+        factory,
+        factoryData,
+    };
+}
+export function createHcaAdapter(construction) {
+    if (construction.account.kind !== 'hca') {
+        throw new Error('Expected HCA account');
+    }
+    return {
+        account: construction.account,
+        capabilities: {
+            modular: false,
+            supportsDeployment: true,
+            supportsUserOperations: true,
+            supportsEip7702Adoption: false,
+            supportsSmartSessions: false,
+            supportsOriginSignatureReuse: true,
+            signatureEnvelope: { kind: 'hca', validator: ENS_HCA_MODULE },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: hcaMaterial(input).address,
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, hcaMaterial(input), input.deployed),
+        encodeCalls: encodeErc7579Calls,
+        encodeModuleInstallation: () => {
+            throw new ModuleInstallationNotSupportedError('hca');
+        },
+        encodeModuleUninstallation: () => {
+            throw new ModuleInstallationNotSupportedError('hca');
+        },
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'hca')
+                throw new Error('Expected HCA envelope');
+            return encodeAddressEnvelope(envelope.validator, validatorContribution, ENS_HCA_MODULE);
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import { type Hex } from 'viem';
+import type { ResolvedModule } from '../../modules/types.js';
+import type { AccountAdapter } from '../adapter.js';
+import type { AccountConstruction } from '../types.js';
+export declare const KERNEL_IMPLEMENTATION_ADDRESS: "0xd6cedde84be40893d153be9d467cd6ad37875b28";
+export declare function wrapKernelMessageHash(messageHash: Hex, account: Hex): Hex;
+export declare function kernelInstallData(module: ResolvedModule): readonly Hex[];
+export declare function createKernelAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=kernel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kernel.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/kernel.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,GAAG,EAOT,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAKnD,eAAO,MAAM,6BAA6B,EACxC,4CAAqD,CAAA;AAQvD,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,GAAG,CAgBzE;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,SAAS,GAAG,EAAE,CA2CxE;AAyED,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAmChB"}

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

@@ -0,0 +1,159 @@
+import { concat, concatHex, decodeAbiParameters, decodeFunctionData, domainSeparator, encodeAbiParameters, encodeFunctionData, getContractAddress, keccak256, parseAbi, stringToHex, toHex, zeroAddress, zeroHash, } from 'viem';
+import { moduleTypeId } from '../../modules/erc7579-abi.js';
+import { deploymentPlan } from '../deployment.js';
+import { encodeErc7579Calls } from '../erc7579-calls.js';
+import { encodeUninstallModule } from './shared.js';
+const KERNEL_META_FACTORY_ADDRESS = '0xd703aae79538628d27099b8c4f621be4ccd142d5';
+export const KERNEL_IMPLEMENTATION_ADDRESS = '0xd6cedde84be40893d153be9d467cd6ad37875b28';
+const KERNEL_FACTORY_ADDRESS = '0x2577507b78c2008ff367261cb6285d44ba5ef2e9';
+const KERNEL_BYTECODE = '0x603d3d8160223d3973d6cedde84be40893d153be9d467cd6ad37875b2860095155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3';
+const HOOK_INSTALLED_ADDRESS = '0x0000000000000000000000000000000000000001';
+export function wrapKernelMessageHash(messageHash, account) {
+    const separator = domainSeparator({
+        domain: {
+            name: 'Kernel',
+            version: '0.3.3',
+            chainId: 0,
+            verifyingContract: account,
+        },
+    });
+    const structHash = keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [keccak256(stringToHex('Kernel(bytes32 hash)')), messageHash]));
+    return keccak256(concatHex(['0x1901', separator, structHash]));
+}
+export function kernelInstallData(module) {
+    const install = (initData) => encodeFunctionData({
+        abi: parseAbi(['function installModule(uint256,address,bytes)']),
+        functionName: 'installModule',
+        args: [moduleTypeId(module.kind), module.address, initData],
+    });
+    switch (module.kind) {
+        case 'validator': {
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x', '0x']);
+            return [
+                install(concat([HOOK_INSTALLED_ADDRESS, data])),
+                encodeFunctionData({
+                    abi: parseAbi(['function grantAccess(bytes21,bytes4,bool)']),
+                    functionName: 'grantAccess',
+                    args: [concat(['0x01', module.address]), '0xe9ae5c53', true],
+                }),
+            ];
+        }
+        case 'executor': {
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x']);
+            return [install(concat([zeroAddress, data]))];
+        }
+        case 'fallback': {
+            const [selector, flags, selectorData] = decodeAbiParameters([{ type: 'bytes4' }, { type: 'bytes1' }, { type: 'bytes' }], module.initData);
+            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [concat([flags, selectorData]), '0x']);
+            return [install(concat([selector, HOOK_INSTALLED_ADDRESS, data]))];
+        }
+        case 'hook':
+            return [install(module.initData)];
+    }
+}
+function kernelMaterial(input) {
+    if (input.account.kind !== 'kernel')
+        throw new Error('Expected Kernel account');
+    if (input.eoa)
+        return { address: input.eoa.address };
+    if (input.initData && !('factory' in input.initData)) {
+        return { address: input.initData.address };
+    }
+    let factoryData;
+    let salt;
+    let initializationCallData;
+    if (input.initData && 'factory' in input.initData) {
+        const decoded = decodeFunctionData({
+            abi: parseAbi([
+                'function deployWithFactory(address factory,bytes createData,bytes32 salt)',
+            ]),
+            data: input.initData.factoryData,
+        });
+        if (decoded.args[0].toLowerCase() !== KERNEL_FACTORY_ADDRESS.toLowerCase()) {
+            throw new Error('Unsupported Kernel implementation');
+        }
+        factoryData = input.initData.factoryData;
+        initializationCallData = decoded.args[1];
+        salt = decoded.args[2];
+    }
+    else {
+        const rootValidator = input.setup.validators[0];
+        if (!rootValidator)
+            throw new Error('Kernel root validator is required');
+        const initConfig = [
+            ...input.setup.validators.slice(1),
+            ...input.setup.executors,
+            ...input.setup.fallbacks,
+            ...input.setup.hooks,
+        ].flatMap(kernelInstallData);
+        initializationCallData = encodeFunctionData({
+            abi: parseAbi([
+                'function initialize(bytes21,address,bytes,bytes,bytes[])',
+            ]),
+            functionName: 'initialize',
+            args: [
+                concat(['0x01', rootValidator.address]),
+                zeroAddress,
+                rootValidator.initData,
+                '0x',
+                initConfig,
+            ],
+        });
+        salt =
+            input.account.salt.source === 'explicit'
+                ? input.account.salt.value
+                : zeroHash;
+        factoryData = encodeFunctionData({
+            abi: parseAbi(['function deployWithFactory(address,bytes,bytes32)']),
+            functionName: 'deployWithFactory',
+            args: [KERNEL_FACTORY_ADDRESS, initializationCallData, salt],
+        });
+    }
+    const actualSalt = keccak256(concat([initializationCallData, salt]));
+    const address = getContractAddress({
+        from: KERNEL_FACTORY_ADDRESS,
+        opcode: 'CREATE2',
+        bytecode: KERNEL_BYTECODE,
+        salt: actualSalt,
+    });
+    return {
+        address,
+        factory: input.initData?.factory ?? KERNEL_META_FACTORY_ADDRESS,
+        factoryData,
+    };
+}
+export function createKernelAdapter(construction) {
+    if (construction.account.kind !== 'kernel') {
+        throw new Error('Expected Kernel account');
+    }
+    const validator = construction.setup.validators[0]?.address ?? zeroAddress;
+    return {
+        account: construction.account,
+        capabilities: {
+            modular: true,
+            supportsDeployment: true,
+            supportsUserOperations: true,
+            supportsEip7702Adoption: false,
+            supportsSmartSessions: true,
+            supportsOriginSignatureReuse: true,
+            signatureEnvelope: { kind: 'kernel', validator, isRoot: true },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: kernelMaterial(input).address,
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, kernelMaterial(input), input.deployed),
+        encodeCalls: encodeErc7579Calls,
+        encodeModuleInstallation: kernelInstallData,
+        encodeModuleUninstallation: encodeUninstallModule,
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'kernel')
+                throw new Error('Expected Kernel envelope');
+            return concat([
+                envelope.isRoot ? '0x00' : concat(['0x01', envelope.validator]),
+                keccak256(toHex('kernel.replayable.signature')),
+                validatorContribution,
+            ]);
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import { type Address, type Hex } from 'viem';
+import type { AccountAdapter } from '../adapter.js';
+import { type DeploymentMaterial } from '../deployment.js';
+import type { AccountConstruction } from '../types.js';
+export declare const NEXUS_IMPLEMENTATION_ADDRESS: "0x000000000032ddc454c3bdcba80484ad5a798705";
+export declare const NEXUS_FACTORY_ADDRESS: "0x0000000000679a258c64d2f20f310e12b64b7375";
+export declare const NEXUS_IMPLEMENTATION_1_2_1: "0x000000000d41c0bf0063dba53343389cdb2c9c78";
+export declare const NEXUS_FACTORY_1_2_1: "0x0000000099d5576c73a3b190dabeeaa0f128ce6b";
+export interface NexusDeploymentMaterial extends DeploymentMaterial {
+    readonly initializationCallData?: Hex;
+    readonly implementation?: Address;
+    readonly salt?: Hex;
+}
+export declare function nexusMaterial(input: AccountConstruction): NexusDeploymentMaterial;
+export declare function createNexusAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=nexus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nexus.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/nexus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAOZ,KAAK,GAAG,EAKT,MAAM,MAAM,CAAA;AAEb,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,KAAK,kBAAkB,EAAkB,MAAM,eAAe,CAAA;AAEvE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAOnD,eAAO,MAAM,4BAA4B,EACvC,4CAAqD,CAAA;AACvD,eAAO,MAAM,qBAAqB,EAChC,4CAAqD,CAAA;AAIvD,eAAO,MAAM,0BAA0B,EACrC,4CAAqD,CAAA;AACvD,eAAO,MAAM,mBAAmB,EAC9B,4CAAqD,CAAA;AAmCvD,MAAM,WAAW,uBAAwB,SAAQ,kBAAkB;IACjE,QAAQ,CAAC,sBAAsB,CAAC,EAAE,GAAG,CAAA;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,CAAA;CACpB;AAED,wBAAgB,aAAa,CAC3B,KAAK,EAAE,mBAAmB,GACzB,uBAAuB,CAwHzB;AA4CD,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAoChB"}