@aastar/sdk 0.14.3 → 0.16.6

package/tests/l4-test-jason1-gasless.ts

@@ -0,0 +1,150 @@
+import { createPublicClient, createWalletClient, http, parseEther, formatEther, type Address, encodeFunctionData, createClient, concat, type Hex, decodeErrorResult } from 'viem';
+import { bundlerActions } from 'viem/account-abstraction';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+// import { PaymasterClient, PaymasterOperator } from '../packages/paymaster/src/V4/index.js';
+import { loadNetworkConfig } from './regression/config.js';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+
+dotenv.config({ path: '.env.sepolia' });
+
+async function main() {
+    const config = await loadNetworkConfig('sepolia');
+    const rpcUrl = process.env.RPC_URL || 'https://eth-sepolia.g.alchemy.com/v2/your-key';
+    
+    const { PaymasterClient, PaymasterOperator } = await import('../packages/paymaster/src/V4/index.js');
+
+    
+    // 1. Roles & Accounts
+    const anniAccount = privateKeyToAccount(process.env.PRIVATE_KEY_ANNI as `0x${string}`);
+    const jasonAccount = privateKeyToAccount(process.env.PRIVATE_KEY_JASON as `0x${string}`);
+    
+    const publicClient = createPublicClient({ chain: sepolia, transport: http(rpcUrl) });
+    const anniWallet = createWalletClient({ account: anniAccount, chain: sepolia, transport: http(rpcUrl) });
+
+    const entryPoint = config.contracts.entryPoint as Address;
+
+    // Load AA addresses from l4-state.json
+    const statePath = path.resolve(process.cwd(), 'scripts/l4-state.json');
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    const jasonAA1 = state.aaAccounts.find((aa: any) => aa.label === 'Jason (AAStar)_AA1')?.address as Address;
+    
+    // CRITICAL: Anni doesn't have PaymasterV4, only SuperPaymaster. 
+    // So we cannot test "Anni sponsoring Jason" with PaymasterV4.
+    // Instead, use Jason's own PaymasterV4 for this test.
+    const jasonPM = state.operators["Jason (AAStar)"].pmV4 as Address;
+    
+    // Resolve Addresses from Config and State
+    const dPNTs = config.contracts.aPNTs as Address;
+
+    console.log('🚀 [FIXED] JASON AA1 Gasless via JASON OWN PM');
+    console.log(`Sender (Jason AA1): ${jasonAA1}`);
+    console.log(`Sponsor (Jason PM): ${jasonPM} (from l4-state.json)`);
+    console.log(`Gas Token: ${dPNTs} (from config)\n`);
+
+
+    // --- STEP 1: ONE-CLICK READINESS & Fix ---
+    console.log('🔍 Step 1: SDK Readiness Check...');
+    const report = await PaymasterOperator.checkGaslessReadiness(
+        publicClient,
+        entryPoint,
+        jasonPM,
+        jasonAA1,
+        dPNTs
+    );
+
+    if (!report.isReady) {
+        console.log('   ⚠️ Issues Detected:', report.issues.join(', '));
+        console.log('\n🛠️ Step 2: Automated Self-Healing (Operator Action)...');
+        const steps = await PaymasterOperator.prepareGaslessEnvironment(
+            anniWallet,
+            publicClient,
+            entryPoint,
+            jasonPM, // Corrected to jasonPM
+            dPNTs,
+            { tokenPriceUSD: 100000000n } // $1.00
+        );
+
+        for (const s of steps) {
+            console.log(`      🚀 [${s.step}] Fixed. Hash: ${s.hash}`);
+            await publicClient.waitForTransactionReceipt({ hash: s.hash as `0x${string}` });
+        }
+    } else {
+        console.log('   ✅ SDK Readiness Check: PERFECT.');
+    }
+
+    // --- STEP 3: USER DEPOSIT ---
+    const userDeposit = await PaymasterClient.getDepositedBalance(publicClient, jasonPM, jasonAA1, dPNTs); // Corrected to jasonPM
+    if (userDeposit < parseEther('50')) {
+        console.log(`\n🏦 Seeding User Deposit (Current: ${formatEther(userDeposit)} dPNTs)...`);
+        
+        const approveHash = await anniWallet.writeContract({
+            address: dPNTs,
+            abi: [{ name: 'approve', type: 'function', inputs: [{ name: 'spender', type: 'address' }, { name: 'value', type: 'uint256' }], outputs: [{ type: 'bool' }], stateMutability: 'nonpayable' }],
+            functionName: 'approve',
+            args: [jasonPM, parseEther('200')] // Corrected to jasonPM
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+
+        // User deposit action is usually done by Client, but funded by Operator in this script
+        const depHash = await PaymasterClient.depositFor(anniWallet, jasonPM, jasonAA1, dPNTs, parseEther('100')); // Corrected to jasonPM
+        await publicClient.waitForTransactionReceipt({ hash: depHash as `0x${string}` });
+        console.log('   ✅ User deposit seeded (100 dPNTs).');
+    }
+
+    // --- STEP 4: GASLESS EXECUTION ---
+    console.log('\n📤 Step 4: Submitting Gasless Transaction...');
+    const transferCalldata = encodeFunctionData({
+        abi: [{ name: 'execute', type: 'function', inputs: [{ name: 'dest', type: 'address' }, { name: 'value', type: 'uint256' }, { name: 'func', type: 'bytes' }], outputs: [], stateMutability: 'nonpayable' }],
+        functionName: 'execute',
+        args: [
+            dPNTs, 
+            0n, 
+            encodeFunctionData({
+                abi: [{ name: 'transfer', type: 'function', inputs: [{ name: 'to', type: 'address' }, { name: 'amount', type: 'uint256' }], outputs: [{ type: 'bool' }], stateMutability: 'nonpayable' }],
+                functionName: 'transfer',
+                args: [anniAccount.address, parseEther('0.1')] // Tiny transfer back
+            })
+        ]
+    });
+
+    const jasonWallet = createWalletClient({ account: jasonAccount, chain: sepolia, transport: http(rpcUrl) });
+
+    const userOpHash = await PaymasterClient.submitGaslessUserOperation(
+        publicClient,
+        jasonWallet,
+        jasonAA1,
+        entryPoint,
+        jasonPM,
+        dPNTs,
+        config.bundlerUrl!, // Changed from process.env.BUNDLER_URL!
+        transferCalldata
+    );
+
+    console.log(`   ✅ UserOp Hash: ${userOpHash}`);
+    console.log('   ⏳ Waiting for block confirmation...');
+
+    // Polling for receipt using Bundler Client
+    const bundlerClient = createPublicClient({ 
+        chain: sepolia, 
+        transport: http(process.env.BUNDLER_URL!) 
+    }).extend(bundlerActions);
+
+    console.log('   ⏳ Waiting for execution (can take up to 60s)...');
+    try {
+        const receipt = await bundlerClient.waitForUserOperationReceipt({ 
+            hash: userOpHash,
+            timeout: 120000 // 2 minutes timeout
+        });
+        
+        console.log(`\n🎉 SUCCESS! Transaction confirmed: ${receipt.receipt.transactionHash}`);
+        console.log(`🔗 Etherscan: https://sepolia.etherscan.io/tx/${receipt.receipt.transactionHash}`);
+    } catch (e) {
+        console.log('\n⌛ Still pending or timed out... check on jiffyscan later.');
+        console.error(e);
+    }
+}
+
+main().catch(console.error);

package/tests/l4-test-jason2-gasless.ts

@@ -0,0 +1,174 @@
+import { createPublicClient, createWalletClient, http, parseEther, formatEther, type Address, encodeFunctionData, concat, type Hex, decodeErrorResult } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+// import { PaymasterClient, PaymasterOperator } from '../packages/paymaster/src/V4/index.ts';
+import { loadNetworkConfig } from './regression/config.js';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+
+dotenv.config({ path: '.env.sepolia' });
+
+async function main() {
+    const config = await loadNetworkConfig('sepolia');
+    const rpcUrl = process.env.RPC_URL || 'https://eth-sepolia.g.alchemy.com/v2/your-key';
+    
+    // Dynamic import to avoid config mismatch
+    const { PaymasterClient, PaymasterOperator } = await import('../packages/paymaster/src/V4/index.js');
+
+    
+    // 1. Roles & Accounts
+    const anniAccount = privateKeyToAccount(process.env.PRIVATE_KEY_ANNI as `0x${string}`);
+    const jasonAccount = privateKeyToAccount(process.env.PRIVATE_KEY_JASON as `0x${string}`);
+    
+    const publicClient = createPublicClient({ chain: sepolia, transport: http(rpcUrl) });
+    const anniWallet = createWalletClient({ account: anniAccount, chain: sepolia, transport: http(rpcUrl) });
+    const jasonWallet = createWalletClient({ account: jasonAccount, chain: sepolia, transport: http(rpcUrl) });
+
+    // Load AA addresses from l4-state.json
+    const statePath = path.resolve(process.cwd(), 'scripts/l4-state.json');
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    const jasonAA2 = state.aaAccounts.find((aa: any) => aa.label === 'Jason (AAStar)_AA2')?.address as Address;
+    const jasonPM = state.operators["Jason (AAStar)"].pmV4 as Address;
+    
+    const dPNTs = config.contracts.aPNTs as Address;
+    const entryPoint = config.contracts.entryPoint as Address;
+
+    console.log('🚀 JASON AA2 Gasless Transaction via JASON OWN Paymaster');
+    console.log(`Jason AA2: ${jasonAA2}`);
+    console.log(`Operator (Jason): ${jasonAccount.address}`);
+    console.log(`Paymaster: ${jasonPM}`);
+    console.log(`Token: ${dPNTs}\n`);
+
+    // --- STEP 1: PRE-FLIGHT CHECK ---
+    console.log('🔍 Step 1: Running SDK Readiness Check...');
+    const report = await PaymasterOperator.checkGaslessReadiness(
+        publicClient,
+        entryPoint,
+        jasonPM,
+        jasonAA2,
+        dPNTs
+    );
+
+    if (!report.isReady) {
+        console.log('   ⚠️ Readiness Check Issues Found:');
+        report.issues.forEach(issue => console.log(`      - ${issue}`));
+        
+        // --- STEP 2: AUTOMATED PREPARATION ---
+        console.log('\n🛠️ Step 2: Running Automated Environment Preparation...');
+        const results = await PaymasterOperator.prepareGaslessEnvironment(
+            jasonWallet,
+            publicClient,
+            entryPoint,
+            jasonPM,
+            dPNTs,
+            {
+                tokenPriceUSD: 100000000n, // $1.00
+                minStake: parseEther('0.1'),
+                minDeposit: parseEther('0.2')
+            }
+        );
+
+        if (results.length > 0) {
+            console.log(`   📝 Sent ${results.length} preparation transactions.`);
+            for (const s of results) {
+                console.log(`      - ${s.step}: ${s.hash}`);
+                await publicClient.waitForTransactionReceipt({ hash: s.hash as `0x${string}` });
+            }
+            console.log('   ✅ Environment Prepared.');
+        } else {
+            console.log('   ✓ Environment already partially prepared (transactions skipped).');
+        }
+    } else {
+        console.log('   ✅ SDK Readiness Check Passed! All systems go.');
+    }
+
+    // --- STEP 3: USER DEPOSIT (If missing) ---
+    console.log('\n💰 Step 3: Checking User Paymaster Deposit...');
+    let userDeposit = await PaymasterClient.getDepositedBalance(publicClient, jasonPM, jasonAA2, dPNTs);
+    console.log(`   Jason AA2 Deposit: ${formatEther(userDeposit)} dPNTs`);
+
+    if (userDeposit < parseEther('10')) {
+        console.log('   🏦 Deposit too low. Seeding 50 dPNTs from Anni EOA...');
+        // Anni EOA (Operator/Community) approves and deposits for Jason
+        const approveHash = await anniWallet.writeContract({
+            address: dPNTs,
+            abi: [{ name: 'approve', type: 'function', inputs: [{ name: 'spender', type: 'address' }, { name: 'value', type: 'uint256' }], outputs: [{ type: 'bool' }], stateMutability: 'nonpayable' }],
+            functionName: 'approve',
+            args: [jasonPM, parseEther('100')]
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+
+        const depositHash = await PaymasterClient.depositFor(anniWallet, jasonPM, jasonAA2, dPNTs, parseEther('50'));
+        await publicClient.waitForTransactionReceipt({ hash: depositHash });
+        console.log('   ✅ 50 dPNTs deposited.');
+    }
+
+    // --- STEP 4: GASLESS TRANSACTION ---
+    console.log('\n📤 Step 4: Submitting Gasless UserOperation...');
+    const transferCalldata = encodeFunctionData({
+        abi: [{ name: 'execute', type: 'function', inputs: [{ name: 'dest', type: 'address' }, { name: 'value', type: 'uint256' }, { name: 'func', type: 'bytes' }], outputs: [], stateMutability: 'nonpayable' }],
+        functionName: 'execute',
+        args: [
+            dPNTs, 
+            0n, 
+            encodeFunctionData({
+                abi: [{ name: 'transfer', type: 'function', inputs: [{ name: 'to', type: 'address' }, { name: 'amount', type: 'uint256' }], outputs: [{ type: 'bool' }], stateMutability: 'nonpayable' }],
+                functionName: 'transfer',
+                args: [anniAccount.address, parseEther('1')] // Transfer 1 dPNT back to Anni
+            })
+        ]
+    });
+
+    try {
+        const userOpHash = await PaymasterClient.submitGaslessUserOperation(
+            publicClient,
+            jasonWallet,
+            jasonAA2,
+            entryPoint,
+            jasonPM,
+            dPNTs,
+            config.bundlerUrl!,
+            transferCalldata
+            // {
+            //    // Let SDK determine dynamic gas prices
+            // }
+        );
+
+        console.log(`   ✅ UserOp submitted! Hash: ${userOpHash}`);
+        console.log('   ⏳ Waiting for execution...');
+
+        let receipt = null;
+        for (let i = 0; i < 20; i++) {
+            const res = await fetch(process.env.BUNDLER_URL!, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: 1,
+                    method: 'eth_getUserOperationReceipt',
+                    params: [userOpHash]
+                })
+            });
+            const data = await res.json();
+            if (data.result) {
+                receipt = data.result;
+                break;
+            }
+            await new Promise(r => setTimeout(r, 5000));
+        }
+
+        if (receipt) {
+            console.log(`   🎉 UserOp Executed! Transaction: ${receipt.receipt.transactionHash}`);
+            console.log(`   ⛽ Gas Used: ${BigInt(receipt.actualGasUsed).toString()}`);
+            console.log(`   💸 Fee Paid: ${formatEther(BigInt(receipt.actualGasCost))} ETH (sponsored by dPNTs)`);
+        } else {
+            console.log('   ❌ Polling timeout. Check Etherscan for status.');
+        }
+
+    } catch (e: any) {
+        console.error('   ❌ Submission Failed:', e.message);
+    }
+}
+
+main().catch(console.error);

package/tests/l4-test-pmv4-deposit.ts

@@ -0,0 +1,111 @@
+// Test 1: Paymaster V4 Deposit Model - depositFor AA user (no SBT required)
+import { createPublicClient, createWalletClient, http, parseEther, formatEther, type Address } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { sepolia } from 'viem/chains';
+import { paymasterV4Actions, tokenActions } from '../packages/core/dist/index.js';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+import * as dotenv from 'dotenv';
+import path from 'path';
+import fs from 'fs';
+
+dotenv.config({ path: path.resolve(process.cwd(), '.env.sepolia') });
+
+async function main() {
+    const config = loadNetworkConfig('sepolia');
+    const publicClient = createPublicClient({ chain: sepolia, transport: http(config.rpcUrl) });
+
+    // Load accounts
+    const bobKey = process.env.PRIVATE_KEY_BOB as `0x${string}`;
+    const bob = privateKeyToAccount(bobKey);
+    const bobClient = createWalletClient({ account: bob, chain: sepolia, transport: http(config.rpcUrl) });
+    
+    // Load state from l4-state.json
+    const statePath = path.resolve(process.cwd(), 'scripts/l4-state.json');
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    
+    // Bob's Paymaster V4 and AA user
+    const bobPaymaster = state.operators.bob.paymasterV4 as Address;
+    const bPNTs = state.operators.bob.tokenAddress as Address;
+    const bobAA1 = state.aaAccounts.find((aa: any) => aa.label === 'Bob (Bread)_AA1')!.address as Address;
+    
+    const pmV4 = paymasterV4Actions(bobPaymaster);
+    
+    console.log('📦 Test 1: Paymaster V4 Deposit Model\n');
+    console.log(`Paymaster V4: ${bobPaymaster}`);
+    console.log(`Test AA User: ${bobAA1}`);
+    console.log(`Gas Token: bPNTs (${bPNTs})\n`);
+    
+    // Step 1: Check if token is supported (tokenPrices should be > 0)
+    console.log('Step 1: Checking token price...');
+    const tokenPrice = await pmV4(publicClient).tokenPrices({ token: bPNTs });
+    console.log(`   Token Price: ${tokenPrice} (${tokenPrice > 0 ? '✅ Supported' : '❌ Not Supported'})`);
+    
+    if (tokenPrice === 0n) {
+        console.log('   ⚠️ Token not supported! Owner needs to call setTokenPrice()');
+        console.log(`   Calling setTokenPrice(${bPNTs}, 20000000) ... (0.02 USD with 8 decimals)`);
+        const setPriceHash = await pmV4(bobClient).setTokenPrice({ 
+            token: bPNTs, 
+            price: 20000000n, // $0.02 with 8 decimals
+            account: bob 
+        });
+        await publicClient.waitForTransactionReceipt({ hash: setPriceHash });
+        console.log('   ✅ Token price set!\n');
+    }
+    
+    //  Step 2: Check AA user's current balance
+    console.log('\nStep 2: Checking AA user balance...');
+    const currentBalance = await pmV4(publicClient).balances({ user: bobAA1, token: bPNTs });
+    console.log(`   Current Balance: ${formatEther(currentBalance)} bPNTs`);
+    
+    // Step 3: depositFor AA user
+    const depositAmount = parseEther('100');
+    console.log(`\nStep 3: Depositing ${formatEther(depositAmount)} bPNTs for AA user...`);
+    
+    // Bob needs bPNTs balance and approval
+    const token = tokenActions();
+    const bobBalance = await token(publicClient).balanceOf({ token: bPNTs, account: bob.address });
+    console.log(`   Bob's bPNTs Balance: ${formatEther(bobBalance)}`);
+    
+    if (bobBalance < depositAmount) {
+        throw new Error(`Bob needs at least ${formatEther(depositAmount)} bPNTs`);
+    }
+    
+    const allowance = await token(publicClient).allowance({ token: bPNTs, owner: bob.address, spender: bobPaymaster });
+    console.log(`   Bob's Allowance: ${formatEther(allowance)}`);
+    
+    if (allowance < depositAmount) {
+        console.log('   Approving Paymaster...');
+        const approveHash = await token(bobClient).approve({ 
+            token: bPNTs, 
+            spender: bobPaymaster, 
+            amount: parseEther('1000'), 
+            account: bob 
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+        console.log('   ✅ Approved!');
+    }
+    
+    console.log('   Calling depositFor...');
+    const depositHash = await pmV4(bobClient).depositFor({ 
+        user: bobAA1, 
+        token: bPNTs, 
+        amount: depositAmount, 
+        account: bob 
+    });
+    await publicClient.waitForTransactionReceipt({ hash: depositHash });
+    console.log(`   ✅ Deposited! Tx: ${depositHash}\n`);
+    
+    // Step 4: Verify new balance
+    console.log('Step 4: Verifying new balance...');
+    const newBalance = await pmV4(publicClient).balances({ user: bobAA1, token: bPNTs });
+    console.log(`   New Balance: ${formatEther(newBalance)} bPNTs`);
+    console.log(`   Delta: +${formatEther(newBalance - currentBalance)} bPNTs\n`);
+    
+    console.log('✅ Test 1 Complete!');
+    console.log(`\nSummary:`);
+    console.log(`   - AA User ${bobAA1} now has ${formatEther(newBalance)} bPNTs deposited`);
+    console.log(`   - User can perform gasless transactions without SBT`);
+    console.log(`   - UserOp paymasterAndData should include bPNTs address at offset 52`);
+}
+
+main().catch(console.error);

package/tests/l4-test-pmv4-gasless.ts

@@ -0,0 +1,166 @@
+// Test 2: Paymaster V4 Gasless Transaction - Transfer using deposited bPNTs
+import { createPublicClient, createWalletClient, http, parseEther, formatEther, encodeFunctionData, type Address } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import {  sepolia } from 'viem/chains';
+import { paymasterV4Actions, tokenActions } from '../packages/core/dist/index.js';
+import { UserOperationBuilder } from '../packages/sdk/dist/utils/userOp.js';
+import { loadNetworkConfig } from '../tests/regression/config.js';
+import * as dotenv from 'dotenv';
+import path from 'path';
+import fs from 'fs';
+
+dotenv.config({ path: path.resolve(process.cwd(), '.env.sepolia') });
+
+async function main() {
+    const config = loadNetworkConfig('sepolia');
+    const publicClient = createPublicClient({ chain: sepolia, transport: http(config.rpcUrl) });
+
+    // Load state from l4-state.json
+    const statePath = path.resolve(process.cwd(), 'scripts/l4-state.json');
+    const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+    
+    // Bob's AA and Paymaster
+    const bobAAInfo = state.aaAccounts.find((aa: any) => aa.label === 'Bob (Bread)_AA1')!;
+    const bobAA = bobAAInfo.address as Address;
+    const bobEOA = bobAAInfo.owner as Address;
+    const bobPaymaster = state.operators.bob.paymasterV4 as Address;
+    const bPNTs = state.operators.bob.tokenAddress as Address;
+    
+    // Bob's private key (owner of AA)
+    const bobKey = process.env.PRIVATE_KEY_BOB as `0x${string}`;
+    const bob = privateKeyToAccount(bobKey);
+    
+    console.log('📦 Test 2: Paymaster V4 Gasless Transaction\n');
+    console.log(`AA Account: ${bobAA}`);
+    console.log(`Paymaster V4: ${bobPaymaster}`);
+    console.log(`Gas Token: bPNTs (${bPNTs})\n`);
+    
+    // Step 1: Verify deposited balance
+    const pmV4 = paymasterV4Actions(bobPaymaster);
+    const depositedBalance = await pmV4(publicClient).balances({ user: bobAA, token: bPNTs });
+    console.log(`Step 1: Verifying deposited balance...`);
+    console.log(`   Deposited Balance: ${formatEther(depositedBalance)} bPNTs`);
+    
+    if (depositedBalance === 0n) {
+        throw new Error('No deposited balance! Run l4-test-pmv4-deposit.ts first');
+    }
+    
+    // Step 2: Construct UserOp for a simple dPNT transfer
+    console.log(`\nStep 2: Constructing gasless UserOp...`);
+    
+    const dPNTs = state.operators.anni.tokenAddress as Address; // Use Anni's token as test recipient token
+    const transferAmount = parseEther('2');
+    const recipient = bobEOA; // Send to Bob's EOA
+    
+    // Encode ERC20 transfer calldata
+    const transferCalldata = encodeFunctionData({
+        abi: [{
+            name: 'transfer',
+            type: 'function',
+            inputs: [
+                { name: 'to', type: 'address' },
+                { name: 'amount', type: 'uint256' }
+            ],
+            outputs: [{ type: 'bool' }],
+            stateMutability: 'nonpayable'
+        }],
+        functionName: 'transfer',
+        args: [recipient, transferAmount]
+    });
+    
+    // Build UserOp
+    const builder = new UserOperationBuilder(
+        config.contracts.entryPoint as Address,
+        publicClient,
+        sepolia.id
+    );
+    
+    const nonce = await publicClient.readContract({
+        address: bobAA,
+        abi: [{
+            name: 'getNonce',
+            type: 'function',
+            inputs: [],
+            outputs: [{ type: 'uint256' }],
+            stateMutability: 'view'
+        }],
+        functionName: 'getNonce'
+    });
+    
+    // Pack paymasterAndData: [paymaster(20)][validUntil(6)][validAfter(6)][token(20)]
+    const currentTimestamp = BigInt(Math.floor(Date.now() / 1000));
+    const paymasterAndData = UserOperationBuilder.packPaymasterV4DepositData(
+        bobPaymaster,
+        currentTimestamp + 3600n, // validUntil: 1 hour from now
+        currentTimestamp - 60n,    // validAfter: 1 minute ago
+        bPNTs   // payment token at offset 52
+    );
+    
+    const userOp = {
+        sender: bobAA,
+        nonce,
+        initCode: '0x' as `0x${string}`, // Empty for already deployed AA
+        callData: encodeFunctionData({
+            abi: [{
+                name: 'execute',
+                type: 'function',
+                inputs: [
+                    { name: 'dest', type: 'address' },
+                    { name: 'value', type: 'uint256' },
+                    { name: 'func', type: 'bytes' }
+                ],
+                outputs: [],
+                stateMutability: 'nonpayable'
+            }],
+            functionName: 'execute',
+            args: [dPNTs, 0n, transferCalldata]
+        }),
+        accountGasLimits: UserOperationBuilder.packAccountGasLimits(200000n, 200000n),
+        preVerificationGas: 100000n,
+        gasFees: UserOperationBuilder.packGasFees(1n, 1n),
+        paymasterAndData,
+        signature: '0x' as `0x${string}` // Placeholder, will be replaced after signing
+    };
+    
+    console.log(`   UserOp constructed`);
+    console.log(`   - Sender: ${userOp.sender}`);
+    console.log(`   - Nonce: ${userOp.nonce}`);
+    console.log(`   - Paymaster: ${bobPaymaster}`);
+    console.log(`   - Payment Token: ${bPNTs} (at offset 52)`);
+    console.log(`   - paymasterAndData length: ${paymasterAndData.length} bytes`);
+    
+    // Step 3: Get UserOp hash and sign
+    console.log(`\nStep 3: Signing UserOp...`);
+    
+    // Create a copy of userOp with empty signature for hash calculation
+    const userOpForHash = { ...userOp, signature: '0x' as `0x${string}` };
+    
+    const userOpHash = await UserOperationBuilder.getUserOpHash({
+        userOp: userOpForHash,
+        entryPoint: config.contracts.entryPoint as Address,
+        chainId: sepolia.id,
+        publicClient
+    });
+    console.log(`   UserOp Hash: ${userOpHash}`);
+    
+    const signature = await bob.signMessage({ message: { raw: userOpHash } });
+    userOp.signature = signature;
+    console.log(`   Signature: ${signature.slice(0, 20)}...`);
+    
+    // Step 4: Convert to Alchemy format and display
+    console.log(`\nStep 4: UserOp ready for submission`);
+    const alchemyUserOp = UserOperationBuilder.toAlchemyUserOperation(userOp);
+    
+    console.log(`\n✅ Test 2 Complete!`);
+    console.log(`\nSummary:`);
+    console.log(`   - AA user ${bobAA} constructed gasless UserOp`);
+    console.log(`   - Transfer 2 dPNTs to ${recipient}`);
+    console.log(`   - Uses deposited ${formatEther(depositedBalance)} bPNTs for gas payment`);
+    console.log(`   - No SBT required (Deposit-Only model)`);
+    console.log(`\nNext Step: Submit to Bundler via eth_sendUserOperation`);
+    console.log(JSON.stringify(alchemyUserOp, (key, value) => 
+        typeof value === 'bigint' ? value.toString() : value
+    , 2));
+}
+
+main().catch(console.error);