192 lines
4.3 KiB
Go
192 lines
4.3 KiB
Go
package rest
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/gorilla/mux"
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/tendermint/basecoin"
|
|
keysutils "github.com/tendermint/go-crypto/cmd"
|
|
keys "github.com/tendermint/go-crypto/keys"
|
|
"github.com/tendermint/tmlibs/common"
|
|
)
|
|
|
|
type Keys struct {
|
|
algo string
|
|
manager keys.Manager
|
|
}
|
|
|
|
func DefaultKeysManager() keys.Manager {
|
|
return keysutils.GetKeyManager()
|
|
}
|
|
|
|
func NewDefaultKeysManager(algo string) *Keys {
|
|
return New(DefaultKeysManager(), algo)
|
|
}
|
|
|
|
func New(manager keys.Manager, algo string) *Keys {
|
|
return &Keys{
|
|
algo: algo,
|
|
manager: manager,
|
|
}
|
|
}
|
|
|
|
func (k *Keys) GenerateKey(w http.ResponseWriter, r *http.Request) {
|
|
ckReq := &CreateKeyRequest{
|
|
Algo: k.algo,
|
|
}
|
|
if err := common.ParseRequestAndValidateJSON(r, ckReq); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
key, seed, err := k.manager.Create(ckReq.Name, ckReq.Passphrase, ckReq.Algo)
|
|
if err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
res := &CreateKeyResponse{Key: key, Seed: seed}
|
|
common.WriteSuccess(w, res)
|
|
}
|
|
|
|
func (k *Keys) GetKey(w http.ResponseWriter, r *http.Request) {
|
|
query := mux.Vars(r)
|
|
name := query["name"]
|
|
key, err := k.manager.Get(name)
|
|
if err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
common.WriteSuccess(w, &key)
|
|
}
|
|
|
|
func (k *Keys) ListKeys(w http.ResponseWriter, r *http.Request) {
|
|
keys, err := k.manager.List()
|
|
if err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
common.WriteSuccess(w, keys)
|
|
}
|
|
|
|
var (
|
|
errNonMatchingPathAndJSONKeyNames = errors.New("path and json key names don't match")
|
|
)
|
|
|
|
func (k *Keys) UpdateKey(w http.ResponseWriter, r *http.Request) {
|
|
uReq := new(UpdateKeyRequest)
|
|
if err := common.ParseRequestAndValidateJSON(r, uReq); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
query := mux.Vars(r)
|
|
name := query["name"]
|
|
if name != uReq.Name {
|
|
common.WriteError(w, errNonMatchingPathAndJSONKeyNames)
|
|
return
|
|
}
|
|
|
|
if err := k.manager.Update(uReq.Name, uReq.OldPass, uReq.NewPass); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
key, err := k.manager.Get(uReq.Name)
|
|
if err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
common.WriteSuccess(w, &key)
|
|
}
|
|
|
|
func (k *Keys) DeleteKey(w http.ResponseWriter, r *http.Request) {
|
|
dReq := new(DeleteKeyRequest)
|
|
if err := common.ParseRequestAndValidateJSON(r, dReq); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
query := mux.Vars(r)
|
|
name := query["name"]
|
|
if name != dReq.Name {
|
|
common.WriteError(w, errNonMatchingPathAndJSONKeyNames)
|
|
return
|
|
}
|
|
|
|
if err := k.manager.Delete(dReq.Name, dReq.Passphrase); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
resp := &common.ErrorResponse{Success: true}
|
|
common.WriteSuccess(w, resp)
|
|
}
|
|
|
|
func doPostTx(w http.ResponseWriter, r *http.Request) {
|
|
tx := new(basecoin.Tx)
|
|
if err := common.ParseRequestAndValidateJSON(r, tx); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
commit, err := PostTx(*tx)
|
|
if err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
common.WriteSuccess(w, commit)
|
|
}
|
|
|
|
func doSign(w http.ResponseWriter, r *http.Request) {
|
|
sr := new(SignRequest)
|
|
if err := common.ParseRequestAndValidateJSON(r, sr); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
|
|
tx := sr.Tx
|
|
if err := SignTx(sr.Name, sr.Password, tx); err != nil {
|
|
common.WriteError(w, err)
|
|
return
|
|
}
|
|
common.WriteSuccess(w, tx)
|
|
}
|
|
|
|
// mux.Router registrars
|
|
|
|
// RegisterPostTx is a mux.Router handler that exposes POST
|
|
// method access to post a transaction to the blockchain.
|
|
func RegisterPostTx(r *mux.Router) error {
|
|
r.HandleFunc("/tx", doPostTx).Methods("POST")
|
|
return nil
|
|
}
|
|
|
|
// RegisterAllCRUD is a convenience method to register all
|
|
// CRUD for keys to allow access by methods and routes:
|
|
// POST: /keys
|
|
// GET: /keys
|
|
// GET: /keys/{name}
|
|
// POST, PUT: /keys/{name}
|
|
// DELETE: /keys/{name}
|
|
func (k *Keys) RegisterAllCRUD(r *mux.Router) error {
|
|
r.HandleFunc("/keys", k.GenerateKey).Methods("POST")
|
|
r.HandleFunc("/keys", k.ListKeys).Methods("GET")
|
|
r.HandleFunc("/keys/{name}", k.GetKey).Methods("GET")
|
|
r.HandleFunc("/keys/{name}", k.UpdateKey).Methods("POST", "PUT")
|
|
r.HandleFunc("/keys/{name}", k.DeleteKey).Methods("DELETE")
|
|
|
|
return nil
|
|
}
|
|
|
|
// RegisterSignTx is a mux.Router handler that
|
|
// exposes POST method access to sign a transaction.
|
|
func RegisterSignTx(r *mux.Router) error {
|
|
r.HandleFunc("/sign", doSign).Methods("POST")
|
|
return nil
|
|
}
|
|
|
|
// End of mux.Router registrars
|