@aastar/sdk 0.16.11 → 0.16.14

package/dist/utils/roleData.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { RoleDataFactory, RoleIds } from './roleData.js';
+import { zeroAddress } from 'viem';
+describe('RoleDataFactory', () => {
+    it('should have correct role ids', () => {
+        expect(RoleIds.COMMUNITY).toBeDefined();
+        expect(RoleIds.ENDUSER).toBeDefined();
+    });
+    it('should encode and decode community data', () => {
+        const params = {
+            name: 'MyCommunity',
+            ensName: 'my.eth',
+            website: 'https://my.com',
+            description: 'desc',
+            logoURI: 'logo',
+            stakeAmount: 100n
+        };
+        const encoded = RoleDataFactory.community(params);
+        const decoded = RoleDataFactory.decodeCommunity(encoded);
+        expect(decoded.name).toBe(params.name);
+        expect(decoded.stakeAmount).toBe(params.stakeAmount);
+    });
+    it('should encode and decode community data with different params', () => {
+        const params = {
+            name: 'VibeCommunity',
+            ensName: 'vibe.eth',
+            website: 'https://vibe.io',
+            description: 'Good vibes only',
+            logoURI: 'ipfs://logo',
+            stakeAmount: 100n
+        };
+        const encoded = RoleDataFactory.community(params);
+        const decoded = RoleDataFactory.decodeCommunity(encoded);
+        expect(decoded.name).toBe(params.name);
+        expect(decoded.ensName).toBe(params.ensName);
+        expect(decoded.stakeAmount).toBe(params.stakeAmount);
+    });
+    it('should encode community with default values', () => {
+        const encoded = RoleDataFactory.community();
+        const decoded = RoleDataFactory.decodeCommunity(encoded);
+        expect(decoded.name).toBe('TestCommunity');
+        expect(decoded.stakeAmount).toBe(0n);
+    });
+    it('should use default values for community', () => {
+        const encoded = RoleDataFactory.community();
+        const decoded = RoleDataFactory.decodeCommunity(encoded);
+        expect(decoded.name).toBe('TestCommunity');
+        expect(decoded.stakeAmount).toBe(0n);
+    });
+    it('should encode and decode endUser data', () => {
+        const params = {
+            account: '0x1111111111111111111111111111111111111111',
+            community: '0x2222222222222222222222222222222222222222',
+            avatarURI: 'avatar',
+            ensName: 'user.eth',
+            stakeAmount: 50n
+        };
+        const encoded = RoleDataFactory.endUser(params);
+        const decoded = RoleDataFactory.decodeEndUser(encoded);
+        expect(decoded.account).toBe(params.account);
+        expect(decoded.community).toBe(params.community);
+        expect(decoded.stakeAmount).toBe(params.stakeAmount);
+    });
+    it('should encode endUser with default values', () => {
+        const encoded = RoleDataFactory.endUser();
+        const decoded = RoleDataFactory.decodeEndUser(encoded);
+        expect(decoded.account).toBe(zeroAddress);
+        expect(decoded.stakeAmount).toBe(0n);
+    });
+    it('should handle paymasterSuper and dvt (empty data)', () => {
+        expect(RoleDataFactory.paymasterSuper()).toBe('0x');
+        expect(RoleDataFactory.dvt()).toBe('0x');
+    });
+});

package/dist/utils/testScenarios.d.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,85 @@
+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(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/testScenarios.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/testScenarios.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { UserOpScenarioBuilder, UserOpScenarioType } from './testScenarios.js';
+describe('UserOpScenarioBuilder', () => {
+    it('should build NATIVE transfer scenario', async () => {
+        const mockPublicClient = {
+            readContract: vi.fn().mockResolvedValue(0n),
+            chain: { id: 1 }
+        };
+        const params = {
+            sender: '0x0000000000000000000000000000000000000001',
+            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
+            recipient: '0x0000000000000000000000000000000000000002',
+            tokenAddress: '0x0000000000000000000000000000000000000003',
+            amount: 100n,
+            entryPoint: '0x0000000000000000000000000000000000000004',
+            chainId: 1,
+            publicClient: mockPublicClient
+        };
+        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.NATIVE, params);
+        expect(result.userOp.paymasterAndData).toBe('0x');
+        expect(result.userOp.signature).toBe('0xsig');
+    });
+    it('should build GASLESS_V4 transfer scenario', async () => {
+        const mockPublicClient = {
+            readContract: vi.fn().mockResolvedValue(0n),
+            chain: { id: 1 }
+        };
+        const params = {
+            sender: '0x0000000000000000000000000000000000000001',
+            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
+            recipient: '0x0000000000000000000000000000000000000002',
+            tokenAddress: '0x0000000000000000000000000000000000000003',
+            amount: 100n,
+            entryPoint: '0x0000000000000000000000000000000000000004',
+            chainId: 1,
+            publicClient: mockPublicClient,
+            paymaster: '0x0000000000000000000000000000000000000005'
+        };
+        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.GASLESS_V4, params);
+        expect(result.userOp.paymasterAndData).toBeDefined();
+        expect(result.userOp.paymasterAndData).not.toBe('0x');
+    });
+    it('should throw if paymaster missing for v4', async () => {
+        const params = { publicClient: { readContract: vi.fn() }, sender: '0x0000000000000000000000000000000000000001' };
+        await expect(UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.GASLESS_V4, params))
+            .rejects.toThrow();
+    });
+    it('should build SUPER_BPNT scenario', async () => {
+        const mockPublicClient = {
+            readContract: vi.fn().mockResolvedValue(0n),
+            chain: { id: 1 }
+        };
+        const params = {
+            sender: '0x0000000000000000000000000000000000000001',
+            ownerAccount: { signMessage: vi.fn().mockResolvedValue('0xsig') },
+            recipient: '0x0000000000000000000000000000000000000002',
+            tokenAddress: '0x0000000000000000000000000000000000000003',
+            amount: 100n,
+            entryPoint: '0x0000000000000000000000000000000000000004',
+            chainId: 1,
+            publicClient: mockPublicClient,
+            paymaster: '0x0000000000000000000000000000000000000005',
+            operator: '0x0000000000000000000000000000000000000006'
+        };
+        const result = await UserOpScenarioBuilder.buildTransferScenario(UserOpScenarioType.SUPER_BPNT, params);
+        expect(result.userOp.paymasterAndData).toContain('0x');
+    });
+});

package/dist/utils/userOp.d.ts

@@ -0,0 +1,78 @@
+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;
+    /**
+     * 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/{packages/sdk/src/utils/userOp.ts → dist/utils/userOp.js}

@@ -1,92 +1,48 @@
-import { type Address, type Hex, concat, pad, keccak256, encodeAbiParameters, parseAbiParameters, type PublicClient } from 'viem';
-
-/**
- * ERC-4337 v0.7 Packed UserOperation structure.
- */
-export interface PackedUserOperation {
-    sender: Address;
-    nonce: Hex;
-    initCode: Hex;
-    callData: Hex;
-    accountGasLimits: Hex; // bytes32 (packed verificationGasLimit and callGasLimit)
-    preVerificationGas: Hex;
-    gasFees: Hex; // bytes32 (packed maxPriorityFeePerGas and maxFeePerGas)
-    paymasterAndData: Hex;
-    signature: Hex;
-}
-
-export interface UserOpGasParams {
-    verificationGasLimit: bigint;
-    callGasLimit: bigint;
-    preVerificationGas: bigint;
-    maxPriorityFeePerGas: bigint;
-    maxFeePerGas: bigint;
-}
-
-export interface PaymasterGasParams {
-    paymasterGasLimit: bigint;
-    paymasterPostOpGasLimit: bigint;
-}
-
+import { concat, pad } from 'viem';
 export class UserOperationBuilder {
     /**
      * Packs verificationGasLimit and callGasLimit into a bytes32 Hex string.
      */
-    static packAccountGasLimits(verificationGasLimit: bigint, callGasLimit: bigint): Hex {
+    static packAccountGasLimits(verificationGasLimit, callGasLimit) {
         return concat([
             pad(`0x${verificationGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
             pad(`0x${callGasLimit.toString(16)}`, { dir: 'left', size: 16 })
-        ]) as Hex;
+        ]);
     }
-
     /**
      * Packs maxPriorityFeePerGas and maxFeePerGas into a bytes32 Hex string.
      */
-    static packGasFees(maxPriorityFeePerGas: bigint, maxFeePerGas: bigint): Hex {
+    static packGasFees(maxPriorityFeePerGas, maxFeePerGas) {
         return concat([
             pad(`0x${maxPriorityFeePerGas.toString(16)}`, { dir: 'left', size: 16 }),
             pad(`0x${maxFeePerGas.toString(16)}`, { dir: 'left', size: 16 })
-        ]) as Hex;
+        ]);
     }
-
     /**
      * Packs Paymaster parameters into the v0.7 paymasterAndData format.
      */
-    static packPaymasterAndData(
-        paymaster: Address,
-        paymasterGasLimit: bigint,
-        paymasterPostOpGasLimit: bigint,
-        paymasterData: Hex = '0x'
-    ): Hex {
+    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
-        ]) as 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 {
+    static packPaymasterV4DepositData(paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymentToken, validUntil, validAfter) {
         return concat([
             paymaster,
             pad(`0x${paymasterVerificationGasLimit.toString(16)}`, { dir: 'left', size: 16 }),
@@ -94,57 +50,45 @@ export class UserOperationBuilder {
             paymentToken,
             pad(`0x${validUntil.toString(16)}`, { dir: 'left', size: 6 }),
             pad(`0x${validAfter.toString(16)}`, { dir: 'left', size: 6 })
-        ]) as Hex;
+        ]);
     }
-
     /**
      * Computes the UserOperation hash for signing.
      */
-    static async getUserOpHash({
-        userOp,
-        entryPoint,
-        chainId,
-        publicClient
-    }: {
-        userOp: PackedUserOperation;
-        entryPoint: Address;
-        chainId: number;
-        publicClient: PublicClient;
-    }): Promise<Hex> {
-        return await (publicClient as any).readContract({
+    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' }
-                    ]
+                    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'
                 }],
-                outputs: [{ type: 'bytes32' }],
-                stateMutability: 'view'
-            }],
             functionName: 'getUserOpHash',
             args: [userOp]
-        }) as Hex;
+        });
     }
-
     /**
      * Formats a PackedUserOperation into a JSON-RPC compatible object with hex-encoded strings.
      */
-    static jsonifyUserOp(userOp: any): any {
+    static jsonifyUserOp(userOp) {
         // Strict allowlist for ERC-4337 v0.7 PackedUserOperation
         // Alchemy rejects requests with unknown fields.
-        const result: any = {
+        const result = {
             sender: userOp.sender,
             nonce: userOp.nonce,
             initCode: userOp.initCode,
@@ -155,26 +99,26 @@ export class UserOperationBuilder {
             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: bigint | string | number) => {
-             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;
+        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
@@ -182,57 +126,46 @@ export class UserOperationBuilder {
      * @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 {
-        const result: any = {
+    static toAlchemyUserOperation(userOp, options) {
+        const result = {
             sender: userOp.sender,
             nonce: 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)}`;
+            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)}`;
+            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
@@ -242,7 +175,8 @@ export class UserOperationBuilder {
                 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) {
+            }
+            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);
@@ -251,7 +185,6 @@ export class UserOperationBuilder {
                 result.paymasterPostOpGasLimit = `0x${(options?.paymasterPostOpGasLimit || defaultGasLimit).toString(16)}`;
             }
         }
-
         return result;
     }
 }

package/dist/utils/userOp.test.d.ts

@@ -0,0 +1 @@
+export {};