fix: improve CI test stability with dynamic address discovery

- Replace hardcoded TestAddress with dynamic discovery via getTestAddress()
- Add waitForValidators() and getValidatorsWithRetry() helpers for CI timing
- Run integration tests sequentially (-p 1) to prevent sequence mismatches
- Update 15 test files to use dynamic address resolution

Author: MrLutik

.github/workflows/ci.yml

@@ -128,7 +128,7 @@ jobs:
         run: ./sekai-cli scenario run examples/scenarios/ci-integration-test.yaml
 
       - name: Run Go integration tests
-        run: go test -v -timeout 30m ./test/integration/...
+        run: go test -v -timeout 30m -p 1 ./test/integration/...
 
       - name: Collect logs on failure
         if: failure()

test/integration/auth_test.go

@@ -11,19 +11,20 @@ import (
 // TestAuthAccount tests querying a single account by address.
 func TestAuthAccount(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := auth.New(client)
-	result, err := mod.Account(ctx, TestAddress)
+	result, err := mod.Account(ctx, testAddr)
 	requireNoError(t, err, "Failed to query account")
 	requireNotNil(t, result, "Account is nil")
 
 	// Verify account has expected fields
-	requireEqual(t, TestAddress, result.Address, "Address mismatch")
+	requireEqual(t, testAddr, result.Address, "Address mismatch")
 	requireTrue(t, result.AccountNumber != "", "Account number should not be empty")
 
 	t.Logf("Account: %s, Number: %s, Sequence: %s", result.Address, result.AccountNumber, result.Sequence)
@@ -32,6 +33,7 @@ func TestAuthAccount(t *testing.T) {
 // TestAuthAccounts tests querying all accounts.
 func TestAuthAccounts(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
@@ -51,7 +53,7 @@ func TestAuthAccounts(t *testing.T) {
 	// Verify the test address is in the list
 	found := false
 	for _, acc := range result.Accounts {
-		if acc.Address == TestAddress {
+		if acc.Address == testAddr {
 			found = true
 			break
 		}
@@ -62,6 +64,7 @@ func TestAuthAccounts(t *testing.T) {
 // TestAuthAddressByAccNum tests querying an address by account number.
 func TestAuthAddressByAccNum(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
@@ -71,7 +74,7 @@ func TestAuthAddressByAccNum(t *testing.T) {
 	mod := auth.New(client)
 
 	// First get the account to know its account number
-	acc, err := mod.Account(ctx, TestAddress)
+	acc, err := mod.Account(ctx, testAddr)
 	requireNoError(t, err, "Failed to query account")
 	requireNotNil(t, acc, "Account is nil")
 
@@ -80,7 +83,7 @@ func TestAuthAddressByAccNum(t *testing.T) {
 	requireNoError(t, err, "Failed to query address by account number")
 	requireNotNil(t, result, "Result is nil")
 
-	requireEqual(t, TestAddress, result.AccountAddress, "Address mismatch")
+	requireEqual(t, testAddr, result.AccountAddress, "Address mismatch")
 	t.Logf("Account number %s maps to address %s", acc.AccountNumber, result.AccountAddress)
 }
 

test/integration/bank_test.go

@@ -13,17 +13,18 @@ import (
 // TestBankBalances tests querying all balances for an address.
 func TestBankBalances(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := bank.New(client)
-	result, err := mod.Balances(ctx, TestAddress)
+	result, err := mod.Balances(ctx, testAddr)
 	requireNoError(t, err, "Failed to query balances")
 
-	t.Logf("Address %s has %d token types", TestAddress, len(result))
+	t.Logf("Address %s has %d token types", testAddr, len(result))
 	for _, coin := range result {
 		t.Logf("  %s: %s", coin.Denom, coin.Amount)
 	}
@@ -32,35 +33,37 @@ func TestBankBalances(t *testing.T) {
 // TestBankBalance tests querying balance for a specific denom.
 func TestBankBalance(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := bank.New(client)
-	result, err := mod.Balance(ctx, TestAddress, "ukex")
+	result, err := mod.Balance(ctx, testAddr, "ukex")
 	requireNoError(t, err, "Failed to query balance")
 	requireNotNil(t, result, "Balance is nil")
 
 	requireEqual(t, "ukex", result.Denom, "Denom mismatch")
-	t.Logf("Address %s has %s ukex", TestAddress, result.Amount)
+	t.Logf("Address %s has %s ukex", testAddr, result.Amount)
 }
 
 // TestBankSpendableBalances tests querying spendable balances.
 func TestBankSpendableBalances(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := bank.New(client)
-	result, err := mod.SpendableBalances(ctx, TestAddress)
+	result, err := mod.SpendableBalances(ctx, testAddr)
 	requireNoError(t, err, "Failed to query spendable balances")
 
-	t.Logf("Address %s has %d spendable token types", TestAddress, len(result))
+	t.Logf("Address %s has %d spendable token types", testAddr, len(result))
 	for _, coin := range result {
 		t.Logf("  %s: %s", coin.Denom, coin.Amount)
 	}
@@ -154,7 +157,8 @@ func TestBankSend(t *testing.T) {
 	t.Logf("Recipient address: %s", recipientAddr)
 
 	// Get initial balances
-	senderBalanceBefore, err := bankMod.Balance(ctx, TestAddress, "ukex")
+	testAddr := getTestAddress(t)
+	senderBalanceBefore, err := bankMod.Balance(ctx, testAddr, "ukex")
 	requireNoError(t, err, "Failed to query sender balance")
 	t.Logf("Sender balance before: %s ukex", senderBalanceBefore.Amount)
 

test/integration/basket_test.go

@@ -325,7 +325,8 @@ func TestBasketProposalWithdrawSurplus(t *testing.T) {
 		Description: "Integration test - verify withdraw surplus proposal",
 	}
 
-	resp, err := mod.ProposalWithdrawSurplus(ctx, TestKey, "1", TestAddress, propOpts, nil)
+	testAddr := getTestAddress(t)
+	resp, err := mod.ProposalWithdrawSurplus(ctx, TestKey, "1", testAddr, propOpts, nil)
 	if err != nil {
 		t.Logf("ProposalWithdrawSurplus may have failed (no basket): %v", err)
 		return

test/integration/bridge_test.go

@@ -10,14 +10,15 @@ import (
 // TestBridgeGetCosmosEthereum tests querying cosmos to ethereum changes.
 func TestBridgeGetCosmosEthereum(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := bridge.New(client)
-	result, err := mod.GetCosmosEthereum(ctx, TestAddress)
+	result, err := mod.GetCosmosEthereum(ctx, testAddr)
 	if err != nil {
 		// This may fail if no bridge changes exist
 		t.Logf("Cosmos to Ethereum query: %v (expected if no changes)", err)
@@ -30,14 +31,15 @@ func TestBridgeGetCosmosEthereum(t *testing.T) {
 // TestBridgeGetEthereumCosmos tests querying ethereum to cosmos changes.
 func TestBridgeGetEthereumCosmos(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := bridge.New(client)
-	result, err := mod.GetEthereumCosmos(ctx, TestAddress)
+	result, err := mod.GetEthereumCosmos(ctx, testAddr)
 	if err != nil {
 		// This may fail if no bridge changes exist
 		t.Logf("Ethereum to Cosmos query: %v (expected if no changes)", err)
@@ -59,7 +61,8 @@ func TestBridgeChangeCosmosEthereum(t *testing.T) {
 	mod := bridge.New(client)
 
 	// Use test values
-	cosmosAddress := TestAddress
+	testAddr := getTestAddress(t)
+	cosmosAddress := testAddr
 	ethAddress := "0x1234567890123456789012345678901234567890"
 	amount := "100ukex"
 
@@ -88,7 +91,8 @@ func TestBridgeChangeEthereumCosmos(t *testing.T) {
 	mod := bridge.New(client)
 
 	// Use test values
-	cosmosAddress := TestAddress
+	testAddr := getTestAddress(t)
+	cosmosAddress := testAddr
 	ethTxHash := "0x" + generateUniqueID("txhash")
 	amount := "100ukex"
 

test/integration/collectives_test.go

@@ -26,21 +26,22 @@ func TestCollectivesAll(t *testing.T) {
 // TestCollectivesByAccount tests querying collectives by account.
 func TestCollectivesByAccount(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := collectives.New(client)
-	result, err := mod.CollectivesByAccount(ctx, TestAddress)
+	result, err := mod.CollectivesByAccount(ctx, testAddr)
 	if err != nil {
 		// This may fail if no collectives for this account
 		t.Logf("Collectives by account query: %v (expected if no collectives)", err)
 		return
 	}
 
-	t.Logf("Collectives for %s: %s", TestAddress, string(result))
+	t.Logf("Collectives for %s: %s", testAddr, string(result))
 }
 
 // TestCollectivesProposals tests querying collectives proposals.
@@ -253,11 +254,12 @@ func TestCollectivesProposalSendDonation(t *testing.T) {
 
 	mod := collectives.New(client)
 
+	testAddr := getTestAddress(t)
 	propOpts := &collectives.ProposalSendDonationOpts{
 		Title:          "Test send donation proposal",
 		Description:    "Integration test - verify send donation proposal submission",
 		CollectiveName: "test-collective",
-		Address:        TestAddress,
+		Address:        testAddr,
 		Amounts:        "10ukex",
 	}
 

test/integration/custody_test.go

@@ -10,95 +10,100 @@ import (
 // TestCustodyGet tests querying custody for an address.
 func TestCustodyGet(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := custody.New(client)
-	result, err := mod.Get(ctx, TestAddress)
+	result, err := mod.Get(ctx, testAddr)
 	if err != nil {
 		// This may fail if no custody is set
 		t.Logf("Custody get query: %v (expected if no custody)", err)
 		return
 	}
 
-	t.Logf("Custody for %s: %s", TestAddress, string(result))
+	t.Logf("Custody for %s: %s", testAddr, string(result))
 }
 
 // TestCustodyCustodians tests querying custody custodians.
 func TestCustodyCustodians(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := custody.New(client)
-	result, err := mod.Custodians(ctx, TestAddress)
+	result, err := mod.Custodians(ctx, testAddr)
 	if err != nil {
 		// This may fail if no custodians are set
 		t.Logf("Custodians query: %v (expected if no custodians)", err)
 		return
 	}
 
-	t.Logf("Custodians for %s: %s", TestAddress, string(result))
+	t.Logf("Custodians for %s: %s", testAddr, string(result))
 }
 
 // TestCustodyWhitelist tests querying custody whitelist.
 func TestCustodyWhitelist(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := custody.New(client)
-	result, err := mod.Whitelist(ctx, TestAddress)
+	result, err := mod.Whitelist(ctx, testAddr)
 	if err != nil {
 		// This may fail if no whitelist is set
 		t.Logf("Whitelist query: %v (expected if no whitelist)", err)
 		return
 	}
 
-	t.Logf("Whitelist for %s: %s", TestAddress, string(result))
+	t.Logf("Whitelist for %s: %s", testAddr, string(result))
 }
 
 // TestCustodyLimits tests querying custody limits.
 func TestCustodyLimits(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := custody.New(client)
-	result, err := mod.Limits(ctx, TestAddress)
+	result, err := mod.Limits(ctx, testAddr)
 	if err != nil {
 		// This may fail if no limits are set
 		t.Logf("Limits query: %v (expected if no limits)", err)
 		return
 	}
 
-	t.Logf("Limits for %s: %s", TestAddress, string(result))
+	t.Logf("Limits for %s: %s", testAddr, string(result))
 }
 
 // TestCustodyCustodiansPool tests querying custody pool for an address.
 func TestCustodyCustodiansPool(t *testing.T) {
 	skipIfContainerNotRunning(t)
+	testAddr := getTestAddress(t)
 	client := getTestClient(t)
 	defer client.Close()
 
 	ctx, cancel := getTestContext()
 	defer cancel()
 
 	mod := custody.New(client)
-	result, err := mod.CustodiansPool(ctx, TestAddress)
+	result, err := mod.CustodiansPool(ctx, testAddr)
 	requireNoError(t, err, "Failed to query custody pool")
 
-	t.Logf("Custody pool for %s: %s", TestAddress, string(result))
+	t.Logf("Custody pool for %s: %s", testAddr, string(result))
 }