index.js

require('dotenv').config();
const {
  alchemy,
  createAlchemySmartAccountClient,
  sepolia,
  getAlchemyPaymasterAddress,
} = require('@account-kit/infra');
const { createLightAccount } = require('@account-kit/smart-contracts');
const { LocalAccountSigner } = require('@aa-sdk/core');
const { encodeFunctionData, parseAbi } = require('viem');
const { privateKeyToAccount } = require('viem/accounts');

async function main() {
  try {
    console.log('🚀 Starting AA Wallet and ERC-20 Sponsored Transaction Demo\n');

    // Check required environment variables
    const requiredEnvVars = ['ALCHEMY_API_KEY', 'GAS_MANAGER_POLICY_ID'];
    for (const envVar of requiredEnvVars) {
      if (!process.env[envVar]) {
        throw new Error(`Missing required environment variable: ${envVar}`);
      }
    }

    const {
      ALCHEMY_API_KEY,
      GAS_MANAGER_POLICY_ID,
      ERC20_RULE_POLICY_ID,
      TOKEN_ADDRESS = '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', // USDC on Sepolia
      MAX_TOKEN_AMOUNT = '10000000', // 10 USDC
      TARGET_ADDRESS = '0x9C179d698ddb0f9BEE55d223AE7D354597a8F877',
    } = process.env;

    // Generate or use existing private key
    const privateKey = process.env.PRIVATE_KEY || '0x' + require('crypto').randomBytes(32).toString('hex');
    console.log('🔑 Using private key:', privateKey);

    // 1. Create Alchemy transport
    console.log('🌐 Creating Alchemy transport...');
    const alchemyTransport = alchemy({
      apiKey: ALCHEMY_API_KEY,
    });

    // 2. Create Light Account (AA Wallet)
    const signer = LocalAccountSigner.privateKeyToAccountSigner(privateKey);
    console.log('💼 Creating AA wallet...');

    const account = await createLightAccount({
      chain: sepolia,
      transport: alchemyTransport,
      signer: LocalAccountSigner.privateKeyToAccountSigner(privateKey),
    });

    console.log('✅ AA Wallet created successfully!');
    console.log('📍 Wallet address:', account.address);

    const ifErc20 = false;
    let policy = {
      transport: alchemyTransport,
      policyId: GAS_MANAGER_POLICY_ID,
      chain: sepolia,
      account: account,
    }

    // 3. Create Smart Account Client with ERC-20 sponsorship policy
    console.log('🔧 Creating smart account client...');

    if (ifErc20) {
      policy.policyId = ERC20_RULE_POLICY_ID;
      policy.policyToken = {
        address: TOKEN_ADDRESS,
        maxTokenAmount: BigInt(MAX_TOKEN_AMOUNT),
      }
    }

    const client = createAlchemySmartAccountClient({
      ...policy,
    });

    console.log('✅ Smart account client created with ERC-20 policy!');

    // 4. Prepare ERC-20 approval and USDC transfer
    console.log('📝 Preparing to send 0.01 USDC to', TARGET_ADDRESS);

    const erc20Abi = parseAbi([
      'function approve(address spender, uint256 amount) public returns (bool)',
      'function transfer(address to, uint256 amount) public returns (bool)',
    ]);

    const paymasterAddress = getAlchemyPaymasterAddress(sepolia, '0.7.0');
    console.log('💰 Paymaster address:', paymasterAddress);

    // 5. Send sponsored UserOperation with ERC-20 payment
    console.log('🚀 Sending sponsored transaction...');

    const userOpResult = await client.sendUserOperation({
      uo: [
        {
          // First: approve the paymaster to spend ERC-20 tokens
          target: TOKEN_ADDRESS,
          data: encodeFunctionData({
            abi: erc20Abi,
            functionName: 'approve',
            args: [paymasterAddress, BigInt(MAX_TOKEN_AMOUNT)],
          }),
        },
        {
          // Second: send 0.01 USDC to target address
          target: TOKEN_ADDRESS,
          data: encodeFunctionData({
            abi: erc20Abi,
            functionName: 'transfer',
            args: [TARGET_ADDRESS, 10000n], // 0.01 USDC = 10000 (6 decimals)
          }),
          value: 0n,  // No ETH value
        },
      ],
    });

    console.log('✅ Transaction sent successfully!');
    console.log('🔍 UserOperation hash:', userOpResult.hash);

    // 6. Wait for transaction receipt
    console.log('⏳ Waiting for transaction receipt...');
    const receipt = await client.waitForUserOperationTransaction({
      hash: userOpResult.hash,
    });

    console.log('✅ Transaction confirmed!');
    console.log('🧾 Transaction hash:', receipt.transactionHash);
    console.log('⛽ Gas used:', receipt.gasUsed?.toString());
    console.log('📦 Block number:', receipt.blockNumber?.toString());

    console.log('\n🎉 Demo completed successfully!');
    console.log('💡 Summary:');
    console.log('   - Created AA wallet:', account.address);
    console.log('   - Sent 0.01 USDC to:', TARGET_ADDRESS);
    console.log('   - Used ERC-20 token for gas payment:', TOKEN_ADDRESS);
    console.log('   - Transaction hash:', receipt.transactionHash);

  } catch (error) {
    console.error('❌ Error:', error.message);
    process.exit(1);
  }
}

// Add some helper functions for debugging
async function checkBalance(client, tokenAddress) {
  try {
    const balanceAbi = parseAbi(['function balanceOf(address) view returns (uint256)']);
    const balance = await client.readContract({
      address: tokenAddress,
      abi: balanceAbi,
      functionName: 'balanceOf',
      args: [client.account.address],
    });
    return balance;
  } catch (error) {
    console.warn('Could not fetch balance:', error.message);
    return null;
  }
}

// Run the main function
if (require.main === module) {
  main();
}

module.exports = { main };