func getRawTx(gate *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
txid := r.FormValue("txid")
if txid == "" {
wh.Error400(w, "txid is empty")
return
}
h, err := cipher.SHA256FromHex(txid)
if err != nil {
wh.Error400(w, err.Error())
return
}
tx, err := gate.V.GetTransaction(h)
if err != nil {
wh.Error400(w, err.Error())
return
}
d := tx.Txn.Serialize()
wh.SendOr404(w, hex.EncodeToString(d))
return
}
}
func getTransactionByID(gate *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
txid := r.FormValue("txid")
if txid == "" {
wh.Error400(w, "txid is empty")
return
}
h, err := cipher.SHA256FromHex(txid)
if err != nil {
wh.Error400(w, err.Error())
return
}
tx, err := gate.V.GetTransaction(h)
if err != nil {
wh.Error400(w, err.Error())
return
}
if tx == nil {
wh.Error404(w, "not found")
return
}
resTx := visor.TransactionResult{
Transaction: visor.NewReadableTransaction(tx),
Status: tx.Status,
}
wh.SendOr404(w, &resTx)
}
}
func getAddrUxOuts(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
addr := r.FormValue("address")
if addr == "" {
wh.Error400(w, "address is empty")
return
}
cipherAddr, err := cipher.DecodeBase58Address(addr)
if err != nil {
wh.Error400(w, err.Error())
return
}
uxs, err := gateway.GetAddrUxOuts(cipherAddr)
if err != nil {
wh.Error400(w, err.Error())
return
}
wh.SendOr404(w, uxs)
}
}
func getUxOutByID(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
uxid := r.FormValue("uxid")
if uxid == "" {
wh.Error400(w, "uxid is empty")
return
}
id, err := cipher.SHA256FromHex(uxid)
if err != nil {
wh.Error400(w, err.Error())
return
}
uxout, err := gateway.GetUxOutByID(id)
if err != nil {
wh.Error400(w, err.Error())
return
}
if uxout == nil {
wh.Error404(w, "not found")
return
}
wh.SendOr404(w, uxout)
}
}
func walletNewAddresses(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
wh.Error405(w, "")
return
}
wltID := r.FormValue("id")
if wltID == "" {
wh.Error400(w, "wallet id not set")
return
}
addrs, err := Wg.NewAddresses(wltID, 1)
if err != nil {
wh.Error400(w, err.Error())
return
}
if err := Wg.SaveWallet(wltID); err != nil {
wh.Error500(w, "")
return
}
var rlt = struct {
Address string `json:"address"`
}{
addrs[0].String(),
}
wh.SendOr404(w, rlt)
return
}
}
// Returns pending transactions
func getPendingTxs(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
V := gateway.V
ret := make([]*visor.ReadableUnconfirmedTxn, 0, len(V.Unconfirmed.Txns))
for _, unconfirmedTxn := range V.Unconfirmed.Txns {
readable := visor.NewReadableUnconfirmedTxn(&unconfirmedTxn)
ret = append(ret, &readable)
}
wh.SendOr404(w, &ret)
}
}
// get block by hash or seq
// method: GET
// url: /block?hash=[:hash] or /block?seq[:seq]
// params: hash or seq, should only specify one filter.
func getBlock(gate *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
hash := r.FormValue("hash")
seq := r.FormValue("seq")
var b *coin.Block
switch {
case hash == "" && seq == "":
wh.Error400(w, "should specify one filter, hash or seq")
return
case hash != "" && seq != "":
wh.Error400(w, "should only specify one filter, hash or seq")
return
case hash != "":
h, err := cipher.SHA256FromHex(hash)
if err != nil {
wh.Error400(w, err.Error())
return
}
b = gate.V.GetBlockByHash(h)
case seq != "":
uSeq, err := strconv.ParseUint(seq, 10, 64)
if err != nil {
wh.Error400(w, err.Error())
return
}
b = gate.V.GetBlockBySeq(uSeq)
}
if b == nil {
wh.SendOr404(w, nil)
return
}
wh.SendOr404(w, visor.NewReadableBlock(b))
}
}
//Implement
func injectTransaction(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
wh.Error405(w, "")
return
}
// get the rawtransaction
v := struct {
Rawtx string `json:"rawtx"`
}{}
if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
logger.Error("bad request: %v", err)
wh.Error400(w, err.Error())
return
}
b, err := hex.DecodeString(v.Rawtx)
if err != nil {
logger.Error("%v", err)
wh.Error400(w, err.Error())
return
}
txn := coin.TransactionDeserialize(b)
if err := visor.VerifyTransactionFee(gateway.D.Visor.Visor.Blockchain, &txn); err != nil {
wh.Error400(w, err.Error())
return
}
t, err := gateway.D.Visor.InjectTransaction(txn, gateway.D.Pool)
if err != nil {
wh.Error400(w, fmt.Sprintf("inject tx failed:%v", err))
return
}
wh.SendOr404(w, t.Hash().Hex())
}
}
func getBlocks(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
sstart := r.FormValue("start")
start, err := strconv.ParseUint(sstart, 10, 64)
if err != nil {
wh.Error400(w, fmt.Sprintf("Invalid start value \"%s\"", sstart))
return
}
send := r.FormValue("end")
end, err := strconv.ParseUint(send, 10, 64)
if err != nil {
wh.Error400(w, fmt.Sprintf("Invalid end value \"%s\"", send))
return
}
wh.SendOr404(w, gateway.GetBlocks(start, end))
}
}
// get last N blocks
func getLastBlocks(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
num := r.FormValue("num")
if num == "" {
wh.Error400(w, "Param: num is empty")
return
}
n, err := strconv.ParseUint(num, 10, 64)
if err != nil {
wh.Error400(w, err.Error())
return
}
wh.SendOr404(w, gateway.GetLastBlocks(n))
}
}
// getLastTxs get the last confirmed txs.
func getLastTxs(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
wh.Error405(w, "")
return
}
txs, err := gateway.V.GetLastTxs()
if err != nil {
wh.Error500(w, err.Error())
return
}
resTxs := make([]visor.TransactionResult, len(txs))
for i, tx := range txs {
resTxs[i] = visor.TransactionResult{
Transaction: visor.NewReadableTransaction(tx),
Status: tx.Status,
}
}
wh.SendOr404(w, &resTxs)
}
}