func main() {
var testnet bool
if len(os.Args) != 2 {
fmt.Println("Specify one P2KH bitcoin address to see it's P2SH-P2WPKH deposit address")
fmt.Println("WARNING: Make sure the input address comes from an uncompressed key!!!!!")
return
}
aa, er := btc.NewAddrFromString(os.Args[1])
if er != nil {
println(er.Error())
return
}
if btc.AddrVerPubkey(false) == aa.Version {
} else if btc.AddrVerPubkey(true) == aa.Version {
testnet = true
} else {
fmt.Println("This does nto seem to be P2KH type address")
return
}
h160 := btc.Rimp160AfterSha256(append([]byte{0, 20}, aa.Hash160[:]...))
aa = btc.NewAddrFromHash160(h160[:], btc.AddrVerScript(testnet))
fmt.Println(aa.String())
}
// It is assumed that you call this function only after rec.IsStealthIdx() was true
func CheckStealthRec(db *qdb.DB, k qdb.KeyType, rec *chain.OneWalkRecord,
addr *btc.BtcAddr, d []byte, inbrowse bool) (fl uint32, uo *chain.OneUnspentTx) {
sth_scr := rec.Script()
sa := addr.StealthAddr
if sa.CheckNonce(sth_scr[3:]) {
vo := rec.VOut() // get the spending output
var spend_v []byte
if inbrowse {
spend_v = db.GetNoMutex(qdb.KeyType(uint64(k) ^ uint64(vo) ^ uint64(vo+1)))
} else {
spend_v = db.Get(qdb.KeyType(uint64(k) ^ uint64(vo) ^ uint64(vo+1)))
}
if spend_v != nil {
rec = chain.NewWalkRecord(spend_v)
if rec.IsP2KH() {
var h160 [20]byte
c := btc.StealthDH(sth_scr[7:40], d)
spen_exp := btc.DeriveNextPublic(sa.SpendKeys[0][:], c)
btc.RimpHash(spen_exp, h160[:])
if bytes.Equal(rec.Script()[3:23], h160[:]) {
adr := btc.NewAddrFromHash160(h160[:], btc.AddrVerPubkey(common.CFG.Testnet))
uo = rec.ToUnspent(adr)
adr.StealthAddr = sa
adr.Extra = addr.Extra
uo.StealthC = c
}
} else {
fl = chain.WALK_NOMORE
}
} else {
fl = chain.WALK_NOMORE
}
}
return
}
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))
}
func json_balance(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
if r.Method != "POST" {
return
}
summary := len(r.Form["summary"]) > 0
inp, er := ioutil.ReadAll(r.Body)
if er != nil {
println(er.Error())
return
}
var addrs []string
er = json.Unmarshal(inp, &addrs)
if er != nil {
println(er.Error())
return
}
type OneOut struct {
TxId string
Vout uint32
Value uint64
Height uint32
Coinbase bool
Message string
Addr string
}
type OneOuts struct {
Value uint64
OutCnt int
SegWitCnt int
SegWitAddr string
Outs []OneOut
}
out := make(map[string]*OneOuts)
lck := new(usif.OneLock)
lck.In.Add(1)
lck.Out.Add(1)
usif.LocksChan <- lck
lck.In.Wait()
for _, a := range addrs {
aa, e := btc.NewAddrFromString(a)
if e != nil {
continue
}
unsp := wallet.GetAllUnspent(aa)
newrec := new(OneOuts)
if len(unsp) > 0 {
newrec.OutCnt = len(unsp)
for _, u := range unsp {
newrec.Value += u.Value
if !summary {
newrec.Outs = append(newrec.Outs, OneOut{
TxId: btc.NewUint256(u.TxPrevOut.Hash[:]).String(), Vout: u.Vout,
Value: u.Value, Height: u.MinedAt, Coinbase: u.Coinbase,
Message: html.EscapeString(string(u.Message)), Addr: a})
}
}
}
out[aa.String()] = newrec
/* Segwit P2WPKH: */
if aa.Version == btc.AddrVerPubkey(common.Testnet) {
// SegWit if applicable
h160 := btc.Rimp160AfterSha256(append([]byte{0, 20}, aa.Hash160[:]...))
aa = btc.NewAddrFromHash160(h160[:], btc.AddrVerScript(common.Testnet))
newrec.SegWitAddr = aa.String()
unsp = wallet.GetAllUnspent(aa)
if len(unsp) > 0 {
newrec.OutCnt += len(unsp)
newrec.SegWitCnt = len(unsp)
as := aa.String()
for _, u := range unsp {
newrec.Value += u.Value
if !summary {
newrec.Outs = append(newrec.Outs, OneOut{
TxId: btc.NewUint256(u.TxPrevOut.Hash[:]).String(), Vout: u.Vout,
Value: u.Value, Height: u.MinedAt, Coinbase: u.Coinbase,
Message: html.EscapeString(string(u.Message)), Addr: as})
}
}
}
}
}
lck.Out.Done()
bx, er := json.Marshal(out)
if er == nil {
w.Header()["Content-Type"] = []string{"application/json"}
w.Write(bx)
} else {
println(er.Error())
}
}
func dl_balance(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
if r.Method != "POST" {
return
}
var addrs []string
var labels []string
if len(r.Form["addrcnt"]) != 1 {
println("no addrcnt")
return
}
addrcnt, _ := strconv.ParseUint(r.Form["addrcnt"][0], 10, 32)
for i := 0; i < int(addrcnt); i++ {
is := fmt.Sprint(i)
if len(r.Form["addr"+is]) == 1 {
addrs = append(addrs, r.Form["addr"+is][0])
if len(r.Form["label"+is]) == 1 {
labels = append(labels, r.Form["label"+is][0])
} else {
labels = append(labels, "")
}
}
}
type one_unsp_rec struct {
btc.TxPrevOut
Value uint64
Addr string
MinedAt uint32
Coinbase bool
}
var thisbal chain.AllUnspentTx
lck := new(usif.OneLock)
lck.In.Add(1)
lck.Out.Add(1)
usif.LocksChan <- lck
lck.In.Wait()
for idx, a := range addrs {
aa, e := btc.NewAddrFromString(a)
aa.Extra.Label = labels[idx]
if e == nil {
newrecs := wallet.GetAllUnspent(aa)
if len(newrecs) > 0 {
thisbal = append(thisbal, newrecs...)
}
/* Segwit P2WPKH: */
if aa.Version == btc.AddrVerPubkey(common.Testnet) {
// SegWit if applicable
h160 := btc.Rimp160AfterSha256(append([]byte{0, 20}, aa.Hash160[:]...))
aa = btc.NewAddrFromHash160(h160[:], btc.AddrVerScript(common.Testnet))
newrecs = wallet.GetAllUnspent(aa)
if len(newrecs) > 0 {
thisbal = append(thisbal, newrecs...)
}
}
}
}
lck.Out.Done()
buf := new(bytes.Buffer)
zi := zip.NewWriter(buf)
was_tx := make(map[[32]byte]bool)
sort.Sort(thisbal)
for i := range thisbal {
if was_tx[thisbal[i].TxPrevOut.Hash] {
continue
}
was_tx[thisbal[i].TxPrevOut.Hash] = true
txid := btc.NewUint256(thisbal[i].TxPrevOut.Hash[:])
fz, _ := zi.Create("balance/" + txid.String() + ".tx")
if dat, er := common.BlockChain.GetRawTx(thisbal[i].MinedAt, txid); er == nil {
fz.Write(dat)
} else {
println(er.Error())
}
}
fz, _ := zi.Create("balance/unspent.txt")
for i := range thisbal {
fmt.Fprintln(fz, thisbal[i].UnspentTextLine())
}
zi.Close()
w.Header()["Content-Type"] = []string{"application/zip"}
w.Write(buf.Bytes())
}
// 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 update_balance() {
var tofetch_stealh []*btc.BtcAddr
var tofetch_secrets [][]byte
tofetch_regular := make(map[uint64]*btc.BtcAddr)
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()
}
// Get the secret seed and generate "keycnt" key pairs (both private and public)
func make_wallet() {
var lab string
load_others()
var seed_key []byte
var hdwal *btc.HDWallet
defer func() {
sys.ClearBuffer(seed_key)
if hdwal != nil {
sys.ClearBuffer(hdwal.Key)
sys.ClearBuffer(hdwal.ChCode)
}
}()
pass := getpass()
if pass == nil {
cleanExit(0)
}
if waltype >= 1 && waltype <= 3 {
seed_key = make([]byte, 32)
btc.ShaHash(pass, seed_key)
sys.ClearBuffer(pass)
lab = fmt.Sprintf("Typ%c", 'A'+waltype-1)
if waltype == 1 {
println("WARNING: Wallet Type 1 is obsolete")
} else if waltype == 2 {
if type2sec != "" {
d, e := hex.DecodeString(type2sec)
if e != nil {
println("t2sec error:", e.Error())
cleanExit(1)
}
type2_secret = d
} else {
type2_secret = make([]byte, 20)
btc.RimpHash(seed_key, type2_secret)
}
}
} else if waltype == 4 {
lab = "TypHD"
hdwal = btc.MasterKey(pass, testnet)
sys.ClearBuffer(pass)
} else {
sys.ClearBuffer(pass)
println("ERROR: Unsupported wallet type", waltype)
cleanExit(1)
}
if *verbose {
fmt.Println("Generating", keycnt, "keys, version", ver_pubkey(), "...")
}
first_determ_idx = len(keys)
for i := uint(0); i < keycnt; {
prv_key := make([]byte, 32)
if waltype == 3 {
btc.ShaHash(seed_key, prv_key)
seed_key = append(seed_key, byte(i))
} else if waltype == 2 {
seed_key = btc.DeriveNextPrivate(seed_key, type2_secret)
copy(prv_key, seed_key)
} else if waltype == 1 {
btc.ShaHash(seed_key, prv_key)
copy(seed_key, prv_key)
} else /*if waltype==4*/ {
// HD wallet
_hd := hdwal.Child(uint32(0x80000000 | i))
copy(prv_key, _hd.Key[1:])
sys.ClearBuffer(_hd.Key)
sys.ClearBuffer(_hd.ChCode)
}
if *scankey != "" {
new_stealth_address(prv_key)
return
}
rec := btc.NewPrivateAddr(prv_key, ver_secret(), !uncompressed)
if *pubkey != "" && *pubkey == rec.BtcAddr.String() {
fmt.Println("Public address:", rec.BtcAddr.String())
fmt.Println("Public hexdump:", hex.EncodeToString(rec.BtcAddr.Pubkey))
return
}
rec.BtcAddr.Extra.Label = fmt.Sprint(lab, " ", i+1)
keys = append(keys, rec)
i++
}
if *verbose {
fmt.Println("Private keys re-generated")
}
// Calculate SegWit addresses
segwit = make([]*btc.BtcAddr, len(keys))
for i, pk := range keys {
if len(pk.Pubkey) != 33 {
continue
}
h160 := btc.Rimp160AfterSha256(append([]byte{0, 20}, pk.Hash160[:]...))
segwit[i] = btc.NewAddrFromHash160(h160[:], btc.AddrVerScript(testnet))
}
}