How to create a user operation which converts ETH to USDC on Uniswap V3

This guide demonstrates how to create a user operation that swaps ETH for USDC using Uniswap V3. By leveraging Account Abstraction and Pimlico's infrastructure, you can create gasless swaps and provide a seamless experience for your users.

Prerequisites

A Pimlico API key (get one from the Pimlico Dashboard)
Basic understanding of Account Abstraction and ERC-4337
Familiarity with TypeScript and Viem
Access to a network with Uniswap V3 deployed (we'll use Sepolia in this example)

Steps

Set up the clients

First, we need to set up the necessary clients for interacting with the blockchain and Pimlico's services. We'll create a public client for reading from the blockchain and a Pimlico client for interacting with Pimlico's bundler and paymaster services.

const apiKey = process.env.PIMLICO_API_KEY
if (!apiKey) throw new Error("Missing PIMLICO_API_KEY")
 
const privateKey =
	(process.env.PRIVATE_KEY as Hex) ??
	(() => {
		const pk = generatePrivateKey()
		writeFileSync(".env", `PRIVATE_KEY=${pk}`)
		return pk
	})()
 
export const publicClient = createPublicClient({
	chain: sepolia,
	transport: http(),
})
 
const pimlicoUrl = `https://api.pimlico.io/v2/sepolia/rpc?apikey=${apiKey}`
 
const pimlicoClient = createPimlicoClient({
	transport: http(pimlicoUrl),
	entryPoint: {
		address: entryPoint07Address,
		version: "0.7",
	},
})

Create a smart account

For this guide, we'll use a Safe smart account. This account is an ERC-4337 wallet controlled by a single EOA signer.

const account = await toSafeSmartAccount({
	client: publicClient,
	owners: [privateKeyToAccount(privateKey)],
	entryPoint: {
		address: entryPoint07Address,
		version: "0.7",
	}, // global entrypoint
	version: "1.4.1",
})
 
console.log(`Smart account address: https://sepolia.etherscan.io/address/${account.address}`)

Create the smart account client

Now that we have a SmartAccount instance, we need to create a SmartAccountClient instance to be able to transact from it. We'll also configure it to use Pimlico's bundler and paymaster services.

const smartAccountClient = createSmartAccountClient({
	account,
	chain: sepolia,
	bundlerTransport: http(pimlicoUrl),
	paymaster: pimlicoClient,
	userOperation: {
		estimateFeesPerGas: async () => {
			return (await pimlicoClient.getUserOperationGasPrice()).fast
		},
	},
})

Define the Uniswap V3 interface

To interact with Uniswap V3, we need to define the ABI for the functions we'll be using. We'll also define the addresses for the Uniswap V3 Router, WETH, and USDC tokens.

// Addresses for Sepolia testnet
// Note: These are example addresses and should be replaced with actual addresses for the network you're using
const SWAP_ROUTER_CONTRACT = "0x3bFA4769FB09eefC5a80d6E87c3B9C650f7Ae48E" // Sepolia  SwapRouter
const QUOTER_CONTRACT = "0xEd1f6473345F45b75F8179591dd5bA1888cf2FB3" // Sepolia Quoter
const FACTORY_CONTRACT = "0x0227628f3F023bb0B980b67D528571c95c6DaC1c" // Sepolia Factory
const WETH_ADDRESS = "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14" // Sepolia WETH
const USDC_ADDRESS = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" // Sepolia USDC

Create swap helper functions

Now, let's create helper functions for getting a quote and creating the calldata for swapping ETH to USDC.

// Add Quoter ABI
 
/**
 * Get a quote for swapping ETH to USDC
 * @param amountIn Amount of ETH to swap (in wei)
 * @returns Expected amount of USDC out
 */
async function getEthToUsdcQuote(amountIn: bigint): Promise<bigint> {
  try {
    // First get the pool address from the factory
    const poolAddress = await publicClient.readContract({
      address: FACTORY_CONTRACT,
      abi: parseAbi(['function getPool(address,address,uint24) external view returns (address)']),
      functionName: 'getPool',
      args: [WETH_ADDRESS, USDC_ADDRESS, 3000]
    })
 
    if (!poolAddress || poolAddress === '0x0000000000000000000000000000000000000000') {
      throw new Error('Pool does not exist')
    }
 
    console.log(`Using pool: ${poolAddress}`)
 
    // Get quote from Quoter contract
    const result = await publicClient.simulateContract({
      address: QUOTER_CONTRACT,
      abi: UniswapQuoterAbi,
      functionName: 'quoteExactInputSingle',
      args: [
        {
          tokenIn: WETH_ADDRESS,
          tokenOut: USDC_ADDRESS,
          fee: 3000,
          recipient: account.address,
          deadline: Math.floor(new Date().getTime() / 1000 + 60 * 10),
          amountIn: amountIn,
          sqrtPriceLimitX96: 0n,
      }
      ]
    })
    const amountOut = result.result[0]
 
    return amountOut
  } catch (error) {
    console.error("Error getting quote:", error)
    if (error instanceof Error) {
      console.error("Error details:", error.message)
    }
    throw error
  }
}
 
/**
 * Create calldata for swapping ETH to USDC
 * @param amountIn Amount of ETH to swap (in wei)
 * @param slippagePercentage Slippage tolerance (e.g., 0.5 for 0.5%)
 * @returns Encoded function data for the swap
 */
async function createEthToUsdcSwapCalldata(
  amountIn: bigint,
  slippagePercentage: number = 0.5
): Promise<Hex> {
  // Get expected amount out
  const expectedAmountOut = await getEthToUsdcQuote(amountIn)
  
  // Calculate minimum amount out based on slippage
  const slippageBps = BigInt(Math.floor(slippagePercentage * 100))
  const minAmountOut = expectedAmountOut - (expectedAmountOut * slippageBps / 10000n)
 
  // Encode the function call
  const calldata = encodeFunctionData({
    abi: UniswapSwapRouterAbi,
    functionName: "exactInputSingle",
    args: [{
      tokenIn: WETH_ADDRESS,
      tokenOut: USDC_ADDRESS,
      fee: 3000, // 0.3% fee tier
      recipient: account.address,
      amountIn,
      amountOutMinimum: minAmountOut,
      sqrtPriceLimitX96: 0n // No price limit
    }]
  })
  
  return calldata
}

These functions handle:

Getting a quote for the expected amount of USDC to receive
Calculating the minimum amount out based on slippage
Setting a deadline for the swap
Encoding the function call to the Uniswap V3 Router

Execute the swap

Finally, let's create a function to execute the swap and submit the user operation.

/**
 * Execute a swap from ETH to USDC
 * @param ethAmount Amount of ETH to swap (in ETH, not wei)
 */
async function swapEthToUsdc(ethAmount: string) {
  const amountIn = parseEther(ethAmount)
  
  // Get expected amount out for logging
  const expectedAmountOut = await getEthToUsdcQuote(amountIn)
  console.log(`Expected to receive approximately ${formatUnits(expectedAmountOut, 6)} USDC for ${ethAmount} ETH`)
  
  // Create the swap calldata
  const swapCalldata = await createEthToUsdcSwapCalldata(amountIn)
 
  // Create a flash fund ETH withdrawal
  const flashFund = new FlashFund()
 
  const [contract, calldata] = await flashFund.sponsorWithdrawal({
    type: "credits",
    data: {
      token: ETH,
      amount: toHex(parseEther(ethAmount)),
      recipient: account.address,
      signature: "0x",
    },
  })
 
  // // Execute the swap
  const txHash = await smartAccountClient.sendTransaction({
    calls: [
      {
        to: contract,
        data: calldata,
        value: 0n
      },
      {
        to: SWAP_ROUTER_CONTRACT,
        data: swapCalldata,
        value: amountIn
      }
    ]
  })
  
  console.log(`Swap transaction submitted: https://sepolia.etherscan.io/tx/${txHash}`)
  return txHash
}

This function:

Gets the ETH from FlashFund
Gets a quote for the expected amount of USDC
Creates the swap calldata
Submits the user operation to the bundler
Returns the transaction hash

Run the swap

Now, let's execute the swap with a small amount of ETH.

// Execute the swap with 0.01 ETH
const ethAmount = "0.00001"
console.log(`Swapping ${ethAmount} ETH for USDC...`)
await swapEthToUsdc(ethAmount)

When you run this code, you should see output similar to:

Smart account address: https://sepolia.etherscan.io/address/0x...
Swapping 0.01 ETH for USDC...
Expected to receive approximately 25.123456 USDC for 0.01 ETH
Swap transaction submitted: https://sepolia.etherscan.io/tx/0x...

Complete code example

You can find the complete code example in the snippets directory.