@charterlabs/rhinestone-sdk 0.0.1

package/dist/accounts/nexus.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeployArgs = getDeployArgs;
+exports.getSmartAccount = getSmartAccount;
+exports.getSessionSmartAccount = getSessionSmartAccount;
+exports.get7702SmartAccount = get7702SmartAccount;
+exports.get7702InitCalls = get7702InitCalls;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const modules_1 = require("../modules");
+const validators_1 = require("../modules/validators");
+const utils_1 = require("./utils");
+const NEXUS_IMPLEMENTATION_ADDRESS = '0x000000004f43c49e93c970e84001853a70923b03';
+const NEXUS_FACTORY_ADDRESS = '0x000000001D1D5004a02bAfAb9de2D6CE5b7B13de';
+const NEXUS_BOOTSTRAP_ADDRESS = '0x00000000D3254452a909E4eeD47455Af7E27C289';
+const K1_MEE_VALIDATOR_ADDRESS = '0x00000000d12897ddadc2044614a9677b191a2d95';
+function getDeployArgs(config) {
+    const salt = (0, viem_1.keccak256)('0x');
+    const moduleSetup = (0, modules_1.getSetup)(config);
+    const initData = (0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'bytes' }], [
+        NEXUS_BOOTSTRAP_ADDRESS,
+        (0, viem_1.encodeFunctionData)({
+            abi: (0, viem_1.parseAbi)([
+                'struct BootstrapConfig {address module;bytes initData;}',
+                'struct BootstrapPreValidationHookConfig {uint256 hookType;address module;bytes data;}',
+                'struct RegistryConfig {address registry;address[] attesters;uint8 threshold;}',
+                'function initNexus(BootstrapConfig[] calldata validators,BootstrapConfig[] calldata executors,BootstrapConfig calldata hook,BootstrapConfig[] calldata fallbacks,BootstrapPreValidationHookConfig[] calldata preValidationHooks,RegistryConfig registryConfig) external',
+            ]),
+            functionName: 'initNexus',
+            args: [
+                moduleSetup.validators.map((v) => ({
+                    module: v.address,
+                    initData: v.initData,
+                })),
+                moduleSetup.executors.map((e) => ({
+                    module: e.address,
+                    initData: e.initData,
+                })),
+                {
+                    module: viem_1.zeroAddress,
+                    initData: '0x',
+                },
+                moduleSetup.fallbacks.map((f) => ({
+                    module: f.address,
+                    initData: f.initData,
+                })),
+                [],
+                {
+                    registry: moduleSetup.registry,
+                    attesters: moduleSetup.attesters,
+                    threshold: moduleSetup.threshold,
+                },
+            ],
+        }),
+    ]);
+    const factoryData = (0, viem_1.encodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(['function createAccount(bytes,bytes32)']),
+        functionName: 'createAccount',
+        args: [initData, salt],
+    });
+    const creationCode = '0x60806040526102aa803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f90b772c2cb8a51aa7a8a65fc23543c6d022d5b3f8e2b92eed79fba7eef8293005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051606b908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00fea164736f6c634300081b000a';
+    const initializationCallData = (0, viem_1.encodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(['function initializeAccount(bytes)']),
+        functionName: 'initializeAccount',
+        args: [initData],
+    });
+    const accountInitData = (0, viem_1.encodeAbiParameters)([
+        {
+            name: 'address',
+            type: 'address',
+        },
+        {
+            name: 'calldata',
+            type: 'bytes',
+        },
+    ], [NEXUS_IMPLEMENTATION_ADDRESS, initializationCallData]);
+    const hashedInitcode = (0, viem_1.keccak256)((0, viem_1.concat)([creationCode, accountInitData]));
+    return {
+        factory: NEXUS_FACTORY_ADDRESS,
+        factoryData,
+        salt,
+        hashedInitcode,
+        implementation: NEXUS_IMPLEMENTATION_ADDRESS,
+        initializationCallData,
+    };
+}
+async function getSmartAccount(client, address, owners, validatorAddress, sign) {
+    return getBaseSmartAccount(address, client, validatorAddress, async () => {
+        return (0, validators_1.getMockSignature)(owners);
+    }, sign);
+}
+async function getSessionSmartAccount(client, address, session, validatorAddress, sign) {
+    return await getBaseSmartAccount(address, client, validatorAddress, async () => {
+        const dummyOpSignature = (0, validators_1.getMockSignature)(session.owners);
+        return (0, validators_1.encodeSmartSessionSignature)(validators_1.SMART_SESSION_MODE_USE, (0, validators_1.getPermissionId)(session), dummyOpSignature);
+    }, async (hash) => {
+        const signature = await sign(hash);
+        return (0, validators_1.encodeSmartSessionSignature)(validators_1.SMART_SESSION_MODE_USE, (0, validators_1.getPermissionId)(session), signature);
+    });
+}
+async function get7702SmartAccount(account, client) {
+    return await getBaseSmartAccount(account.address, client, viem_1.zeroAddress, async () => {
+        const dynamicPart = K1_MEE_VALIDATOR_ADDRESS.substring(2).padEnd(40, '0');
+        return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000`;
+    }, async (hash) => {
+        if (!account.signMessage) {
+            throw new Error('Sign message not supported by account');
+        }
+        return await account.signMessage({
+            message: { raw: hash },
+        });
+    });
+}
+async function getBaseSmartAccount(address, client, nonceValidatorAddress, getStubSignature, signUserOperation) {
+    return await (0, account_abstraction_1.toSmartAccount)({
+        client,
+        entryPoint: {
+            abi: account_abstraction_1.entryPoint07Abi,
+            address: account_abstraction_1.entryPoint07Address,
+            version: '0.7',
+        },
+        async decodeCalls() {
+            throw new Error('Not implemented');
+        },
+        async encodeCalls(calls) {
+            return (0, utils_1.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(args) {
+            const TIMESTAMP_ADJUSTMENT = 16777215n; // max value for size 3
+            const defaultedKey = (args?.key ?? 0n) % TIMESTAMP_ADJUSTMENT;
+            const defaultedValidationMode = '0x00';
+            const key = (0, viem_1.concat)([
+                (0, viem_1.toHex)(defaultedKey, { size: 3 }),
+                defaultedValidationMode,
+                nonceValidatorAddress,
+            ]);
+            return (0, utils_1.getAccountNonce)(client, {
+                address,
+                entryPointAddress: account_abstraction_1.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 = (0, account_abstraction_1.getUserOperationHash)({
+                userOperation: {
+                    ...userOperation,
+                    sender: userOperation.sender ?? (await this.getAddress()),
+                    signature: '0x',
+                },
+                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointVersion: '0.7',
+                chainId: chainId,
+            });
+            return await signUserOperation(hash);
+        },
+    });
+}
+function get7702InitCalls(config) {
+    const eoa = config.eoa;
+    if (!eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const moduleSetup = (0, modules_1.getSetup)(config);
+    return [
+        {
+            to: eoa.address,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: (0, viem_1.parseAbi)([
+                    'function setRegistry(address newRegistry, address[] calldata attesters, uint8 threshold)',
+                ]),
+                functionName: 'setRegistry',
+                args: [
+                    moduleSetup.registry,
+                    moduleSetup.attesters,
+                    moduleSetup.threshold,
+                ],
+            }),
+        },
+        ...moduleSetup.validators.map((validator) => ({
+            to: eoa.address,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: (0, viem_1.parseAbi)([
+                    'function installModule(uint256 moduleTypeId, address module, bytes calldata initData)',
+                ]),
+                functionName: 'installModule',
+                args: [validator.type, validator.address, validator.initData],
+            }),
+        })),
+        ...moduleSetup.executors.map((executor) => ({
+            to: eoa.address,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: (0, viem_1.parseAbi)([
+                    'function installModule(uint256 moduleTypeId, address module, bytes calldata initData)',
+                ]),
+                functionName: 'installModule',
+                args: [executor.type, executor.address, executor.initData],
+            }),
+        })),
+        ...moduleSetup.fallbacks.map((fallback) => ({
+            to: eoa.address,
+            data: (0, viem_1.encodeFunctionData)({
+                abi: (0, viem_1.parseAbi)([
+                    'function installModule(uint256 moduleTypeId, address module, bytes calldata initData)',
+                ]),
+                functionName: 'installModule',
+                args: [fallback.type, fallback.address, fallback.initData],
+            }),
+        })),
+    ];
+}

package/dist/accounts/safe.d.ts

@@ -0,0 +1,17 @@
+import { type Abi, type Address, type Hex, type PublicClient } from 'viem';
+import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
+import type { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
+declare function getDeployArgs(config: RhinestoneAccountConfig): {
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: null;
+};
+declare function getSmartAccount(client: PublicClient, address: Address, owners: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
+declare function getSessionSmartAccount(client: PublicClient, address: Address, session: Session, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
+declare function get7702SmartAccount(): never;
+declare function get7702InitCalls(): never;
+export { getDeployArgs, getSmartAccount, getSessionSmartAccount, get7702InitCalls, get7702SmartAccount, };
+//# sourceMappingURL=safe.d.ts.map

package/dist/accounts/safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe.d.ts","sourceRoot":"","sources":["../../accounts/safe.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,GAAG,EACR,KAAK,OAAO,EAIZ,KAAK,GAAG,EAER,KAAK,YAAY,EAGlB,MAAM,MAAM,CAAA;AACb,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAA;AASjC,OAAO,KAAK,EAAE,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAgB1E,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;EA0ErD;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,iEAWlC;AAED,iBAAe,sBAAsB,CACnC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEAuBlC;AA0ED,iBAAS,mBAAmB,IAAI,KAAK,CAEpC;AAED,iBAAS,gBAAgB,IAAI,KAAK,CAEjC;AAsBD,OAAO,EACL,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EAChB,mBAAmB,GACpB,CAAA"}

package/dist/accounts/safe.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeployArgs = getDeployArgs;
+exports.getSmartAccount = getSmartAccount;
+exports.getSessionSmartAccount = getSessionSmartAccount;
+exports.get7702InitCalls = get7702InitCalls;
+exports.get7702SmartAccount = get7702SmartAccount;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const modules_1 = require("../modules");
+const validators_1 = require("../modules/validators");
+const utils_1 = require("./utils");
+const SAFE_7579_LAUNCHPAD_ADDRESS = '0x7579011aB74c46090561ea277Ba79D510c6C00ff';
+const SAFE_7579_ADAPTER_ADDRESS = '0x7579ee8307284f293b1927136486880611f20002';
+const SAFE_SINGLETON_ADDRESS = '0x29fcb43b46531bca003ddc8fcb67ffe91900c762';
+const SAFE_PROXY_FACTORY_ADDRESS = '0x4e1dcf7ad4e460cfd30791ccc4f9c8a4f820ec67';
+const NO_SAFE_OWNER_ADDRESS = '0xbabe99e62d8bcbd3acf5ccbcfcd4f64fe75e5e72';
+function getDeployArgs(config) {
+    {
+        const owners = getOwners(config);
+        const threshold = getThreshold(config);
+        const moduleSetup = (0, modules_1.getSetup)(config);
+        const initData = (0, viem_1.encodeFunctionData)({
+            abi: (0, viem_1.parseAbi)([
+                'function setup(address[] calldata _owners,uint256 _threshold,address to,bytes calldata data,address fallbackHandler,address paymentToken,uint256 payment, address paymentReceiver) external',
+            ]),
+            functionName: 'setup',
+            args: [
+                owners,
+                threshold,
+                SAFE_7579_LAUNCHPAD_ADDRESS,
+                (0, viem_1.encodeFunctionData)({
+                    abi: (0, viem_1.parseAbi)([
+                        'struct ModuleInit {address module;bytes initData;}',
+                        'function addSafe7579(address safe7579,ModuleInit[] calldata validators,ModuleInit[] calldata executors,ModuleInit[] calldata fallbacks, ModuleInit[] calldata hooks,address[] calldata attesters,uint8 threshold) external',
+                    ]),
+                    functionName: 'addSafe7579',
+                    args: [
+                        SAFE_7579_ADAPTER_ADDRESS,
+                        moduleSetup.validators.map((v) => ({
+                            module: v.address,
+                            initData: v.initData,
+                        })),
+                        moduleSetup.executors.map((e) => ({
+                            module: e.address,
+                            initData: e.initData,
+                        })),
+                        moduleSetup.fallbacks.map((f) => ({
+                            module: f.address,
+                            initData: f.initData,
+                        })),
+                        moduleSetup.hooks.map((h) => ({
+                            module: h.address,
+                            initData: h.initData,
+                        })),
+                        moduleSetup.attesters,
+                        moduleSetup.threshold,
+                    ],
+                }),
+                SAFE_7579_ADAPTER_ADDRESS,
+                viem_1.zeroAddress,
+                BigInt(0),
+                viem_1.zeroAddress,
+            ],
+        });
+        const saltNonce = 0n;
+        const factoryData = (0, viem_1.encodeFunctionData)({
+            abi: (0, viem_1.parseAbi)([
+                'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
+            ]),
+            functionName: 'createProxyWithNonce',
+            args: [SAFE_SINGLETON_ADDRESS, initData, saltNonce],
+        });
+        const salt = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes32', 'uint256'], [(0, viem_1.keccak256)(initData), saltNonce]));
+        const hashedInitcode = '0xe298282cefe913ab5d282047161268a8222e4bd4ed106300c547894bbefd31ee';
+        return {
+            factory: SAFE_PROXY_FACTORY_ADDRESS,
+            factoryData,
+            salt,
+            hashedInitcode,
+            implementation: SAFE_SINGLETON_ADDRESS,
+            initializationCallData: null,
+        };
+    }
+}
+async function getSmartAccount(client, address, owners, validatorAddress, sign) {
+    return getBaseSmartAccount(address, client, validatorAddress, async () => {
+        return (0, validators_1.getMockSignature)(owners);
+    }, sign);
+}
+async function getSessionSmartAccount(client, address, session, validatorAddress, sign) {
+    return await getBaseSmartAccount(address, client, validatorAddress, async () => {
+        const dummyOpSignature = (0, validators_1.getMockSignature)(session.owners);
+        return (0, validators_1.encodeSmartSessionSignature)(validators_1.SMART_SESSION_MODE_USE, (0, validators_1.getPermissionId)(session), dummyOpSignature);
+    }, async (hash) => {
+        const signature = await sign(hash);
+        return (0, validators_1.encodeSmartSessionSignature)(validators_1.SMART_SESSION_MODE_USE, (0, validators_1.getPermissionId)(session), signature);
+    });
+}
+async function getBaseSmartAccount(address, client, validatorAddress, getStubSignature, signUserOperation) {
+    return await (0, account_abstraction_1.toSmartAccount)({
+        client,
+        entryPoint: {
+            abi: account_abstraction_1.entryPoint07Abi,
+            address: account_abstraction_1.entryPoint07Address,
+            version: '0.7',
+        },
+        async decodeCalls() {
+            throw new Error('Not implemented');
+        },
+        async encodeCalls(calls) {
+            return (0, utils_1.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() {
+            const key = (0, viem_1.concat)([validatorAddress, '0x00000000']);
+            const nonce = await (0, utils_1.getAccountNonce)(client, {
+                address,
+                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                key: BigInt(key),
+            });
+            return nonce;
+        },
+        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 = (0, account_abstraction_1.getUserOperationHash)({
+                userOperation: {
+                    ...userOperation,
+                    sender: userOperation.sender ?? (await this.getAddress()),
+                    signature: '0x',
+                },
+                entryPointAddress: account_abstraction_1.entryPoint07Address,
+                entryPointVersion: '0.7',
+                chainId: chainId,
+            });
+            return await signUserOperation(hash);
+        },
+    });
+}
+function get7702SmartAccount() {
+    throw new Error('EIP-7702 is not supported for Safe accounts');
+}
+function get7702InitCalls() {
+    throw new Error('EIP-7702 is not supported for Safe accounts');
+}
+function getOwners(config) {
+    const ownerSet = config.owners;
+    switch (ownerSet.type) {
+        case 'ecdsa':
+            return ownerSet.accounts.map((account) => account.address);
+        case 'passkey':
+            return [NO_SAFE_OWNER_ADDRESS];
+    }
+}
+function getThreshold(config) {
+    const ownerSet = config.owners;
+    switch (ownerSet.type) {
+        case 'ecdsa':
+            return ownerSet.threshold ? BigInt(ownerSet.threshold) : 1n;
+        case 'passkey':
+            return 1n;
+    }
+}

package/dist/accounts/utils.d.ts

@@ -0,0 +1,27 @@
+import type { Address, Client, Hex } from 'viem';
+import type { RhinestoneAccountConfig } from '../types';
+type CallType = 'call' | 'delegatecall' | 'batchcall';
+interface ExecutionMode<callType extends CallType> {
+    type: callType;
+    revertOnError?: boolean;
+    selector?: Hex;
+    context?: Hex;
+}
+interface EncodeCallDataParams<callType extends CallType> {
+    mode: ExecutionMode<callType>;
+    callData: readonly {
+        to: Address;
+        value?: bigint | undefined;
+        data?: Hex | undefined;
+    }[];
+}
+interface GetAccountNonceParams {
+    address: Address;
+    entryPointAddress: Address;
+    key?: bigint;
+}
+declare function encode7579Calls<callType extends CallType>({ mode, callData, }: EncodeCallDataParams<callType>): Hex;
+declare function getAccountNonce(client: Client, args: GetAccountNonceParams): Promise<bigint>;
+declare function getBundlerClient(config: RhinestoneAccountConfig, client: Client): import("viem/account-abstraction").BundlerClient<import("viem").HttpTransport<undefined, false>, undefined, undefined, Client, undefined>;
+export { encode7579Calls, getAccountNonce, getBundlerClient };
+//# sourceMappingURL=utils.d.ts.map

package/dist/accounts/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../accounts/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAchD,OAAO,KAAK,EAAiB,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEtE,KAAK,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAErD,UAAU,aAAa,CAAC,QAAQ,SAAS,QAAQ;IAC/C,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,OAAO,CAAC,EAAE,GAAG,CAAA;CACd;AAED,UAAU,oBAAoB,CAAC,QAAQ,SAAS,QAAQ;IACtD,IAAI,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IAC7B,QAAQ,EAAE,SAAS;QACjB,EAAE,EAAE,OAAO,CAAA;QACX,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QAC1B,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAA;KACvB,EAAE,CAAA;CACJ;AAED,UAAU,qBAAqB;IAC7B,OAAO,EAAE,OAAO,CAAA;IAChB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAkDD,iBAAS,eAAe,CAAC,QAAQ,SAAS,QAAQ,EAAE,EAClD,IAAI,EACJ,QAAQ,GACT,EAAE,oBAAoB,CAAC,QAAQ,CAAC,GAAG,GAAG,CAuFtC;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,MAAM,CAAC,CAmCjB;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,6IAyBxE;AAyBD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/accounts/utils.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode7579Calls = encode7579Calls;
+exports.getAccountNonce = getAccountNonce;
+exports.getBundlerClient = getBundlerClient;
+const viem_1 = require("viem");
+const account_abstraction_1 = require("viem/account-abstraction");
+const actions_1 = require("viem/actions");
+const utils_1 = require("viem/utils");
+function parseCallType(callType) {
+    switch (callType) {
+        case 'call':
+            return '0x00';
+        case 'batchcall':
+            return '0x01';
+        case 'delegatecall':
+            return '0xff';
+    }
+}
+function encodeExecutionMode({ type, revertOnError, selector, context, }) {
+    return (0, viem_1.encodePacked)(['bytes1', 'bytes1', 'bytes4', 'bytes4', 'bytes22'], [
+        (0, viem_1.toHex)((0, viem_1.toBytes)(parseCallType(type), { size: 1 })),
+        (0, viem_1.toHex)((0, viem_1.toBytes)(revertOnError ? '0x01' : '0x00', { size: 1 })),
+        (0, viem_1.toHex)((0, viem_1.toBytes)('0x0', { size: 4 })),
+        (0, viem_1.toHex)((0, viem_1.toBytes)(selector ?? '0x', { size: 4 })),
+        (0, viem_1.toHex)((0, viem_1.toBytes)(context ?? '0x', { size: 22 })),
+    ]);
+}
+function encode7579Calls({ mode, callData, }) {
+    if (callData.length > 1 && mode?.type !== 'batchcall') {
+        throw new Error(`mode ${JSON.stringify(mode)} does not supported for batchcall calldata`);
+    }
+    const executeAbi = [
+        {
+            type: 'function',
+            name: 'execute',
+            inputs: [
+                {
+                    name: 'execMode',
+                    type: 'bytes32',
+                    internalType: 'ExecMode',
+                },
+                {
+                    name: 'executionCalldata',
+                    type: 'bytes',
+                    internalType: 'bytes',
+                },
+            ],
+            outputs: [],
+            stateMutability: 'payable',
+        },
+    ];
+    if (callData.length > 1) {
+        return (0, viem_1.encodeFunctionData)({
+            abi: executeAbi,
+            functionName: 'execute',
+            args: [
+                encodeExecutionMode(mode),
+                (0, viem_1.encodeAbiParameters)([
+                    {
+                        name: 'executionBatch',
+                        type: 'tuple[]',
+                        components: [
+                            {
+                                name: 'target',
+                                type: 'address',
+                            },
+                            {
+                                name: 'value',
+                                type: 'uint256',
+                            },
+                            {
+                                name: 'callData',
+                                type: 'bytes',
+                            },
+                        ],
+                    },
+                ], [
+                    callData.map((arg) => {
+                        return {
+                            target: arg.to,
+                            value: arg.value ?? 0n,
+                            callData: arg.data ?? '0x',
+                        };
+                    }),
+                ]),
+            ],
+        });
+    }
+    const call = callData.length === 0 ? undefined : callData[0];
+    if (!call) {
+        throw new Error('No calls to encode');
+    }
+    return (0, viem_1.encodeFunctionData)({
+        abi: executeAbi,
+        functionName: 'execute',
+        args: [
+            encodeExecutionMode(mode),
+            (0, viem_1.concatHex)([
+                call.to,
+                (0, viem_1.toHex)(call.value ?? 0n, { size: 32 }),
+                call.data ?? '0x',
+            ]),
+        ],
+    });
+}
+async function getAccountNonce(client, args) {
+    const { address, entryPointAddress, key = 0n } = args;
+    return await (0, utils_1.getAction)(client, actions_1.readContract, 'readContract')({
+        address: entryPointAddress,
+        abi: [
+            {
+                inputs: [
+                    {
+                        name: 'sender',
+                        type: 'address',
+                    },
+                    {
+                        name: 'key',
+                        type: 'uint192',
+                    },
+                ],
+                name: 'getNonce',
+                outputs: [
+                    {
+                        name: 'nonce',
+                        type: 'uint256',
+                    },
+                ],
+                stateMutability: 'view',
+                type: 'function',
+            },
+        ],
+        functionName: 'getNonce',
+        args: [address, key],
+    });
+}
+function getBundlerClient(config, client) {
+    function getBundlerEndpoint(config, chainId) {
+        switch (config.type) {
+            case 'pimlico':
+                return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${config.apiKey}`;
+        }
+    }
+    const { bundler } = config;
+    const chainId = client.chain?.id;
+    if (!chainId) {
+        throw new Error('Chain id is required');
+    }
+    const endpoint = bundler
+        ? getBundlerEndpoint(bundler, chainId)
+        : `https://public.pimlico.io/v2/${chainId}/rpc`;
+    return (0, account_abstraction_1.createBundlerClient)({
+        client,
+        transport: (0, viem_1.http)(endpoint),
+        paymaster: true,
+        userOperation: {
+            estimateFeesPerGas: () => getGasPriceEstimate(endpoint),
+        },
+    });
+}
+async function getGasPriceEstimate(bundlerUrl) {
+    const response = await fetch(bundlerUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            id: Date.now(),
+            // TODO do not rely on vendor-specific methods
+            method: 'pimlico_getUserOperationGasPrice',
+            params: [],
+        }),
+    });
+    const json = (await response.json());
+    return {
+        maxFeePerGas: BigInt(json.result.fast.maxFeePerGas),
+        maxPriorityFeePerGas: BigInt(json.result.fast.maxPriorityFeePerGas),
+    };
+}