예제 #1
0
func makeMoreBlocks(t *testing.T, mv *Visor, n int, when uint64) []SignedBlock {
	dest := wallet.NewWalletEntry()
	blocks := make([]SignedBlock, 0, n)
	for i := 0; i < n; i++ {
		tx, err := mv.Spend(mv.Wallets[0].GetID(), wallet.Balance{10 * 1e6, 0},
			0, dest.Address)
		assert.Nil(t, err)
		if err != nil {
			return nil
		}
		mv.RecordTxn(tx)
		assert.Equal(t, len(mv.Unconfirmed.Txns), 1)
		sb, err := mv.CreateBlock(when + 1 + uint64(i))
		assert.Nil(t, err)
		if err != nil {
			return nil
		}
		err = mv.ExecuteSignedBlock(sb)
		assert.Nil(t, err)
		if err != nil {
			return nil
		}
		assert.Equal(t, len(mv.Unconfirmed.Txns), 0)
		blocks = append(blocks, sb)
	}
	return blocks
}
예제 #2
0
func makeValidTxnNoError(t *testing.T, mv *visor.Visor) coin.Transaction {
	we := wallet.NewWalletEntry()
	tx, err := mv.Spend(mv.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0}, 0,
		we.Address)
	assert.Nil(t, err)
	return tx
}
예제 #3
0
func makeValidTxnWithFeeFactorAndExtraChange(mv *Visor,
	factor, extra, change uint64) (coin.Transaction, error) {
	we := wallet.NewWalletEntry()
	tmp := mv.Config.CoinHourBurnFactor
	mv.Config.CoinHourBurnFactor = factor
	tx, err := mv.Spend(mv.Wallets[0].GetID(), wallet.Balance{10 * 1e6, 1002},
		extra, we.Address)
	mv.Config.CoinHourBurnFactor = tmp
	return tx, err
}
예제 #4
0
func newDefaultDaemon() *Daemon {
	cleanupPeers()
	c := NewConfig()
	we := wallet.NewWalletEntry()
	c.Visor.Config.MasterKeys = we
	c.Visor.Config.GenesisSignature = createGenesisSignature(we)
	c.Visor.Disabled = true
	c.DHT.Disabled = true
	return NewDaemon(c)
}
예제 #5
0
func makeInvalidTxn(mv *Visor) (coin.Transaction, error) {
	we := wallet.NewWalletEntry()
	txn, err := mv.Spend(mv.Wallets[0].GetID(), wallet.Balance{10 * 1e6, 0}, 0,
		we.Address)
	if err != nil {
		return txn, err
	}
	txn.Out[0].Address = cipher.Address{}
	return txn, nil
}
예제 #6
0
func setupMasterVisor() VisorConfig {
	cleanupVisor()
	coin.SetAddressVersion("test")
	c := NewVisorConfig()
	c.Config.IsMaster = true
	mw := wallet.NewWalletEntry()
	c.Config.MasterKeys = mw
	c.Config.GenesisSignature = createGenesisSignature(mw)
	return c
}
예제 #7
0
func setupMasterVisorConfig() VisorConfig {
	// Create testmaster.keys file
	c := NewVisorConfig()
	c.CoinHourBurnFactor = 0
	c.IsMaster = true
	mw := wallet.NewWalletEntry()
	c.MasterKeys = mw
	c.GenesisSignature = createGenesisSignature(mw)
	return c
}
예제 #8
0
func TestVisorSpend(t *testing.T) {
	defer cleanupVisor()
	we := wallet.NewWalletEntry()
	addr := we.Address
	vc := newMasterVisorConfig(t)
	assert.Equal(t, vc.CoinHourBurnFactor, uint64(0))
	v := NewVisor(vc)
	wid := v.Wallets[0].GetFilename()
	ogb := v.WalletBalance(wid).Confirmed

	// Test spend 0 amount
	v = NewVisor(vc)
	b = wallet.Balance{0, 0}
	_, err = v.Spend(v.Wallets[0].GetFilename(), b, 0, addr)
	assert.NotNil(t, err)
	assert.Equal(t, err.Error(), "Zero spend amount")

	// Test lacking funds
	v = NewVisor(vc)
	b = wallet.Balance{10e16, 10e16}
	_, err = v.Spend(v.Wallets[0].GetFilename(), b, 10e16, addr)
	assert.NotNil(t, err)
	assert.Equal(t, err.Error(), "Not enough coins")

	// Test created txn too large
	v = NewVisor(vc)
	v.Config.MaxBlockSize = 0
	b = wallet.Balance{10e6, 10}
	assert.Panics(t, func() { v.Spend(v.Wallets[0].GetFilename(), b, 0, addr) })

	// Test simple spend (we have only 1 address to spend from, no fee)
	v = NewVisor(vc)
	assert.Equal(t, v.Config.CoinHourBurnFactor, uint64(0))
	b = wallet.Balance{10e6, 10}
	tx, err := v.Spend(v.Wallets[0].GetFilename(), b, 0, addr)
	assert.Nil(t, err)
	assert.Equal(t, len(tx.In), 1)
	assert.Equal(t, len(tx.Out), 2)
	// Hash should be updated
	assert.NotEqual(t, tx.Head.Hash, cipher.SHA256{})
	// Should be 1 signature for the single input
	assert.Equal(t, len(tx.Head.Sigs), 1)
	// Spent amount should be correct
	assert.Equal(t, tx.Out[1].Address, addr)
	assert.Equal(t, tx.Out[1].Coins, b.Coins)
	assert.Equal(t, tx.Out[1].Hours, b.Hours)
	// Change amount should be correct
	ourAddr := v.Wallets[0].GetAddresses()[0]
	assert.Equal(t, tx.Out[0].Address, ourAddr)
	assert.Equal(t, tx.Out[0].Coins, ogb.Coins-b.Coins)
	assert.Equal(t, tx.Out[0].Hours, ogb.Hours-b.Hours)
	assert.Nil(t, tx.Verify())
}
예제 #9
0
func TestLoadBlockchainPrivate(t *testing.T) {
	defer cleanupVisor()
	cleanupVisor()

	we := wallet.NewWalletEntry()

	// No filename should return fresh blockchain
	bc := loadBlockchain("", we.Address)
	assert.Equal(t, len(bc.Blocks), 0)

	// Filename with no file should return fresh blockchain
	assertFileNotExists(t, testBlockchainFile)
	bc = loadBlockchain(testBlockchainFile, we.Address)
	assert.Equal(t, len(bc.Blocks), 0)

	// Loading an empty blockchain should panic
	assert.Nil(t, SaveBlockchain(bc, testBlockchainFile))
	assertFileExists(t, testBlockchainFile)
	assert.Panics(t, func() {
		loadBlockchain(testBlockchainFile, we.Address)
	})

	// Loading a blockchain with a different genesis address should panic
	vc := newMasterVisorConfig(t)
	bc.CreateGenesisBlock(vc.MasterKeys.Address, 0, 100e6)
	assert.Equal(t, len(bc.Blocks), 1)
	assert.Nil(t, SaveBlockchain(bc, testBlockchainFile))
	assertFileExists(t, testBlockchainFile)
	assert.Panics(t, func() {
		loadBlockchain(testBlockchainFile, coin.Address{})
	})

	// Loading a corrupt blockchain should panic
	corruptFile(t, testBlockchainFile)
	assert.Panics(t, func() {
		loadBlockchain(testBlockchainFile, we.Address)
	})
	cleanupVisor()

	// Loading a valid blockchain should be safe
	vc = newMasterVisorConfig(t)
	vc.BlockchainFile = testBlockchainFile
	v := NewVisor(vc)
	assert.Nil(t, transferCoinsToSelf(v, v.Config.MasterKeys.Address))
	assert.Equal(t, len(v.blockchain.Blocks), 2)
	assert.Nil(t, v.SaveBlockchain())
	assertFileExists(t, testBlockchainFile)
	bc = loadBlockchain(testBlockchainFile, v.Config.MasterKeys.Address)
	assert.Equal(t, v.blockchain, bc)
}
예제 #10
0
func TestCreateMasterWallet(t *testing.T) {
	defer cleanupVisor()
	cleanupVisor()
	we := wallet.NewWalletEntry()
	w := CreateMasterWallet(we)
	assert.Equal(t, w.NumEntries(), 1)
	assert.Equal(t, w.GetAddresses()[0], we.Address)

	// Having a wallet file present should not affect loading master wallet
	w.Save(testWalletFile)
	we = wallet.NewWalletEntry()
	w = CreateMasterWallet(we)
	assert.Equal(t, w.NumEntries(), 1)
	assert.Equal(t, w.GetAddresses()[0], we.Address)

	// Creating with an invalid wallet entry should panic
	we = wallet.NewWalletEntry()
	we.Secret = cipher.SecKey{}
	assert.Panics(t, func() { CreateMasterWallet(we) })
	we = wallet.NewWalletEntry()
	we.Public = cipher.PubKey{}
	assert.Panics(t, func() { CreateMasterWallet(we) })
}
예제 #11
0
func addSignedBlockAt(t *testing.T, v *Visor, when uint64) SignedBlock {
	we := wallet.NewWalletEntry()
	tx, err := v.Spend(v.Wallets[0].GetFilename(), wallet.Balance{1e6, 0}, 0, we.Address)
	assert.Nil(t, err)
	err, known := v.InjectTxn(tx)
	assert.Nil(t, err)
	assert.False(t, known)
	sb, err := v.CreateBlock(when)
	assert.Nil(t, err)
	if err != nil {
		return sb
	}
	err = v.ExecuteSignedBlock(sb)
	assert.Nil(t, err)
	return sb
}
예제 #12
0
// Returns an appropriate VisorConfig and a master visor
func setupVisorConfig() (VisorConfig, *Visor) {
	// Make a new master visor + blockchain
	// Get the signed genesis block,
	mw := wallet.NewWalletEntry()
	mvc := NewVisorConfig()
	mvc.CoinHourBurnFactor = 0
	mvc.IsMaster = true
	mvc.MasterKeys = mw
	mvc.GenesisSignature = createGenesisSignature(mw)
	mv := NewVisor(mvc)

	// Use the master values for a client configuration
	c := NewVisorConfig()
	c.IsMaster = false
	c.GenesisSignature = mvc.GenesisSignature
	c.GenesisTimestamp = mvc.GenesisTimestamp
	c.MasterKeys = mw
	c.MasterKeys.Secret = cipher.SecKey{}
	c.WalletDirectory = testWalletDir
	return c, mv
}
예제 #13
0
func makeMoreBlocks(mv *visor.Visor, n int,
	now uint64) ([]visor.SignedBlock, error) {
	dest := wallet.NewWalletEntry()
	blocks := make([]visor.SignedBlock, n)
	for i := 0; i < n; i++ {
		tx, err := mv.Spend(mv.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0},
			0, dest.Address)
		if err != nil {
			return nil, err
		}
		mv.RecordTxn(tx)
		sb, err := mv.CreateBlock(now + uint64(i) + 1)
		if err != nil {
			return nil, err
		}
		err = mv.ExecuteSignedBlock(sb)
		if err != nil {
			return nil, err
		}
		blocks[i] = sb
	}
	return blocks, nil
}
예제 #14
0
func TestCreateAndPublishBlock(t *testing.T) {
	defer cleanupVisor()
	defer gnet.EraseMessages()
	p, gc := setupPool()
	vc, mv := setupVisor()
	dest := wallet.NewWalletEntry()
	go p.Pool.ConnectionWriteLoop(gc)

	// Disabled
	vc.Disabled = true
	vc.Config = mv.Config
	v := NewVisor(vc)
	v.Visor = mv
	err := v.CreateAndPublishBlock(p)
	assert.NotNil(t, err)
	wait()
	assert.Equal(t, err.Error(), "Visor disabled")
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.Equal(t, v.Visor.MostRecentBkSeq(), uint64(0))

	// Created and sent
	vc.Disabled = false
	vc.Config.IsMaster = true
	vc.Config = mv.Config
	v = NewVisor(vc)
	gc.Conn = NewDummyConn(addr)
	_, err = v.Spend(v.Visor.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0}, 0,
		dest.Address, p)
	assert.Nil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	<-p.Pool.SendResults
	err = v.CreateAndPublishBlock(p)
	wait()
	assert.Nil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	sr := <-p.Pool.SendResults
	assert.Nil(t, sr.Error)
	assert.Equal(t, sr.Connection, gc)
	_, ok := sr.Message.(*GiveBlocksMessage)
	assert.True(t, ok)
	assert.Equal(t, v.Visor.MostRecentBkSeq(), uint64(1))

	// Can't create, don't have coins
	// First, spend all of our coins
	// vc2, _ := setupVisor()
	// vc2.Config.GenesisSignature = vc.Config.GenesisSignature
	// vc2.Config.MasterKeys = vc.Config.MasterKeys
	// vc2.Config.IsMaster = true
	// vc2.Disabled = false
	vc.Config.IsMaster = true
	vc.Disabled = false
	v = NewVisor(vc)
	tx, err := v.Spend(v.Visor.Wallets[0].GetID(),
		visor.Balance{vc.Config.GenesisCoinVolume, 0},
		vc.Config.GenesisCoinVolume, dest.Address, p)
	mv.RecordTxn(tx)
	wait()
	assert.Nil(t, err)
	assert.Equal(t, len(p.Pool.SendResults), 1)
	for len(p.Pool.SendResults) > 0 {
		<-p.Pool.SendResults
	}
	err = v.CreateAndPublishBlock(p)
	assert.Nil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	for len(p.Pool.SendResults) > 0 {
		<-p.Pool.SendResults
	}
	// No coins to spend, fail
	assert.Equal(t, v.Visor.MostRecentBkSeq(), uint64(1))
	_, err = v.Spend(v.Visor.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0}, 0,
		dest.Address, p)
	assert.NotNil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	err = v.CreateAndPublishBlock(p)
	assert.NotNil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.Equal(t, v.Visor.MostRecentBkSeq(), uint64(1))
}
예제 #15
0
func newWalletEntry(t *testing.T) wallet.WalletEntry {
	we := wallet.NewWalletEntry()
	assert.Nil(t, we.Verify())
	return we
}
예제 #16
0
func testBlockCreationTicker(t *testing.T, vcfg VisorConfig, master bool,
	mv *visor.Visor) {
	vcfg.Config.BlockCreationInterval = 1
	defer gnet.EraseMessages()
	c := NewConfig()
	c.Visor = vcfg
	c.Daemon.DisableNetworking = false
	d := NewDaemon(c)
	if !master {
		err := transferCoins(mv, d.Visor.Visor)
		assert.Nil(t, err)
	}
	quit := make(chan int)
	defer closeDaemon(d, quit)
	gc := setupExistingPool(d.Pool)
	go d.Pool.Pool.ConnectionWriteLoop(gc)
	assert.True(t, gc.LastSent.IsZero())
	assert.Equal(t, len(d.Pool.Pool.Pool), 1)
	assert.Equal(t, d.Pool.Pool.Pool[gc.Id], gc)
	assert.Equal(t, len(d.Pool.Pool.Addresses), 1)
	start := 0
	if !master {
		start = 1
	}
	assert.Equal(t, d.Visor.Visor.MostRecentBkSeq(), uint64(start))
	go d.Start(quit)
	time.Sleep(time.Second + (time.Millisecond * 50))
	// Creation should not have occured, because no transaction
	assert.Equal(t, d.Visor.Visor.MostRecentBkSeq(), uint64(start))
	assert.Equal(t, len(d.Pool.Pool.SendResults), 0)

	// Creation should occur with a transaction, if not a master
	// Make a transaction
	assert.False(t, d.Visor.Config.Disabled)
	assert.True(t, gc.LastSent.IsZero())
	dest := wallet.NewWalletEntry()
	tx, err := d.Visor.Spend(d.Visor.Visor.Wallets[0].GetID(),
		visor.Balance{10 * 1e6, 0}, 0, dest.Address, d.Pool)
	wait()
	assert.Nil(t, err)
	assert.Equal(t, d.Pool.Pool.Pool[gc.Id], gc)
	assert.Equal(t, len(d.Pool.Pool.DisconnectQueue), 0)
	assert.Equal(t, len(d.Pool.Pool.Pool), 1)
	assert.Equal(t, len(d.Pool.Pool.Addresses), 1)
	// Since the daemon loop is running, it will have processed the SendResult
	// Instead we can check if the txn was announced
	assert.Equal(t, len(d.Pool.Pool.SendResults), 0)
	ut := d.Visor.Visor.Unconfirmed.Txns[tx.Hash()]
	assert.False(t, ut.Announced.IsZero())
	assert.False(t, gc.LastSent.IsZero())
	ls := gc.LastSent

	// Now, block should be created
	time.Sleep(time.Second + (time.Millisecond * 50))
	final := start
	if master {
		final += 1
	}
	assert.Equal(t, len(d.Pool.Pool.Pool), 1)
	// Again, we can't check SendResults since the daemon loop is running.
	// We can only check that LastSent was updated, if its the master and it
	// created the block.
	if master {
		assert.True(t, gc.LastSent.After(ls))
	} else {
		assert.Equal(t, gc.LastSent, ls)
	}
	assert.Equal(t, d.Visor.Visor.MostRecentBkSeq(), uint64(final))
	assert.False(t, gc.LastSent.IsZero())
}
예제 #17
0
func TestExecuteSignedBlock(t *testing.T) {
	defer cleanupVisor()
	cleanupVisor()
	we := wallet.NewWalletEntry()
	vc := newMasterVisorConfig(t)
	v := NewVisor(vc)
	wid := v.Wallets[0].GetFilename()
	assert.Equal(t, len(v.Unconfirmed.Txns), 0)
	tx, err := v.Spend(wid, wallet.Balance{1e6, 0}, 0, we.Address)
	assert.Nil(t, err)
	err, known := v.InjectTxn(tx)
	assert.Nil(t, err)
	assert.False(t, known)
	assert.Equal(t, len(v.Unconfirmed.Txns), 1)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)
	now := uint64(util.UnixNow())

	// Invalid signed block
	sb, err := v.CreateBlock(now)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)
	assert.Nil(t, err)
	sb.Sig = cipher.Sig{}
	err = v.ExecuteSignedBlock(sb)
	assert.NotNil(t, err)
	assert.Equal(t, len(v.Unconfirmed.Txns), 1)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)

	// Invalid block
	sb, err = v.CreateBlock(now)
	assert.Nil(t, err)
	// TODO -- empty BodyHash is being accepted, fix blockchain verification
	sb.Block.Head.BodyHash = cipher.SHA256{}
	sb.Block.Body.Transactions = make(coin.Transactions, 0)
	sb = v.SignBlock(sb.Block)
	err = v.ExecuteSignedBlock(sb)
	assert.NotNil(t, err)
	assert.Equal(t, len(v.Unconfirmed.Txns), 1)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)

	// Valid block
	sb, err = v.CreateBlock(now)
	assert.Nil(t, err)
	err = v.ExecuteSignedBlock(sb)
	assert.Nil(t, err)
	assert.Equal(t, len(v.blockSigs.Sigs), 2)
	assert.Equal(t, v.blockSigs.Sigs[uint64(1)], sb.Sig)
	assert.Equal(t, v.blockchain.Blocks[1], sb.Block)
	assert.Equal(t, len(v.Unconfirmed.Txns), 0)

	// Test a valid block created by a master but executing in non master
	vc2, mv := setupVisorConfig()
	v2 := NewVisor(vc2)
	w := v2.Wallets[0]
	addr := w.GetAddresses()[0]
	tx, err = mv.Spend(mv.Wallets[0].GetFilename(), wallet.Balance{1e6, 0}, 0, addr)
	assert.Nil(t, err)
	err, known = mv.InjectTxn(tx)
	assert.Nil(t, err)
	assert.False(t, known)
	sb, err = mv.CreateAndExecuteBlock()
	assert.Nil(t, err)
	err = v2.ExecuteSignedBlock(sb)
	assert.Nil(t, err)
	assert.Equal(t, len(v2.blockSigs.Sigs), 2)
	assert.Equal(t, v2.blockSigs.Sigs[uint64(1)], sb.Sig)
	assert.Equal(t, v2.blockchain.Blocks[1], sb.Block)
	assert.Equal(t, len(v2.Unconfirmed.Txns), 0)
}
예제 #18
0
func makeValidTxn(mv *visor.Visor) (coin.Transaction, error) {
	we := wallet.NewWalletEntry()
	return mv.Spend(mv.Wallets[0].GetID(), visor.Balance{10 * 1e6, 0}, 0,
		we.Address)
}
예제 #19
0
// Writes a wallet entry to disk at filename
func writeMasterKeysFile() (wallet.WalletEntry, error) {
	we := wallet.NewWalletEntry()
	rwe := wallet.NewReadableWalletEntry(&we)
	err := rwe.Save(testMasterKeysFile)
	return we, err
}
예제 #20
0
func TestNewVisor(t *testing.T) {
	defer cleanupVisor()

	// Not master, Invalid master keys
	cleanupVisor()
	we := wallet.NewWalletEntry()
	we.Public = cipher.PubKey{}
	vc := NewVisorConfig()
	vc.IsMaster = false
	assert.Panics(t, func() { NewVisor(vc) })
	vc.MasterKeys = we
	assert.Panics(t, func() { NewVisor(vc) })

	// Master, invalid master keys
	cleanupVisor()
	vc.IsMaster = true
	vc.MasterKeys = wallet.WalletEntry{}
	assert.Panics(t, func() { NewVisor(vc) })
	vc.MasterKeys = we
	assert.Panics(t, func() { NewVisor(vc) })

	// Not master, no wallet, blockchain, blocksigs file
	cleanupVisor()
	vc = NewVisorConfig()
	vc.IsMaster = false
	we, sig, ts := setupGenesis(t)
	vc.MasterKeys = we
	vc.GenesisSignature = sig
	vc.GenesisTimestamp = ts
	v := NewVisor(vc)
	assert.Equal(t, len(v.blockchain.Blocks), 1)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)

	// Master, no wallet, blockchain, blocksigs file
	cleanupVisor()
	vc = NewVisorConfig()
	we = newWalletEntry(t)
	vc.MasterKeys = we
	vc.GenesisSignature = createGenesisSignature(we)
	vc.IsMaster = true
	v = NewVisor(vc)
	assert.Equal(t, len(v.Wallets), 1)
	// Wallet should only have 1 entry if master
	assert.Equal(t, v.Wallets[0].NumEntries(), 1)
	assert.Equal(t, len(v.blockchain.Blocks), 1)
	assert.Equal(t, len(v.blockSigs.Sigs), 1)

	// Not master, has all files
	cleanupVisor()
	refvc := newGenesisConfig(t)
	refv := writeVisorFiles(t, refvc)
	vc = setupChildVisorConfig(refvc, false)
	v = NewVisor(vc)
	assert.Equal(t, v.Wallets, refv.Wallets)
	assert.Equal(t, len(v.Wallets), 1)
	assert.Equal(t, v.blockchain, refv.blockchain)
	assert.Equal(t, v.blockSigs, refv.blockSigs)

	// Master, has all files
	cleanupVisor()
	refvc = newMasterVisorConfig(t)
	refv = writeVisorFiles(t, refvc)
	vc = setupChildVisorConfig(refvc, true)
	v = NewVisor(vc)
	assert.Equal(t, v.Wallets[0].GetEntries(), refv.Wallets[0].GetEntries())
	assert.Equal(t, v.blockchain, refv.blockchain)

	// Not master, wallet is corrupt
	cleanupVisor()
	refvc = newGenesisConfig(t)
	refv = writeVisorFiles(t, refvc)
	walletFile := filepath.Join(testWalletDir, testWalletFile)
	assertFileExists(t, walletFile)
	corruptFile(t, walletFile)
	vc = setupChildVisorConfig(refvc, false)
	assert.Panics(t, func() { NewVisor(vc) })

	// Master, wallet is corrupt.  Nothing happens because master ignores
	// wallet
	cleanupVisor()
	refvc = newMasterVisorConfig(t)
	refv = writeVisorFiles(t, refvc)
	assertFileExists(t, walletFile)
	corruptFile(t, walletFile)
	vc = setupChildVisorConfig(refvc, true)
	assert.NotPanics(t, func() { NewVisor(vc) })

	// Not master, blocksigs is corrupt
	cleanupVisor()
	refvc = newGenesisConfig(t)
	assertFileNotExists(t, testWalletFile)
	refv = writeVisorFiles(t, refvc)
	corruptFile(t, testBlocksigsFile)
	vc = setupChildVisorConfig(refvc, false)
	assert.Panics(t, func() { NewVisor(vc) })

	// Master, blocksigs is corrupt
	cleanupVisor()
	refvc = newMasterVisorConfig(t)
	refv = writeVisorFiles(t, refvc)
	corruptFile(t, testBlocksigsFile)
	assertFileExists(t, testBlocksigsFile)
	vc = setupChildVisorConfig(refvc, true)
	assert.Panics(t, func() { NewVisor(vc) })

	// Not master, blockchain is corrupt
	cleanupVisor()
	refvc = newGenesisConfig(t)
	refv = writeVisorFiles(t, refvc)
	corruptFile(t, testBlockchainFile)
	vc = setupChildVisorConfig(refvc, false)
	assert.Panics(t, func() { NewVisor(vc) })

	// Master, blockchain is corrupt
	cleanupVisor()
	refvc = newMasterVisorConfig(t)
	refv = writeVisorFiles(t, refvc)
	corruptFile(t, testBlockchainFile)
	vc = setupChildVisorConfig(refvc, true)
	assert.Panics(t, func() { NewVisor(vc) })

	// Not master, blocksigs is not valid for blockchain
	cleanupVisor()
	refvc = newGenesisConfig(t)
	refv = setupVisorWriting(refvc)
	// Corrupt the signature
	refv.blockSigs.Sigs[uint64(0)] = cipher.Sig{}
	writeVisorFilesDirect(t, refv)
	vc = setupChildVisorConfig(refvc, false)
	assert.Panics(t, func() { NewVisor(vc) })

	// Master, blocksigs is not valid for blockchain
	cleanupVisor()
	refvc = newMasterVisorConfig(t)
	refv = setupVisorWriting(refvc)
	// Corrupt the signature
	refv.blockSigs.Sigs[uint64(0)] = cipher.Sig{}
	writeVisorFilesDirect(t, refv)
	vc = setupChildVisorConfig(refvc, true)
	assert.Panics(t, func() { NewVisor(vc) })
}
예제 #21
0
func makeValidTxnNoChange(mv *Visor) (coin.Transaction, error) {
	we := wallet.NewWalletEntry()
	b := mv.AddressBalance(mv.Config.MasterKeys.Address)
	return mv.Spend(mv.Wallets[0].GetID(), b.Confirmed, 0, we.Address)
}