Reshape ArmSwap as explicit token in/out swap with per-side rates

apexearth · apexearth · commit d3e12f30e2c6 · 2026-06-16T16:03:59.000-07:00
diff --git a/db/migrations/1781651014827-Data.js b/db/migrations/1781651014827-Data.js
diff --git a/schema.graphql b/schema.graphql
@@ -832,10 +832,21 @@ type ArmSwap @entity {
   blockNumber: Int! @index
   address: String! @index
   from: String!
-  # One row per transaction (aggregated). Amounts are paired from the tx's ERC20
-  # Transfer logs and normalized to liquidity-asset terms. Per-action decoding via
-  # trace return data was reverted: the portal serves callResultOutput only for
-  # recent blocks, which silently dropped most pre-Dec-2025 swaps.
+  # One row per (transaction, base asset, direction), paired from the tx's ERC20 Transfer logs.
+  # Modeled as an explicit swap: tokenIn/amountIn = what the trader supplied (ARM received);
+  # tokenOut/amountOut = what the trader received (ARM sent). amount* are RAW token units; rate*
+  # is each token's asset0 (liquidity) rate at the swap block, 1e18-scaled (== 1e18 for the
+  # liquidity asset and pegged base assets). Every swap has the liquidity asset on exactly one
+  # side (the contract forbids base<->base). Derived: asset0 value = amount x rate / 1e18;
+  # execution price = amountOut / amountIn; spread = valueOut / valueIn.
+  tokenIn: String! @index
+  tokenOut: String! @index
+  amountIn: BigInt!
+  amountOut: BigInt!
+  rateIn: BigInt!
+  rateOut: BigInt!
+  # Legacy ARM-perspective signed deltas in asset0 terms (assets1 = base x rate). Kept for
+  # back-compat; superseded by the token*/amount*/rate* fields above.
   assets0: BigInt!
   assets1: BigInt!
 }
diff --git a/src/model/generated/armSwap.model.ts b/src/model/generated/armSwap.model.ts
@@ -38,6 +38,26 @@ export class ArmSwap {
     @StringColumn_({nullable: false})
     from!: string
 
+    @Index_()
+    @StringColumn_({nullable: false})
+    tokenIn!: string
+
+    @Index_()
+    @StringColumn_({nullable: false})
+    tokenOut!: string
+
+    @BigIntColumn_({nullable: false})
+    amountIn!: bigint
+
+    @BigIntColumn_({nullable: false})
+    amountOut!: bigint
+
+    @BigIntColumn_({nullable: false})
+    rateIn!: bigint
+
+    @BigIntColumn_({nullable: false})
+    rateOut!: bigint
+
     @BigIntColumn_({nullable: false})
     assets0!: bigint
 
diff --git a/src/templates/origin-arm/origin-arm.graphql b/src/templates/origin-arm/origin-arm.graphql
@@ -152,10 +152,21 @@ type ArmSwap @entity {
   blockNumber: Int! @index
   address: String! @index
   from: String!
-  # One row per transaction (aggregated). Amounts are paired from the tx's ERC20
-  # Transfer logs and normalized to liquidity-asset terms. Per-action decoding via
-  # trace return data was reverted: the portal serves callResultOutput only for
-  # recent blocks, which silently dropped most pre-Dec-2025 swaps.
+  # One row per (transaction, base asset, direction), paired from the tx's ERC20 Transfer logs.
+  # Modeled as an explicit swap: tokenIn/amountIn = what the trader supplied (ARM received);
+  # tokenOut/amountOut = what the trader received (ARM sent). amount* are RAW token units; rate*
+  # is each token's asset0 (liquidity) rate at the swap block, 1e18-scaled (== 1e18 for the
+  # liquidity asset and pegged base assets). Every swap has the liquidity asset on exactly one
+  # side (the contract forbids base<->base). Derived: asset0 value = amount x rate / 1e18;
+  # execution price = amountOut / amountIn; spread = valueOut / valueIn.
+  tokenIn: String! @index
+  tokenOut: String! @index
+  amountIn: BigInt!
+  amountOut: BigInt!
+  rateIn: BigInt!
+  rateOut: BigInt!
+  # Legacy ARM-perspective signed deltas in asset0 terms (assets1 = base x rate). Kept for
+  # back-compat; superseded by the token*/amount*/rate* fields above.
   assets0: BigInt!
   assets1: BigInt!
 }
diff --git a/src/templates/origin-arm/origin-arm.ts b/src/templates/origin-arm/origin-arm.ts
@@ -421,6 +421,21 @@ export const createOriginARMProcessors = ({
         }
         const calculateTotalYield = (state: ArmState) =>
           state.totalAssets - state.totalDeposits + state.totalWithdrawals
+        // A base asset's rate in asset0 (liquidity) terms, 1e18-scaled (token0 per base).
+        // Mirrors the assetRates logic: pegged base assets and the liquidity asset are 1:1;
+        // appreciating assets use their adapter (post-upgrade) or getRate1 (pre-upgrade single base).
+        const getBaseAssetRate = async (block: Block, assetIdx: number): Promise<bigint> => {
+          if (assetIdx === 0 || armEntity.assetPegged[assetIdx]) return 10n ** 18n
+          const upgraded = armEntity.upgradeBlock != null && block.header.height >= armEntity.upgradeBlock
+          if (upgraded) {
+            return new originMultibaseArmAbi.Contract(
+              ctx,
+              block.header,
+              armEntity.assetAdapters[assetIdx],
+            ).convertToAssets(10n ** 18n)
+          }
+          return getRate1 ? await getRate1(ctx, block) : 10n ** 18n
+        }
         const checkpoint = (
           account: string,
           block: Block,
@@ -607,66 +622,104 @@ export const createOriginARMProcessors = ({
                 const transfers0 = transfers
                   .filter((log) => log.address === armEntity.token0)
                   .map((log) => erc20Abi.events.Transfer.decode(log))
-                const transfers1 = transfers
-                  .filter((log) => log.address === armEntity.token1)
-                  .map((log) => erc20Abi.events.Transfer.decode(log))
 
-                const pairs: { assets0: bigint; assets1: bigint }[] = []
+                const ONE = 10n ** 18n
+                const swapMeta = {
+                  chainId: ctx.chain.id,
+                  txHash: transactionHash,
+                  txFrom: trace.transaction?.from ?? '',
+                  txTo: trace.transaction?.to ?? '',
+                  timestamp: new Date(block.header.timestamp),
+                  blockNumber: block.header.height,
+                  address: armAddress,
+                  from: trace.action.from,
+                }
 
-                const transfersOut0 = transfers0.filter((t) => t.from.toLowerCase() === armAddress)
-                const transfersIn1 = transfers1.filter((t) => t.to.toLowerCase() === armAddress)
+                // Every swap is liquidityAsset(token0) <-> one base asset (the contract forbids
+                // base<->base). Pair token0 transfers against each base asset and emit one ArmSwap
+                // per (tx, baseAsset, direction) with raw amounts and each side's asset0 rate.
+                for (let assetIdx = 1; assetIdx < armEntity.assets.length; assetIdx++) {
+                  const baseAsset = armEntity.assets[assetIdx]
+                  const transfersB = transfers
+                    .filter((log) => log.address === baseAsset)
+                    .map((log) => erc20Abi.events.Transfer.decode(log))
+                  if (transfersB.length === 0) continue
 
-                const rate1 = getRate1 ? await getRate1(ctx, block) : 10n ** 18n
-                const rate1Number = +formatEther(rate1)
+                  const rateB = await getBaseAssetRate(block, assetIdx) // token0 per base
+                  const rateBNumber = +formatEther(rateB)
 
-                for (let i = 0; i < transfersOut0.length; i++) {
-                  for (let j = 0; j < transfersIn1.length; j++) {
-                    const out0 = transfersOut0[i]
-                    const in1 = transfersIn1[j]
-                    if (out0.value === 0n || in1.value === 0n) continue
-                    const rate = +formatEther((out0.value * 10n ** 18n) / in1.value)
-                    if (Math.abs(rate - rate1Number) <= 0.01) {
-                      pairs.push({ assets0: -out0.value, assets1: (in1.value * rate1) / 10n ** 18n })
-                      transfersIn1.splice(j, 1)
-                      break
+                  // Trader sells base for token0: ARM receives base, sends token0.
+                  const transfersOut0 = transfers0.filter((t) => t.from.toLowerCase() === armAddress)
+                  const transfersInB = transfersB.filter((t) => t.to.toLowerCase() === armAddress)
+                  let sellBaseIn = 0n
+                  let sellToken0Out = 0n
+                  for (let i = 0; i < transfersOut0.length; i++) {
+                    for (let j = 0; j < transfersInB.length; j++) {
+                      const out0 = transfersOut0[i]
+                      const inB = transfersInB[j]
+                      if (out0.value === 0n || inB.value === 0n) continue
+                      const rate = +formatEther((out0.value * ONE) / inB.value) // token0 per base
+                      if (Math.abs(rate - rateBNumber) <= 0.01) {
+                        sellBaseIn += inB.value
+                        sellToken0Out += out0.value
+                        transfersInB.splice(j, 1)
+                        break
+                      }
                     }
                   }
-                }
+                  if (sellBaseIn > 0n) {
+                    swaps.push(
+                      new ArmSwap({
+                        ...swapMeta,
+                        id: `${ctx.chain.id}::${transactionHash}:${baseAsset}:sell`,
+                        tokenIn: baseAsset,
+                        amountIn: sellBaseIn,
+                        rateIn: rateB,
+                        tokenOut: armEntity.token0,
+                        amountOut: sellToken0Out,
+                        rateOut: ONE,
+                        assets0: -sellToken0Out,
+                        assets1: (sellBaseIn * rateB) / ONE,
+                      }),
+                    )
+                  }
 
-                const transfersOut1 = transfers1.filter((t) => t.from.toLowerCase() === armAddress)
-                const transfersIn0 = transfers0.filter((t) => t.to.toLowerCase() === armAddress)
-                for (let i = 0; i < transfersOut1.length; i++) {
-                  for (let j = 0; j < transfersIn0.length; j++) {
-                    const out1 = transfersOut1[i]
-                    const in0 = transfersIn0[j]
-                    if (out1.value === 0n || in0.value === 0n) continue
-                    const rate = +formatEther((out1.value * 10n ** 18n) / in0.value)
-                    if (Math.abs(rate - rate1Number) <= 0.01) {
-                      pairs.push({ assets0: in0.value, assets1: (-out1.value * rate1) / 10n ** 18n })
-                      transfersIn0.splice(j, 1)
-                      break
+                  // Trader buys base with token0: ARM receives token0, sends base.
+                  const transfersOutB = transfersB.filter((t) => t.from.toLowerCase() === armAddress)
+                  const transfersIn0 = transfers0.filter((t) => t.to.toLowerCase() === armAddress)
+                  let buyBaseOut = 0n
+                  let buyToken0In = 0n
+                  for (let i = 0; i < transfersOutB.length; i++) {
+                    for (let j = 0; j < transfersIn0.length; j++) {
+                      const outB = transfersOutB[i]
+                      const in0 = transfersIn0[j]
+                      if (outB.value === 0n || in0.value === 0n) continue
+                      const rate = +formatEther((in0.value * ONE) / outB.value) // token0 per base
+                      if (Math.abs(rate - rateBNumber) <= 0.01) {
+                        buyBaseOut += outB.value
+                        buyToken0In += in0.value
+                        transfersIn0.splice(j, 1)
+                        break
+                      }
                     }
                   }
+                  if (buyBaseOut > 0n) {
+                    swaps.push(
+                      new ArmSwap({
+                        ...swapMeta,
+                        id: `${ctx.chain.id}::${transactionHash}:${baseAsset}:buy`,
+                        tokenIn: armEntity.token0,
+                        amountIn: buyToken0In,
+                        rateIn: ONE,
+                        tokenOut: baseAsset,
+                        amountOut: buyBaseOut,
+                        rateOut: rateB,
+                        assets0: buyToken0In,
+                        assets1: -(buyBaseOut * rateB) / ONE,
+                      }),
+                    )
+                  }
                 }
-
-                const assets0 = pairs.reduce((acc, pair) => acc + pair.assets0, 0n)
-                const assets1 = pairs.reduce((acc, pair) => acc + pair.assets1, 0n)
-
-                swaps.push(
-                  new ArmSwap({
-                    id: `${ctx.chain.id}::${transactionHash}:${trace.traceAddress.join(':')}`,
-                    chainId: ctx.chain.id,
-                    txHash: transactionHash,
-                    txFrom: trace.transaction?.from ?? '',
-                    txTo: trace.transaction?.to ?? '',
-                    timestamp: new Date(block.header.timestamp),
-                    blockNumber: block.header.height,
-                    address: armAddress,
-                    from: trace.action.from,
-                    assets0,
-                    assets1,
-                  }),
-                )
               }
             }
           }
