@aastar/sdk 0.16.6 → 0.16.8

package/dist/sdk/src/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/sdk/src/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,34 +99,31 @@ export class UserOperationBuilder {
             paymasterAndData: userOp.paymasterAndData,
             signature: userOp.signature
         };
-
-        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') {
-                 // Remove leading zeros if present (but keep 0x)
-                 if (val === '0x') return '0x'; // invalid quantity? Should be 0x0?
-                 // JSON-RPC Quantity: 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') {
+                // Remove leading zeros if present (but keep 0x)
+                if (val === '0x')
+                    return '0x'; // invalid quantity? Should be 0x0?
+                // JSON-RPC Quantity: 0x0
+                if (val === '0x0')
+                    return '0x0';
+                return val.replace(/^0x0+(?!$)/, '0x');
+            }
+            return val;
         };
-
-
         result.nonce = toCompactHex(result.nonce);
         result.preVerificationGas = toCompactHex(result.preVerificationGas);
-        
         // Note: Alchemy usually accepts non-padded Quantities for nonce/preVerificationGas.
         // But let's verify if strict padding is required by using viem's pad
-        
         // Alchemy v0.7 Validator seems to reject PADDED Quantities (leads to 'Invalid fields').
         // It accepts COMPACT HEX (e.g. 0x1 instead of 0x0...01).
         // Viem toHex produces compact hex.
-
         return result;
     }
-
     /**
      * Converts a PackedUserOperation to the Alchemy-specific v0.7 JSON format.
      * @param userOp - The packed UserOperation
@@ -190,57 +131,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
@@ -250,7 +180,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);
@@ -259,7 +190,6 @@ export class UserOperationBuilder {
                 result.paymasterPostOpGasLimit = `0x${(options?.paymasterPostOpGasLimit || defaultGasLimit).toString(16)}`;
             }
         }
-
         return result;
     }
 }

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

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

package/{packages/sdk/src/utils/userOp.test.ts → dist/sdk/src/utils/userOp.test.js}

@@ -1,180 +1,142 @@
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { UserOperationBuilder } from './userOp.js';
-import { type Address, type Hex, createPublicClient, http, concat } from 'viem';
-
+import { concat } from 'viem';
 describe('UserOperationBuilder', () => {
-    const MOCK_ADDR = '0x1111111111111111111111111111111111111111' as Address;
-    const MOCK_PM = '0x2222222222222222222222222222222222222222' as Address;
-    const MOCK_TOKEN = '0x3333333333333333333333333333333333333333' as Address;
-
+    const MOCK_ADDR = '0x1111111111111111111111111111111111111111';
+    const MOCK_PM = '0x2222222222222222222222222222222222222222';
+    const MOCK_TOKEN = '0x3333333333333333333333333333333333333333';
     describe('Gas Packing', () => {
         it('should pack account gas limits', () => {
             const packed = UserOperationBuilder.packAccountGasLimits(100000n, 200000n);
             expect(packed).toBeDefined();
             expect(packed.length).toBeGreaterThan(2);
         });
-
         it('should pack gas fees', () => {
             const packed = UserOperationBuilder.packGasFees(1000000000n, 2000000000n);
             expect(packed).toBeDefined();
             expect(packed.length).toBeGreaterThan(2);
         });
-
         it('should pack paymaster and data', () => {
-            const packed = UserOperationBuilder.packPaymasterAndData(
-                MOCK_PM,
-                250000n,
-                50000n,
-                '0x1234' as Hex
-            );
+            const packed = UserOperationBuilder.packPaymasterAndData(MOCK_PM, 250000n, 50000n, '0x1234');
             expect(packed).toBeDefined();
             expect(packed.startsWith(MOCK_PM.toLowerCase())).toBe(true);
         });
-
         it('should pack PaymasterV4 deposit data', () => {
             const validUntil = BigInt(Math.floor(Date.now() / 1000) + 3600);
             const validAfter = BigInt(Math.floor(Date.now() / 1000));
-            
-            const packed = UserOperationBuilder.packPaymasterV4DepositData(
-                MOCK_PM,
-                250000n,
-                50000n,
-                MOCK_TOKEN,
-                validUntil,
-                validAfter
-            );
+            const packed = UserOperationBuilder.packPaymasterV4DepositData(MOCK_PM, 250000n, 50000n, MOCK_TOKEN, validUntil, validAfter);
             expect(packed).toBeDefined();
             expect(packed.length).toBeGreaterThan(100);
         });
     });
-
-
     describe('UserOp Formatting', () => {
         it('should jsonify UserOp', () => {
             const userOp = {
                 sender: MOCK_ADDR,
                 nonce: 0n,
-                initCode: '0x' as Hex,
-                callData: '0x' as Hex,
+                initCode: '0x',
+                callData: '0x',
                 accountGasLimits: UserOperationBuilder.packAccountGasLimits(100000n, 200000n),
                 preVerificationGas: 50000n,
                 gasFees: UserOperationBuilder.packGasFees(1000000000n, 2000000000n),
-                paymasterAndData: '0x' as Hex,
-                signature: '0x' as Hex
+                paymasterAndData: '0x',
+                signature: '0x'
             };
-
             const jsonified = UserOperationBuilder.jsonifyUserOp(userOp);
             expect(jsonified).toBeDefined();
             expect(jsonified.sender).toBe(MOCK_ADDR);
         });
-
         it('should convert to Alchemy format', () => {
             const userOp = {
                 sender: MOCK_ADDR,
-                nonce: '0x0' as Hex,
-                initCode: '0x' as Hex,
-                callData: '0x' as Hex,
+                nonce: '0x0',
+                initCode: '0x',
+                callData: '0x',
                 accountGasLimits: UserOperationBuilder.packAccountGasLimits(100000n, 200000n),
-                preVerificationGas: '0xc350' as Hex,
+                preVerificationGas: '0xc350',
                 gasFees: UserOperationBuilder.packGasFees(1000000000n, 2000000000n),
-                paymasterAndData: '0x' as Hex, // no paymaster
-                signature: '0x' as Hex
+                paymasterAndData: '0x', // no paymaster
+                signature: '0x'
             };
-
             const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
             expect(alchemy).toBeDefined();
             expect(alchemy.sender).toBe(MOCK_ADDR);
             expect(alchemy.verificationGasLimit).toBeDefined();
             expect(alchemy.callGasLimit).toBeDefined();
         });
-
         it('should unpack paymaster and data (full v0.7 format)', () => {
-            const pmData = UserOperationBuilder.packPaymasterAndData(
-                MOCK_PM,
-                300000n,
-                100000n,
-                '0x12345678' as Hex
-            );
-            
-             const userOp = {
+            const pmData = UserOperationBuilder.packPaymasterAndData(MOCK_PM, 300000n, 100000n, '0x12345678');
+            const userOp = {
                 sender: MOCK_ADDR,
-                nonce: '0x0' as Hex,
-                initCode: '0x' as Hex,
-                callData: '0x' as Hex,
-                accountGasLimits: '0x' as Hex,
-                preVerificationGas: '0x0' as Hex,
-                gasFees: '0x' as Hex,
+                nonce: '0x0',
+                initCode: '0x',
+                callData: '0x',
+                accountGasLimits: '0x',
+                preVerificationGas: '0x0',
+                gasFees: '0x',
                 paymasterAndData: pmData,
-                signature: '0x' as Hex
+                signature: '0x'
             };
-
             const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
             expect(alchemy.paymaster).toBe(MOCK_PM);
             expect(alchemy.paymasterVerificationGasLimit).toBeDefined();
             expect(alchemy.paymasterPostOpGasLimit).toBeDefined();
             expect(alchemy.paymasterData).toBe('0x12345678');
         });
-
         it('should unpack paymaster and data (legacy format fallback)', () => {
-             // Not enough bytes for Gas Limits, treated as paymaster + data
-             const legacyPmData = concat([MOCK_PM, '0xabcdef' as Hex]) as Hex;
-             
+            // Not enough bytes for Gas Limits, treated as paymaster + data
+            const legacyPmData = concat([MOCK_PM, '0xabcdef']);
             const userOp = {
                 sender: MOCK_ADDR,
-                nonce: '0x0' as Hex,
-                initCode: '0x' as Hex,
-                callData: '0x' as Hex,
-                accountGasLimits: '0x' as Hex,
-                preVerificationGas: '0x0' as Hex,
-                gasFees: '0x' as Hex,
+                nonce: '0x0',
+                initCode: '0x',
+                callData: '0x',
+                accountGasLimits: '0x',
+                preVerificationGas: '0x0',
+                gasFees: '0x',
                 paymasterAndData: legacyPmData,
-                signature: '0x' as Hex
+                signature: '0x'
             };
-
             const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
             expect(alchemy.paymaster).toBe(MOCK_PM);
             expect(alchemy.paymasterData).toBe('0xabcdef');
             expect(alchemy.paymasterVerificationGasLimit).toBeDefined(); // defaults
         });
-
         it('should unpack initCode into factory and factoryData', () => {
             const factory = MOCK_ADDR;
-            const factoryData = '0xdeadbeef' as Hex;
-            const initCode = concat([factory, factoryData]) as Hex;
-
+            const factoryData = '0xdeadbeef';
+            const initCode = concat([factory, factoryData]);
             const userOp = {
                 sender: MOCK_ADDR,
-                nonce: '0x0' as Hex,
+                nonce: '0x0',
                 initCode: initCode,
-                callData: '0x' as Hex,
-                accountGasLimits: '0x' as Hex,
-                preVerificationGas: '0x0' as Hex,
-                gasFees: '0x' as Hex,
-                paymasterAndData: '0x' as Hex,
-                signature: '0x' as Hex
+                callData: '0x',
+                accountGasLimits: '0x',
+                preVerificationGas: '0x0',
+                gasFees: '0x',
+                paymasterAndData: '0x',
+                signature: '0x'
             };
-
             const alchemy = UserOperationBuilder.toAlchemyUserOperation(userOp);
             expect(alchemy.factory.toLowerCase()).toBe(factory.toLowerCase());
             expect(alchemy.factoryData).toBe(factoryData);
         });
         it('should jsonify various types', () => {
-             const userOp = {
+            const userOp = {
                 sender: MOCK_ADDR,
                 nonce: 123, // number
-                initCode: '0x' as Hex,
-                callData: '0x' as Hex,
-                accountGasLimits: '0x' as Hex,
-                preVerificationGas: '0x10' as Hex, // string
-                gasFees: '0x' as Hex,
-                paymasterAndData: '0x' as Hex,
-                signature: '0x' as Hex
+                initCode: '0x',
+                callData: '0x',
+                accountGasLimits: '0x',
+                preVerificationGas: '0x10', // string
+                gasFees: '0x',
+                paymasterAndData: '0x',
+                signature: '0x'
             };
             const json = UserOperationBuilder.jsonifyUserOp(userOp);
             expect(json.nonce).toBe('0x7b');
             expect(json.preVerificationGas).toBe('0x10');
         });
-
         it('should handle leading zeros in string quantities for Alchemy', () => {
             const userOp = {
                 sender: MOCK_ADDR,
@@ -182,9 +144,9 @@ describe('UserOperationBuilder', () => {
                 preVerificationGas: '0x0', // valid zero
                 // ... others
             };
-             const json = UserOperationBuilder.jsonifyUserOp(userOp);
-             expect(json.nonce).toBe('0x1'); // compact
-             expect(json.preVerificationGas).toBe('0x0');
+            const json = UserOperationBuilder.jsonifyUserOp(userOp);
+            expect(json.nonce).toBe('0x1'); // compact
+            expect(json.preVerificationGas).toBe('0x0');
         });
     });
 });