Skip to content
Snippets Groups Projects
Commit ce68ef59 authored by Hans Moog's avatar Hans Moog
Browse files

Feat: continued porting ledgerstate

parent 5e4fb5a5
No related branches found
No related tags found
No related merge requests found
package ledgerstate
import (
"unicode/utf8"
"github.com/iotaledger/goshimmer/packages/stringify"
)
type Color [colorLength]byte
func NewColor(color string) (result Color) {
......@@ -9,7 +15,11 @@ func NewColor(color string) (result Color) {
}
func (color Color) String() string {
return "color"
if utf8.Valid(color[:]) {
return string(color[:])
} else {
return stringify.SliceOfBytes(color[:])
}
}
const colorLength = 8
......@@ -21,20 +21,27 @@ func NewLedgerState(storageId string) *LedgerState {
}
func (ledgerState *LedgerState) AddTransferOutput(transferHash TransferHash, addressHash AddressHash, balances ...*ColoredBalance) *LedgerState {
ledgerState.transferOutputs.Store(NewTransferOutput(ledgerState, MAIN_REALITY_ID, transferHash, addressHash, balances...)).Release()
ledgerState.storeTransferOutput(NewTransferOutput(ledgerState, MAIN_REALITY_ID, transferHash, addressHash, balances...)).Release()
return ledgerState
}
func (ledgerState *LedgerState) GetTransferOutput(transferOutputReference *TransferOutputReference) (*objectstorage.CachedObject, error) {
cachedTransferOutput, err := ledgerState.transferOutputs.Load(transferOutputReference.GetStorageKey())
if err == nil && cachedTransferOutput.Exists() {
func (ledgerState *LedgerState) storeTransferOutput(transferOutput *TransferOutput) *objectstorage.CachedObject {
return ledgerState.transferOutputs.Store(transferOutput)
}
func (ledgerState *LedgerState) GetTransferOutput(transferOutputReference *TransferOutputReference) *objectstorage.CachedObject {
if cachedTransferOutput, err := ledgerState.transferOutputs.Load(transferOutputReference.GetStorageKey()); err != nil {
panic(err)
} else {
if cachedTransferOutput.Exists() {
if transferOutput := cachedTransferOutput.Get().(*TransferOutput); transferOutput != nil {
transferOutput.ledgerState = ledgerState
}
}
return cachedTransferOutput, err
return cachedTransferOutput
}
}
func (ledgerState *LedgerState) CreateReality(id RealityId) {
......
package ledgerstate
import (
"fmt"
"testing"
"github.com/iotaledger/goshimmer/packages/objectstorage"
......@@ -40,5 +41,7 @@ func Test(t *testing.T) {
)
reality.BookTransfer(transfer)
fmt.Println(ledgerState.GetTransferOutput(NewTransferOutputReference(transferHash2, addressHash3)).Get())
})
}
......@@ -2,7 +2,6 @@ package ledgerstate
import (
"encoding/binary"
"fmt"
"github.com/iotaledger/goshimmer/packages/stringify"
......@@ -24,7 +23,11 @@ func newReality(id RealityId, parentRealities ...RealityId) *Reality {
}
func (reality *Reality) BookTransfer(transfer *Transfer) {
fmt.Println("BOOK")
// process outputs
for addressHash, coloredBalances := range transfer.GetOutputs() {
createdTransferOutput := NewTransferOutput(reality.ledgerState, reality.id, transfer.GetHash(), addressHash, coloredBalances...)
reality.ledgerState.storeTransferOutput(createdTransferOutput).Release()
}
}
func (reality *Reality) String() string {
......
......@@ -3,17 +3,21 @@ package ledgerstate
type Transfer struct {
hash TransferHash
inputs []*TransferOutputReference
outputs map[AddressHash]map[Color]*ColoredBalance
outputs map[AddressHash][]*ColoredBalance
}
func NewTransfer(transferHash TransferHash) *Transfer {
return &Transfer{
hash: transferHash,
inputs: make([]*TransferOutputReference, 0),
outputs: make(map[AddressHash]map[Color]*ColoredBalance),
outputs: make(map[AddressHash][]*ColoredBalance),
}
}
func (transfer *Transfer) GetHash() TransferHash {
return transfer.hash
}
func (transfer *Transfer) AddInput(input *TransferOutputReference) *Transfer {
transfer.inputs = append(transfer.inputs, input)
......@@ -21,14 +25,15 @@ func (transfer *Transfer) AddInput(input *TransferOutputReference) *Transfer {
}
func (transfer *Transfer) AddOutput(address AddressHash, balance *ColoredBalance) *Transfer {
addressEntry, addressExists := transfer.outputs[address]
if !addressExists {
addressEntry = make(map[Color]*ColoredBalance)
transfer.outputs[address] = addressEntry
if _, addressExists := transfer.outputs[address]; !addressExists {
transfer.outputs[address] = make([]*ColoredBalance, 0)
}
addressEntry[balance.GetColor()] = balance
transfer.outputs[address] = append(transfer.outputs[address], balance)
return transfer
}
func (transfer *Transfer) GetOutputs() map[AddressHash][]*ColoredBalance {
return transfer.outputs
}
package ledgerstate
import (
"encoding/binary"
"github.com/iotaledger/goshimmer/packages/objectstorage"
"github.com/iotaledger/goshimmer/packages/stringify"
)
......@@ -45,19 +47,48 @@ func (transferOutput *TransferOutput) GetId() []byte {
func (transferOutput *TransferOutput) Update(other objectstorage.StorableObject) {}
func (transferOutput *TransferOutput) Marshal() ([]byte, error) {
return transferOutput.realityId[:], nil
balanceCount := len(transferOutput.balances)
coloredBalanceLength := colorLength + 64
result := make([]byte, realityIdLength+balanceCount*coloredBalanceLength)
copy(result[0:], transferOutput.realityId[:])
binary.LittleEndian.PutUint32(result[realityIdLength:], uint32(balanceCount))
for i := 0; i < balanceCount; i++ {
copy(result[realityIdLength+4+i*coloredBalanceLength:], transferOutput.balances[i].color[:colorLength])
binary.LittleEndian.PutUint64(result[realityIdLength+4+i*coloredBalanceLength+colorLength:], transferOutput.balances[i].balance)
}
return result, nil
}
func (transferOutput *TransferOutput) Unmarshal(key []byte, serializedObject []byte) (objectstorage.StorableObject, error) {
result := &TransferOutput{
id: key,
balances: transferOutput.unmarshalBalances(serializedObject[realityIdLength:]),
}
copy(result.transferHash[:], key[:transferHashLength])
copy(result.addressHash[:], key[transferHashLength:transferHashLength+addressHashLength])
copy(result.realityId[:], serializedObject)
copy(result.realityId[:], serializedObject[:realityIdLength])
return result, nil
}
func (transferOutput *TransferOutput) unmarshalBalances(serializedBalances []byte) []*ColoredBalance {
balanceCount := int(binary.LittleEndian.Uint32(serializedBalances))
coloredBalanceLength := colorLength + 64
balances := make([]*ColoredBalance, balanceCount)
for i := 0; i < balanceCount; i++ {
color := Color{}
copy(color[:], serializedBalances[4+i*coloredBalanceLength:])
balances[i] = NewColoredBalance(color, binary.LittleEndian.Uint64(serializedBalances[4+i*coloredBalanceLength+colorLength:]))
}
return balances
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
......@@ -18,8 +18,6 @@ func Interface(value interface{}) string {
return Int(typeCastedValue)
case uint64:
return strconv.FormatUint(typeCastedValue, 10)
case fmt.Stringer:
return value.(fmt.Stringer).String()
case reflect.Value:
switch typeCastedValue.Kind() {
case reflect.Slice:
......@@ -37,6 +35,8 @@ func Interface(value interface{}) string {
default:
panic("undefined reflect type: " + typeCastedValue.Kind().String())
}
case fmt.Stringer:
return value.(fmt.Stringer).String()
default:
value := reflect.ValueOf(value)
switch value.Kind() {
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment