[Applicaton] Provable past delegations & delayed undelegations

e2e/tests/delegate.feature

@@ -0,0 +1,61 @@
+Feature: Delegate Namespaces
+
+ Background:
+ # Setup Tx and NewBlock event query clients for each scenario
+ Given the poktroll chain is reachable
+
+ Scenario: User can delegate Application to Gateway
+ Given the user has the pocketd binary installed
+ And the actor type "application" with account "app1" is staked with enough uPOKT
+ And the actor type "gateway" with account "gateway1" is staked with enough uPOKT
+ # Ensure that the application does not have any delegation
+ # This is to avoid any conflicts with previous delegations added by
+ # genesis transactions or previous tests.
+ And the application "app1" does not have any delegation
+ When the user delegates application "app1" to gateway "gateway1"
+ Then application "app1" is delegated to gateway "gateway1"
+
+ Scenario: User can undelegate Application from Gateway
+ Given the user has the pocketd binary installed
+ And the actor type "application" with account "app1" is staked with enough uPOKT
+ And the actor type "gateway" with account "gateway1" is staked with enough uPOKT
+ And the application "app1" does not have any delegation
+ When the user delegates application "app1" to gateway "gateway1"
+ # Ensure that the undelegation does not happen in the last block of the
+ # sesssion which could prevent observing that is only effective in the next session.
+ And the user undelegates application "app1" from gateway "gateway1" before the session end block
+ # Undelegation is not effective yet.
+ Then application "app1" is delegated to gateway "gateway1"
+ When the user waits until the start of the next session
+ # The undelegation becomes effective.
+ Then application "app1" is not delegated to gateway "gateway1"
+ And application "app1" has gateway "gateway1" address in the archived delegations
+
+ Scenario: Application can override undelegation from a Gateway
+ Given the user has the pocketd binary installed
+ And the actor type "application" with account "app1" is staked with enough uPOKT
+ And the actor type "gateway" with account "gateway1" is staked with enough uPOKT
+ And the application "app1" does not have any delegation
+ When the user delegates application "app1" to gateway "gateway1"
+ # Undelegate before the current session's end block so the next step can override it.
+ And the user undelegates application "app1" from gateway "gateway1" before the session end block
+ # The user redelegates to the same gateway before the next session.
+ # This should override the previous undelegation.
+ And the user delegates application "app1" to gateway "gateway1"
+ # Wait until the next session to see that the undelegation did not take effect.
+ And the user waits until the start of the next session
+ Then application "app1" is delegated to gateway "gateway1"
+
+ Scenario: Application gets its archived delegations pruned
+ Given the user has the pocketd binary installed
+ And the actor type "application" with account "app1" is staked with enough uPOKT
+ And the actor type "gateway" with account "gateway1" is staked with enough uPOKT
+ And the application "app1" does not have any delegation
+ When the user delegates application "app1" to gateway "gateway1"
+ And the user undelegates application "app1" from gateway "gateway1"
+ And the user waits until the start of the next session
+ Then application "app1" is not delegated to gateway "gateway1"
+ And application "app1" has gateway "gateway1" address in the archived delegations
+ When the user waits until archived delegations are pruned
+ Then application "app1" is not delegated to gateway "gateway1"
+ And application "app1" does not have gateway "gateway1" address in the archived delegations

e2e/tests/delegate_steps_test.go

@@ -0,0 +1,249 @@
+//go:build e2e
+
+package e2e
+
+import (
+ "context"
+ "fmt"
+ "strings"
+ "sync"
+
+ "cosmossdk.io/depinject"
+ "github.com/cometbft/cometbft/libs/json"
+ "github.com/stretchr/testify/require"
+ "golang.org/x/exp/slices"
+
+ "github.com/pokt-network/poktroll/pkg/client"
+ "github.com/pokt-network/poktroll/pkg/client/block"
+ "github.com/pokt-network/poktroll/pkg/client/events"
+ "github.com/pokt-network/poktroll/pkg/client/tx"
+ "github.com/pokt-network/poktroll/testutil/testclient"
+ appkeeper "github.com/pokt-network/poktroll/x/application/keeper"
+ "github.com/pokt-network/poktroll/x/application/types"
+ sessionkeeper "github.com/pokt-network/poktroll/x/session/keeper"
+)
+
+const (
+ // serviceId to stake for by applications.
+ serviceId = "anvil"
+ // defaultStakeAmount is the default amount to stake for applications and gateways.
+ defaultStakeAmount = 1000000
+)
+
+func (s *suite) TheActorTypeWithAccountIsStakedWithEnoughUpokt(accType, accName string) {
+ // Get the staked amount for account, if it exists.
+ // This is used to determine how much to stake for the actor and whether
+ // it is already staked or not.
+ stakedAmount, ok := s.getStakedAmount(accType, accName)
+ if !ok {
+ stakedAmount = defaultStakeAmount
+ }
+
+ // Fund the actor with enough upokt to stake for the service.
+ s.TheUserSendsUpoktFromAccountToAccount(int64(stakedAmount+1), "pnf", accName)
+ s.waitForTxResultEvent(
+ "transfer",
+ "recipient",
+ accNameToAddrMap[accName],
+ )
+
+ // Stake for the service with the
+ s.TheUserStakesAWithUpoktForServiceFromTheAccount(
+ accType,
+ int64(stakedAmount+1),
+ serviceId,
+ accName,
+ )
+ s.TheUserShouldWaitForTheModuleMessageToBeSubmitted(
+ accType,
+ fmt.Sprintf("Stake%s", strings.Title(accType)),
+ )
+}
+
+func (s *suite) TheUserDelegatesApplicationToGateway(appName, gatewayName string) {
+ args := []string{
+ "tx",
+ "application",
+ "delegate-to-gateway",
+ accNameToAddrMap[gatewayName],
+ "--from",
+ appName,
+ keyRingFlag,
+ chainIdFlag,
+ "-y",
+ }
+ _, err := s.pocketd.RunCommandOnHost("", args...)
+ require.NoError(s, err)
+
+ s.TheUserShouldWaitForTheModuleMessageToBeSubmitted(
+ "application",
+ "DelegateToGateway",
+ )
+}
+
+func (s *suite) TheApplicationDoesNotHaveAnyDelegation(appName string) {
+ application := s.showApplication(appName)
+ undelegationWaitGroup := sync.WaitGroup{}
+ undelegationWaitGroup.Add(len(application.DelegateeGatewayAddresses))
+
+ // Concurrently undelegate the application from all gateways and wait for the
+ // transactions to be committed.
+ for _, gatewayAddress := range application.DelegateeGatewayAddresses {
+ go func(gatewayAddress string) {
+ s.TheUserUndelegatesApplicationFromGateway(appName, accAddrToNameMap[gatewayAddress])
+ s.TheUserWaitsUntilTheStartOfTheNextSession()
+ undelegationWaitGroup.Done()
+ }(gatewayAddress)
+ }
+ undelegationWaitGroup.Wait()
+}
+
+func (s *suite) ApplicationIsDelegatedToGateway(appName, gatewayName string) {
+ application := s.showApplication(appName)
+ require.Containsf(s,
+ application.DelegateeGatewayAddresses,
+ accNameToAddrMap[gatewayName],
+ "app %q is not delegated to gateway %q",
+ appName, gatewayName,
+ )
+}
+
+func (s *suite) ApplicationIsNotDelegatedToGateway(appName, gatewayName string) {
+ application := s.showApplication(appName)
+ require.NotContainsf(s,
+ application.DelegateeGatewayAddresses,
+ accNameToAddrMap[gatewayName],
+ "app %q is delegated to gateway %q",
+ appName, gatewayName,
+ )
+}
+
+func (s *suite) TheUserUndelegatesApplicationFromGatewayBeforeTheSessionEndBlock(appName, gatewayName string) {
+ s.TheUserWaitsUntilTheStartOfTheNextSession()
+ s.TheUserUndelegatesApplicationFromGateway(appName, gatewayName)
+}
+
+func (s *suite) TheUserUndelegatesApplicationFromGateway(appName, gatewayName string) {
+ args := []string{
+ "tx",
+ "application",
+ "undelegate-from-gateway",
+ accNameToAddrMap[gatewayName],
+ "--from",
+ appName,
+ keyRingFlag,
+ chainIdFlag,
+ "-y",
+ }
+ _, err := s.pocketd.RunCommandOnHost("", args...)
+ require.NoError(s, err)
+
+ s.TheUserShouldWaitForTheModuleMessageToBeSubmitted(
+ "application",
+ "UndelegateFromGateway",
+ )
+}
+
+func (s *suite) ApplicationHasGatewayAddressInTheArchivedDelegations(appName, gatewayName string) {
+ application := s.showApplication(appName)
+ require.Truef(s,
+ slices.ContainsFunc(application.ArchivedDelegations,
+ func(archivedDelegations types.ArchivedDelegations) bool {
+ return slices.Contains(archivedDelegations.GatewayAddresses, accNameToAddrMap[gatewayName])
+ }),
+ "app %q does not have gateway %q in its archived delegations",
+ appName, gatewayName,
+ )
+}
+
+func (s *suite) ApplicationDoesNotHaveGatewayAddressInTheArchivedDelegations(appName, gatewayName string) {
+ application := s.showApplication(appName)
+ require.Falsef(s,
+ slices.ContainsFunc(application.ArchivedDelegations,
+ func(archivedDelegations types.ArchivedDelegations) bool {
+ return slices.Contains(archivedDelegations.GatewayAddresses, accNameToAddrMap[gatewayName])
+ }),
+ "app %q has gateway %q in its archived delegations",
+ appName, gatewayName,
+ )
+}
+
+func (s *suite) ThePoktrollChainIsReachable() {
+ ctx := context.Background()
+
+ // Construct an events query client to listen for tx events from the supplier.
+ deps := depinject.Supply(events.NewEventsQueryClient(testclient.CometLocalWebsocketURL))
+ txEventsReplayClient, err := events.NewEventsReplayClient(
+ ctx,
+ deps,
+ "tm.event='Tx'",
+ tx.UnmarshalTxResult,
+ eventsReplayClientBufferSize,
+ )
+ require.NoError(s, err)
+ s.scenarioState[txResultEventsReplayClientKey] = txEventsReplayClient
+
+ // Construct an events query client to listen for claim settlement or expiration events on-chain.
+ blockEventsReplayClient, err := events.NewEventsReplayClient(
+ ctx,
+ deps,
+ newBlockEventSubscriptionQuery,
+ block.UnmarshalNewBlockEvent,
+ eventsReplayClientBufferSize,
+ )
+ require.NoError(s, err)
+ s.scenarioState[newBlockEventReplayClientKey] = blockEventsReplayClient
+}
+
+func (s *suite) TheUserWaitsUntilTheStartOfTheNextSession() {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ blockReplayClient := s.scenarioState[newBlockEventReplayClientKey].(client.EventsReplayClient[*block.CometNewBlockEvent])
+ block := blockReplayClient.LastNEvents(ctx, 1)[0]
+ nextSessionStartHeight := sessionkeeper.GetSessionEndBlockHeight(block.Height()) + 1
+
+ blockObs := blockReplayClient.EventsSequence(ctx).Subscribe(ctx)
+ for newBlock := range blockObs.Ch() {
+ if newBlock.Height() >= nextSessionStartHeight {
+ break
+ }
+ }
+}
+
+func (s *suite) TheUserWaitsUntilArchivedDelegationsArePruned() {
+ ctx, cancel := context.WithCancel(context.Background())
+ defer cancel()
+
+ blockReplayClient := s.scenarioState[newBlockEventReplayClientKey].(client.EventsReplayClient[*block.CometNewBlockEvent])
+ block := blockReplayClient.LastNEvents(ctx, 1)[0]
+ delegationPruningBlockHeight := block.Height() + appkeeper.ArchivedDelegationsRetentionBlocks
+
+ blockObs := blockReplayClient.EventsSequence(ctx).Subscribe(ctx)
+ for newBlock := range blockObs.Ch() {
+ if newBlock.Height() >= delegationPruningBlockHeight {
+ break
+ }
+ }
+}
+
+// showApplication issues a application show-application query with json output
+// parses its content and return the application.
+func (s *suite) showApplication(appName string) types.Application {
+ args := []string{
+ "q",
+ "application",
+ "show-application",
+ accNameToAddrMap[appName],
+ chainIdFlag,
+ "--output",
+ "json",
+ }
+ res, err := s.pocketd.RunCommandOnHost("", args...)
+ require.NoError(s, err)
+ var queryGetApplicationResponse types.QueryGetApplicationResponse
+ err = json.Unmarshal([]byte(res.Stdout), &queryGetApplicationResponse)
+ require.NoError(s, err)
+
+ return queryGetApplicationResponse.Application
+}

e2e/tests/init_test.go

@@ -269,6 +269,10 @@ func (s *suite) getConfigFileContent(amount int64, actorType, serviceId string)
  - publicly_exposed_url: http://relayminer:8545
  rpc_type: json_rpc`,
  amount, serviceId)
+ case "gateway":
+ configContent = fmt.Sprintf(`
+ stake_amount: %dupokt`,
+ amount)
  default:
  s.Fatalf("unknown actor type %s", actorType)
  }

e2e/tests/session_steps_test.go

@@ -57,7 +57,7 @@ const (
 )
 
 func (s *suite) TheUserShouldWaitForTheModuleMessageToBeSubmitted(module, message string) {
- s.waitForTxResultEvent(fmt.Sprintf("/poktroll.%s.Msg%s", module, message))
+ s.waitForTxResultEvent("message", "action", fmt.Sprintf("/poktroll.%s.Msg%s", module, message))
 }
 
 func (s *suite) TheUserShouldWaitForTheModuleEventToBeBroadcast(module, message string) {
@@ -200,7 +200,7 @@ func (s *suite) sendRelaysForSession(
 }
 
 // waitForTxResultEvent waits for an event to be observed which has the given message action.
-func (s *suite) waitForTxResultEvent(targetAction string) {
+func (s *suite) waitForTxResultEvent(eventType, targetKey, targetValue string) {
  ctx, done := context.WithCancel(context.Background())
 
  txResultEventsReplayClientState, ok := s.scenarioState[txResultEventsReplayClientKey]
@@ -221,9 +221,12 @@ func (s *suite) waitForTxResultEvent(targetAction string) {
  // Range over each event's attributes to find the "action" attribute
  // and compare its value to that of the action provided.
  for _, event := range txResult.Result.Events {
+ if event.Type != eventType {
+ continue
+ }
  for _, attribute := range event.Attributes {
- if attribute.Key == "action" {
- if attribute.Value == targetAction {
+ if attribute.Key == targetKey {
+ if attribute.Value == targetValue {
  done()
  return
  }
@@ -235,7 +238,7 @@ func (s *suite) waitForTxResultEvent(targetAction string) {
 
  select {
  case <-time.After(eventTimeout):
- s.Fatalf("timed out waiting for message with action %q", targetAction)
+ s.Fatalf("timed out waiting for message with %q %q", targetKey, targetValue)
  case <-ctx.Done():
  s.Log("Success; message detected before timeout.")
  }

pkg/crypto/interface.go

@@ -33,9 +33,9 @@ type RingCache interface {
 // the addresses of the gateways the application delegated to, and converting
 // them into their corresponding public key points on the secp256k1 curve.
 type RingClient interface {
- // GetRingForAddress returns the ring for the given application address if
- // it exists.
- GetRingForAddress(ctx context.Context, appAddress string) (*ring.Ring, error)
+ // GetRingForAddress returns the ring for the application address at a given
+ // block height if it exists.
+ GetRingForAddress(ctx context.Context, appAddress string, blockHeight int64) (*ring.Ring, error)
 
  // VerifyRelayRequestSignature verifies the relay request signature against
  // the ring for the application address in the relay request.