") @@ -317,6 +324,52 @@ func buildAnalysisHtmlFromStructured(s Summary) string { return sb.String() } +// buildFeesSectionHTML renders the Cost section from Summary.Fees.Total — +// same multi-token format as Telegram, just wrapped in HTML. Simulations +// render only the static placeholder. Returns "" when there's nothing to show. +func buildFeesSectionHTML(s Summary) string { + if s.Fees == nil { + return "" + } + + if s.Workflow != nil && s.Workflow.IsSimulation { + // Heading omitted — the placeholder line carries enough context on its own. + return `
⛽ (cost estimated at deploy)
` + + `⛽ `) + sb.WriteString(strings.Join(parts, ", ")) + sb.WriteString("
-wrapped (hex
+ // addresses don't trigger Telegram auto-linking; the wrap adds noise).
+ hasRunner := s.Runner != nil && s.Runner.SmartWallet != ""
+ costLine := formatTelegramCostLine(s)
+ if network != "" || s.TriggeredAt != "" || hasRunner || costLine != "" {
sb.WriteString("\n")
- if network != "" {
- sb.WriteString("Network: ")
- sb.WriteString(html.EscapeString(network))
- sb.WriteString("\n")
- }
if s.TriggeredAt != "" {
sb.WriteString("Time: ")
sb.WriteString(html.EscapeString(formatTimestampHumanReadable(s.TriggeredAt)))
sb.WriteString("\n")
}
+ switch {
+ case hasRunner && network != "":
+ sb.WriteString("Runner: ")
+ sb.WriteString(html.EscapeString(truncateAddress(s.Runner.SmartWallet)))
+ sb.WriteString(" on ")
+ sb.WriteString(html.EscapeString(network))
+ sb.WriteString("\n")
+ case hasRunner:
+ sb.WriteString("Runner: ")
+ sb.WriteString(html.EscapeString(truncateAddress(s.Runner.SmartWallet)))
+ sb.WriteString("\n")
+ case network != "":
+ sb.WriteString("Network: ")
+ sb.WriteString(html.EscapeString(network))
+ sb.WriteString("\n")
+ }
+ if costLine != "" {
+ sb.WriteString(costLine)
+ }
}
// Trigger section
@@ -221,6 +246,42 @@ func formatSubjectWithBoldName(subject string) string {
return sb.String()
}
+// formatTelegramCostLine renders a single Cost line from Summary.Fees.Total.
+// Format: "⛽ Cost: 0.000003 ETH ($0.01), 1.2 USDC ($1.20)" — native
+// token first, comma-separated, USD parenthetical per token. Unpriceable
+// tokens render as "$?". For simulations the line collapses to the static
+// "⛽ (cost estimated at deploy)" placeholder. Returns "" when there's
+// nothing to render.
+func formatTelegramCostLine(s Summary) string {
+ if s.Workflow != nil && s.Workflow.IsSimulation {
+ return "⛽ (cost estimated at deploy)\n"
+ }
+ if s.Fees == nil || len(s.Fees.Total) == 0 {
+ return ""
+ }
+ parts := make([]string, 0, len(s.Fees.Total))
+ for _, t := range s.Fees.Total {
+ if t == nil || t.Amount == "" || t.Amount == "0" {
+ continue
+ }
+ // USD-unit entries are the platform fee — render as "$X platform fee"
+ // (the dollar amount is already canonical; no need for the parenthetical).
+ if t.Unit == "USD" {
+ parts = append(parts, fmt.Sprintf("$%s platform fee", html.EscapeString(t.Amount)))
+ continue
+ }
+ usd := "$?"
+ if t.USD != "" {
+ usd = "$" + t.USD
+ }
+ parts = append(parts, fmt.Sprintf("%s %s (%s)", html.EscapeString(t.Amount), html.EscapeString(t.Unit), usd))
+ }
+ if len(parts) == 0 {
+ return ""
+ }
+ return "⛽ Cost: " + strings.Join(parts, ", ") + "\n"
+}
+
func formatTelegramExampleMessage(workflowName, chainName string) string {
var sb strings.Builder
diff --git a/core/taskengine/summarizer_format_test.go b/core/taskengine/summarizer_format_test.go
index 19d7bd54..cf3007e9 100644
--- a/core/taskengine/summarizer_format_test.go
+++ b/core/taskengine/summarizer_format_test.go
@@ -3,6 +3,7 @@ package taskengine
import (
"context"
"fmt"
+ "math/big"
"os"
"strings"
"testing"
@@ -1010,6 +1011,323 @@ func TestFormatTelegramFromStructured_Annotation(t *testing.T) {
t.Logf("Without annotation:\n%s", resultNoAnnotation)
}
+// TestFormatTelegramFromStructured_RunnerAndFees verifies the Runner and Cost
+// blocks render from Summary.Runner / Summary.Fees, mirroring what the
+// context-memory API now returns. Numbers come from the real Sepolia run
+// captured in aggregator-sepolia.log on 2026-05-02 (see PRD).
+func TestFormatTelegramFromStructured_RunnerAndFees(t *testing.T) {
+ summary := Summary{
+ Subject: "Run #1: Automatically Split Incoming USDC Payments successfully completed",
+ Status: "success",
+ Network: "Sepolia",
+ Trigger: "Transfer event detected: received 1 USDC from 0x804e...1557 on Sepolia",
+ TriggeredAt: "2026-05-02T04:05:29.526Z",
+ Executions: []ExecutionEntry{
+ {Description: "Transferred 0.2 USDC to 0x804e...1557"},
+ {Description: "Transferred 0.5 USDC to 0x25d9...321D"},
+ {Description: "Transferred 0.3 USDC to 0xfE66...bDA9"},
+ },
+ Workflow: &WorkflowInfo{IsSimulation: false},
+ Runner: &RunnerInfo{
+ SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017",
+ OwnerEOA: "0x804e49e8C4eDb560AE7c48B554f6d2e27Bb81557",
+ },
+ Fees: &FeesInfo{
+ ExecutionFee: &FeeAmount{Amount: "0.020000", Unit: "USD"},
+ Total: []*TokenTotal{
+ {Amount: "0.000003", Unit: "ETH", USD: "0.01"},
+ {Amount: "0.02", Unit: "USD", USD: "0.02"}, // platform fee — renders as "$0.02 platform fee"
+ },
+ },
+ }
+
+ out := FormatForMessageChannels(summary, "telegram", nil)
+
+ // Runner line: smart wallet + chain qualifier on a single line ("Runner:
+ // 0x… on Sepolia"). Owner intentionally omitted on Telegram — kept compact
+ // for the channel. Address is truncated (7-char prefix + 4-char suffix),
+ // NOT -wrapped (per PRD).
+ if !strings.Contains(out, "Runner: 0x8Ee38...7017 on Sepolia") {
+ t.Errorf("missing combined Runner+chain line in:\n%s", out)
+ }
+ // Standalone Network line should NOT render when Runner is present —
+ // chain is folded into the Runner line.
+ if strings.Contains(out, "Network:") {
+ t.Errorf("standalone Network line should not render when Runner is present, got:\n%s", out)
+ }
+ if strings.Contains(out, "Owner:") {
+ t.Errorf("Owner line should NOT render on Telegram, got:\n%s", out)
+ }
+ if strings.Contains(out, "0x8Ee3") {
+ t.Errorf("runner address should not be -wrapped, got:\n%s", out)
+ }
+
+ // Cost line: native gas first, then platform fee as a separate "$X platform fee".
+ if !strings.Contains(out, "⛽ Cost: 0.000003 ETH ($0.01), $0.02 platform fee") {
+ t.Errorf("missing combined gas+platform Cost line in:\n%s", out)
+ }
+ if strings.Contains(out, "(~") || strings.Contains(out, "Value fee:") {
+ t.Errorf("Telegram should not render gas-units detail or Value fee line, got:\n%s", out)
+ }
+ if strings.Contains(out, "(cost estimated at deploy)") {
+ t.Errorf("deployed run should not show simulation placeholder, got:\n%s", out)
+ }
+
+ // Cost line follows Runner directly inside the metadata block (no blank
+ // line between them).
+ if !strings.Contains(out, "Runner: 0x8Ee38...7017 on Sepolia\n⛽ Cost: ") {
+ t.Errorf("Cost line should immediately follow Runner line, got:\n%s", out)
+ }
+
+ t.Logf("Telegram render:\n%s", out)
+}
+
+// TestFormatTelegramFromStructured_PlatformFeeOnly covers the read-only path:
+// no on-chain steps, only the platform fee. Renders as "$0.02 platform fee"
+// with no gas-equivalent ETH line that could be misread as gas.
+func TestFormatTelegramFromStructured_PlatformFeeOnly(t *testing.T) {
+ summary := Summary{
+ Subject: "Run #1: Read-Only Workflow successfully completed",
+ Status: "success",
+ Network: "Sepolia",
+ Workflow: &WorkflowInfo{IsSimulation: false},
+ Runner: &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
+ Fees: &FeesInfo{
+ ExecutionFee: &FeeAmount{Amount: "0.02", Unit: "USD"},
+ Total: []*TokenTotal{
+ {Amount: "0.02", Unit: "USD", USD: "0.02"},
+ },
+ },
+ }
+ out := FormatForMessageChannels(summary, "telegram", nil)
+ if !strings.Contains(out, "⛽ Cost: $0.02 platform fee") {
+ t.Errorf("expected platform-fee-only Cost line, got:\n%s", out)
+ }
+ if strings.Contains(out, " ETH (") {
+ t.Errorf("read-only run should not render an ETH line, got:\n%s", out)
+ }
+}
+
+// TestFormatTelegramFromStructured_NoPriceService covers Moralis-not-configured:
+// gas renders with $? for USD; platform fee still shows as the canonical $X.
+func TestFormatTelegramFromStructured_NoPriceService(t *testing.T) {
+ summary := Summary{
+ Subject: "Run #1: Workflow successfully completed",
+ Status: "success",
+ Network: "Sepolia",
+ Workflow: &WorkflowInfo{IsSimulation: false},
+ Runner: &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
+ Fees: &FeesInfo{
+ ExecutionFee: &FeeAmount{Amount: "0.02", Unit: "USD"},
+ Total: []*TokenTotal{
+ {Amount: "0.000003", Unit: "ETH", USD: ""}, // unpriced — renders "$?"
+ {Amount: "0.02", Unit: "USD", USD: "0.02"},
+ },
+ },
+ }
+ out := FormatForMessageChannels(summary, "telegram", nil)
+ if !strings.Contains(out, "⛽ Cost: 0.000003 ETH ($?), $0.02 platform fee") {
+ t.Errorf("expected unpriced ETH + platform fee, got:\n%s", out)
+ }
+}
+
+// TestFormatTelegramFromStructured_MultiToken_USDPlaceholder verifies the
+// multi-token comma-separated render and the "$?" placeholder for unpriceable
+// entries. Mirror of the format spec in the PRD's Rendering section.
+func TestFormatTelegramFromStructured_MultiToken_USDPlaceholder(t *testing.T) {
+ summary := Summary{
+ Subject: "Run #1: Multi-token Workflow successfully completed",
+ Status: "success",
+ Network: "Ethereum",
+ Executions: []ExecutionEntry{{Description: "Transferred 1.2 USDC"}},
+ Workflow: &WorkflowInfo{IsSimulation: false},
+ Runner: &RunnerInfo{SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017"},
+ Fees: &FeesInfo{
+ Total: []*TokenTotal{
+ {Amount: "0.01", Unit: "ETH", USD: "25.00"},
+ {Amount: "1.2", Unit: "USDC", USD: "1.20"},
+ {Amount: "0.005", Unit: "PEPE", USD: ""}, // unpriceable
+ },
+ },
+ }
+
+ out := FormatForMessageChannels(summary, "telegram", nil)
+ want := "⛽ Cost: 0.01 ETH ($25.00), 1.2 USDC ($1.20), 0.005 PEPE ($?)"
+ if !strings.Contains(out, want) {
+ t.Errorf("missing multi-token Cost line %q in:\n%s", want, out)
+ }
+}
+
+// TestPercentOfRaw verifies the value-fee percentage math against raw amounts.
+func TestPercentOfRaw(t *testing.T) {
+ pct := func(s string) *big.Float {
+ v, _ := new(big.Float).SetString(s)
+ return v
+ }
+ cases := []struct {
+ name string
+ raw string
+ pct *big.Float
+ want string
+ }{
+ {"1 USDC × 0.03% = 300 raw (6 decimals)", "1000000", pct("0.0003"), "300"},
+ {"1000 USDC × 0.03%", "1000000000", pct("0.0003"), "300000"},
+ {"zero raw", "0", pct("0.0003"), ""},
+ {"zero pct", "1000000", pct("0"), ""},
+ }
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ rawInt, _ := new(big.Int).SetString(tc.raw, 10)
+ got := percentOfRaw(rawInt, tc.pct)
+ if tc.want == "" {
+ if got != nil && got.Sign() > 0 {
+ t.Errorf("expected nil/zero, got %s", got.String())
+ }
+ return
+ }
+ if got == nil || got.String() != tc.want {
+ t.Errorf("percentOfRaw(%s, %s) = %v, want %s", tc.raw, tc.pct.String(), got, tc.want)
+ }
+ })
+ }
+}
+
+// TestTokenBucketToTokenTotal verifies stablecoin shortcut + zero-rounding.
+func TestTokenBucketToTokenTotal(t *testing.T) {
+ cases := []struct {
+ name string
+ bucket *tokenBucket
+ chainID uint64
+ wantNil bool
+ wantAmount string
+ wantUnit string
+ wantUSD string
+ }{
+ {
+ name: "USDC mainnet 1.0 token via stablecoin shortcut",
+ bucket: &tokenBucket{
+ contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+ symbol: "USDC",
+ decimals: 6,
+ raw: mustBigInt("1000000"),
+ },
+ chainID: 1,
+ wantAmount: "1",
+ wantUnit: "USDC",
+ wantUSD: "1",
+ },
+ {
+ name: "0.0003 USDC via stablecoin shortcut",
+ bucket: &tokenBucket{
+ contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+ symbol: "USDC",
+ decimals: 6,
+ raw: mustBigInt("300"),
+ },
+ chainID: 1,
+ wantAmount: "0.0003",
+ wantUnit: "USDC",
+ wantUSD: "0",
+ },
+ {
+ name: "below precision rounds to zero — omit",
+ bucket: &tokenBucket{
+ contract: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+ symbol: "USDC",
+ decimals: 6,
+ raw: mustBigInt("0"),
+ },
+ chainID: 1,
+ wantNil: true,
+ },
+ {
+ name: "unknown ERC20 with no price service → empty USD",
+ bucket: &tokenBucket{
+ contract: "0xff00000000000000000000000000000000000099",
+ symbol: "?",
+ decimals: 18,
+ raw: mustBigInt("1000000000000000000"),
+ },
+ chainID: 1,
+ wantAmount: "1",
+ wantUnit: "?",
+ wantUSD: "",
+ },
+ }
+ // Ensure no globalPriceService leaks into these tests.
+ prev := globalPriceService
+ globalPriceService = nil
+ t.Cleanup(func() { globalPriceService = prev })
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := tc.bucket.toTokenTotal(tc.chainID)
+ if tc.wantNil {
+ if got != nil {
+ t.Errorf("expected nil, got %+v", got)
+ }
+ return
+ }
+ if got == nil {
+ t.Fatalf("expected non-nil")
+ }
+ if got.Amount != tc.wantAmount {
+ t.Errorf("Amount = %q, want %q", got.Amount, tc.wantAmount)
+ }
+ if got.Unit != tc.wantUnit {
+ t.Errorf("Unit = %q, want %q", got.Unit, tc.wantUnit)
+ }
+ if got.USD != tc.wantUSD {
+ t.Errorf("USD = %q, want %q", got.USD, tc.wantUSD)
+ }
+ })
+ }
+}
+
+func mustBigInt(s string) *big.Int {
+ v, _ := new(big.Int).SetString(s, 10)
+ return v
+}
+
+// TestFormatTelegramFromStructured_Simulation_PlaceholderCost confirms simulation
+// runs render the "(cost estimated at deploy)" placeholder instead of fake-precision
+// numbers. Sim gas prices are conservative chain defaults, so any specific ETH/gas
+// figure would mislead the user.
+func TestFormatTelegramFromStructured_Simulation_PlaceholderCost(t *testing.T) {
+ summary := Summary{
+ Subject: "Simulation: Test Workflow successfully completed",
+ Status: "success",
+ Network: "Sepolia",
+ Executions: []ExecutionEntry{{Description: "(Simulated) Transferred 0.01 ETH"}},
+ Workflow: &WorkflowInfo{IsSimulation: true},
+ Runner: &RunnerInfo{
+ SmartWallet: "0x8Ee38eB323c14a1752DABDA1cca9661AEE377017",
+ OwnerEOA: "0x804e49e8C4eDb560AE7c48B554f6d2e27Bb81557",
+ },
+ Fees: &FeesInfo{
+ ExecutionFee: &FeeAmount{Amount: "0.020000", Unit: "USD"},
+ Cogs: []*NodeCOGS{{
+ NodeID: "transfer1",
+ StepName: "transfer1",
+ CostType: "gas",
+ Fee: &FeeAmount{Amount: "10500000000000", Unit: "WEI"},
+ GasUnits: "21000",
+ }},
+ },
+ }
+
+ out := FormatForMessageChannels(summary, "telegram", nil)
+
+ if !strings.Contains(out, "⛽ (cost estimated at deploy)") {
+ t.Errorf("simulation should render the deploy-time placeholder, got:\n%s", out)
+ }
+ for _, banned := range []string{"Cost:", "0.0000105 ETH", "21 K gas", "platform fee"} {
+ if strings.Contains(out, banned) {
+ t.Errorf("simulation should not render %q, got:\n%s", banned, out)
+ }
+ }
+}
+
// TestTruncateAddress tests the address truncation helper function
func TestTruncateAddress(t *testing.T) {
tests := []struct {
@@ -1392,7 +1710,8 @@ func TestComposeSummary_SimulateTaskFromClientPayload(t *testing.T) {
expectedTelegramContents := []string{
"✅ Simulation: Test settings.name successfully completed",
- "Network: Sepolia",
+ "Runner: ", // chain qualifier folded onto Runner line — see formatTelegramFromStructured
+ " on Sepolia",
"Time:",
"Trigger: (Simulated) Scheduled task ran on Sepolia",
"Executed:",
@@ -1404,9 +1723,14 @@ func TestComposeSummary_SimulateTaskFromClientPayload(t *testing.T) {
}
}
- // Telegram should NOT contain annotation for simulate_task
- if strings.Contains(telegram, "") {
- t.Errorf("Telegram output should not contain italic annotation for simulate_task\nFull output:\n%s", telegram)
+ // Standalone Network line should NOT render — chain is folded into Runner.
+ if strings.Contains(telegram, "Network:") {
+ t.Errorf("standalone Network line should not render when Runner is present, got:\n%s", telegram)
+ }
+
+ // The simulation Cost placeholder uses italic text; allow that but no other italics.
+ if strings.Contains(telegram, "") && !strings.Contains(telegram, "(cost estimated at deploy)") {
+ t.Errorf("Telegram should not contain italic annotation other than the cost placeholder, got:\n%s", telegram)
}
t.Logf("Subject: %s", summary.Subject)
diff --git a/core/taskengine/tenderly_client.go b/core/taskengine/tenderly_client.go
index b7e08752..039dfb65 100644
--- a/core/taskengine/tenderly_client.go
+++ b/core/taskengine/tenderly_client.go
@@ -677,12 +677,13 @@ func (tc *TenderlyClient) SimulateContractWrite(ctx context.Context, contractAdd
}
}
+ sentGasPrice := GetDefaultGasPrice(uint64(chainID))
body := map[string]interface{}{
"network_id": fmt.Sprintf("%d", chainID),
"from": fromAddress,
"to": contractAddress,
"gas": 8000000,
- "gas_price": 0,
+ "gas_price": sentGasPrice,
"value": apiValue,
"input": callData,
"simulation_type": "full",
@@ -996,32 +997,30 @@ func (tc *TenderlyClient) SimulateContractWrite(ctx context.Context, contractAdd
}
}
- // Calculate total gas cost if both gas_used and gas_price are available
- if gasUsed != "" && gasPrice != "" {
- // Convert strings to big.Int for accurate calculation
+ // Compute total gas cost when the simulation produced gas data. The
+ // simulate request always sends a non-zero gas_price (sentGasPrice),
+ // so a zero/missing gas_price in the response is a real anomaly —
+ // surface it as an error rather than silently substituting a default.
+ if gasUsed != "" {
gasUsedBig, gasUsedOk := new(big.Int).SetString(gasUsed, 10)
+ if !gasUsedOk {
+ return nil, fmt.Errorf("tenderly returned unparseable gas_used=%q (chain %d)", gasUsed, chainID)
+ }
gasPriceBig, gasPriceOk := new(big.Int).SetString(gasPrice, 10)
- if gasUsedOk && gasPriceOk {
- totalGasCost := new(big.Int).Mul(gasUsedBig, gasPriceBig)
- result.GasUsed = gasUsed
- result.GasPrice = gasPrice
- result.TotalGasCost = totalGasCost.String()
- tc.logger.Info("✅ Extracted gas information from Tenderly",
- "gas_used", gasUsed,
- "gas_price", gasPrice,
- "total_gas_cost", result.TotalGasCost)
- } else {
- tc.logger.Warn("Failed to parse gas values as big integers",
- "gas_used", gasUsed,
- "gas_price", gasPrice)
- // Store individual values even if calculation failed
- result.GasUsed = gasUsed
- result.GasPrice = gasPrice
+ if !gasPriceOk || gasPriceBig.Sign() == 0 {
+ return nil, fmt.Errorf(
+ "tenderly returned gas_price=%q despite request sending %d (chain %d); refusing silent fallback",
+ gasPrice, sentGasPrice, chainID,
+ )
}
- } else if gasUsed != "" {
- // Only gas used is available
+ totalGasCost := new(big.Int).Mul(gasUsedBig, gasPriceBig)
result.GasUsed = gasUsed
- tc.logger.Info("⚠️ Only gas_used available from Tenderly", "gas_used", gasUsed)
+ result.GasPrice = gasPrice
+ result.TotalGasCost = totalGasCost.String()
+ tc.logger.Info("✅ Extracted gas information from Tenderly",
+ "gas_used", gasUsed,
+ "gas_price", gasPrice,
+ "total_gas_cost", result.TotalGasCost)
} else {
tc.logger.Warn("⚠️ No gas information found in Tenderly response")
}
diff --git a/core/taskengine/vm_runner_eth_transfer.go b/core/taskengine/vm_runner_eth_transfer.go
index dcdf1192..02a8eb39 100644
--- a/core/taskengine/vm_runner_eth_transfer.go
+++ b/core/taskengine/vm_runner_eth_transfer.go
@@ -195,9 +195,26 @@ func (p *ETHTransferProcessor) Execute(stepID string, node *avsproto.ETHTransfer
// Get the sender (smart wallet) address for the transfer object
fromAddress := getAASenderString(p.vm)
+ // Estimated gas for the simulated transfer; populates the same fields a real
+ // receipt would, so downstream cogs/fees handling treats sim and deployed
+ // runs identically.
+ var simChainID uint64
+ if p.smartWalletConfig != nil {
+ simChainID = uint64(p.smartWalletConfig.ChainID)
+ }
+ gasUsedBig := new(big.Int).SetUint64(StandardGasCost)
+ gasPriceBig := new(big.Int).SetUint64(GetDefaultGasPrice(simChainID))
+ totalGasCost := new(big.Int).Mul(gasUsedBig, gasPriceBig)
+ executionLog.GasUsed = gasUsedBig.String()
+ executionLog.GasPrice = gasPriceBig.String()
+ executionLog.TotalGasCost = totalGasCost.String()
+
// Build result object for metadata (only transactionHash - success/isSimulated are in response/executionContext)
resultObj := map[string]interface{}{
"transactionHash": txHash,
+ "gasUsed": executionLog.GasUsed,
+ "gasPrice": executionLog.GasPrice,
+ "totalGasCost": executionLog.TotalGasCost,
}
// Create output data: only transfer object in data field (matches ERC20 format)
diff --git a/core/taskengine/vm_runner_eth_transfer_test.go b/core/taskengine/vm_runner_eth_transfer_test.go
index 752dedbb..653eb645 100644
--- a/core/taskengine/vm_runner_eth_transfer_test.go
+++ b/core/taskengine/vm_runner_eth_transfer_test.go
@@ -477,3 +477,40 @@ func TestETHTransferProcessor_Execute_OversizedHandlebarsTemplate(t *testing.T)
require.NotNil(t, executionLog)
})
}
+
+func TestETHTransferProcessor_Simulation_PopulatesGasFields(t *testing.T) {
+ vm := NewVM()
+ vm.WithLogger(testutil.GetLogger())
+
+ testUserAddress := testutil.TestUser1().Address
+ processor := NewETHTransferProcessor(vm, nil, nil, &testUserAddress)
+
+ node := &avsproto.ETHTransferNode{
+ Config: &avsproto.ETHTransferNode_Config{
+ Destination: "0x742d35Cc6634C0532925a3b8D4C9db96C4b4d8b6",
+ Amount: "1000000000000000000",
+ },
+ }
+ taskNode := &avsproto.TaskNode{
+ Id: "test-step",
+ Name: "TestETHTransfer",
+ Type: avsproto.NodeType_NODE_TYPE_ETH_TRANSFER,
+ TaskType: &avsproto.TaskNode_EthTransfer{EthTransfer: node},
+ }
+ processor.CommonProcessor.SetTaskNode(taskNode)
+ vm.TaskNodes = map[string]*avsproto.TaskNode{"test-step": taskNode}
+
+ executionLog, err := processor.Execute("test-step", node)
+ require.NoError(t, err)
+ require.NotNil(t, executionLog)
+ require.True(t, executionLog.Success)
+
+ // Simulation path lands here when smartWalletConfig is nil. Chain falls back
+ // to GetDefaultGasPrice(0) == DefaultGasPrice (0.5 gwei).
+ wantGasUsed := "21000"
+ wantGasPrice := "500000000" // DefaultGasPrice = 0.5 gwei
+ wantTotal := "10500000000000"
+ assert.Equal(t, wantGasUsed, executionLog.GasUsed, "GasUsed should be StandardGasCost")
+ assert.Equal(t, wantGasPrice, executionLog.GasPrice, "GasPrice should fall back to DefaultGasPrice for unknown chain")
+ assert.Equal(t, wantTotal, executionLog.TotalGasCost, "TotalGasCost should be GasUsed × GasPrice")
+}
diff --git a/core/taskengine/vm_runner_rest.go b/core/taskengine/vm_runner_rest.go
index f81b61d7..aaad62c0 100644
--- a/core/taskengine/vm_runner_rest.go
+++ b/core/taskengine/vm_runner_rest.go
@@ -10,7 +10,6 @@ import (
"time"
avsproto "github.com/AvaProtocol/EigenLayer-AVS/protobuf"
- "github.com/ethereum/go-ethereum/common"
"github.com/go-resty/resty/v2"
"google.golang.org/protobuf/types/known/structpb"
)
@@ -715,36 +714,15 @@ func (r *RestProcessor) Execute(stepID string, node *avsproto.RestAPINode) (*avs
// Get dynamic template data from summary (subject/title/analysis...)
dynamicData := s.SendGridDynamicData()
- // Enrich with runner/eoaAddress for template usage.
- // Read from vm.task directly.
- smartWallet := ""
- ownerEOA := ""
- if r.vm.task != nil && r.vm.task.Task != nil {
- smartWallet = r.vm.task.SmartWalletAddress
- ownerEOA = r.vm.task.Owner
+ // Single source of truth: the runner block returned by context-memory,
+ // shared with the Telegram render. SendGrid template variables keep
+ // their existing format — `runner` is full hex, `eoaAddress` is shortened.
+ if s.Runner != nil {
+ dynamicData["runner"] = s.Runner.SmartWallet
+ dynamicData["eoaAddress"] = shortHex(s.Runner.OwnerEOA)
}
- // Fallback to aa_sender or settings if task not available
- r.vm.mu.Lock()
- if smartWallet == "" {
- if aaSender, ok := r.vm.vars["aa_sender"].(string); ok && aaSender != "" {
- smartWallet = aaSender
- }
- }
- if smartWallet == "" {
- if settings, ok := r.vm.vars["settings"].(map[string]interface{}); ok {
- if runner, ok := settings["runner"].(string); ok && strings.TrimSpace(runner) != "" {
- smartWallet = runner
- }
- }
- }
- if ownerEOA == "" && r.vm.TaskOwner != (common.Address{}) {
- ownerEOA = r.vm.TaskOwner.Hex()
- }
- r.vm.mu.Unlock()
// Get execution index from VM field (set by executor)
executionIndex := r.vm.ExecutionIndex
- dynamicData["runner"] = smartWallet
- dynamicData["eoaAddress"] = shortHex(ownerEOA)
dynamicData["year"] = fmt.Sprintf("%d", time.Now().Year()) // Current year for email footer
// Compute skipped nodes (by name) = workflow nodes - executed step names
diff --git a/docs/changes/0001-execution-status-redesign.md b/docs/changes/20260413-execution-status-redesign.md
similarity index 100%
rename from docs/changes/0001-execution-status-redesign.md
rename to docs/changes/20260413-execution-status-redesign.md
diff --git a/docs/changes/0002-uniswap-simulation-state-propagation.md b/docs/changes/20260416-uniswap-simulation-state-propagation.md
similarity index 100%
rename from docs/changes/0002-uniswap-simulation-state-propagation.md
rename to docs/changes/20260416-uniswap-simulation-state-propagation.md
diff --git a/docs/changes/20260502-notification-cost-line-and-runner.md b/docs/changes/20260502-notification-cost-line-and-runner.md
new file mode 100644
index 00000000..e24fee28
--- /dev/null
+++ b/docs/changes/20260502-notification-cost-line-and-runner.md
@@ -0,0 +1,91 @@
+# Notification Cost Line and Runner — Multi-Token Rendering
+
+- **Date**: 2026-05-02
+- **Status**: Implemented (PR #529, final commit `937d1fd`)
+- **Branch**: `staging`
+- **Related**:
+ - Context-memory PRD: [`context-memory/docs/changes/20260501-summary-runner-and-fees-sections.md`](../../../context-memory/docs/changes/20260501-summary-runner-and-fees-sections.md) — rendering format spec (kept after rollback to aggregator-local)
+ - Aggregator fee model: [`docs/FEE_ESTIMATION.md`](../FEE_ESTIMATION.md)
+ - Proto: [`protobuf/avs.proto`](../../protobuf/avs.proto) — `Execution` (711-713), step gas (737-739), `Fee` / `NodeCOGS` / `ValueFee` (1402-1463)
+ - Commits on PR #529: `cba1ac8` (rollback to aggregator-local), `53f01ed` (multi-token line + price service), `9bac118` (per-token value-fee + stablecoin shortcut), `937d1fd` (TokenEnrichmentService for arbitrary ERC20s)
+
+## Problem
+
+Notifications (Telegram, email) lacked two things a user reads next after "did it work":
+
+1. **Who actually ran this.** The smart wallet and owner EOA were known to the aggregator (`vm.task.SmartWalletAddress`, `vm.task.Owner`) but never surfaced — Telegram/email formatters either omitted them or stitched them in via duplicate VM-state lookups.
+2. **What it cost.** Fees are a first-class concept in the aggregator (execution fee in USD, per-node gas in WEI, value-fee % per workflow), but notifications showed nothing — at most a per-step gas line buried in email.
+
+A separate gap on simulation runs: the aggregator was sending `gas_price: 0` to Tenderly, so simulated `total_gas_cost` always came back zero, and `cogs[]` for sim summaries was empty. Even if we'd surfaced cost, the numbers would've been useless.
+
+## Decision
+
+### Final architecture (after one round of rollback)
+
+**Aggregator owns Runner and Fees end-to-end. Context-memory's `/api/summarize` is unchanged.**
+
+An earlier iteration of this work routed Runner and Fees through context-memory (request payload + response echo) — but those fields were pure passthroughs adding nothing but round-trip latency and API-shape complexity. The aggregator already has every input it needs locally; the API call exists for natural-language fields (subject, executions[], errors), not for data the aggregator can compute itself.
+
+So the data path is:
+
+```
+VM state ──► buildRunnerFromVM ──► Summary.Runner
+ ──► buildFeesFromVM ──► Summary.Fees ──► formatters render
+```
+
+`ComposeSummary` (deterministic) and `ContextMemorySummarizer.Summarize` (when context-memory is available) both call the same helpers; `Summary.Workflow.IsSimulation` is sourced from `vm.IsSimulation` rather than the API response so the formatter's simulation branch never silently misclassifies.
+
+### Cost line format
+
+Single-line, multi-token, native unit first with USD parenthetical per token:
+
+| Case | Render |
+|---|---|
+| ETH-only deployed | `⛽ Cost: 0.000003 ETH ($0.01)` |
+| ETH gas + USDC value-fee | `⛽ Cost: 0.000003 ETH ($0.01), 1.2 USDC ($1.20)` |
+| Unpriceable ERC20 | `⛽ Cost: 0.000003 ETH ($0.01), 0.005 PEPE ($?)` |
+| Read-only deployed (no on-chain steps) | (line omitted) |
+| Simulation | `⛽ (cost estimated at deploy)` — static, no numbers |
+
+Telegram drops bullets, gas-units, and value-fee detail; email matches. Breakdowns live on the dashboard. Simulation collapses to the placeholder because sim gas prices are conservative chain defaults rather than real network conditions — any specific number would mislead.
+
+### Price service: aggregator-only, no fabricated fallback
+
+`PriceService` interface gains `GetERC20PriceUSD(chainID, contract) (*big.Float, error)`. Three-tier hierarchy at the call site (`tokenBucket.toTokenTotal`):
+
+1. **`Stablecoins` map** ([`blockchain_constants.go`](../../core/taskengine/blockchain_constants.go)) — 12 fully-reserved or strongly-collateralized stablecoins (USDC, USDT, DAI, USDS, PYUSD, sDAI, FDUSD, TUSD, GUSD, LUSD, RLUSD, USDG) on the four supported chains. Treated as exactly $1.00; no network call. Algorithmic/synthetic ones (USDe, USDD, FRAX) deliberately excluded — a depeg event must surface, not be papered over.
+2. **`MoralisService.GetERC20PriceUSD`** — for everything else.
+3. **`$?` placeholder** — when neither path yields a price.
+
+`FallbackPriceService` ($2,500/ETH hardcoded) was deleted. When the aggregator's `MoralisApiKey` is empty, the price service stays nil; renderers print `$?` and the aggregator logs "configure Moralis" at startup rather than emitting silently-wrong USD numbers. (Moralis is an aggregator concern; operator nodes don't deal with prices or fee rendering — see [`memory/project_aggregator_vs_operator.md`](../../../../.claude/projects/-Users-mikasa-Code-EigenLayer-AVS/memory/project_aggregator_vs_operator.md).)
+
+### Transfer extraction
+
+`extractOutgoingTransfers` walks `vm.ExecutionLogs` for `eth_transfer`, single `contract_write`, and `loop` step outputs (each loop iteration's child output is examined), filters for `from == smartWallet`, and returns `outgoingTransfer` records. `resolveTokenInfo` resolves `(symbol, decimals)` via Stablecoins → `TokenEnrichmentService.GetTokenMetadata` (same source `/api/summarize` uses) → `("?", 18)` fallback. Per-token aggregation in `buildTotalsFromVM` applies the workflow's value-fee tier percentage to each token's outgoing total; native-ETH transfers fold into the native bucket; ERC20s become separate entries; entries that round to zero at the token's display precision are omitted.
+
+### Simulation-cogs fix (related)
+
+To make simulation cogs[] non-empty in the first place, the Tenderly client now sends `gas_price: GetDefaultGasPrice(chainID)` (per-chain conservative defaults — 5 gwei mainnet, 0.5 gwei Sepolia, 0.05 gwei Base, 0.01 gwei Base Sepolia) rather than `0`. The response parser refuses to silently fall back if the echoed `gas_price` is zero — it returns an error so the bug surfaces upstream rather than producing zeroed cogs. ETH-transfer simulation paths similarly populate `Step.GasUsed/GasPrice/TotalGasCost` from `StandardGasCost × GetDefaultGasPrice(chainID)` so cogs[] aggregates correctly across loop iterations.
+
+## Alternatives considered
+
+- **Compute USD totals on the API server (context-memory).** Rejected: the aggregator already has the price service for `EstimateFees()`. Sending pre-formatted strings or rounded USD numbers from the API locks every channel into the same wording and creates two systems that must agree on which steps are on-chain. The aggregator stays the source of truth.
+- **Hardcode `$2,500/ETH` fallback for ergonomics.** Rejected: silently fabricated USD numbers when the price service is unavailable mask a real configuration issue. `$?` is honest and points operators at "configure Moralis."
+- **Show per-step gas bullets and value-fee subtitle in notifications.** Rejected on simplicity grounds — notifications stay scannable; the dashboard owns the breakdown.
+- **Include algorithmic stablecoins (USDe, USDD, FRAX) in the $1.00 map.** Rejected: incorrect ≈$1.00 assumption miscomputes fees on a depeg, which is exactly when accurate accounting matters. They go through the price service like any other ERC20.
+- **Compute per-iteration cogs entries for loop steps.** Rejected for v1: the existing loop helper rolls child gas into a parent step, and shipping the per-iteration breakdown affects billing reconciliation — bigger decision than a render improvement.
+
+## Verification
+
+- `go test ./core/taskengine/ -count=1` green (full suite covers formatters, fee builders, simulation cogs path, multi-token render, stablecoin lookup, percent-of-raw math).
+- New focused tests:
+ - `TestLookupStablecoin` — chain-keyed map coverage.
+ - `TestPercentOfRaw` — value-fee percentage math against raw amounts.
+ - `TestTokenBucketToTokenTotal` — stablecoin shortcut, zero-rounding omission, missing price service path.
+ - `TestFormatTelegramFromStructured_RunnerAndFees` and `TestFormatTelegramFromStructured_MultiToken_USDPlaceholder` — end-to-end render assertions.
+- Production verification: the next deployed run on Sepolia after `cba1ac8` showed the Telegram block ordering with Runner-and-Network folded onto one line; the simulation summary correctly rendered `⛽ (cost estimated at deploy)` after `4f784c9` (`vm.IsSimulation` flowing through to the formatter).
+- The aggregator's existing tests pass with the price service possibly nil: executor (`executor.go:321,478`), fee estimator (`fee_estimator.go:195`), and the new `buildTotalsFromVM` all guard against `nil` rather than panicking.
+
+## Cross-repo coordination
+
+The context-memory PRD ([`context-memory/docs/changes/20260501-summary-runner-and-fees-sections.md`](../../../context-memory/docs/changes/20260501-summary-runner-and-fees-sections.md)) was rewritten to be a rendering-format spec only — the API stays unchanged, so no context-memory code change is required for this work. The PRD's Decision section retains the Cost-line format table because that's the contract between the aggregator and any future renderer (web dashboard, mobile, etc.).
diff --git a/docs/changes/README.md b/docs/changes/README.md
index 771b5a89..622b593d 100644
--- a/docs/changes/README.md
+++ b/docs/changes/README.md
@@ -4,8 +4,6 @@ Long-form notes for changes worth remembering after the PR merges. Format and ed
Filename: `YYYYMMDD-kebab-case-title.md`. Each entry opens with a header block (Date, Status, Branch, Related) and a body adapted to the change (typically Problem / Decision / Alternatives / Verification). See existing entries for examples.
-Earlier entries (`0001-…`, `0002-…`) used a sequential four-digit prefix; those filenames are referenced from merged commits and stay as-is. New entries use the date prefix.
-
## Project-specific notes
_None yet. Add things here that only apply to this repo: dashboards we cross-link to, tags or prefixes we use, runbooks worth pointing at._