func handleEntryCreditBalance(ctx *web.Context, eckey string) {
type ecbal struct {
Response string
Success bool
}
var b ecbal
adr, err := hex.DecodeString(eckey)
if err == nil && len(adr) != common.HASH_LENGTH {
b = ecbal{Response: "Invalid Address", Success: false}
}
if err == nil {
if bal, err := factomapi.ECBalance(eckey); err != nil {
wsLog.Error(err)
return
} else {
str := fmt.Sprintf("%d", bal)
b = ecbal{Response: str, Success: true}
}
} else {
b = ecbal{Response: err.Error(), Success: false}
}
if p, err := json.Marshal(b); err != nil {
wsLog.Error(err)
return
} else {
ctx.Write(p)
}
}
func handleFactoidBalance(ctx *web.Context, eckey string) {
type fbal struct {
Response string
Success bool
}
var b fbal
adr, err := hex.DecodeString(eckey)
if err == nil && len(adr) != common.HASH_LENGTH {
b = fbal{Response: "Invalid Address", Success: false}
}
if err == nil {
v := int64(common.FactoidState.GetBalance(fct.NewAddress(adr)))
str := fmt.Sprintf("%d", v)
b = fbal{Response: str, Success: true}
} else {
b = fbal{Response: err.Error(), Success: false}
}
if p, err := json.Marshal(b); err != nil {
wsLog.Error(err)
return
} else {
ctx.Write(p)
}
}
func returnV1Msg(ctx *web.Context, msg string, success bool) {
/* V1 requires call specific case changes that can't be handled with
interfaces for example. Block Height needs to return height as the json item name
in golang, lower case names are private so won't be returned.
Deal with the responses in the call specific v1 handlers until they are depricated.
*/
bMsg := []byte(msg)
ctx.Write(bMsg)
}
func handleGetFee(ctx *web.Context) {
type x struct{ Fee int64 }
b := new(x)
b.Fee = int64(common.FactoidState.GetFactoshisPerEC())
if p, err := json.Marshal(b); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
return
} else {
ctx.Write(p)
}
}
func HandleV2Error(ctx *web.Context, j *primitives.JSON2Request, err *primitives.JSONError) {
resp := primitives.NewJSON2Response()
if j != nil {
resp.ID = j.ID
} else {
resp.ID = nil
}
resp.Error = err
ctx.WriteHeader(httpBad)
ctx.Write([]byte(resp.String()))
}
func HandleGetAddresses(ctx *web.Context) {
b := new(Response)
b.Response = string(GetAddresses())
b.Success = true
j, err := json.Marshal(b)
if err != nil {
reportResults(ctx, err.Error(), false)
return
}
ctx.ContentType("json")
ctx.Write(j)
}
// True is success! False is failure. The Response is what the CLI
// should report.
func reportResults(ctx *web.Context, response string, success bool) {
b := Response{
Response: response,
Success: success,
}
if p, err := json.Marshal(b); err != nil {
ctx.WriteHeader(httpBad)
return
} else {
ctx.ContentType("json")
ctx.Write(p)
}
}
func returnMsg(ctx *web.Context, msg string, success bool) {
type rtn struct {
Response string
Success bool
}
r := rtn{Response: msg, Success: success}
if p, err := json.Marshal(r); err != nil {
wsLog.Error(err)
return
} else {
ctx.Write(p)
}
}
func handleProperties(ctx *web.Context) {
r := new(common.Properties)
r.Factomd_Version = common.FACTOMD_VERSION
r.Protocol_Version = btcd.ProtocolVersion
if p, err := json.Marshal(r); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}
func HandleGetTransactionsj(ctx *web.Context) {
b := new(Response)
txt, err := GetTransactionsj(ctx)
if err != nil {
reportResults(ctx, err.Error(), false)
return
}
b.Response = txt
b.Success = true
j, err := json.Marshal(b)
if err != nil {
reportResults(ctx, err.Error(), false)
return
}
ctx.Write(j)
}
func HandleCommitEntry(ctx *web.Context, name string) {
data, err := ioutil.ReadAll(ctx.Request.Body)
if err != nil {
fmt.Println("Could not read from http request:", err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
err = Wallet.CommitEntry(name, data)
if err != nil {
fmt.Println(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
func handleRevealEntry(ctx *web.Context) {
type revealentry struct {
Entry string
}
e := new(revealentry)
if p, err := ioutil.ReadAll(ctx.Request.Body); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
if err := json.Unmarshal(p, e); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
entry := common.NewEntry()
if p, err := hex.DecodeString(e.Entry); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
_, err := entry.UnmarshalBinaryData(p)
if err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
if err := factomapi.RevealEntry(entry); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
// ctx.WriteHeader(httpOK)
}
func handleCommitChain(ctx *web.Context) {
type commitchain struct {
CommitChainMsg string
}
c := new(commitchain)
if p, err := ioutil.ReadAll(ctx.Request.Body); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
if err := json.Unmarshal(p, c); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
commit := common.NewCommitChain()
if p, err := hex.DecodeString(c.CommitChainMsg); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
_, err := commit.UnmarshalBinaryData(p)
if err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
if err := factomapi.CommitChain(commit); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
}
func handleEntry(ctx *web.Context, hash string) {
type entry struct {
ChainID string
Content string
ExtIDs []string
}
e := new(entry)
if entry, err := factomapi.EntryByHash(hash); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
e.ChainID = entry.ChainID.String()
e.Content = hex.EncodeToString(entry.Content)
for _, v := range entry.ExtIDs {
e.ExtIDs = append(e.ExtIDs, hex.EncodeToString(v))
}
}
if p, err := json.Marshal(e); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}
func returnMsg(ctx *web.Context, msg interface{}, success bool) {
type rtn struct {
Response interface{}
Success bool
}
/*str, ok:=msg.(string)
if ok == false {
var err error
str, err = primitives.EncodeJSONString(msg)
if err != nil {
wsLog.Error(err)
return
}
}*/
r := msg
if p, err := json.Marshal(r); err != nil {
wsLog.Error(err)
return
} else {
ctx.Write(p)
}
}
func HandleV2(ctx *web.Context) {
ServersMutex.Lock()
state := ctx.Server.Env["state"].(interfaces.IState)
ServersMutex.Unlock()
if err := checkAuthHeader(state, ctx.Request); err != nil {
remoteIP := ""
remoteIP += strings.Split(ctx.Request.RemoteAddr, ":")[0]
fmt.Printf("Unauthorized V2 API client connection attempt from %s\n", remoteIP)
ctx.ResponseWriter.Header().Add("WWW-Authenticate", `Basic realm="factomd RPC"`)
http.Error(ctx.ResponseWriter, "401 Unauthorized.", http.StatusUnauthorized)
return
}
body, err := ioutil.ReadAll(ctx.Request.Body)
if err != nil {
HandleV2Error(ctx, nil, NewInvalidRequestError())
return
}
j, err := primitives.ParseJSON2Request(string(body))
if err != nil {
HandleV2Error(ctx, nil, NewInvalidRequestError())
return
}
jsonResp, jsonError := HandleV2Request(state, j)
if jsonError != nil {
HandleV2Error(ctx, j, jsonError)
return
}
ctx.Write([]byte(jsonResp.String()))
}
func handleGetRaw(ctx *web.Context, hashkey string) {
type rawData struct {
Data string
}
//TODO: var block common.BinaryMarshallable
d := new(rawData)
h, err := common.HexToHash(hashkey)
if err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
}
// try to find the block data in db and return the first one found
if block, _ := dbase.FetchFBlockByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchDBlockByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchABlockByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchDBlockByMR(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchEBlockByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchEBlockByMR(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchECBlockByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
} else if block, _ := dbase.FetchEntryByHash(h); block != nil {
bytes, _ := block.MarshalBinary()
d.Data = hex.EncodeToString(bytes[:])
}
if p, err := json.Marshal(d); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
// ctx.WriteHeader(httpOK)
}
func handleDirectoryBlock(ctx *web.Context, keymr string) {
type eblockaddr struct {
ChainID string
KeyMR string
}
type dblock struct {
Header struct {
PrevBlockKeyMR string
SequenceNumber uint32
Timestamp uint32
}
EntryBlockList []eblockaddr
}
d := new(dblock)
if block, err := factomapi.DBlockByKeyMR(keymr); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
d.Header.PrevBlockKeyMR = block.Header.PrevKeyMR.String()
d.Header.SequenceNumber = block.Header.DBHeight
d.Header.Timestamp = block.Header.Timestamp * 60
for _, v := range block.DBEntries {
l := new(eblockaddr)
l.ChainID = v.ChainID.String()
l.KeyMR = v.KeyMR.String()
d.EntryBlockList = append(d.EntryBlockList, *l)
}
}
if p, err := json.Marshal(d); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
// ctx.WriteHeader(httpOK)
}
func handleDirectoryBlockHeight(ctx *web.Context) {
type dbheight struct {
Height int
}
h := new(dbheight)
if block, err := factomapi.DBlockHead(); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
h.Height = int(block.Header.DBHeight)
}
if p, err := json.Marshal(h); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}
func handleChainHead(ctx *web.Context, chainid string) {
type chead struct {
ChainHead string
}
c := new(chead)
if mr, err := factomapi.ChainHead(chainid); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
c.ChainHead = mr.String()
}
if p, err := json.Marshal(c); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}
func handleDirectoryBlockHead(ctx *web.Context) {
type dbhead struct {
KeyMR string
}
h := new(dbhead)
if block, err := factomapi.DBlockHead(); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
h.KeyMR = block.KeyMR.String()
}
if p, err := json.Marshal(h); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}
func handleEntryBlock(ctx *web.Context, keymr string) {
type entryaddr struct {
EntryHash string
Timestamp uint32
}
type eblock struct {
Header struct {
BlockSequenceNumber uint32
ChainID string
PrevKeyMR string
Timestamp uint32
}
EntryList []entryaddr
}
e := new(eblock)
if block, err := factomapi.EBlockByKeyMR(keymr); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
e.Header.BlockSequenceNumber = block.Header.EBSequence
e.Header.ChainID = block.Header.ChainID.String()
e.Header.PrevKeyMR = block.Header.PrevKeyMR.String()
if dblock, err := dbase.FetchDBlockByHeight(block.Header.EBHeight); err == nil {
e.Header.Timestamp = dblock.Header.Timestamp * 60
}
// create a map of possible minute markers that may be found in the
// EBlock Body
mins := make(map[string]uint8)
for i := byte(1); i <= 10; i++ {
h := make([]byte, 32)
h[len(h)-1] = i
mins[hex.EncodeToString(h)] = i
}
estack := make([]entryaddr, 0)
for _, v := range block.Body.EBEntries {
if n, exist := mins[v.String()]; exist {
// the entry is a minute marker. add time to all of the
// previous entries for the minute
t := e.Header.Timestamp + 60*uint32(n)
for _, w := range estack {
w.Timestamp = t
e.EntryList = append(e.EntryList, w)
}
estack = make([]entryaddr, 0)
} else {
l := new(entryaddr)
l.EntryHash = v.String()
estack = append(estack, *l)
}
}
}
if p, err := json.Marshal(e); err != nil {
wsLog.Error(err)
ctx.WriteHeader(httpBad)
ctx.Write([]byte(err.Error()))
return
} else {
ctx.Write(p)
}
}