derohe-miniblock-mod/dvm/dvm_store.go

// Copyright 2017-2018 DERO Project. All rights reserved.
// Use of this source code in any form is governed by RESEARCH license.
// license can be found in the LICENSE file.
// GPG: 0F39 E425 8C65 3947 702A  8234 08B2 0360 A03A 9DE8
//
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package dvm

import "fmt"
import "encoding/binary"
import "github.com/deroproject/derohe/cryptography/crypto"

// this package exports an interface which is used by blockchain to persist/query data

type DataKey struct {
	SCID    crypto.Hash // tx which created the the contract or contract ID
	Asset   crypto.Hash // used only if it repesebts a balane
	Balance bool        // whether this represents a balance
	Key     Variable
}

type DataAtom struct {
	Key        DataKey
	Prev_Value Variable // previous Value if any
	Value      Variable // current value if any
}

type Object map[Variable]Variable

type TransferInternal struct {
	Asset  crypto.Hash `cbor:"Asset,omitempty" json:"Asset,omitempty"` //  transfer this asset
	SCID   string      `cbor:"A,omitempty" json:"A,omitempty"`         //  transfer to this SCID
	Amount uint64      `cbor:"V,omitempty" json:"V,omitempty"`         // Amount in Atomic units
}

// any external tranfers
type TransferExternal struct {
	Asset   crypto.Hash `cbor:"Asset,omitempty" json:"Asset,omitempty"` //  transfer this asset
	Address string      `cbor:"A,omitempty" json:"A,omitempty"`         //  transfer to this address 33 bytes
	Amount  uint64      `cbor:"V,omitempty" json:"V,omitempty"`         // Amount in Atomic units
}

type SC_Transfers struct {
	BalanceAtStart uint64             // value at start
	TransferI      []TransferInternal // all internal transfers, SC to other SC
	TransferE      []TransferExternal // all external transfers, SC to external wallets
}

// all SC load and store operations will go though this
type TX_Storage struct {
	DiskLoader     func(DataKey, *uint64) Variable // used to load variabled
	BalanceLoader  func(DataKey) uint64            // used to load balance
	DiskLoaderRaw  func([]byte) ([]byte, bool)
	SCID           crypto.Hash
	BalanceAtStart uint64               // at runtime this will be fed balance
	Keys           map[DataKey]Variable // this keeps the in-transit DB updates, just in case we have to discard instantly
	RawKeys        map[string][]byte

	Transfers map[crypto.Hash]SC_Transfers // all transfers ( internal/external )
}

var DVM_STORAGE_BACKEND DVM_Storage_Loader // this variable can be hijacked at runtime to offer different stores such as RAM/file/DB etc

type DVM_Storage_Loader interface {
	Load(DataKey, *uint64) Variable
	Store(DataKey, Variable)
	RawLoad([]byte) ([]byte, bool)
	RawStore([]byte, []byte)
}

// initialize tx store
func Initialize_TX_store() (tx_store *TX_Storage) {
	tx_store = &TX_Storage{Keys: map[DataKey]Variable{}, RawKeys: map[string][]byte{}, Transfers: map[crypto.Hash]SC_Transfers{}}
	return
}

func (tx_store *TX_Storage) RawLoad(key []byte) (value []byte, found bool) {
	if value, found = tx_store.RawKeys[string(key)]; !found {
		if tx_store.DiskLoaderRaw == nil {
			return
		}
		value, found = tx_store.DiskLoaderRaw(key)
	}
	return
}

func (tx_store *TX_Storage) RawStore(key []byte, value []byte) {
	tx_store.RawKeys[string(key)] = value
	return
}

// this will load the variable, and if the key is found
func (tx_store *TX_Storage) Load(dkey DataKey, found_value *uint64) (value Variable) {

	//fmt.Printf("Loading %+v   \n", dkey)

	*found_value = 0
	if result, ok := tx_store.Keys[dkey]; ok { // if it was modified in current TX, use it
		*found_value = 1
		return result
	}

	if tx_store.DiskLoader == nil {
		panic("DVM_STORAGE_BACKEND is not ready")
	}

	value = tx_store.DiskLoader(dkey, found_value)

	return
}

// store variable
func (tx_store *TX_Storage) Store(dkey DataKey, v Variable) {
	//fmt.Printf("Storing request %+v   : %+v\n", dkey, v)

	tx_store.Keys[dkey] = v
}

// store variable
func (tx_store *TX_Storage) SendExternal(sender_scid, asset crypto.Hash, addr_str string, amount uint64) {
	//fmt.Printf("Transfer to  external address   : %+v\n", addr_str)
	transfer := tx_store.Transfers[sender_scid]
	transfer.TransferE = append(transfer.TransferE, TransferExternal{Address: addr_str, Asset: asset, Amount: amount})
	tx_store.Transfers[sender_scid] = transfer

}

func GetBalanceKey(scid, asset crypto.Hash) (x DataKey) {
	x.SCID = scid
	x.Balance = true
	x.Key = Variable{Type: String, ValueString: string(asset[:])}
	return x
}

/*
func GetNormalKey(scid crypto.Key,  v Variable) (x DataKey) {
    x.SCID = scid
    x.Key = Variable {Type:v.Type, Value: v.Value}
    return x
}
*/

// why should we not hash the return value to return a hash value
// using entire key could be useful, if DB can somehow link between  them in the form of buckets and all
func (dkey DataKey) MarshalBinary() (ser []byte, err error) {
	ser, err = dkey.Key.MarshalBinary()
	return
}

func (dkey DataKey) MarshalBinaryPanic() (ser []byte) {
	var err error

	if dkey.Balance {
		switch dkey.Key.Type {
		case String:
			ser = append(ser, ([]byte(dkey.Key.ValueString))...) // string
			return
		default:

			panic("balance keys can only be string")
		}
	}
	if ser, err = dkey.Key.MarshalBinary(); err != nil {
		panic(err)
	}
	return
}

// these are used by lowest layers
func (v Variable) MarshalBinary() (data []byte, err error) {
	switch v.Type {
	case Invalid:
		return
	case Uint64:
		var buf [binary.MaxVarintLen64]byte
		done := binary.PutUvarint(buf[:], v.ValueUint64) // uint64 data type
		data = append(data, buf[:done]...)
	case String:
		data = append(data, ([]byte(v.ValueString))...) // string
	default:
		panic("unknown variable type not implemented")
	}
	data = append(data, byte(v.Type)) // add object type
	return
}
func (v Variable) MarshalBinaryPanic() (ser []byte) {
	var err error
	if ser, err = v.MarshalBinary(); err != nil {
		panic(err)
	}
	return
}

func (v *Variable) UnmarshalBinary(buf []byte) (err error) {
	if len(buf) < 1 {
		return fmt.Errorf("invalid, probably corruption")
	}

	switch Vtype(buf[len(buf)-1]) {
	case Invalid:
		return fmt.Errorf("Invalid cannot be deserialized")
	case Uint64:
		v.Type = Uint64
		var n int
		v.ValueUint64, n = binary.Uvarint(buf[:len(buf)-1]) // uint64 data type
		if n <= 0 {
			panic("corruption in DB")
			return fmt.Errorf("corruption in DB")
		}
	case String:
		v.Type = String
		v.ValueString = string(buf[:len(buf)-1])
		return nil

	default:
		panic("unknown variable type not implemented")

	}
	return
}