func main() {
var testnet bool
if len(os.Args) < 3 {
fmt.Println("Specify secret, public_key and optionaly number of addresses you want.")
fmt.Println("Use a negative value for number of addresses, to work with Testnet addresses.")
return
}
public_key, er := hex.DecodeString(os.Args[2])
if er != nil {
println("Error parsing public_key:", er.Error())
os.Exit(1)
}
if len(public_key) == 33 && (public_key[0] == 2 || public_key[0] == 3) {
fmt.Println("Compressed")
} else if len(public_key) == 65 && (public_key[0] == 4) {
fmt.Println("Uncompressed")
} else {
println("Incorrect public key")
}
secret, er := hex.DecodeString(os.Args[1])
if er != nil {
println("Error parsing secret:", er.Error())
os.Exit(1)
}
n := int64(25)
if len(os.Args) > 3 {
n, er = strconv.ParseInt(os.Args[3], 10, 32)
if er != nil {
println("Error parsing number of keys value:", er.Error())
os.Exit(1)
}
if n == 0 {
return
}
if n < 0 {
n = -n
testnet = true
}
}
fmt.Println("# Type-2")
fmt.Println("#", hex.EncodeToString(public_key))
fmt.Println("#", hex.EncodeToString(secret))
for i := 1; i <= int(n); i++ {
fmt.Println(btc.NewAddrFromPubkey(public_key, btc.AddrVerPubkey(testnet)).String(), "TypB", i)
if i >= int(n) {
break
}
public_key = btc.DeriveNextPublic(public_key, secret)
}
}
func main() {
if len(os.Args) < 3 {
fmt.Println("Specify secret and public_key to get the next Type-2 deterministic address")
fmt.Println("Add -t as the third argument to work with Testnet addresses.")
return
}
public_key, er := hex.DecodeString(os.Args[2])
if er != nil {
println("Error parsing public_key:", er.Error())
os.Exit(1)
}
if len(public_key) == 33 && (public_key[0] == 2 || public_key[0] == 3) {
fmt.Println("Compressed")
} else if len(public_key) == 65 && (public_key[0] == 4) {
fmt.Println("Uncompressed")
} else {
println("Incorrect public key")
}
secret, er := hex.DecodeString(os.Args[1])
if er != nil {
println("Error parsing secret:", er.Error())
os.Exit(1)
}
testnet := len(os.Args) > 3 && os.Args[3] == "-t"
// Old address
public_key = btc.DeriveNextPublic(public_key, secret)
// New address
fmt.Println(btc.NewAddrFromPubkey(public_key, btc.AddrVerPubkey(testnet)).String())
// New key
fmt.Println(hex.EncodeToString(public_key))
}
func list_unspent(addr string) {
fmt.Println("Checking unspent coins for addr", addr)
defer func() { // in case if ad.OutScript() would panic
if r := recover(); r != nil {
err := r.(error)
fmt.Println("main panic recovered:", err.Error())
}
}()
var ad *btc.BtcAddr
var e error
ad, e = btc.NewAddrFromString(addr)
if e != nil {
println(e.Error())
return
}
sa := ad.StealthAddr
var walk chain.FunctionWalkUnspent
var unsp chain.AllUnspentTx
if sa == nil {
exp_scr := ad.OutScript()
walk = func(tx *chain.QdbRec) {
for idx, rec := range tx.Outs {
if rec != nil && bytes.Equal(rec.PKScr, exp_scr) {
unsp = append(unsp, tx.ToUnspent(uint32(idx), ad))
}
}
}
} else {
var c, spen_exp []byte
var rec, out *chain.QdbTxOut
var h160 [20]byte
wallet.FetchStealthKeys()
d := wallet.FindStealthSecret(sa)
if d == nil {
fmt.Println("No matching secret found in your wallet/stealth folder")
return
}
walk = func(tx *chain.QdbRec) {
for i := 0; i < len(tx.Outs)-1; i++ {
if rec = tx.Outs[i]; rec == nil {
continue
}
if out = tx.Outs[i+1]; out == nil {
continue
}
if !rec.IsStealthIdx() || !out.IsP2KH() || !ad.StealthAddr.CheckNonce(rec.PKScr[3:40]) {
continue
}
c = btc.StealthDH(rec.PKScr[7:40], d)
spen_exp = btc.DeriveNextPublic(sa.SpendKeys[0][:], c)
btc.RimpHash(spen_exp, h160[:])
if bytes.Equal(out.PKScr[3:23], h160[:]) {
uo := new(chain.OneUnspentTx)
uo.TxPrevOut.Hash = tx.TxID
uo.TxPrevOut.Vout = uint32(i + 1)
uo.Value = out.Value
uo.MinedAt = tx.InBlock
uo.BtcAddr = btc.NewAddrFromHash160(h160[:], btc.AddrVerPubkey(common.CFG.Testnet))
uo.FixDestString()
uo.BtcAddr.StealthAddr = sa
uo.BtcAddr.Extra = ad.Extra
uo.StealthC = c
unsp = append(unsp, uo)
}
}
}
}
common.BlockChain.Unspent.BrowseUTXO(false, walk)
sort.Sort(unsp)
var sum uint64
for i := range unsp {
if len(unsp) < 200 {
fmt.Println(unsp[i].String())
}
sum += unsp[i].Value
}
fmt.Printf("Total %.8f unspent BTC in %d outputs at address %s\n",
float64(sum)/1e8, len(unsp), ad.String())
}
func do_scan_stealth(p string, ignore_prefix bool) {
ad, _ := btc.NewAddrFromString(p)
if ad == nil {
fmt.Println("Specify base58 encoded bitcoin address")
return
}
sa := ad.StealthAddr
if sa == nil {
fmt.Println("Specify base58 encoded stealth address")
return
}
if sa.Version != btc.StealthAddressVersion(common.Testnet) {
fmt.Println("Incorrect version of the stealth address")
return
}
if len(sa.SpendKeys) != 1 {
fmt.Println("Currently only single spend keys are supported. This address has", len(sa.SpendKeys))
return
}
//fmt.Println("scankey", hex.EncodeToString(sa.ScanKey[:]))
if ignore_prefix {
sa.Prefix = []byte{0}
fmt.Println("Ignoring Prefix inside the address")
} else if len(sa.Prefix) == 0 {
fmt.Println("Prefix not present in the address")
} else {
fmt.Println("Prefix", sa.Prefix[0], hex.EncodeToString(sa.Prefix[1:]))
}
wallet.FetchStealthKeys()
d := wallet.FindStealthSecret(sa)
if d == nil {
fmt.Println("No matching secret found in your wallet/stealth folder")
return
}
var unsp chain.AllUnspentTx
var c, spen_exp []byte
var rec, out *chain.QdbTxOut
var h160 [20]byte
common.BlockChain.Unspent.BrowseUTXO(true, func(tx *chain.QdbRec) {
for i := 0; i < len(tx.Outs)-1; i++ {
if rec = tx.Outs[i]; rec == nil {
continue
}
if out = tx.Outs[i+1]; out == nil {
continue
}
if !rec.IsStealthIdx() || !out.IsP2KH() || !ad.StealthAddr.CheckNonce(rec.PKScr[3:40]) {
continue
}
c = btc.StealthDH(rec.PKScr[7:40], d)
spen_exp = btc.DeriveNextPublic(sa.SpendKeys[0][:], c)
btc.RimpHash(spen_exp, h160[:])
if bytes.Equal(out.PKScr[3:23], h160[:]) {
uo := new(chain.OneUnspentTx)
uo.TxPrevOut.Hash = tx.TxID
uo.TxPrevOut.Vout = uint32(i + 1)
uo.Value = out.Value
uo.MinedAt = tx.InBlock
uo.BtcAddr = btc.NewAddrFromHash160(h160[:], btc.AddrVerPubkey(common.CFG.Testnet))
uo.FixDestString()
uo.BtcAddr.StealthAddr = sa
uo.BtcAddr.Extra = ad.Extra
uo.StealthC = c
unsp = append(unsp, uo)
}
}
})
sort.Sort(unsp)
os.RemoveAll("balance")
os.MkdirAll("balance/", 0770)
utxt, _ := os.Create("balance/unspent.txt")
fmt.Print(wallet.DumpBalance(unsp, utxt, true, false))
}
// This function is only used when loading UTXO database
func newUTXO(tx *chain.QdbRec) (update_wallet bool) {
var c, spen_exp []byte
var rec *chain.QdbTxOut
var h160 [20]byte
check_next_address:
for idx, out := range tx.Outs {
if out == nil {
continue
}
// check for stealth
if len(StealthAdCache) > 0 && idx > 0 {
if rec = tx.Outs[idx-1]; rec == nil {
goto not_stealth
}
if !rec.IsStealthIdx() || !out.IsP2KH() {
goto not_stealth
}
for _, ad := range StealthAdCache {
if sa := ad.addr.StealthAddr; sa.CheckNonce(rec.PKScr[3:40]) {
c = btc.StealthDH(rec.PKScr[7:40], ad.d[:])
spen_exp = btc.DeriveNextPublic(sa.SpendKeys[0][:], c)
btc.RimpHash(spen_exp, h160[:])
if bytes.Equal(out.PKScr[3:23], h160[:]) {
uo := new(chain.OneUnspentTx)
uo.TxPrevOut.Hash = tx.TxID
uo.TxPrevOut.Vout = uint32(idx)
uo.Value = out.Value
uo.MinedAt = tx.InBlock
uo.BtcAddr = btc.NewAddrFromHash160(h160[:], btc.AddrVerPubkey(common.CFG.Testnet))
uo.FixDestString()
uo.BtcAddr.StealthAddr = sa
uo.BtcAddr.Extra = ad.addr.Extra
uo.StealthC = c
carec := CachedAddrs[ad.h160]
carec.Value += uo.Value
CacheUnspent[carec.CacheIndex].AllUnspentTx = append(CacheUnspent[carec.CacheIndex].AllUnspentTx, uo)
CacheUnspentIdx[uo.TxPrevOut.UIdx()] = &OneCachedUnspentIdx{Index: carec.CacheIndex, Record: uo}
if carec.InWallet {
update_wallet = true
}
continue check_next_address // it it was setalth, cannot be enythign else
}
}
}
}
not_stealth:
// Extract hash160 from pkscript
adr := btc.NewAddrFromPkScript(out.PKScr, common.Testnet)
if adr != nil {
if carec, ok := CachedAddrs[adr.Hash160]; ok {
carec.Value += out.Value
utxo := new(chain.OneUnspentTx)
utxo.TxPrevOut.Hash = tx.TxID
utxo.TxPrevOut.Vout = uint32(idx)
utxo.Value = out.Value
utxo.MinedAt = tx.InBlock
utxo.BtcAddr = CacheUnspent[carec.CacheIndex].BtcAddr
CacheUnspent[carec.CacheIndex].AllUnspentTx = append(CacheUnspent[carec.CacheIndex].AllUnspentTx, utxo)
CacheUnspentIdx[utxo.TxPrevOut.UIdx()] = &OneCachedUnspentIdx{Index: carec.CacheIndex, Record: utxo}
if carec.InWallet {
update_wallet = true
}
}
}
}
return
}
func UpdateBalance() {
var tofetch_stealh []*btc.BtcAddr
var tofetch_secrets [][]byte
tofetch_regular := make(map[uint64]*btc.BtcAddr)
BalanceMutex.Lock()
MyBalance = nil
for _, v := range CachedAddrs {
v.InWallet = false
}
FetchStealthKeys()
for i := range MyWallet.Addrs {
if rec, pres := CachedAddrs[MyWallet.Addrs[i].Hash160]; pres {
rec.InWallet = true
cu := CacheUnspent[rec.CacheIndex]
cu.BtcAddr = MyWallet.Addrs[i]
for j := range cu.AllUnspentTx {
// update BtcAddr in each of AllUnspentTx to reflect the latest label
cu.AllUnspentTx[j].BtcAddr = MyWallet.Addrs[i]
}
MyBalance = append(MyBalance, CacheUnspent[rec.CacheIndex].AllUnspentTx...)
} else {
add_it := true
// Add a new address to the balance cache
if MyWallet.Addrs[i].StealthAddr == nil {
tofetch_regular[MyWallet.Addrs[i].AIdx()] = MyWallet.Addrs[i]
} else {
sa := MyWallet.Addrs[i].StealthAddr
if ssecret := FindStealthSecret(sa); ssecret != nil {
tofetch_stealh = append(tofetch_stealh, MyWallet.Addrs[i])
tofetch_secrets = append(tofetch_secrets, ssecret)
var rec stealthCacheRec
rec.addr = MyWallet.Addrs[i]
copy(rec.d[:], ssecret)
copy(rec.h160[:], MyWallet.Addrs[i].Hash160[:])
StealthAdCache = append(StealthAdCache, rec)
} else {
if MyWallet.Addrs[i].Extra.Wallet != AddrBookFileName {
fmt.Println("No matching secret for", sa.String())
}
add_it = false
}
}
if add_it {
CachedAddrs[MyWallet.Addrs[i].Hash160] = &OneCachedAddrBalance{InWallet: true, CacheIndex: uint(len(CacheUnspent))}
CacheUnspent = append(CacheUnspent, &OneCachedUnspent{BtcAddr: MyWallet.Addrs[i]})
}
}
}
if len(tofetch_regular) > 0 || len(tofetch_stealh) > 0 {
fmt.Println("Fetching a new blance for", len(tofetch_regular), "regular and", len(tofetch_stealh), "stealth addresses")
// There are new addresses which we have not monitored yet
var new_addrs chain.AllUnspentTx
var c, spen_exp []byte
var out *chain.QdbTxOut
var h160 [20]byte
common.BlockChain.Unspent.BrowseUTXO(true, func(tx *chain.QdbRec) {
for idx, rec := range tx.Outs {
if rec == nil {
continue
}
if rec.IsP2KH() {
if ad, ok := tofetch_regular[binary.LittleEndian.Uint64(rec.PKScr[3:3+8])]; ok {
new_addrs = append(new_addrs, tx.ToUnspent(uint32(idx), ad))
}
} else if rec.IsP2SH() {
if ad, ok := tofetch_regular[binary.LittleEndian.Uint64(rec.PKScr[2:2+8])]; ok {
new_addrs = append(new_addrs, tx.ToUnspent(uint32(idx), ad))
}
} else if idx < len(tx.Outs)-1 {
// check for stealth
if out = tx.Outs[idx+1]; out == nil {
continue
}
if !rec.IsStealthIdx() || !out.IsP2KH() {
continue
}
stealth_check:
for _, ad := range tofetch_stealh {
if sa := ad.StealthAddr; sa.CheckNonce(rec.PKScr[3:40]) {
for _, d := range tofetch_secrets {
c = btc.StealthDH(rec.PKScr[7:40], d)
spen_exp = btc.DeriveNextPublic(sa.SpendKeys[0][:], c)
btc.RimpHash(spen_exp, h160[:])
if bytes.Equal(out.PKScr[3:23], h160[:]) {
uo := new(chain.OneUnspentTx)
uo.TxPrevOut.Hash = tx.TxID
uo.TxPrevOut.Vout = uint32(idx + 1)
uo.Value = out.Value
uo.MinedAt = tx.InBlock
uo.BtcAddr = btc.NewAddrFromHash160(h160[:], btc.AddrVerPubkey(common.CFG.Testnet))
uo.FixDestString()
uo.BtcAddr.StealthAddr = sa
uo.BtcAddr.Extra = ad.Extra
uo.StealthC = c
new_addrs = append(new_addrs, uo)
break stealth_check
}
}
}
}
}
}
})
for i := range new_addrs {
poi := new_addrs[i].TxPrevOut.UIdx()
if _, ok := CacheUnspentIdx[poi]; ok {
fmt.Println(new_addrs[i].TxPrevOut.String(), "- already on the list")
continue
}
var rec *OneCachedAddrBalance
if new_addrs[i].BtcAddr.StealthAddr != nil {
var h160 [20]byte
copy(h160[:], new_addrs[i].BtcAddr.StealthAddr.Hash160())
rec = CachedAddrs[h160]
} else {
rec = CachedAddrs[new_addrs[i].BtcAddr.Hash160]
}
if rec == nil {
println("Hash160 not in CachedAddrs for", new_addrs[i].BtcAddr.String())
continue
}
rec.Value += new_addrs[i].Value
CacheUnspent[rec.CacheIndex].AllUnspentTx = append(CacheUnspent[rec.CacheIndex].AllUnspentTx, new_addrs[i])
CacheUnspentIdx[new_addrs[i].TxPrevOut.UIdx()] = &OneCachedUnspentIdx{Index: rec.CacheIndex, Record: new_addrs[i]}
}
MyBalance = append(MyBalance, new_addrs...)
}
sort_and_sum()
BalanceMutex.Unlock()
}