@rhinestone/sdk 0.1.0 → 0.2.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"nexus.d.ts","sourceRoot":"","sources":["../../accounts/nexus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,GAAG,EAQT,MAAM,MAAM,CAAA;AAQb,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAalD,iBAAe,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;GA8E3D;AAED,iBAAS,gBAAgB,CAAC,MAAM,EAAE,uBAAuB;;;IAqDxD;AAED,iBAAe,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;8rBAoFigH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAA+mP,CAAC;uCAA6lC,CAAC;;;;;;;;;;;;;;;;sfAA81mB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAHvn/B;AAED,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/accounts/nexus.js

@@ -0,0 +1,209 @@
+import { encodeAbiParameters, encodeFunctionData, keccak256, parseAbi, zeroAddress, concat, toHex, } from 'viem';
+import { entryPoint07Address, getUserOperationHash, entryPoint07Abi, toSmartAccount, } from 'viem/account-abstraction';
+import { getSetup as getModuleSetup } from '../modules';
+import { encode7579Calls, getAccountNonce } from './utils';
+const NEXUS_IMPLEMENTATION_ADDRESS = '0x000000004f43c49e93c970e84001853a70923b03';
+const NEXUS_FACTORY_ADDRESS = '0x000000001D1D5004a02bAfAb9de2D6CE5b7B13de';
+const NEXUS_BOOTSTRAP_ADDRESS = '0x00000000D3254452a909E4eeD47455Af7E27C289';
+const K1_MEE_VALIDATOR_ADDRESS = '0x00000000d12897ddadc2044614a9677b191a2d95';
+async function getDeployArgs(config) {
+    const salt = keccak256('0x');
+    const moduleSetup = getModuleSetup(config);
+    const initData = encodeAbiParameters([{ type: 'address' }, { type: 'bytes' }], [
+        NEXUS_BOOTSTRAP_ADDRESS,
+        encodeFunctionData({
+            abi: 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: zeroAddress,
+                    initData: '0x',
+                },
+                moduleSetup.fallbacks.map((f) => ({
+                    module: f.address,
+                    initData: f.initData,
+                })),
+                [],
+                {
+                    registry: moduleSetup.registry,
+                    attesters: moduleSetup.attesters,
+                    threshold: moduleSetup.threshold,
+                },
+            ],
+        }),
+    ]);
+    const factoryData = encodeFunctionData({
+        abi: parseAbi(['function createAccount(bytes,bytes32)']),
+        functionName: 'createAccount',
+        args: [initData, salt],
+    });
+    const creationCode = '0x60806040526102aa803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f90b772c2cb8a51aa7a8a65fc23543c6d022d5b3f8e2b92eed79fba7eef8293005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051606b908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00fea164736f6c634300081b000a';
+    const initializationCallData = encodeFunctionData({
+        abi: parseAbi(['function initializeAccount(bytes)']),
+        functionName: 'initializeAccount',
+        args: [initData],
+    });
+    const accountInitData = encodeAbiParameters([
+        {
+            name: 'address',
+            type: 'address',
+        },
+        {
+            name: 'calldata',
+            type: 'bytes',
+        },
+    ], [NEXUS_IMPLEMENTATION_ADDRESS, initializationCallData]);
+    const hashedInitcode = keccak256(concat([creationCode, accountInitData]));
+    return {
+        factory: NEXUS_FACTORY_ADDRESS,
+        factoryData,
+        salt,
+        hashedInitcode,
+        implementation: NEXUS_IMPLEMENTATION_ADDRESS,
+        initializationCallData,
+    };
+}
+function get7702InitCalls(config) {
+    const eoa = config.eoa;
+    if (!eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const moduleSetup = getModuleSetup(config);
+    return [
+        {
+            to: eoa.address,
+            data: encodeFunctionData({
+                abi: 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: encodeFunctionData({
+                abi: 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: encodeFunctionData({
+                abi: 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: encodeFunctionData({
+                abi: parseAbi([
+                    'function installModule(uint256 moduleTypeId, address module, bytes calldata initData)',
+                ]),
+                functionName: 'installModule',
+                args: [fallback.type, fallback.address, fallback.initData],
+            }),
+        })),
+    ];
+}
+async function get7702SmartAccount(account, client) {
+    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 account.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 = concat([
+                toHex(defaultedKey, { size: 3 }),
+                defaultedValidationMode,
+                zeroAddress,
+            ]);
+            const address = await this.getAddress();
+            return getAccountNonce(client, {
+                address,
+                entryPointAddress: entryPoint07Address,
+                key: BigInt(key),
+            });
+        },
+        async getStubSignature() {
+            const dynamicPart = K1_MEE_VALIDATOR_ADDRESS.substring(2).padEnd(40, '0');
+            return `0x0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000${dynamicPart}000000000000000000000000000000000000000000000000000000000000004181d4b4981670cb18f99f0b4a66446df1bf5b204d24cfcb659bf38ba27a4359b5711649ec2423c5e1247245eba2964679b6a1dbb85c992ae40b9b00c6935b02ff1b00000000000000000000000000000000000000000000000000000000000000`;
+        },
+        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,
+            });
+            if (!account.signMessage) {
+                throw new Error('Sign message not supported by account');
+            }
+            return await account.signMessage({
+                message: { raw: hash },
+            });
+        },
+    });
+}
+export { getDeployArgs, get7702InitCalls, get7702SmartAccount };

package/dist/accounts/safe.d.ts

@@ -0,0 +1,13 @@
+import { RhinestoneAccountConfig } from '../types';
+declare function getDeployArgs(config: RhinestoneAccountConfig): Promise<{
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: null;
+}>;
+declare function get7702InitCalls(): never;
+declare function get7702SmartAccount(): never;
+export { getDeployArgs, 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":"AAWA,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAclD,iBAAe,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;GA0E3D;AAED,iBAAS,gBAAgB,IAAI,KAAK,CAEjC;AAED,iBAAS,mBAAmB,IAAI,KAAK,CAEpC;AAsBD,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/accounts/safe.js

@@ -0,0 +1,100 @@
+import { encodeFunctionData, encodePacked, keccak256, parseAbi, zeroAddress, } from 'viem';
+import { getSetup as getModuleSetup } from '../modules';
+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';
+async function getDeployArgs(config) {
+    {
+        const owners = getOwners(config);
+        const threshold = getThreshold(config);
+        const moduleSetup = getModuleSetup(config);
+        const initData = encodeFunctionData({
+            abi: 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,
+                encodeFunctionData({
+                    abi: 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,
+                zeroAddress,
+                BigInt(0),
+                zeroAddress,
+            ],
+        });
+        const saltNonce = 0n;
+        const factoryData = encodeFunctionData({
+            abi: parseAbi([
+                'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
+            ]),
+            functionName: 'createProxyWithNonce',
+            args: [SAFE_SINGLETON_ADDRESS, initData, saltNonce],
+        });
+        const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initData), saltNonce]));
+        const hashedInitcode = '0xe298282cefe913ab5d282047161268a8222e4bd4ed106300c547894bbefd31ee';
+        return {
+            factory: SAFE_PROXY_FACTORY_ADDRESS,
+            factoryData,
+            salt,
+            hashedInitcode,
+            implementation: SAFE_SINGLETON_ADDRESS,
+            initializationCallData: null,
+        };
+    }
+}
+function get7702InitCalls() {
+    throw new Error('EIP-7702 is not supported for Safe accounts');
+}
+function get7702SmartAccount() {
+    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;
+    }
+}
+export { getDeployArgs, get7702InitCalls, get7702SmartAccount };

package/dist/accounts/utils.d.ts

@@ -0,0 +1,27 @@
+import { type Address, type Hex, type Client } from 'viem';
+import { 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,EACL,KAAK,OAAO,EACZ,KAAK,GAAG,EACR,KAAK,MAAM,EAQZ,MAAM,MAAM,CAAA;AAKb,OAAO,EAAiB,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAEjE,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;AA+BD,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,6IAuBxE;AAED,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/accounts/utils.js

@@ -0,0 +1,155 @@
+import { concatHex, encodeAbiParameters, encodeFunctionData, encodePacked, http, toBytes, toHex, } from 'viem';
+import { readContract } from 'viem/actions';
+import { getAction } from 'viem/utils';
+import { createBundlerClient } from 'viem/account-abstraction';
+function parseCallType(callType) {
+    switch (callType) {
+        case 'call':
+            return '0x00';
+        case 'batchcall':
+            return '0x01';
+        case 'delegatecall':
+            return '0xff';
+    }
+}
+function encodeExecutionMode({ type, revertOnError, selector, context, }) {
+    return encodePacked(['bytes1', 'bytes1', 'bytes4', 'bytes4', 'bytes22'], [
+        toHex(toBytes(parseCallType(type), { size: 1 })),
+        toHex(toBytes(revertOnError ? '0x01' : '0x00', { size: 1 })),
+        toHex(toBytes('0x0', { size: 4 })),
+        toHex(toBytes(selector ?? '0x', { size: 4 })),
+        toHex(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 encodeFunctionData({
+            abi: executeAbi,
+            functionName: 'execute',
+            args: [
+                encodeExecutionMode(mode),
+                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 encodeFunctionData({
+        abi: executeAbi,
+        functionName: 'execute',
+        args: [
+            encodeExecutionMode(mode),
+            concatHex([
+                call.to,
+                toHex(call.value ?? 0n, { size: 32 }),
+                call.data ?? '0x',
+            ]),
+        ],
+    });
+}
+async function getAccountNonce(client, args) {
+    const { address, entryPointAddress, key = 0n } = args;
+    return await getAction(client, 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;
+    if (!bundler) {
+        throw new Error('Bundler is required');
+    }
+    const chainId = client.chain?.id;
+    if (!chainId) {
+        throw new Error('Chain id is required');
+    }
+    const endpoint = getBundlerEndpoint(bundler, chainId);
+    return createBundlerClient({
+        client,
+        transport: http(endpoint),
+        paymaster: true,
+    });
+}
+export { encode7579Calls, getAccountNonce, getBundlerClient };

package/dist/example.js

@@ -1,6 +1,14 @@
 "use strict";
 // import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
-// import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
+// import {
+//   baseSepolia,
+//   arbitrumSepolia,
+//   optimismSepolia,
+//   arbitrum,
+//   base,
+//   optimism,
+//   sepolia,
+// } from 'viem/chains'
 // import {
 //   Chain,
 //   createPublicClient,
@@ -10,7 +18,6 @@
 //   Hex,
 //   http,
 //   parseEther,
-//   parseUnits,
 // } from 'viem'
 // import { createRhinestoneAccount } from './index'
 // const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY
@@ -23,18 +30,17 @@
 // }
 // const sourceChain = baseSepolia
 // const targetChain = arbitrumSepolia
-// const usdc = getTokenAddress(sourceChain)
 // const usdcTarget = getTokenAddress(targetChain)
 // const usdcAmount = 1n
 // const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex)
 // const publicClient = createPublicClient({
 //   chain: sourceChain,
-//   transport: http(),
+//   transport: getTransport(sourceChain),
 // })
 // const fundingClient = createWalletClient({
 //   account: fundingAccount,
 //   chain: sourceChain,
-//   transport: http(),
+//   transport: getTransport(sourceChain),
 // })
 // console.log('new pks', [
 //   generatePrivateKey(),
@@ -42,22 +48,24 @@
 //   generatePrivateKey(),
 // ])
 // const privateKeyA =
-//   '0x04ba71050a787d8b50dbe6cfd35810276699a9eb6dae8c0ac48ccbf8d891324c'
+//   '0xc1d2bc5a55f47783735daad366cefa85a7fbd2619a2639c1f0bef7aafe6217b0'
 // const accountA = privateKeyToAccount(privateKeyA)
 // const privateKeyB =
-//   '0x921e8d0b257173f92791f47c14ecb84f0545a897a7b12f477a9fb743c1d2b2e3'
+//   '0xe076077b3c53583d0eefcad6b30929cc0dfd58e9a2566cf6a059e327ec62fdbe'
 // const accountB = privateKeyToAccount(privateKeyB)
 // const privateKeyC =
-//   '0xc55f1b744fcd9781d6a711fa8347dd41cf6fb662249aede85ed77e95bb2f3aa2'
+//   '0x34afca21087883dba533ecf1d9d705dd2ab8a1933e98db704bb7d9ff83edcaa8'
 // const accountC = privateKeyToAccount(privateKeyC)
 // const rhinestoneAccount = await createRhinestoneAccount({
 //   account: {
-//     type: 'safe',
+//     type: 'nexus',
 //   },
 //   owners: {
 //     type: 'ecdsa',
-//     accounts: [accountA, accountB],
+//     accounts: [accountA, accountB, accountC],
+//     threshold: 2,
 //   },
+//   sessions: [],
 //   rhinestoneApiKey,
 //   deployerAccount: fundingAccount,
 // })
@@ -74,23 +82,6 @@
 //   })
 //   await publicClient.waitForTransactionReceipt({ hash: txHash })
 // }
-// const usdcBalance = await publicClient.readContract({
-//   address: usdc,
-//   abi: erc20Abi,
-//   functionName: 'balanceOf',
-//   args: [address],
-// })
-// if (usdcBalance < usdcAmount) {
-//   const txHash2 = await fundingClient.sendTransaction({
-//     to: usdc,
-//     data: encodeFunctionData({
-//       abi: erc20Abi,
-//       functionName: 'transfer',
-//       args: [address, usdcAmount],
-//     }),
-//   })
-//   await publicClient.waitForTransactionReceipt({ hash: txHash2 })
-// }
 // const bundleId = await rhinestoneAccount.sendTransactions({
 //   sourceChain,
 //   targetChain,
@@ -117,13 +108,27 @@
 // console.log('status', bundleResult.status)
 // function getTokenAddress(chain: Chain) {
 //   switch (chain.id) {
+//     case sepolia.id:
+//       return '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238'
 //     case baseSepolia.id:
 //       return '0x036cbd53842c5426634e7929541ec2318f3dcf7e'
 //     case arbitrumSepolia.id:
 //       return '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'
 //     case optimismSepolia.id:
 //       return '0x5fd84259d66Cd46123540766Be93DFE6D43130D7'
+//     case base.id:
+//       return '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
+//     case arbitrum.id:
+//       return '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'
+//     case optimism.id:
+//       return '0x0b2c639c533813f4aa9d7837caf62653d097ff85'
 //     default:
 //       throw new Error('Unsupported chain')
 //   }
 // }
+// function getTransport(chain: Chain) {
+//   if (chain.id === sepolia.id) {
+//     return http('https://ethereum-sepolia-rpc.publicnode.com')
+//   }
+//   return http()
+// }

package/dist/{services/transaction.d.ts → execution/index.d.ts}

@@ -1,6 +1,6 @@
-import { type BundleResult } from './orchestrator';
+import { type BundleResult } from '../orchestrator';
 import { RhinestoneAccountConfig, Transaction } from '../types';
 declare function sendTransactions(config: RhinestoneAccountConfig, transaction: Transaction): Promise<bigint>;
 declare function waitForExecution(config: RhinestoneAccountConfig, id: bigint): Promise<BundleResult>;
 export { sendTransactions, waitForExecution };
-//# sourceMappingURL=transaction.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../execution/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,YAAY,EAQlB,MAAM,iBAAiB,CAAA;AAaxB,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAY,MAAM,UAAU,CAAA;AAIzE,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,mBA4DzB;AAED,iBAAe,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,EAAE,EAAE,EAAE,MAAM,yBAe1E;AAkCD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAA"}