@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

package/README.md

@@ -143,7 +143,7 @@ const prepared = await account.prepareTransaction({
   targetChain: arbitrumSepolia,
   calls: [
     {
-      to: 'USDC',
+      to: usdc,
       value: 0n,
       data: encodeFunctionData({
         abi: erc20Abi,
@@ -152,7 +152,7 @@ const prepared = await account.prepareTransaction({
       }),
     },
   ],
-  tokenRequests: [{ address: 'USDC', amount }],
+  tokenRequests: [{ address: usdc, amount }],
 })
 
 const signed = await account.signTransaction(prepared)

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/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;AA2FvD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAqChB"}

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

@@ -0,0 +1,121 @@
+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 };
+    // HCA derives its address from the ENS owner alone and has no module
+    // installation, so recovery, sessions, and extra modules can never be
+    // installed. `recovery` resolves into `modules`, so it is rejected here too.
+    if (input.sessions.enabled || input.modules.length > 0) {
+        throw new Error('HCA accounts cannot install recovery, 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"}

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

@@ -0,0 +1,212 @@
+import { concat, decodeFunctionData, encodeAbiParameters, encodeFunctionData, encodePacked, getContractAddress, keccak256, parseAbi, size, zeroAddress, } from 'viem';
+import { OWNABLE_VALIDATOR_ADDRESS } from '../../modules/validators/ownable.js';
+import { deploymentPlan } from '../deployment.js';
+import { encodeErc7579Calls } from '../erc7579-calls.js';
+import { encodeAddressEnvelope, encodeInstallModule, encodeUninstallModule, } from './shared.js';
+export const NEXUS_IMPLEMENTATION_ADDRESS = '0x000000000032ddc454c3bdcba80484ad5a798705';
+export const NEXUS_FACTORY_ADDRESS = '0x0000000000679a258c64d2f20f310e12b64b7375';
+// Current default (1.2.1): new implementation + factory, same bootstrap and
+// proxy creation code as 1.2.0. `version: '1.2.0'` opts back into the previous
+// implementation + factory so its counterfactual address doesn't change.
+export const NEXUS_IMPLEMENTATION_1_2_1 = '0x000000000d41c0bf0063dba53343389cdb2c9c78';
+export const NEXUS_FACTORY_1_2_1 = '0x0000000099d5576c73a3b190dabeeaa0f128ce6b';
+const NEXUS_BOOTSTRAP_ADDRESS = '0x00000000006efb61d8c9546ff1b500de3f244ea7';
+const NEXUS_CREATION_CODE = '0x60806040526102aa803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f90b772c2cb8a51aa7a8a65fc23543c6d022d5b3f8e2b92eed79fba7eef8293005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051606b908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00fea164736f6c634300081b000a';
+// Resolves the implementation + factory a fresh account deploys against. Only
+// the default (unset) and an explicit '1.2.1' deploy the current contracts;
+// '1.2.0' keeps the previous implementation + factory so its counterfactual
+// address doesn't change.
+function getNexusDeployment(version) {
+    if (!version || version === '1.2.1') {
+        return {
+            implementation: NEXUS_IMPLEMENTATION_1_2_1,
+            factory: NEXUS_FACTORY_1_2_1,
+        };
+    }
+    return {
+        implementation: NEXUS_IMPLEMENTATION_ADDRESS,
+        factory: NEXUS_FACTORY_ADDRESS,
+    };
+}
+// Maps a Nexus factory to the implementation it deploys, so a persisted
+// `initData` payload recomputes against the right implementation instead of
+// defaulting to one version.
+function implementationForFactory(factory) {
+    return factory.toLowerCase() === NEXUS_FACTORY_1_2_1
+        ? NEXUS_IMPLEMENTATION_1_2_1
+        : NEXUS_IMPLEMENTATION_ADDRESS;
+}
+export function nexusMaterial(input) {
+    if (input.account.kind !== 'nexus')
+        throw new Error('Expected Nexus account');
+    if (input.eoa)
+        return { address: input.eoa.address };
+    if (input.initData && !('factory' in input.initData)) {
+        return { address: input.initData.address };
+    }
+    const version = input.account.version.source === 'explicit'
+        ? input.account.version.value
+        : undefined;
+    let factory;
+    let factoryData;
+    let implementation;
+    let initializationCallData;
+    let salt;
+    if (input.initData && 'factory' in input.initData) {
+        const decoded = decodeFunctionData({
+            abi: parseAbi(['function createAccount(bytes,bytes32)']),
+            data: input.initData.factoryData,
+        });
+        factory = input.initData.factory;
+        implementation = implementationForFactory(factory);
+        factoryData = input.initData.factoryData;
+        const initData = decoded.args[0];
+        salt = decoded.args[1];
+        initializationCallData = encodeFunctionData({
+            abi: parseAbi(['function initializeAccount(bytes)']),
+            functionName: 'initializeAccount',
+            args: [initData],
+        });
+    }
+    else {
+        const deployment = getNexusDeployment(version);
+        factory = deployment.factory;
+        implementation = deployment.implementation;
+        salt =
+            input.account.salt.source === 'explicit'
+                ? input.account.salt.value
+                : keccak256('0x');
+        const defaultValidator = input.setup.validators.find((module) => module.address === OWNABLE_VALIDATOR_ADDRESS);
+        const defaultValidatorInitData = defaultValidator?.initData ?? '0x';
+        const validators = input.setup.validators.filter((module) => module.address !== OWNABLE_VALIDATOR_ADDRESS);
+        const configs = (modules) => modules.map((module) => ({
+            module: module.address,
+            initData: module.initData,
+        }));
+        const bootstrapData = size(defaultValidatorInitData) > 0
+            ? encodeFunctionData({
+                abi: parseAbi([
+                    'struct BootstrapConfig {address module;bytes initData;}',
+                    'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
+                    'function initNexusWithDefaultValidatorAndOtherModulesNoRegistry(bytes defaultValidatorInitData,BootstrapConfig[] validators,BootstrapConfig[] executors,BootstrapConfig hook,BootstrapConfig[] fallbacks,BootstrapPreValidationHookConfig[] preValidationHooks)',
+                ]),
+                functionName: 'initNexusWithDefaultValidatorAndOtherModulesNoRegistry',
+                args: [
+                    defaultValidatorInitData,
+                    configs(validators),
+                    configs(input.setup.executors),
+                    { module: zeroAddress, initData: '0x' },
+                    configs(input.setup.fallbacks),
+                    [],
+                ],
+            })
+            : encodeFunctionData({
+                abi: parseAbi([
+                    'struct BootstrapConfig {address module;bytes initData;}',
+                    'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
+                    'function initNexusNoRegistry(BootstrapConfig[] validators,BootstrapConfig[] executors,BootstrapConfig hook,BootstrapConfig[] fallbacks,BootstrapPreValidationHookConfig[] preValidationHooks)',
+                ]),
+                functionName: 'initNexusNoRegistry',
+                args: [
+                    configs(validators),
+                    configs(input.setup.executors),
+                    { module: zeroAddress, initData: '0x' },
+                    configs(input.setup.fallbacks),
+                    [],
+                ],
+            });
+        const initData = encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [NEXUS_BOOTSTRAP_ADDRESS, bootstrapData]);
+        factoryData = encodeFunctionData({
+            abi: parseAbi(['function createAccount(bytes,bytes32)']),
+            functionName: 'createAccount',
+            args: [initData, salt],
+        });
+        initializationCallData = encodeFunctionData({
+            abi: parseAbi(['function initializeAccount(bytes)']),
+            functionName: 'initializeAccount',
+            args: [initData],
+        });
+    }
+    const accountInitData = encodeAbiParameters([
+        { name: 'address', type: 'address' },
+        { name: 'calldata', type: 'bytes' },
+    ], [implementation, initializationCallData]);
+    const address = getContractAddress({
+        opcode: 'CREATE2',
+        from: factory,
+        salt,
+        bytecode: concat([NEXUS_CREATION_CODE, accountInitData]),
+    });
+    return {
+        address,
+        factory,
+        factoryData,
+        implementation,
+        initializationCallData,
+        salt,
+    };
+}
+function nexusEip7702AdoptionPlan(input) {
+    const { eoa: _eoa, ...factoryConstruction } = input;
+    const material = nexusMaterial(factoryConstruction);
+    if (!material.factoryData || !material.implementation) {
+        throw new Error('Nexus EIP-7702 initialization data is unavailable');
+    }
+    const decoded = decodeFunctionData({
+        abi: parseAbi(['function createAccount(bytes,bytes32)']),
+        data: material.factoryData,
+    });
+    if (decoded.functionName !== 'createAccount') {
+        throw new Error('Invalid Nexus EIP-7702 initialization data');
+    }
+    return {
+        contract: material.implementation,
+        initData: decoded.args[0],
+    };
+}
+// Builds the signed `initializeAccount` call sent as the account setup op when a
+// 7702 intent is prepared. The account authorizes initialization by prefixing
+// the raw module init data (packed with the any-chain sentinel) with its
+// EIP-7702 init signature.
+function nexusEip7702InitCall(input, eip7702InitSignature) {
+    const { initData } = nexusEip7702AdoptionPlan(input);
+    const packedInitData = encodePacked(['uint256', 'uint256', 'uint256', 'bytes'], [0n, 1n, 0n, initData]);
+    return encodeFunctionData({
+        abi: parseAbi(['function initializeAccount(bytes)']),
+        functionName: 'initializeAccount',
+        args: [concat([eip7702InitSignature, packedInitData])],
+    });
+}
+export function createNexusAdapter(construction) {
+    if (construction.account.kind !== 'nexus') {
+        throw new Error('Expected Nexus account');
+    }
+    const validator = construction.setup.validators[0]?.address ?? zeroAddress;
+    return {
+        account: construction.account,
+        capabilities: {
+            modular: true,
+            supportsDeployment: true,
+            supportsUserOperations: true,
+            supportsEip7702Adoption: true,
+            supportsSmartSessions: true,
+            supportsOriginSignatureReuse: true,
+            signatureEnvelope: { kind: 'nexus', validator },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: nexusMaterial(input).address,
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, nexusMaterial(input), input.deployed),
+        getEip7702AdoptionPlan: nexusEip7702AdoptionPlan,
+        getEip7702InitCall: nexusEip7702InitCall,
+        encodeCalls: encodeErc7579Calls,
+        encodeModuleInstallation: (module) => [encodeInstallModule(module)],
+        encodeModuleUninstallation: encodeUninstallModule,
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'nexus')
+                throw new Error('Expected Nexus envelope');
+            return encodeAddressEnvelope(envelope.validator, validatorContribution, OWNABLE_VALIDATOR_ADDRESS);
+        },
+    };
+}

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

@@ -0,0 +1,6 @@
+import type { AccountAdapter } from '../adapter.js';
+import { type DeploymentMaterial } from '../deployment.js';
+import type { AccountConstruction } from '../types.js';
+export declare function safeV0FactoryMaterial(input: AccountConstruction): Pick<Required<DeploymentMaterial>, 'factory' | 'factoryData'>;
+export declare function createSafeAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=safe.d.ts.map