Feat: booking funds is now possible

packages/ledgerstate/address.go

@@ -2,16 +2,27 @@ package ledgerstate
 
 type Address struct {
 	hash                   AddressHash
-	unspentTransferOutputs map[TransferHash]*ColoredBalance
+	unspentTransferOutputs TransferOutputs
 }
 
 func NewAddress(hash AddressHash) *Address {
 	return &Address{
 		hash:                   hash,
+		unspentTransferOutputs: make(TransferOutputs),
 	}
 }
 
-func (address *Address) GetUnspentTransferOutputs() map[TransferHash]*ColoredBalance {
+func (address *Address) GetHash() AddressHash {
+	return address.hash
+}
+
+func (address *Address) AddTransferOutput(transferOutput *TransferOutput) *Address {
+	address.unspentTransferOutputs[transferOutput.GetHash()] = transferOutput
+
+	return address
+}
+
+func (address *Address) GetUnspentTransferOutputs() TransferOutputs {
 	return address.unspentTransferOutputs
 }
 

packages/ledgerstate/colored_balance.go

 package ledgerstate
 
+import (
+	"strconv"
+)
+
 type ColoredBalance struct {
-	colorHash ColorHash
+	color   ColorHash
 	balance uint64
 }
+
+func NewColoredBalance(color ColorHash, balance uint64) *ColoredBalance {
+	return &ColoredBalance{
+		color:   color,
+		balance: balance,
+	}
+}
+
+func (coloredBalance *ColoredBalance) String() string {
+	return "ColoredBalance(\"" + coloredBalance.color + "\", " + strconv.FormatUint(coloredBalance.balance, 10) + ")"
+}

packages/ledgerstate/ledgerstate.go

@@ -12,8 +12,14 @@ func NewLedgerState() *LedgerState {
 	}
 }
 
-func (ledgerState *LedgerState) GetUnspentTransferOutputs(address AddressHash, includedSubRealities ...TransferHash) (result map[TransferHash]*ColoredBalance) {
-	result = make(map[TransferHash]*ColoredBalance)
+func (ledgerState *LedgerState) AddAddress(address *Address) *LedgerState {
+	ledgerState.mainReality.SetAddress(address)
+
+	return ledgerState
+}
+
+func (ledgerState *LedgerState) GetUnspentTransferOutputs(address AddressHash, includedSubRealities ...TransferHash) (result TransferOutputs) {
+	result = make(TransferOutputs)
 
 	for _, reality := range ledgerState.getRealities(includedSubRealities...) {
 		if address := reality.GetAddress(address); address.Exists() {

packages/ledgerstate/ledgerstate_test.go

@@ -8,7 +8,11 @@ import (
 func TestLedgerState_GetUnspentTransferOutputs(t *testing.T) {
 	ledgerState := NewLedgerState()
 
-	NewAddress("ABC")
+	ledgerState.AddAddress(
+		NewAddress("ABC").AddTransferOutput(
+			NewTransferOutput("12").SetColoredBalance("I", 144).SetColoredBalance("A", 77),
+		),
+	)
 
 	fmt.Println(ledgerState.GetUnspentTransferOutputs("ABC"))
 }

packages/ledgerstate/reality.go

@@ -10,6 +10,12 @@ func NewReality() *Reality {
 	}
 }
 
+func (reality *Reality) SetAddress(address *Address) *Reality {
+	reality.addresses[address.GetHash()] = address
+
+	return reality
+}
+
 func (reality *Reality) GetAddress(address AddressHash) *Address {
 	return reality.addresses[address]
 }

packages/ledgerstate/transfer_output.go

 package ledgerstate
 
-type TransferOutput struct{}
+type TransferOutput struct {
+	hash            TransferHash
+	coloredBalances map[ColorHash]*ColoredBalance
+}
+
+func NewTransferOutput(hash TransferHash) *TransferOutput {
+	return &TransferOutput{
+		hash:            hash,
+		coloredBalances: make(map[ColorHash]*ColoredBalance),
+	}
+}
+
+func (transferOutput *TransferOutput) SetColoredBalance(color ColorHash, balance uint64) *TransferOutput {
+	transferOutput.coloredBalances[color] = NewColoredBalance(color, balance)
+
+	return transferOutput
+}
+
+func (transferOutput *TransferOutput) GetHash() TransferHash {
+	return transferOutput.hash
+}
+
+func (transferOutput *TransferOutput) String() (result string) {
+	result = "TransferOutput(" + transferOutput.hash + ") {"
+
+	if len(transferOutput.coloredBalances) >= 1 {
+		for _, coloredBalance := range transferOutput.coloredBalances {
+			result += "\n    " + coloredBalance.String()
+		}
+
+		result += "\n"
+	}
+
+	result += "}"
+
+	return
+}

packages/ledgerstate/types.go

@@ -5,3 +5,13 @@ type AddressHash = string
 type TransferHash = string
 
 type ColorHash = string
+
+type TransferOutputs map[TransferHash]*TransferOutput
+
+func (transferOutputs TransferOutputs) String() (result string) {
+	for _, transferOutput := range transferOutputs {
+		result += transferOutput.String() + " "
+	}
+
+	return
+}