func generateFromPrivate(in PrivateKeyDat, Private string) PrivateKeyDat {
var answer PrivateKeyDat
answer.Error = in.Error
answer.Priv2WIF = []string{}
answer.WIF2Priv = in.WIF2Priv
answer.WIFChecksum = in.WIFChecksum
answer.Minikey = in.Minikey
curve := bitelliptic.S256()
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(Private)) == false {
if answer.Error == "" {
answer.Error = "Private key is not on curve"
}
answer.Priv2WIF = []string{Private, "", "", "", "", "", ""}
return answer
}
priv := append([]byte{0x80}, mymath.Str2Hex(Private)...)
answer.Priv2WIF = append(answer.Priv2WIF, Private)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(priv))
sha := mymath.SingleSHA(priv)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha))
sha = mymath.SingleSHA(sha)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha))
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(sha[0:4]))
priv = append(priv, sha[0:4]...)
answer.Priv2WIF = append(answer.Priv2WIF, mymath.Hex2Str(priv))
answer.Priv2WIF = append(answer.Priv2WIF, string(mymath.Hex2Base58(priv)))
return answer
}
func generateFromChecksum(in PrivateKeyDat, WIF string) PrivateKeyDat {
var answer PrivateKeyDat
answer.Error = in.Error
answer.Priv2WIF = in.Priv2WIF
answer.WIF2Priv = in.WIF2Priv
answer.WIFChecksum = []string{}
answer.Minikey = in.Minikey
hex := mymath.Base582Hex(WIF)
if mymath.Hex2Base58(hex) != mymath.Base58(WIF) {
if answer.Error == "" {
answer.Error = "Invalid Base58 encoding"
}
answer.WIFChecksum = []string{WIF, "", "", "", "", "", ""}
return answer
}
answer.WIFChecksum = append(answer.WIFChecksum, WIF)
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(hex))
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(hex[0:len(hex)-4]))
sha := mymath.SingleSHA(hex[0 : len(hex)-4])
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(sha))
sha = mymath.SingleSHA(sha)
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(sha))
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(sha[0:4]))
answer.WIFChecksum = append(answer.WIFChecksum, mymath.Hex2Str(hex[len(hex)-4:]))
return answer
}
func brainwalletTest(w http.ResponseWriter, r *http.Request) {
if r.FormValue("passphrase") != "" {
var data BrainwalletDat
data.Passphrase = r.FormValue("passphrase")
data.PrivateKey = mymath.Hex2Str(mymath.SingleSHA(mymath.ASCII2Hex(data.Passphrase)))
address, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(data.PrivateKey))
data.Address = string(address.Base)
BrainwalletTestTemplate.Execute(w, data)
return
}
BrainwalletTestTemplate.Execute(w, DefaultWallet)
}
func generateFromWIF(in PrivateKeyDat, WIF string) PrivateKeyDat {
var answer PrivateKeyDat
answer.Error = in.Error
answer.Priv2WIF = in.Priv2WIF
answer.WIF2Priv = []string{}
answer.WIFChecksum = in.WIFChecksum
answer.Minikey = in.Minikey
hex := mymath.Base582Hex(WIF)
if mymath.Hex2Base58(hex) != mymath.Base58(WIF) {
if answer.Error == "" {
answer.Error = "Invalid Base58 encoding"
}
answer.WIF2Priv = []string{WIF, "", "", ""}
return answer
}
answer.WIF2Priv = append(answer.WIF2Priv, WIF)
answer.WIF2Priv = append(answer.WIF2Priv, mymath.Hex2Str(hex))
answer.WIF2Priv = append(answer.WIF2Priv, mymath.Hex2Str(hex[0:len(hex)-4]))
answer.WIF2Priv = append(answer.WIF2Priv, mymath.Hex2Str(hex[1:len(hex)-4]))
return answer
}
func privateKeyTest(w http.ResponseWriter, r *http.Request) {
if r.FormValue("Random") != "" {
curve := bitelliptic.S256()
priv, _, _, _ := curve.GenerateKey(rand.Reader)
copyPriv := generateFromPrivate(DefaultPrivKeyDat, mymath.Hex2Str(priv))
copyPriv = generateFromWIF(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
copyPriv = generateFromChecksum(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else if r.FormValue("wif") != "" {
copyPriv := generateFromWIF(DefaultPrivKeyDat, r.FormValue("wif"))
copyPriv = generateFromPrivate(copyPriv, copyPriv.WIF2Priv[len(copyPriv.WIF2Priv)-1])
copyPriv = generateFromChecksum(copyPriv, r.FormValue("wif"))
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else if r.FormValue("wif2") != "" {
copyPriv := generateFromWIF(DefaultPrivKeyDat, r.FormValue("wif2"))
copyPriv = generateFromPrivate(copyPriv, copyPriv.WIF2Priv[len(copyPriv.WIF2Priv)-1])
copyPriv = generateFromChecksum(copyPriv, r.FormValue("wif2"))
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else if r.FormValue("wif3") != "" {
copyPriv := generateFromWIF(DefaultPrivKeyDat, r.FormValue("wif3"))
copyPriv = generateFromPrivate(copyPriv, copyPriv.WIF2Priv[len(copyPriv.WIF2Priv)-1])
copyPriv = generateFromChecksum(copyPriv, r.FormValue("wif3"))
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else if r.FormValue("private") != "" {
copyPriv := generateFromPrivate(DefaultPrivKeyDat, r.FormValue("private"))
copyPriv = generateFromWIF(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
copyPriv = generateFromChecksum(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else if r.FormValue("private2") != "" {
copyPriv := generateFromPrivate(DefaultPrivKeyDat, r.FormValue("private2"))
copyPriv = generateFromWIF(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
copyPriv = generateFromChecksum(copyPriv, copyPriv.Priv2WIF[len(copyPriv.Priv2WIF)-1])
PrivateKeyTestTemplate.Execute(w, copyPriv)
} else {
PrivateKeyTestTemplate.Execute(w, DefaultPrivKeyDat)
}
}
func vanityMultTest(w http.ResponseWriter, r *http.Request) {
curve := bitelliptic.S256()
if r.FormValue("Random") != "" {
vd := new(VanityMultData)
priv, gx, gy, _ := curve.GenerateKey(rand.Reader)
vd.Private1 = mymath.Hex2Str(priv)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
curve2 := curve.Copy()
curve2.Gx = gx
curve2.Gy = gy
priv, _, _, _ = curve2.GenerateKey(rand.Reader)
vd.Private2 = mymath.Hex2Str(priv)
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = mymath.Hex2Str(mymath.Big2Hex(mymath.MultiplyPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateMult))
vd.PrivateMultPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateMultAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateMultPublic)).Base)
VanityMultTestTemplate.Execute(w, vd)
return
} else if r.FormValue("Private") != "" {
vd := new(VanityMultData)
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(r.FormValue("Private1"))) != true {
vd.Error = "Private key 1 is invalid"
} else {
priv1, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private1")), curve)
vd.Private1 = mymath.Hex2Str(mymath.Big2Hex(priv1.D))
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
curve2 := curve.Copy()
curve2.Gx = priv1.PublicKey.X
curve2.Gy = priv1.PublicKey.Y
if bitecdsa.CheckIsOnCurve(curve2, mymath.Str2Big(r.FormValue("Private2"))) != true {
vd.Error = "Private key 2 is invalid"
} else {
priv2, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private2")), curve2)
vd.Private2 = mymath.Hex2Str(mymath.Big2Hex(priv2.D))
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = mymath.Hex2Str(mymath.Big2Hex(mymath.MultiplyPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateMult))
vd.PrivateMultPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateMultAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateMultPublic)).Base)
}
}
VanityMultTestTemplate.Execute(w, vd)
return
} else if r.FormValue("Public") != "" {
vd := new(VanityMultData)
vd.Public1 = r.FormValue("Public1")
if len(vd.Public1) != 130 {
vd.Error = "Public key is invalid"
} else if vd.Public1[0] != '0' || vd.Public1[1] != '4' {
vd.Error = "Public key is invalid"
} else {
gx, gy := mymath.PublicKeyToPointCoordinates(vd.Public1)
curve2 := curve.Copy()
curve2.Gx = gx
curve2.Gy = gy
vd.Private1 = ""
if bitecdsa.CheckIsOnCurve(curve2, mymath.Str2Big(r.FormValue("Private2"))) != true {
vd.Error = "Private key is invalid"
} else {
priv2, _ := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("Private2")), curve2)
vd.Private2 = mymath.Hex2Str(mymath.Big2Hex(priv2.D))
two, _ := mymath.NewAddressFromPrivateKeyWithCurve(mymath.Str2Hex(vd.Private2), curve2)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
vd.Public2Address = string(two.Base)
vd.PrivateMult = "??"
vd.PrivateMultPublic = "??"
vd.PrivateMultAddress = "??"
}
}
VanityMultTestTemplate.Execute(w, vd)
return
} else {
VanityMultTestTemplate.Execute(w, DefaultVanityMultData)
}
}
func vanitySumTest(w http.ResponseWriter, r *http.Request) {
if r.FormValue("Random") != "" {
vd := new(VanitySumData)
curve := bitelliptic.S256()
priv, _, _, _ := curve.GenerateKey(rand.Reader)
vd.Private1 = mymath.Hex2Str(priv)
priv, _, _, _ = curve.GenerateKey(rand.Reader)
vd.Private2 = mymath.Hex2Str(priv)
vd.PrivateSum = mymath.Hex2Str(mymath.Big2Hex(mymath.AddPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateSum))
vd.PrivateSumPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateSumAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateSumPublic)).Base)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
two, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private2))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
VanitySumTestTemplate.Execute(w, vd)
} else if r.FormValue("Private") != "" {
vd := new(VanitySumData)
vd.Private1 = r.FormValue("Private1")
vd.Private2 = r.FormValue("Private2")
curve := bitelliptic.S256()
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false || bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false && bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
vd.Error = "Both private keys appear to be invalid"
} else if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private1)) == false {
vd.Error = fmt.Sprintf("Private key one (%s) appears to be invalid", vd.Private1)
} else if bitecdsa.CheckIsOnCurve(curve, mymath.Str2Big(vd.Private2)) == false {
vd.Error = fmt.Sprintf("Private key two (%s) appears to be invalid", vd.Private2)
} else {
vd.Error = "One of the private keys is invalid, but we can't figure out which (this is an unexpected server behaviour)."
}
} else {
vd.PrivateSum = mymath.Hex2Str(mymath.Big2Hex(mymath.AddPrivateKeys(vd.Private1, vd.Private2)))
zero, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.PrivateSum))
vd.PrivateSumPublic = mymath.Hex2Str(zero.PublicKey)
vd.PrivateSumAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PrivateSumPublic)).Base)
one, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private1))
two, _ := mymath.NewAddressFromPrivateKey(mymath.Str2Hex(vd.Private2))
vd.Public1 = mymath.Hex2Str(one.PublicKey)
vd.Public2 = mymath.Hex2Str(two.PublicKey)
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
}
VanitySumTestTemplate.Execute(w, vd)
} else if r.FormValue("Public") != "" {
vd := new(VanitySumData)
vd.Public1 = r.FormValue("Public1")
vd.Public2 = r.FormValue("Public2")
if len(vd.Public1) != 130 || len(vd.Public2) != 130 {
vd.Error = "Public keys are invalid"
} else if vd.Public1[0] != '0' || vd.Public1[1] != '4' || vd.Public2[0] != '0' || vd.Public2[1] != '4' {
vd.Error = "Public keys are invalid"
} else {
a, b := mymath.AddPublicKeys(vd.Public1, vd.Public2)
vd.PublicSum = "04" + mymath.Hex2Str(mymath.Big2HexPadded(a, 32)) + mymath.Hex2Str(mymath.Big2HexPadded(b, 32))
vd.PublicAddress = string(mymath.NewFromPublicKey(0x00, mymath.Str2Hex(vd.PublicSum)).Base)
}
VanitySumTestTemplate.Execute(w, vd)
} else {
VanitySumTestTemplate.Execute(w, DefaultVanitySumData)
}
}
func addressTest(w http.ResponseWriter, r *http.Request) {
c := appengine.NewContext(r)
if r.FormValue("Random") != "" {
var address AddressDat
curve := bitelliptic.S256()
priv, x, y, _ := curve.GenerateKey(rand.Reader)
pub := append(append([]byte{0x04}, mymath.Big2HexWithMinimumLength(x, 32)...), mymath.Big2HexWithMinimumLength(y, 32)...)
//pub=mymath.Str2Hex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f")
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
mymath.Hex2Str(priv),
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("private") != "" {
var err error
var address AddressDat
curve := bitelliptic.S256()
privs, err := bitecdsa.GenerateFromPrivateKey(mymath.Str2Big(r.FormValue("private")), curve)
if err != nil {
if err.Error() == "Private key is not on curve" {
address = DefaultAddress
address.Error = "Private key is not on curve"
AddressTestTemplate.Execute(w, address)
} else {
c.Errorf("Err ", err)
return
}
} else {
priv := mymath.Big2Hex(privs.D)
x := privs.PublicKey.X
y := privs.PublicKey.Y
//priv, x, y, _:=curve.GenerateKey(rand.Reader)
pub := append(append([]byte{0x04}, mymath.Big2HexWithMinimumLength(x, 32)...), mymath.Big2HexWithMinimumLength(y, 32)...)
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
mymath.Hex2Str(priv),
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
}
} else if r.FormValue("public") != "" {
var address AddressDat
pub := mymath.Str2Hex(r.FormValue("public"))
if len(pub) != 65 {
address.Error = "Invalid public key length"
} else if pub[0] != 0x04 {
address.Error = "Invalid public key format"
}
st2 := mymath.SingleSHA(pub)
st3 := mymath.Ripemd(st2)
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"",
mymath.Hex2Str(pub),
mymath.Hex2Str(st2),
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("RIPEMD") != "" {
var address AddressDat
st3 := mymath.Str2Hex(r.FormValue("RIPEMD"))
if len(st3) != 20 {
address.Error = "Invalid RIPEMD-160 length"
}
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("RIPEMDWithHash") != "" {
var address AddressDat
st4 := mymath.Str2Hex(r.FormValue("RIPEMDWithHash"))
if len(st4) != 21 {
address.Error = "Invalid RIPEMD-160 length"
}
st3 := st4[1:]
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
st8 := append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("FullAddress") != "" {
var address AddressDat
st8 := mymath.Str2Hex(r.FormValue("FullAddress"))
if len(st8) != 25 {
address.Error = "Invalid address length"
c.Debugf("%d", len(st8))
}
st3 := st8[1:21]
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
//st8:=append(st4[:], st7[:]...)
st9 := mymath.Hex2Base58(st8)
if len(st8) == 25 {
if st7[3] != st8[24] || st7[2] != st8[23] || st7[1] != st8[22] || st7[0] != st8[21] {
address.Error = "Invalid checksum"
}
}
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else if r.FormValue("Base58") != "" {
var address AddressDat
st9 := r.FormValue("Base58")
st8 := mymath.Base582Hex(st9)
if len(st8) != 25 {
address.Error = "Invalid address length"
c.Debugf("%d", len(st8))
}
st3 := st8[1:21]
st4 := append([]byte{0x00}, st3[:]...)
st5 := mymath.SingleSHA(st4)
st6 := mymath.SingleSHA(st5)
st7 := st6[0:4]
//st8:=append(st4[:], st7[:]...)
//st9:=mymath.Hex2Base58(st8)
if len(st8) == 25 {
if st7[3] != st8[24] || st7[2] != st8[23] || st7[1] != st8[22] || st7[0] != st8[21] {
address.Error = "Invalid checksum"
}
}
address.HashString = []string{
"", "", "",
mymath.Hex2Str(st3),
mymath.Hex2Str(st4),
mymath.Hex2Str(st5),
mymath.Hex2Str(st6),
mymath.Hex2Str(st7),
mymath.Hex2Str(st8),
string(st9)}
AddressTestTemplate.Execute(w, address)
} else {
AddressTestTemplate.Execute(w, DefaultAddress)
}
}