introduce Contract struct with storage operations

Author: rmnblm

protocol/contract.go

@@ -0,0 +1,81 @@
+package protocol
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+)
+
+type Contract struct {
+	Address            [64]byte              // 64 Byte
+	Issuer             [64]byte              // 64 Byte
+	Balance            uint64                // 8 Byte
+	Contract           []byte                // Arbitrary length
+	ContractVariables  []ByteArray           // Arbitrary length
+}
+
+func NewContract(address [64]byte,
+	issuer [64]byte,
+	balance uint64,
+	contract []byte,
+	contractVariables []ByteArray) Contract {
+
+	return Contract {
+		address,
+		issuer,
+		balance,
+		contract,
+		contractVariables,
+	}
+}
+
+func (contract *Contract) Hash() [32]byte {
+	if contract == nil {
+		return [32]byte{}
+	}
+
+	return SerializeHashContent(contract.Address)
+}
+
+func (contract *Contract) Encode() []byte {
+	if contract == nil {
+		return nil
+	}
+
+	encoded := Contract{
+		Address:           contract.Address,
+		Issuer:            contract.Issuer,
+		Balance:           contract.Balance,
+		Contract:          contract.Contract,
+		ContractVariables: contract.ContractVariables,
+	}
+
+	buffer := new(bytes.Buffer)
+	gob.NewEncoder(buffer).Encode(encoded)
+	return buffer.Bytes()
+}
+
+func (*Contract) Decode(encoded []byte) (contract *Contract) {
+	var decoded Contract
+	buffer := bytes.NewBuffer(encoded)
+	decoder := gob.NewDecoder(buffer)
+	decoder.Decode(&decoded)
+	return &decoded
+}
+
+func (contract Contract) String() string {
+	addressHash := contract.Hash()
+	return fmt.Sprintf(
+		"Hash: %x, " +
+			"Address: %x, " +
+			"Issuer: %x, " +
+			"Balance: %v, " +
+			"Contract: %v, " +
+			"ContractVariables: %v",
+		addressHash[0:8],
+		contract.Address[0:8],
+		contract.Issuer[0:8],
+		contract.Balance,
+		contract.Contract,
+		contract.ContractVariables)
+}

protocol/contract_test.go

@@ -0,0 +1,65 @@
+package protocol
+
+import (
+	"math/rand"
+	"reflect"
+	"testing"
+)
+
+func TestContractCreation(t *testing.T) {
+	createdContract := NewContract(accA.Address, accA.Issuer, accA.Balance, accA.Contract, accA.ContractVariables)
+
+	if !reflect.DeepEqual(createdContract.Address, accA.Address) {
+		t.Errorf("Address does not match the given one: %x vs. %x", createdContract.Address, accA.Address)
+	}
+
+	if !reflect.DeepEqual(createdContract.Issuer, accA.Issuer) {
+		t.Errorf("Issuer does not match the given one: %x vs. %x", createdContract.Issuer, accA.Issuer)
+	}
+
+	if !reflect.DeepEqual(createdContract.Balance, accA.Balance) {
+		t.Errorf("Balance does not match the given one: %v vs. %v", createdContract.Balance, accA.Balance)
+	}
+
+	if !reflect.DeepEqual(createdContract.Contract, accA.Contract) {
+		t.Errorf("Contract does not match the given one: %x vs. %x", createdContract.Contract, accA.Contract)
+	}
+
+	if !reflect.DeepEqual(createdContract.ContractVariables, accA.ContractVariables) {
+		t.Errorf("ContractVariables does not match the given one: %x vs. %x", createdContract.ContractVariables, accA.ContractVariables)
+	}
+}
+
+func TestContractHash(t *testing.T) {
+	var address [64]byte
+	rand.Read(address[:])
+
+	hash1 := accA.Hash()
+
+	if !reflect.DeepEqual(hash1, accA.Hash()) {
+		t.Errorf("Contract hashing failed!")
+	}
+
+	accA.Address = address
+	hash2 :=accA.Hash()
+
+	if reflect.DeepEqual(hash1, hash2) {
+		t.Errorf("Contract hashing failed!")
+	}
+}
+
+func TestContractSerialization(t *testing.T) {
+	addTestingAccounts()
+
+	accA.Balance = 1000
+	accA.IsStaking = true
+	accA.TxCnt = 5
+
+	var compareContract *Contract
+	encodedContract := accA.Encode()
+	compareContract = compareContract.Decode(encodedContract)
+
+	if !reflect.DeepEqual(accA, compareContract) {
+		t.Error("Contract encoding/decoding failed!")
+	}
+}

storage/delete.go

@@ -68,6 +68,14 @@ func DeleteAccount(address [64]byte) error {
 	})
 }
 
+func DeleteContract(address [64]byte) error {
+	delete(AccountState, address)
+	return db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(ACCOUNTS_BUCKET))
+		return b.Delete(address[:])
+	})
+}
+
 func DeleteAll() (err error) {
 	//Delete in-memory storage
 	for key := range txMemPool {

storage/read.go

@@ -131,6 +131,19 @@ func ReadAccounts() (accounts []*protocol.Account, err error) {
 	return accounts, err
 }
 
+func ReadContracts() (contracts []*protocol.Contract, err error) {
+	err = db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(CONTRACTS_BUCKET))
+		return b.ForEach(func(k, v []byte) error {
+			var contract *protocol.Contract
+			contract = contract.Decode(v)
+			contracts = append(contracts, contract)
+			return nil
+		})
+	})
+	return contracts, err
+}
+
 func ReadGenesis() (genesis *protocol.Genesis, err error) {
 	err = db.View(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte(GENESIS_BUCKET))

storage/storage.go

@@ -13,11 +13,12 @@ var (
 	db                 *bolt.DB
 	logger             *log.Logger
 	AccountState       = make(map[[64]byte]*protocol.Account)
+	ContractState      = make(map[[64]byte]*protocol.Contract)
 	RootKeys           = make(map[[64]byte]*protocol.Account)
 	txMemPool          = make(map[[32]byte]protocol.Transaction)
 	AllClosedBlocksAsc []*protocol.Block
 	BootstrapServer    string
-	Buckets			   []string
+	Buckets            []string
 )
 
 const (
@@ -30,6 +31,7 @@ const (
 	CLOSEDCONFIGS_BUCKET	= "closedconfigs"
 	LASTCLOSEDBLOCK_BUCKET 	= "lastclosedblock"
 	ACCOUNTS_BUCKET			= "accounts"
+	CONTRACTS_BUCKET		= "contracts"
 	GENESIS_BUCKET			= "genesis"
 )
 
@@ -47,6 +49,7 @@ func Init(dbname string, bootstrapIpport string) error {
 		CLOSEDCONFIGS_BUCKET,
 		LASTCLOSEDBLOCK_BUCKET,
 		ACCOUNTS_BUCKET,
+		CONTRACTS_BUCKET,
 		GENESIS_BUCKET,
 	}
 
@@ -69,6 +72,11 @@ func Init(dbname string, bootstrapIpport string) error {
 		return err
 	}
 
+	err = loadContractState()
+	if err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -79,7 +87,19 @@ func loadAccountState() error {
 	}
 
 	for _, acc := range accounts {
-		State[acc.Address] = acc
+		AccountState[acc.Address] = acc
+	}
+	return nil
+}
+
+func loadContractState() error {
+	contracts, err := ReadContracts()
+	if err != nil {
+		return err
+	}
+
+	for _, contract := range contracts {
+		ContractState[contract.Address] = contract
 	}
 	return nil
 }

storage/utils.go

@@ -21,6 +21,14 @@ func GetAccount(pubKey [64]byte) (acc *protocol.Account, err error) {
 	}
 }
 
+func GetContract(address [64]byte) (contract *protocol.Contract, err error) {
+	if contract = ContractState[address]; contract != nil {
+		return contract, nil
+	} else {
+		return nil, errors.New(fmt.Sprintf("Contract (%x) not in the state.", address[0:8]))
+	}
+}
+
 func GetRootAccount(pubKey [64]byte) (acc *protocol.Account, err error) {
 	if IsRootKey(pubKey) {
 		acc, err = GetAccount(pubKey)

storage/write.go

@@ -59,6 +59,14 @@ func WriteAccount(account *protocol.Account) error {
 	})
 }
 
+func WriteContract(contract *protocol.Contract) error {
+	ContractState[contract.Address] = contract
+	return db.Update(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(CONTRACTS_BUCKET))
+		return b.Put(contract.Address[:], contract.Encode())
+	})
+}
+
 func WriteGenesis(genesis *protocol.Genesis) error {
 	return db.Update(func(tx *bolt.Tx) error {
 		b := tx.Bucket([]byte(GENESIS_BUCKET))