func WalletEntryFromReadable(w *ReadableWalletEntry) WalletEntry {
// SimpleWallet entries are shared as a form of identification, the secret key
// is not required
// TODO -- fix lib/base58 to not panic on invalid input -- should
// return error, so we can detect a broken wallet.
if w.Address == "" {
//log.Panic("ReadableWalletEntry has no Address")
}
var s cipher.SecKey
if w.Secret != "" {
s = cipher.MustSecKeyFromHex(w.Secret)
}
//regen from the private key
//redundant/
if w.Address == "" {
addr := cipher.AddressFromSecKey(s)
pub := cipher.PubKeyFromSecKey(s)
return WalletEntry{
Address: addr,
Public: pub,
Secret: s,
}
}
return WalletEntry{
Address: cipher.MustDecodeBase58Address(w.Address),
Public: cipher.MustPubKeyFromHex(w.Public),
Secret: s,
}
}
func Decrypt(in []byte, nonce []byte, pubkey string, seckey string) (data []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = errors.New("encrypt faild")
}
}()
p := cipher.MustPubKeyFromHex(pubkey)
s := cipher.MustSecKeyFromHex(seckey)
key := cipher.ECDH(p, s)
data, err = cipher.Chacha20Decrypt(in, key, nonce)
return
}
func main() {
initLogging(logging.DEBUG, true)
cfg := initConfig()
initProfiling(cfg.HttpProf)
// print pubkey so that client can use that to communicate with server
sk := cipher.MustSecKeyFromHex(cfg.Seckey)
logger.Info("pubkey:%v", cipher.PubKeyFromSecKey(sk).Hex())
s := server.New(cfg)
// Bind supported coins
s.BindCoins(
&bitcoin.Bitcoin{},
skycoin.New(cfg.NodeAddresses[skycoin.Type]),
mzcoin.New(cfg.NodeAddresses[mzcoin.Type]))
s.Run()
}
func Encrypt(r interface{}, pubkey string, seckey string) (data []byte, nonce []byte, err error) {
defer func() {
if r := recover(); r != nil {
err = errors.New("encrypt faild")
}
}()
d, err := json.Marshal(r)
if err != nil {
return
}
p := cipher.MustPubKeyFromHex(pubkey)
s := cipher.MustSecKeyFromHex(seckey)
nonce = cipher.RandByte(chacha20.NonceSize)
key := cipher.ECDH(p, s)
data, err = cipher.Chacha20Encrypt([]byte(d), key, nonce)
return
}
func addBlock(bc historydb.Blockchainer, td testData, tm uint64) (*coin.Block, *coin.Transaction, error) {
tx := coin.Transaction{}
// get unspent output
ux, err := getUx(bc, td.Vin.BlockSeq, td.Vin.TxID, td.Vin.Addr)
if err != nil {
return nil, nil, err
}
if ux == nil {
return nil, nil, errors.New("no unspent output")
}
tx.PushInput(ux.Hash())
for _, o := range td.Vouts {
addr, err := cipher.DecodeBase58Address(o.ToAddr)
if err != nil {
return nil, nil, err
}
tx.PushOutput(addr, o.Coins, o.Hours)
}
sigKey := cipher.MustSecKeyFromHex(td.Vin.SigKey)
tx.SignInputs([]cipher.SecKey{sigKey})
tx.UpdateHeader()
if err := bc.VerifyTransaction(tx); err != nil {
return nil, nil, err
}
preBlock := bc.GetBlock(td.PreBlockHash)
b := newBlock(*preBlock, tm, *bc.GetUnspent(), coin.Transactions{tx}, _feeCalc)
// uxs, err := bc.ExecuteBlock(&b)
_, err = bc.ExecuteBlock(&b)
if err != nil {
return nil, nil, err
}
return &b, &tx, nil
}
func createSkyWithdrawTx(egn engine.Exchange, amount uint64, toAddr string) (*SkyTxResult, error) {
uxs, err := egn.ChooseUtxos(skycoin.Type, amount, ChooseUtxoTm)
if err != nil {
return nil, err
}
utxos := uxs.([]skycoin.Utxo)
for _, u := range utxos {
logger.Debug("using skycoin utxos:%s", u.GetHash())
}
var success bool
defer func() {
if !success {
go func() { egn.PutUtxos(skycoin.Type, utxos) }()
}
}()
var totalAmounts uint64
var totalHours uint64
for _, u := range utxos {
totalAmounts += u.GetCoins()
totalHours += u.GetHours()
}
outAddrs := []skycoin.TxOut{}
chgAmt := totalAmounts - amount
chgHours := totalHours / 4
chgAddr := ""
if chgAmt > 0 {
// generate a change address
chgAddr = egn.GetNewAddress(skycoin.Type)
outAddrs = append(outAddrs,
skycoin.MakeUtxoOutput(toAddr, amount, chgHours/2),
skycoin.MakeUtxoOutput(chgAddr, chgAmt, chgHours/2))
} else {
outAddrs = append(outAddrs, skycoin.MakeUtxoOutput(toAddr, amount, chgHours/2))
}
keys := make([]cipher.SecKey, len(utxos))
for i, u := range utxos {
k, err := egn.GetAddrPrivKey(skycoin.Type, u.GetAddress())
if err != nil {
panic(err)
}
keys[i] = cipher.MustSecKeyFromHex(k)
}
logger.Debug("creating skycoin transaction...")
tx := skycoin.NewTransaction(utxos, keys, outAddrs)
if err := tx.Verify(); err != nil {
return nil, err
}
success = true
rlt := SkyTxResult{
Tx: tx,
UsingUtxos: utxos[:],
ChangeAddr: chgAddr,
}
return &rlt, nil
}