func makeKey(keyType string, account *definitions.Account) error {
log.WithFields(log.Fields{
"path": keys.DaemonAddr,
"type": keyType,
}).Debug("Sending Call to eris-keys server")
var err error
log.WithField("endpoint", "gen").Debug()
account.Address, err = keys.Call("gen", map[string]string{"auth": "", "type": keyType, "name": account.Name}) // note, for now we use not password to lock/unlock keys
if _, ok := err.(keys.ErrConnectionRefused); ok {
return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err)
}
if err != nil {
return err
}
log.WithField("endpoint", "pub").Debug()
account.PubKey, err = keys.Call("pub", map[string]string{"addr": account.Address, "name": account.Name})
if _, ok := err.(keys.ErrConnectionRefused); ok {
return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err)
}
if err != nil {
return err
}
// log.WithField("endpoint", "to-mint").Debug()
// mint, err := keys.Call("to-mint", map[string]string{"addr": account.Address, "name": account.Name})
log.WithField("endpoint", "mint").Debug()
mint, err := keys.Call("mint", map[string]string{"addr": account.Address, "name": account.Name})
if _, ok := err.(keys.ErrConnectionRefused); ok {
return fmt.Errorf("Could not connect to eris-keys server. Start it with `eris services start keys`. Error: %v", err)
}
if err != nil {
return err
}
account.MintKey = &definitions.MintPrivValidator{}
err = json.Unmarshal([]byte(mint), account.MintKey)
if err != nil {
log.Error(string(mint))
log.Error(account.MintKey)
return err
}
account.MintKey.Address = account.Address
return nil
}
func txFinalize(do *definitions.Do, tx interface{}, wait bool) (string, error) {
var result string
erisNodeClient := client.NewErisNodeClient(do.Chain)
erisKeyClient := keys.NewErisKeyClient(do.Signer)
res, err := core.SignAndBroadcast(do.ChainID, erisNodeClient, erisKeyClient, tx.(txs.Tx), true, true, wait)
if err != nil {
return util.MintChainErrorHandler(do, err)
}
if err := util.ReadTxSignAndBroadcast(res, err); err != nil {
log.Error("ERROR =>")
return "", err
}
result = fmt.Sprintf("%X", res.Hash)
return result, nil
}
func RegisterNameJob(name *definitions.RegisterName, do *definitions.Do) (string, error) {
// Process Variables
name.DataFile, _ = util.PreProcess(name.DataFile, do)
// If a data file is given it should be in csv format and
// it will be read first. Once the file is parsed and sent
// to the chain then a single nameRegTx will be sent if that
// has been populated.
if name.DataFile != "" {
// open the file and use a reader
fileReader, err := os.Open(name.DataFile)
if err != nil {
log.Error("ERROR =>")
return "", err
}
defer fileReader.Close()
r := csv.NewReader(fileReader)
// loop through the records
for {
// Read the record
record, err := r.Read()
// Catch the errors
if err == io.EOF {
break
}
if err != nil {
log.Error("ERROR =>")
return "", err
}
// Sink the Amount into the third slot in the record if
// it doesn't exist
if len(record) <= 2 {
record = append(record, name.Amount)
}
// Send an individual Tx for the record
// [TODO]: move these to async using goroutines?
r, err := registerNameTx(&definitions.RegisterName{
Source: name.Source,
Name: record[0],
Data: record[1],
Amount: record[2],
Fee: name.Fee,
Nonce: name.Nonce,
Wait: name.Wait,
}, do)
if err != nil {
log.Error("ERROR =>")
return "", err
}
n := fmt.Sprintf("%s:%s", record[0], record[1])
// TODO: fix this... simple and naive result just now.
if err = util.WriteJobResultCSV(n, r); err != nil {
log.Error("ERROR =>")
return "", err
}
}
}
// If the data field is populated then there is a single
// nameRegTx to send. So do that *now*.
if name.Data != "" {
return registerNameTx(name, do)
} else {
return "data_file_parsed", nil
}
}
func deployContract(deploy *definitions.Deploy, do *definitions.Do, r response.ResponseItem, p string) (string, error) {
log.WithField("=>", string(r.ABI)).Debug("ABI Specification (From Compilers)")
contractCode := r.Bytecode
// Save ABI
if _, err := os.Stat(do.ABIPath); os.IsNotExist(err) {
if err := os.Mkdir(do.ABIPath, 0775); err != nil {
return "", err
}
}
// saving contract/library abi
var abiLocation string
if r.Objectname != "" {
abiLocation = filepath.Join(do.ABIPath, r.Objectname)
log.WithField("=>", abiLocation).Debug("Saving ABI")
if err := ioutil.WriteFile(abiLocation, []byte(r.ABI), 0664); err != nil {
return "", err
}
} else {
log.Debug("Objectname from compilers is blank. Not saving abi.")
}
// saving binary
if deploy.SaveBinary {
contractDir := filepath.Dir(deploy.Contract)
contractName := filepath.Join(contractDir, fmt.Sprintf("%s.bin", strings.TrimSuffix(deploy.Contract, filepath.Ext(deploy.Contract))))
log.WithField("=>", contractName).Info("Saving Binary")
if err := ioutil.WriteFile(contractName, []byte(contractCode), 0664); err != nil {
return "", err
}
} else {
log.Debug("Not saving binary.")
}
// additional data may be sent along with the contract
// these are naively added to the end of the contract code using standard
// mint packing
if deploy.Data != nil {
_, callDataArray, err := util.PreProcessInputData(r.Objectname, deploy.Data, do, true)
if err != nil {
return "", err
}
packedBytes, err := util.ReadAbiFormulateCall(r.Objectname, "", callDataArray, do)
if err != nil {
return "", err
}
callData := hex.EncodeToString(packedBytes)
contractCode = contractCode + callData
}
tx, err := deployRaw(do, deploy, r.Objectname, contractCode)
if err != nil {
return "", err
}
// Sign, broadcast, display
result, err := deployFinalize(do, tx, deploy.Wait)
if err != nil {
return "", fmt.Errorf("Error finalizing contract deploy %s: %v", p, err)
}
// saving contract/library abi at abi/address
if result != "" {
abiLocation := filepath.Join(do.ABIPath, result)
log.WithField("=>", abiLocation).Debug("Saving ABI")
if err := ioutil.WriteFile(abiLocation, []byte(r.ABI), 0664); err != nil {
return "", err
}
} else {
// we shouldn't reach this point because we should have an error before this.
log.Error("The contract did not deploy. Unable to save abi to abi/contractAddress.")
}
return result, err
}
func SaveAccountResults(do *definitions.Do) error {
addrFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "addresses.csv"))
if err != nil {
return fmt.Errorf("Error creating addresses file. This usually means that there was a problem with the chain making process.")
}
defer addrFile.Close()
log.WithField("name", do.Name).Debug("Creating file")
actFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "accounts.csv"))
if err != nil {
return fmt.Errorf("Error creating accounts file.")
}
log.WithField("path", filepath.Join(ChainsPath, do.Name, "accounts.csv")).Debug("File successfully created")
defer actFile.Close()
log.WithField("name", do.Name).Debug("Creating file")
actJSONFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "accounts.json"))
if err != nil {
return fmt.Errorf("Error creating accounts file.")
}
log.WithField("path", filepath.Join(ChainsPath, do.Name, "accounts.json")).Debug("File successfully created")
defer actJSONFile.Close()
valFile, err := os.Create(filepath.Join(ChainsPath, do.Name, "validators.csv"))
if err != nil {
return fmt.Errorf("Error creating validators file.")
}
defer valFile.Close()
accountJsons := make(map[string]*accountInfo)
for _, account := range do.Accounts {
accountJsons[account.Name] = &accountInfo{
Address: account.Address,
PubKey: account.PubKey,
PrivKey: account.MintKey.PrivKey[1].(string),
}
_, err := addrFile.WriteString(fmt.Sprintf("%s,%s\n", account.Address, account.Name))
if err != nil {
log.Error("Error writing addresses file.")
return err
}
_, err = actFile.WriteString(fmt.Sprintf("%s,%d,%s,%d,%d\n", account.PubKey, account.Tokens, account.Name, account.MintPermissions.MintBase.MintPerms, account.MintPermissions.MintBase.MintSetBit))
if err != nil {
log.Error("Error writing accounts file.")
return err
}
if account.Validator {
_, err = valFile.WriteString(fmt.Sprintf("%s,%d,%s,%d,%d\n", account.PubKey, account.ToBond, account.Name, account.MintPermissions.MintBase.MintPerms, account.MintPermissions.MintBase.MintSetBit))
if err != nil {
log.Error("Error writing validators file.")
return err
}
}
}
addrFile.Sync()
actFile.Sync()
valFile.Sync()
j, err := json.MarshalIndent(accountJsons, "", " ")
if err != nil {
return err
}
_, err = actJSONFile.Write(j)
if err != nil {
return err
}
log.WithField("path", actJSONFile.Name()).Debug("Saving File.")
log.WithField("path", addrFile.Name()).Debug("Saving File.")
log.WithField("path", actFile.Name()).Debug("Saving File.")
log.WithField("path", valFile.Name()).Debug("Saving File.")
return nil
}