Strategy Deposit

PODS_API_KEY=your-api-key
WALLET_ADDRESS=0x...
PRIVATE_KEY=0x...
ETHEREUM_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/your-key
POLYGON_RPC_URL=https://polygon-mainnet.g.alchemy.com/v2/your-key

import axios from 'axios'

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

const { data: strategies } = await pods.get('/strategies', {
  params: { page: '1', limit: '10' }
})

console.log('Available strategies:')
strategies.data.forEach(strategy => {
  console.log(`- ${strategy.id} (${strategy.protocol})`)
  console.log(`  APY: ${(strategy.apy * 100).toFixed(2)}%`)
})

const strategyId = 'aave-usdc-polygon'
const { data: strategy } = await pods.get(`/strategies/${strategyId}`)

console.log('Strategy:', strategy.id)
console.log('Protocol:', strategy.protocol)
console.log('Network:', strategy.network)
console.log('Asset:', strategy.assetName)
console.log('APY:', (strategy.apy * 100).toFixed(2) + '%')
console.log('Status:', strategy.paused ? 'Paused' : 'Active')

const { data: result } = await pods.get('/strategies/aave-usdc-polygon/bytecode', {
  params: {
    action: 'lend',
    amount: '1000000000',
    wallet: walletAddress
  }
})

console.log('ID:', result.id)
console.log('Transactions to execute:', result.bytecode.length)

const { data: result } = await pods.get('/strategies/aave-usdc-polygon/bytecode', {
  params: {
    action: 'lend',
    amount: '1000000000000000000', // 1 WETH (amount is in fromTokenAddress units)
    wallet: walletAddress,
    fromChainId: 137,
    fromTokenAddress: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619' // WETH on Polygon
  }
})

console.log('Cross-chain:', result.crossChain.isCrossChain) // false
console.log('Transactions to execute:', result.bytecode.length) // e.g. 2 (swap + deposit)

const { data: result } = await pods.get('/strategies/aave-usdc-arbitrum/bytecode', {
  params: {
    action: 'lend',
    amount: '1000000',
    wallet: walletAddress,
    fromChainId: 8453,
    fromTokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' // USDC on Base
  }
})

console.log('ID:', result.id)
console.log('Bridge:', result.quote.bridge)
console.log('Source chain:', result.chainIdIn)
console.log('Destination chain:', result.chainIdOut)

import { http, createWalletClient, publicActions } from 'viem'
import { polygon } from 'viem/chains'
import { privateKeyToAccount } from 'viem/accounts'
import { executeLegsViaEip7702 } from './eip7702-batch.js'

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

const receipt = await executeLegsViaEip7702(walletClient, result.bytecode)
console.log('Confirmed in block:', receipt.blockNumber)

// Wait for indexing
await new Promise(resolve => setTimeout(resolve, 5000))

const { data: walletData } = await pods.get(`/wallets/${walletAddress}`)

console.log('Wallet positions:')
walletData.positions.forEach(position => {
  console.log(`${position.strategy.id}:`)
  console.log(`  Balance: ${position.spotPosition.currentPosition.humanized} ${position.spotPosition.currentPosition.symbol}`)
  console.log(`  Value: $${position.spotPosition.underlyingBalanceUSD}`)
  console.log(`  APY: ${(position.spotPosition.apy * 100).toFixed(2)}%`)
})

console.log('Total portfolio value: $' + walletData.summary.totalUnderlyingBalanceUSD)

const id = result.id // returned from /strategies/:id/bytecode

// (Optional) preview the bridge & expected output before signing
if (result.crossChain.isCrossChain) {
  console.log(`Bridging via ${result.quote.bridge}`)
  console.log(`Expected out: ${result.quote.outputAmount.humanized} ${result.quote.outputAmount.symbol}`)
  console.log(`Min out:      ${result.quote.minimumOutputAmount.humanized} ${result.quote.minimumOutputAmount.symbol}`)
}

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

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

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

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

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

const actionId = result.id // returned from /strategies/:id/bytecode

// (Optional) preview the bridge & expected output before signing
if (result.crossChain.isCrossChain) {
  console.log(`Bridging via ${result.quote.bridge}`)
  console.log(`Expected out: ${result.quote.outputAmount.humanized} ${result.quote.outputAmount.symbol}`)
  console.log(`Min out:      ${result.quote.minimumOutputAmount.humanized} ${result.quote.minimumOutputAmount.symbol}`)
}

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

  while (true) {
    const { data: action } = await pods.get(`/actions/${actionId}`)
    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(actionId)
console.log('Final transactions:')
finalAction.transactions.forEach(tx => {
  console.log(`  ${tx.chain}: ${tx.txHash} (${tx.status})`)
})

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)

    // Handle specific errors
    if (apiError.code === 'STRATEGY_NOT_FOUND') {
      console.log('Strategy does not exist or is not available')
    } else if (apiError.code === 'INSUFFICIENT_BALANCE') {
      console.log('Wallet does not have enough tokens')
    }
  } else {
    console.error('Unexpected error:', error.message)
  }
}

# Install dependencies
npm install

# Set environment variables
cp .env.example .env
# Edit .env with your values

# Run the example
node strategy-deposit.js

1️⃣  Fetching available strategies...
✅ Available strategies:
   - Aave-USDC-polygon (Aave)
     APY: 4.50%
   - Morpho-BTC-base (Morpho)
     APY: 3.20%

2️⃣  Getting details for Aave-USDC-polygon...
✅ Strategy details:
   Strategy: Aave-USDC-polygon
   Protocol: Aave
   Network: polygon
   Asset: USDC
   APY: 4.50%
   Status: ✅ Active

4️⃣  Generating deposit bytecode...
✅ Bytecode generated:
   ID: 65f3a1c8e9b2d4f8a7c1d2e3
   Transactions: 2

5️⃣  Executing atomic EIP-7702 batch...
   ✅ Confirmed in block 12345678

6️⃣  Verifying deposit...
✅ Wallet positions:
   Aave-USDC-polygon:
      Balance: 1000.00 USDC
      Value: $1000.00
      APY: 4.17%

   Total Portfolio Value: $1000.00

🎉 Strategy deposit completed successfully!