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 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 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 CreateWebContext() *web.Context {
context := new(web.Context)
context.Server = new(web.Server)
context.Server.Env = map[string]interface{}{}
context.Server.Env["state"] = CreateAndPopulateTestState()
context.ResponseWriter = new(TestResponseWriter)
return context
}
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 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)
}
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 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 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 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 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 handleV1Error(ctx *web.Context, err *primitives.JSONError) {
/*
if err.Data != nil {
data, ok := err.Data.(string)
if ok == true {
ctx.WriteHeader(httpBad)
returnMsg(ctx, "", false)
return
}
}
ctx.WriteHeader(httpBad)
returnMsg(ctx,"", false)
return
*/
ctx.WriteHeader(httpBad)
return
}
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 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 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 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 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 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 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
}
}
// 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 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 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)
}
}
// &key=<key>&name=<name or address>&amount=<amount>
// If no amount is specified, a zero is returned.
func getParams_(ctx *web.Context, params string, ec bool) (
trans fct.ITransaction,
key string,
name string,
address fct.IAddress,
amount int64,
ok bool) {
key = ctx.Params["key"]
name = ctx.Params["name"]
StrAmount := ctx.Params["amount"]
if len(StrAmount) == 0 {
StrAmount = "0"
}
if len(key) == 0 || len(name) == 0 {
str := fmt.Sprintln("Missing Parameters: key='", key, "' name='", name, "' amount='", StrAmount, "'")
reportResults(ctx, str, false)
ok = false
return
}
msg, valid := ValidateKey(key)
if !valid {
reportResults(ctx, msg, false)
ok = false
return
}
amount, err := strconv.ParseInt(StrAmount, 10, 64)
if err != nil {
str := fmt.Sprintln("Error parsing amount.\n", err)
reportResults(ctx, str, false)
ok = false
return
}
// Get the transaction
trans, err = getTransaction(ctx, key)
if err != nil {
reportResults(ctx, "Failure to locate the transaction", false)
ok = false
return
}
// Get the input/output/ec address. Which could be a name. First look and see if it is
// a name. If it isn't, then look and see if it is an address. Someone could
// do a weird Address as a name and fool the code, but that seems unlikely.
// Could check for that some how, but there are many ways around such checks.
if len(name) <= fct.ADDRESS_LENGTH {
we := Wallet.GetRaw([]byte(fct.W_NAME), []byte(name))
if we != nil {
address, err = we.(wallet.IWalletEntry).GetAddress()
if we.(wallet.IWalletEntry).GetType() == "ec" {
if !ec {
reportResults(ctx, "Was Expecting a Factoid Address", false)
ok = false
return
}
} else {
if ec {
reportResults(ctx, "Was Expecting an Entry Credit Address", false)
ok = false
return
}
}
if err != nil || address == nil {
reportResults(ctx, "Should not get an error geting a address from a Wallet Entry", false)
ok = false
return
}
ok = true
return
}
}
if (!ec && !fct.ValidateFUserStr(name)) || (ec && !fct.ValidateECUserStr(name)) {
reportResults(ctx, fmt.Sprintf("The address specified isn't defined or is invalid: %s", name), false)
ctx.WriteHeader(httpBad)
ok = false
return
}
baddr := fct.ConvertUserStrToAddress(name)
address = fct.NewAddress(baddr)
ok = true
return
}
func ClearContextResponseWriter(context *web.Context) {
context.ResponseWriter = new(TestResponseWriter)
}
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 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)
}