@aastar/sdk 0.18.0 → 0.20.1

package/dist/utils/roleData.d.ts

@@ -1,66 +0,0 @@
-import { type Hex, type Address } from 'viem';
-export declare const RoleIds: {
-    readonly PAYMASTER_SUPER: `0x${string}`;
-    readonly DVT: `0x${string}`;
-    readonly PAYMASTER_AOA: `0x${string}`;
-    readonly KMS: `0x${string}`;
-    readonly COMMUNITY: `0x${string}`;
-    readonly ENDUSER: `0x${string}`;
-    readonly ANODE: `0x${string}`;
-};
-export type RoleId = typeof RoleIds[keyof typeof RoleIds];
-export declare const RoleDataFactory: {
-    /**
-     * Data for SuperPaymaster Operator (Empty)
-     */
-    paymasterSuper: () => Hex;
-    /**
-     * Data for Generic DVT Role (Empty)
-     */
-    dvt: () => Hex;
-    /**
-     * Data for Community Registration (matches Registry.sol CommunityRoleData)
-     * NOTE: Solidity's abi.encode(struct) adds a 32-byte offset prefix (0x20)
-     * which is required for abi.decode(struct) to work correctly.
-     *
-     * @param params.name Community Name (defaults to 'TestCommunity')
-     * @param params.ensName ENS name (optional)
-     * @param params.website Website URL (optional)
-     * @param params.description Community description (optional)
-     * @param params.logoURI Logo URI string (optional)
-     * @param params.stakeAmount Stake amount (defaults to 0)
-     */
-    community: (params?: {
-        name?: string;
-        ensName?: string;
-        website?: string;
-        description?: string;
-        logoURI?: string;
-        stakeAmount?: bigint;
-    }) => Hex;
-    /**
-     * Data for EndUser (matches Registry.sol EndUserRoleData)
-     */
-    endUser: (params?: {
-        account?: Address;
-        community?: Address;
-        avatarURI?: string;
-        ensName?: string;
-        stakeAmount?: bigint;
-    }) => Hex;
-    decodeCommunity: (data: Hex) => {
-        name: any;
-        ensName: any;
-        website: any;
-        description: any;
-        logoURI: any;
-        stakeAmount: any;
-    };
-    decodeEndUser: (data: Hex) => {
-        account: any;
-        community: any;
-        avatarURI: any;
-        ensName: any;
-        stakeAmount: any;
-    };
-};

package/dist/utils/roleData.js

@@ -1,128 +0,0 @@
-import { keccak256, stringToBytes, encodeAbiParameters, decodeAbiParameters, zeroAddress } from 'viem';
-export const RoleIds = {
-    PAYMASTER_SUPER: keccak256(stringToBytes('PAYMASTER_SUPER')),
-    DVT: keccak256(stringToBytes('DVT')), // Replaced PAYMASTER
-    PAYMASTER_AOA: keccak256(stringToBytes('PAYMASTER_AOA')),
-    KMS: keccak256(stringToBytes('KMS')),
-    COMMUNITY: keccak256(stringToBytes('COMMUNITY')),
-    ENDUSER: keccak256(stringToBytes('ENDUSER')),
-    ANODE: keccak256(stringToBytes('ANODE'))
-};
-export const RoleDataFactory = {
-    /**
-     * Data for SuperPaymaster Operator (Empty)
-     */
-    paymasterSuper: () => '0x',
-    /**
-     * Data for Generic DVT Role (Empty)
-     */
-    dvt: () => '0x',
-    /**
-     * Data for Community Registration (matches Registry.sol CommunityRoleData)
-     * NOTE: Solidity's abi.encode(struct) adds a 32-byte offset prefix (0x20)
-     * which is required for abi.decode(struct) to work correctly.
-     *
-     * @param params.name Community Name (defaults to 'TestCommunity')
-     * @param params.ensName ENS name (optional)
-     * @param params.website Website URL (optional)
-     * @param params.description Community description (optional)
-     * @param params.logoURI Logo URI string (optional)
-     * @param params.stakeAmount Stake amount (defaults to 0)
-     */
-    community: (params) => {
-        return encodeAbiParameters([{
-                type: 'tuple',
-                components: [
-                    { name: 'name', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'website', type: 'string' },
-                    { name: 'description', type: 'string' },
-                    { name: 'logoURI', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ]
-            }], [[
-                params?.name || 'TestCommunity',
-                params?.ensName || '',
-                params?.website || '',
-                params?.description || '',
-                params?.logoURI || '',
-                params?.stakeAmount || 0n
-            ]]);
-    },
-    /**
-     * Data for EndUser (matches Registry.sol EndUserRoleData)
-     */
-    endUser: (params) => {
-        return encodeAbiParameters([{
-                type: 'tuple',
-                components: [
-                    { name: 'account', type: 'address' },
-                    { name: 'community', type: 'address' },
-                    { name: 'avatarURI', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ]
-            }], [[
-                params?.account || zeroAddress,
-                params?.community || zeroAddress,
-                params?.avatarURI || '',
-                params?.ensName || '',
-                params?.stakeAmount || 0n
-            ]]);
-    },
-    decodeCommunity: (data) => {
-        const decoded = decodeAbiParameters([{
-                type: 'tuple',
-                components: [
-                    { name: 'name', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'website', type: 'string' },
-                    { name: 'description', type: 'string' },
-                    { name: 'logoURI', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ]
-            }], data);
-        const result = decoded[0];
-        // Check if result is array (iterable) or object
-        if (Array.isArray(result)) {
-            const [n, e, w, d, l, s] = result;
-            return { name: n, ensName: e, website: w, description: d, logoURI: l, stakeAmount: s };
-        }
-        else {
-            return {
-                name: result.name,
-                ensName: result.ensName,
-                website: result.website,
-                description: result.description,
-                logoURI: result.logoURI,
-                stakeAmount: result.stakeAmount
-            };
-        }
-    },
-    decodeEndUser: (data) => {
-        const decoded = decodeAbiParameters([{
-                type: 'tuple',
-                components: [
-                    { name: 'account', type: 'address' },
-                    { name: 'community', type: 'address' },
-                    { name: 'avatarURI', type: 'string' },
-                    { name: 'ensName', type: 'string' },
-                    { name: 'stakeAmount', type: 'uint256' }
-                ]
-            }], data);
-        const result = decoded[0];
-        if (Array.isArray(result)) {
-            const [a, c, av, en, s] = result;
-            return { account: a, community: c, avatarURI: av, ensName: en, stakeAmount: s };
-        }
-        else {
-            return {
-                account: result.account,
-                community: result.community,
-                avatarURI: result.avatarURI,
-                ensName: result.ensName,
-                stakeAmount: result.stakeAmount
-            };
-        }
-    }
-};

package/dist/utils/testScenarios.d.ts

@@ -1,33 +0,0 @@
-import { type Address, type Hash, type PublicClient } from 'viem';
-export declare enum UserOpScenarioType {
-    NATIVE = "NATIVE",// Plain ERC-4337, user pays ETH
-    GASLESS_V4 = "GASLESS_V4",// Standard PaymasterV4
-    SUPER_BPNT = "SUPER_BPNT",// SuperPaymaster with bPNT internal payment
-    SUPER_CPNT = "SUPER_CPNT",// SuperPaymaster with cPNT internal payment
-    SUPER_CUSTOM = "SUPER_CUSTOM"
-}
-export interface ScenarioParams {
-    sender: Address;
-    ownerAccount: any;
-    recipient: Address;
-    tokenAddress: Address;
-    amount: bigint;
-    entryPoint: Address;
-    chainId: number;
-    publicClient: PublicClient;
-    paymaster?: Address;
-    operator?: Address;
-    paymasterGasLimit?: bigint;
-    paymasterPostOpGasLimit?: bigint;
-    nonceKey?: bigint;
-    gasToken?: Address;
-}
-export declare class UserOpScenarioBuilder {
-    /**
-     * Builds a signed PackedUserOperation for a token transfer based on the specified scenario.
-     */
-    static buildTransferScenario(type: UserOpScenarioType, params: ScenarioParams): Promise<{
-        userOp: any;
-        opHash: Hash;
-    }>;
-}

package/dist/utils/testScenarios.js

@@ -1,85 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { UserOperationBuilder } from './userOp.js';
-export var UserOpScenarioType;
-(function (UserOpScenarioType) {
-    UserOpScenarioType["NATIVE"] = "NATIVE";
-    UserOpScenarioType["GASLESS_V4"] = "GASLESS_V4";
-    UserOpScenarioType["SUPER_BPNT"] = "SUPER_BPNT";
-    UserOpScenarioType["SUPER_CPNT"] = "SUPER_CPNT";
-    UserOpScenarioType["SUPER_CUSTOM"] = "SUPER_CUSTOM"; // SuperPaymaster with custom token/operator
-})(UserOpScenarioType || (UserOpScenarioType = {}));
-export class UserOpScenarioBuilder {
-    /**
-     * Builds a signed PackedUserOperation for a token transfer based on the specified scenario.
-     */
-    static async buildTransferScenario(type, params) {
-        const { sender, ownerAccount, recipient, tokenAddress, amount, entryPoint, chainId, publicClient, paymaster, operator, paymasterGasLimit = 100000n, paymasterPostOpGasLimit = 40000n, nonceKey = 0n, gasToken } = params;
-        // 1. Build Token Transfer CallData
-        const transferData = encodeFunctionData({
-            abi: [{ name: 'transfer', type: 'function', inputs: [{ type: 'address', name: 'to' }, { type: 'uint256', name: 'amount' }], outputs: [{ type: 'bool' }] }],
-            functionName: 'transfer',
-            args: [recipient, amount]
-        });
-        // 2. Build AA Execute CallData (Assuming SimpleAccount execute)
-        const callData = encodeFunctionData({
-            abi: [{ name: 'execute', type: 'function', inputs: [{ type: 'address' }, { type: 'uint256' }, { type: 'bytes' }] }],
-            functionName: 'execute',
-            args: [tokenAddress, 0n, transferData]
-        });
-        // 3. Build Base UserOperation
-        const userOp = {
-            sender,
-            nonce: await publicClient.readContract({
-                address: entryPoint,
-                abi: [{ name: 'getNonce', type: 'function', inputs: [{ type: 'address' }, { type: 'uint192' }], outputs: [{ type: 'uint256' }] }],
-                functionName: 'getNonce',
-                args: [sender, nonceKey]
-            }),
-            initCode: '0x',
-            callData,
-            accountGasLimits: UserOperationBuilder.packAccountGasLimits(type === UserOpScenarioType.NATIVE ? 75000n : 250000n, 150000n),
-            preVerificationGas: 80000n,
-            gasFees: UserOperationBuilder.packGasFees(2000000000n, 2000000000n), // 2 Gwei
-            paymasterAndData: '0x',
-            signature: '0x'
-        };
-        // 4. Handle Paymaster and Data (PMD)
-        if (type === UserOpScenarioType.NATIVE) {
-            userOp.paymasterAndData = '0x';
-        }
-        else if (type === UserOpScenarioType.GASLESS_V4) {
-            const pm = paymaster;
-            const token = gasToken || tokenAddress;
-            const validUntil = BigInt(Math.floor(Date.now() / 1000) + 3600);
-            const validAfter = BigInt(Math.floor(Date.now() / 1000) - 100);
-            if (!pm)
-                throw new Error('paymaster address required for GASLESS_V4');
-            if (!token)
-                throw new Error('gasToken or tokenAddress required for GASLESS_V4');
-            // PaymasterV4 Deposit-Only Model: includes payment token address
-            userOp.paymasterAndData = UserOperationBuilder.packPaymasterV4DepositData(pm, paymasterGasLimit, // paymasterVerificationGasLimit
-            paymasterPostOpGasLimit, // paymasterPostOpGasLimit
-            token, // Payment token
-            validUntil, validAfter);
-        }
-        else if (type.startsWith('SUPER_')) {
-            if (!paymaster || !operator)
-                throw new Error('Paymaster and Operator required for SuperPM scenarios');
-            userOp.paymasterAndData = UserOperationBuilder.packPaymasterAndData(paymaster, paymasterGasLimit, paymasterPostOpGasLimit, operator);
-        }
-        // 5. Get Hash and Sign
-        const opHash = await UserOperationBuilder.getUserOpHash({
-            userOp,
-            entryPoint,
-            chainId,
-            publicClient
-        });
-        const signature = await ownerAccount.signMessage({
-            message: { raw: opHash }
-        });
-        userOp.signature = signature;
-        // 6. JSON-RPC Hex-Encoding Compliance
-        const jsonUserOp = UserOperationBuilder.jsonifyUserOp(userOp);
-        return { userOp: jsonUserOp, opHash };
-    }
-}

package/dist/utils/userOp.d.ts

@@ -1,89 +0,0 @@
-import { type Address, type Hex, type PublicClient } from 'viem';
-/**
- * ERC-4337 v0.7 Packed UserOperation structure.
- */
-export interface PackedUserOperation {
-    sender: Address;
-    nonce: Hex;
-    initCode: Hex;
-    callData: Hex;
-    accountGasLimits: Hex;
-    preVerificationGas: Hex;
-    gasFees: Hex;
-    paymasterAndData: Hex;
-    signature: Hex;
-}
-export interface UserOpGasParams {
-    verificationGasLimit: bigint;
-    callGasLimit: bigint;
-    preVerificationGas: bigint;
-    maxPriorityFeePerGas: bigint;
-    maxFeePerGas: bigint;
-}
-export interface PaymasterGasParams {
-    paymasterGasLimit: bigint;
-    paymasterPostOpGasLimit: bigint;
-}
-export declare class UserOperationBuilder {
-    /**
-     * Packs verificationGasLimit and callGasLimit into a bytes32 Hex string.
-     */
-    static packAccountGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): Hex;
-    /**
-     * Packs maxPriorityFeePerGas and maxFeePerGas into a bytes32 Hex string.
-     */
-    static packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): Hex;
-    static estimatePreVerificationGasV07(userOp: {
-        sender: Address;
-        nonce: bigint | Hex | number | string;
-        initCode: Hex;
-        callData: Hex;
-        accountGasLimits: Hex;
-        preVerificationGas: bigint | Hex | number | string;
-        gasFees: Hex;
-        paymasterAndData: Hex;
-        signature: Hex;
-    }): bigint;
-    /**
-     * Packs Paymaster parameters into the v0.7 paymasterAndData format.
-     */
-    static packPaymasterAndData(paymaster: Address, paymasterGasLimit: bigint, paymasterPostOpGasLimit: bigint, paymasterData?: Hex): Hex;
-    /**
-     * Pack PaymasterV4 Deposit-Only paymasterAndData
-     *
-     * v0.7 EntryPoint packs: [paymaster(20)][verificationGas(16)][postOpGas(16)][paymasterData]
-     * Contract extracts token at offset 52 = paymasterData[0:20]
-     *
-     * So paymasterData format must be: [token(20)][validUntil(6)][validAfter(6)]
-     *
-     * @param paymaster - Paymaster address (20 bytes)
-     * @param paymentToken - ERC20 token address (20 bytes, FIRST in paymasterData!)
-     * @param validUntil - Validity end timestamp (6 bytes)
-     * @param validAfter - Validity start timestamp (6 bytes)
-     */
-    static packPaymasterV4DepositData(paymaster: Address, paymasterVerificationGasLimit: bigint, paymasterPostOpGasLimit: bigint, paymentToken: Address, validUntil: bigint, validAfter: bigint): Hex;
-    /**
-     * Computes the UserOperation hash for signing.
-     */
-    static getUserOpHash({ userOp, entryPoint, chainId, publicClient }: {
-        userOp: PackedUserOperation;
-        entryPoint: Address;
-        chainId: number;
-        publicClient: PublicClient;
-    }): Promise<Hex>;
-    /**
-     * Formats a PackedUserOperation into a JSON-RPC compatible object with hex-encoded strings.
-     */
-    static jsonifyUserOp(userOp: any): any;
-    /**
-     * Converts a PackedUserOperation to the Alchemy-specific v0.7 JSON format.
-     * @param userOp - The packed UserOperation
-     * @param options - Optional configuration
-     * @param options.paymasterVerificationGasLimit - Gas limit for paymaster verification (default: 200000)
-     * @param options.paymasterPostOpGasLimit - Gas limit for paymaster postOp (default: 200000)
-     */
-    static toAlchemyUserOperation(userOp: any, options?: {
-        paymasterVerificationGasLimit?: bigint;
-        paymasterPostOpGasLimit?: bigint;
-    }): any;
-}

package/dist/utils/userOp.js

@@ -1,231 +0,0 @@
-import { concat, pad, encodeAbiParameters, parseAbiParameters, toBytes } from 'viem';
-export class UserOperationBuilder {
-    /**
-     * Packs verificationGasLimit and callGasLimit into a bytes32 Hex string.
-     */
-    static packAccountGasLimits(verificationGasLimit, callGasLimit) {
-        return concat([
-            pad(`0x${verificationGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
-            pad(`0x${callGasLimit.toString(16)}`, { dir: 'left', size: 16 })
-        ]);
-    }
-    /**
-     * Packs maxPriorityFeePerGas and maxFeePerGas into a bytes32 Hex string.
-     */
-    static packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
-        return concat([
-            pad(`0x${maxPriorityFeePerGas.toString(16)}`, { dir: 'left', size: 16 }),
-            pad(`0x${maxFeePerGas.toString(16)}`, { dir: 'left', size: 16 })
-        ]);
-    }
-    static estimatePreVerificationGasV07(userOp) {
-        const nonce = typeof userOp.nonce === 'bigint'
-            ? userOp.nonce
-            : typeof userOp.nonce === 'number'
-                ? BigInt(userOp.nonce)
-                : BigInt(userOp.nonce);
-        const preVerificationGas = typeof userOp.preVerificationGas === 'bigint'
-            ? userOp.preVerificationGas
-            : typeof userOp.preVerificationGas === 'number'
-                ? BigInt(userOp.preVerificationGas)
-                : BigInt(userOp.preVerificationGas);
-        const encoded = encodeAbiParameters(parseAbiParameters('(address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)'), [
-            [
-                userOp.sender,
-                nonce,
-                userOp.initCode,
-                userOp.callData,
-                userOp.accountGasLimits,
-                preVerificationGas,
-                userOp.gasFees,
-                userOp.paymasterAndData,
-                userOp.signature
-            ]
-        ]);
-        const bytes = toBytes(encoded);
-        let calldataCost = 0n;
-        for (const b of bytes)
-            calldataCost += b === 0 ? 4n : 16n;
-        return calldataCost + 26000n;
-    }
-    /**
-     * Packs Paymaster parameters into the v0.7 paymasterAndData format.
-     */
-    static packPaymasterAndData(paymaster, paymasterGasLimit, paymasterPostOpGasLimit, paymasterData = '0x') {
-        return concat([
-            paymaster,
-            pad(`0x${paymasterGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
-            pad(`0x${paymasterPostOpGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
-            paymasterData
-        ]);
-    }
-    /**
-     * Pack PaymasterV4 Deposit-Only paymasterAndData
-     *
-     * v0.7 EntryPoint packs: [paymaster(20)][verificationGas(16)][postOpGas(16)][paymasterData]
-     * Contract extracts token at offset 52 = paymasterData[0:20]
-     *
-     * So paymasterData format must be: [token(20)][validUntil(6)][validAfter(6)]
-     *
-     * @param paymaster - Paymaster address (20 bytes)
-     * @param paymentToken - ERC20 token address (20 bytes, FIRST in paymasterData!)
-     * @param validUntil - Validity end timestamp (6 bytes)
-     * @param validAfter - Validity start timestamp (6 bytes)
-     */
-    static packPaymasterV4DepositData(paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymentToken, validUntil, validAfter) {
-        return concat([
-            paymaster,
-            pad(`0x${paymasterVerificationGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
-            pad(`0x${paymasterPostOpGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
-            paymentToken,
-            pad(`0x${validUntil.toString(16)}`, { dir: 'left', size: 6 }),
-            pad(`0x${validAfter.toString(16)}`, { dir: 'left', size: 6 })
-        ]);
-    }
-    /**
-     * Computes the UserOperation hash for signing.
-     */
-    static async getUserOpHash({ userOp, entryPoint, chainId, publicClient }) {
-        return await publicClient.readContract({
-            address: entryPoint,
-            abi: [{
-                    type: 'function',
-                    name: 'getUserOpHash',
-                    inputs: [{
-                            type: 'tuple',
-                            components: [
-                                { name: 'sender', type: 'address' },
-                                { name: 'nonce', type: 'uint256' },
-                                { name: 'initCode', type: 'bytes' },
-                                { name: 'callData', type: 'bytes' },
-                                { name: 'accountGasLimits', type: 'bytes32' },
-                                { name: 'preVerificationGas', type: 'uint256' },
-                                { name: 'gasFees', type: 'bytes32' },
-                                { name: 'paymasterAndData', type: 'bytes' },
-                                { name: 'signature', type: 'bytes' }
-                            ]
-                        }],
-                    outputs: [{ type: 'bytes32' }],
-                    stateMutability: 'view'
-                }],
-            functionName: 'getUserOpHash',
-            args: [userOp]
-        });
-    }
-    /**
-     * Formats a PackedUserOperation into a JSON-RPC compatible object with hex-encoded strings.
-     */
-    static jsonifyUserOp(userOp) {
-        // Strict allowlist for ERC-4337 v0.7 PackedUserOperation
-        // Alchemy rejects requests with unknown fields.
-        const result = {
-            sender: userOp.sender,
-            nonce: userOp.nonce,
-            initCode: userOp.initCode,
-            callData: userOp.callData,
-            accountGasLimits: userOp.accountGasLimits,
-            preVerificationGas: userOp.preVerificationGas,
-            gasFees: userOp.gasFees,
-            paymasterAndData: userOp.paymasterAndData,
-            signature: userOp.signature
-        };
-        // Ensure all numeric fields are hex strings and padded
-        // Helper to ensure '0x' prefix and valid hex string
-        const toCompactHex = (val) => {
-            if (typeof val === 'bigint')
-                return `0x${val.toString(16)}`;
-            if (typeof val === 'number')
-                return `0x${val.toString(16)}`;
-            if (typeof val === 'string') {
-                if (val === '0x')
-                    return '0x0';
-                if (val === '0x0')
-                    return '0x0';
-                return val.replace(/^0x0+(?!$)/, '0x');
-            }
-            return val;
-        };
-        result.nonce = toCompactHex(result.nonce);
-        result.preVerificationGas = toCompactHex(result.preVerificationGas);
-        return result;
-    }
-    /**
-     * Converts a PackedUserOperation to the Alchemy-specific v0.7 JSON format.
-     * @param userOp - The packed UserOperation
-     * @param options - Optional configuration
-     * @param options.paymasterVerificationGasLimit - Gas limit for paymaster verification (default: 200000)
-     * @param options.paymasterPostOpGasLimit - Gas limit for paymaster postOp (default: 200000)
-     */
-    static toAlchemyUserOperation(userOp, options) {
-        const toHexStr = (val) => {
-            if (val === undefined || val === null)
-                return undefined;
-            if (typeof val === 'bigint')
-                return `0x${val.toString(16)}`;
-            if (typeof val === 'number')
-                return `0x${val.toString(16)}`;
-            if (typeof val === 'string' && !val.startsWith('0x'))
-                return `0x${val}`;
-            return val;
-        };
-        const result = {
-            sender: userOp.sender,
-            nonce: toHexStr(userOp.nonce),
-            callData: userOp.callData,
-            signature: userOp.signature
-        };
-        // 1. Unpack accountGasLimits: [verificationGasLimit(16)][callGasLimit(16)]
-        if (userOp.accountGasLimits && userOp.accountGasLimits !== '0x') {
-            const val = userOp.accountGasLimits.toString().startsWith('0x') ? userOp.accountGasLimits.slice(2) : userOp.accountGasLimits;
-            const padded = val.padStart(64, '0');
-            const verificationGasLimit = BigInt('0x' + padded.slice(0, 32));
-            const callGasLimit = BigInt('0x' + padded.slice(32, 64));
-            result.verificationGasLimit = `0x${verificationGasLimit.toString(16)}`;
-            result.callGasLimit = `0x${callGasLimit.toString(16)}`;
-        }
-        // 2. Unpack gasFees: [maxPriorityFee(16)][maxFee(16)]
-        if (userOp.gasFees && userOp.gasFees !== '0x') {
-            const val = userOp.gasFees.toString().startsWith('0x') ? userOp.gasFees.slice(2) : userOp.gasFees;
-            const padded = val.padStart(64, '0');
-            const maxPriorityFeePerGas = BigInt('0x' + padded.slice(0, 32));
-            const maxFeePerGas = BigInt('0x' + padded.slice(32, 64));
-            result.maxPriorityFeePerGas = `0x${maxPriorityFeePerGas.toString(16)}`;
-            result.maxFeePerGas = `0x${maxFeePerGas.toString(16)}`;
-        }
-        // 3. PreVerificationGas (Direct copy but ensure hex)
-        if (userOp.preVerificationGas) {
-            result.preVerificationGas = `0x${BigInt(userOp.preVerificationGas).toString(16)}`;
-        }
-        // 4. Unpack initCode -> factory + factoryData
-        if (userOp.initCode && userOp.initCode !== '0x') {
-            const initCode = userOp.initCode.toString();
-            result.factory = initCode.slice(0, 42); // First 20 bytes
-            result.factoryData = '0x' + initCode.slice(42);
-        }
-        // 5. Unpack paymasterAndData -> paymaster + gas limits + paymasterData
-        // Full format: [paymaster(20)][verificationGas(16)][postOpGas(16)][paymasterData]
-        // paymasterData = [token(20)][validUntil(6)][validAfter(6)] = 32 bytes
-        if (userOp.paymasterAndData && userOp.paymasterAndData !== '0x') {
-            const pmd = userOp.paymasterAndData.toString().startsWith('0x') ? userOp.paymasterAndData.slice(2) : userOp.paymasterAndData;
-            // Check if we have full format with gas limits (at least 20+16+16 = 52 bytes = 104 hex chars)
-            if (pmd.length >= 104) {
-                // Full v0.7 packed format
-                result.paymaster = '0x' + pmd.slice(0, 40); // bytes 0-19 (20 bytes)
-                const vGas = BigInt('0x' + pmd.slice(40, 72)); // bytes 20-35 (16 bytes)
-                const pGas = BigInt('0x' + pmd.slice(72, 104)); // bytes 36-51 (16 bytes)
-                result.paymasterVerificationGasLimit = `0x${vGas.toString(16)}`;
-                result.paymasterPostOpGasLimit = `0x${pGas.toString(16)}`;
-                result.paymasterData = '0x' + pmd.slice(104); // bytes 52+ (token + timestamps)
-            }
-            else if (pmd.length >= 40) {
-                // Fallback: assume 52-byte format without gas limits (old format)
-                result.paymaster = '0x' + pmd.slice(0, 40);
-                result.paymasterData = '0x' + pmd.slice(40);
-                const defaultGasLimit = 200000n;
-                result.paymasterVerificationGasLimit = `0x${(options?.paymasterVerificationGasLimit || defaultGasLimit).toString(16)}`;
-                result.paymasterPostOpGasLimit = `0x${(options?.paymasterPostOpGasLimit || defaultGasLimit).toString(16)}`;
-            }
-        }
-        return result;
-    }
-}