func payAccount(authtoken, paytoken []byte, serverKnown string, cacert []byte) (server string, lastcounter uint64, err error) { var ServerT string var ok bool method := "AccountServer.LoadAccount" url := DefaultAccountServer if server != "" { url = server } url = "https://" + url + ":" + RPCPort + "/account" client, err := DefaultClientFactory(url, cacert) if err != nil { return "", 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) paytokenEnc := base64.StdEncoding.EncodeToString(paytoken) data, err := client.JSONRPCRequest(method, struct { AuthToken string PayToken string }{ AuthToken: authtokenEnc, PayToken: paytokenEnc, }) if err != nil { LastCounter, err := walletauth.IsReplay(err) return "", LastCounter, err } if _, ok = data["Server"]; !ok { return "", 0, ErrProto } if ServerT, ok = data["Server"].(string); !ok { return "", 0, ErrProto } return ServerT, 0, nil }
// delAccount delets an account func delAccount(authtoken []byte, server string, cacert []byte) (bool, uint64, error) { var ok, ResultT bool method := "AccountServer.DeleteAccount" url := "https://" + server + ":" + RPCPort + "/account" client, err := DefaultClientFactory(url, cacert) if err != nil { return false, 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) data, err := client.JSONRPCRequest(method, struct{ AuthToken string }{AuthToken: authtokenEnc}) if err != nil { LastCounter, err := walletauth.IsReplay(err) return false, LastCounter, err } if _, ok = data["Result"]; !ok { return false, 0, ErrProto } if ResultT, ok = data["Result"].(bool); !ok { return false, 0, ErrProto } return ResultT, 0, nil }
func (wc WalletClient) getToken(usage string, authtoken []byte) (token, params, pubKeyUsed []byte, LastCounter uint64, err error) { method := "WalletServer.GetToken" client, err := wc.ClientFactory(ServiceURL, wc.ServiceGuardCA) if err != nil { return nil, nil, nil, 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) data, err := client.JSONRPCRequest(method, struct{ AuthToken, Usage string }{AuthToken: authtokenEnc, Usage: usage}) if err != nil { LastCounter, err := walletauth.IsReplay(err) return nil, nil, nil, LastCounter, err } if _, ok := data["Token"]; !ok { return nil, nil, nil, 0, ErrParams } if _, ok := data["Token"].(string); !ok { return nil, nil, nil, 0, ErrParams } if _, ok := data["Params"]; !ok { return nil, nil, nil, 0, ErrParams } if _, ok := data["Params"].(string); !ok { return nil, nil, nil, 0, ErrParams } token, err = base64.StdEncoding.DecodeString(data["Token"].(string)) if err != nil { return nil, nil, nil, 0, ErrParams } params, err = base64.StdEncoding.DecodeString(data["Params"].(string)) if err != nil { return nil, nil, nil, 0, ErrParams } pubKeyUsed, err = base64.StdEncoding.DecodeString(data["PubKeyUsed"].(string)) if err != nil { return nil, nil, nil, 0, ErrParams } return token, params, pubKeyUsed, 0, nil }
// getBalance is the real GetBalance call to return the client's balance from the wallet service func (wc WalletClient) getBalance(authtoken []byte) (SubscriptionTokens, PrepayTokens, LastSubscribeLoad, LastCounter uint64, err error) { var ok bool var SubscriptionTokensT, PrepayTokensT, LastSubscribeLoadT float64 method := "WalletServer.GetBalance" client, err := wc.ClientFactory(ServiceURL, wc.ServiceGuardCA) if err != nil { return 0, 0, 0, 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) data, err := client.JSONRPCRequest(method, struct{ AuthToken string }{AuthToken: authtokenEnc}) if err != nil { LastCounter, err := walletauth.IsReplay(err) return 0, 0, 0, LastCounter, err } if _, ok := data["SubscriptionTokens"]; !ok { return 0, 0, 0, 0, ErrParams } if SubscriptionTokensT, ok = data["SubscriptionTokens"].(float64); !ok { return 0, 0, 0, 0, ErrParams } SubscriptionTokens = uint64(SubscriptionTokensT) if _, ok := data["PrepayTokens"]; !ok { return 0, 0, 0, 0, ErrParams } if PrepayTokensT, ok = data["PrepayTokens"].(float64); !ok { return 0, 0, 0, 0, ErrParams } PrepayTokens = uint64(PrepayTokensT) if _, ok := data["LastSubscribeLoad"]; !ok { return 0, 0, 0, 0, ErrParams } if LastSubscribeLoadT, ok = data["LastSubscribeLoad"].(float64); !ok { return 0, 0, 0, 0, ErrParams } LastSubscribeLoad = uint64(LastSubscribeLoadT) return SubscriptionTokens, PrepayTokens, LastSubscribeLoad, 0, nil }
func fetchmessage(messageID, authtoken []byte, server string, cacert []byte) (message []byte, lastcounter uint64, err error) { postVal := url.Values{} postVal.Set("messageid", hex.EncodeToString(messageID)) postVal.Set("authtoken", base64.StdEncoding.EncodeToString(authtoken)) body, err := HTTPSPost(postVal, "https://"+server+":"+RPCPort+"/message", cacert) if err != nil { return nil, 0, err } if len(body) < 7 { return nil, 0, ErrProto } if string(body[0:6]) == "ERROR:" { errStr := body[7:] err := fmt.Errorf("%s", errStr) LastCounter, err := walletauth.IsReplay(err) return nil, LastCounter, err } message, err = ReadMail(body) if err != nil { return nil, 0, err } return message, 0, nil }
// accountStat real call func accountStat(authtoken []byte, server string, cacert []byte) (int64, uint64, error) { var ok bool var LoadTimeT float64 method := "AccountServer.AccountStat" url := "https://" + server + ":" + RPCPort + "/account" client, err := DefaultClientFactory(url, cacert) if err != nil { return 0, 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) data, err := client.JSONRPCRequest(method, struct{ AuthToken string }{AuthToken: authtokenEnc}) if err != nil { LastCounter, err := walletauth.IsReplay(err) return 0, LastCounter, err } if _, ok = data["LoadTime"]; !ok { return 0, 0, ErrProto } if LoadTimeT, ok = data["LoadTime"].(float64); !ok { return 0, 0, ErrProto } return int64(LoadTimeT), 0, nil }
// listMessages real call func listMessages(authtoken []byte, lastMessageTime int64, server string, cacert []byte) ([]MessageMeta, uint64, error) { var ok bool var messages []MessageMeta method := "AccountServer.ListMessages" url := "https://" + server + ":" + RPCPort + "/account" client, err := DefaultClientFactory(url, cacert) if err != nil { return nil, 0, err } authtokenEnc := base64.StdEncoding.EncodeToString(authtoken) data, err := client.JSONRPCRequest(method, struct { AuthToken string LastReceiveTime int64 }{ AuthToken: authtokenEnc, LastReceiveTime: lastMessageTime, }) if err != nil { LastCounter, err := walletauth.IsReplay(err) return nil, LastCounter, err } if _, ok = data["Messages"]; !ok { return nil, 0, ErrProto } messagesI, ok := data["Messages"].([]interface{}) if !ok { return nil, 0, ErrProto } if len(messagesI) > 0 { for _, e := range messagesI { x := e.(map[string]interface{}) ReceiveTime, ok := x["ReceiveTime"].(float64) if !ok { err = ErrProto break } ReceiveTimeNano, ok := x["ReceiveTimeNano"].(float64) if !ok { err = ErrProto break } ReadTime, ok := x["ReadTime"].(float64) if !ok { err = ErrProto break } uks, ok := x["UserKey"].(string) if !ok { err = ErrProto break } uk, err := hex.DecodeString(uks) if err != nil { break } ukh := new([ed25519.PublicKeySize]byte) copy(ukh[:], uk) mis, ok := x["MessageID"].(string) if !ok { err = ErrProto break } mi, err := hex.DecodeString(mis) if err != nil { break } messages = append(messages, MessageMeta{ MessageID: mi, ReceiveTime: int64(ReceiveTime), ReceiveTimeNano: int64(ReceiveTimeNano), ReadTime: int64(ReadTime), UserKey: *ukh, }) } if err != nil { return nil, 0, err } } return messages, 0, nil }