NFT Trading Agents: Automated Floor Sweeping and Rarity Arbitrage

import fetch from 'node-fetch'

const RESERVOIR_API = 'https://api.reservoir.tools'
const RESERVOIR_KEY = 'your_reservoir_key'
const PURPLE_FLEA_WALLET_API = 'https://purpleflea.com/wallet-api'
const PF_API_KEY = 'your_pf_api_key'

// Step 1: Build rarity map for a collection
async function buildRarityMap(collectionId) {
  let allTokens = []
  let continuation = null

  do {
    const url = new URL(`${RESERVOIR_API}/tokens/v6`)
    url.searchParams.set('collection', collectionId)
    url.searchParams.set('limit', '1000')
    url.searchParams.set('includeAttributes', 'true')
    if (continuation) url.searchParams.set('continuation', continuation)

    const res = await fetch(url, {
      headers: { 'x-api-key': RESERVOIR_KEY }
    })
    const data = await res.json()
    allTokens = [...allTokens, ...data.tokens]
    continuation = data.continuation
  } while (continuation)

  // Count occurrences of each trait value
  const traitCounts = {}
  const total = allTokens.length

  for (const token of allTokens) {
    for (const attr of (token.token.attributes || [])) {
      const key = `${attr.key}:${attr.value}`
      traitCounts[key] = (traitCounts[key] || 0) + 1
    }
  }

  // Compute rarity score per token
  const rarityMap = {}
  for (const token of allTokens) {
    let score = 0
    for (const attr of (token.token.attributes || [])) {
      const key = `${attr.key}:${attr.value}`
      score += 1 / (traitCounts[key] / total)
    }
    rarityMap[token.token.tokenId] = score
  }

  return rarityMap
}

// Step 2: Fetch active listings and score them
async function findUndervaluedListings(collectionId, rarityMap, floorPriceEth) {
  const res = await fetch(
    `${RESERVOIR_API}/orders/asks/v5?collection=${collectionId}&sortBy=price&limit=200`,
    { headers: { 'x-api-key': RESERVOIR_KEY } }
  )
  const { orders } = await res.json()

  const rarityScores = Object.values(rarityMap)
  const maxRarity = Math.max(...rarityScores)
  const avgRarity = rarityScores.reduce((a, b) => a + b, 0) / rarityScores.length

  const opportunities = []

  for (const order of orders) {
    const tokenId = order.tokenSetId.split(':')[2]
    const rarityScore = rarityMap[tokenId] || avgRarity
    const rarityRank = rarityScore / maxRarity  // 0-1, higher = rarer

    // Expected premium based on rarity rank
    let expectedPremium = 1.0
    if (rarityRank > 0.95) expectedPremium = 8.0       // legendary
    else if (rarityRank > 0.80) expectedPremium = 3.0  // epic
    else if (rarityRank > 0.60) expectedPremium = 1.5  // rare

    const fairValueEth = floorPriceEth * expectedPremium
    const listingPriceEth = order.price.amount.native
    const discount = (fairValueEth - listingPriceEth) / fairValueEth

    if (discount > 0.20) {  // at least 20% undervalued
      opportunities.push({
        tokenId,
        listingPriceEth,
        fairValueEth,
        discount: (discount * 100).toFixed(1) + '%',
        rarityRank: (rarityRank * 100).toFixed(1) + 'th pct',
        marketplace: order.source?.name
      })
    }
  }

  return opportunities.sort((a, b) => b.discount - a.discount)
}

// Step 3: Execute buy via Purple Flea Wallet API
async function executeBuy(order, agentWallet) {
  const res = await fetch(`${PURPLE_FLEA_WALLET_API}/v1/nft/buy`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-API-Key': PF_API_KEY
    },
    body: JSON.stringify({
      wallet: agentWallet,
      marketplace: order.marketplace,
      token_id: order.tokenId,
      max_price_eth: order.listingPriceEth * 1.01, // 1% slippage
      gas_priority: 'fast'
    })
  })
  return res.json()
}

// Main agent loop
async function runNFTScanner(collectionId, agentWallet, maxSpendEth = 5) {
  console.log(`Building rarity map for ${collectionId}...`)
  const rarityMap = await buildRarityMap(collectionId)

  setInterval(async () => {
    const floorRes = await fetch(
      `${RESERVOIR_API}/collections/v6?id=${collectionId}`,
      { headers: { 'x-api-key': RESERVOIR_KEY } }
    )
    const { collections } = await floorRes.json()
    const floorPrice = collections[0]?.floorAsk?.price?.amount?.native || 0

    const opportunities = await findUndervaluedListings(collectionId, rarityMap, floorPrice)
    console.log(`Found ${opportunities.length} undervalued listings`)

    for (const opp of opportunities.slice(0, 3)) {
      if (opp.listingPriceEth <= maxSpendEth) {
        console.log(`Buying token ${opp.tokenId} at ${opp.listingPriceEth} ETH (${opp.discount} discount)`)
        const result = await executeBuy(opp, agentWallet)
        console.log(`Buy result: ${result.status}`)
      }
    }
  }, 5000)  // scan every 5 seconds
}

runNFTScanner('0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d', '0xYourWallet')

import asyncio
import httpx
from collections import Counter
from dataclasses import dataclass, field
from typing import Dict, List

PURPLE_FLEA = "https://purpleflea.com/wallet-api"
RESERVOIR = "https://api.reservoir.tools"

@dataclass
class NFTOpportunity:
    token_id: str
    collection: str
    listing_price_eth: float
    rarity_percentile: float
    estimated_fair_value_eth: float
    expected_profit_eth: float
    marketplace: str
    wash_trade_flag: bool = False
    attributes: Dict = field(default_factory=dict)

def compute_rarity_scores(tokens: List[dict]) -> Dict[str, float]:
    """Statistical rarity scoring across all tokens in collection."""
    total = len(tokens)
    trait_counts = Counter()

    for t in tokens:
        for attr in t.get("attributes", []):
            trait_counts[f"{attr['key']}:{attr['value']}"] += 1

    scores = {}
    for t in tokens:
        score = 0.0
        for attr in t.get("attributes", []):
            key = f"{attr['key']}:{attr['value']}"
            score += 1 / (trait_counts[key] / total)
        scores[t["tokenId"]] = score

    return scores

def detect_wash_trades(sales_history: List[dict]) -> bool:
    """Flag if recent sales show wash trade patterns."""
    buyers = [s["buyer"] for s in sales_history]
    sellers = [s["seller"] for s in sales_history]

    # Check for buyer-seller overlap within the same token's history
    buyer_set = set(buyers)
    seller_set = set(sellers)
    overlap = buyer_set & seller_set

    # Check for rapid round-trips (same token sold within 60 seconds)
    rapid_resales = 0
    for i in range(len(sales_history) - 1):
        time_delta = sales_history[i+1]["timestamp"] - sales_history[i]["timestamp"]
        if time_delta < 60:
            rapid_resales += 1

    return len(overlap) > 0 or rapid_resales > 2

def estimate_fair_value(
    rarity_rank: float,
    floor_price_eth: float,
    comparable_sales: List[float]
) -> float:
    """Estimate fair value using rarity premium model."""
    if rarity_rank > 0.95:
        premium = 10.0
    elif rarity_rank > 0.85:
        premium = 4.0
    elif rarity_rank > 0.70:
        premium = 2.0
    elif rarity_rank > 0.50:
        premium = 1.3
    else:
        premium = 1.0

    model_value = floor_price_eth * premium

    # Blend with comparable recent sales if available
    if comparable_sales:
        avg_comps = sum(comparable_sales) / len(comparable_sales)
        model_value = (model_value * 0.6) + (avg_comps * 0.4)

    return model_value

async def scan_and_report(collection_id: str, api_key: str):
    async with httpx.AsyncClient() as client:
        # Get floor price
        col_res = await client.get(
            f"{RESERVOIR}/collections/v6",
            params={"id": collection_id},
            headers={"x-api-key": api_key}
        )
        floor = col_res.json()["collections"][0]["floorAsk"]["price"]["amount"]["native"]

        # Get listings
        listings_res = await client.get(
            f"{RESERVOIR}/orders/asks/v5",
            params={"collection": collection_id, "sortBy": "price", "limit": 100},
            headers={"x-api-key": api_key}
        )
        listings = listings_res.json()["orders"]

    print(f"Floor: {floor:.4f} ETH | Scanning {len(listings)} listings")
    for listing in listings[:5]:
        price = listing["price"]["amount"]["native"]
        print(f"  Token {listing['tokenSetId']}: {price:.4f} ETH")

asyncio.run(scan_and_report("0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d", "your_key"))