func NewFactoidState(filename string) state.IFactoidState {
fs := new(state.FactoidState)
wall := new(wallet.SCWallet)
wall.Init()
fs.SetWallet(wall)
fs.GetWallet().GetDB().Init()
// Use Bolt DB
if true {
fs.SetDB(new(database.MapDB))
fs.GetDB().Init()
db := GetDatabase(filename)
fs.GetDB().SetPersist(db)
fs.GetDB().SetBacker(db)
fs.GetWallet().GetDB().SetPersist(db)
fs.GetWallet().GetDB().SetBacker(db)
fs.GetDB().DoNotPersist(fct.DB_F_BALANCES)
fs.GetDB().DoNotPersist(fct.DB_EC_BALANCES)
fs.GetDB().DoNotPersist(fct.DB_BUILD_TRANS)
fs.GetDB().DoNotCache(fct.DB_FACTOID_BLOCKS)
fs.GetDB().DoNotCache(fct.DB_TRANSACTIONS)
} else {
fs.SetDB(GetDatabase(filename))
}
return fs
}
func main() {
// Get a wallet
wallet := new(wallet.SCWallet) // make me a wallet
wallet.Init()
// Generate a Random Seed
seed := fct.Sha([]byte(fmt.Sprintf("asdfjkoergipupdiofbd;;aerled: %v", time.Now().UnixNano()))).Bytes()
// Randomize the address generation. This should be very random, and destroyed for security
wallet.NewSeed(seed)
addr, err := wallet.GenerateECAddress([]byte("dan"))
if err != nil {
fmt.Println(err)
return
}
we := wallet.GetAddressDetailsAddr(addr.Bytes())
pub := we.GetKey(0)
pri := we.GetPrivKey(0)
fmt.Printf("Public Key: %x\n", pub)
fmt.Printf("Private Key: %x\n %x\n", pri[:])
}
func Test_create_block(test *testing.T) {
w := new(wallet.SCWallet) // make me a wallet
w.Init()
w.NewSeed([]byte("slfkjasdlfjasflajsfl"))
scb := block.NewFBlock(1000, 0)
cb := w.CreateTransaction(uint64(time.Now().UnixNano() / 1000000))
scb.AddCoinbase(cb)
for i := 0; i < 3; i++ {
h0, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-0"), 1, 1)
if err != nil {
sc.Prtln("Error 1")
test.Fail()
}
h1, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-1"), 1, 1)
if err != nil {
sc.Prtln("Error 2")
test.Fail()
}
h2, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-2"), 1, 1)
if err != nil {
sc.Prtln("Error 3")
test.Fail()
}
h3, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-3"), 1, 1)
if err != nil {
sc.Prtln("Error 4")
test.Fail()
}
h4, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-4"), 1, 1)
if err != nil {
sc.Prtln("Error 5")
test.Fail()
}
h5, err := w.GenerateFctAddress([]byte("test "+cv.Itoa(i)+"-5"), 1, 1)
if err != nil {
sc.Prtln("Error 6")
test.Fail()
}
t := w.CreateTransaction(uint64(time.Now().UnixNano() / 1000000))
w.AddInput(t, h1, 1000000)
w.AddInput(t, h2, 1000000)
w.AddOutput(t, h3, 1000000)
w.AddOutput(t, h4, 500000)
w.AddECOutput(t, h5, 500000)
w.AddInput(t, h0, 0)
fee, err := t.CalculateFee(1000)
w.UpdateInput(t, 2, h0, fee)
signed, err := w.SignInputs(t)
if err != nil {
sc.Prtln("Error found: ", err)
test.Fail()
return
}
if !signed {
sc.Prtln("Not valid")
test.Fail()
return
}
err = scb.AddTransaction(t)
if err != nil {
sc.Prtln("Error found: ", err)
test.Fail()
return
}
}
data, err := scb.MarshalBinary()
if err != nil {
fmt.Println(err)
test.Fail()
return
}
scb2 := new(block.FBlock)
_, err = scb2.UnmarshalBinaryData(data)
fmt.Println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n", scb2)
if err != nil {
fmt.Println(err)
test.Fail()
return
}
//sc.Prtln("FIRST\n",scb,"SECOND\n",scb2)
if scb.IsEqual(scb2) != nil {
fmt.Println(err)
test.Fail()
return
}
}