@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

package/dist/src/accounts/startale.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEip712Domain = getEip712Domain;
+exports.getInstallData = getInstallData;
+exports.getAddress = getAddress;
+exports.packSignature = packSignature;
+exports.getDeployArgs = getDeployArgs;
+exports.getSmartAccount = getSmartAccount;
+exports.getSessionSmartAccount = getSessionSmartAccount;
+exports.getGuardianSmartAccount = getGuardianSmartAccount;
+const viem_1 = require("viem");
+const modules_1 = require("../modules");
+const error_1 = require("./error");
+const nexus_1 = require("./nexus");
+const K1_DEFAULT_VALIDATOR_ADDRESS = '0x00000072f286204bb934ed49d8969e86f7dec7b1';
+const STARTALE_VERSION = '1.0.0';
+const IMPLEMENTATION_ADDRESS = '0x000000b8f5f723a680d3d7ee624fe0bc84a6e05a';
+const FACTORY_ADDRESS = '0x0000003B3E7b530b4f981aE80d9350392Defef90';
+const BOOTSTRAP_ADDRESS = '0x000000552A5fAe3Db7a8F3917C435448F49BA6a9';
+const CREATION_CODE = '0x608060405261029d803803806100148161018c565b92833981016040828203126101885781516001600160a01b03811692909190838303610188576020810151906001600160401b03821161018857019281601f8501121561018857835161006e610069826101c5565b61018c565b9481865260208601936020838301011161018857815f926020809301865e8601015260017f754fd8b321c4649cb777ae6fdce7e89e9cceaa31a4f639795c7807eb7f1a27005d823b15610176577f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80546001600160a01b031916821790557fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f80a282511561015e575f8091610146945190845af43d15610156573d91610137610069846101c5565b9283523d5f602085013e6101e0565b505b604051605e908161023f8239f35b6060916101e0565b50505034156101485763b398979f60e01b5f5260045ffd5b634c9c8ce360e01b5f5260045260245ffd5b5f80fd5b6040519190601f01601f191682016001600160401b038111838210176101b157604052565b634e487b7160e01b5f52604160045260245ffd5b6001600160401b0381116101b157601f01601f191660200190565b9061020457508051156101f557805190602001fd5b63d6bda27560e01b5f5260045ffd5b81511580610235575b610215575090565b639996b31560e01b5f9081526001600160a01b0391909116600452602490fd5b50803b1561020d56fe60806040523615605c575f8073ffffffffffffffffffffffffffffffffffffffff7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5416368280378136915af43d5f803e156058573d5ff35b3d5ffd5b00';
+function getDeployArgs(config) {
+    const account = config.account;
+    const salt = account?.salt ?? viem_1.zeroHash;
+    const moduleSetup = (0, modules_1.getSetup)(config);
+    const initData = (0, viem_1.encodeAbiParameters)([{ type: 'address' }, { type: 'bytes' }], [
+        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;}',
+                'function init(BootstrapConfig[] calldata validators,BootstrapConfig[] calldata executors,BootstrapConfig calldata hook,BootstrapConfig[] calldata fallbacks,BootstrapPreValidationHookConfig[] calldata preValidationHooks) external',
+            ]),
+            functionName: 'init',
+            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,
+                })),
+                [],
+            ],
+        }),
+    ]);
+    const factoryData = (0, viem_1.encodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(['function createAccount(bytes,bytes32)']),
+        functionName: 'createAccount',
+        args: [initData, salt],
+    });
+    const initializationCallData = (0, viem_1.encodeFunctionData)({
+        abi: (0, viem_1.parseAbi)(['function initializeAccount(bytes)']),
+        functionName: 'initializeAccount',
+        args: [initData],
+    });
+    return {
+        factory: FACTORY_ADDRESS,
+        factoryData,
+        salt,
+        implementation: IMPLEMENTATION_ADDRESS,
+        initializationCallData,
+    };
+}
+function getAddress(config) {
+    const { factory, salt, initializationCallData } = getDeployArgs(config);
+    const accountInitData = (0, viem_1.encodeAbiParameters)([
+        {
+            name: 'address',
+            type: 'address',
+        },
+        {
+            name: 'calldata',
+            type: 'bytes',
+        },
+    ], [IMPLEMENTATION_ADDRESS, initializationCallData]);
+    const hashedInitcode = (0, viem_1.keccak256)((0, viem_1.concat)([CREATION_CODE, accountInitData]));
+    const hash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes1', 'address', 'bytes32', 'bytes'], ['0xff', factory, salt, hashedInitcode]));
+    const address = (0, viem_1.slice)(hash, 12, 32);
+    return address;
+}
+function getEip712Domain(config, chain) {
+    if (config.initData) {
+        throw new error_1.Eip712DomainNotAvailableError('Existing Startale accounts are not yet supported');
+    }
+    return {
+        name: 'Startale',
+        version: STARTALE_VERSION,
+        chainId: chain.id,
+        verifyingContract: getAddress(config),
+        salt: viem_1.zeroHash,
+    };
+}
+function getInstallData(module) {
+    return (0, nexus_1.getInstallData)(module);
+}
+async function packSignature(signature, validator, transformSignature = (signature) => signature) {
+    return (0, nexus_1.packSignature)(signature, validator, transformSignature, K1_DEFAULT_VALIDATOR_ADDRESS);
+}
+async function getSmartAccount(client, address, owners, validatorAddress, sign) {
+    return (0, nexus_1.getSmartAccount)(client, address, owners, validatorAddress, sign, K1_DEFAULT_VALIDATOR_ADDRESS);
+}
+async function getSessionSmartAccount(client, address, session, validatorAddress, enableData, sign) {
+    return (0, nexus_1.getSessionSmartAccount)(client, address, session, validatorAddress, enableData, sign, K1_DEFAULT_VALIDATOR_ADDRESS);
+}
+async function getGuardianSmartAccount(client, address, guardians, validatorAddress, sign) {
+    return (0, nexus_1.getGuardianSmartAccount)(client, address, guardians, validatorAddress, sign, K1_DEFAULT_VALIDATOR_ADDRESS);
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=startale.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"startale.test.d.ts","sourceRoot":"","sources":["../../../accounts/startale.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const common_1 = require("../modules/common");
+const startale_1 = require("./startale");
+const MOCK_MODULE_ADDRESS = '0x28de6501fa86f2e6cd0b33c3aabdaeb4a1b93f3f';
+(0, vitest_1.describe)('Accounts: Startale', () => {
+    (0, vitest_1.describe)('Deploy Args', () => {
+        (0, vitest_1.test)('ECDSA owners', () => {
+            const { factory, factoryData, salt, implementation, initializationCallData, } = (0, startale_1.getDeployArgs)({
+                account: {
+                    type: 'startale',
+                },
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+            });
+            (0, vitest_1.expect)(factory).toEqual('0x0000003B3E7b530b4f981aE80d9350392Defef90');
+            (0, vitest_1.expect)(factoryData).toEqual('0xea6d13ac0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000552a5fae3db7a8f3917c435448f49ba6a9000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000003240984b2f700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000028000000000000000000000000000000000000000000000000000000000000002e0000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e98000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da0994869360000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(salt).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(implementation).toEqual('0x000000b8f5f723a680d3d7ee624fe0bc84a6e05a');
+            (0, vitest_1.expect)(initializationCallData).toEqual('0x4b6a1419000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000003a0000000000000000000000000000000552a5fae3db7a8f3917c435448f49ba6a9000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000003240984b2f700000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000001e0000000000000000000000000000000000000000000000000000000000000028000000000000000000000000000000000000000000000000000000000000002e0000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e98000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000020000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da0994869360000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000005ad9ce1f5035fd62ca96cef16adaaf000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000');
+        });
+        (0, vitest_1.test)('Passkey owner', () => {
+            const { factory, factoryData, salt, implementation, initializationCallData, } = (0, startale_1.getDeployArgs)({
+                account: {
+                    type: 'startale',
+                },
+                owners: {
+                    type: 'passkey',
+                    accounts: [consts_1.passkeyAccount],
+                },
+            });
+            (0, vitest_1.expect)(factory).toEqual('0x0000003B3E7b530b4f981aE80d9350392Defef90');
+            (0, vitest_1.expect)(factoryData).toEqual('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');
+            (0, vitest_1.expect)(salt).toEqual('0x0000000000000000000000000000000000000000000000000000000000000000');
+            (0, vitest_1.expect)(implementation).toEqual('0x000000b8f5f723a680d3d7ee624fe0bc84a6e05a');
+            (0, vitest_1.expect)(initializationCallData).toEqual('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');
+        });
+    });
+    (0, vitest_1.describe)('Get Address', () => {
+        (0, vitest_1.test)('ECDSA owners', () => {
+            const address = (0, startale_1.getAddress)({
+                account: {
+                    type: 'startale',
+                },
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0x614ea8885429c480a83deddd2e050d411da36d4b');
+        });
+        (0, vitest_1.test)('Passkey owner', () => {
+            const address = (0, startale_1.getAddress)({
+                account: {
+                    type: 'startale',
+                },
+                owners: {
+                    type: 'passkey',
+                    accounts: [consts_1.passkeyAccount],
+                },
+            });
+            (0, vitest_1.expect)(address).toEqual('0x4d78f6b273d07f2fd24433ebc7a90d89f0d061ae');
+        });
+    });
+    (0, vitest_1.describe)('Get Install Data', () => {
+        (0, vitest_1.test)('Module', () => {
+            const installData = (0, startale_1.getInstallData)({
+                address: MOCK_MODULE_ADDRESS,
+                initData: '0xabcd',
+                type: common_1.MODULE_TYPE_ID_VALIDATOR,
+                deInitData: '0x0000',
+                additionalContext: '0x0000',
+            });
+            (0, vitest_1.expect)(installData).toEqual('0x9517e29f000000000000000000000000000000000000000000000000000000000000000100000000000000000000000028de6501fa86f2e6cd0b33c3aabdaeb4a1b93f3f00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002abcd000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+    (0, vitest_1.describe)('Get Packed Signature', () => {
+        (0, vitest_1.test)('Mock signature', async () => {
+            const mockSignature = '0x1234';
+            const validator = {
+                address: '0xe35b75e5ec3c04e9cefa8e581fbee859f56edeb4',
+                isRoot: true,
+            };
+            const signature = await (0, startale_1.packSignature)(mockSignature, validator);
+            (0, vitest_1.expect)(signature).toEqual('0xe35b75e5ec3c04e9cefa8e581fbee859f56edeb41234');
+        });
+    });
+});

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

@@ -0,0 +1,33 @@
+import type { Address, Client, Hex } from 'viem';
+import type { RhinestoneConfig } from '../types';
+import { createTransport } from './json-rpc';
+type CallType = 'call' | 'delegatecall' | 'batchcall';
+interface ValidatorConfig {
+    address: Address;
+    isRoot: boolean;
+}
+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: RhinestoneConfig, client: Client): import("viem/account-abstraction").BundlerClient<import("viem").HttpTransport<undefined, false>, undefined, undefined, Client, undefined>;
+export { encode7579Calls, getAccountNonce, getBundlerClient, createTransport };
+export type { ValidatorConfig };
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/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;AAgBhD,OAAO,KAAK,EAAkC,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAE5C,KAAK,QAAQ,GAAG,MAAM,GAAG,cAAc,GAAG,WAAW,CAAA;AAErD,UAAU,eAAe;IACvB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB;AAED,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,gBAAgB,EAAE,MAAM,EAAE,MAAM,6IAuDjE;AAyBD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAA;AAC9E,YAAY,EAAE,eAAe,EAAE,CAAA"}

package/dist/src/accounts/utils.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = void 0;
+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");
+const json_rpc_1 = require("./json-rpc");
+Object.defineProperty(exports, "createTransport", { enumerable: true, get: function () { return json_rpc_1.createTransport; } });
+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}`;
+            case 'biconomy':
+                return `https://bundler.biconomy.io/api/v3/${chainId}/${config.apiKey}`;
+            case 'custom':
+                return typeof config.url === 'string' ? config.url : config.url[chainId];
+        }
+    }
+    function getPaymasterEndpoint(config, chainId) {
+        switch (config.type) {
+            case 'pimlico':
+                return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=${config.apiKey}`;
+            case 'biconomy':
+                return `https://paymaster.biconomy.io/api/v2/${chainId}/${config.apiKey}`;
+            case 'custom':
+                return typeof config.url === 'string' ? config.url : config.url[chainId];
+        }
+    }
+    const { bundler, paymaster } = 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`;
+    const paymasterEndpoint = paymaster
+        ? getPaymasterEndpoint(paymaster, chainId)
+        : undefined;
+    const isCustomBundler = bundler?.type === 'custom';
+    return (0, account_abstraction_1.createBundlerClient)({
+        client,
+        transport: (0, viem_1.http)(endpoint),
+        paymaster: paymasterEndpoint
+            ? (0, account_abstraction_1.createPaymasterClient)({
+                transport: (0, viem_1.http)(paymasterEndpoint),
+            })
+            : undefined,
+        userOperation: isCustomBundler
+            ? undefined
+            : {
+                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),
+    };
+}

package/dist/src/accounts/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../accounts/utils.test.ts"],"names":[],"mappings":""}

package/dist/src/accounts/utils.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("./utils");
+const target = '0xc7c0190e83dedd6f28cad873b7befe9ab06fc0db';
+const data = '0xabcd';
+(0, vitest_1.describe)('Accounts: Utils', () => {
+    (0, vitest_1.describe)('Encode ERC-7579 Calls', () => {
+        (0, vitest_1.test)('single call', () => {
+            const calldata = (0, utils_1.encode7579Calls)({
+                mode: {
+                    type: 'call',
+                    revertOnError: false,
+                    selector: '0x',
+                    context: '0x',
+                },
+                callData: [
+                    {
+                        to: target,
+                        value: 1n,
+                        data,
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(calldata).toEqual('0xe9ae5c53000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000036c7c0190e83dedd6f28cad873b7befe9ab06fc0db0000000000000000000000000000000000000000000000000000000000000001abcd00000000000000000000');
+        });
+        (0, vitest_1.test)('batch call', () => {
+            const calldata = (0, utils_1.encode7579Calls)({
+                mode: {
+                    type: 'batchcall',
+                    revertOnError: false,
+                    selector: '0x',
+                    context: '0x',
+                },
+                callData: [
+                    {
+                        to: target,
+                        value: 1n,
+                        data,
+                    },
+                    {
+                        to: target,
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(calldata).toEqual('0xe9ae5c530100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000c7c0190e83dedd6f28cad873b7befe9ab06fc0db000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000002abcd000000000000000000000000000000000000000000000000000000000000000000000000000000000000c7c0190e83dedd6f28cad873b7befe9ab06fc0db000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000');
+        });
+    });
+});

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

@@ -0,0 +1,34 @@
+import type { Account, WalletClient } from 'viem';
+/**
+ * Adapts a Viem/Wagmi WalletClient into an Account-like signer that the SDK can consume.
+ * Ensures address is set and routes sign methods through the provided client.
+ */
+export declare function walletClientToAccount(walletClient: WalletClient): Account;
+/**
+ * Wraps a Para viem account with custom signing for Rhinestone compatibility.
+ *
+ * Para's MPC signatures use 0/1 v-byte recovery, but Rhinestone/Smart wallets
+ * expect 27/28 v-byte recovery. This wrapper adjusts Para signatures automatically.
+ *
+ * @param viemAccount - The Para viem account to wrap
+ * @param walletId - Optional wallet ID for Para signing operations
+ * @returns Account compatible with Rhinestone SDK
+ *
+ * @example
+ * ```ts
+ * const paraAccount = // ... Para viem account
+ * const wrappedAccount = wrapParaAccount(paraAccount, wallet.id)
+ *
+ * const rhinestoneAccount = await rhinestone.createAccount({
+ *   owners: {
+ *     type: "ecdsa",
+ *     accounts: [wrappedAccount],
+ *   },
+ * })
+ *
+ * // Also works for EIP-7702 (signAuthorization uses original 0/1 v-byte)
+ * const authorization = await wrappedAccount.signAuthorization?.({ ... })
+ * ```
+ */
+export declare function wrapParaAccount(viemAccount: Account, walletId?: string): Account;
+//# sourceMappingURL=walletClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walletClient.d.ts","sourceRoot":"","sources":["../../../accounts/walletClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAOP,YAAY,EACb,MAAM,MAAM,CAAA;AAGb;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CA8CzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAC7B,WAAW,EAAE,OAAO,EACpB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAyCT"}