Skip to content
Snippets Groups Projects
Select Git revision
  • 743ca97d526340043d3eb0d4c46f3e11efb52959
  • without_tipselection default
  • develop protected
  • fix/grafana-local-dashboard
  • wasp
  • fix/dashboard-explorer-freeze
  • master
  • feat/timerqueue
  • test/sync_debug_and_650
  • feat/sync_revamp_inv
  • wip/sync
  • tool/db-recovery
  • portcheck/fix
  • fix/synchronization
  • feat/new-dashboard-analysis
  • feat/refactored-analysis-dashboard
  • feat/new-analysis-dashboard
  • test/demo-prometheus-fpc
  • prometheus_metrics
  • wip/analysis-server
  • merge/fpc-test-value-transfer
  • v0.2.2
  • v0.2.1
  • v0.2.0
  • v0.1.3
  • v0.1.2
  • v0.1.1
  • v0.1.0
28 results

transfer_output.go

Blame
  • user avatar
    Hans Moog authored
    743ca97d
    History
    transfer_output.go 3.38 KiB
    package ledgerstate
    
    import (
    	"encoding/binary"
    
    	"github.com/iotaledger/goshimmer/packages/objectstorage"
    	"github.com/iotaledger/goshimmer/packages/stringify"
    )
    
    type TransferOutput struct {
    	transferHash TransferHash
    	addressHash  AddressHash
    	balances     []*ColoredBalance
    	realityId    RealityId
    
    	storageKey  []byte
    	ledgerState *LedgerState
    }
    
    func NewTransferOutput(ledgerState *LedgerState, realityId RealityId, transferHash TransferHash, addressHash AddressHash, balances ...*ColoredBalance) *TransferOutput {
    	return &TransferOutput{
    		transferHash: transferHash,
    		addressHash:  addressHash,
    		balances:     balances,
    		realityId:    realityId,
    
    		storageKey:  append(transferHash[:], addressHash[:]...),
    		ledgerState: ledgerState,
    	}
    }
    
    func (transferOutput *TransferOutput) GetBalances() []*ColoredBalance {
    	return transferOutput.balances
    }
    
    func (transferOutput *TransferOutput) String() string {
    	return stringify.Struct("TransferOutput",
    		stringify.StructField("transferHash", transferOutput.transferHash.String()),
    		stringify.StructField("addressHash", transferOutput.addressHash.String()),
    		stringify.StructField("balances", transferOutput.balances),
    		stringify.StructField("realityId", transferOutput.realityId.String()),
    	)
    }
    
    // region support object storage ///////////////////////////////////////////////////////////////////////////////////////
    
    func (transferOutput *TransferOutput) GetStorageKey() []byte {
    	return transferOutput.storageKey
    }
    
    func (transferOutput *TransferOutput) Update(other objectstorage.StorableObject) {}
    
    func (transferOutput *TransferOutput) MarshalBinary() ([]byte, error) {
    	balanceCount := len(transferOutput.balances)
    
    	result := make([]byte, realityIdLength+4+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) UnmarshalBinary(serializedObject []byte) error {
    	if err := transferOutput.transferHash.UnmarshalBinary(transferOutput.storageKey[:transferHashLength]); err != nil {
    		return err
    	}
    
    	if err := transferOutput.addressHash.UnmarshalBinary(transferOutput.storageKey[transferHashLength:]); err != nil {
    		return err
    	}
    
    	if err := transferOutput.realityId.UnmarshalBinary(serializedObject[:realityIdLength]); err != nil {
    		return err
    	}
    
    	if balances, err := transferOutput.unmarshalBalances(serializedObject[realityIdLength:]); err != nil {
    		return err
    	} else {
    		transferOutput.balances = balances
    	}
    
    	return nil
    }
    
    func (transferOutput *TransferOutput) unmarshalBalances(serializedBalances []byte) ([]*ColoredBalance, error) {
    	balanceCount := int(binary.LittleEndian.Uint32(serializedBalances))
    
    	balances := make([]*ColoredBalance, balanceCount)
    	for i := 0; i < balanceCount; i++ {
    		coloredBalance := ColoredBalance{}
    		if err := coloredBalance.UnmarshalBinary(serializedBalances[4+i*coloredBalanceLength:]); err != nil {
    			return nil, err
    		}
    
    		balances[i] = &coloredBalance
    	}
    
    	return balances, nil
    }
    
    // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////