fix issues with arm swap renderer, utlizie transaction_logs field in config

Author: apexearth

CLAUDE.md

@@ -6,6 +6,10 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 This is a Subsquid-based notification system for Origin Protocol. It monitors blockchain events and traces across Ethereum mainnet, Base, and Sonic chains, persists them to a database, and sends notifications to Discord webhooks based on configurable alert rules stored in a separate Postgres database.
 
+## User Interaction
+
+You are encouraged to ask the user questions in order to save time and effort.
+
 ## Common Commands
 
 ```shell

src/alert-config/config-loader.ts

@@ -118,6 +118,7 @@ const loadRules = async (): Promise<AlertRule[]> => {
       topic: row.topic as Topic,
       severity: row.severity as Severity, // DB enum guarantees valid value
       notifyTargets: row.notify_targets,
+      transactionLogs: row.transaction_logs ?? false,
       displayName: row.display_name,
       description: row.description,
     }),

src/alert-config/types.ts

@@ -103,6 +103,9 @@ export interface AlertRule {
   severity: Severity
   notifyTargets: NotifyTarget | null
 
+  // Subscription options
+  transactionLogs: boolean
+
   // Display
   displayName: string | null
   description: string | null

src/main.ts

@@ -19,7 +19,7 @@ import { persistenceProcessor } from './processors/persistence';
 import { load } from './topics';
 
 
-const from = 21_540_000
+const from = Number(process.env.BLOCK_FROM) || 21_540_000
 process.env.BLOCK_FROM = from.toString()
 
 const start = async () => {

src/notify/event/renderers/arm.ts

@@ -1,11 +1,12 @@
-import { ContractBase, event, viewFun } from '@subsquid/evm-abi'
+import { event } from '@subsquid/evm-abi'
 import * as p from '@subsquid/evm-codec'
 
 import * as erc20Abi from '../../../abi/erc20'
 import { addresses, arms } from '../../../utils/addresses'
 import { sonicAddresses } from '../../../utils/addresses/addresses-sonic'
 import { getAddressesPyName } from '../../../utils/addresses/names'
 import { formatAmount } from '../../../utils/formatAmount'
+import { discordIconOrName } from '../../const'
 import { explorerUrl } from '../../format'
 import { registerEventRenderer } from '../event'
 import { defaultEventRenderer } from './default'
@@ -17,39 +18,12 @@ const TraderateChanged = event(
   { traderate0: p.uint256, traderate1: p.uint256 },
 )
 
-const armFunctions = {
-  traderate0: viewFun('0x45059a6b', 'traderate0()', {}, p.uint256),
-  traderate1: viewFun('0xcf1de5d8', 'traderate1()', {}, p.uint256),
-}
-
-const erc4626Functions = {
-  convertToAssets: viewFun('0x07a2d13a', 'convertToAssets(uint256)', { shares: p.uint256 }, p.uint256),
-}
-
-class ArmContract extends ContractBase {
-  traderate0() {
-    return this.eth_call(armFunctions.traderate0, {})
-  }
-  traderate1() {
-    return this.eth_call(armFunctions.traderate1, {})
-  }
-}
-
-class ERC4626Contract extends ContractBase {
-  convertToAssets(shares: bigint) {
-    return this.eth_call(erc4626Functions.convertToAssets, { shares })
-  }
-}
-
 interface ArmConfig {
   address: string
   symbol0: string
   symbol1: string
   token0: string
   token1: string
-  // ERC4626 vault token (e.g. sUSDe). When set, traderates are raw spread rates
-  // and the vault's convertToAssets rate must be applied for output estimation.
-  vaultToken?: string
 }
 
 // Build lookup from ARM contract address to config
@@ -81,7 +55,6 @@ registerArm({
   symbol1: 'sUSDe',
   token0: addresses.tokens.USDe,
   token1: addresses.tokens.sUSDe,
-  vaultToken: addresses.tokens.sUSDe,
 })
 
 registerArm({
@@ -92,60 +65,13 @@ registerArm({
   token1: sonicAddresses.tokens.OS,
 })
 
-// Cache traderates per ARM address
-const traderateCache = new Map<string, { traderate0: bigint; traderate1: bigint }>()
-
-// Cache vault exchange rate (e.g. sUSDe → USDe via convertToAssets)
-const vaultRateCache = new Map<string, bigint>()
-const ONE = 10n ** 18n
-
-type RendererCtx = Parameters<Parameters<typeof registerEventRenderer>[1]>[0]['ctx']
-type RendererBlock = Parameters<Parameters<typeof registerEventRenderer>[1]>[0]['log']['block']
-
-async function getVaultRate(ctx: RendererCtx, block: RendererBlock, vaultToken: string): Promise<bigint> {
-  const cached = vaultRateCache.get(vaultToken)
-  if (cached) return cached
-  try {
-    const contract = new ERC4626Contract(ctx, block, vaultToken)
-    const rate = await contract.convertToAssets(ONE)
-    vaultRateCache.set(vaultToken, rate)
-    return rate
-  } catch {
-    return ONE // Fallback: assume 1:1
-  }
-}
-
-async function getTraderates(
-  ctx: RendererCtx,
-  block: RendererBlock,
-  armAddress: string,
-): Promise<{ traderate0: bigint; traderate1: bigint } | undefined> {
-  const cached = traderateCache.get(armAddress)
-  if (cached) return cached
-  try {
-    const contract = new ArmContract(ctx, block, armAddress)
-    const [traderate0, traderate1] = await Promise.all([contract.traderate0(), contract.traderate1()])
-    const rates = { traderate0, traderate1 }
-    traderateCache.set(armAddress, rates)
-    return rates
-  } catch {
-    return undefined
-  }
-}
-
 // TraderateChanged renderer — shows raw ARM spread rates
 registerEventRenderer(TraderateChanged.topic, async (params) => {
   const arm = armConfigs.get(params.log.address.toLowerCase())
   if (!arm) return defaultEventRenderer(params)
 
   const data = TraderateChanged.decode(params.log)
 
-  // Cache for swap calculations
-  traderateCache.set(params.log.address.toLowerCase(), {
-    traderate0: data.traderate0,
-    traderate1: data.traderate1,
-  })
-
   const sellRate = 10n ** 72n / data.traderate0 // 1e36 precision
   const buyRate = data.traderate1 // 1e36 precision
   const rateLabel = `${arm.symbol1}/${arm.symbol0}`
@@ -164,7 +90,9 @@ registerEventRenderer(TraderateChanged.topic, async (params) => {
   })
 })
 
-// Transfer renderer — renders ARM swaps, falls back to default for non-ARM transfers
+// Transfer renderer — renders ARM swaps using actual transaction logs.
+// Requires transactionLogs: true on the alert rule to access sibling logs.
+// Falls back to default for non-ARM transfers or deposits/withdrawals.
 registerEventRenderer(erc20Abi.events.Transfer.topic, async (params) => {
   // Check if topic2 (the `to` address) is a known ARM
   const topic2 = params.log.topics[2]
@@ -174,83 +102,68 @@ registerEventRenderer(erc20Abi.events.Transfer.topic, async (params) => {
   const arm = armConfigs.get(toAddress)
   if (!arm) return defaultEventRenderer(params)
 
-  const data = erc20Abi.events.Transfer.decode(params.log)
-  const tokenAddress = params.log.address.toLowerCase()
-  const isToken0In = tokenAddress === arm.token0.toLowerCase()
-  const isToken1In = tokenAddress === arm.token1.toLowerCase()
-  if (!isToken0In && !isToken1In) return defaultEventRenderer(params)
+  // Need transaction logs to find the counterpart transfer
+  const txLogs = params.log.transaction?.logs
+  if (!txLogs) return defaultEventRenderer(params)
 
-  const inSymbol = isToken0In ? arm.symbol0 : arm.symbol1
-  const outSymbol = isToken0In ? arm.symbol1 : arm.symbol0
+  // Find the transfer IN (to ARM) and transfer OUT (from ARM) in this transaction
+  const transferInLog = txLogs.find(
+    (l) => l.topics[0] === erc20Abi.events.Transfer.topic && l.topics[2] && ('0x' + l.topics[2].slice(26)).toLowerCase() === arm.address.toLowerCase(),
+  )
+  const transferOutLog = txLogs.find(
+    (l) => l.topics[0] === erc20Abi.events.Transfer.topic && l.topics[1] && ('0x' + l.topics[1].slice(26)).toLowerCase() === arm.address.toLowerCase(),
+  )
 
-  const rates = await getTraderates(params.ctx, params.log.block, toAddress)
-  const explorer = explorerUrl(params.ctx.chain)
+  // If we don't have both in and out, it's a deposit/withdrawal — not a swap
+  if (!transferInLog || !transferOutLog) return
 
-  // Source address from topic1 (the `from` field)
-  const fromAddress = params.log.topics[1] ? ('0x' + params.log.topics[1].slice(26)).toLowerCase() : undefined
-  const sourceName = fromAddress
-    ? getAddressesPyName(fromAddress) ?? `${fromAddress.slice(0, 6)}...${fromAddress.slice(-4)}`
-    : undefined
+  // Only render once per swap (on the inbound transfer)
+  if (params.log.logIndex !== transferInLog.logIndex) return
 
-  const fields: { name: string; value: string; inline?: boolean }[] = [
-    {
-      name: formatAmount(data.value, 18, { maximumFractionDigits: 6 }),
-      value: `${inSymbol} in`,
-      inline: true,
-    },
-  ]
+  const transferInData = erc20Abi.events.Transfer.decode(transferInLog)
+  const transferOutData = erc20Abi.events.Transfer.decode(transferOutLog)
 
-  if (rates) {
-    // Traderates are raw spread rates (~1.0). For vault tokens (e.g. sUSDe),
-    // the ARM contract applies the vault conversion internally during swaps,
-    // so we must apply it here too for output estimation.
-    //
-    // traderate0: for 1 token0 from trader, how many token1 the pool sends (raw)
-    // traderate1: for 1 token1 from trader, how many token0 the pool sends (raw)
-    let outAmount: bigint
+  const explorer = explorerUrl(params.ctx.chain)
 
-    if (isToken0In) {
-      // token0 → token1: traderate0 is a price (token0/token1), so divide
-      // For vault: further divide by vaultRate (fewer vault tokens per unit)
-      outAmount = (data.value * 10n ** 36n) / rates.traderate0
-      if (arm.vaultToken) {
-        const vaultRate = await getVaultRate(params.ctx, params.log.block, arm.vaultToken)
-        outAmount = (outAmount * ONE) / vaultRate
-      }
-    } else {
-      // token1 → token0: outAmount = inAmount * traderate1 / 1e36
-      // For vault: actual token0 out = inAmount * vaultRate * traderate1 / 1e36 / 1e18
-      outAmount = (data.value * rates.traderate1) / 10n ** 36n
-      if (arm.vaultToken) {
-        const vaultRate = await getVaultRate(params.ctx, params.log.block, arm.vaultToken)
-        outAmount = (outAmount * vaultRate) / ONE
-      }
-    }
+  // Source address from the inbound transfer's `from` field
+  const fromAddress = transferInData.from.toLowerCase()
+  const sourceName =
+    getAddressesPyName(fromAddress) ?? discordIconOrName(fromAddress) ?? `${fromAddress.slice(0, 6)}...${fromAddress.slice(-4)}`
 
-    // Rate = token0/token1, derived from actual in/out amounts
-    const rate = isToken0In
-      ? Number(data.value) / Number(outAmount)
-      : Number(outAmount) / Number(data.value)
+  const inTokenAddress = transferInLog.address.toLowerCase()
+  const outTokenAddress = transferOutLog.address.toLowerCase()
+  const inSymbol = discordIconOrName(inTokenAddress) ?? (inTokenAddress === arm.token0.toLowerCase() ? arm.symbol0 : arm.symbol1)
+  const outSymbol = discordIconOrName(outTokenAddress) ?? (outTokenAddress === arm.token0.toLowerCase() ? arm.symbol0 : arm.symbol1)
 
-    fields.push({
-      name: formatAmount(outAmount, 18, { maximumFractionDigits: 6 }),
-      value: `${outSymbol} out`,
-      inline: true,
-    })
-    fields.push({
-      name: rate.toLocaleString('en-US', { maximumFractionDigits: 6 }),
-      value: 'Rate',
-      inline: true,
-    })
-  }
+  // Rate = token0/token1, matching original renderer behavior
+  const isToken0In = inTokenAddress === arm.token0.toLowerCase()
+  const rate = isToken0In
+    ? Number(transferInData.value) / Number(transferOutData.value)
+    : Number(transferOutData.value) / Number(transferInData.value)
 
   renderDiscordEmbed({
     sortId: `${params.log.block.height}:${params.log.transactionIndex}:${params.log.logIndex}`,
     topic: params.topic,
     severity: params.severity,
     title: `${params.name} - Swap`,
     titleUrl: `${explorer}/tx/${params.log.transactionHash}`,
-    description: sourceName ? `Source: [${sourceName}](${explorer}/address/${fromAddress})` : undefined,
-    fields,
+    description: `Source: [${sourceName}](${explorer}/address/${fromAddress})`,
+    fields: [
+      {
+        name: formatAmount(transferInData.value, 18, { maximumFractionDigits: 6 }),
+        value: `${inSymbol} in`,
+        inline: true,
+      },
+      {
+        name: formatAmount(transferOutData.value, 18, { maximumFractionDigits: 6 }),
+        value: `${outSymbol} out`,
+        inline: true,
+      },
+      {
+        name: rate.toLocaleString('en-US', { maximumFractionDigits: 6 }),
+        value: 'Rate',
+        inline: true,
+      },
+    ],
   })
 })

src/processors/config-alert.ts

@@ -183,6 +183,7 @@ export function buildSubscriptions(rules: AlertRule[]) {
           topic2: rule.topic2s ?? undefined,
           topic3: rule.topic3s ?? undefined,
           transaction: true,
+          transactionLogs: rule.transactionLogs || undefined,
         }),
       )
     } else if (rule.matchType === 'trace') {