//this func is just a check
func checkAddr(addr string, w io.Writer) error {
c := cclient.NewClient(DefaultNodeRPCAddr, REQUEST_TYPE)
if addr == "" {
_, err := c.ListAccounts()
IfExit(err)
return nil
} else {
addrBytes, err := hex.DecodeString(addr)
if err != nil {
IfExit(fmt.Errorf("Addr %s is improper hex: %v", addr, err))
}
r, err := c.GetAccount(addrBytes)
IfExit(err)
if r == nil {
IfExit(fmt.Errorf("Account %X does not exist", addrBytes))
}
r2 := r.Account
if r2 == nil {
IfExit(fmt.Errorf("Account %X does not exist", addrBytes))
}
}
//TODO get more infos (like check if they have perms!)
//something like: w.Write([]byte("Permission denied, invalid address\n"))
return nil
}
func get_account() {
addrHex, err := Prompt("Enter the address of the account in HEX (e.g. 9FCBA7F840A0BFEBBE755E853C9947270A912D04):\n> ", "")
if err != nil {
Exit(Fmt("Error: %v", err))
}
cli := cclient.NewClient("http://localhost:46657", "JSONRPC")
address, err := hex.DecodeString(addrHex)
if err != nil {
Exit(Fmt("Address was not hex: %v", addrHex))
}
res, err := cli.GetAccount(address)
if res == nil {
Exit(Fmt("Account does not exist: %X", address))
}
if err != nil {
Exit(Fmt("Error fetching account: %v", err))
}
acc := res.Account
fmt.Printf(`
Address: %X
PubKey: %v
Sequence: %v
Balance: %v
Permissions: %v
`,
acc.Address,
acc.PubKey,
acc.Sequence,
acc.Balance,
acc.Permissions)
}
// need to think of the name spacing carefullly
func ListAllTheNames() ([]string, error) {
//GET chain URL
url := os.Getenv("MINTX_NODE_ADDR")
c := cclient.NewClient(url, "HTTP")
res, err := c.ListNames()
if err != nil {
return nil, fmt.Errorf("error calling c.LN(): %v", err)
}
names := make([]string, len(res.Names))
for i, name := range res.Names {
names[i] = name.Name
}
return names, nil
}
//TODO cleanup -> func GetHashFromFileName()
func GetInfos(fileName string) (string, error) {
c := cclient.NewClient(DefaultNodeRPCAddr, REQUEST_TYPE)
if fileName == "" {
//to support an endpoint that lists available files
_, err := c.ListNames()
IfExit(err)
/*res := make([]string, len(names.Names))
i := 0
for n := range names.Names {
res[i] = n.Entry.Name
i += 1
}
result := string.Join(res, "\n")*/
return "", nil
} else {
n, err := c.GetName(fileName)
IfExit(err)
name := n.Entry.Data
return name, nil
}
}
// Create a new client for the node at the given addr
func NewNodeClient(addr string) *NodeClient {
return &NodeClient{
rpc: cclient.NewClient("http://"+addr, "JSONRPC"),
ws: cclient.NewWSClient("ws://" + addr + "/events"),
}
}
var (
rpcAddr = "127.0.0.1:36657" // Not 46657
requestAddr = "http://" + rpcAddr + "/"
websocketAddr = "ws://" + rpcAddr + "/websocket"
node *nm.Node
mempoolCount = 0
// make keys
user = makeUsers(5)
chainID string
clients = map[string]cclient.Client{
"JSONRPC": cclient.NewClient(requestAddr, "JSONRPC"),
"HTTP": cclient.NewClient(requestAddr, "HTTP"),
}
)
// deterministic account generation, synced with genesis file in config/tendermint_test/config.go
func makeUsers(n int) []*acm.PrivAccount {
accounts := []*acm.PrivAccount{}
for i := 0; i < n; i++ {
secret := ("mysecret" + strconv.Itoa(i))
user := acm.GenPrivAccountFromSecret(secret)
accounts = append(accounts, user)
}
return accounts
}
func send_tx() {
// Get PrivAccount
var privAccount *acm.PrivAccount
secret := getString("Enter your secret, or just hit <Enter> to enter a private key in HEX.\n> ")
if secret == "" {
privKeyBytes := getByteSliceFromHex("Enter your private key in HEX (e.g. E353CAD81134A301A542AEBE2D2E4EF1A64A145117EC72743AE9C9D171A4AA69F3A7DD670A9E9307AAED000D97D5B3C07D90276BFCEEDA5ED11DA089A4E87A81):\n> ")
privAccount = acm.GenPrivAccountFromPrivKeyBytes(privKeyBytes)
} else {
// Auto-detect private key hex
if len(secret) == 128 {
privKeyBytes, err := hex.DecodeString(secret)
if err == nil {
fmt.Println("Detected priv-key bytes...")
privAccount = acm.GenPrivAccountFromPrivKeyBytes(privKeyBytes)
} else {
fmt.Println("That's a long seed...")
privAccount = acm.GenPrivAccountFromSecret(secret)
}
} else {
privAccount = acm.GenPrivAccountFromSecret(secret)
}
}
pubKey := privAccount.PubKey
// Get account data
cli := cclient.NewClient("http://localhost:46657", "JSONRPC")
res, err := cli.GetAccount(privAccount.Address)
if err != nil {
Exit(Fmt("Error fetching account: %v", err))
}
if res == nil {
Exit(Fmt("No account was found with that secret/private-key"))
}
inputAcc := res.Account
fmt.Printf(`
Source account:
Address: %X
PubKey: %v
Sequence: %v
Balance: %v
Permissions: %v
`,
inputAcc.Address,
pubKey,
inputAcc.Sequence,
inputAcc.Balance,
inputAcc.Permissions)
output := getByteSliceFromHex("\nEnter the output address in HEX:\n> ")
amount := getInt64("Enter the amount to send:\n> ")
// Construct transaction
tx := types.NewSendTx()
tx.AddInputWithNonce(pubKey, amount, inputAcc.Sequence+1)
tx.AddOutput(output, amount)
tx.Inputs[0].Signature = privAccount.Sign(config.GetString("chain_id"), tx)
fmt.Println("Signed SendTx!: ", tx)
// Sign up for events
wsCli := cclient.NewWSClient("ws://localhost:46657/websocket")
wsCli.Start()
err = wsCli.Subscribe(types.EventStringAccInput(inputAcc.Address))
if err != nil {
Exit(Fmt("Error subscribing to account send event: %v", err))
}
// Broadcast transaction
_, err = cli.BroadcastTx(tx)
if err != nil {
Exit(Fmt("Error broadcasting transaction: %v", err))
}
fmt.Println("Waiting for confirmation...")
_ = <-wsCli.EventsCh
fmt.Println("Confirmed.")
}