EOA Integration - Pods API

This example walks an EOA holder through depositing into a Pods yield strategy via an ERC-4337 smart account (a Gnosis Safe with the Safe 4337 module). Instead of signing each on-chain transaction with the EOA, you create a smart account owned by the EOA, fund it once, then deposit by signing a single userOperation that the bundler executes — with gas sponsored by a paymaster.

Overview

This example covers:

Creating a smart account for an EOA with POST /smart-account
Waiting for the smart account to deploy on-chain
Funding the smart account from the EOA (a standard ERC-20 transfer)
Generating a deposit userOperation with GET /strategies/:id/bytecode?output=userOperation
Signing the userOperation (Safe 4337 SafeOp EIP-712)
Propagating it with POST /aa/send-user-operation

The signer key is the smart account’s owner. The EOA you use to sign the userOperation must be the same owner you pass to POST /smart-account, or the Safe 4337 module rejects the signature (AA24).

Prerequisites

Node.js 18+
Pods API key
An EOA (private key) with USDC on Polygon to deposit
Basic understanding of async/await

Gas is sponsored. The deposit userOperation is paid by a paymaster, so the smart account only needs the asset you are depositing (USDC) — it does not need native MATIC for gas.

Installation

ethers.js
viem

npm install axios ethers

npm install axios viem

Environment Variables

Create a .env file:

PODS_API_KEY=your-api-key
PRIVATE_KEY=0x...                 # the EOA that owns the smart account and signs the userOperation
POLYGON_RPC_URL=https://polygon-mainnet.g.alchemy.com/v2/your-key

Never commit your .env file to version control. Add it to .gitignore.

Step-by-Step Walkthrough

1. Initialize clients

import axios from 'axios'

const CHAIN_ID = 137 // Polygon
const STRATEGY_ID = 'aave-usdc-polygon'
const USDC = '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359' // USDC on Polygon
const AMOUNT = '1000000' // raw units — USDC has 6 decimals, so 1000000 = 1 USDC

const pods = axios.create({
  baseURL: 'https://api.pods.finance',
  headers: {
    'x-api-key': process.env.PODS_API_KEY,
    'Content-Type': 'application/json'
  }
})

ethers.js
viem

import { ethers } from 'ethers'

const provider = new ethers.JsonRpcProvider(process.env.POLYGON_RPC_URL)
const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)

const owner = signer.address // the EOA — also the smart account owner
console.log('Owner (EOA):', owner)

import { createPublicClient, createWalletClient, http } from 'viem'
import { polygon } from 'viem/chains'
import { privateKeyToAccount } from 'viem/accounts'

const account = privateKeyToAccount(process.env.PRIVATE_KEY)
const publicClient = createPublicClient({ chain: polygon, transport: http(process.env.POLYGON_RPC_URL) })
const walletClient = createWalletClient({ account, chain: polygon, transport: http(process.env.POLYGON_RPC_URL) })

const owner = account.address // the EOA — also the smart account owner
console.log('Owner (EOA):', owner)

2. Create the smart account

Create a smart account owned by the EOA. The address is deterministic for an owner + chainId, so this call is idempotent — repeated calls return the same record.

const { data: smartAccount } = await pods.post('/smart-account', {
  owner,
  chainId: CHAIN_ID
})

const smartAccountAddress = smartAccount.address
console.log('Smart account:', smartAccountAddress)

Response:

{
  "address": "0x4F380a141607935c747725a07A97a146CF512755",
  "owner": "0xb794F5eA0ba39494cE839613fffBA74279579268",
  "chainId": 137
}

The endpoint returns 200 with the record immediately, while the Safe is deployed in the background. The next step waits for that deployment to land on-chain.

3. Wait for on-chain deployment

The smart account must have code on-chain before you can build a userOperation for it. Poll until it’s deployed.

Skip this and Step 5 fails: building a userOperation for a not-yet-deployed smart account throws Could not create a new SmartAccount without an owner.

ethers.js
viem

async function waitForDeployment (address, { tries = 30, delayMs = 5000 } = {}) {
  for (let i = 0; i < tries; i++) {
    const code = await provider.getCode(address)
    if (code && code !== '0x') return true
    await new Promise(resolve => setTimeout(resolve, delayMs))
  }
  throw new Error(`Smart account ${address} was not deployed in time`)
}

await waitForDeployment(smartAccountAddress)
console.log('Smart account deployed')

async function waitForDeployment (address, { tries = 30, delayMs = 5000 } = {}) {
  for (let i = 0; i < tries; i++) {
    const code = await publicClient.getBytecode({ address })
    if (code && code !== '0x') return true
    await new Promise(resolve => setTimeout(resolve, delayMs))
  }
  throw new Error(`Smart account ${address} was not deployed in time`)
}

await waitForDeployment(smartAccountAddress)
console.log('Smart account deployed')

4. Fund the smart account

Move the asset you want to deposit from the EOA to the smart account. This is a plain ERC-20 transfer() — there is no Pods endpoint for it.

ethers.js
viem

const ERC20_ABI = ['function transfer(address to, uint256 amount) returns (bool)']
const usdc = new ethers.Contract(USDC, ERC20_ABI, signer)

const fundTx = await usdc.transfer(smartAccountAddress, AMOUNT)
console.log('Funding tx:', fundTx.hash)
await fundTx.wait()
console.log('Smart account funded')

const ERC20_ABI = [{
  type: 'function',
  name: 'transfer',
  stateMutability: 'nonpayable',
  inputs: [{ name: 'to', type: 'address' }, { name: 'amount', type: 'uint256' }],
  outputs: [{ type: 'bool' }]
}]

const fundHash = await walletClient.writeContract({
  address: USDC,
  abi: ERC20_ABI,
  functionName: 'transfer',
  args: [smartAccountAddress, BigInt(AMOUNT)]
})
console.log('Funding tx:', fundHash)
await publicClient.waitForTransactionReceipt({ hash: fundHash })
console.log('Smart account funded')

Only the deposit asset (USDC) is required — gas for the deposit userOperation is sponsored by a paymaster.

5. Request the deposit userOperation

Ask the API for the lend bytecode as a fully-populated (but unsigned) userOperation, using the smart account as the wallet. Gas limits and paymasterAndData are filled in for you.

const { data: result } = await pods.get(`/strategies/${STRATEGY_ID}/bytecode`, {
  params: {
    action: 'lend',
    wallet: smartAccountAddress,
    amount: AMOUNT,
    output: 'userOperation'
  }
})

const userOperation = result.userOperation
console.log('Action id:', result.id) // keep for tracking

The userOperation contains sender, nonce, initCode, callData, the gas fields, paymasterAndData, and an empty signature you fill in next.

6. Sign the userOperation (SafeOp)

A Safe with the 4337 module validates the userOperation against the module’s SafeOp EIP-712 hash — not the vanilla ERC-4337 UserOperation hash. The EIP-712 verifyingContract is the Safe 4337 module, and the packed signature is 12 zero bytes (validAfter + validUntil) followed by the 65-byte ECDSA signature.

ethers.js
viem

// Canonical Safe 4337 (EntryPoint v0.6) addresses — identical on every chain
const SAFE_4337_MODULE_ADDRESS = '0xa581c4A4DB7175302464fF3C06380BC3270b4037'
const ENTRYPOINT_ADDRESS = '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789'

async function signUserOperation (userOperation, signer, chainId) {
  const domain = { chainId, verifyingContract: SAFE_4337_MODULE_ADDRESS }
  const types = {
    SafeOp: [
      { type: 'address', name: 'safe' },
      { type: 'uint256', name: 'nonce' },
      { type: 'bytes', name: 'initCode' },
      { type: 'bytes', name: 'callData' },
      { type: 'uint256', name: 'callGasLimit' },
      { type: 'uint256', name: 'verificationGasLimit' },
      { type: 'uint256', name: 'preVerificationGas' },
      { type: 'uint256', name: 'maxFeePerGas' },
      { type: 'uint256', name: 'maxPriorityFeePerGas' },
      { type: 'bytes', name: 'paymasterAndData' },
      { type: 'uint48', name: 'validAfter' },
      { type: 'uint48', name: 'validUntil' },
      { type: 'address', name: 'entryPoint' }
    ]
  }
  const message = {
    safe: userOperation.sender,
    nonce: userOperation.nonce,
    initCode: userOperation.initCode,
    callData: userOperation.callData,
    callGasLimit: userOperation.callGasLimit,
    verificationGasLimit: userOperation.verificationGasLimit,
    preVerificationGas: userOperation.preVerificationGas,
    maxFeePerGas: userOperation.maxFeePerGas,
    maxPriorityFeePerGas: userOperation.maxPriorityFeePerGas,
    paymasterAndData: userOperation.paymasterAndData,
    validAfter: '0x000000000000',
    validUntil: '0x000000000000',
    entryPoint: ENTRYPOINT_ADDRESS
  }

  const signature = await signer.signTypedData(domain, types, message)
  // 6 bytes validAfter + 6 bytes validUntil (both zero) + the 65-byte signature
  return '0x000000000000000000000000' + signature.slice(2)
}

userOperation.signature = await signUserOperation(userOperation, signer, CHAIN_ID)

// Canonical Safe 4337 (EntryPoint v0.6) addresses — identical on every chain
const SAFE_4337_MODULE_ADDRESS = '0xa581c4A4DB7175302464fF3C06380BC3270b4037'
const ENTRYPOINT_ADDRESS = '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789'

async function signUserOperation (userOperation, walletClient, chainId) {
  const signature = await walletClient.signTypedData({
    domain: { chainId, verifyingContract: SAFE_4337_MODULE_ADDRESS },
    types: {
      SafeOp: [
        { type: 'address', name: 'safe' },
        { type: 'uint256', name: 'nonce' },
        { type: 'bytes', name: 'initCode' },
        { type: 'bytes', name: 'callData' },
        { type: 'uint256', name: 'callGasLimit' },
        { type: 'uint256', name: 'verificationGasLimit' },
        { type: 'uint256', name: 'preVerificationGas' },
        { type: 'uint256', name: 'maxFeePerGas' },
        { type: 'uint256', name: 'maxPriorityFeePerGas' },
        { type: 'bytes', name: 'paymasterAndData' },
        { type: 'uint48', name: 'validAfter' },
        { type: 'uint48', name: 'validUntil' },
        { type: 'address', name: 'entryPoint' }
      ]
    },
    primaryType: 'SafeOp',
    message: {
      safe: userOperation.sender,
      nonce: BigInt(userOperation.nonce),
      initCode: userOperation.initCode,
      callData: userOperation.callData,
      callGasLimit: BigInt(userOperation.callGasLimit),
      verificationGasLimit: BigInt(userOperation.verificationGasLimit),
      preVerificationGas: BigInt(userOperation.preVerificationGas),
      maxFeePerGas: BigInt(userOperation.maxFeePerGas),
      maxPriorityFeePerGas: BigInt(userOperation.maxPriorityFeePerGas),
      paymasterAndData: userOperation.paymasterAndData,
      validAfter: 0,
      validUntil: 0,
      entryPoint: ENTRYPOINT_ADDRESS
    }
  })
  // 6 bytes validAfter + 6 bytes validUntil (both zero) + the 65-byte signature
  return '0x000000000000000000000000' + signature.slice(2)
}

userOperation.signature = await signUserOperation(userOperation, walletClient, CHAIN_ID)

7. Send the userOperation

Propagate the signed userOperation to the bundler. The endpoint returns the userOpHash.

const { data: sent } = await pods.post('/aa/send-user-operation', {
  chainId: CHAIN_ID,
  userOperation
})

console.log('userOpHash:', sent.userOpHash)

Numeric userOperation fields may be decimal or 0x-hex strings — the endpoint normalizes them, and the SafeOp signature hashes the integer values, so signing the fields exactly as returned by Step 5 is correct.

8. Track the deposit (optional)

Use the id from Step 5 to poll the action until it reaches a terminal state.

async function waitForDeposit (id) {
  const TERMINAL = ['SUCCESS', 'FAILED', 'REFUNDED', 'EXPIRED']

  while (true) {
    const { data: action } = await pods.get(`/actions/${id}`)
    console.log(`Status: ${action.status} (${action.transactions.length} tx)`)

    if (TERMINAL.includes(action.status)) return action

    await new Promise(resolve => setTimeout(resolve, 5000))
  }
}

const finalAction = await waitForDeposit(result.id)
finalAction.transactions.forEach(tx => {
  console.log(`  ${tx.chain}: ${tx.txHash} (${tx.status})`)
})

Error Handling

try {
  // Your code here
} catch (error) {
  if (error.response?.data?.error) {
    const apiError = error.response.data.error
    console.error('API Error:', apiError.code)
    console.error('Message:', apiError.message)

    if (apiError.code === 'USER_OPERATION_REJECTED') {
      // The bundler rejected the userOp — the message carries the AA reason code:
      //   AA24 = signature (is the signer the smart account owner? is it a SafeOp signature?)
      //   AA25 = nonce      (stale userOp — re-fetch it in Step 5)
      //   AA21 / AA31 = prefund / paymaster (not a signing problem)
      console.log('Bundler rejected the user operation:', apiError.message)
    }
  } else {
    console.error('Unexpected error:', error.message)
  }
}

Expected Output

Owner (EOA): 0xb794F5eA0ba39494cE839613fffBA74279579268

1️⃣  Creating smart account...
✅ Smart account: 0x4F380a141607935c747725a07A97a146CF512755

2️⃣  Waiting for on-chain deployment...
✅ Smart account deployed

3️⃣  Funding smart account (1 USDC)...
   Funding tx: 0x123...
✅ Smart account funded

4️⃣  Requesting deposit userOperation...
✅ Action id: 65f3a1c8e9b2d4f8a7c1d2e3

5️⃣  Signing userOperation (SafeOp)...
✅ Signed

6️⃣  Sending to bundler...
✅ userOpHash: 0xabc...

🎉 Deposit submitted via smart account!

Next Steps

Strategy Deposit (EOA)

The same deposit flow signing directly with an EOA

Check Positions

Track the smart account’s positions

Strategy Withdrawal

Withdraw from strategies, including cross-chain

API Reference

View complete API documentation

​Overview

​Prerequisites

​Installation

​Environment Variables

​Step-by-Step Walkthrough

​1. Initialize clients

​2. Create the smart account

​3. Wait for on-chain deployment

​4. Fund the smart account

​5. Request the deposit userOperation

​6. Sign the userOperation (SafeOp)

​7. Send the userOperation

​8. Track the deposit (optional)

​Error Handling

​Expected Output

​Next Steps

Strategy Deposit (EOA)

Check Positions

Strategy Withdrawal

API Reference

Overview

Prerequisites

Installation

Environment Variables

Step-by-Step Walkthrough

1. Initialize clients

2. Create the smart account

3. Wait for on-chain deployment

4. Fund the smart account

5. Request the deposit userOperation

6. Sign the userOperation (SafeOp)

7. Send the userOperation

8. Track the deposit (optional)

Error Handling

Expected Output

Next Steps