Make Handlers constructed only once

[mossid]

The reason we are not implementing handler like Keeper.Handle() is that a malicious module can forge a msg and pass it to other keeper's handler to manipulate the state illegally if they hold the keeper. But still they can call NewHandler() that the modules are exposing.

Proposal

Define a function UniqueHandler:

var created map[uintptr]struct{} = make(map[uintptr]struct{})

func UniqueHandler(h sdk.Handler) sdk.Handler {
  ptr := reflect.ValueOf(h).Pointer()
  if _, ok := created[ptr]; ok {
    panic("Multiple generation of handler")
  }
  created[ptr] = struct{}{}
  return h
}

The users can simply wrap the inner handler in their NewHandler to prevent double-NewHandler

func NewHandler(k Keeper) sdk.Handler {
  return sdk.UniqueHandler(func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
    //...
  }
}

In go playground: https://play.golang.org/p/D5QMF02KRAk

The downside of this implementation is that it willnot generate multiple handlers for multiple keepers within a module. For now the developer can simply don't use this function when they need multiple handlers.

[rigelrozanski]

Are we actually concerned about this?
My understanding was that we just wanted to avoid bad practices if modules were to call the handlers on the keepers within other modules.

Any module can still just broadcast the message if they want to manipulate the state.

[jackzampolin]

This is no longer applicable, closing.