@rhinestone/sdk 2.0.0-beta.9 → 2.1.0

package/dist/src/accounts/kernel.js

@@ -1,272 +0,0 @@
-import { concat, concatHex, decodeAbiParameters, decodeFunctionData, domainSeparator, encodeAbiParameters, encodeFunctionData, getContractAddress, keccak256, parseAbi, stringToHex, toHex, zeroAddress, zeroHash, } from 'viem';
-import { entryPoint07Abi, entryPoint07Address, getUserOperationHash, toSmartAccount, } from 'viem/account-abstraction';
-import { getSetup as getModuleSetup } from '../modules/index.js';
-import { MODULE_TYPE_ID_EXECUTOR, MODULE_TYPE_ID_FALLBACK, MODULE_TYPE_ID_HOOK, MODULE_TYPE_ID_VALIDATOR, } from '../modules/common.js';
-import { getMockSignature } from '../modules/validators/index.js';
-import { AccountConfigurationNotSupportedError, Eip712DomainNotAvailableError, } from './error.js';
-import { encode7579Calls, getAccountNonce } from './utils.js';
-const KERNEL_META_FACTORY_ADDRESS = '0xd703aae79538628d27099b8c4f621be4ccd142d5';
-const KERNEL_IMPLEMENTATION_ADDRESS = '0xd6cedde84be40893d153be9d467cd6ad37875b28';
-const KERNEL_FACTORY_ADDRESS = '0x2577507b78c2008ff367261cb6285d44ba5ef2e9';
-const KERNEL_BYTECODE = '0x603d3d8160223d3973d6cedde84be40893d153be9d467cd6ad37875b2860095155f3363d3d373d3d363d7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc545af43d6000803e6038573d6000fd5b3d6000f3';
-const KERNEL_VERSION = '0.3.3';
-function getDeployArgs(config) {
-    if (config.initData) {
-        if (!('factory' in config.initData)) {
-            return null;
-        }
-        const factoryData = decodeFunctionData({
-            abi: parseAbi([
-                'function deployWithFactory(address factory,bytes createData,bytes32 salt)',
-            ]),
-            data: config.initData.factoryData,
-        });
-        if (factoryData.functionName !== 'deployWithFactory') {
-            throw new AccountConfigurationNotSupportedError('Invalid factory data', 'kernel');
-        }
-        const factory = factoryData.args[0];
-        const createData = factoryData.args[1];
-        const salt = factoryData.args[2];
-        const implementation = factory.toLowerCase() === KERNEL_FACTORY_ADDRESS
-            ? KERNEL_IMPLEMENTATION_ADDRESS
-            : zeroAddress;
-        if (implementation === zeroAddress) {
-            throw new AccountConfigurationNotSupportedError('Unsupported Kernel implementation', 'kernel');
-        }
-        return {
-            factory: config.initData.factory,
-            factoryData: config.initData.factoryData,
-            implementation,
-            initializationCallData: createData,
-            salt,
-        };
-    }
-    const account = config.account;
-    const salt = account?.salt ?? zeroHash;
-    const moduleSetup = getModuleSetup(config);
-    const rootValidator = concat(['0x01', moduleSetup.validators[0].address]);
-    const hook = zeroAddress;
-    const validatorData = moduleSetup.validators[0].initData;
-    const hookData = '0x';
-    // Install modules via init config
-    const spareValidators = moduleSetup.validators.slice(1);
-    const initConfig = [];
-    for (const module of spareValidators) {
-        initConfig.push(...getInstallData(module));
-    }
-    for (const module of moduleSetup.executors) {
-        initConfig.push(...getInstallData(module));
-    }
-    for (const module of moduleSetup.fallbacks) {
-        initConfig.push(...getInstallData(module));
-    }
-    for (const module of moduleSetup.hooks) {
-        initConfig.push(...getInstallData(module));
-    }
-    const initializationCallData = encodeFunctionData({
-        abi: parseAbi(['function initialize(bytes21,address,bytes,bytes,bytes[])']),
-        functionName: 'initialize',
-        args: [rootValidator, hook, validatorData, hookData, initConfig],
-    });
-    const factoryData = encodeFunctionData({
-        abi: parseAbi(['function deployWithFactory(address,bytes,bytes32)']),
-        functionName: 'deployWithFactory',
-        args: [KERNEL_FACTORY_ADDRESS, initializationCallData, salt],
-    });
-    return {
-        factory: KERNEL_META_FACTORY_ADDRESS,
-        factoryData,
-        salt,
-        implementation: KERNEL_IMPLEMENTATION_ADDRESS,
-        initializationCallData,
-    };
-}
-function getAddress(config) {
-    const deployArgs = getDeployArgs(config);
-    if (!deployArgs) {
-        throw new Error('Cannot derive address: deploy args not available');
-    }
-    const { salt, initializationCallData } = deployArgs;
-    const actualSalt = keccak256(concat([initializationCallData, salt]));
-    return getContractAddress({
-        from: KERNEL_FACTORY_ADDRESS,
-        opcode: 'CREATE2',
-        bytecode: KERNEL_BYTECODE,
-        salt: actualSalt,
-    });
-}
-function getEip712Domain(config, chain) {
-    if (config.initData) {
-        throw new Eip712DomainNotAvailableError('Existing Kernel accounts are not yet supported');
-    }
-    return {
-        name: 'Kernel',
-        version: KERNEL_VERSION,
-        chainId: chain.id,
-        verifyingContract: getAddress(config),
-        salt: zeroHash,
-    };
-}
-function getInstallData(module) {
-    const HOOK_INSTALLED_ADDRESS = '0x0000000000000000000000000000000000000001';
-    switch (module.type) {
-        case MODULE_TYPE_ID_VALIDATOR: {
-            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x', '0x']);
-            const initData = concat([HOOK_INSTALLED_ADDRESS, data]);
-            const validatorId = concat(['0x01', module.address]);
-            return [
-                encodeFunctionData({
-                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
-                    functionName: 'installModule',
-                    args: [module.type, module.address, initData],
-                }),
-                encodeFunctionData({
-                    abi: parseAbi(['function grantAccess(bytes21,bytes4,bool)']),
-                    functionName: 'grantAccess',
-                    args: [validatorId, '0xe9ae5c53', true],
-                }),
-            ];
-        }
-        case MODULE_TYPE_ID_EXECUTOR: {
-            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [module.initData, '0x']);
-            const initData = concat([zeroAddress, data]);
-            return [
-                encodeFunctionData({
-                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
-                    functionName: 'installModule',
-                    args: [module.type, module.address, initData],
-                }),
-            ];
-        }
-        case MODULE_TYPE_ID_FALLBACK: {
-            const [selector, flags, selectorData] = decodeAbiParameters([
-                { name: 'selector', type: 'bytes4' },
-                { name: 'flags', type: 'bytes1' },
-                { name: 'data', type: 'bytes' },
-            ], module.initData);
-            const data = encodeAbiParameters([{ type: 'bytes' }, { type: 'bytes' }], [concat([flags, selectorData]), '0x']);
-            const initData = concat([selector, HOOK_INSTALLED_ADDRESS, data]);
-            return [
-                encodeFunctionData({
-                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
-                    functionName: 'installModule',
-                    args: [module.type, module.address, initData],
-                }),
-            ];
-        }
-        case MODULE_TYPE_ID_HOOK: {
-            return [
-                encodeFunctionData({
-                    abi: parseAbi(['function installModule(uint256,address,bytes)']),
-                    functionName: 'installModule',
-                    args: [module.type, module.address, module.initData],
-                }),
-            ];
-        }
-    }
-}
-async function packSignature(signature, validator, transformSignature = (signature) => signature) {
-    const vId = validator.isRoot ? '0x00' : concat(['0x01', validator.address]);
-    const magicValueSigReplayable = keccak256(toHex('kernel.replayable.signature'));
-    const packedSig = concat([
-        vId,
-        magicValueSigReplayable,
-        transformSignature(signature),
-    ]);
-    return packedSig;
-}
-function wrapMessageHash(messageHash, accountAddress) {
-    const _domainSeparator = domainSeparator({
-        domain: {
-            name: 'Kernel',
-            version: KERNEL_VERSION,
-            chainId: 0,
-            verifyingContract: accountAddress,
-        },
-    });
-    const kernelTypeHash = keccak256(stringToHex('Kernel(bytes32 hash)'));
-    const wrappedMessageHash = keccak256(encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [kernelTypeHash, messageHash]));
-    const digest = keccak256(concatHex(['0x1901', _domainSeparator, wrappedMessageHash]));
-    return digest;
-}
-async function getSmartAccount(client, address, owners, validatorAddress, sign) {
-    return getBaseSmartAccount(address, client, validatorAddress, 'root', async () => {
-        return getMockSignature(owners);
-    }, sign);
-}
-async function getGuardianSmartAccount(client, address, guardians, validatorAddress, sign) {
-    return await getBaseSmartAccount(address, client, validatorAddress, 'validator', async () => {
-        return getMockSignature(guardians);
-    }, async (hash) => {
-        return await sign(hash);
-    });
-}
-async function getBaseSmartAccount(address, client, validatorAddress, validatorType, getStubSignature, signUserOperation) {
-    return await toSmartAccount({
-        client,
-        entryPoint: {
-            abi: entryPoint07Abi,
-            address: entryPoint07Address,
-            version: '0.7',
-        },
-        async decodeCalls() {
-            throw new Error('Not implemented');
-        },
-        async encodeCalls(calls) {
-            return encode7579Calls({
-                mode: {
-                    type: calls.length > 1 ? 'batchcall' : 'call',
-                    revertOnError: false,
-                    selector: '0x',
-                    context: '0x',
-                },
-                callData: calls,
-            });
-        },
-        async getAddress() {
-            return address;
-        },
-        async getFactoryArgs() {
-            return {};
-        },
-        async getNonce() {
-            // Default mode
-            const mode = '0x00';
-            const type = validatorType === 'root' ? '0x00' : '0x01';
-            const identifier = validatorAddress;
-            const nonceKey = '0x0000';
-            const key = concat([mode, type, identifier, nonceKey]);
-            return getAccountNonce(client, {
-                address,
-                entryPointAddress: entryPoint07Address,
-                key: BigInt(key),
-            });
-        },
-        async getStubSignature() {
-            return getStubSignature();
-        },
-        async signMessage() {
-            throw new Error('Not implemented');
-        },
-        async signTypedData() {
-            throw new Error('Not implemented');
-        },
-        async signUserOperation(parameters) {
-            const { chainId = client.chain?.id, ...userOperation } = parameters;
-            if (!chainId)
-                throw new Error('Chain id not found');
-            const hash = getUserOperationHash({
-                userOperation: {
-                    ...userOperation,
-                    sender: userOperation.sender ?? (await this.getAddress()),
-                    signature: '0x',
-                },
-                entryPointAddress: entryPoint07Address,
-                entryPointVersion: '0.7',
-                chainId: chainId,
-            });
-            return await signUserOperation(hash);
-        },
-    });
-}
-export { getEip712Domain, getInstallData, getAddress, getDeployArgs, getSmartAccount, getGuardianSmartAccount, packSignature, wrapMessageHash, };

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

@@ -1,33 +0,0 @@
-import type { Abi, Account, Address, Chain, Hex, PublicClient } from 'viem';
-import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
-import type { Module } from '../modules/common.js';
-import type { OwnerSet, RhinestoneAccountConfig } from '../types.js';
-import { type ValidatorConfig } from './utils.js';
-declare function getDeployArgs(config: RhinestoneAccountConfig): {
-    salt: `0x${string}`;
-    factory: `0x${string}`;
-    factoryData: `0x${string}`;
-    implementation: `0x${string}`;
-    initData: `0x${string}`;
-    initializationCallData: `0x${string}`;
-} | null;
-declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
-declare function getEip712Domain(config: RhinestoneAccountConfig, chain: Chain): {
-    name: string;
-    version: string;
-    chainId: number;
-    verifyingContract: `0x${string}`;
-    salt: "0x0000000000000000000000000000000000000000000000000000000000000000";
-};
-declare function getInstallData(module: Module): `0x${string}`;
-declare function getDefaultValidatorAddress(version: '1.0.2' | '1.2.0' | 'rhinestone-1.0.0-beta' | 'rhinestone-1.0.0' | undefined): Address;
-declare function packSignature(signature: Hex, validator: ValidatorConfig, transformSignature?: (signature: Hex) => Hex, defaultValidatorAddress?: Address): Promise<`0x${string}`>;
-declare function getSmartAccount(client: PublicClient, address: Address, owners: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>, defaultValidatorAddress?: Address): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
-declare function getGuardianSmartAccount(client: PublicClient, address: Address, guardians: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>, defaultValidatorAddress?: Address): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
-declare function signEip7702InitData(config: RhinestoneAccountConfig, eoa: Account): Promise<`0x${string}`>;
-declare function getEip7702InitCall(config: RhinestoneAccountConfig, signature: Hex): {
-    initData: `0x${string}`;
-    contract: `0x${string}`;
-};
-export { getEip712Domain, getInstallData, getAddress, getDefaultValidatorAddress, packSignature, getDeployArgs, getSmartAccount, getGuardianSmartAccount, signEip7702InitData, getEip7702InitCall, };
-//# sourceMappingURL=nexus.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"nexus.d.ts","sourceRoot":"","sources":["../../../accounts/nexus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAe3E,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAA;AAGjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAG/C,OAAO,KAAK,EAAgB,QAAQ,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAM/E,OAAO,EAAoC,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAqBhF,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;SAqHrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAsClD;AAED,iBAAS,eAAe,CAAC,MAAM,EAAE,uBAAuB,EAAE,KAAK,EAAE,KAAK;;;;;;EAarE;AAED,iBAAS,cAAc,CAAC,MAAM,EAAE,MAAM,iBA2BrC;AAED,iBAAS,0BAA0B,CACjC,OAAO,EACH,OAAO,GACP,OAAO,GACP,uBAAuB,GACvB,kBAAkB,GAClB,SAAS,GACZ,OAAO,CAcT;AAED,iBAAe,aAAa,CAC1B,SAAS,EAAE,GAAG,EACd,SAAS,EAAE,eAAe,EAC1B,kBAAkB,GAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAA8B,EACtE,uBAAuB,GAAE,OAAyC,0BAWnE;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,QAAQ,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACjC,uBAAuB,GAAE,OAAyC,iEAYnE;AAED,iBAAe,uBAAuB,CACpC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,QAAQ,EACnB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EACjC,uBAAuB,GAAE,OAAyC,iEAcnE;AAqFD,iBAAe,mBAAmB,CAChC,MAAM,EAAE,uBAAuB,EAC/B,GAAG,EAAE,OAAO,0BA8Bb;AAED,iBAAS,kBAAkB,CAAC,MAAM,EAAE,uBAAuB,EAAE,SAAS,EAAE,GAAG;;;EA0C1E;AA6FD,OAAO,EACL,eAAe,EACf,cAAc,EACd,UAAU,EACV,0BAA0B,EAC1B,aAAa,EACb,aAAa,EACb,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,GACnB,CAAA"}