@rhinestone/sdk 2.0.0-beta.44 → 2.0.0-beta.46

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

@@ -0,0 +1,194 @@
+import { concat, decodeFunctionData, encodeAbiParameters, encodeFunctionData, encodePacked, getContractAddress, keccak256, parseAbi, parseAbiParameters, zeroAddress, } from 'viem';
+import { getV0Attesters } from '../../modules/legacy-core.js';
+import { deploymentPlan } from '../deployment.js';
+import { encodeErc7579Calls } from '../erc7579-calls.js';
+import { encodeAddressEnvelope, encodeInstallModule, encodeUninstallModule, primaryOwnerAddresses, primaryThreshold, } from './shared.js';
+const SAFE_LAUNCHPAD = '0x75798463024bda64d83c94a64bc7d7eab41300ef';
+const SAFE_ADAPTER = '0x7579f2ad53b01c3d8779fe17928e0d48885b0003';
+const SAFE_V0_LAUNCHPAD = '0x7579011ab74c46090561ea277ba79d510c6c00ff';
+const SAFE_V0_ADAPTER = '0x7579ee8307284f293b1927136486880611f20002';
+const SAFE_SINGLETON = '0x29fcb43b46531bca003ddc8fcb67ffe91900c762';
+const SAFE_FACTORY = '0x4e1dcf7ad4e460cfd30791ccc4f9c8a4f820ec67';
+const SAFE_PROXY_INIT_CODE = '0x608060405234801561001057600080fd5b506040516101e63803806101e68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101c46022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505060ab806101196000396000f3fe608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea264697066735822122003d1488ee65e08fa41e58e888a9865554c535f2c77126a82cb4c0f917f31441364736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564';
+function safeMaterial(input) {
+    if (input.account.kind !== 'safe')
+        throw new Error('Expected Safe account');
+    if (input.eoa)
+        return { address: input.eoa.address };
+    if (input.initData && !('factory' in input.initData)) {
+        return { address: input.initData.address };
+    }
+    let factory = SAFE_FACTORY;
+    let factoryData;
+    let implementation = SAFE_SINGLETON;
+    let salt;
+    if (input.initData && 'factory' in input.initData) {
+        const decoded = decodeFunctionData({
+            abi: parseAbi([
+                'function createProxyWithNonce(address singleton,bytes initializer,uint256 saltNonce)',
+            ]),
+            data: input.initData.factoryData,
+        });
+        if (decoded.functionName !== 'createProxyWithNonce') {
+            throw new Error('Invalid Safe factory data');
+        }
+        factory = input.initData.factory;
+        factoryData = input.initData.factoryData;
+        implementation = decoded.args[0];
+        salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(decoded.args[1]), decoded.args[2]]));
+    }
+    else {
+        if (!input.owner)
+            throw new Error('Safe account owners are required');
+        const modules = [
+            ...input.setup.validators,
+            ...input.setup.executors,
+            ...input.setup.fallbacks,
+            ...input.setup.hooks,
+        ];
+        const addSafe7579 = encodeFunctionData({
+            abi: parseAbi([
+                'struct ModuleInit {address module;bytes initData;uint256 moduleType}',
+                'function addSafe7579(address safe7579,ModuleInit[] modules,address[] attesters,uint8 threshold)',
+            ]),
+            functionName: 'addSafe7579',
+            args: [
+                SAFE_ADAPTER,
+                modules.map((module) => ({
+                    module: module.address,
+                    initData: module.initData,
+                    moduleType: module.kind === 'validator'
+                        ? 1n
+                        : module.kind === 'executor'
+                            ? 2n
+                            : module.kind === 'fallback'
+                                ? 3n
+                                : 4n,
+                })),
+                [],
+                0,
+            ],
+        });
+        const initializer = encodeFunctionData({
+            abi: parseAbi([
+                'function setup(address[] _owners,uint256 _threshold,address to,bytes data,address fallbackHandler,address paymentToken,uint256 payment,address paymentReceiver)',
+            ]),
+            functionName: 'setup',
+            args: [
+                [...primaryOwnerAddresses(input.owner)],
+                primaryThreshold(input.owner),
+                SAFE_LAUNCHPAD,
+                addSafe7579,
+                SAFE_ADAPTER,
+                zeroAddress,
+                0n,
+                zeroAddress,
+            ],
+        });
+        const nonce = input.account.nonce.source === 'explicit' ? input.account.nonce.value : 0n;
+        factoryData = encodeFunctionData({
+            abi: parseAbi([
+                'function createProxyWithNonce(address singleton,bytes initializer,uint256 saltNonce)',
+            ]),
+            functionName: 'createProxyWithNonce',
+            args: [SAFE_SINGLETON, initializer, nonce],
+        });
+        salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initializer), nonce]));
+    }
+    const constructorArgs = encodeAbiParameters(parseAbiParameters('address singleton'), [implementation]);
+    const address = getContractAddress({
+        opcode: 'CREATE2',
+        from: factory,
+        salt,
+        bytecode: concat([SAFE_PROXY_INIT_CODE, constructorArgs]),
+    });
+    return { address, factory, factoryData };
+}
+export function safeV0FactoryMaterial(input) {
+    if (input.account.kind !== 'safe')
+        throw new Error('Expected Safe account');
+    if (input.initData) {
+        throw new Error('Account configuration for Safe account is not supported: Custom V0 accounts are not supported');
+    }
+    if (!input.owner)
+        throw new Error('Safe account owners are required');
+    const attesters = getV0Attesters();
+    const modules = (items) => items.map((module) => ({
+        module: module.address,
+        initData: module.initData,
+    }));
+    const addSafe7579 = encodeFunctionData({
+        abi: parseAbi([
+            'struct ModuleInit {address module;bytes initData;}',
+            'function addSafe7579(address safe7579,ModuleInit[] validators,ModuleInit[] executors,ModuleInit[] fallbacks,ModuleInit[] hooks,address[] attesters,uint8 threshold)',
+        ]),
+        functionName: 'addSafe7579',
+        args: [
+            SAFE_V0_ADAPTER,
+            modules(input.setup.validators),
+            modules(input.setup.executors),
+            modules(input.setup.fallbacks),
+            modules(input.setup.hooks),
+            [...attesters.addresses],
+            attesters.threshold,
+        ],
+    });
+    const initializer = encodeFunctionData({
+        abi: parseAbi([
+            'function setup(address[] _owners,uint256 _threshold,address to,bytes data,address fallbackHandler,address paymentToken,uint256 payment,address paymentReceiver)',
+        ]),
+        functionName: 'setup',
+        args: [
+            [...primaryOwnerAddresses(input.owner)],
+            primaryThreshold(input.owner),
+            SAFE_V0_LAUNCHPAD,
+            addSafe7579,
+            SAFE_V0_ADAPTER,
+            zeroAddress,
+            0n,
+            zeroAddress,
+        ],
+    });
+    const nonce = input.account.nonce.source === 'explicit' ? input.account.nonce.value : 0n;
+    return {
+        factory: SAFE_FACTORY,
+        factoryData: encodeFunctionData({
+            abi: parseAbi([
+                'function createProxyWithNonce(address singleton,bytes initializer,uint256 saltNonce)',
+            ]),
+            functionName: 'createProxyWithNonce',
+            args: [SAFE_SINGLETON, initializer, nonce],
+        }),
+    };
+}
+export function createSafeAdapter(construction) {
+    if (construction.account.kind !== 'safe') {
+        throw new Error('Expected Safe 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: 'safe', validator },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: safeMaterial(input).address,
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, safeMaterial(input), input.deployed),
+        encodeCalls: encodeErc7579Calls,
+        encodeModuleInstallation: (module) => [encodeInstallModule(module)],
+        encodeModuleUninstallation: encodeUninstallModule,
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'safe')
+                throw new Error('Expected Safe envelope');
+            return encodeAddressEnvelope(envelope.validator, validatorContribution);
+        },
+    };
+}

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

@@ -0,0 +1,9 @@
+import { type Hex } from 'viem';
+import type { ResolvedModule } from '../../modules/types.js';
+import type { ResolvedValidatorDefinition } from '../../modules/validators/types.js';
+export declare function primaryOwnerAddresses(validator: ResolvedValidatorDefinition): readonly `0x${string}`[];
+export declare function primaryThreshold(validator: ResolvedValidatorDefinition): bigint;
+export declare function encodeInstallModule(module: ResolvedModule): Hex;
+export declare function encodeUninstallModule(module: ResolvedModule): Hex;
+export declare function encodeAddressEnvelope(validator: `0x${string}`, signature: Hex, defaultValidator?: `0x${string}`): Hex;
+//# sourceMappingURL=shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,GAAG,EAAe,MAAM,MAAM,CAAA;AAE9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAEjF,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,2BAA2B,GACrC,SAAS,KAAK,MAAM,EAAE,EAAE,CAU1B;AAED,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,2BAA2B,GACrC,MAAM,CAMR;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,GAAG,CAkB/D;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,cAAc,GAAG,GAAG,CAkBjE;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,KAAK,MAAM,EAAE,EACxB,SAAS,EAAE,GAAG,EACd,gBAAgB,CAAC,EAAE,KAAK,MAAM,EAAE,GAC/B,GAAG,CAML"}

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

@@ -0,0 +1,62 @@
+import { encodeFunctionData, encodePacked, zeroAddress } from 'viem';
+import { moduleTypeId } from '../../modules/erc7579-abi.js';
+export function primaryOwnerAddresses(validator) {
+    if (validator.kind === 'passkey' || validator.kind === 'multi-factor') {
+        return ['0xbabe99e62d8bcbd3acf5ccbcfcd4f64fe75e5e72'];
+    }
+    return validator.owners.map((owner) => {
+        if (owner.kind === 'webauthn') {
+            throw new Error('Validator owner does not expose an address');
+        }
+        return owner.account.address;
+    });
+}
+export function primaryThreshold(validator) {
+    return BigInt(validator.kind === 'passkey' || validator.kind === 'multi-factor'
+        ? 1
+        : validator.threshold);
+}
+export function encodeInstallModule(module) {
+    return encodeFunctionData({
+        abi: [
+            {
+                type: 'function',
+                name: 'installModule',
+                inputs: [
+                    { type: 'uint256', name: 'moduleTypeId' },
+                    { type: 'address', name: 'module' },
+                    { type: 'bytes', name: 'initData' },
+                ],
+                outputs: [],
+                stateMutability: 'nonpayable',
+            },
+        ],
+        functionName: 'installModule',
+        args: [moduleTypeId(module.kind), module.address, module.initData],
+    });
+}
+export function encodeUninstallModule(module) {
+    return 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: [moduleTypeId(module.kind), module.address, module.deInitData],
+    });
+}
+export function encodeAddressEnvelope(validator, signature, defaultValidator) {
+    const address = defaultValidator?.toLowerCase() === validator.toLowerCase()
+        ? zeroAddress
+        : validator;
+    return encodePacked(['address', 'bytes'], [address, signature]);
+}

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

@@ -0,0 +1,14 @@
+import { type Address } from 'viem';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../../modules/validators/k1.js';
+import type { AccountAdapter } from '../adapter.js';
+import type { AccountConstruction } from '../types.js';
+export { K1_DEFAULT_VALIDATOR_ADDRESS };
+export declare function startaleEip712Domain(account: Address, chainId: number): {
+    readonly name: "Startale";
+    readonly version: "1.0.0";
+    readonly chainId: number;
+    readonly verifyingContract: `0x${string}`;
+    readonly salt: "0x0000000000000000000000000000000000000000000000000000000000000000";
+};
+export declare function createStartaleAdapter(construction: AccountConstruction): AccountAdapter;
+//# sourceMappingURL=startale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"startale.d.ts","sourceRoot":"","sources":["../../../../accounts/adapters/startale.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAYb,MAAM,MAAM,CAAA;AAEb,OAAO,EAAE,4BAA4B,EAAE,MAAM,6BAA6B,CAAA;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAGhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AAQnD,OAAO,EAAE,4BAA4B,EAAE,CAAA;AACvC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM;;;;;;EAQrE;AAqID,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,mBAAmB,GAChC,cAAc,CAoChB"}

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

@@ -0,0 +1,165 @@
+import { concat, decodeFunctionData, encodeAbiParameters, encodeFunctionData, encodePacked, keccak256, parseAbi, slice, zeroAddress, zeroHash, } from 'viem';
+import { K1_DEFAULT_VALIDATOR_ADDRESS } from '../../modules/validators/k1.js';
+import { deploymentPlan } from '../deployment.js';
+import { encodeErc7579Calls } from '../erc7579-calls.js';
+import { encodeAddressEnvelope, encodeInstallModule, encodeUninstallModule, primaryOwnerAddresses, } from './shared.js';
+export { K1_DEFAULT_VALIDATOR_ADDRESS };
+export function startaleEip712Domain(account, chainId) {
+    return {
+        name: 'Startale',
+        version: '1.0.0',
+        chainId,
+        verifyingContract: account,
+        salt: zeroHash,
+    };
+}
+const STARTALE_IMPLEMENTATION_ADDRESS = '0x000000b8f5f723a680d3d7ee624fe0bc84a6e05a';
+const STARTALE_FACTORY_ADDRESS = '0x0000003b3e7b530b4f981ae80d9350392defef90';
+const STARTALE_BOOTSTRAP_ADDRESS = '0x000000552a5fae3db7a8f3917c435448f49ba6a9';
+const STARTALE_CREATION_CODE = '0x608060405261029d803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f754fd8b321c4649cb777ae6fdce7e89e9cceaa31a4f639795c7807eb7f1a27005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051605e908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00';
+function moduleConfigs(modules) {
+    return modules.map((module) => ({
+        module: module.address,
+        initData: module.initData,
+    }));
+}
+function startaleInitData(input) {
+    const ownerValidator = input.setup.validators[0];
+    if (!ownerValidator)
+        throw new Error('Startale owner validator is required');
+    const isK1 = ownerValidator.address.toLowerCase() ===
+        K1_DEFAULT_VALIDATOR_ADDRESS.toLowerCase();
+    let bootstrapData;
+    if (isK1) {
+        if (!input.owner)
+            throw new Error('Startale K1 owner is required');
+        const owners = primaryOwnerAddresses(input.owner);
+        if (owners.length !== 1) {
+            throw new Error('K1 validator only supports a single owner');
+        }
+        bootstrapData = encodeFunctionData({
+            abi: parseAbi([
+                'struct BootstrapConfig {address module;bytes initData;}',
+                'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
+                'function initWithDefaultValidatorAndOtherModules(bytes defaultValidatorInitData,BootstrapConfig[] validators,BootstrapConfig[] executors,BootstrapConfig hook,BootstrapConfig[] fallbacks,BootstrapPreValidationHookConfig[] preValidationHooks)',
+            ]),
+            functionName: 'initWithDefaultValidatorAndOtherModules',
+            args: [
+                owners[0],
+                moduleConfigs(input.setup.validators.slice(1)),
+                moduleConfigs(input.setup.executors),
+                { module: zeroAddress, initData: zeroHash },
+                moduleConfigs(input.setup.fallbacks),
+                [],
+            ],
+        });
+    }
+    else {
+        bootstrapData = encodeFunctionData({
+            abi: parseAbi([
+                'struct BootstrapConfig {address module;bytes initData;}',
+                'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
+                'function init(BootstrapConfig[] validators,BootstrapConfig[] executors,BootstrapConfig hook,BootstrapConfig[] fallbacks,BootstrapPreValidationHookConfig[] preValidationHooks)',
+            ]),
+            functionName: 'init',
+            args: [
+                moduleConfigs(input.setup.validators),
+                moduleConfigs(input.setup.executors),
+                { module: zeroAddress, initData: '0x' },
+                moduleConfigs(input.setup.fallbacks),
+                [],
+            ],
+        });
+    }
+    return encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [STARTALE_BOOTSTRAP_ADDRESS, bootstrapData]);
+}
+function startaleMaterial(input) {
+    if (input.account.kind !== 'startale') {
+        throw new Error('Expected Startale account');
+    }
+    if (input.eoa)
+        return { address: input.eoa.address };
+    if (input.initData && !('factory' in input.initData)) {
+        return { address: input.initData.address };
+    }
+    let factory = STARTALE_FACTORY_ADDRESS;
+    let factoryData;
+    let salt;
+    let initializationCallData;
+    if (input.initData && 'factory' in input.initData) {
+        try {
+            const decoded = decodeFunctionData({
+                abi: parseAbi(['function createAccount(bytes,bytes32)']),
+                data: input.initData.factoryData,
+            });
+            factory = input.initData.factory;
+            factoryData = input.initData.factoryData;
+            salt = decoded.args[1];
+            initializationCallData = encodeFunctionData({
+                abi: parseAbi(['function initializeAccount(bytes)']),
+                functionName: 'initializeAccount',
+                args: [decoded.args[0]],
+            });
+        }
+        catch {
+            return { address: input.initData.address };
+        }
+    }
+    else {
+        salt =
+            input.account.salt.source === 'explicit'
+                ? input.account.salt.value
+                : zeroHash;
+        const initData = startaleInitData(input);
+        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([{ type: 'address' }, { type: 'bytes' }], [STARTALE_IMPLEMENTATION_ADDRESS, initializationCallData]);
+    const hash = keccak256(encodePacked(['bytes1', 'address', 'bytes32', 'bytes32'], [
+        '0xff',
+        factory,
+        salt,
+        keccak256(concat([STARTALE_CREATION_CODE, accountInitData])),
+    ]));
+    return { address: slice(hash, 12, 32), factory, factoryData };
+}
+export function createStartaleAdapter(construction) {
+    if (construction.account.kind !== 'startale') {
+        throw new Error('Expected Startale 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: 'startale', validator },
+        },
+        getIdentity: (input) => ({
+            definition: input.account,
+            address: startaleMaterial(input).address,
+        }),
+        getDeploymentPlan: (input) => deploymentPlan(input.chain, startaleMaterial(input), input.deployed),
+        encodeCalls: encodeErc7579Calls,
+        encodeModuleInstallation: (module) => [encodeInstallModule(module)],
+        encodeModuleUninstallation: encodeUninstallModule,
+        encodeSignatureEnvelope: ({ envelope, validatorContribution }) => {
+            if (envelope.kind !== 'startale') {
+                throw new Error('Expected Startale envelope');
+            }
+            return encodeAddressEnvelope(envelope.validator, validatorContribution, K1_DEFAULT_VALIDATOR_ADDRESS);
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+import type { Account } from 'viem';
+import type { EvmChainReference } from '../chains/types.js';
+import type { ConfiguredModule, ModuleSetup } from '../modules/types.js';
+import type { ResolvedValidatorDefinition } from '../modules/validators/types.js';
+import type { AccountConstruction, AccountDefinition, AccountInitData } from './types.js';
+export interface AccountConstructionMaterial {
+    readonly account: AccountDefinition;
+    readonly owner?: ResolvedValidatorDefinition;
+    readonly modules: readonly ConfiguredModule[];
+    readonly initData?: AccountInitData;
+    readonly eoa?: Account;
+    readonly sessions: {
+        readonly enabled: boolean;
+        readonly environment: 'production' | 'development';
+        readonly module?: `0x${string}`;
+        readonly compatibilityFallback?: `0x${string}`;
+    };
+}
+export declare function createAccountConstruction(input: {
+    readonly material: AccountConstructionMaterial;
+    readonly chain: EvmChainReference;
+    readonly deployed: boolean;
+    readonly setup?: ModuleSetup;
+}): AccountConstruction;
+//# sourceMappingURL=construction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"construction.d.ts","sourceRoot":"","sources":["../../../accounts/construction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAExD,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAErE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,6BAA6B,CAAA;AAC9E,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EAChB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAA;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,2BAA2B,CAAA;IAC5C,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAA;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAA;IACnC,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;QACzB,QAAQ,CAAC,WAAW,EAAE,YAAY,GAAG,aAAa,CAAA;QAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;QAC/B,QAAQ,CAAC,qBAAqB,CAAC,EAAE,KAAK,MAAM,EAAE,CAAA;KAC/C,CAAA;CACF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,QAAQ,EAAE,2BAA2B,CAAA;IAC9C,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;IACjC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAC7B,GAAG,mBAAmB,CAgCtB"}

package/dist/src/accounts/construction.js

@@ -0,0 +1,34 @@
+import { planModuleSetup } from '../modules/plan.js';
+import { resolveValidator } from '../modules/validators/resolve.js';
+export function createAccountConstruction(input) {
+    const ownerModule = input.material.owner
+        ? resolveValidator(input.material.owner)
+        : undefined;
+    if (!ownerModule && input.material.account.kind !== 'eoa') {
+        throw new Error('Smart account owner is required');
+    }
+    const setup = input.setup ??
+        (ownerModule
+            ? planModuleSetup({
+                accountKind: input.material.account.kind,
+                owner: ownerModule,
+                configured: input.material.modules,
+                environment: input.material.sessions.environment,
+                sessions: input.material.sessions,
+            })
+            : { validators: [], executors: [], hooks: [], fallbacks: [] });
+    return {
+        account: input.material.account,
+        ...(input.material.owner ? { owner: input.material.owner } : {}),
+        modules: input.material.modules,
+        setup,
+        sessions: {
+            enabled: input.material.sessions.enabled,
+            environment: input.material.sessions.environment,
+        },
+        ...(input.material.initData ? { initData: input.material.initData } : {}),
+        ...(input.material.eoa ? { eoa: input.material.eoa } : {}),
+        chain: input.chain,
+        deployed: input.deployed,
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { Address, Hex } from 'viem';
+import type { AccountDefinition, AccountDeploymentPlan, AccountInitData, AccountValueSelection } from './types.js';
+export interface DeploymentMaterial {
+    readonly address: Address;
+    readonly factory?: Address;
+    readonly factoryData?: Hex;
+}
+export declare function selectedValue<Value, Profile extends string>(selection: AccountValueSelection<Value, Profile>, defaults: Readonly<Record<Profile, Value>>): Value;
+export declare function deploymentPlan(chain: AccountDeploymentPlan['chain'], material: DeploymentMaterial, deployed: boolean): AccountDeploymentPlan;
+export declare function initDataMaterial(initData: AccountInitData | undefined): DeploymentMaterial | undefined;
+export declare function accountKind(definition: AccountDefinition): AccountDefinition['kind'];
+//# sourceMappingURL=deployment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deployment.d.ts","sourceRoot":"","sources":["../../../accounts/deployment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AACxC,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAEhB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,GAAG,CAAA;CAC3B;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,SAAS,MAAM,EACzD,SAAS,EAAE,qBAAqB,CAAC,KAAK,EAAE,OAAO,CAAC,EAChD,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,GACzC,KAAK,CAIP;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,qBAAqB,CAAC,OAAO,CAAC,EACrC,QAAQ,EAAE,kBAAkB,EAC5B,QAAQ,EAAE,OAAO,GAChB,qBAAqB,CAcvB;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,GAAG,SAAS,GACpC,kBAAkB,GAAG,SAAS,CAShC;AAED,wBAAgB,WAAW,CACzB,UAAU,EAAE,iBAAiB,GAC5B,iBAAiB,CAAC,MAAM,CAAC,CAE3B"}

package/dist/src/accounts/deployment.js

@@ -0,0 +1,33 @@
+export function selectedValue(selection, defaults) {
+    return selection.source === 'explicit'
+        ? selection.value
+        : defaults[selection.profile];
+}
+export function deploymentPlan(chain, material, deployed) {
+    return {
+        chain,
+        address: material.address,
+        ...(material.factory ? { factory: material.factory } : {}),
+        ...(material.factoryData ? { factoryData: material.factoryData } : {}),
+        ...(material.factory && material.factoryData
+            ? {
+                initCode: `${material.factory}${material.factoryData.slice(2)}`,
+            }
+            : {}),
+        deployed,
+    };
+}
+export function initDataMaterial(initData) {
+    if (!initData)
+        return undefined;
+    return 'factory' in initData
+        ? {
+            address: initData.address,
+            factory: initData.factory,
+            factoryData: initData.factoryData,
+        }
+        : { address: initData.address };
+}
+export function accountKind(definition) {
+    return definition.kind;
+}

package/dist/src/accounts/erc7579-calls.d.ts

@@ -0,0 +1,4 @@
+import { type Hex } from 'viem';
+import type { AccountCallEncodingInput } from './types.js';
+export declare function encodeErc7579Calls(input: AccountCallEncodingInput): Hex;
+//# sourceMappingURL=erc7579-calls.d.ts.map

package/dist/src/accounts/erc7579-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc7579-calls.d.ts","sourceRoot":"","sources":["../../../accounts/erc7579-calls.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,GAAG,EAGT,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AA4BvD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,GAAG,GAAG,CAqCvE"}

package/dist/src/accounts/erc7579-calls.js

@@ -0,0 +1,57 @@
+import { concatHex, encodeAbiParameters, encodeFunctionData, encodePacked, toBytes, toHex, } from 'viem';
+function executionMode(mode) {
+    return encodePacked(['bytes1', 'bytes1', 'bytes4', 'bytes4', 'bytes22'], [
+        toHex(toBytes(mode === 'batch' ? '0x01' : '0x00', { size: 1 })),
+        '0x00',
+        '0x00000000',
+        '0x00000000',
+        `0x${'00'.repeat(22)}`,
+    ]);
+}
+const executeAbi = [
+    {
+        type: 'function',
+        name: 'execute',
+        inputs: [
+            { name: 'execMode', type: 'bytes32' },
+            { name: 'executionCalldata', type: 'bytes' },
+        ],
+        outputs: [],
+        stateMutability: 'payable',
+    },
+];
+export function encodeErc7579Calls(input) {
+    if (input.calls.length === 0)
+        throw new Error('No calls to encode');
+    if (input.calls.length > 1 && input.mode !== 'batch') {
+        throw new Error('Single execution mode cannot encode multiple calls');
+    }
+    const calldata = input.mode === 'batch'
+        ? encodeAbiParameters([
+            {
+                name: 'executionBatch',
+                type: 'tuple[]',
+                components: [
+                    { name: 'target', type: 'address' },
+                    { name: 'value', type: 'uint256' },
+                    { name: 'callData', type: 'bytes' },
+                ],
+            },
+        ], [
+            input.calls.map((call) => ({
+                target: call.target,
+                value: call.value,
+                callData: call.data,
+            })),
+        ])
+        : concatHex([
+            input.calls[0].target,
+            toHex(input.calls[0].value, { size: 32 }),
+            input.calls[0].data,
+        ]);
+    return encodeFunctionData({
+        abi: executeAbi,
+        functionName: 'execute',
+        args: [executionMode(input.mode), calldata],
+    });
+}

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

@@ -1,4 +1,4 @@
-import type { AccountType } from '../types.js';
+import type { AccountType } from './types.js';
 declare class AccountError extends Error {
     private readonly _message;
     private readonly _context;