Harden settlement indexing and test database isolation

Author: bitprecipice

controller/st_controller.go

@@ -1562,6 +1562,9 @@ func (self *CoreStClient) stEventDecoders() []stEventDecoder {
 			stEvent("EmissionDeferred", v.UnpackEmissionDeferredEvent, func(e *stabi.STSettlementVaultEmissionDeferred) map[string]any {
 				return map[string]any{"e": e.Epoch.String(), "no_id": e.NoId.String()}
 			}),
+			stEvent("EmissionDustDeferred", v.UnpackEmissionDustDeferredEvent, func(e *stabi.STSettlementVaultEmissionDustDeferred) map[string]any {
+				return map[string]any{"e": e.Epoch.String(), "no_id": e.NoId.String(), "pool_hotkey": fmt.Sprintf("0x%x", e.PoolHotkey), "observed_alpha_rao": e.ObservedAlphaRao.String(), "tao_equivalent_rao": e.TaoEquivalentRao.String(), "minimum_transfer_tao_rao": fmt.Sprintf("%d", e.MinimumTransferTaoRao)}
+			}),
 			stEvent("EntitlementFinalized", v.UnpackEntitlementFinalizedEvent, func(e *stabi.STSettlementVaultEntitlementFinalized) map[string]any {
 				return map[string]any{"e": e.Epoch.String(), "no_id": e.NoId.String(), "payout_root": fmt.Sprintf("0x%x", e.PayoutRoot), "artifact_hash": fmt.Sprintf("0x%x", e.ArtifactHash), "pool_total": e.Total.String(), "expiry_block": e.ExpiryBlock}
 			}),
@@ -1571,6 +1574,12 @@ func (self *CoreStClient) stEventDecoders() []stEventDecoder {
 			stEvent("MinerClaimed", v.UnpackClaimedEvent, func(e *stabi.STSettlementVaultClaimed) map[string]any {
 				return map[string]any{"e": e.Epoch.String(), "no_id": e.NoId.String(), "coldkey": fmt.Sprintf("0x%x", e.Coldkey), "share_bps": e.ShareBps.String(), "amount": e.Amount.String(), "caller": e.Relayer.Hex()}
 			}),
+			stEvent("ClaimPaymentDeferred", v.UnpackClaimPaymentDeferredEvent, func(e *stabi.STSettlementVaultClaimPaymentDeferred) map[string]any {
+				return map[string]any{"coldkey": fmt.Sprintf("0x%x", e.Coldkey), "credit_alpha_rao": e.CreditAlphaRao.String(), "tao_equivalent_rao": e.TaoEquivalentRao.String(), "minimum_transfer_tao_rao": fmt.Sprintf("%d", e.MinimumTransferTaoRao), "reason": fmt.Sprintf("%d", e.Reason)}
+			}),
+			stEvent("ClaimPaid", v.UnpackClaimPaidEvent, func(e *stabi.STSettlementVaultClaimPaid) map[string]any {
+				return map[string]any{"coldkey": fmt.Sprintf("0x%x", e.Coldkey), "amount": e.Amount.String(), "caller": e.Relayer.Hex()}
+			}),
 			stEvent("BuybackReserved", r.UnpackReservePrincipalAddedEvent, func(e *stabi.STReserveSinkReservePrincipalAdded) map[string]any {
 				return map[string]any{"e": e.Epoch.String(), "no_id": e.NoId.String(), "amount": e.Amount.String(), "buyback_total": e.TotalPrincipal.String(), "live_stake": e.LiveStake.String()}
 			}),

controller/st_event_decoder_test.go

@@ -0,0 +1,101 @@
+package controller
+
+import (
+	"math/big"
+	"reflect"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/urfoundation/sn/stabi"
+)
+
+func settlementVaultEventLog(t *testing.T, name string, indexed []common.Hash, values ...any) *types.Log {
+	t.Helper()
+	parsed, err := stabi.STSettlementVaultMetaData.ParseABI()
+	if err != nil {
+		t.Fatal(err)
+	}
+	event, ok := parsed.Events[name]
+	if !ok {
+		t.Fatalf("settlement-vault ABI has no %s event", name)
+	}
+	data, err := event.Inputs.NonIndexed().Pack(values...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &types.Log{Topics: append([]common.Hash{event.ID}, indexed...), Data: data}
+}
+
+func decodeReleaseEvent(t *testing.T, log *types.Log) (string, map[string]any) {
+	t.Helper()
+	client := &CoreStClient{
+		coordinator: stabi.NewSTCoordinator(),
+		vault:       stabi.NewSTSettlementVault(),
+		reserve:     stabi.NewSTReserveSink(),
+	}
+	for _, decoder := range client.stEventDecoders() {
+		if kind, data, ok := decoder(log); ok {
+			return kind, data
+		}
+	}
+	t.Fatal("release event was not decoded")
+	return "", nil
+}
+
+func TestStEventDecoderMirrorsEmissionDustDeferral(t *testing.T) {
+	pool := common.HexToHash("0x1234")
+	log := settlementVaultEventLog(
+		t,
+		"EmissionDustDeferred",
+		[]common.Hash{common.BigToHash(big.NewInt(7)), common.BigToHash(big.NewInt(3)), pool},
+		big.NewInt(175_960_612),
+		big.NewInt(99_999),
+		uint64(100_000),
+	)
+	kind, data := decodeReleaseEvent(t, log)
+	want := map[string]any{
+		"e": "7", "no_id": "3", "pool_hotkey": pool.Hex(),
+		"observed_alpha_rao": "175960612", "tao_equivalent_rao": "99999", "minimum_transfer_tao_rao": "100000",
+	}
+	if kind != "EmissionDustDeferred" || !reflect.DeepEqual(data, want) {
+		t.Fatalf("decoded dust deferral = %s %#v, want %#v", kind, data, want)
+	}
+}
+
+func TestStEventDecoderMirrorsDeferredClaimCredit(t *testing.T) {
+	coldkey := common.HexToHash("0xabcd")
+	log := settlementVaultEventLog(
+		t,
+		"ClaimPaymentDeferred",
+		[]common.Hash{coldkey},
+		big.NewInt(175_960_612),
+		big.NewInt(99_999),
+		uint64(100_000),
+		uint8(1),
+	)
+	kind, data := decodeReleaseEvent(t, log)
+	want := map[string]any{
+		"coldkey": coldkey.Hex(), "credit_alpha_rao": "175960612", "tao_equivalent_rao": "99999",
+		"minimum_transfer_tao_rao": "100000", "reason": "1",
+	}
+	if kind != "ClaimPaymentDeferred" || !reflect.DeepEqual(data, want) {
+		t.Fatalf("decoded claim deferral = %s %#v, want %#v", kind, data, want)
+	}
+}
+
+func TestStEventDecoderDistinguishesActualClaimPayment(t *testing.T) {
+	coldkey := common.HexToHash("0xabcd")
+	relayer := common.HexToAddress("0x0000000000000000000000000000000000000521")
+	log := settlementVaultEventLog(
+		t,
+		"ClaimPaid",
+		[]common.Hash{coldkey, common.BytesToHash(relayer.Bytes())},
+		big.NewInt(351_921_226),
+	)
+	kind, data := decodeReleaseEvent(t, log)
+	want := map[string]any{"coldkey": coldkey.Hex(), "amount": "351921226", "caller": relayer.Hex()}
+	if kind != "ClaimPaid" || !reflect.DeepEqual(data, want) {
+		t.Fatalf("decoded claim payment = %s %#v, want %#v", kind, data, want)
+	}
+}

db.go

@@ -107,9 +107,10 @@ type safePgPool struct {
 // maintenance pool uses pg_maintenance.yml (direct Postgres, bypassing
 // PgBouncer) and db_maintenance.yml (its own max_connections) — and falls back
 // to the defaults (pg.yml / db.yml) when the pool-specific resource is absent
-// or does not define the size. That fallback keeps tests working (they only
-// redirect pg.yml) and tolerates an empty db_maintenance.yml. The main pool's
-// names ARE the defaults, so its resolution is unchanged.
+// or does not define the size. The test harness redirects both pool resources
+// when a production-shaped profile supplies pg_maintenance.yml, and the
+// fallback still tolerates that resource being absent. The main pool's names
+// ARE the defaults, so its resolution is unchanged.
 func (self *safePgPool) resolveResources() (vaultKeys *SimpleResource, configKeys *SimpleResource) {
 	vaultKeys = Vault.RequireSimpleResource(DefaultPgVaultResourceName)
 	if self.vaultResourceName != DefaultPgVaultResourceName {

test_util.go

@@ -294,6 +294,41 @@ func runTestMain(setup func() func(), run func() int) int {
 	return run()
 }
 
+func testPgResourceForDatabase(pg map[string]any, database string) []byte {
+	return []byte(fmt.Sprintf(
+		`
+authority: "%s"
+user: "%s"
+password: "%s"
+db: "%s"`,
+		pg["authority"],
+		pg["user"],
+		pg["password"],
+		database,
+	))
+}
+
+// Redirect both application and direct-maintenance pools to one ephemeral
+// test database. Production-shaped profiles define pg_maintenance.yml; if it
+// remained pointed at the persistent database, migrations would run there
+// while the test itself saw an empty temporary schema.
+func pushTestPgResources(pg, maintenancePg map[string]any, database string) func() {
+	popPg := Vault.PushSimpleResource(
+		DefaultPgVaultResourceName,
+		testPgResourceForDatabase(pg, database),
+	)
+	popMaintenance := Vault.PushSimpleResource(
+		MaintenancePgVaultResourceName,
+		testPgResourceForDatabase(maintenancePg, database),
+	)
+	PgReset()
+	return func() {
+		popMaintenance()
+		popPg()
+		PgReset()
+	}
+}
+
 // in each test file, `func TestMain(m *testing.M) {(&server.TestEnv{}).TestMain(m)}`
 // https://pkg.go.dev/testing
 func (self *TestEnv) TestMain(m *testing.M) {
@@ -476,7 +511,11 @@ func (self *TestEnv) setup() func() {
 
 	ctx := context.Background()
 
-	pg := Vault.RequireSimpleResource("pg.yml").Parse()
+	pg := Vault.RequireSimpleResource(DefaultPgVaultResourceName).Parse()
+	maintenancePg := pg
+	if resource, resourceErr := Vault.SimpleResource(MaintenancePgVaultResourceName); resourceErr == nil {
+		maintenancePg = resource.Parse()
+	}
 	redisResource := Vault.RequireSimpleResource("redis.yml")
 	redisAuthority := redisResource.RequireString("authority")
 	redisPassword := redisResource.RequireString("password")
@@ -534,21 +573,7 @@ func (self *TestEnv) setup() func() {
 		Raise(err)
 	}, OptReadWrite())
 
-	popPg := Vault.PushSimpleResource(
-		"pg.yml",
-		[]byte(fmt.Sprintf(
-			`
-authority: "%s"
-user: "%s"
-password: "%s"
-db: "%s"`,
-			pg["authority"],
-			pg["user"],
-			pg["password"],
-			testPgDbName,
-		)),
-	)
-	PgReset()
+	popPgResources := pushTestPgResources(pg, maintenancePg, testPgDbName)
 
 	popRedis := Vault.PushSimpleResource(
 		"redis.yml",
@@ -606,8 +631,7 @@ cluster: %t`,
 		popRedis()
 		RedisReset()
 
-		popPg()
-		PgReset()
+		popPgResources()
 
 		Db(ctx, func(conn PgConn) {
 			_, err := conn.Exec(

test_util_test.go

@@ -74,6 +74,50 @@ func TestParseTestPgDbNameValidatesFullIdentifier(t *testing.T) {
 	}
 }
 
+func TestPgResourcesRedirectMaintenancePoolAndRestore(t *testing.T) {
+	popBasePg := Vault.PushSimpleResource(DefaultPgVaultResourceName, []byte(`
+authority: "app.example:5432"
+user: "app"
+password: "app-secret"
+db: "app-db"
+`))
+	defer popBasePg()
+	popBaseMaintenance := Vault.PushSimpleResource(MaintenancePgVaultResourceName, []byte(`
+authority: "direct.example:5432"
+user: "maintenance"
+password: "maintenance-secret"
+db: "maintenance-db"
+`))
+	defer popBaseMaintenance()
+
+	app := Vault.RequireSimpleResource(DefaultPgVaultResourceName).Parse()
+	maintenance := Vault.RequireSimpleResource(MaintenancePgVaultResourceName).Parse()
+	popTest := pushTestPgResources(app, maintenance, "test_exact")
+
+	testApp := Vault.RequireSimpleResource(DefaultPgVaultResourceName)
+	testMaintenance := Vault.RequireSimpleResource(MaintenancePgVaultResourceName)
+	if got := testApp.RequireString("db"); got != "test_exact" {
+		t.Fatalf("test application database = %q, want test_exact", got)
+	}
+	if got := testMaintenance.RequireString("db"); got != "test_exact" {
+		t.Fatalf("test maintenance database = %q, want test_exact", got)
+	}
+	if got := testMaintenance.RequireString("authority"); got != "direct.example:5432" {
+		t.Fatalf("test maintenance authority = %q, want direct authority", got)
+	}
+	if got := testMaintenance.RequireString("user"); got != "maintenance" {
+		t.Fatalf("test maintenance user = %q, want maintenance credentials", got)
+	}
+
+	popTest()
+	if got := Vault.RequireSimpleResource(DefaultPgVaultResourceName).RequireString("db"); got != "app-db" {
+		t.Fatalf("restored application database = %q, want app-db", got)
+	}
+	if got := Vault.RequireSimpleResource(MaintenancePgVaultResourceName).RequireString("db"); got != "maintenance-db" {
+		t.Fatalf("restored maintenance database = %q, want maintenance-db", got)
+	}
+}
+
 // TestRunRetriesUntilPass checks every failure mode is retried: attempt 1
 // panics, 2 calls t.Fail, 3 fails an assertion (assert.Equal -> FailNow ->
 // runtime.Goexit), and 4 passes. Each failure is recorded only on the retryTB