diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10ecf91a5d..e0a4f59a4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,19 @@
+# v0.6.0 - 2021-05-19
+* Add first iteration of the tokenization framework
+* Add aMana refresher
+* Add CORS to middleware Dashboard server
+* Allow specifying parents count when issuing messages
+* Move PoW for Faucet requests to client
+* Remove Faucet requests from Node's Dashboard
+* Improve cli-wallet
+* Improve APIs
+* Improve integration tests
+* Refactor statement remote logging
+* Display full messageID in explorer feed
+* Update JS dependencies
+* Update documentation
+* **Breaking**: bumps network and database versions
+
# v0.5.9 - 2021-05-11
* Replace sync beacons with Tangle Time
* Fix approval weight manager persistence
diff --git a/client/faucet.go b/client/faucet.go
index 41f789d28f..1f6e1b9b61 100644
--- a/client/faucet.go
+++ b/client/faucet.go
@@ -1,8 +1,18 @@
package client
import (
+ "context"
+ "crypto"
"net/http"
+ "github.com/cockroachdb/errors"
+ "github.com/iotaledger/hive.go/identity"
+ "github.com/mr-tron/base58"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/mana"
+ "github.com/iotaledger/goshimmer/packages/pow"
+ "github.com/iotaledger/goshimmer/plugins/faucet"
"github.com/iotaledger/goshimmer/plugins/webapi/jsonmodels"
)
@@ -10,17 +20,59 @@ const (
routeFaucet = "faucet"
)
+var (
+ defaultPOWTarget = 25
+ powWorker = pow.New(crypto.BLAKE2b_512, 1)
+)
+
// SendFaucetRequest requests funds from faucet nodes by sending a faucet request payload message.
-func (api *GoShimmerAPI) SendFaucetRequest(base58EncodedAddr string, pledgeIDs ...string) (*jsonmodels.FaucetResponse, error) {
- aManaPledgeID, cManaPledgeID := "", ""
+func (api *GoShimmerAPI) SendFaucetRequest(base58EncodedAddr string, powTarget int, pledgeIDs ...string) (*jsonmodels.FaucetResponse, error) {
+ var aManaPledgeID identity.ID
+ var cManaPledgeID identity.ID
if len(pledgeIDs) > 1 {
- aManaPledgeID, cManaPledgeID = pledgeIDs[0], pledgeIDs[1]
+ aManaPledgeIDFromString, err := mana.IDFromStr(pledgeIDs[0])
+ if err != nil {
+ aManaPledgeID = aManaPledgeIDFromString
+ }
+ cManaPledgeIDFromString, err := mana.IDFromStr(pledgeIDs[1])
+ if err != nil {
+ cManaPledgeID = cManaPledgeIDFromString
+ }
+ }
+
+ address, err := ledgerstate.AddressFromBase58EncodedString(base58EncodedAddr)
+ if err != nil {
+ return nil, errors.Errorf("could not decode address from string: %w", err)
+ }
+
+ nonce, err := computeFaucetPoW(address, aManaPledgeID, cManaPledgeID, powTarget)
+ if err != nil {
+ return nil, errors.Errorf("could not compute faucet PoW: %w", err)
}
+
res := &jsonmodels.FaucetResponse{}
if err := api.do(http.MethodPost, routeFaucet,
- &jsonmodels.FaucetRequest{Address: base58EncodedAddr, AccessManaPledgeID: aManaPledgeID, ConsensusManaPledgeID: cManaPledgeID}, res); err != nil {
+ &jsonmodels.FaucetRequest{
+ Address: base58EncodedAddr,
+ AccessManaPledgeID: base58.Encode(aManaPledgeID.Bytes()),
+ ConsensusManaPledgeID: base58.Encode(cManaPledgeID.Bytes()),
+ Nonce: nonce,
+ }, res); err != nil {
return nil, err
}
return res, nil
}
+
+func computeFaucetPoW(address ledgerstate.Address, aManaPledgeID, cManaPledgeID identity.ID, powTarget int) (nonce uint64, err error) {
+ if powTarget < 0 {
+ powTarget = defaultPOWTarget
+ }
+
+ faucetRequest := faucet.NewRequest(address, aManaPledgeID, cManaPledgeID, 0)
+
+ objectBytes := faucetRequest.Bytes()
+ powRelevantBytes := objectBytes[:len(objectBytes)-pow.NonceBytes]
+
+ return powWorker.Mine(context.Background(), powRelevantBytes, powTarget)
+}
diff --git a/client/ledgerstate.go b/client/ledgerstate.go
new file mode 100644
index 0000000000..353d47edf6
--- /dev/null
+++ b/client/ledgerstate.go
@@ -0,0 +1,192 @@
+package client
+
+import (
+ "net/http"
+ "strings"
+
+ json_models "github.com/iotaledger/goshimmer/plugins/webapi/jsonmodels"
+)
+
+const (
+ // basic routes
+ routeGetAddresses = "ledgerstate/addresses/"
+ routeGetBranches = "ledgerstate/branches/"
+ routeGetOutputs = "ledgerstate/outputs/"
+ routeGetTransactions = "ledgerstate/transactions/"
+ routePostTransactions = "ledgerstate/transactions"
+
+ // route path modifiers
+ pathUnspentOutputs = "/unspentOutputs"
+ pathChildren = "/children"
+ pathConflicts = "/conflicts"
+ pathConsumers = "/consumers"
+ pathMetadata = "/metadata"
+ pathInclusionState = "/inclusionState"
+ pathConsensus = "/consensus"
+ pathAttachments = "/attachments"
+)
+
+// GetAddressOutputs gets the spent and unspent outputs of an address.
+func (api *GoShimmerAPI) GetAddressOutputs(base58EncodedAddress string) (*json_models.GetAddressResponse, error) {
+ res := &json_models.GetAddressResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetAddresses, base58EncodedAddress}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetAddressUnspentOutputs gets the unspent outputs of an address.
+func (api *GoShimmerAPI) GetAddressUnspentOutputs(base58EncodedAddress string) (*json_models.GetAddressResponse, error) {
+ res := &json_models.GetAddressResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetAddresses, base58EncodedAddress, pathUnspentOutputs}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// PostAddressUnspentOutputs gets the unspent outputs of several addresses.
+func (api *GoShimmerAPI) PostAddressUnspentOutputs(base58EncodedAddresses []string) (*json_models.PostAddressesUnspentOutputsResponse, error) {
+ res := &json_models.PostAddressesUnspentOutputsResponse{}
+ if err := api.do(http.MethodPost, func() string {
+ return strings.Join([]string{routeGetAddresses, "unspentOutputs"}, "")
+ }(), &json_models.PostAddressesUnspentOutputsRequest{Addresses: base58EncodedAddresses}, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetBranch gets the branch information.
+func (api *GoShimmerAPI) GetBranch(base58EncodedBranchID string) (*json_models.Branch, error) {
+ res := &json_models.Branch{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetBranches, base58EncodedBranchID}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetBranchChildren gets the children of a branch.
+func (api *GoShimmerAPI) GetBranchChildren(base58EncodedBranchID string) (*json_models.GetBranchChildrenResponse, error) {
+ res := &json_models.GetBranchChildrenResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetBranches, base58EncodedBranchID, pathChildren}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetBranchConflicts gets the conflict branches of a branch.
+func (api *GoShimmerAPI) GetBranchConflicts(base58EncodedBranchID string) (*json_models.GetBranchConflictsResponse, error) {
+ res := &json_models.GetBranchConflictsResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetBranches, base58EncodedBranchID, pathConflicts}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetOutput gets the output corresponding to OutputID.
+func (api *GoShimmerAPI) GetOutput(base58EncodedOutputID string) (*json_models.Output, error) {
+ res := &json_models.Output{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetOutputs, base58EncodedOutputID}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetOutputConsumers gets the consumers of the output corresponding to OutputID.
+func (api *GoShimmerAPI) GetOutputConsumers(base58EncodedOutputID string) (*json_models.GetOutputConsumersResponse, error) {
+ res := &json_models.GetOutputConsumersResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetOutputs, base58EncodedOutputID, pathConsumers}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetOutputMetadata gets the metadata of the output corresponding to OutputID.
+func (api *GoShimmerAPI) GetOutputMetadata(base58EncodedOutputID string) (*json_models.OutputMetadata, error) {
+ res := &json_models.OutputMetadata{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetOutputs, base58EncodedOutputID, pathMetadata}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetTransaction gets the transaction of the corresponding to TransactionID.
+func (api *GoShimmerAPI) GetTransaction(base58EncodedTransactionID string) (*json_models.Transaction, error) {
+ res := &json_models.Transaction{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetTransactions, base58EncodedTransactionID}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetTransactionMetadata gets metadata of the transaction corresponding to TransactionID.
+func (api *GoShimmerAPI) GetTransactionMetadata(base58EncodedTransactionID string) (*json_models.TransactionMetadata, error) {
+ res := &json_models.TransactionMetadata{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetTransactions, base58EncodedTransactionID, pathMetadata}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetTransactionInclusionState gets inclusion state of the transaction corresponding to TransactionID.
+func (api *GoShimmerAPI) GetTransactionInclusionState(base58EncodedTransactionID string) (*json_models.TransactionInclusionState, error) {
+ res := &json_models.TransactionInclusionState{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetTransactions, base58EncodedTransactionID, pathInclusionState}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetTransactionConsensusMetadata gets the consensus metadata of the transaction corresponding to TransactionID.
+func (api *GoShimmerAPI) GetTransactionConsensusMetadata(base58EncodedTransactionID string) (*json_models.TransactionConsensusMetadata, error) {
+ res := &json_models.TransactionConsensusMetadata{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetTransactions, base58EncodedTransactionID, pathConsensus}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// GetTransactionAttachments gets the attachments (messageIDs) of the transaction corresponding to TransactionID.
+func (api *GoShimmerAPI) GetTransactionAttachments(base58EncodedTransactionID string) (*json_models.GetTransactionAttachmentsResponse, error) {
+ res := &json_models.GetTransactionAttachmentsResponse{}
+ if err := api.do(http.MethodGet, func() string {
+ return strings.Join([]string{routeGetTransactions, base58EncodedTransactionID, pathAttachments}, "")
+ }(), nil, res); err != nil {
+ return nil, err
+ }
+ return res, nil
+}
+
+// PostTransaction sends the transaction(bytes) to the Tangle and returns its transaction ID.
+func (api *GoShimmerAPI) PostTransaction(transactionBytes []byte) (*json_models.PostTransactionResponse, error) {
+ res := &json_models.PostTransactionResponse{}
+ if err := api.do(http.MethodPost, routePostTransactions,
+ &json_models.PostTransactionRequest{TransactionBytes: transactionBytes}, res); err != nil {
+ return nil, err
+ }
+
+ return res, nil
+}
diff --git a/client/mana.go b/client/mana.go
index 1367f17cdf..3dc8fe47b8 100644
--- a/client/mana.go
+++ b/client/mana.go
@@ -18,6 +18,7 @@ const (
routePending = "mana/pending"
routePastConsensusVector = "mana/consensus/past"
routePastConsensusEventLogs = "mana/consensus/logs"
+ routeAllowedPledgeNodeIDs = "mana/allowedManaPledge"
)
// GetOwnMana returns the access and consensus mana of the node this api client is communicating with.
@@ -166,3 +167,13 @@ func (api *GoShimmerAPI) GetConsensusEventLogs(nodeIDs []string) (*jsonmodels.Ge
}
return res, nil
}
+
+// GetAllowedManaPledgeNodeIDs returns the list of allowed mana pledge IDs.
+func (api *GoShimmerAPI) GetAllowedManaPledgeNodeIDs() (*jsonmodels.AllowedManaPledgeResponse, error) {
+ res := &jsonmodels.AllowedManaPledgeResponse{}
+ if err := api.do(http.MethodGet, routeAllowedPledgeNodeIDs, nil, res); err != nil {
+ return nil, err
+ }
+
+ return res, nil
+}
diff --git a/client/value.go b/client/value.go
index e356a7f691..e5f3f80aac 100644
--- a/client/value.go
+++ b/client/value.go
@@ -8,12 +8,11 @@ import (
)
const (
- routeAttachments = "value/attachments"
- routeGetTxnByID = "value/transactionByID"
- routeSendTxn = "value/sendTransaction"
- routeSendTxnByJSON = "value/sendTransactionByJson"
- routeUnspentOutputs = "value/unspentOutputs"
- routeAllowedPledgeNodeIDs = "value/allowedManaPledge"
+ routeAttachments = "value/attachments"
+ routeGetTxnByID = "value/transactionByID"
+ routeSendTxn = "value/sendTransaction"
+ routeSendTxnByJSON = "value/sendTransactionByJson"
+ routeUnspentOutputs = "value/unspentOutputs"
)
// GetAttachments gets the attachments of a transaction ID
@@ -79,13 +78,3 @@ func (api *GoShimmerAPI) SendTransactionByJSON(txn value.SendTransactionByJSONRe
return res.TransactionID, nil
}
-
-// GetAllowedManaPledgeNodeIDs returns the list of allowed mana pledge IDs.
-func (api *GoShimmerAPI) GetAllowedManaPledgeNodeIDs() (*value.AllowedManaPledgeResponse, error) {
- res := &value.AllowedManaPledgeResponse{}
- if err := api.do(http.MethodGet, routeAllowedPledgeNodeIDs, nil, res); err != nil {
- return nil, err
- }
-
- return res, nil
-}
diff --git a/client/wallet/addressmanager.go b/client/wallet/address_manager.go
similarity index 98%
rename from client/wallet/addressmanager.go
rename to client/wallet/address_manager.go
index 5463062489..daffc63e02 100644
--- a/client/wallet/addressmanager.go
+++ b/client/wallet/address_manager.go
@@ -155,7 +155,7 @@ func (addressManager *AddressManager) updateFirstUnspentAddressIndex() {
}
}
-// updateLastUnspentAddressIndex searches for the first unspent address and updates the lastUnspentAddressIndex.
+// updateLastUnspentAddressIndex searches for the last unspent address and updates the lastUnspentAddressIndex.
func (addressManager *AddressManager) updateLastUnspentAddressIndex() {
// search for last unspent address
for i := addressManager.lastUnspentAddressIndex; true; i-- {
diff --git a/client/wallet/balances.go b/client/wallet/balances.go
new file mode 100644
index 0000000000..62a1af093c
--- /dev/null
+++ b/client/wallet/balances.go
@@ -0,0 +1,24 @@
+package wallet
+
+import (
+ "sort"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// TimedBalance represents a balance that is time dependent.
+type TimedBalance struct {
+ Balance map[ledgerstate.Color]uint64
+ Time time.Time
+}
+
+// TimedBalanceSlice is a slice containing TimedBalances.
+type TimedBalanceSlice []*TimedBalance
+
+// Sort sorts the balances based on their Time.
+func (t TimedBalanceSlice) Sort() {
+ sort.Slice(t, func(i, j int) bool {
+ return t[i].Time.Before(t[j].Time)
+ })
+}
diff --git a/client/wallet/connector.go b/client/wallet/connector.go
index 25b1418eee..9fc4556f22 100644
--- a/client/wallet/connector.go
+++ b/client/wallet/connector.go
@@ -9,8 +9,10 @@ import (
// Connector represents an interface that defines how the wallet interacts with the network. A wallet can either be used
// locally on a server or it can connect remotely using the web API.
type Connector interface {
- UnspentOutputs(addresses ...address.Address) (unspentOutputs map[address.Address]map[ledgerstate.OutputID]*Output, err error)
+ UnspentOutputs(addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID, err error)
SendTransaction(transaction *ledgerstate.Transaction) (err error)
- RequestFaucetFunds(address address.Address) (err error)
+ RequestFaucetFunds(address address.Address, powTarget int) (err error)
GetAllowedPledgeIDs() (pledgeIDMap map[mana.Type][]string, err error)
+ GetTransactionInclusionState(txID ledgerstate.TransactionID) (inc ledgerstate.InclusionState, err error)
+ GetUnspentAliasOutput(address *ledgerstate.AliasAddress) (output *ledgerstate.AliasOutput, err error)
}
diff --git a/client/wallet/options.go b/client/wallet/options.go
index f78c50ce64..8e1f0f9b7c 100644
--- a/client/wallet/options.go
+++ b/client/wallet/options.go
@@ -33,6 +33,35 @@ func ReusableAddress(enabled bool) Option {
}
}
+// FaucetPowDifficulty configures the wallet with the faucet's target PoW difficulty
+func FaucetPowDifficulty(powTarget int) Option {
+ return func(wallet *Wallet) {
+ wallet.faucetPowDifficulty = powTarget
+ }
+}
+
+// ConfirmationPollingInterval defines how often the wallet polls the node for confirmation info.
+func ConfirmationPollingInterval(interval int) Option {
+ return func(wallet *Wallet) {
+ if interval < 0 {
+ wallet.ConfirmationPollInterval = DefaultPollingInterval
+ } else {
+ wallet.ConfirmationPollInterval = interval
+ }
+ }
+}
+
+// ConfirmationTimeout defines the timeout for waiting for tx confirmation.
+func ConfirmationTimeout(timeout int) Option {
+ return func(wallet *Wallet) {
+ if timeout < 0 {
+ wallet.ConfirmationPollInterval = DefaultConfirmationTimeout
+ } else {
+ wallet.ConfirmationPollInterval = timeout
+ }
+ }
+}
+
// GenericConnector allows us to provide a generic connector to the wallet. It can be used to mock the behavior of a
// real connector in tests or to provide new connection methods for nodes.
func GenericConnector(connector Connector) Option {
diff --git a/client/wallet/output.go b/client/wallet/output.go
index ed0d59aa17..c1c535d0bc 100644
--- a/client/wallet/output.go
+++ b/client/wallet/output.go
@@ -9,29 +9,14 @@ import (
"github.com/iotaledger/goshimmer/packages/ledgerstate"
)
-// region Output ///////////////////////////////////////////////////////////////////////////////////////////////////////
-
// Output is a wallet specific representation of an output in the IOTA network.
type Output struct {
Address address.Address
- OutputID ledgerstate.OutputID
- Balances *ledgerstate.ColoredBalances
+ Object ledgerstate.Output
InclusionState InclusionState
Metadata OutputMetadata
}
-// String returns a human-readable representation of the Output.
-func (o *Output) String() string {
- return stringify.Struct("Output",
- stringify.StructField("Address", o.Address),
- stringify.StructField("OutputID", o.OutputID),
- stringify.StructField("Balances", o.Balances),
- stringify.StructField("InclusionState", o.InclusionState),
- )
-}
-
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-
// region InclusionState ///////////////////////////////////////////////////////////////////////////////////////////////
// InclusionState is a container for the different flags of an output that define if it was accepted in the network.
@@ -85,11 +70,13 @@ func (o OutputsByID) OutputsByAddressAndOutputID() (outputsByAddressAndOutputID
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-// region OutputsByAddressAndOutputID //////////////////////////////////////////////////////////////////////////////////
-
-// OutputsByAddressAndOutputID is a collection of Outputs associated with their Address and OutputID.
type OutputsByAddressAndOutputID map[address.Address]map[ledgerstate.OutputID]*Output
+// NewAddressToOutputs creates an empty container.
+func NewAddressToOutputs() OutputsByAddressAndOutputID {
+ return make(map[address.Address]map[ledgerstate.OutputID]*Output)
+}
+
// OutputsByID returns a collection of Outputs associated with their OutputID.
func (o OutputsByAddressAndOutputID) OutputsByID() (outputsByID OutputsByID) {
outputsByID = make(OutputsByID)
@@ -102,4 +89,121 @@ func (o OutputsByAddressAndOutputID) OutputsByID() (outputsByID OutputsByID) {
return
}
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+// ValueOutputsOnly filters out non-value type outputs (aliases).
+func (o OutputsByAddressAndOutputID) ValueOutputsOnly() OutputsByAddressAndOutputID {
+ result := NewAddressToOutputs()
+ for addy, IDToOutputMap := range o {
+ for outputID, output := range IDToOutputMap {
+ switch output.Object.Type() {
+ case ledgerstate.SigLockedSingleOutputType, ledgerstate.SigLockedColoredOutputType, ledgerstate.ExtendedLockedOutputType:
+ if _, addressExists := result[addy]; !addressExists {
+ result[addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ result[addy][outputID] = output
+ }
+ }
+ }
+ return result
+}
+
+// ConditionalOutputsOnly return ExtendedLockedOutputs that are currently conditionally owned by the wallet.
+func (o OutputsByAddressAndOutputID) ConditionalOutputsOnly() OutputsByAddressAndOutputID {
+ now := time.Now()
+ result := NewAddressToOutputs()
+ for addy, IDToOutputMap := range o {
+ for outputID, output := range IDToOutputMap {
+ if output.Object.Type() == ledgerstate.ExtendedLockedOutputType {
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ _, fallbackDeadline := casted.FallbackOptions()
+ if !fallbackDeadline.IsZero() && addy.Address().Equals(casted.UnlockAddressNow(now)) {
+ if _, addressExists := result[addy]; !addressExists {
+ result[addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ result[addy][outputID] = output
+ }
+ }
+ }
+ }
+ return result
+}
+
+// AliasOutputsOnly filters out any non-alias outputs.
+func (o OutputsByAddressAndOutputID) AliasOutputsOnly() OutputsByAddressAndOutputID {
+ result := NewAddressToOutputs()
+ for addy, IDToOutputMap := range o {
+ for outputID, output := range IDToOutputMap {
+ if output.Object.Type() == ledgerstate.AliasOutputType {
+ if _, addressExists := result[addy]; !addressExists {
+ result[addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ result[addy][outputID] = output
+ }
+ }
+ }
+ return result
+}
+
+// TotalFundsInOutputs returns the total funds present in the outputs.
+func (o OutputsByAddressAndOutputID) TotalFundsInOutputs() map[ledgerstate.Color]uint64 {
+ result := make(map[ledgerstate.Color]uint64)
+ for _, IDToOutputMap := range o {
+ for _, output := range IDToOutputMap {
+ output.Object.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ result[color] += balance
+ return true
+ })
+ }
+ }
+ return result
+}
+
+// ToLedgerStateOutputs transforms all outputs in the mapping into a slice of ledgerstate outputs.
+func (o OutputsByAddressAndOutputID) ToLedgerStateOutputs() ledgerstate.Outputs {
+ outputs := ledgerstate.Outputs{}
+ for _, outputIDMapping := range o {
+ for _, output := range outputIDMapping {
+ outputs = append(outputs, output.Object)
+ }
+ }
+ return outputs
+}
+
+// OutputCount returns the number of outputs in the struct.
+func (o OutputsByAddressAndOutputID) OutputCount() int {
+ outputCount := 0
+ for _, outputIDMapping := range o {
+ for range outputIDMapping {
+ outputCount++
+ }
+ }
+ return outputCount
+}
+
+// SplitIntoChunksOfMaxInputCount splits the mapping into chunks that contain at most ledgerstate.MaxInputCount outputs.
+func (o OutputsByAddressAndOutputID) SplitIntoChunksOfMaxInputCount() []OutputsByAddressAndOutputID {
+ outputCount := o.OutputCount()
+ if outputCount <= ledgerstate.MaxInputCount {
+ // there is no need to split
+ return []OutputsByAddressAndOutputID{o}
+ }
+ result := make([]OutputsByAddressAndOutputID, outputCount/ledgerstate.MaxInputCount+1)
+ for i := range result {
+ // init all chunks
+ result[i] = NewAddressToOutputs()
+ }
+ processedCount := 0
+ chunkCount := -1
+ for addy, outputIDMapping := range o {
+ for outputID, output := range outputIDMapping {
+ if processedCount%ledgerstate.MaxInputCount == 0 {
+ chunkCount++
+ }
+ if _, has := result[chunkCount][addy]; !has {
+ result[chunkCount][addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ result[chunkCount][addy][outputID] = output
+ processedCount++
+ }
+ }
+ return result
+}
diff --git a/client/wallet/output_manager.go b/client/wallet/output_manager.go
new file mode 100644
index 0000000000..5e156b85f6
--- /dev/null
+++ b/client/wallet/output_manager.go
@@ -0,0 +1,131 @@
+package wallet
+
+import (
+ "github.com/iotaledger/goshimmer/client/wallet/packages/address"
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// OutputManager keeps track of the outputs
+type OutputManager struct {
+ addressManager *AddressManager
+ connector Connector
+ unspentOutputs OutputsByAddressAndOutputID
+}
+
+// NewUnspentOutputManager creates a new UnspentOutputManager.
+func NewUnspentOutputManager(addressManager *AddressManager, connector Connector) (outputManager *OutputManager) {
+ outputManager = &OutputManager{
+ addressManager: addressManager,
+ connector: connector,
+ unspentOutputs: NewAddressToOutputs(),
+ }
+
+ if err := outputManager.Refresh(true); err != nil {
+ panic(err)
+ }
+
+ return
+}
+
+// Refresh checks for unspent outputs on the addresses provided by address manager and updates the internal state.
+func (o *OutputManager) Refresh(includeSpentAddresses ...bool) error {
+ // go through the list of all addresses in the wallet
+ addressesToRefresh := o.addressManager.Addresses()
+
+ // fetch unspent outputs on these addresses
+ unspentOutputs, err := o.connector.UnspentOutputs(addressesToRefresh...)
+ if err != nil {
+ return err
+ }
+
+ // update addressmanager's internal store
+ for addy, IDToOutputMap := range unspentOutputs {
+ for outputID, output := range IDToOutputMap {
+ if _, addressExists := o.unspentOutputs[addy]; !addressExists {
+ o.unspentOutputs[addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ // mark the output as spent if we already marked it as spent locally
+ if existingOutput, outputExists := o.unspentOutputs[addy][outputID]; outputExists && existingOutput.InclusionState.Spent {
+ output.InclusionState.Spent = true
+ }
+ o.unspentOutputs[addy][outputID] = output
+ }
+ }
+
+ return nil
+}
+
+// UnspentOutputs returns the all outputs that have not been spent, yet.
+func (o *OutputManager) UnspentOutputs(includePending bool, addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID) {
+ return o.getOutputs(includePending, addresses...)
+}
+
+// UnspentValueOutputs returns the value type outputs that have not been spent, yet.
+func (o *OutputManager) UnspentValueOutputs(includePending bool, addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID) {
+ return o.getOutputs(includePending, addresses...).ValueOutputsOnly()
+}
+
+// UnspentConditionalOutputs returns the ExtendedLockedoutputs that are conditionally owned by the wallet right now and
+// have not been spent yet. Such outputs can be claimed by the wallet.
+func (o *OutputManager) UnspentConditionalOutputs(includePending bool, addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID) {
+ return o.getOutputs(includePending, addresses...).ConditionalOutputsOnly()
+}
+
+// UnspentAliasOutputs returns the alias type outputs that have not been spent, yet.
+func (o *OutputManager) UnspentAliasOutputs(includePending bool, addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID) {
+ return o.getOutputs(includePending, addresses...).AliasOutputsOnly()
+}
+
+func (o *OutputManager) getOutputs(includePending bool, addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID) {
+ // prepare result
+ unspentOutputs = make(map[address.Address]map[ledgerstate.OutputID]*Output)
+
+ // retrieve the list of addresses from the address manager if none was provided
+ if len(addresses) == 0 {
+ addresses = o.addressManager.Addresses()
+ }
+
+ // iterate through addresses and scan for unspent outputs
+ for _, addr := range addresses {
+ // skip the address if we have no outputs for it stored
+ unspentOutputsOnAddress, addressExistsInStoredOutputs := o.unspentOutputs[addr]
+ if !addressExistsInStoredOutputs {
+ continue
+ }
+
+ // iterate through outputs
+ for transactionID, output := range unspentOutputsOnAddress {
+ // skip spent outputs
+ if output.InclusionState.Spent {
+ continue
+ }
+ // discard non-confirmed if includePending is false
+ if !includePending && !output.InclusionState.Confirmed {
+ continue
+ }
+
+ // store unspent outputs in result
+ if _, addressExists := unspentOutputs[addr]; !addressExists {
+ unspentOutputs[addr] = make(map[ledgerstate.OutputID]*Output)
+ }
+ unspentOutputs[addr][transactionID] = output
+ }
+ }
+
+ return unspentOutputs
+}
+
+// MarkOutputSpent marks the output identified by the given parameters as spent.
+func (o *OutputManager) MarkOutputSpent(addy address.Address, outputID ledgerstate.OutputID) {
+ // abort if we try to mark an unknown output as spent
+ if _, addressExists := o.unspentOutputs[addy]; !addressExists {
+ return
+ }
+ output, outputExists := o.unspentOutputs[addy][outputID]
+ if !outputExists {
+ return
+ }
+
+ // mark output as spent
+ output.InclusionState.Spent = true
+}
diff --git a/client/wallet/packages/claimconditionaloptions/options.go b/client/wallet/packages/claimconditionaloptions/options.go
new file mode 100644
index 0000000000..f38e60e22c
--- /dev/null
+++ b/client/wallet/packages/claimconditionaloptions/options.go
@@ -0,0 +1,51 @@
+package claimconditionaloptions
+
+// ClaimConditionalFundsOption is a function that provides options.
+type ClaimConditionalFundsOption func(options *ClaimConditionalFundsOptions) error
+
+// WaitForConfirmation is an optional parameter to define if the ClaimConditionalFunds command should wait for confirmation
+// before it returns.
+func WaitForConfirmation(wait bool) ClaimConditionalFundsOption {
+ return func(options *ClaimConditionalFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for ClaimConditionalFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) ClaimConditionalFundsOption {
+ return func(options *ClaimConditionalFundsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for ClaimConditionalFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) ClaimConditionalFundsOption {
+ return func(options *ClaimConditionalFundsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ClaimConditionalFundsOptions is a struct that is used to aggregate the optional parameters in the claimConditionalFunds call.
+type ClaimConditionalFundsOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// Build builds the options.
+func Build(options ...ClaimConditionalFundsOption) (result *ClaimConditionalFundsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &ClaimConditionalFundsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ return
+}
diff --git a/client/wallet/packages/consolidateoptions/options.go b/client/wallet/packages/consolidateoptions/options.go
new file mode 100644
index 0000000000..eed96ad796
--- /dev/null
+++ b/client/wallet/packages/consolidateoptions/options.go
@@ -0,0 +1,51 @@
+package consolidateoptions
+
+// ConsolidateFundsOption is a function that provides options.
+type ConsolidateFundsOption func(options *ConsolidateFundsOptions) error
+
+// WaitForConfirmation is an optional parameter to define if the consolidateFunds command should wait for confirmation
+// before it returns.
+func WaitForConfirmation(wait bool) ConsolidateFundsOption {
+ return func(options *ConsolidateFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) ConsolidateFundsOption {
+ return func(options *ConsolidateFundsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) ConsolidateFundsOption {
+ return func(options *ConsolidateFundsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsolidateFundsOptions is a struct that is used to aggregate the optional parameters in the consolidateFunds call.
+type ConsolidateFundsOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// Build build the options.
+func Build(options ...ConsolidateFundsOption) (result *ConsolidateFundsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &ConsolidateFundsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ return
+}
diff --git a/client/wallet/packages/createnftoptions/options.go b/client/wallet/packages/createnftoptions/options.go
new file mode 100644
index 0000000000..0af950cae3
--- /dev/null
+++ b/client/wallet/packages/createnftoptions/options.go
@@ -0,0 +1,86 @@
+package createnftoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// CreateNFTOption is a function that provides options.
+type CreateNFTOption func(options *CreateNFTOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) CreateNFTOption {
+ return func(options *CreateNFTOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// InitialBalance sets the initial balance of the newly created NFT.
+func InitialBalance(balance map[ledgerstate.Color]uint64) CreateNFTOption {
+ return func(options *CreateNFTOptions) error {
+ if balance[ledgerstate.ColorIOTA] < ledgerstate.DustThresholdAliasOutputIOTA {
+ return errors.Errorf("NFT must have at least %d IOTA balance", ledgerstate.DustThresholdAliasOutputIOTA)
+ }
+ options.InitialBalance = balance
+ return nil
+ }
+}
+
+// ImmutableData sets the immutable data field of the freshly created NFT.
+func ImmutableData(data []byte) CreateNFTOption {
+ return func(options *CreateNFTOptions) error {
+ if data == nil {
+ return errors.Errorf("empty data supplied for immutable data")
+ }
+ if len(data) > ledgerstate.MaxOutputPayloadSize {
+ return errors.Errorf("provided immutable data size %d is greater than maximum allowed %d", len(data), ledgerstate.MaxOutputPayloadSize)
+ }
+ options.ImmutableData = data
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) CreateNFTOption {
+ return func(options *CreateNFTOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) CreateNFTOption {
+ return func(options *CreateNFTOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// CreateNFTOptions is a struct that is used to aggregate the optional parameters in the CreateNFT call.
+type CreateNFTOptions struct {
+ InitialBalance map[ledgerstate.Color]uint64
+ ImmutableData []byte
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// Build builds the options.
+func Build(options ...CreateNFTOption) (result *CreateNFTOptions, err error) {
+ // create options to collect the arguments provided
+ result = &CreateNFTOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+ if result.InitialBalance == nil {
+ result.InitialBalance = map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: ledgerstate.DustThresholdAliasOutputIOTA}
+ }
+
+ return
+}
diff --git a/client/wallet/packages/delegateoptions/options.go b/client/wallet/packages/delegateoptions/options.go
new file mode 100644
index 0000000000..e7292bbc7d
--- /dev/null
+++ b/client/wallet/packages/delegateoptions/options.go
@@ -0,0 +1,142 @@
+package delegateoptions
+
+import (
+ "time"
+
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/client/wallet/packages/address"
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// DelegateFundsOption is the type for the optional parameters for the DelegateFunds call.
+type DelegateFundsOption func(*DelegateFundsOptions) error
+
+// Destination is an option for the SendFunds call that defines a destination for funds that are supposed to be moved.
+func Destination(addr address.Address, balance map[ledgerstate.Color]uint64) DelegateFundsOption {
+ // return an error if the IOTA amount is less
+ if balance[ledgerstate.ColorIOTA] < ledgerstate.DustThresholdAliasOutputIOTA {
+ return optionError(errors.Errorf("the IOTA amount provided in the destination needs to be larger than %d", ledgerstate.DustThresholdAliasOutputIOTA))
+ }
+
+ // return Option
+ return func(options *DelegateFundsOptions) error {
+ // initialize destinations property
+ if options.Destinations == nil {
+ options.Destinations = make(map[address.Address]map[ledgerstate.Color]uint64)
+ }
+
+ // initialize address specific destination
+ if _, addressExists := options.Destinations[addr]; !addressExists {
+ options.Destinations[addr] = make(map[ledgerstate.Color]uint64)
+ }
+
+ for color, amount := range balance {
+ // increase amount
+ options.Destinations[addr][color] += amount
+ }
+ return nil
+ }
+}
+
+// DelegateUntil is an option for the DelegateFunds call that specifies until when the delegation should last.
+func DelegateUntil(until time.Time) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ if until.Before(time.Now()) {
+ return errors.Errorf("can't delegate funds in the past")
+ }
+ options.DelegateUntil = until
+ return nil
+ }
+}
+
+// Remainder is an option for the SendsFunds call that allows us to specify the remainder address that is
+// supposed to be used in the corresponding transaction.
+func Remainder(addr address.Address) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ options.RemainderAddress = addr
+
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// DelegateFundsOptions is a struct that is used to aggregate the optional parameters provided in the DelegateFunds call.
+type DelegateFundsOptions struct {
+ Destinations map[address.Address]map[ledgerstate.Color]uint64
+ DelegateUntil time.Time
+ RemainderAddress address.Address
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// RequiredFunds derives how much funds are needed based on the Destinations to fund the transfer.
+func (s *DelegateFundsOptions) RequiredFunds() map[ledgerstate.Color]uint64 {
+ // aggregate total amount of required funds, so we now what and how many funds we need
+ requiredFunds := make(map[ledgerstate.Color]uint64)
+ for _, coloredBalances := range s.Destinations {
+ for color, amount := range coloredBalances {
+ // if we want to color sth then we need fresh IOTA
+ if color == ledgerstate.ColorMint {
+ color = ledgerstate.ColorIOTA
+ }
+
+ requiredFunds[color] += amount
+ }
+ }
+ return requiredFunds
+}
+
+// Build is a utility function that constructs the DelegateFundsOptions.
+func Build(options ...DelegateFundsOption) (result *DelegateFundsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &DelegateFundsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ // sanitize parameters
+ if len(result.Destinations) == 0 {
+ err = errors.New("you need to provide at least one Destination for a valid delegation to be issued")
+
+ return
+ }
+
+ return
+}
+
+// optionError is a utility function that returns a Option that returns the error provided in the
+// argument.
+func optionError(err error) DelegateFundsOption {
+ return func(options *DelegateFundsOptions) error {
+ return err
+ }
+}
diff --git a/client/wallet/packages/deposittonftoptions/options.go b/client/wallet/packages/deposittonftoptions/options.go
new file mode 100644
index 0000000000..1dd3aa70b2
--- /dev/null
+++ b/client/wallet/packages/deposittonftoptions/options.go
@@ -0,0 +1,85 @@
+package deposittonftoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// DepositFundsToNFTOption is a function that provides options.
+type DepositFundsToNFTOption func(options *DepositFundsToNFTOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) DepositFundsToNFTOption {
+ return func(options *DepositFundsToNFTOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// Amount sets how much funds should be withdrew.
+func Amount(amount map[ledgerstate.Color]uint64) DepositFundsToNFTOption {
+ return func(options *DepositFundsToNFTOptions) error {
+ options.Amount = amount
+ return nil
+ }
+}
+
+// Alias specifies which alias to transfer.
+func Alias(aliasID string) DepositFundsToNFTOption {
+ return func(options *DepositFundsToNFTOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) DepositFundsToNFTOption {
+ return func(options *DepositFundsToNFTOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) DepositFundsToNFTOption {
+ return func(options *DepositFundsToNFTOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// DepositFundsToNFTOptions is a struct that is used to aggregate the optional parameters in the DepositFundsToNFT call.
+type DepositFundsToNFTOptions struct {
+ Amount map[ledgerstate.Color]uint64
+ Alias *ledgerstate.AliasAddress
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// Build build the options.
+func Build(options ...DepositFundsToNFTOption) (result *DepositFundsToNFTOptions, err error) {
+ // create options to collect the arguments provided
+ result = &DepositFundsToNFTOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+ if result.Alias == nil {
+ return nil, errors.Errorf("an alias identifier must be specified for withdrawal")
+ }
+
+ if result.Amount == nil {
+ return nil, errors.Errorf("no funds provided for deposit")
+ }
+
+ return
+}
diff --git a/client/wallet/packages/destroynftoptions/options.go b/client/wallet/packages/destroynftoptions/options.go
new file mode 100644
index 0000000000..6dec92feb2
--- /dev/null
+++ b/client/wallet/packages/destroynftoptions/options.go
@@ -0,0 +1,86 @@
+package destroynftoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// DestroyNFTOption is a function that provides options.
+type DestroyNFTOption func(options *DestroyNFTOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) DestroyNFTOption {
+ return func(options *DestroyNFTOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for DestroyNFT call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) DestroyNFTOption {
+ return func(options *DestroyNFTOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for DestroyNFT call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) DestroyNFTOption {
+ return func(options *DestroyNFTOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// Alias specifies which alias to destroy.
+func Alias(aliasID string) DestroyNFTOption {
+ return func(options *DestroyNFTOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// RemainderAddress specifies the address where the funds of the destroyed NFT will be sent. (optional)
+func RemainderAddress(address string) DestroyNFTOption {
+ return func(options *DestroyNFTOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.RemainderAddress = parsed
+ return nil
+ }
+}
+
+// DestroyNFTOptions is a struct that is used to aggregate the optional parameters in the DestroyNFT call.
+type DestroyNFTOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ Alias *ledgerstate.AliasAddress
+ RemainderAddress ledgerstate.Address
+ WaitForConfirmation bool
+}
+
+// Build builds the options.
+func Build(options ...DestroyNFTOption) (result *DestroyNFTOptions, err error) {
+ // create options to collect the arguments provided
+ result = &DestroyNFTOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ if result.Alias == nil {
+ return nil, errors.Errorf("an alias identifier must be specified for destroy")
+ }
+
+ return
+}
diff --git a/client/wallet/packages/reclaimoptions/options.go b/client/wallet/packages/reclaimoptions/options.go
new file mode 100644
index 0000000000..b1fbe2e79d
--- /dev/null
+++ b/client/wallet/packages/reclaimoptions/options.go
@@ -0,0 +1,86 @@
+package reclaimoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// ReclaimFundsOption is a function that provides an option.
+type ReclaimFundsOption func(options *ReclaimFundsOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) ReclaimFundsOption {
+ return func(options *ReclaimFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) ReclaimFundsOption {
+ return func(options *ReclaimFundsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) ReclaimFundsOption {
+ return func(options *ReclaimFundsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// Alias specifies which alias to reclaim.
+func Alias(aliasID string) ReclaimFundsOption {
+ return func(options *ReclaimFundsOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// ToAddress specifies the new governor of the alias.
+func ToAddress(address string) ReclaimFundsOption {
+ return func(options *ReclaimFundsOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.ToAddress = parsed
+ return nil
+ }
+}
+
+// ReclaimFundsOptions is a struct that is used to aggregate the optional parameters in the ReclaimDelegatedFunds call.
+type ReclaimFundsOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ Alias *ledgerstate.AliasAddress
+ ToAddress ledgerstate.Address
+ WaitForConfirmation bool
+}
+
+// Build build the options.
+func Build(options ...ReclaimFundsOption) (result *ReclaimFundsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &ReclaimFundsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ if result.Alias == nil {
+ return nil, errors.Errorf("an alias identifier must be specified for reclaiming delegated funds")
+ }
+
+ return
+}
diff --git a/client/wallet/sendfunds_options.go b/client/wallet/packages/sendoptions/options.go
similarity index 54%
rename from client/wallet/sendfunds_options.go
rename to client/wallet/packages/sendoptions/options.go
index 40542f7100..1a455b6e97 100644
--- a/client/wallet/sendfunds_options.go
+++ b/client/wallet/packages/sendoptions/options.go
@@ -1,6 +1,8 @@
-package wallet
+package sendoptions
import (
+ "time"
+
"github.com/cockroachdb/errors"
"github.com/iotaledger/goshimmer/client/wallet/packages/address"
@@ -8,7 +10,7 @@ import (
)
// SendFundsOption is the type for the optional parameters for the SendFunds call.
-type SendFundsOption func(*sendFundsOptions) error
+type SendFundsOption func(*SendFundsOptions) error
// Destination is an option for the SendFunds call that defines a destination for funds that are supposed to be moved.
func Destination(addr address.Address, amount uint64, optionalColor ...ledgerstate.Color) SendFundsOption {
@@ -29,7 +31,7 @@ func Destination(addr address.Address, amount uint64, optionalColor ...ledgersta
}
// return Option
- return func(options *sendFundsOptions) error {
+ return func(options *SendFundsOptions) error {
// initialize destinations property
if options.Destinations == nil {
options.Destinations = make(map[address.Address]map[ledgerstate.Color]uint64)
@@ -55,7 +57,7 @@ func Destination(addr address.Address, amount uint64, optionalColor ...ledgersta
// Remainder is an option for the SendsFunds call that allows us to specify the remainder address that is
// supposed to be used in the corresponding transaction.
func Remainder(addr address.Address) SendFundsOption {
- return func(options *sendFundsOptions) error {
+ return func(options *SendFundsOptions) error {
options.RemainderAddress = addr
return nil
@@ -64,7 +66,7 @@ func Remainder(addr address.Address) SendFundsOption {
// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
func AccessManaPledgeID(nodeID string) SendFundsOption {
- return func(options *sendFundsOptions) error {
+ return func(options *SendFundsOptions) error {
options.AccessManaPledgeID = nodeID
return nil
}
@@ -72,24 +74,80 @@ func AccessManaPledgeID(nodeID string) SendFundsOption {
// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
func ConsensusManaPledgeID(nodeID string) SendFundsOption {
- return func(options *sendFundsOptions) error {
+ return func(options *SendFundsOptions) error {
options.ConsensusManaPledgeID = nodeID
return nil
}
}
-// sendFundsOptions is a struct that is used to aggregate the optional parameters provided in the SendFunds call.
-type sendFundsOptions struct {
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) SendFundsOption {
+ return func(options *SendFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// LockUntil is an option for SendFunds call that defines if the created outputs should be locked until a certain time.
+func LockUntil(until time.Time) SendFundsOption {
+ return func(options *SendFundsOptions) error {
+ if until.Before(time.Now()) {
+ return errors.Errorf("can't timelock funds in the past")
+ }
+ options.LockUntil = until
+ return nil
+ }
+}
+
+// Fallback defines the parameters for conditional sending: fallback address and fallback deadline.
+// If the output is not spent by the recipient within the fallback deadline, only fallback address is able to unlock it.
+func Fallback(addy ledgerstate.Address, deadline time.Time) SendFundsOption {
+ return func(options *SendFundsOptions) error {
+ if addy == nil {
+ return errors.Errorf("empty fallback address provided")
+ }
+ if deadline.Before(time.Now()) {
+ return errors.Errorf("invalid fallback deadline: %s is in the past", deadline.String())
+ }
+ options.FallbackAddress = addy
+ options.FallbackDeadline = deadline
+ return nil
+ }
+}
+
+// SendFundsOptions is a struct that is used to aggregate the optional parameters provided in the SendFunds call.
+type SendFundsOptions struct {
Destinations map[address.Address]map[ledgerstate.Color]uint64
RemainderAddress address.Address
+ LockUntil time.Time
+ FallbackAddress ledgerstate.Address
+ FallbackDeadline time.Time
AccessManaPledgeID string
ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// RequiredFunds derives how much funds are needed based on the Destinations to fund the transfer.
+func (s *SendFundsOptions) RequiredFunds() map[ledgerstate.Color]uint64 {
+ // aggregate total amount of required funds, so we now what and how many funds we need
+ requiredFunds := make(map[ledgerstate.Color]uint64)
+ for _, coloredBalances := range s.Destinations {
+ for color, amount := range coloredBalances {
+ // if we want to color sth then we need fresh IOTA
+ if color == ledgerstate.ColorMint {
+ color = ledgerstate.ColorIOTA
+ }
+
+ requiredFunds[color] += amount
+ }
+ }
+ return requiredFunds
}
-// buildSendFundsOptions is a utility function that constructs the sendFundsOptions.
-func buildSendFundsOptions(options ...SendFundsOption) (result *sendFundsOptions, err error) {
+// Build is a utility function that constructs the SendFundsOptions.
+func Build(options ...SendFundsOption) (result *SendFundsOptions, err error) {
// create options to collect the arguments provided
- result = &sendFundsOptions{}
+ result = &SendFundsOptions{}
// apply arguments to our options
for _, option := range options {
@@ -111,7 +169,7 @@ func buildSendFundsOptions(options ...SendFundsOption) (result *sendFundsOptions
// optionError is a utility function that returns a Option that returns the error provided in the
// argument.
func optionError(err error) SendFundsOption {
- return func(options *sendFundsOptions) error {
+ return func(options *SendFundsOptions) error {
return err
}
}
diff --git a/client/wallet/packages/sweepnftownednftsoptions/options.go b/client/wallet/packages/sweepnftownednftsoptions/options.go
new file mode 100644
index 0000000000..17e83119a8
--- /dev/null
+++ b/client/wallet/packages/sweepnftownednftsoptions/options.go
@@ -0,0 +1,86 @@
+package sweepnftownednftsoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// SweepNFTOwnedNFTsOption is a function that provides an option.
+type SweepNFTOwnedNFTsOption func(options *SweepNFTOwnedNFTsOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) SweepNFTOwnedNFTsOption {
+ return func(options *SweepNFTOwnedNFTsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) SweepNFTOwnedNFTsOption {
+ return func(options *SweepNFTOwnedNFTsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) SweepNFTOwnedNFTsOption {
+ return func(options *SweepNFTOwnedNFTsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// Alias specifies which an aliasID that is checked for available funds.
+func Alias(aliasID string) SweepNFTOwnedNFTsOption {
+ return func(options *SweepNFTOwnedNFTsOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// ToAddress specifies the optional receiving address.
+func ToAddress(address string) SweepNFTOwnedNFTsOption {
+ return func(options *SweepNFTOwnedNFTsOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.ToAddress = parsed
+ return nil
+ }
+}
+
+// SweepNFTOwnedNFTsOptions is a struct that is used to aggregate the optional parameters in the sweepNFTOwnedNFTs call.
+type SweepNFTOwnedNFTsOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ Alias *ledgerstate.AliasAddress
+ ToAddress ledgerstate.Address
+ WaitForConfirmation bool
+}
+
+// Build builds the options.
+func Build(options ...SweepNFTOwnedNFTsOption) (result *SweepNFTOwnedNFTsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &SweepNFTOwnedNFTsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ if result.Alias == nil {
+ return nil, errors.Errorf("an nft identifier must be specified to sweep funds from")
+ }
+
+ return
+}
diff --git a/client/wallet/packages/sweepnftownedoptions/options.go b/client/wallet/packages/sweepnftownedoptions/options.go
new file mode 100644
index 0000000000..c3c4126942
--- /dev/null
+++ b/client/wallet/packages/sweepnftownedoptions/options.go
@@ -0,0 +1,86 @@
+package sweepnftownedoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// SweepNFTOwnedFundsOption is a function that provides option.
+type SweepNFTOwnedFundsOption func(options *SweepNFTOwnedFundsOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) SweepNFTOwnedFundsOption {
+ return func(options *SweepNFTOwnedFundsOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) SweepNFTOwnedFundsOption {
+ return func(options *SweepNFTOwnedFundsOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SweepNFTOwnedFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) SweepNFTOwnedFundsOption {
+ return func(options *SweepNFTOwnedFundsOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// Alias specifies which an aliasID that is checked for available funds.
+func Alias(aliasID string) SweepNFTOwnedFundsOption {
+ return func(options *SweepNFTOwnedFundsOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// ToAddress specifies the optional receiving address.
+func ToAddress(address string) SweepNFTOwnedFundsOption {
+ return func(options *SweepNFTOwnedFundsOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.ToAddress = parsed
+ return nil
+ }
+}
+
+// SweepNFTOwnedFundsOptions is a struct that is used to aggregate the optional parameters in the SweepNFTOwnedFunds call.
+type SweepNFTOwnedFundsOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ Alias *ledgerstate.AliasAddress
+ ToAddress ledgerstate.Address
+ WaitForConfirmation bool
+}
+
+// Build build the options.
+func Build(options ...SweepNFTOwnedFundsOption) (result *SweepNFTOwnedFundsOptions, err error) {
+ // create options to collect the arguments provided
+ result = &SweepNFTOwnedFundsOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ if result.Alias == nil {
+ return nil, errors.Errorf("an nft identifier must be specified to sweep funds from")
+ }
+
+ return
+}
diff --git a/client/wallet/packages/transfernftoptions/options.go b/client/wallet/packages/transfernftoptions/options.go
new file mode 100644
index 0000000000..1ed160b4b9
--- /dev/null
+++ b/client/wallet/packages/transfernftoptions/options.go
@@ -0,0 +1,107 @@
+package transfernftoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// TransferNFTOption is a function that provides an option.
+type TransferNFTOption func(options *TransferNFTOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// Alias specifies which alias to transfer.
+func Alias(aliasID string) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// ToAddress specifies the new governor of the alias.
+func ToAddress(address string) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.ToAddress = parsed
+ return nil
+ }
+}
+
+// ResetStateAddress defines if the state address should be set to ToAddress as well, or not.
+func ResetStateAddress(reset bool) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ options.ResetStateAddress = reset
+ return nil
+ }
+}
+
+// ResetDelegation defines if the output's delegation staus should be reset.
+func ResetDelegation(reset bool) TransferNFTOption {
+ return func(options *TransferNFTOptions) error {
+ options.ResetDelegation = reset
+ return nil
+ }
+}
+
+// TransferNFTOptions is a struct that is used to aggregate the optional parameters in the TransferNFT call.
+type TransferNFTOptions struct {
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ Alias *ledgerstate.AliasAddress
+ ToAddress ledgerstate.Address
+ WaitForConfirmation bool
+ ResetStateAddress bool
+ ResetDelegation bool
+}
+
+// Build build the options.
+func Build(options ...TransferNFTOption) (result *TransferNFTOptions, err error) {
+ // create options to collect the arguments provided
+ result = &TransferNFTOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+
+ if result.Alias == nil {
+ return nil, errors.Errorf("an alias identifier must be specified for transfer")
+ }
+ if result.ToAddress == nil {
+ return nil, errors.Errorf("no receiving address specified for nft transfer")
+ }
+
+ return
+}
diff --git a/client/wallet/packages/withdrawfromnftoptions/options.go b/client/wallet/packages/withdrawfromnftoptions/options.go
new file mode 100644
index 0000000000..94ec344a74
--- /dev/null
+++ b/client/wallet/packages/withdrawfromnftoptions/options.go
@@ -0,0 +1,94 @@
+package withdrawfromnftoptions
+
+import (
+ "github.com/cockroachdb/errors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// WithdrawFundsFromNFTOption is a function that provides an option.
+type WithdrawFundsFromNFTOption func(options *WithdrawFundsFromNFTOptions) error
+
+// WaitForConfirmation defines if the call should wait for confirmation before it returns.
+func WaitForConfirmation(wait bool) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ options.WaitForConfirmation = wait
+ return nil
+ }
+}
+
+// Amount sets how much funds should be withdrew.
+func Amount(amount map[ledgerstate.Color]uint64) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ options.Amount = amount
+ return nil
+ }
+}
+
+// Alias specifies which alias to transfer.
+func Alias(aliasID string) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ parsed, err := ledgerstate.AliasAddressFromBase58EncodedString(aliasID)
+ if err != nil {
+ return err
+ }
+ options.Alias = parsed
+ return nil
+ }
+}
+
+// ToAddress specifies the new governor of the alias.
+func ToAddress(address string) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ parsed, err := ledgerstate.AddressFromBase58EncodedString(address)
+ if err != nil {
+ return err
+ }
+ options.ToAddress = parsed
+ return nil
+ }
+}
+
+// AccessManaPledgeID is an option for SendFunds call that defines the nodeID to pledge access mana to.
+func AccessManaPledgeID(nodeID string) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ options.AccessManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// ConsensusManaPledgeID is an option for SendFunds call that defines the nodeID to pledge consensus mana to.
+func ConsensusManaPledgeID(nodeID string) WithdrawFundsFromNFTOption {
+ return func(options *WithdrawFundsFromNFTOptions) error {
+ options.ConsensusManaPledgeID = nodeID
+ return nil
+ }
+}
+
+// WithdrawFundsFromNFTOptions is a struct that is used to aggregate the optional parameters in the CreateNFT call.
+type WithdrawFundsFromNFTOptions struct {
+ Amount map[ledgerstate.Color]uint64
+ Alias *ledgerstate.AliasAddress
+ ToAddress ledgerstate.Address
+ AccessManaPledgeID string
+ ConsensusManaPledgeID string
+ WaitForConfirmation bool
+}
+
+// Build builds the options.
+func Build(options ...WithdrawFundsFromNFTOption) (result *WithdrawFundsFromNFTOptions, err error) {
+ // create options to collect the arguments provided
+ result = &WithdrawFundsFromNFTOptions{}
+
+ // apply arguments to our options
+ for _, option := range options {
+ if err = option(result); err != nil {
+ return
+ }
+ }
+ if result.Alias == nil {
+ return nil, errors.Errorf("an alias identifier must be specified for withdrawal")
+ }
+
+ return
+}
diff --git a/client/wallet/serverstatus.go b/client/wallet/serverstatus.go
index 9c668ea8b5..28473f78bc 100644
--- a/client/wallet/serverstatus.go
+++ b/client/wallet/serverstatus.go
@@ -2,8 +2,9 @@ package wallet
// ServerStatus defines the information of connected server
type ServerStatus struct {
- ID string
- Synced bool
- Version string
- ManaDecay float64
+ ID string
+ Synced bool
+ Version string
+ ManaDecay float64
+ DelegationAddress string
}
diff --git a/client/wallet/unspentoutputmanager.go b/client/wallet/unspentoutputmanager.go
deleted file mode 100644
index f6fccc2883..0000000000
--- a/client/wallet/unspentoutputmanager.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package wallet
-
-import (
- "github.com/iotaledger/goshimmer/client/wallet/packages/address"
- "github.com/iotaledger/goshimmer/packages/ledgerstate"
-)
-
-// UnspentOutputManager is a manager for the unspent outputs of the addresses of a wallet. It allows us to keep track of
-// the spent state of outputs using our local knowledge about outputs that have already been spent and allows us to
-// cache results that would otherwise have to be requested by the server over and over again.
-type UnspentOutputManager struct {
- addressManager *AddressManager
- connector Connector
- unspentOutputs map[address.Address]map[ledgerstate.OutputID]*Output
-}
-
-// NewUnspentOutputManager creates a new UnspentOutputManager.
-func NewUnspentOutputManager(addressManager *AddressManager, connector Connector) (outputManager *UnspentOutputManager) {
- outputManager = &UnspentOutputManager{
- addressManager: addressManager,
- connector: connector,
- unspentOutputs: make(map[address.Address]map[ledgerstate.OutputID]*Output),
- }
-
- if err := outputManager.Refresh(true); err != nil {
- panic(err)
- }
-
- return
-}
-
-// Refresh retrieves the unspent outputs from the node. If includeSpentAddresses is set to true, then it also scans the
-// addresses from which we previously spent already.
-func (unspentOutputManager *UnspentOutputManager) Refresh(includeSpentAddresses ...bool) (err error) {
- var addressesToRefresh []address.Address
- if len(includeSpentAddresses) >= 1 && includeSpentAddresses[0] {
- addressesToRefresh = unspentOutputManager.addressManager.Addresses()
- } else {
- addressesToRefresh = unspentOutputManager.addressManager.UnspentAddresses()
- }
-
- unspentOutputs, err := unspentOutputManager.connector.UnspentOutputs(addressesToRefresh...)
- if err != nil {
- return
- }
-
- for outputAddress, unspentOutputs := range unspentOutputs {
- for outputID, output := range unspentOutputs {
- if _, addressExists := unspentOutputManager.unspentOutputs[outputAddress]; !addressExists {
- unspentOutputManager.unspentOutputs[outputAddress] = make(map[ledgerstate.OutputID]*Output)
- }
-
- // mark the output as spent if we already marked it as spent locally
- if existingOutput, outputExists := unspentOutputManager.unspentOutputs[outputAddress][outputID]; outputExists && existingOutput.InclusionState.Spent {
- output.InclusionState.Spent = true
- }
-
- unspentOutputManager.unspentOutputs[outputAddress][outputID] = output
- }
- }
-
- return
-}
-
-// UnspentOutputs returns the outputs that have not been spent, yet.
-func (unspentOutputManager *UnspentOutputManager) UnspentOutputs(addresses ...address.Address) (unspentOutputs map[address.Address]map[ledgerstate.OutputID]*Output) {
- // prepare result
- unspentOutputs = make(map[address.Address]map[ledgerstate.OutputID]*Output)
-
- // retrieve the list of addresses from the address manager if none was provided
- if len(addresses) == 0 {
- addresses = unspentOutputManager.addressManager.Addresses()
- }
-
- // iterate through addresses and scan for unspent outputs
- for _, addr := range addresses {
- // skip the address if we have no outputs for it stored
- unspentOutputsOnAddress, addressExistsInStoredOutputs := unspentOutputManager.unspentOutputs[addr]
- if !addressExistsInStoredOutputs {
- continue
- }
-
- // iterate through outputs
- for transactionID, output := range unspentOutputsOnAddress {
- // skip spent outputs
- if output.InclusionState.Spent {
- continue
- }
-
- // store unspent outputs in result
- if _, addressExists := unspentOutputs[addr]; !addressExists {
- unspentOutputs[addr] = make(map[ledgerstate.OutputID]*Output)
- }
- unspentOutputs[addr][transactionID] = output
- }
- }
-
- return
-}
-
-// MarkOutputSpent marks the output identified by the given parameters as spent.
-func (unspentOutputManager *UnspentOutputManager) MarkOutputSpent(address address.Address, outputID ledgerstate.OutputID) {
- // abort if we try to mark an unknown output as spent
- if _, addressExists := unspentOutputManager.unspentOutputs[address]; !addressExists {
- return
- }
- output, outputExists := unspentOutputManager.unspentOutputs[address][outputID]
- if !outputExists {
- return
- }
-
- // mark output as spent
- output.InclusionState.Spent = true
-}
diff --git a/client/wallet/wallet.go b/client/wallet/wallet.go
index 8f1b457562..5713a82bc5 100644
--- a/client/wallet/wallet.go
+++ b/client/wallet/wallet.go
@@ -12,21 +12,48 @@ import (
"golang.org/x/crypto/blake2b"
"github.com/iotaledger/goshimmer/client/wallet/packages/address"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/claimconditionaloptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/consolidateoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/createnftoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/delegateoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/deposittonftoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/destroynftoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/reclaimoptions"
"github.com/iotaledger/goshimmer/client/wallet/packages/seed"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/sendoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/sweepnftownednftsoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/sweepnftownedoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/transfernftoptions"
+ "github.com/iotaledger/goshimmer/client/wallet/packages/withdrawfromnftoptions"
"github.com/iotaledger/goshimmer/packages/ledgerstate"
"github.com/iotaledger/goshimmer/packages/mana"
)
-// Wallet represents a simple cryptocurrency wallet for the IOTA tangle. It contains the logic to manage the movement of
-// funds.
+// region Wallet ///////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const (
+ // DefaultPollingInterval is the polling interval of the wallet when waiting for confirmation. (in ms)
+ DefaultPollingInterval = 500 // in ms
+ // DefaultConfirmationTimeout is the timeout of waiting for confirmation. (in ms)
+ DefaultConfirmationTimeout = 150000 // in ms
+ milliSeconds = 1000 // miliseconds in a second
+)
+
+// ErrTooManyOutputs is an error returned when the number of outputs/inputs exceeds the protocol wide constant
+var ErrTooManyOutputs = errors.New("number of outputs is more, than supported for a single transaction")
+
+// Wallet is a wallet that can handle aliases and extendedlockedoutputs.
type Wallet struct {
- addressManager *AddressManager
- assetRegistry *AssetRegistry
- unspentOutputManager *UnspentOutputManager
- connector Connector
+ addressManager *AddressManager
+ assetRegistry *AssetRegistry
+ outputManager *OutputManager
+ connector Connector
+ faucetPowDifficulty int
// if this option is enabled the wallet will use a single reusable address instead of changing addresses.
- reusableAddress bool
+ reusableAddress bool
+ ConfirmationPollInterval int // in milliseconds
+ ConfirmationTimeout int // in ms
}
// New is the factory method of the wallet. It either creates a new wallet or restores the wallet backup that is handed
@@ -42,6 +69,14 @@ func New(options ...Option) (wallet *Wallet) {
option(wallet)
}
+ if wallet.ConfirmationPollInterval == 0 {
+ wallet.ConfirmationPollInterval = DefaultPollingInterval
+ }
+
+ if wallet.ConfirmationTimeout == 0 {
+ wallet.ConfirmationTimeout = DefaultConfirmationTimeout
+ }
+
// initialize wallet with default address manager if we did not import a previous wallet
if wallet.addressManager == nil {
wallet.addressManager = NewAddressManager(seed.NewSeed(), 0, []bitmask.BitMask{})
@@ -58,8 +93,8 @@ func New(options ...Option) (wallet *Wallet) {
}
// initialize output manager
- wallet.unspentOutputManager = NewUnspentOutputManager(wallet.addressManager, wallet.connector)
- err := wallet.unspentOutputManager.Refresh(true)
+ wallet.outputManager = NewUnspentOutputManager(wallet.addressManager, wallet.connector)
+ err := wallet.outputManager.Refresh(true)
if err != nil {
panic(err)
}
@@ -67,100 +102,239 @@ func New(options ...Option) (wallet *Wallet) {
return
}
-// ServerStatus retrieves the connected server status.
-func (wallet *Wallet) ServerStatus() (status ServerStatus, err error) {
- return wallet.connector.(*WebConnector).ServerStatus()
-}
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-// AllowedPledgeNodeIDs retrieves the allowed pledge node IDs.
-func (wallet *Wallet) AllowedPledgeNodeIDs() (res map[mana.Type][]string, err error) {
- return wallet.connector.(*WebConnector).GetAllowedPledgeIDs()
-}
+// region SendFunds ////////////////////////////////////////////////////////////////////////////////////////////////////
-// SendFunds issues a payment of the given amount to the given address.
-func (wallet *Wallet) SendFunds(options ...SendFundsOption) (tx *ledgerstate.Transaction, err error) {
- // build options from the parameters
- sendFundsOptions, err := buildSendFundsOptions(options...)
+// SendFunds sends funds from the wallet
+func (wallet *Wallet) SendFunds(options ...sendoptions.SendFundsOption) (tx *ledgerstate.Transaction, err error) {
+ sendOptions, err := sendoptions.Build(options...)
if err != nil {
return
}
- // determine which outputs to use for our transfer
- consumedOutputs, err := wallet.determineOutputsToConsume(sendFundsOptions)
+ // how much funds will we need to fund this transfer?
+ requiredFunds := sendOptions.RequiredFunds()
+ // collect that many outputs for funding
+ consumedOutputs, err := wallet.collectOutputsForFunding(requiredFunds)
if err != nil {
+ if errors.Is(err, ErrTooManyOutputs) {
+ err = errors.Errorf("consolidate funds and try again: %w", err)
+ }
return
}
- // determine pledge IDs
- allowedPledgeNodeIDs, err := wallet.connector.GetAllowedPledgeIDs()
+ // determine pledgeIDs
+ aPledgeID, cPledgeID, err := wallet.derivePledgeIDs(sendOptions.AccessManaPledgeID, sendOptions.ConsensusManaPledgeID)
if err != nil {
return
}
- var accessPledgeNodeID identity.ID
- if sendFundsOptions.AccessManaPledgeID == "" {
- accessPledgeNodeID, err = mana.IDFromStr(allowedPledgeNodeIDs[mana.AccessMana][0])
- } else {
- accessPledgeNodeID, err = mana.IDFromStr(sendFundsOptions.AccessManaPledgeID)
+
+ // build inputs from consumed outputs
+ inputs := wallet.buildInputs(consumedOutputs)
+ // aggregate all the funds we consume from inputs
+ totalConsumedFunds := consumedOutputs.TotalFundsInOutputs()
+ remainderAddress := wallet.chooseRemainderAddress(consumedOutputs, sendOptions.RemainderAddress)
+ outputs := wallet.buildOutputs(sendOptions, totalConsumedFunds, remainderAddress)
+
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), aPledgeID, cPledgeID, inputs, outputs)
+ outputsByID := consumedOutputs.OutputsByID()
+
+ unlockBlocks, inputsAsOutputsInOrder := wallet.buildUnlockBlocks(inputs, outputsByID, txEssence)
+
+ tx = ledgerstate.NewTransaction(txEssence, unlockBlocks)
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
}
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsAsOutputsInOrder, tx)
if err != nil {
- return
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
}
- var consensusPledgeNodeID identity.ID
- if sendFundsOptions.ConsensusManaPledgeID == "" {
- consensusPledgeNodeID, err = mana.IDFromStr(allowedPledgeNodeIDs[mana.AccessMana][0])
- } else {
- consensusPledgeNodeID, err = mana.IDFromStr(sendFundsOptions.ConsensusManaPledgeID)
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+ if sendOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ConsolidateFunds /////////////////////////////////////////////////////////////////////////////////////////////
+
+// ConsolidateFunds consolidates available wallet funds into one output.
+func (wallet *Wallet) ConsolidateFunds(options ...consolidateoptions.ConsolidateFundsOption) (txs []*ledgerstate.Transaction, err error) {
+ consolidateOptions, err := consolidateoptions.Build(options...)
+ if err != nil {
+ return
}
+ // get available balances
+ confirmedAvailableBalance, _, err := wallet.AvailableBalance()
if err != nil {
return
}
+ if len(confirmedAvailableBalance) == 0 {
+ err = errors.Errorf("no available balance to be consolidated in wallet")
+ return
+ }
+ // collect outputs
+ allOutputs, err := wallet.collectOutputsForFunding(confirmedAvailableBalance)
+ if err != nil && !errors.Is(err, ErrTooManyOutputs) {
+ return
+ }
+ if allOutputs.OutputCount() == 1 {
+ err = errors.Errorf("can't consolidate funds, there is only one value output in wallet")
+ return
+ }
+ consumedOutputsSlice := allOutputs.SplitIntoChunksOfMaxInputCount()
- // build transaction
- inputs, consumedFunds := wallet.buildInputs(consumedOutputs)
- outputs := wallet.buildOutputs(sendFundsOptions, consumedFunds)
- txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID, inputs, outputs)
- outputsByID := consumedOutputs.OutputsByID()
+ for _, consumedOutputs := range consumedOutputsSlice {
+ // build inputs from consumed outputs
+ inputs := wallet.buildInputs(consumedOutputs)
+ // aggregate all the funds we consume from inputs
+ totalConsumedFunds := consumedOutputs.TotalFundsInOutputs()
+ toAddress := wallet.chooseToAddress(consumedOutputs, address.AddressEmpty) // no optional toAddress from options
- unlockBlocks := make([]ledgerstate.UnlockBlock, len(inputs))
- existingUnlockBlocks := make(map[address.Address]uint16)
- for outputIndex, input := range inputs {
- output := outputsByID[input.(*ledgerstate.UTXOInput).ReferencedOutputID()]
- if unlockBlockIndex, unlockBlockExists := existingUnlockBlocks[output.Address]; unlockBlockExists {
- unlockBlocks[outputIndex] = ledgerstate.NewReferenceUnlockBlock(unlockBlockIndex)
- continue
+ outputs := ledgerstate.NewOutputs(ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(totalConsumedFunds), toAddress.Address()))
+
+ // determine pledgeIDs
+ aPledgeID, cPledgeID, pErr := wallet.derivePledgeIDs(consolidateOptions.AccessManaPledgeID, consolidateOptions.ConsensusManaPledgeID)
+ if pErr != nil {
+ err = pErr
+ return
}
- keyPair := wallet.Seed().KeyPair(output.Address.Index)
- unlockBlock := ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(txEssence.Bytes())))
- unlockBlocks[outputIndex] = unlockBlock
- existingUnlockBlocks[output.Address] = uint16(len(existingUnlockBlocks))
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), aPledgeID, cPledgeID, inputs, outputs)
+ outputsByID := consumedOutputs.OutputsByID()
+
+ unlockBlocks, inputsAsOutputsInOrder := wallet.buildUnlockBlocks(inputs, outputsByID, txEssence)
+
+ tx := ledgerstate.NewTransaction(txEssence, unlockBlocks)
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, cErr := checkBalancesAndUnlocks(inputsAsOutputsInOrder, tx)
+ if cErr != nil {
+ return nil, cErr
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+ txs = append(txs, tx)
+ if consolidateOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ if err != nil {
+ return txs, err
+ }
+ }
+ }
+
+ return txs, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ClaimConditionalFunds ////////////////////////////////////////////////////////////////////////////////////////
+
+// ClaimConditionalFunds gathers all currently conditionally owned outputs and consolidates them into the output.
+func (wallet *Wallet) ClaimConditionalFunds(options ...claimconditionaloptions.ClaimConditionalFundsOption) (tx *ledgerstate.Transaction, err error) {
+ claimOptions, err := claimconditionaloptions.Build(options...)
+ if err != nil {
+ return
+ }
+ confirmedConditionalBalance, _, err := wallet.ConditionalBalances()
+ if err != nil {
+ return
+ }
+ if len(confirmedConditionalBalance) == 0 {
+ err = errors.Errorf("no conditional balance found in the wallet")
+ return
+ }
+ addresses := wallet.addressManager.Addresses()
+ consumedOutputs := wallet.outputManager.UnspentConditionalOutputs(false, addresses...)
+ if len(consumedOutputs) == 0 {
+ err = errors.Errorf("failed to find conditionally owned outputs in wallet")
+ return
+ }
+
+ // build inputs from consumed outputs
+ inputs := wallet.buildInputs(consumedOutputs)
+ // aggregate all the funds we consume from inputs
+ totalConsumedFunds := consumedOutputs.TotalFundsInOutputs()
+ toAddress := wallet.chooseToAddress(consumedOutputs, address.AddressEmpty) // no optional toAddress from options
+ outputs := ledgerstate.NewOutputs(ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(totalConsumedFunds), toAddress.Address()))
+
+ // determine pledgeIDs
+ aPledgeID, cPledgeID, err := wallet.derivePledgeIDs(claimOptions.AccessManaPledgeID, claimOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
}
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), aPledgeID, cPledgeID, inputs, outputs)
+ outputsByID := consumedOutputs.OutputsByID()
+
+ unlockBlocks, inputsAsOutputsInOrder := wallet.buildUnlockBlocks(inputs, outputsByID, txEssence)
+
tx = ledgerstate.NewTransaction(txEssence, unlockBlocks)
- // mark outputs as spent
- for addr, outputs := range consumedOutputs {
- for transactionID := range outputs {
- wallet.unspentOutputManager.MarkOutputSpent(addr, transactionID)
- }
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
}
- // mark addresses as spent
- if !wallet.reusableAddress {
- for addr := range consumedOutputs {
- wallet.addressManager.MarkAddressSpent(addr.Index)
- }
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsAsOutputsInOrder, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
}
- // send transaction
- err = wallet.connector.SendTransaction(tx)
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+ if claimOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
return
}
+// endregion //////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region CreateAsset //////////////////////////////////////////////////////////////////////////////////////////////////
+
// CreateAsset creates a new colored token with the given details.
-func (wallet *Wallet) CreateAsset(asset Asset) (assetColor ledgerstate.Color, err error) {
+func (wallet *Wallet) CreateAsset(asset Asset, waitForConfirmation ...bool) (assetColor ledgerstate.Color, err error) {
if asset.Amount == 0 {
err = errors.New("required to provide the amount when trying to create an asset")
@@ -173,8 +347,24 @@ func (wallet *Wallet) CreateAsset(asset Asset) (assetColor ledgerstate.Color, er
return
}
+ // where will we spend from?
+ consumedOutputs, err := wallet.collectOutputsForFunding(map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: asset.Amount})
+ if err != nil {
+ if errors.Is(err, ErrTooManyOutputs) {
+ err = errors.Errorf("consolidate funds and try again: %w", err)
+ }
+ return
+ }
+ receiveAddress := wallet.chooseToAddress(consumedOutputs, address.AddressEmpty)
+
+ var wait bool
+ if len(waitForConfirmation) > 0 {
+ wait = waitForConfirmation[0]
+ }
+
tx, err := wallet.SendFunds(
- Destination(wallet.ReceiveAddress(), asset.Amount, ledgerstate.ColorMint),
+ sendoptions.Destination(receiveAddress, asset.Amount, ledgerstate.ColorMint),
+ sendoptions.WaitForConfirmation(wait),
)
if err != nil {
return
@@ -203,248 +393,1787 @@ func (wallet *Wallet) CreateAsset(asset Asset) (assetColor ledgerstate.Color, er
return
}
-// AssetRegistry return the internal AssetRegistry instance of the wallet.
-func (wallet *Wallet) AssetRegistry() *AssetRegistry {
- return wallet.assetRegistry
-}
-
-// ReceiveAddress returns the last receive address of the wallet.
-func (wallet *Wallet) ReceiveAddress() address.Address {
- return wallet.addressManager.LastUnspentAddress()
-}
-
-// NewReceiveAddress generates and returns a new unused receive address.
-func (wallet *Wallet) NewReceiveAddress() address.Address {
- return wallet.addressManager.NewAddress()
-}
-
-// RemainderAddress returns the address that is used for the remainder of funds.
-func (wallet *Wallet) RemainderAddress() address.Address {
- return wallet.addressManager.FirstUnspentAddress()
-}
-
-// UnspentOutputs returns the unspent outputs that are available for spending.
-func (wallet *Wallet) UnspentOutputs() map[address.Address]map[ledgerstate.OutputID]*Output {
- return wallet.unspentOutputManager.UnspentOutputs()
-}
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-// RequestFaucetFunds requests some funds from the faucet for testing purposes.
-func (wallet *Wallet) RequestFaucetFunds(waitForConfirmation ...bool) (err error) {
- if len(waitForConfirmation) == 0 || !waitForConfirmation[0] {
- err = wallet.connector.RequestFaucetFunds(wallet.ReceiveAddress())
+// region DelegateFunds ////////////////////////////////////////////////////////////////////////////////////////////////
+// DelegateFunds delegates funds to a given address by creating a delegated alias output.
+func (wallet *Wallet) DelegateFunds(options ...delegateoptions.DelegateFundsOption) (tx *ledgerstate.Transaction, delegationIDs []*ledgerstate.AliasAddress, err error) {
+ // build options
+ delegateOptions, err := delegateoptions.Build(options...)
+ if err != nil {
return
}
- if err = wallet.Refresh(); err != nil {
- return
- }
- confirmedBalance, _, err := wallet.Balance()
+ // how much funds will we need to fund this transfer?
+ requiredFunds := delegateOptions.RequiredFunds()
+ // collect that many outputs for funding
+ consumedOutputs, err := wallet.collectOutputsForFunding(requiredFunds)
if err != nil {
+ if errors.Is(err, ErrTooManyOutputs) {
+ err = errors.Errorf("consolidate funds and try again: %w", err)
+ }
return
}
- err = wallet.connector.RequestFaucetFunds(wallet.ReceiveAddress())
+ // determine pledgeIDs
+ aPledgeID, cPledgeID, err := wallet.derivePledgeIDs(delegateOptions.AccessManaPledgeID, delegateOptions.ConsensusManaPledgeID)
if err != nil {
return
}
- for {
- time.Sleep(500 * time.Millisecond)
-
- if err = wallet.Refresh(); err != nil {
+ // build inputs from consumed outputs
+ inputs := wallet.buildInputs(consumedOutputs)
+ // aggregate all the funds we consume from inputs
+ totalConsumedFunds := consumedOutputs.TotalFundsInOutputs()
+ remainderAddress := wallet.chooseRemainderAddress(consumedOutputs, delegateOptions.RemainderAddress)
+
+ unsortedOutputs := ledgerstate.Outputs{}
+ for addr, balanceMap := range delegateOptions.Destinations {
+ var delegationOutput *ledgerstate.AliasOutput
+ delegationOutput, err = ledgerstate.NewAliasOutputMint(balanceMap, addr.Address())
+ if err != nil {
return
}
- newConfirmedBalance, _, balanceErr := wallet.Balance()
- if balanceErr != nil {
- err = balanceErr
-
- return
+ // we are the governance controllers, so we can claim back the delegated funds
+ delegationOutput.SetGoverningAddress(wallet.ReceiveAddress().Address())
+ // is there a delegation timelock?
+ if !delegateOptions.DelegateUntil.IsZero() {
+ delegationOutput = delegationOutput.WithDelegationAndTimelock(delegateOptions.DelegateUntil)
+ } else {
+ delegationOutput = delegationOutput.WithDelegation()
}
-
- if !reflect.DeepEqual(confirmedBalance, newConfirmedBalance) {
+ unsortedOutputs = append(unsortedOutputs, delegationOutput)
+ }
+ // remainder balance = totalConsumed - required
+ for color, balance := range requiredFunds {
+ if totalConsumedFunds[color] < balance {
+ err = errors.Errorf("delegated funds are greater than consumed funds")
return
}
+ totalConsumedFunds[color] -= balance
+ if totalConsumedFunds[color] <= 0 {
+ delete(totalConsumedFunds, color)
+ }
+ }
+ // only create remainder output if there is a remainder balance
+ if len(totalConsumedFunds) > 0 {
+ remainderBalances := ledgerstate.NewColoredBalances(totalConsumedFunds)
+ unsortedOutputs = append(unsortedOutputs, ledgerstate.NewSigLockedColoredOutput(remainderBalances, remainderAddress.Address()))
}
-}
-
-// Refresh scans the addresses for incoming transactions. If the optional rescanSpentAddresses parameter is set to true
-// we also scan the spent addresses again (this can take longer).
-func (wallet *Wallet) Refresh(rescanSpentAddresses ...bool) (err error) {
- err = wallet.unspentOutputManager.Refresh(rescanSpentAddresses...)
- return
-}
+ outputs := ledgerstate.NewOutputs(unsortedOutputs...)
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), aPledgeID, cPledgeID, inputs, outputs)
+ outputsByID := consumedOutputs.OutputsByID()
+ unlockBlocks, inputsAsOutputsInOrder := wallet.buildUnlockBlocks(inputs, outputsByID, txEssence)
+ tx = ledgerstate.NewTransaction(txEssence, unlockBlocks)
-// Balance returns the confirmed and pending balance of the funds managed by this wallet.
-func (wallet *Wallet) Balance() (confirmedBalance map[ledgerstate.Color]uint64, pendingBalance map[ledgerstate.Color]uint64, err error) {
- err = wallet.unspentOutputManager.Refresh()
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
if err != nil {
return
}
- confirmedBalance = make(map[ledgerstate.Color]uint64)
- pendingBalance = make(map[ledgerstate.Color]uint64)
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsAsOutputsInOrder, tx)
+ if err != nil {
+ return
+ }
+ if !ok {
+ err = errors.Errorf("created transaction is invalid: %s", tx.String())
+ return
+ }
- // iterate through the unspent outputs
- for _, outputsOnAddress := range wallet.unspentOutputManager.UnspentOutputs() {
- for _, output := range outputsOnAddress {
- // skip if the output was rejected or spent already
- if output.InclusionState.Spent || output.InclusionState.Rejected {
- continue
- }
+ // look for the ids of the freshly created delegation aliases that are only available after the outputID is set.
+ delegationIDs = make([]*ledgerstate.AliasAddress, 0)
+ for _, output := range tx.Essence().Outputs() {
+ if output.Type() == ledgerstate.AliasOutputType {
+ // Address() for an alias output returns the alias address, the unique ID of the alias
+ delegationIDs = append(delegationIDs, output.Address().(*ledgerstate.AliasAddress))
+ }
+ }
- // determine target map
- var targetMap map[ledgerstate.Color]uint64
- if output.InclusionState.Confirmed {
- targetMap = confirmedBalance
- } else {
- targetMap = pendingBalance
- }
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
- // store amount
- output.Balances.ForEach(func(color ledgerstate.Color, balance uint64) bool {
- targetMap[color] += balance
- return true
- })
- }
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return
+ }
+ if delegateOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
}
return
}
-// Seed returns the seed of this wallet that is used to generate all of the wallets addresses and private keys.
-func (wallet *Wallet) Seed() *seed.Seed {
- return wallet.addressManager.seed
-}
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-// AddressManager returns the manager for the addresses of this wallet.
-func (wallet *Wallet) AddressManager() *AddressManager {
- return wallet.addressManager
-}
+// region ReclaimDelegatedFunds ////////////////////////////////////////////////////////////////////////////////////////
-// ExportState exports the current state of the wallet to a marshaled version.
-func (wallet *Wallet) ExportState() []byte {
- marshalUtil := marshalutil.New()
- marshalUtil.WriteBytes(wallet.Seed().Bytes())
- marshalUtil.WriteUint64(wallet.AddressManager().lastAddressIndex)
- marshalUtil.WriteBytes(wallet.assetRegistry.Bytes())
- marshalUtil.WriteBytes(*(*[]byte)(unsafe.Pointer(&wallet.addressManager.spentAddresses)))
+// ReclaimDelegatedFunds reclaims delegated funds (alias outputs).
+func (wallet *Wallet) ReclaimDelegatedFunds(options ...reclaimoptions.ReclaimFundsOption) (tx *ledgerstate.Transaction, err error) {
+ // build options
+ reclaimOptions, err := reclaimoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ if reclaimOptions.ToAddress == nil {
+ // if no optional address is provided, send to receive address of the wallet
+ reclaimOptions.ToAddress = wallet.ReceiveAddress().Address()
+ }
- return marshalUtil.Bytes()
+ tx, err = wallet.DestroyNFT(
+ destroynftoptions.Alias(reclaimOptions.Alias.Base58()),
+ destroynftoptions.RemainderAddress(reclaimOptions.ToAddress.Base58()),
+ destroynftoptions.WaitForConfirmation(reclaimOptions.WaitForConfirmation),
+ )
+
+ return
}
-func (wallet *Wallet) determineOutputsToConsume(sendFundsOptions *sendFundsOptions) (outputsToConsume OutputsByAddressAndOutputID, err error) {
- // initialize return values
- outputsToConsume = make(OutputsByAddressAndOutputID)
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
- // aggregate total amount of required funds, so we now what and how many funds we need
- requiredFunds := make(map[ledgerstate.Color]uint64)
- for _, coloredBalances := range sendFundsOptions.Destinations {
- for color, amount := range coloredBalances {
- // if we want to color sth then we need fresh IOTA
- if color == ledgerstate.ColorMint {
- color = ledgerstate.ColorIOTA
- }
+// region CreateNFT ////////////////////////////////////////////////////////////////////////////////////////////////////
- requiredFunds[color] += amount
- }
+// CreateNFT spends funds from the wallet to create an NFT.
+func (wallet *Wallet) CreateNFT(options ...createnftoptions.CreateNFTOption) (tx *ledgerstate.Transaction, nftID *ledgerstate.AliasAddress, err error) { // build options from the parameters
+ // build options
+ createNFTOptions, err := createnftoptions.Build(options...)
+ if err != nil {
+ return
}
-
- // refresh balances so we get the latest changes
- if err = wallet.unspentOutputManager.Refresh(); err != nil {
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(createNFTOptions.AccessManaPledgeID, createNFTOptions.ConsensusManaPledgeID)
+ if err != nil {
return
}
+ // collect funds required for an alias input
+ consumedOutputs, err := wallet.collectOutputsForFunding(createNFTOptions.InitialBalance)
+ if err != nil {
+ if errors.Is(err, ErrTooManyOutputs) {
+ err = errors.Errorf("consolidate funds and try again: %w", err)
+ }
+ return nil, nil, err
+ }
+ // determine which address should receive the nft
+ nftWalletAddress := wallet.chooseToAddress(consumedOutputs, address.AddressEmpty)
+ // build inputs from consumed outputs
+ inputs := wallet.buildInputs(consumedOutputs)
+ // aggregate all the funds we consume from inputs
+ totalConsumedFunds := consumedOutputs.TotalFundsInOutputs()
+ // create an alias mint output
+ nft, err := ledgerstate.NewAliasOutputMint(
+ createNFTOptions.InitialBalance,
+ nftWalletAddress.Address(),
+ createNFTOptions.ImmutableData,
+ )
+ if err != nil {
+ return nil, nil, err
+ }
+ unsortedOutputs := ledgerstate.Outputs{nft}
- // look for the required funds in the available unspent outputs
- for addr, unspentOutputsOnAddress := range wallet.unspentOutputManager.UnspentOutputs() {
- // keeps track if outputs from this address are supposed to be spent
- outputsFromAddressSpent := false
+ // calculate remainder balances (consumed - nft balance)
+ nft.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ totalConsumedFunds[color] -= balance
+ if totalConsumedFunds[color] <= 0 {
+ delete(totalConsumedFunds, color)
+ }
+ return true
+ })
+ remainderBalances := ledgerstate.NewColoredBalances(totalConsumedFunds)
+ // only add remainder output if there is a remainder balance
+ if remainderBalances.Size() != 0 {
+ unsortedOutputs = append(unsortedOutputs, ledgerstate.NewSigLockedColoredOutput(
+ remainderBalances, wallet.chooseRemainderAddress(consumedOutputs, address.AddressEmpty).Address()))
+ }
+ // create tx essence
+ outputs := ledgerstate.NewOutputs(unsortedOutputs...)
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID, inputs, outputs)
- // scan the outputs on this address for required funds
- for outputID, output := range unspentOutputsOnAddress {
- // keeps track if the output contains any usable funds
- requiredColorFoundInOutput := false
+ // build unlock blocks
+ unlockBlocks, inputsInOrder := wallet.buildUnlockBlocks(inputs, consumedOutputs.OutputsByID(), txEssence)
- // subtract the found matching balances from the required funds
- output.Balances.ForEach(func(color ledgerstate.Color, balance uint64) bool {
- if requiredAmount, requiredColorExists := requiredFunds[color]; requiredColorExists {
- if requiredAmount > balance {
- requiredFunds[color] -= balance
- } else {
- delete(requiredFunds, color)
- }
+ tx = ledgerstate.NewTransaction(txEssence, unlockBlocks)
- requiredColorFoundInOutput = true
- }
- return true
- })
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, nil, err
+ }
- // if we found required tokens in this output
- if requiredColorFoundInOutput {
- // store the output in the outputs to use for the transfer
- if _, addressEntryExists := outputsToConsume[addr]; !addressEntryExists {
- outputsToConsume[addr] = make(map[ledgerstate.OutputID]*Output)
- }
- outputsToConsume[addr][outputID] = output
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsInOrder, tx)
+ if err != nil {
+ return nil, nil, err
+ }
+ if !ok {
+ return nil, nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
- // mark address as spent
- outputsFromAddressSpent = true
- }
+ // look for the id of the freshly created nft (alias) that is only available after the outputID is set.
+ for _, output := range tx.Essence().Outputs() {
+ if output.Type() == ledgerstate.AliasOutputType {
+ // Address() for an alias output returns the alias address, the unique ID of the alias
+ nftID = output.Address().(*ledgerstate.AliasAddress)
}
+ }
- // if outputs from this address were spent add the remaining outputs as well (we want to spend only once from
- // every address if we are not using a reusable address)
- if !wallet.reusableAddress && outputsFromAddressSpent {
- for transactionID, output := range unspentOutputsOnAddress {
- outputsToConsume[addr][transactionID] = output
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, nil, err
+ }
+ if createNFTOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, nftID, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region TransferNFT //////////////////////////////////////////////////////////////////////////////////////////////////
+
+// TransferNFT transfers an NFT to a given address.
+func (wallet *Wallet) TransferNFT(options ...transfernftoptions.TransferNFTOption) (tx *ledgerstate.Transaction, err error) {
+ transferOptions, err := transfernftoptions.Build(options...)
+ if err != nil {
+ return
+ }
+
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(transferOptions.AccessManaPledgeID, transferOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+
+ // look up if we have the alias output
+ walletAlias, err := wallet.findGovernedAliasOutputByAliasID(transferOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+ if alias.DelegationTimeLockedNow(time.Now()) {
+ err = errors.Errorf("alias %s is delegation timelocked until %s", alias.GetAliasAddress().Base58(),
+ alias.DelegationTimelock().String())
+ return
+ }
+
+ // check if we are not trying to governance deadlock
+ // Note, that a deadlock means that aliases circularly govern each other. Such aliases will not be able to get
+ // governance unlocked due to protocol constraints.
+ // - an alias cannot govern itself, so level 1 circular dependency is covered by the syntactic checks of outputs
+ // - here we can check if the other alias is governed by us, hence preventing level 2 circular dependency
+ // - but we can't prevent level 3 or greater circular dependency without walking the governing path, which can be
+ // expensive.
+ if transferOptions.ToAddress.Type() == ledgerstate.AliasAddressType {
+ // we are giving the governor role to another alias. Is that other alias governed by this alias?
+ var otherAlias *ledgerstate.AliasOutput
+ otherAlias, err = wallet.connector.GetUnspentAliasOutput(transferOptions.ToAddress.(*ledgerstate.AliasAddress))
+ if err != nil {
+ err = errors.Errorf("failed to check that transfer wouldn't result in deadlocked outputs: %w", err)
+ return
+ }
+ if otherAlias.GetGoverningAddress().Equals(alias.GetAliasAddress()) {
+ err = errors.Errorf("transfer of nft to %s would result in circular alias governance", transferOptions.ToAddress.Base58())
+ return
+ }
+ }
+
+ // transfer means we are transferring the governor role, so it has to be a governance update
+ nextAlias := alias.NewAliasOutputNext(true)
+ if nextAlias.IsSelfGoverned() {
+ err = nextAlias.SetStateAddress(transferOptions.ToAddress)
+ if err != nil {
+ return
+ }
+ } else {
+ if transferOptions.ResetStateAddress {
+ // we make it self governed for the receive address
+ nextAlias.SetGoverningAddress(nil)
+ err = nextAlias.SetStateAddress(transferOptions.ToAddress)
+ if err != nil {
+ return
+ }
+ } else {
+ // only transfer the governor role, state controller remains.
+ nextAlias.SetGoverningAddress(transferOptions.ToAddress)
+ }
+ }
+
+ if transferOptions.ResetDelegation {
+ nextAlias.SetIsDelegated(false)
+ }
+
+ essence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID,
+ ledgerstate.NewInputs(alias.Input()),
+ ledgerstate.NewOutputs(nextAlias),
+ )
+ // there is only one input, so signing is easy
+ keyPair := wallet.Seed().KeyPair(walletAlias.Address.Index)
+ tx = ledgerstate.NewTransaction(essence, ledgerstate.UnlockBlocks{
+ ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes()))),
+ })
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(ledgerstate.Outputs{alias}, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(OutputsByAddressAndOutputID{walletAlias.Address: {
+ walletAlias.Object.ID(): walletAlias,
+ }})
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+
+ if transferOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region DestroyNFT ///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// DestroyNFT destroys the given nft (alias).
+func (wallet *Wallet) DestroyNFT(options ...destroynftoptions.DestroyNFTOption) (tx *ledgerstate.Transaction, err error) {
+ destroyOptions, err := destroynftoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(destroyOptions.AccessManaPledgeID, destroyOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+ // look up if we have the alias output
+ walletAlias, err := wallet.findGovernedAliasOutputByAliasID(destroyOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+
+ if alias.DelegationTimeLockedNow(time.Now()) {
+ err = errors.Errorf("alias %s is delegation timelocked until %s", alias.GetAliasAddress().Base58(), alias.DelegationTimelock().String())
+ return
+ }
+
+ // can only be destroyed when minimal funds are present (unless it is delegated)
+ if !alias.IsDelegated() && !ledgerstate.IsExactDustMinimum(alias.Balances()) {
+ withdrawAmount := alias.Balances().Map()
+ withdrawAmount[ledgerstate.ColorIOTA] -= ledgerstate.DustThresholdAliasOutputIOTA
+ _, err = wallet.WithdrawFundsFromNFT(
+ withdrawfromnftoptions.Alias(destroyOptions.Alias.Base58()),
+ withdrawfromnftoptions.Amount(withdrawAmount),
+ withdrawfromnftoptions.WaitForConfirmation(true),
+ )
+ if err != nil {
+ return
+ }
+ walletAlias, err = wallet.findGovernedAliasOutputByAliasID(destroyOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias = walletAlias.Object.(*ledgerstate.AliasOutput)
+ }
+
+ // determine where the remainder will go
+ consumedOutputs := OutputsByAddressAndOutputID{
+ // we only consume the to-be-destroyed alias
+ walletAlias.Address: {walletAlias.Object.ID(): walletAlias},
+ }
+ remainderAddy := wallet.chooseRemainderAddress(consumedOutputs, address.AddressEmpty)
+ remainderOutput := ledgerstate.NewSigLockedColoredOutput(alias.Balances(), remainderAddy.Address())
+
+ inputs := ledgerstate.Inputs{alias.Input()}
+ outputs := ledgerstate.Outputs{remainderOutput}
+ essence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID,
+ ledgerstate.NewInputs(inputs...), ledgerstate.NewOutputs(outputs...))
+
+ // there is only one input, so signing is easy
+ keyPair := wallet.Seed().KeyPair(walletAlias.Address.Index)
+ tx = ledgerstate.NewTransaction(essence, ledgerstate.UnlockBlocks{
+ ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes()))),
+ })
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(ledgerstate.Outputs{alias}, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(OutputsByAddressAndOutputID{walletAlias.Address: {
+ walletAlias.Object.ID(): walletAlias,
+ }})
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+
+ if destroyOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region WithdrawFundsFromNFT /////////////////////////////////////////////////////////////////////////////////////////
+
+// WithdrawFundsFromNFT withdraws funds from the given alias. If the wallet is not the state controller, or too much funds
+// are withdrawn, an error is returned.
+func (wallet *Wallet) WithdrawFundsFromNFT(options ...withdrawfromnftoptions.WithdrawFundsFromNFTOption) (tx *ledgerstate.Transaction, err error) {
+ withdrawOptions, err := withdrawfromnftoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ // look up if we have the alias output. Only the state controller can modify balances in aliases.
+ walletAlias, err := wallet.findStateControlledAliasOutputByAliasID(withdrawOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+ balancesOfAlias := alias.Balances()
+ withdrawBalances := withdrawOptions.Amount
+ newAliasBalance := map[ledgerstate.Color]uint64{}
+
+ // check if withdrawBalance is valid for alias
+ balancesOfAlias.ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ if balance < withdrawBalances[color] {
+ err = errors.Errorf("trying to withdraw %d %s tokens from alias, but there are only %d tokens in it",
+ withdrawBalances[color], color.Base58(), balance)
+ return false
+ }
+ newAliasBalance[color] = balance - withdrawBalances[color]
+ if newAliasBalance[color] == 0 {
+ delete(newAliasBalance, color)
+ }
+ if color == ledgerstate.ColorIOTA && newAliasBalance[color] < ledgerstate.DustThresholdAliasOutputIOTA {
+ err = errors.Errorf("%d IOTA tokens would remain after withdrawal, which is less, then the minimum required %d",
+ newAliasBalance[color], ledgerstate.DustThresholdAliasOutputIOTA)
+ return false
+ }
+ return true
+ })
+ if err != nil {
+ return
+ }
+
+ nextAlias := alias.NewAliasOutputNext(false)
+ err = nextAlias.SetBalances(newAliasBalance)
+ if err != nil {
+ return
+ }
+
+ consumedOutputs := OutputsByAddressAndOutputID{
+ // we only consume the to-be-destroyed alias
+ walletAlias.Address: {walletAlias.Object.ID(): walletAlias},
+ }
+ var optionsToAddress address.Address
+ if withdrawOptions.ToAddress == nil {
+ optionsToAddress = address.AddressEmpty
+ } else {
+ optionsToAddress = address.Address{AddressBytes: withdrawOptions.ToAddress.Array()}
+ }
+ remainderAddress := wallet.chooseRemainderAddress(consumedOutputs, optionsToAddress)
+
+ remainderOutput := ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(withdrawBalances), remainderAddress.Address())
+
+ inputs := ledgerstate.Inputs{alias.Input()}
+ outputs := ledgerstate.Outputs{remainderOutput, nextAlias}
+
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(withdrawOptions.AccessManaPledgeID, withdrawOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+
+ essence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID,
+ ledgerstate.NewInputs(inputs...), ledgerstate.NewOutputs(outputs...))
+
+ // there is only one input, so signing is easy
+ keyPair := wallet.Seed().KeyPair(walletAlias.Address.Index)
+ tx = ledgerstate.NewTransaction(essence, ledgerstate.UnlockBlocks{
+ ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes()))),
+ })
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(ledgerstate.Outputs{alias}, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(OutputsByAddressAndOutputID{walletAlias.Address: {
+ walletAlias.Object.ID(): walletAlias,
+ }})
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+
+ if withdrawOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region DepositFundsToNFT ////////////////////////////////////////////////////////////////////////////////////////////
+
+// DepositFundsToNFT deposits funds to the given alias from the wallet funds. If the wallet is not the state controller, an error is returned.
+func (wallet *Wallet) DepositFundsToNFT(options ...deposittonftoptions.DepositFundsToNFTOption) (tx *ledgerstate.Transaction, err error) {
+ depositOptions, err := deposittonftoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(depositOptions.AccessManaPledgeID, depositOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+ // look up if we have the alias output. Only the state controller can modify balances in aliases.
+ walletAlias, err := wallet.findStateControlledAliasOutputByAliasID(depositOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+ depositBalances := depositOptions.Amount
+ newAliasBalance := alias.Balances().Map() // we are going to top it up with depositbalances
+ // add deposit balances to alias balance
+ for color, balance := range depositBalances {
+ newAliasBalance[color] += balance
+ }
+
+ // collect funds required for a deposit
+ consumedOutputs, err := wallet.collectOutputsForFunding(depositBalances)
+ if err != nil {
+ if errors.Is(err, ErrTooManyOutputs) {
+ err = errors.Errorf("consolidate funds and try again: %w", err)
+ }
+ return nil, err
+ }
+ // build inputs from consumed outputs
+ inputsFromConsumedOutputs := wallet.buildInputs(consumedOutputs)
+ // add the alias
+ unsortedInputs := append(inputsFromConsumedOutputs, alias.Input())
+ // sort all inputs
+ inputs := ledgerstate.NewInputs(unsortedInputs...)
+ // aggregate all the funds we consume from inputs used to fund the deposit (there is the alias input as well)
+ totalConsumed := consumedOutputs.TotalFundsInOutputs()
+ // create the alias state transition (only state transition can modify balance)
+ nextAlias := alias.NewAliasOutputNext(false)
+ // update the balance of the deposited nft output
+ err = nextAlias.SetBalances(newAliasBalance)
+ if err != nil {
+ return nil, err
+ }
+ unsortedOutputs := ledgerstate.Outputs{nextAlias}
+
+ // remainder balance = totalConsumed - deposit
+ for color, balance := range depositBalances {
+ if totalConsumed[color] < balance {
+ return nil, errors.Errorf("deposit funds are greater than consumed funds")
+ }
+ totalConsumed[color] -= balance
+ if totalConsumed[color] <= 0 {
+ delete(totalConsumed, color)
+ }
+ }
+ remainderBalances := ledgerstate.NewColoredBalances(totalConsumed)
+ // only add remainder output if there is a remainder balance
+ if remainderBalances.Size() != 0 {
+ unsortedOutputs = append(unsortedOutputs, ledgerstate.NewSigLockedColoredOutput(
+ remainderBalances, wallet.chooseRemainderAddress(consumedOutputs, address.AddressEmpty).Address()))
+ }
+
+ // create tx essence
+ outputs := ledgerstate.NewOutputs(unsortedOutputs...)
+ txEssence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID, inputs, outputs)
+ // add the alias to the consumed outputs
+ if _, exists := consumedOutputs[walletAlias.Address]; !exists {
+ consumedOutputs[walletAlias.Address] = make(map[ledgerstate.OutputID]*Output)
+ }
+ consumedOutputs[walletAlias.Address][walletAlias.Object.ID()] = walletAlias
+
+ // build unlock blocks
+ unlockBlocks, inputsInOrder := wallet.buildUnlockBlocks(inputs, consumedOutputs.OutputsByID(), txEssence)
+
+ tx = ledgerstate.NewTransaction(txEssence, unlockBlocks)
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsInOrder, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(consumedOutputs)
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+
+ if depositOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region SweepNFTOwnedFunds ///////////////////////////////////////////////////////////////////////////////////////////
+
+// SweepNFTOwnedFunds collects all funds from non-alias outputs that are owned by the nft into the wallet.
+func (wallet Wallet) SweepNFTOwnedFunds(options ...sweepnftownedoptions.SweepNFTOwnedFundsOption) (tx *ledgerstate.Transaction, err error) {
+ sweepOptions, err := sweepnftownedoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(sweepOptions.AccessManaPledgeID, sweepOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+ // do we own the nft as a state controller?
+ _, stateControlled, _, _, err := wallet.AliasBalance()
+ if err != nil {
+ return
+ }
+ if _, has := stateControlled[*sweepOptions.Alias]; !has {
+ err = errors.Errorf("nft %s is not state controlled by the wallet", sweepOptions.Alias.Base58())
+ }
+ // look up if we have the alias output. Only the state controller can modify balances in aliases.
+ walletAlias, err := wallet.findStateControlledAliasOutputByAliasID(sweepOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+
+ owned, _, err := wallet.AvailableOutputsOnNFT(sweepOptions.Alias.Base58())
+ if err != nil {
+ return
+ }
+ if len(owned) == 0 {
+ err = errors.Errorf("no owned outputs with funds are found on nft %s", sweepOptions.Alias.Base58())
+ }
+
+ toBeConsumed := ledgerstate.Outputs{}
+ totalConsumed := map[ledgerstate.Color]uint64{}
+ // owned contains all outputs that are owned by nft. we want to filter out alias outputs, as they are not "funds"
+ for _, output := range owned {
+ if len(toBeConsumed) == ledgerstate.MaxOutputCount-1 {
+ // we can spend at most 127 inputs in a tx, need one more for the alias
+ break
+ }
+ if output.Type() == ledgerstate.AliasOutputType {
+ continue
+ }
+ output.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ totalConsumed[color] += balance
+ return true
+ })
+ toBeConsumed = append(toBeConsumed, output)
+ }
+
+ nextAlias := alias.NewAliasOutputNext(false)
+ toBeConsumed = append(toBeConsumed, alias)
+
+ var optionsToAddress address.Address
+ if sweepOptions.ToAddress == nil {
+ optionsToAddress = address.AddressEmpty
+ } else {
+ optionsToAddress = address.Address{AddressBytes: sweepOptions.ToAddress.Array()}
+ }
+ consumedOutputs := OutputsByAddressAndOutputID{
+ // we only consume the to-be-destroyed alias from the wallet
+ walletAlias.Address: {walletAlias.Object.ID(): walletAlias},
+ }
+ toAddress := wallet.chooseToAddress(consumedOutputs, optionsToAddress)
+
+ unsortedInputs := toBeConsumed.Inputs()
+ unsortedOutputs := ledgerstate.Outputs{nextAlias, ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(totalConsumed), toAddress.Address())}
+
+ essence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID, ledgerstate.NewInputs(unsortedInputs...), ledgerstate.NewOutputs(unsortedOutputs...))
+
+ toBeConsumeByID := toBeConsumed.ByID()
+ inputsInOrder := ledgerstate.Outputs{}
+ unlockBlocks := make(ledgerstate.UnlockBlocks, len(essence.Inputs()))
+ aliasInputIndex := -1
+ // find the input of alias
+ for index, input := range essence.Inputs() {
+ if input.Type() == ledgerstate.UTXOInputType {
+ casted := input.(*ledgerstate.UTXOInput)
+ if casted.ReferencedOutputID() == alias.ID() {
+ keyPair := wallet.Seed().KeyPair(walletAlias.Address.Index)
+ unlockBlock := ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes())))
+ unlockBlocks[index] = unlockBlock
+ aliasInputIndex = index
+ }
+ inputsInOrder = append(inputsInOrder, toBeConsumeByID[casted.ReferencedOutputID()])
+ }
+ }
+ if aliasInputIndex < 0 {
+ err = errors.Errorf("failed to find alias %s among prepared transaction inputs", alias.GetAliasAddress().Base58())
+ return
+ }
+ // fill rest of the unlock blocks
+ for i := range essence.Inputs() {
+ if i != aliasInputIndex {
+ unlockBlocks[i] = ledgerstate.NewAliasUnlockBlock(uint16(aliasInputIndex))
+ }
+ }
+
+ tx = ledgerstate.NewTransaction(essence, unlockBlocks)
+
+ // check syntactical validity by marshaling an unmarshaling
+ tx, _, err = ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return nil, err
+ }
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsInOrder, tx)
+ if err != nil {
+ return nil, err
+ }
+ if !ok {
+ return nil, errors.Errorf("created transaction is invalid: %s", tx.String())
+ }
+
+ wallet.markOutputsAndAddressesSpent(OutputsByAddressAndOutputID{walletAlias.Address: {
+ walletAlias.Object.ID(): walletAlias,
+ }})
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return nil, err
+ }
+
+ if sweepOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+
+ return tx, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region SweepNFTOwnedNFTs ////////////////////////////////////////////////////////////////////////////////////////////
+
+func (wallet *Wallet) SweepNFTOwnedNFTs(options ...sweepnftownednftsoptions.SweepNFTOwnedNFTsOption) (tx *ledgerstate.Transaction, sweptNFTs []*ledgerstate.AliasAddress, err error) {
+ sweepOptions, err := sweepnftownednftsoptions.Build(options...)
+ if err != nil {
+ return
+ }
+ // derive mana pledge IDs
+ accessPledgeNodeID, consensusPledgeNodeID, err := wallet.derivePledgeIDs(sweepOptions.AccessManaPledgeID, sweepOptions.ConsensusManaPledgeID)
+ if err != nil {
+ return
+ }
+
+ // do we own the nft as a state controller?
+ _, stateControlled, _, _, err := wallet.AliasBalance()
+ if err != nil {
+ return
+ }
+ if _, has := stateControlled[*sweepOptions.Alias]; !has {
+ err = errors.Errorf("nft %s is not state controlled by the wallet", sweepOptions.Alias.Base58())
+ }
+ // look up if we have the alias output. Only the state controller can modify balances in aliases.
+ walletAlias, err := wallet.findStateControlledAliasOutputByAliasID(sweepOptions.Alias)
+ if err != nil {
+ return
+ }
+ alias := walletAlias.Object.(*ledgerstate.AliasOutput)
+ owned, _, err := wallet.AvailableOutputsOnNFT(sweepOptions.Alias.Base58())
+ if err != nil {
+ return
+ }
+ if len(owned) == 0 {
+ err = errors.Errorf("no owned outputs with funds are found on nft %s", sweepOptions.Alias.Base58())
+ }
+ toBeConsumed := ledgerstate.Outputs{}
+ // owned contains all outputs that are owned by nft. we want to filter out non alias outputs
+ now := time.Now()
+ for _, output := range owned {
+ if len(toBeConsumed) == ledgerstate.MaxInputCount-1 {
+ // we can spend at most 127 inputs in a tx, need one more for the alias
+ break
+ }
+ if output.Type() == ledgerstate.AliasOutputType {
+ casted := output.(*ledgerstate.AliasOutput)
+ if casted.DelegationTimeLockedNow(now) {
+ // the output is delegation timelocked at the moment, so the governor can't move it
+ continue
+ }
+ toBeConsumed = append(toBeConsumed, output)
+ }
+ }
+ // determine which address to send to
+ var optionsToAddress address.Address
+ if sweepOptions.ToAddress == nil {
+ optionsToAddress = address.AddressEmpty
+ } else {
+ optionsToAddress = address.Address{AddressBytes: sweepOptions.ToAddress.Array()}
+ }
+ consumedOutputs := OutputsByAddressAndOutputID{
+ // we only consume the to-be-destroyed alias from the wallet
+ walletAlias.Address: {walletAlias.Object.ID(): walletAlias},
+ }
+ toAddress := wallet.chooseToAddress(consumedOutputs, optionsToAddress)
+ // nextAlias is the nft we control
+ nextAlias := alias.NewAliasOutputNext(false)
+ // transition nft owned aliases
+ unsortedOutputs := ledgerstate.Outputs{nextAlias}
+ for _, output := range toBeConsumed {
+ if output.Type() != ledgerstate.AliasOutputType {
+ continue
+ }
+ next := output.(*ledgerstate.AliasOutput).NewAliasOutputNext(true)
+ // set to self-governed by toAddress
+ next.SetGoverningAddress(nil)
+ err = next.SetStateAddress(toAddress.Address())
+ if err != nil {
+ return
+ }
+ unsortedOutputs = append(unsortedOutputs, next)
+ }
+ // we will consume the nft that owns the others too
+ toBeConsumed = append(toBeConsumed, alias)
+ unsortedInputs := toBeConsumed.Inputs()
+
+ // create essence, contains sorted inputs and outputs
+ essence := ledgerstate.NewTransactionEssence(0, time.Now(), accessPledgeNodeID, consensusPledgeNodeID, ledgerstate.NewInputs(unsortedInputs...), ledgerstate.NewOutputs(unsortedOutputs...))
+
+ toBeConsumeByID := toBeConsumed.ByID()
+ inputsInOrder := ledgerstate.Outputs{}
+ unlockBlocks := make(ledgerstate.UnlockBlocks, len(essence.Inputs()))
+ aliasInputIndex := -1
+ // find the input of alias
+ for index, input := range essence.Inputs() {
+ if input.Type() == ledgerstate.UTXOInputType {
+ casted := input.(*ledgerstate.UTXOInput)
+ if casted.ReferencedOutputID() == alias.ID() {
+ keyPair := wallet.Seed().KeyPair(walletAlias.Address.Index)
+ unlockBlock := ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes())))
+ unlockBlocks[index] = unlockBlock
+ aliasInputIndex = index
+ }
+ inputsInOrder = append(inputsInOrder, toBeConsumeByID[casted.ReferencedOutputID()])
+ }
+ }
+ if aliasInputIndex < 0 {
+ err = errors.Errorf("failed to find alias %s among prepared transaction inputs", alias.GetAliasAddress().Base58())
+ return
+ }
+ // fill rest of the unlock blocks
+ for i := range essence.Inputs() {
+ if i != aliasInputIndex {
+ unlockBlocks[i] = ledgerstate.NewAliasUnlockBlock(uint16(aliasInputIndex))
+ }
+ }
+
+ tx = ledgerstate.NewTransaction(essence, unlockBlocks)
+
+ // check tx validity (balances, unlock blocks)
+ ok, err := checkBalancesAndUnlocks(inputsInOrder, tx)
+ if err != nil {
+ return
+ }
+ if !ok {
+ err = errors.Errorf("created transaction is invalid: %s", tx.String())
+ return
+ }
+
+ wallet.markOutputsAndAddressesSpent(OutputsByAddressAndOutputID{walletAlias.Address: {
+ walletAlias.Object.ID(): walletAlias,
+ }})
+
+ err = wallet.connector.SendTransaction(tx)
+ if err != nil {
+ return
+ }
+
+ for _, output := range tx.Essence().Outputs() {
+ if output.Type() == ledgerstate.AliasOutputType {
+ casted := output.(*ledgerstate.AliasOutput)
+ if casted.GetAliasAddress().Equals(alias.GetAliasAddress()) {
+ // we skip the owned nft
+ continue
+ }
+ sweptNFTs = append(sweptNFTs, casted.GetAliasAddress())
+ }
+ }
+
+ if sweepOptions.WaitForConfirmation {
+ err = wallet.WaitForTxConfirmation(tx.ID())
+ }
+ return tx, sweptNFTs, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ServerStatus /////////////////////////////////////////////////////////////////////////////////////////////////
+
+// ServerStatus retrieves the connected server status.
+func (wallet *Wallet) ServerStatus() (status ServerStatus, err error) {
+ return wallet.connector.(*WebConnector).ServerStatus()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AllowedPledgeNodeIDs /////////////////////////////////////////////////////////////////////////////////////////
+
+// AllowedPledgeNodeIDs retrieves the allowed pledge node IDs.
+func (wallet *Wallet) AllowedPledgeNodeIDs() (res map[mana.Type][]string, err error) {
+ return wallet.connector.(*WebConnector).GetAllowedPledgeIDs()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AssetRegistry ////////////////////////////////////////////////////////////////////////////////////////////////
+
+// AssetRegistry return the internal AssetRegistry instance of the wallet.
+func (wallet *Wallet) AssetRegistry() *AssetRegistry {
+ return wallet.assetRegistry
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ReceiveAddress ///////////////////////////////////////////////////////////////////////////////////////////////
+
+// ReceiveAddress returns the last receive address of the wallet.
+func (wallet *Wallet) ReceiveAddress() address.Address {
+ return wallet.addressManager.LastUnspentAddress()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region NewReceiveAddress ////////////////////////////////////////////////////////////////////////////////////////////
+
+// NewReceiveAddress generates and returns a new unused receive address.
+func (wallet *Wallet) NewReceiveAddress() address.Address {
+ return wallet.addressManager.NewAddress()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region RemainderAddress /////////////////////////////////////////////////////////////////////////////////////////////
+
+// RemainderAddress returns the address that is used for the remainder of funds.
+func (wallet *Wallet) RemainderAddress() address.Address {
+ return wallet.addressManager.FirstUnspentAddress()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region UnspentOutputs ///////////////////////////////////////////////////////////////////////////////////////////////
+
+// UnspentOutputs returns the unspent outputs that are available for spending.
+func (wallet *Wallet) UnspentOutputs() map[address.Address]map[ledgerstate.OutputID]*Output {
+ return wallet.outputManager.UnspentOutputs(false)
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region UnspentValueOutputs //////////////////////////////////////////////////////////////////////////////////////////
+
+// UnspentValueOutputs returns the unspent value type outputs that are available for spending.
+func (wallet *Wallet) UnspentValueOutputs() map[address.Address]map[ledgerstate.OutputID]*Output {
+ return wallet.outputManager.UnspentValueOutputs(false)
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region UnspentAliasOutputs //////////////////////////////////////////////////////////////////////////////////////////
+
+// UnspentAliasOutputs returns the unspent alias outputs that are available for spending.
+func (wallet *Wallet) UnspentAliasOutputs(includePending bool) map[address.Address]map[ledgerstate.OutputID]*Output {
+ return wallet.outputManager.UnspentAliasOutputs(includePending)
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region RequestFaucetFunds ///////////////////////////////////////////////////////////////////////////////////////////
+
+// RequestFaucetFunds requests some funds from the faucet for testing purposes.
+func (wallet *Wallet) RequestFaucetFunds(waitForConfirmation ...bool) (err error) {
+ if len(waitForConfirmation) == 0 || !waitForConfirmation[0] {
+ err = wallet.connector.RequestFaucetFunds(wallet.ReceiveAddress(), wallet.faucetPowDifficulty)
+
+ return
+ }
+
+ if err = wallet.Refresh(); err != nil {
+ return
+ }
+ confirmedBalance, _, err := wallet.Balance()
+ if err != nil {
+ return
+ }
+
+ err = wallet.connector.RequestFaucetFunds(wallet.ReceiveAddress(), wallet.faucetPowDifficulty)
+ if err != nil {
+ return
+ }
+ err = wallet.waitForBalanceConfirmation(confirmedBalance)
+ return
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region Refresh //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Refresh scans the addresses for incoming transactions. If the optional rescanSpentAddresses parameter is set to true
+// we also scan the spent addresses again (this can take longer).
+func (wallet *Wallet) Refresh(rescanSpentAddresses ...bool) (err error) {
+ err = wallet.outputManager.Refresh(rescanSpentAddresses...)
+ return
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region Balance //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Balance returns the confirmed and pending balance of the funds managed by this wallet.
+func (wallet *Wallet) Balance(refresh ...bool) (confirmedBalance, pendingBalance map[ledgerstate.Color]uint64, err error) {
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ confirmedBalance = make(map[ledgerstate.Color]uint64)
+ pendingBalance = make(map[ledgerstate.Color]uint64)
+
+ // iterate through the unspent outputs
+ for addy, outputsOnAddress := range wallet.outputManager.UnspentOutputs(true) {
+ for _, output := range outputsOnAddress {
+ // skip if the output was rejected or spent already
+ if output.InclusionState.Spent || output.InclusionState.Rejected {
+ continue
+ }
+ // determine target map
+ var targetMap map[ledgerstate.Color]uint64
+ if output.InclusionState.Confirmed {
+ targetMap = confirmedBalance
+ } else {
+ targetMap = pendingBalance
+ }
+
+ switch output.Object.Type() {
+ case ledgerstate.SigLockedSingleOutputType:
+ case ledgerstate.SigLockedColoredOutputType:
+ // extract balance
+ output.Object.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ targetMap[color] += balance
+ return true
+ })
+ case ledgerstate.ExtendedLockedOutputType:
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ unlockAddyNow := casted.UnlockAddressNow(time.Now())
+ if addy.Address().Equals(unlockAddyNow) {
+ // we own this output now
+ casted.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ targetMap[color] += balance
+ return true
+ })
+ }
+ case ledgerstate.AliasOutputType:
+ casted := output.Object.(*ledgerstate.AliasOutput)
+ if casted.IsDelegated() {
+ continue
+ }
+ if casted.IsSelfGoverned() {
+ // if it is self governed, addy is the state address, so we own everything
+ casted.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ targetMap[color] += balance
+ return true
+ })
+ continue
+ }
+ if casted.GetStateAddress().Equals(addy.Address()) {
+ // we are state controller
+ casted.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ if color == ledgerstate.ColorIOTA {
+ // the minimum amount can only be moved by the governor
+ surplusIOTA := balance - ledgerstate.DustThresholdAliasOutputIOTA
+ if surplusIOTA == 0 {
+ return true
+ }
+ targetMap[color] += surplusIOTA
+ } else {
+ targetMap[color] += balance
+ }
+ return true
+ })
+ continue
+ }
+ if casted.GetGoverningAddress().Equals(addy.Address()) {
+ // we are the governor, so we only own the minimum dust amount that cannot be withdrawn by the state controller
+ targetMap[ledgerstate.ColorIOTA] += ledgerstate.DustThresholdAliasOutputIOTA
+ continue
+ }
+ }
+ }
+ }
+
+ return confirmedBalance, pendingBalance, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AvailableBalance /////////////////////////////////////////////////////////////////////////////////////////////
+
+// AvailableBalance returns the balance that is not held in aliases, and therefore can be used to fund transfers.
+func (wallet *Wallet) AvailableBalance(refresh ...bool) (confirmedBalance, pendingBalance map[ledgerstate.Color]uint64, err error) {
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ confirmedBalance = make(map[ledgerstate.Color]uint64)
+ pendingBalance = make(map[ledgerstate.Color]uint64)
+ now := time.Now()
+ // iterate through the unspent outputs
+ for addy, outputsOnAddress := range wallet.outputManager.UnspentOutputs(true) {
+ for _, output := range outputsOnAddress {
+ // skip if the output was rejected or spent already
+ if output.InclusionState.Spent || output.InclusionState.Rejected {
+ continue
+ }
+ // determine target map
+ var targetMap map[ledgerstate.Color]uint64
+ if output.InclusionState.Confirmed {
+ targetMap = confirmedBalance
+ } else {
+ targetMap = pendingBalance
+ }
+
+ switch output.Object.Type() {
+ case ledgerstate.SigLockedSingleOutputType:
+ case ledgerstate.SigLockedColoredOutputType:
+ // extract balance
+ output.Object.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ targetMap[color] += balance
+ return true
+ })
+ case ledgerstate.ExtendedLockedOutputType:
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ if casted.TimeLockedNow(now) {
+ // timelocked funds are not available
+ continue
+ }
+ unlockAddyNow := casted.UnlockAddressNow(now)
+ if addy.Address().Equals(unlockAddyNow) {
+ // we own this output now
+ casted.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ targetMap[color] += balance
+ return true
+ })
+ }
+ }
+ }
+ }
+
+ return confirmedBalance, pendingBalance, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region TimelockedBalances ///////////////////////////////////////////////////////////////////////////////////////////
+
+// TimelockedBalances returns all confirmed and pending balances that are currently timelocked.
+func (wallet *Wallet) TimelockedBalances(refresh ...bool) (confirmed, pending TimedBalanceSlice, err error) {
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ confirmed = make([]*TimedBalance, 0)
+ pending = make([]*TimedBalance, 0)
+ now := time.Now()
+
+ // iterate through the unspent outputs
+ for _, outputsOnAddress := range wallet.outputManager.UnspentOutputs(true) {
+ for _, output := range outputsOnAddress {
+ // skip if the output was rejected or spent already
+ if output.InclusionState.Spent || output.InclusionState.Rejected {
+ continue
+ }
+ if output.Object.Type() != ledgerstate.ExtendedLockedOutputType {
+ continue
+ }
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ if casted.TimeLockedNow(now) {
+ tBal := &TimedBalance{
+ Balance: casted.Balances().Map(),
+ Time: casted.TimeLock(),
+ }
+ if output.InclusionState.Confirmed {
+ confirmed = append(confirmed, tBal)
+ } else {
+ pending = append(pending, tBal)
+ }
+ }
+ }
+ }
+
+ return confirmed, pending, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ConditionalBalances //////////////////////////////////////////////////////////////////////////////////////////
+
+// ConditionalBalances returns all confirmed and pending balances that can be claimed by the wallet up to a certain time.
+func (wallet *Wallet) ConditionalBalances(refresh ...bool) (confirmed, pending TimedBalanceSlice, err error) {
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ confirmed = make(TimedBalanceSlice, 0)
+ pending = make(TimedBalanceSlice, 0)
+ now := time.Now()
+
+ // iterate through the unspent outputs
+ for addy, outputsOnAddress := range wallet.outputManager.UnspentOutputs(true) {
+ for _, output := range outputsOnAddress {
+ // skip if the output was rejected or spent already
+ if output.InclusionState.Spent || output.InclusionState.Rejected {
+ continue
+ }
+ if output.Object.Type() != ledgerstate.ExtendedLockedOutputType {
+ continue
+ }
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ _, fallbackDeadline := casted.FallbackOptions()
+ if !fallbackDeadline.IsZero() && addy.Address().Equals(casted.UnlockAddressNow(now)) {
+ // fallback option is set and currently we are the unlock address
+ cBal := &TimedBalance{
+ Balance: casted.Balances().Map(),
+ Time: fallbackDeadline,
+ }
+ if output.InclusionState.Confirmed {
+ confirmed = append(confirmed, cBal)
+ } else {
+ pending = append(pending, cBal)
+ }
+ }
+ }
+ }
+
+ return confirmed, pending, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AliasBalance /////////////////////////////////////////////////////////////////////////////////////////////////
+
+// AliasBalance returns the aliases held by this wallet
+func (wallet *Wallet) AliasBalance(refresh ...bool) (
+ confirmedGovernedAliases,
+ confirmedStateControlledAliases,
+ pendingGovernedAliases,
+ pendingStateControlledAliases map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput,
+ err error,
+) {
+ confirmedGovernedAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+ confirmedStateControlledAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+ pendingGovernedAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+ pendingStateControlledAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ aliasOutputs := wallet.UnspentAliasOutputs(true)
+
+ for addr, outputIDToOutputMap := range aliasOutputs {
+ for _, output := range outputIDToOutputMap {
+ if output.Object.Type() != ledgerstate.AliasOutputType {
+ continue
+ }
+ // skip if the output was rejected or spent already
+ if output.InclusionState.Spent || output.InclusionState.Rejected {
+ continue
+ }
+ // target maps
+ var governedAliases, stateControlledAliases map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput
+ if output.InclusionState.Confirmed {
+ governedAliases = confirmedGovernedAliases
+ stateControlledAliases = confirmedStateControlledAliases
+ } else {
+ governedAliases = pendingGovernedAliases
+ stateControlledAliases = pendingStateControlledAliases
+ }
+ alias := output.Object.(*ledgerstate.AliasOutput)
+ if alias.GetGoverningAddress().Equals(addr.Address()) {
+ // alias is governed by the wallet
+ governedAliases[*alias.GetAliasAddress()] = alias
+ }
+ if alias.GetStateAddress().Equals(addr.Address()) {
+ // alias is state controlled by the wallet
+ stateControlledAliases[*alias.GetAliasAddress()] = alias
+ }
+ }
+ }
+ return confirmedGovernedAliases, confirmedStateControlledAliases, pendingGovernedAliases, pendingStateControlledAliases, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AvailableOutputsOnNFT ////////////////////////////////////////////////////////////////////////////////////////
+
+// AvailableOutputsOnNFT returns all outputs that are either owned (SigLocked***, Extended, stateControlled Alias) or governed
+// (governance controlled alias outputs) and are not currently locked.
+func (wallet Wallet) AvailableOutputsOnNFT(nftID string) (owned, governed ledgerstate.Outputs, err error) {
+ aliasAddress, err := ledgerstate.AliasAddressFromBase58EncodedString(nftID)
+ if err != nil {
+ return
+ }
+ res, err := wallet.connector.UnspentOutputs(address.Address{AddressBytes: aliasAddress.Array()})
+ if err != nil {
+ return
+ }
+ outputs := res.ToLedgerStateOutputs()
+ now := time.Now()
+ for _, o := range outputs {
+ switch o.Type() {
+ case ledgerstate.SigLockedSingleOutputType, ledgerstate.SigLockedColoredOutputType:
+ owned = append(owned, o)
+ case ledgerstate.ExtendedLockedOutputType:
+ casted := o.(*ledgerstate.ExtendedLockedOutput)
+ if casted.UnlockAddressNow(now).Equals(aliasAddress) && !casted.TimeLockedNow(now) {
+ owned = append(owned, o)
+ }
+ case ledgerstate.AliasOutputType:
+ casted := o.(*ledgerstate.AliasOutput)
+ // the alias output of aliasAddress is filtered out
+ if casted.GetStateAddress().Equals(aliasAddress) && !casted.DelegationTimeLockedNow(now) {
+ owned = append(owned, o)
+ } else if casted.GetGoverningAddress().Equals(aliasAddress) && !casted.DelegationTimeLockedNow(now) {
+ governed = append(governed, o)
+ }
+ }
+ }
+ return owned, governed, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region DelegatedAliasBalance ////////////////////////////////////////////////////////////////////////////////////////
+
+// DelegatedAliasBalance returns the pending and confirmed aliases that are delegated.
+func (wallet *Wallet) DelegatedAliasBalance(refresh ...bool) (
+ confirmedDelegatedAliases map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput,
+ pendingDelegatedAliases map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput,
+ err error,
+) {
+ confirmedDelegatedAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+ pendingDelegatedAliases = map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput{}
+
+ shouldRefresh := true
+ if len(refresh) > 0 {
+ shouldRefresh = refresh[0]
+ }
+ if shouldRefresh {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+ }
+
+ aliasOutputs := wallet.UnspentAliasOutputs(true)
+
+ for addr, outputIDToOutputMap := range aliasOutputs {
+ for _, output := range outputIDToOutputMap {
+ if output.Object.Type() != ledgerstate.AliasOutputType {
+ continue
+ }
+ alias := output.Object.(*ledgerstate.AliasOutput)
+ // skip if the output was rejected, spent already or not a delegated one
+ if output.InclusionState.Spent || output.InclusionState.Rejected || !alias.IsDelegated() {
+ continue
+ }
+ // target maps
+ var delegatedAliases map[ledgerstate.AliasAddress]*ledgerstate.AliasOutput
+ if output.InclusionState.Confirmed {
+ delegatedAliases = confirmedDelegatedAliases
+ } else {
+ delegatedAliases = pendingDelegatedAliases
+ }
+ if alias.GetGoverningAddress().Equals(addr.Address()) {
+ // alias is governed by the wallet (and we previously checked that it is delegated)
+ delegatedAliases[*alias.GetAliasAddress()] = alias
}
}
}
+ return confirmedDelegatedAliases, pendingDelegatedAliases, err
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region Seed /////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// Seed returns the seed of this wallet that is used to generate all of the wallets addresses and private keys.
+func (wallet *Wallet) Seed() *seed.Seed {
+ return wallet.addressManager.seed
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AddressManager ///////////////////////////////////////////////////////////////////////////////////////////////
+
+// AddressManager returns the manager for the addresses of this wallet.
+func (wallet *Wallet) AddressManager() *AddressManager {
+ return wallet.addressManager
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ExportState //////////////////////////////////////////////////////////////////////////////////////////////////
+
+// ExportState exports the current state of the wallet to a marshaled version.
+func (wallet *Wallet) ExportState() []byte {
+ marshalUtil := marshalutil.New()
+ marshalUtil.WriteBytes(wallet.Seed().Bytes())
+ marshalUtil.WriteUint64(wallet.AddressManager().lastAddressIndex)
+ marshalUtil.WriteBytes(wallet.assetRegistry.Bytes())
+ marshalUtil.WriteBytes(*(*[]byte)(unsafe.Pointer(&wallet.addressManager.spentAddresses)))
+
+ return marshalUtil.Bytes()
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region WaitForTxConfirmation ////////////////////////////////////////////////////////////////////////////////////////
+
+// WaitForTxConfirmation waits for the given tx to confirm. If the transaction is rejected, an error is returned.
+func (wallet *Wallet) WaitForTxConfirmation(txID ledgerstate.TransactionID) (err error) {
+ timeoutCounter := 0
+ for {
+ time.Sleep(time.Duration(wallet.ConfirmationPollInterval) * time.Millisecond)
+ timeoutCounter += wallet.ConfirmationPollInterval
+ state, fetchErr := wallet.connector.GetTransactionInclusionState(txID)
+ if fetchErr != nil {
+ return fetchErr
+ }
+ if state == ledgerstate.Confirmed {
+ return
+ }
+ if state == ledgerstate.Rejected {
+ return errors.Errorf("transaction %s has been rejected", txID.Base58())
+ }
+ if timeoutCounter > wallet.ConfirmationTimeout {
+ return errors.Errorf("transaction %s did not confirm within %d seconds", txID.Base58(), wallet.ConfirmationTimeout/milliSeconds)
+ }
+ }
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
- // update remainder address with default value (first unspent address) if none was provided
- if sendFundsOptions.RemainderAddress == address.AddressEmpty {
- sendFundsOptions.RemainderAddress = wallet.RemainderAddress()
+// region Internal Methods /////////////////////////////////////////////////////////////////////////////////////////////
+
+// waitForBalanceConfirmation waits until the balance of the wallet changes compared to the provided argument.
+// (a transaction modifying the wallet balance got confirmed)
+func (wallet *Wallet) waitForBalanceConfirmation(prevConfirmedBalance map[ledgerstate.Color]uint64) (err error) {
+ timeoutCounter := 0
+ for {
+ time.Sleep(time.Duration(wallet.ConfirmationPollInterval) * time.Millisecond)
+ timeoutCounter += wallet.ConfirmationPollInterval
+ if err = wallet.Refresh(); err != nil {
+ return
+ }
+ newConfirmedBalance, _, balanceErr := wallet.Balance()
+ if balanceErr != nil {
+ err = balanceErr
+ return
+ }
+ if !reflect.DeepEqual(prevConfirmedBalance, newConfirmedBalance) {
+ return
+ }
+ if timeoutCounter > wallet.ConfirmationTimeout {
+ return errors.Errorf("confirmed balance did not change within timeout limit (%d)", wallet.ConfirmationTimeout/milliSeconds)
+ }
}
- if _, remainderAddressInConsumedOutputs := outputsToConsume[sendFundsOptions.RemainderAddress]; remainderAddressInConsumedOutputs && !wallet.reusableAddress {
- sendFundsOptions.RemainderAddress = wallet.ReceiveAddress()
+}
+
+// waitForGovAliasBalanceConfirmation waits until the balance of the confirmed governed aliases changes in the wallet.
+// (a tx submitting an alias governance transition is confirmed)
+func (wallet *Wallet) waitForGovAliasBalanceConfirmation(preGovAliasBalance map[*ledgerstate.AliasAddress]*ledgerstate.AliasOutput) (err error) {
+ for {
+ time.Sleep(time.Duration(wallet.ConfirmationPollInterval) * time.Millisecond)
+ if err = wallet.Refresh(); err != nil {
+ return
+ }
+ newGovAliasBalance, _, _, _, balanceErr := wallet.AliasBalance()
+ if balanceErr != nil {
+ err = balanceErr
+ return
+ }
+ if !reflect.DeepEqual(preGovAliasBalance, newGovAliasBalance) {
+ return
+ }
}
- if _, remainderAddressInConsumedOutputs := outputsToConsume[sendFundsOptions.RemainderAddress]; remainderAddressInConsumedOutputs && !wallet.reusableAddress {
- sendFundsOptions.RemainderAddress = wallet.NewReceiveAddress()
+}
+
+// waitForStateAliasBalanceConfirmation waits until the balance of the state controlled aliases changes in the wallet.
+// (a tx submitting an alias state transition is confirmed)
+func (wallet *Wallet) waitForStateAliasBalanceConfirmation(preStateAliasBalance map[*ledgerstate.AliasAddress]*ledgerstate.AliasOutput) (err error) {
+ for {
+ time.Sleep(time.Duration(wallet.ConfirmationPollInterval) * time.Millisecond)
+
+ if err = wallet.Refresh(); err != nil {
+ return
+ }
+ _, newStateAliasBalance, _, _, balanceErr := wallet.AliasBalance()
+ if balanceErr != nil {
+ err = balanceErr
+
+ return
+ }
+
+ if !reflect.DeepEqual(preStateAliasBalance, newStateAliasBalance) {
+ return
+ }
}
+}
- // check if we have found all required funds
- if len(requiredFunds) != 0 {
- outputsToConsume = nil
- err = errors.New("not enough funds to create transaction")
+// derivePledgeIDs returns the mana pledge IDs from the provided options.
+func (wallet *Wallet) derivePledgeIDs(aIDFromOptions, cIDFromOptions string) (aID, cID identity.ID, err error) {
+ // determine pledge IDs
+ allowedPledgeNodeIDs, err := wallet.connector.GetAllowedPledgeIDs()
+ if err != nil {
+ return
+ }
+ if aIDFromOptions == "" {
+ aID, err = mana.IDFromStr(allowedPledgeNodeIDs[mana.AccessMana][0])
+ } else {
+ aID, err = mana.IDFromStr(aIDFromOptions)
+ }
+ if err != nil {
+ return
}
+ if cIDFromOptions == "" {
+ cID, err = mana.IDFromStr(allowedPledgeNodeIDs[mana.AccessMana][0])
+ } else {
+ cID, err = mana.IDFromStr(cIDFromOptions)
+ }
return
}
-func (wallet *Wallet) buildInputs(outputsToUseAsInputs map[address.Address]map[ledgerstate.OutputID]*Output) (inputs ledgerstate.Inputs, consumedFunds map[ledgerstate.Color]uint64) {
- consumedInputs := make(ledgerstate.Inputs, 0)
- consumedFunds = make(map[ledgerstate.Color]uint64)
- for _, unspentOutputsOfAddress := range outputsToUseAsInputs {
- i := uint16(0)
- for outputID, output := range unspentOutputsOfAddress {
- input := ledgerstate.NewUTXOInput(outputID)
- consumedInputs = append(consumedInputs, input)
- i++
- output.Balances.ForEach(func(color ledgerstate.Color, balance uint64) bool {
- consumedFunds[color] += balance
+// findGovernedAliasOutputByAliasID tries to load the output with given alias address from output manager that is governed by this wallet.
+func (wallet *Wallet) findGovernedAliasOutputByAliasID(id *ledgerstate.AliasAddress) (res *Output, err error) {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+
+ unspentAliasOutputs := wallet.outputManager.UnspentAliasOutputs(false)
+ for _, outputIDMap := range unspentAliasOutputs {
+ for _, output := range outputIDMap {
+ if output.Object.Address().Equals(id) && output.Object.(*ledgerstate.AliasOutput).GetGoverningAddress().Equals(output.Address.Address()) {
+ res = output
+ return res, nil
+ }
+ }
+ }
+ err = errors.Errorf("couldn't find aliasID %s in the wallet that is owned for governance", id.Base58())
+ return nil, err
+}
+
+// findStateControlledAliasOutputByAliasID tries to load the output with given alias address from output manager that is state controlled by this wallet.
+func (wallet *Wallet) findStateControlledAliasOutputByAliasID(id *ledgerstate.AliasAddress) (res *Output, err error) {
+ err = wallet.outputManager.Refresh()
+ if err != nil {
+ return
+ }
+
+ unspentAliasOutputs := wallet.outputManager.UnspentAliasOutputs(false)
+ for _, outputIDMap := range unspentAliasOutputs {
+ for _, output := range outputIDMap {
+ if output.Object.Address().Equals(id) && output.Object.(*ledgerstate.AliasOutput).GetStateAddress().Equals(output.Address.Address()) {
+ res = output
+ return res, nil
+ }
+ }
+ }
+ err = errors.Errorf("couldn't find aliasID %s in the wallet that is state controlled by the wallet", id.Base58())
+ return nil, err
+}
+
+// collectOutputsForFunding tries to collect unspent outputs to fund fundingBalance
+func (wallet *Wallet) collectOutputsForFunding(fundingBalance map[ledgerstate.Color]uint64) (OutputsByAddressAndOutputID, error) {
+ if fundingBalance == nil {
+ return nil, errors.Errorf("can't collect fund: empty fundingBalance provided")
+ }
+
+ _ = wallet.outputManager.Refresh()
+ addresses := wallet.addressManager.Addresses()
+ unspentOutputs := wallet.outputManager.UnspentValueOutputs(false, addresses...)
+
+ collected := make(map[ledgerstate.Color]uint64)
+ outputsToConsume := NewAddressToOutputs()
+ numOfCollectedOutputs := 0
+ now := time.Now()
+ for _, addy := range addresses {
+ for outputID, output := range unspentOutputs[addy] {
+ if output.InclusionState.Spent || !output.InclusionState.Confirmed {
+ // skip counting spent and not confirmed outputs
+ continue
+ }
+ if output.Object.Type() == ledgerstate.ExtendedLockedOutputType {
+ casted := output.Object.(*ledgerstate.ExtendedLockedOutput)
+ if casted.TimeLockedNow(now) || !casted.UnlockAddressNow(now).Equals(addy.Address()) {
+ // skip the output because we wouldn't be able to unlock it
+ continue
+ }
+ }
+ contributingOutput := false
+ output.Object.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ _, has := fundingBalance[color]
+ if has {
+ collected[color] += balance
+ contributingOutput = true
+ }
return true
})
+ if contributingOutput {
+ // store the output in the outputs to use for the transfer
+ if _, addressEntryExists := outputsToConsume[addy]; !addressEntryExists {
+ outputsToConsume[addy] = make(map[ledgerstate.OutputID]*Output)
+ }
+ outputsToConsume[addy][outputID] = output
+ numOfCollectedOutputs++
+ if enoughCollected(collected, fundingBalance) && numOfCollectedOutputs <= ledgerstate.MaxInputCount {
+ return outputsToConsume, nil
+ }
+ }
}
}
- inputs = ledgerstate.NewInputs(consumedInputs...)
- return
+
+ if enoughCollected(collected, fundingBalance) && numOfCollectedOutputs > ledgerstate.MaxOutputCount {
+ return outputsToConsume, errors.Errorf("failed to collect outputs: %w", ErrTooManyOutputs)
+ }
+
+ return nil, errors.Errorf("failed to gather initial funds \n %s, there are only \n %s funds available",
+ ledgerstate.NewColoredBalances(fundingBalance).String(),
+ ledgerstate.NewColoredBalances(collected).String(),
+ )
+}
+
+// enoughCollected checks if collected has at least target funds
+func enoughCollected(collected, target map[ledgerstate.Color]uint64) bool {
+ for color, balance := range target {
+ if collected[color] < balance {
+ return false
+ }
+ }
+ return true
+}
+
+// buildInputs builds a list of deterministically sorted inputs from the provided OutputsByAddressAndOutputID mapping.
+func (wallet *Wallet) buildInputs(addressToIDToOutput OutputsByAddressAndOutputID) ledgerstate.Inputs {
+ unsortedInputs := ledgerstate.Inputs{}
+ for _, outputIDToOutputMap := range addressToIDToOutput {
+ for _, output := range outputIDToOutputMap {
+ unsortedInputs = append(unsortedInputs, output.Object.Input())
+ }
+ }
+ return ledgerstate.NewInputs(unsortedInputs...)
}
-func (wallet *Wallet) buildOutputs(sendFundsOptions *sendFundsOptions, consumedFunds map[ledgerstate.Color]uint64) (outputs ledgerstate.Outputs) {
+// buildOutputs builds outputs based on desired destination balances and consumedFunds. If consumedFunds is greater, than
+// the destination funds, remainderAddress specifies where the remaining amount is put.
+func (wallet *Wallet) buildOutputs(
+ sendOptions *sendoptions.SendFundsOptions,
+ consumedFunds map[ledgerstate.Color]uint64,
+ remainderAddress address.Address,
+) (outputs ledgerstate.Outputs) {
// build outputs for destinations
outputsByColor := make(map[address.Address]map[ledgerstate.Color]uint64)
- for walletAddress, coloredBalances := range sendFundsOptions.Destinations {
+ for walletAddress, coloredBalances := range sendOptions.Destinations {
if _, addressExists := outputsByColor[walletAddress]; !addressExists {
outputsByColor[walletAddress] = make(map[ledgerstate.Color]uint64)
}
@@ -465,26 +2194,126 @@ func (wallet *Wallet) buildOutputs(sendFundsOptions *sendFundsOptions, consumedF
}
}
}
+ // construct result
+ var outputsSlice []ledgerstate.Output
- // build outputs for remainder
+ // add output for remainder
if len(consumedFunds) != 0 {
- if _, addressExists := outputsByColor[sendFundsOptions.RemainderAddress]; !addressExists {
- outputsByColor[sendFundsOptions.RemainderAddress] = make(map[ledgerstate.Color]uint64)
- }
+ outputsSlice = append(outputsSlice, ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(consumedFunds), remainderAddress.Address()))
+ }
- for color, amount := range consumedFunds {
- outputsByColor[sendFundsOptions.RemainderAddress][color] += amount
+ for addr, outputBalanceMap := range outputsByColor {
+ coloredBalances := ledgerstate.NewColoredBalances(outputBalanceMap)
+ var output ledgerstate.Output
+ if !sendOptions.LockUntil.IsZero() || !sendOptions.FallbackDeadline.IsZero() || sendOptions.FallbackAddress != nil {
+ extended := ledgerstate.NewExtendedLockedOutput(outputBalanceMap, addr.Address())
+ if !sendOptions.LockUntil.IsZero() {
+ extended = extended.WithTimeLock(sendOptions.LockUntil)
+ }
+ if !sendOptions.FallbackDeadline.IsZero() && sendOptions.FallbackAddress != nil {
+ extended = extended.WithFallbackOptions(sendOptions.FallbackAddress, sendOptions.FallbackDeadline)
+ }
+ output = extended
+ } else {
+ output = ledgerstate.NewSigLockedColoredOutput(coloredBalances, addr.Address())
}
- }
- // construct result
- var outputsSlice []ledgerstate.Output
- for addr, outputs := range outputsByColor {
- coloredBalances := ledgerstate.NewColoredBalances(outputs)
- output := ledgerstate.NewSigLockedColoredOutput(coloredBalances, addr.Address())
outputsSlice = append(outputsSlice, output)
}
outputs = ledgerstate.NewOutputs(outputsSlice...)
return
}
+
+// buildUnlockBlocks constructs the unlock blocks for a transaction.
+func (wallet *Wallet) buildUnlockBlocks(inputs ledgerstate.Inputs, consumedOutputsByID OutputsByID, essence *ledgerstate.TransactionEssence) (unlocks ledgerstate.UnlockBlocks, inputsInOrder ledgerstate.Outputs) {
+ unlocks = make([]ledgerstate.UnlockBlock, len(inputs))
+ existingUnlockBlocks := make(map[address.Address]uint16)
+ for outputIndex, input := range inputs {
+ output := consumedOutputsByID[input.(*ledgerstate.UTXOInput).ReferencedOutputID()]
+ inputsInOrder = append(inputsInOrder, output.Object)
+ if unlockBlockIndex, unlockBlockExists := existingUnlockBlocks[output.Address]; unlockBlockExists {
+ unlocks[outputIndex] = ledgerstate.NewReferenceUnlockBlock(unlockBlockIndex)
+ continue
+ }
+
+ keyPair := wallet.Seed().KeyPair(output.Address.Index)
+ unlockBlock := ledgerstate.NewSignatureUnlockBlock(ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(essence.Bytes())))
+ unlocks[outputIndex] = unlockBlock
+ existingUnlockBlocks[output.Address] = uint16(outputIndex)
+ }
+ return
+}
+
+// markOutputsAndAddressesSpent marks consumed outputs and their addresses as spent.
+func (wallet *Wallet) markOutputsAndAddressesSpent(consumedOutputs OutputsByAddressAndOutputID) {
+ // mark outputs as spent
+ for addr, outputs := range consumedOutputs {
+ for outputID := range outputs {
+ wallet.outputManager.MarkOutputSpent(addr, outputID)
+ }
+ }
+
+ // mark addresses as spent
+ if !wallet.reusableAddress {
+ for addr := range consumedOutputs {
+ wallet.addressManager.MarkAddressSpent(addr.Index)
+ }
+ }
+}
+
+// chooseRemainderAddress chooses an appropriate remainder address based on the wallet configuration and where we are spending from.
+func (wallet *Wallet) chooseRemainderAddress(consumedOutputs OutputsByAddressAndOutputID, optionsRemainder address.Address) (remainder address.Address) {
+ if optionsRemainder == address.AddressEmpty {
+ if wallet.reusableAddress {
+ return wallet.RemainderAddress()
+ }
+ _, spendFromRemainderAddress := consumedOutputs[wallet.RemainderAddress()]
+ _, spendFromReceiveAddress := consumedOutputs[wallet.ReceiveAddress()]
+ if spendFromRemainderAddress && spendFromReceiveAddress {
+ // we are about to spend from both
+ return wallet.NewReceiveAddress()
+ }
+ if spendFromRemainderAddress && !spendFromReceiveAddress {
+ // we are about to spend from remainder, but not from receive
+ return wallet.ReceiveAddress()
+ }
+ // we are not spending from remainder
+ return wallet.RemainderAddress()
+ }
+ return optionsRemainder
+}
+
+// chooseToAddress chooses an appropriate toAddress based on the wallet configuration and where we are spending from.
+func (wallet *Wallet) chooseToAddress(consumedOutputs OutputsByAddressAndOutputID, optionsToAddress address.Address) (toAddress address.Address) {
+ if optionsToAddress == address.AddressEmpty {
+ if wallet.reusableAddress {
+ return wallet.ReceiveAddress()
+ }
+ _, spendFromRemainderAddress := consumedOutputs[wallet.RemainderAddress()]
+ _, spendFromReceiveAddress := consumedOutputs[wallet.ReceiveAddress()]
+ if spendFromRemainderAddress && spendFromReceiveAddress {
+ // we are about to spend from both
+ return wallet.NewReceiveAddress()
+ }
+ if spendFromRemainderAddress && !spendFromReceiveAddress {
+ // we are about to spend from remainder, but not from receive
+ return wallet.ReceiveAddress()
+ }
+ // we are not spending from remainder
+ return wallet.RemainderAddress()
+ }
+ return optionsToAddress
+}
+
+// checkBalancesAndUnlocks checks if tx balances are okay and unlock blocks are valid.
+func checkBalancesAndUnlocks(inputs ledgerstate.Outputs, tx *ledgerstate.Transaction) (bool, error) {
+ balancesValid := ledgerstate.TransactionBalancesValid(inputs, tx.Essence().Outputs())
+ unlocksValid, err := ledgerstate.UnlockBlocksValidWithError(inputs, tx)
+ if err != nil {
+ return false, err
+ }
+ return balancesValid && unlocksValid, nil
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/client/wallet/wallet_test.go b/client/wallet/wallet_test.go
deleted file mode 100644
index b39b62ce1b..0000000000
--- a/client/wallet/wallet_test.go
+++ /dev/null
@@ -1,258 +0,0 @@
-package wallet
-
-import (
- "crypto/rand"
- "testing"
-
- "github.com/iotaledger/hive.go/bitmask"
- "github.com/iotaledger/hive.go/identity"
- "github.com/mr-tron/base58"
- "github.com/stretchr/testify/assert"
-
- "github.com/iotaledger/goshimmer/client/wallet/packages/address"
- walletaddr "github.com/iotaledger/goshimmer/client/wallet/packages/address"
- walletseed "github.com/iotaledger/goshimmer/client/wallet/packages/seed"
- "github.com/iotaledger/goshimmer/packages/ledgerstate"
- "github.com/iotaledger/goshimmer/packages/mana"
-)
-
-func TestWallet_SendFunds(t *testing.T) {
- // create test seed
- senderSeed := walletseed.NewSeed()
- receiverSeed := walletseed.NewSeed()
-
- // define sub-tests by providing a list of parameters and a validator function
- testCases := []struct {
- name string
- parameters []SendFundsOption
- validator func(t *testing.T, tx *ledgerstate.Transaction, err error)
- }{
- // test if not providing a destination triggers an error
- {
- name: "missingDestination",
- parameters: []SendFundsOption{
- Remainder(address.AddressEmpty),
- },
- validator: func(t *testing.T, tx *ledgerstate.Transaction, err error) {
- assert.True(t, tx == nil, "the transaction should be nil")
- assert.Error(t, err, "calling SendFunds without a Destination should trigger an error")
- assert.Equal(t, "you need to provide at least one Destination for a valid transfer to be issued", err.Error(), "the error message is wrong")
- },
- },
-
- // test if providing an invalid destination (amount <= 0) triggers an error
- {
- name: "zeroAmount",
- parameters: []SendFundsOption{
- Destination(address.AddressEmpty, 1),
- Destination(address.AddressEmpty, 0),
- Destination(address.AddressEmpty, 123),
- },
- validator: func(t *testing.T, tx *ledgerstate.Transaction, err error) {
- assert.True(t, tx == nil, "the transaction should be nil")
- assert.Error(t, err, "calling SendFunds without an invalid Destination (amount <= 0) should trigger an error")
- assert.Equal(t, "the amount provided in the destinations needs to be larger than 0", err.Error(), "the error message is wrong")
- },
- },
-
- // test if a valid transaction can be created
- {
- name: "validTransfer",
- parameters: []SendFundsOption{
- Destination(receiverSeed.Address(0), 1999),
- },
- validator: func(t *testing.T, tx *ledgerstate.Transaction, err error) {
- assert.False(t, tx == nil, "there should be a transaction created")
- assert.Nil(t, err)
- assert.True(t, ledgerstate.UnlockBlocksValid(ledgerstate.NewOutputs(
- ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(map[ledgerstate.Color]uint64{
- ledgerstate.ColorIOTA: 1337,
- {3}: 1338,
- }), senderSeed.Address(0).Address()).SetID(ledgerstate.NewOutputID(ledgerstate.TransactionID{3}, 0)),
- ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(map[ledgerstate.Color]uint64{
- ledgerstate.ColorIOTA: 663,
- {4}: 1338,
- }), senderSeed.Address(0).Address()).SetID(ledgerstate.NewOutputID(ledgerstate.TransactionID{3}, 0)),
- ), tx))
- },
- },
-
- // test if a valid transaction having a colored coin can be created
- {
- name: "validColoredTransfer",
- parameters: []SendFundsOption{
- Destination(receiverSeed.Address(0), 1200, ledgerstate.ColorMint),
- },
- validator: func(t *testing.T, tx *ledgerstate.Transaction, err error) {
- assert.False(t, tx == nil, "there should be a transaction created")
- assert.Nil(t, err)
- },
- },
- }
-
- // execute sub-tests and hand in the results to the validator function
- for _, testCase := range testCases {
- t.Run(testCase.name, func(t *testing.T) {
- // create mocked connector
- mockedConnector := newMockConnector(
- &Output{
- Address: senderSeed.Address(0),
- OutputID: ledgerstate.NewOutputID(ledgerstate.GenesisTransactionID, 0),
- Balances: ledgerstate.NewColoredBalances(map[ledgerstate.Color]uint64{
- ledgerstate.ColorIOTA: 1337,
- {3}: 1338,
- }),
- InclusionState: InclusionState{
- Liked: true,
- Confirmed: true,
- },
- },
- &Output{
- Address: senderSeed.Address(0),
- OutputID: ledgerstate.NewOutputID(ledgerstate.TransactionID{3}, 0),
- Balances: ledgerstate.NewColoredBalances(map[ledgerstate.Color]uint64{
- ledgerstate.ColorIOTA: 663,
- {4}: 1338,
- }),
- InclusionState: InclusionState{
- Liked: true,
- Confirmed: true,
- },
- },
- )
-
- // create our test wallet
- wallet := New(
- Import(senderSeed, 2, []bitmask.BitMask{}, NewAssetRegistry()),
- GenericConnector(mockedConnector),
- )
-
- // validate the result of the function call
- tx, err := wallet.SendFunds(testCase.parameters...)
- testCase.validator(t, tx, err)
- })
- }
-}
-
-type mockConnector struct {
- outputs map[address.Address]map[ledgerstate.OutputID]*Output
-}
-
-func (connector *mockConnector) GetAllowedPledgeIDs() (pledgeIDMap map[mana.Type][]string, err error) {
- res := map[mana.Type][]string{
- mana.AccessMana: {base58.Encode(identity.GenerateIdentity().ID().Bytes())},
- mana.ConsensusMana: {base58.Encode(identity.GenerateIdentity().ID().Bytes())},
- }
- return res, nil
-}
-
-func (connector *mockConnector) RequestFaucetFunds(addr walletaddr.Address) (err error) {
- // generate random transaction id
- idBytes := make([]byte, ledgerstate.OutputIDLength)
- _, err = rand.Read(idBytes)
- if err != nil {
- return
- }
- outputID, _, err := ledgerstate.OutputIDFromBytes(idBytes)
- if err != nil {
- return
- }
-
- newOutput := &Output{
- Address: addr,
- OutputID: outputID,
- Balances: ledgerstate.NewColoredBalances(map[ledgerstate.Color]uint64{
- ledgerstate.ColorIOTA: 1337,
- }),
- InclusionState: InclusionState{
- Liked: true,
- Confirmed: true,
- Rejected: false,
- Conflicting: false,
- Spent: false,
- },
- }
-
- if _, addressExists := connector.outputs[addr]; !addressExists {
- connector.outputs[addr] = make(map[ledgerstate.OutputID]*Output)
- }
- connector.outputs[addr][outputID] = newOutput
-
- return
-}
-
-func (connector *mockConnector) SendTransaction(tx *ledgerstate.Transaction) (err error) {
- // mark outputs as spent
- //for _, input := range tx.Essence().Inputs() {
- //if input.Type() == ledgerstate.UTXOInputType {
- //utxoInput := input.(*ledgerstate.UTXOInput)
- //outputID := utxoInput.ReferencedOutputID()
- //connector.outputs[.Address()][outputID.TransactionID()].InclusionState.Spent = true
- //}
- //}
-
- // create new outputs
- //tx.Outputs().ForEach(func(addr address.Address, balances []*balance.Balance) bool {
- // // initialize missing address entry
- // if _, addressExists := connector.outputs[addr]; !addressExists {
- // connector.outputs[addr] = make(map[transaction.ID]*Output)
- // }
- //
- // // translate balances to mockConnector specific balances
- // outputBalances := make(map[balance.Color]uint64)
- // for _, coloredBalance := range balances {
- // outputBalances[coloredBalance.Color] += uint64(coloredBalance.Value)
- // }
- //
- // // store new output
- // connector.outputs[addr][tx.ID()] = &Output{
- // Address: addr,
- // TransactionID: tx.ID(),
- // Balances: outputBalances,
- // InclusionState: InclusionState{
- // Liked: true,
- // Confirmed: true,
- // Rejected: false,
- // Conflicting: false,
- // Spent: false,
- // },
- // }
- //
- // return true
- //})
-
- return
-}
-
-func newMockConnector(outputs ...*Output) (connector *mockConnector) {
- connector = &mockConnector{
- outputs: make(map[address.Address]map[ledgerstate.OutputID]*Output),
- }
-
- for _, output := range outputs {
- if _, addressExists := connector.outputs[output.Address]; !addressExists {
- connector.outputs[output.Address] = make(map[ledgerstate.OutputID]*Output)
- }
-
- connector.outputs[output.Address][output.OutputID] = output
- }
-
- return
-}
-
-func (connector *mockConnector) UnspentOutputs(addresses ...walletaddr.Address) (outputs map[address.Address]map[ledgerstate.OutputID]*Output, err error) {
- outputs = make(map[address.Address]map[ledgerstate.OutputID]*Output)
- for _, addr := range addresses {
- for outputID, output := range connector.outputs[addr] {
- if !output.InclusionState.Spent {
- if _, outputsExist := outputs[addr]; !outputsExist {
- outputs[addr] = make(map[ledgerstate.OutputID]*Output)
- }
-
- outputs[addr][outputID] = output
- }
- }
- }
-
- return
-}
diff --git a/client/wallet/webconnector.go b/client/wallet/webconnector.go
index cd572dc286..522d44f7e0 100644
--- a/client/wallet/webconnector.go
+++ b/client/wallet/webconnector.go
@@ -1,6 +1,8 @@
package wallet
import (
+ "github.com/cockroachdb/errors"
+
"github.com/iotaledger/goshimmer/client"
"github.com/iotaledger/goshimmer/client/wallet/packages/address"
"github.com/iotaledger/goshimmer/packages/ledgerstate"
@@ -31,19 +33,20 @@ func (webConnector *WebConnector) ServerStatus() (status ServerStatus, err error
status.Synced = response.TangleTime.Synced
status.Version = response.Version
status.ManaDecay = response.ManaDecay
+ status.DelegationAddress = response.ManaDelegationAddress
return
}
// RequestFaucetFunds request some funds from the faucet for test purposes.
-func (webConnector *WebConnector) RequestFaucetFunds(addr address.Address) (err error) {
- _, err = webConnector.client.SendFaucetRequest(addr.Address().Base58())
+func (webConnector *WebConnector) RequestFaucetFunds(addr address.Address, powTarget int) (err error) {
+ _, err = webConnector.client.SendFaucetRequest(addr.Address().Base58(), powTarget)
return
}
// UnspentOutputs returns the outputs of transactions on the given addresses that have not been spent yet.
-func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (unspentOutputs map[address.Address]map[ledgerstate.OutputID]*Output, err error) {
+func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (unspentOutputs OutputsByAddressAndOutputID, err error) {
// build reverse lookup table + arguments for client call
addressReverseLookupTable := make(map[string]address.Address)
base58EncodedAddresses := make([]string, len(addresses))
@@ -53,7 +56,7 @@ func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (u
}
// request unspent outputs
- response, err := webConnector.client.GetUnspentOutputs(base58EncodedAddresses)
+ response, err := webConnector.client.PostAddressUnspentOutputs(base58EncodedAddresses)
if err != nil {
return
}
@@ -62,36 +65,22 @@ func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (u
unspentOutputs = make(map[address.Address]map[ledgerstate.OutputID]*Output)
for _, unspentOutput := range response.UnspentOutputs {
// lookup wallet address from raw address
- addr, addressRequested := addressReverseLookupTable[unspentOutput.Address]
+ addr, addressRequested := addressReverseLookupTable[unspentOutput.Address.Base58]
if !addressRequested {
panic("the server returned an unrequested address")
}
// iterate through outputs
- for _, output := range unspentOutput.OutputIDs {
- // parse output id
- outputID, parseErr := ledgerstate.OutputIDFromBase58(output.ID)
- if parseErr != nil {
- err = parseErr
-
- return
- }
-
- // build balances map
- balancesByColor := make(map[ledgerstate.Color]uint64)
- for _, bal := range output.Balances {
- color := colorFromString(bal.Color)
- balancesByColor[color] += uint64(bal.Value)
+ for _, output := range unspentOutput.Outputs {
+ lOutput, err := output.Output.ToLedgerstateOutput()
+ if err != nil {
+ return nil, err
}
- balances := ledgerstate.NewColoredBalances(balancesByColor)
-
// build output
walletOutput := &Output{
- Address: addr,
- OutputID: outputID,
- Balances: balances,
+ Address: addr,
+ Object: lOutput,
InclusionState: InclusionState{
- Liked: output.InclusionState.Liked,
Confirmed: output.InclusionState.Confirmed,
Rejected: output.InclusionState.Rejected,
Conflicting: output.InclusionState.Conflicting,
@@ -106,7 +95,7 @@ func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (u
if _, addressExists := unspentOutputs[addr]; !addressExists {
unspentOutputs[addr] = make(map[ledgerstate.OutputID]*Output)
}
- unspentOutputs[addr][walletOutput.OutputID] = walletOutput
+ unspentOutputs[addr][walletOutput.Object.ID()] = walletOutput
}
}
@@ -115,11 +104,34 @@ func (webConnector WebConnector) UnspentOutputs(addresses ...address.Address) (u
// SendTransaction sends a new transaction to the network.
func (webConnector WebConnector) SendTransaction(tx *ledgerstate.Transaction) (err error) {
- _, err = webConnector.client.SendTransaction(tx.Bytes())
+ _, err = webConnector.client.PostTransaction(tx.Bytes())
return
}
+// GetTransactionInclusionState fetches the inlcusion state of the transaction.
+func (webConnector WebConnector) GetTransactionInclusionState(txID ledgerstate.TransactionID) (inc ledgerstate.InclusionState, err error) {
+ inclusionState, err := webConnector.client.GetTransactionInclusionState(txID.Base58())
+ if err != nil {
+ return
+ }
+ if inclusionState != nil {
+ if inclusionState.Pending && !inclusionState.Confirmed && !inclusionState.Rejected {
+ inc = ledgerstate.Pending
+ return
+ }
+ if !inclusionState.Pending && inclusionState.Confirmed && !inclusionState.Rejected {
+ inc = ledgerstate.Confirmed
+ return
+ }
+ if !inclusionState.Pending && !inclusionState.Confirmed && inclusionState.Rejected {
+ inc = ledgerstate.Rejected
+ return
+ }
+ }
+ return
+}
+
// GetAllowedPledgeIDs gets the list of nodeIDs that the node accepts as pledgeIDs in a transaction.
func (webConnector WebConnector) GetAllowedPledgeIDs() (pledgeIDMap map[mana.Type][]string, err error) {
res, err := webConnector.client.GetAllowedManaPledgeNodeIDs()
@@ -134,6 +146,35 @@ func (webConnector WebConnector) GetAllowedPledgeIDs() (pledgeIDMap map[mana.Typ
return
}
+// GetUnspentAliasOutput returns the current unspent alias output that belongs to a given alias address.
+func (webConnector WebConnector) GetUnspentAliasOutput(addr *ledgerstate.AliasAddress) (output *ledgerstate.AliasOutput, err error) {
+ res, err := webConnector.client.GetAddressUnspentOutputs(addr.Base58())
+ if err != nil {
+ return
+ }
+ for _, o := range res.Outputs {
+ if o.Type != ledgerstate.AliasOutputType.String() {
+ continue
+ }
+ var uncastedOutput ledgerstate.Output
+ uncastedOutput, err = o.ToLedgerstateOutput()
+ if err != nil {
+ return
+ }
+ alias, ok := uncastedOutput.(*ledgerstate.AliasOutput)
+ if !ok {
+ err = errors.Errorf("alias output received from api cannot be casted to ledgerstate representation")
+ return
+ }
+ if alias.GetAliasAddress().Equals(addr) {
+ // we found what we were looking for
+ output = alias
+ return
+ }
+ }
+ return nil, errors.Errorf("couldn't find unspent alias output for alias addr %s", addr.Base58())
+}
+
// colorFromString is an internal utility method that parses the given string into a Color.
func colorFromString(colorStr string) (color ledgerstate.Color) {
if colorStr == "IOTA" {
diff --git a/docs/apis/mana.md b/docs/apis/mana.md
index 636ce40111..aa857f68ab 100644
--- a/docs/apis/mana.md
+++ b/docs/apis/mana.md
@@ -746,7 +746,7 @@ for nodeID, e := range res.Logs {
| `inputID` | string | The input ID of revoked mana. |
-## `/value/allowedManaPledge`
+## `/mana/allowedManaPledge`
This returns the list of allowed mana pledge node IDs.
@@ -758,7 +758,7 @@ None.
#### cURL
```shell
-curl http://localhost:8080/value/allowedManaPledge \
+curl http://localhost:8080/mana/allowedManaPledge \
-X GET \
-H 'Content-Type: application/json'
```
@@ -810,7 +810,7 @@ for _, id := range res.Consensus.Allowed {
|field | Type | Description|
|:-----|:------|:------|
| `isFilterEnabled` | bool | A flag shows that if mana pledge filter is enabled. |
-| `allowed` | []string | A list of node ID that allow to be pledged mana. |
+| `allowed` | []string | A list of node ID that allow to be pledged mana. This list has effect only if `isFilterEnabled` is `true`|
diff --git a/docs/tutorials/wallet.md b/docs/tutorials/wallet.md
index 0d885c696f..f19b809fa5 100644
--- a/docs/tutorials/wallet.md
+++ b/docs/tutorials/wallet.md
@@ -1,12 +1,979 @@
-# The wallet library
+# Command Line Wallet
-This page describes how to use the wallet library.
+This page describes how to use the command line wallet (cli-wallet).
-GoShimmer ships with a very basic wallet library so that developers and testers can use it to move tokens around.
+GoShimmer ships with a basic (golang) wallet library so that developers and testers can use it to move tokens around,
+create digital assets, NFTs or delegate funds.
+The cli-wallet is built by using this wallet library to demonstrate the capabilities of the protocol.
-To demonstrate its functionalities we have developed a simple command line interface (cli-wallet).
-You can have a look at its source code to have an idea about how the wallet library can be used.
+The main features in the wallet are:
+ - Requesting tokens from the faucet
+ - Creating digital assets
+ - Sending tokens or assets to addresses
+ - Creating, transferring or destroying Non-Fungible Tokens (NFTs)
+ - Managing NFT owned tokens or assets
+ - Delegating tokens or digital assets
-The cli-wallet supports the following commands:
+In the following, we will go through these features one-by-one to aid the reader in learning how to use the wallet.
-
+Disclaimer: The command line wallet and this tutorial is intended for developer audience, you at least have to be familiar with using a terminal.
+
+## Initializing the wallet
+
+- Download the latest cli-wallet for the system of your choice from the [Goshimmer GitHub Releases](https://github.com/iotaledger/goshimmer/releases) page.
+- If needed, make the downloaded binary executable (`chmod +x ` on linux).
+- For simplicity, we renamed the binary to `cli-wallet` in this tutorial.
+
+The first time the wallet is started, it has to be initialized. This step involves generating a secret seed that is used
+to generate addresses and sign transactions. The generated seed is persisted in `wallet.dat` after the first run.
+
+The wallet can be configured by creating a `config.json` file in the directory of the executable:
+
+```json
+{
+ "WebAPI": "http://127.0.0.1:8080",
+ "basic_auth": {
+ "enabled": false,
+ "username": "goshimmer",
+ "password": "goshimmer"
+ },
+ "reuse_addresses": false
+}
+```
+ - The `WebAPI` tells the wallet which node API to communicate with. Set it to the url of a node API.
+ - If the node has basic authentication enabled, you may configure your wallet with a username and password.
+ - The `resuse_addresses` option specifies if the wallet should treat addresses as reusable, or whether it should try to
+ spend from any wallet address only once.
+
+To perform the wallet initialization, run the `init` command of the wallet:
+```bash
+./cli-wallet init
+```
+If successful, you'll see the generated seed (encoded in base58) on your screen:
+```
+IOTA Pollen CLI-Wallet 0.2
+GENERATING NEW WALLET ... [DONE]
+
+================================================================
+!!! PLEASE CREATE A BACKUP OF YOUR SEED !!!
+!!! !!!
+!!! ExzYy6wS2k59dPh19Q9JiAf6z1jyDq1hieDEMmbUzkbE !!!
+!!! !!!
+!!! PLEASE CREATE A BACKUP OF YOUR SEED !!!
+================================================================
+
+CREATING WALLET STATE FILE (wallet.dat) ... [DONE]
+```
+
+## Requesting Tokens
+
+To get your hands on some precious testnet tokens, execute the `request-funds` command:
+```bash
+./cli-wallet request-funds
+```
+Output:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Requesting funds from faucet ... [PERFORMING POW] (this can take a while)
+Requesting funds from faucet ... [DONE]
+```
+Once executed, you can check the balance of your wallet by running the `balance` command:
+```bash
+./cli-wallet balance
+```
+Output:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[PEND] 1000000 I IOTA IOTA
+```
+The status of your token balance is pending (`[PEND]`) until the network has confirmed the transaction. Pending token balances
+can not be spent, wait until status becomes `[ OK ]`. Call the `balance` command again to check for status changes.
+
+## Creating Digital Assets
+
+Digital assets are tokens with a special attribute, namely, a color. A color is a sequence of 32 bytes represented as
+a base58 encoded string. The color of a token is derived from the unique transaction that created the asset, therefore,
+it is not possible to create assets with the same color in a subsequent transaction.
+
+The transaction "minting" the assets can specify the amount of tokens to be created with the unique color. To create
+assets with the cli-wallet, execute the `create-asset` command.
+
+```bash
+./cli-wallet create-asset -name MyUniqueToken -symbol MUT -amount 1000
+```
+ - The `name` flag specifies the name of the asset.
+ - The `symbol` flag specifies the symbol of the asset.
+ - The `amount` flag specifies the amount of asset tokens to create.
+
+Output:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Creating 1000 tokens with the color 'HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn' ... [DONE]
+```
+By executing the `balance` command shortly after, you will notice that the wallet balances changed:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[PEND] 999000 IOTA IOTA
+[PEND] 1000 HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+```
+1000 IOTA tokens were tagged with the color `HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn` to create `MyUniqueToken`.
+The IOTA balance is decremented, but we have received assets in return for the used IOTAs. The created asset tokens
+behave exactly like an IOTA token, they can be transferred without fees to any address.
+
+## Sending Tokens and Assets
+
+Funds in IOTA are tied to addresses. Only the owner of the private key behind the address is able to spend (move) the funds,
+let them be IOTA tokens or digital assets. In previous steps, we have requested funds from the faucet, which actually sent
+these tokens to an address provided by our wallet. When we created `MyUniqueToken`, the wallet internally generated a new address
+to hold the assets. You may examine the addresses used by the wallet by executing the `addresses -list` command:
+```bash
+./cli-wallet addresses -list
+```
+Output:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+INDEX ADDRESS SPENT
+----- -------------------------------------------- -----
+0 19ZD79gRvVzXpQV4QfpY5gefqgrBA4gp11weeyqbY89FK true
+1 1BbywJFGFtDFXpZidmjN39d8cVWUskT2MhbFqSrmVs3qi false
+```
+Consequently, when you wish to send tokens, you need to provide an address where to send the tokens to.
+
+### Simple Send
+
+Let's suppose your friend gave you their address `1E5Q82XTF5QGyC598br9oCj71cREyjD1CGUk2gmaJaFQt` and you want to send
+them some of your `MyUniqueTokens`. The `send-funds` command is the one you are looking for. Let's ask for some help on
+what options we have:
+```bash
+./cli-wallet send-funds -help
+```
+Output:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet send-funds [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -amount int
+ the amount of tokens that are supposed to be sent
+ -color string
+ (optional) color of the tokens to transfer (default "IOTA")
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -dest-addr string
+ destination address for the transfer
+ -fallb-addr string
+ (optional) fallback address that can claim back the (unspent) sent funds after fallback deadline
+ -fallb-deadline int
+ (optional) unix timestamp after which only the fallback address can claim the funds back
+ -help
+ show this help screen
+ -lock-until int
+ (optional) unix timestamp until which time the sent funds are locked from spending
+```
+You can ignore the mana pledge options, as your wallet can derive pledge IDs automatically. The more important options are:
+ - `amount` is the amount of token you want to send,
+ - `color` is an optional flag to send digital assets with a certain color. When not specified, it defaults to the
+ color of the IOTA token.
+ - `dest-addr` is the destination address for the transfer. You'll have to se this to the address your friend provided you with.
+ - `fallb-addr` and `fallb-deadline` are optional flags to initiate a conditional transfer. A conditional transfer has a
+ fallback deadline set, after which, only `fallback-address` can unlock the funds. Obviously, before the fallback deadline,
+ it is only the receiver of the funds who can spend the funds. Such conditional transfers therefore have to be claimed
+ by the receiving party before the deadline expires.
+- `lock-until` is an optional flag for a simple time locking mechanism: before the time lock expires, the funds are locked
+ and can not be spent by the owner.
+
+To simply send 500 `MyUniqueTokens` to your friend's address, run the following command:
+```bash
+./cli-wallet send-funds -amount 500 -color HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn -dest-addr 1E5Q82XTF5QGyC598br9oCj71cREyjD1CGUk2gmaJaFQt
+```
+Note, that you have to tell the wallet that `MyUniqueTokens` are of color `HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn`.
+
+### Time Locked Sending
+
+What if you wanted to send your friend IOTA tokens, but you don't want them to spend it right away, so you impose a one-week
+locking period. You should execute the `send-funds` command with the `-lock-until` flag.
+
+The `-lock-until` flag expects a unix timestamp. On linux, to get a unix timestamp 7 days in the future, execute:
+```bash
+date -d "+7 days" +%s
+1621426409
+```
+Noe that you have a unix timestamp, you can execute the transfer:
+```bash
+$ ./cli-wallet send-funds -amount 500 -dest-addr 1E5Q82XTF5QGyC598br9oCj71cREyjD1CGUk2gmaJaFQt -lock-until 1621426409
+```
+
+### Conditional Sending
+
+You have the option to specify a fallback unlocking mechanism on the tokens you send. If the recipient doesn't claim
+the funds before the fallback deadline you specify expires, the fallback address can essentially take back the tokens.
+
+So let's assume you want to send your friend some IOTAs, but if your friend doesn't claim them for a week, you want to
+have them back. First things first, let's get the receive address of your wallet by running:
+```bash
+./cli-wallet address -receive
+```
+which will give you your wallets current receive address:
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Latest Receive Address: 17KoEZbWoBLRjBsb6oSyrSKVVqd7DVdHUWpxfBFbHaMSm
+```
+Then we can execute the send with the proper parameters:
+```bash
+./cli-wallet send-funds -amount 500 -dest-addr 1E5Q82XTF5QGyC598br9oCj71cREyjD1CGUk2gmaJaFQt \
+-fallb-addr 17KoEZbWoBLRjBsb6oSyrSKVVqd7DVdHUWpxfBFbHaMSm --fallb-deadline 1621426409
+```
+
+When you receive such conditional funds, they will be displayed on the balance page in the wallet:
+```bash
+./cli-wallet balance
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 I IOTA IOTA
+
+Conditional Token Balances - execute `claim-conditional` command to sweep these funds into wallet
+
+STATUS OWNED UNTIL BALANCE COLOR TOKEN NAME
+------ ------------------------------ --------------- -------------------------------------------- -------------------------
+[ OK ] 2021-05-19 14:13:29 +0200 CEST 500 I IOTA IOTA
+```
+As the output suggests, you need to execute the `claim-conditional` command to claim these funds:
+```bash
+./cli-wallet claim-conditional
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Claiming conditionally owned funds... [DONE]
+```
+```
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[PEND] 500 IOTA IOTA
+```
+
+## Creating NFTs
+
+NFTs are non-fungible tokens that have unique properties. In IOTA, NFTs are represented as non-forkable, uniquely
+identifiable outputs. When such an output is spent, the transaction spending it is only valid if it satisfies the
+constraints defined in the outputs. One such constraint is, that immutable data attached to the output can not change.
+Therefore, we can create an NFT and record immutable metadata in its output.
+
+Let's create our first NFT with the help of the cli-wallet.
+```bash
+./cli-wallet create-nft -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet create-nft [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -color string
+ color of the tokens that should be deposited into the nft upon creation (on top of the minimum required) (default "IOTA")
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -immutable-data string
+ path to the file containing the immutable data that shall be attached to the nft
+ -initial-amount int
+ the amount of tokens that should be deposited into the nft upon creation (on top of the minimum required)
+```
+None of the flags are strictly required to mint an NFT, so we could just execute the command as it is, however, in most
+cases, you'll want to attach immutable metadata to it, which is only possible during creation. Each NFT must have some
+IOTAs backing it (locked into its output) to prevent bloating the ledger database. Currently, the minimum requirement
+is 100 IOTA tokens, but bear in mind that it might change in the future.
+Nevertheless, on top of the minimum required amount IOTAs, you can lock any additional funds into the NFT. To do so,
+use the `-initial-amount` and `-color` flags.
+
+To attach immutable data to the NFT, you can define a path to a file that holds the metadata. The wallet will read the
+byte content of the file and attach it to the NFT. Note, that currently the maximum allowed metadata file size is 4
+kilobytes. Use the `-immutable-data` flag to specify a path to a file that holds the metadata.
+
+Let's create our very first NFT. We create an `nft_metadata.json` file in the directory of the cli-wallet with the
+following content:
+```json
+{
+ "title": "Asset Metadata",
+ "type": "object",
+ "properties": {
+ "name": {
+ "type": "string",
+ "description": "MyFirstNFT"
+ },
+ "description": {
+ "type": "string",
+ "description": "My very first NFT that has this metadata attached to it."
+ },
+ "image": {
+ "type": "string",
+ "description": ""
+ }
+ }
+}
+```
+The above JSON file is just a template, you can aby define binary data that fits the size limit to be attached to the NFT.
+
+To create the NFT, simply execute:
+```bash
+./cli-wallet create-nft -immutable-data nft_metadata.json
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Created NFT with ID: gSfeBrWp1HwDLwSL7rt1qEMM59YBFZ4iBgAqHuqaQHo5
+Creating NFT ... [DONE]
+```
+The created NFT's unique identifier is `gSfeBrWp1HwDLwSL7rt1qEMM59YBFZ4iBgAqHuqaQHo5` that is also a valid IOTA address.
+Navigate to a node dashboard/explorer and search for the address. On a node dashboard, you would see something like this:
+
+
+The immutable data field contains the attached binary metadata (encoded in base64 in the node dashboard).
+
+The NFT is also displayed on the balance page of the cli-wallet:
+```
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 996200 I IOTA IOTA
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] gSfeBrWp1HwDLwSL7rt1qEMM59YBFZ4iBgAqHuqaQHo5 100 IOTA IOTA
+```
+
+## Transferring NFTs
+
+Any valid IOTA address can own NFTs, so how can we send it?
+The `transfer-nft` command of the cli-wallet comes to the rescue:
+```
+./cli-wallet transfer-nft -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet transfer-nft [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -dest-addr string
+ destination address for the transfer
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft that should be transferred
+ -reset-delegation
+ defines whether to reset the delegation status of the alias being transferred
+ -reset-state-addr
+ defines whether to set the state address to dest-addr
+```
+
+There are 2 mandatory flags that need to be provided for a valid transfer: `-id` and `-dest-addr`. The former is the
+unique identifier of the NFT that you wish to transfer, the latter is the destination address.
+
+Let's transfer the NFT to our friend's address:
+```bash
+./cli-wallet transfer-nft -id gSfeBrWp1HwDLwSL7rt1qEMM59YBFZ4iBgAqHuqaQHo5 -dest-addr 1E5Q82XTF5QGyC598br9oCj71cREyjD1CGUk2gmaJaFQt
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Transferring NFT... [DONE]
+```
+
+## Destroying NFTs
+
+The owner of an NFT has the ability to destroy it. When an NFT is destroyed, all of its balance is transferred to
+the current owner, and the alias output representing the NFT is spent without creating a corresponding next alias output.
+
+The command to destroy an NFT is called `destroy-nft` in the cli-wallet:
+```
+./cli-wallet destroy-nft -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet destroy-nft [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft that should be destroyed
+
+```
+
+Let's create an NFT and destroy it right after:
+```bash
+./cli-wallet create-nft
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Created NFT with ID: bdrvyKvaE6CZUEbdRDK57oBCRb2SLUyE8padFGxrV3zg
+Creating NFT ... [DONE]
+```
+Then let's wait until the balance page shows that the NFT status is `OK`:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 996100 I IOTA IOTA
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] bdrvyKvaE6CZUEbdRDK57oBCRb2SLUyE8padFGxrV3zg 100 IOTA IOTA
+```
+Finally, let's destroy it:
+```bash
+./cli-wallet destroy-nft -id bdrvyKvaE6CZUEbdRDK57oBCRb2SLUyE8padFGxrV3zg
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Destroying NFT... [DONE]
+```
+
+## Managing NFT Owned Assets
+
+An NFT is not only a valid IOTA address via its NFT ID, but it is stored as an output in the ledger. Therefore, the NFT
+is not only capable of receiving funds to its address, but the owner can directly manage the funds held in the NFT
+output.
+
+ - The owner might deposit assets into an NFT, or withdraw assets from there, essentially using it as a standalone wallet.
+ - Other users in the network can send any asset to the NFT address, that will be owned by the NFT. The owner might choose
+ to deposit such funds into the NFT or sweep them into their own wallet.
+
+### Deposit Assets Into Owned NFT
+
+Suppose I have created an NFT with the minimum required 100 IOTA balance. Later I figure, that I would like to keep some
+assets in the NFT. I can deposit the assets via the `deposit-to-nft` command:
+```bash
+./cli-wallet deposit-to-nft -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet deposit-to-nft [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -amount int
+ the amount of tokens that are supposed to be deposited
+ -color string
+ color of funds to deposit (default "IOTA")
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft to deposit to
+```
+
+To deposit some previously created `MyUniqueTokens` into the NFT, we need to specify the following flags:
+ - `-id` the NFT ID to deposit to
+ - `-amount` amount of assets to deposit
+ - `-color` asset color to deposit
+
+Balance before the deposit looks like this:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 996300 I IOTA IOTA
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg 100 IOTA IOTA
+```
+
+The actual deposit operation:
+
+```bash
+./cli-wallet deposit-to-nft -id f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg -amount 500 -color HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+Depositing funds into NFT ... [DONE]
+```
+```
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 996300 I IOTA IOTA
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg 100 IOTA IOTA
+ 500 HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+```
+
+### Withdrawing Assets From NFT
+
+The reverse of the deposit command looks quite similar:
+```bash
+./cli-wallet withdraw-from-nft -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet withdraw-from-nft [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -amount int
+ the amount of tokens that are supposed to be withdrew
+ -color string
+ color of funds to withdraw (default "IOTA")
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -dest-addr string
+ (optional) address to send the withdrew tokens to
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft to withdraw from
+```
+
+Therefore, to withdraw the previously deposited `MyUniqueTokens`, execute the following command:
+```bash
+./cli-wallet withdraw-from-nft -id f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg -amount 500 -color HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Withdrawing funds from NFT... [DONE]
+```
+Once the transaction confirms, you'll see the updated balance:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 996300 I IOTA IOTA
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg 100 IOTA IOTA
+```
+
+Note, that if the withdrawal leaves less, than the minimum required funds in the NFT, the transaction fails.
+
+### Sweep NFT Owned Funds
+
+We have previously explained, that an NFT can receive funds to its NFT ID because it is a valid IOTA address. Such
+funds can be collected by the owner of the NFT with the `sweep-nft-owned-funds` command:
+```bash
+./cli-wallet sweep-nft-owned-funds -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet sweep-nft-owned-funds [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft that should be checked for outputs with funds
+ -to string
+ optional address where to sweep
+```
+
+The only mandatory flag is the `-id`, as it specifies which NFT ID (address) to scan for funds.
+
+Let's suppose that are friend sent funds form their wallet to our NFT `f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg`
+with a normal `send-funds` command:
+```bash
+./your-friends-wallet send-funds -amount 1000000 -dest-addr f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg
+```
+We can execute the `sweep-nft-owned-funds` command to transfer these funds into our wallet:
+```bash
+./cli-wallet sweep-nft-owned-funds -id f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Sweeping NFT owned funds... [DONE]
+```
+The wallet balance should be updated, the wallet contains 1 MI more:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 1996300 I IOTA IOTA
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg 100 IOTA IOTA
+```
+
+### Sweep NFT Owned NFTs
+
+NFTs can own other NFTs, that in turn can own other NFTs and so on... wow, NFTception!
+Let's say your friend created an NFT, and transferred it to your NFT's ID `f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg`.
+```bash
+./your-friends-wallet create-nft
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Created NFT with ID: faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi
+Creating NFT ... [DONE]
+```
+```
+./your-friends-wallet transfer-nft -id faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi -dest-addr f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Transferring NFT... [DONE]
+```
+
+Your NFT `f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg` now owns NFT `faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi`.
+To sweep the owned NFT into your wallet, execute the `sweep-nft-owned-nft` command:
+```bash
+./cli-wallet sweep-nft-owned-nfts -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet sweep-nft-owned-nfts [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -id string
+ unique identifier of the nft that should be checked for owning other nfts
+ -to string
+ optional address where to sweep
+```
+
+All you need to specify is the `-id` of your NFT that you would like to check for owned NFTs:
+```bash
+./cli-wallet sweep-nft-owned-nfts -id f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Swept NFT faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi into the wallet
+Sweeping NFT owned NFTs... [DONE]
+```
+That's it, your wallet owns `faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi` now. If this NFT owned other funds or NFTs,
+you would be able to sweep them into your wallet just like you did for `f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg`.
+
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 1996300 I IOTA IOTA
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+
+Owned NFTs (Governance Controlled Aliases)
+
+STATUS NFT ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] f1BW8jcdDn3staviCVbVz54NqVwsshb5gpNLqY6Rrgrg 100 IOTA IOTA
+[ OK ] faf9tkdBfcTv2AgPm3Zt8duX4iUGKjqbEyrdBYsUb2hi 100 IOTA IOTA
+```
+
+## Delegating Assets
+
+The primary use case of fund delegation in Coordicide is to enable refreshing a node's access mana without requiring
+the use of a master key that has full control over the funds. A delegated key can not spend the funds, but can
+"refresh" the outputs holding the funds in a transaction that can pledge mana to any arbitrary nodes.
+
+A token holder can therefore keep their funds in secure cold storage, while delegating them to a node or third party
+to utilize the mana generated by the funds. Assuming there is demand for access mana in the network, the holder of the
+assets can then sell the generated mana to realize return on their assets.
+
+Delegating funds via the cli-wallet is rather simple: you just need to execute the `delegate-funds` command. By default,
+the cli-wallet will delegate funds to the node that the wallet is connected to, unless you specify a delegation
+address via the `-del-addr` flag.
+specify a valid IOTA address where to delegate to.
+```bash
+./cli-wallet delegate-funds -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet delegate-funds [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -amount int
+ the amount of tokens that should be delegated
+ -color string
+ color of the tokens that should delegated (default "IOTA")
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -del-addr string
+ address to delegate funds to. when omitted, wallet delegates to the node it is connected to
+ -help
+ show this help screen
+ -until int
+ unix timestamp until which the delegated funds are timelocked
+```
+
+ - Mandatory parameter is only the `-amount`.
+ - Use the `-del-addr` flag to delegate to arbitrary address.
+ - You may specify a delegation deadline via the `-until` flag. If this is set, the delegated party can not unlock
+ the funds for refreshing mana after the deadline expired, but the neither can the owner reclaim the funds before
+ that. If the `-until` flag is omitted, the delegation is open-ended, the owner can reclaim the delegated funds at
+ any time.
+ - You can specify a certain asset to be delegated (`-color`), default is IOTA.
+
+Let's delegate some funds to an address provided by a node in the network, `1EqJf5K1LJ6bVMCrxxxdZ6VNYoBTvEoXgxnbLJe7aqajc`:
+```bash
+./cli-wallet delegate-funds -amount 1000000 -del-addr 1EqJf5K1LJ6bVMCrxxxdZ6VNYoBTvEoXgxnbLJe7aqajc
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Delegating to address 1EqJf5K1LJ6bVMCrxxxdZ6VNYoBTvEoXgxnbLJe7aqajc
+Delegation ID is: tGoTKjt2y277ssKax9stsZXfLGdf8bPj3TZFaUDcAEwK
+Delegating funds... [DONE]
+```
+
+If we omitted the `-del-addr` flag and its value, the wallet would have asked the node it is connected to, to provide
+a delegation address. You can get this delegation address yourself as well by running the `server-status` command in
+the wallet, or querying the `/info` endpoint of a node through the webapi.
+```bash
+./cli-wallet server-status
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Server ID: 2GtxMQD94KvDH1SJPJV7icxofkyV1njuUZKtsqKmtux5
+Server Synced: true
+Server Version: v0.5.9
+Delegation Address: 1HG9Z5NSiWTmT1HG65JLmn1jxQj7xUcVppKKi2vHAZLmr
+```
+
+By running the `balance` command, we can see the delegated funds:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 996500 I IOTA IOTA
+
+Delegated Funds
+
+STATUS DELEGATION ID (ALIAS ID) BALANCE COLOR TOKEN NAME
+------ -------------------------------------------- --------------- -------------------------------------------- -------------------------
+[ OK ] tGoTKjt2y277ssKax9stsZXfLGdf8bPj3TZFaUDcAEwK 1000000 IOTA IOTA
+```
+
+To be able to reclaim the delegated funds, we will need the delegation ID of the delegated funds.
+
+## Reclaiming Delegated Assets
+
+To reclaim delegated funds, you have to tell the cli-wallet the delegation ID that is displayed on the balance page.
+Use the `reclaim-delegated` command once you got the delegation ID:
+```bash
+ ./cli-wallet reclaim-delegated -help
+IOTA Pollen CLI-Wallet 0.2
+
+USAGE:
+ cli-wallet reclaim-delegated [OPTIONS]
+
+OPTIONS:
+ -access-mana-id string
+ node ID to pledge access mana to
+ -consensus-mana-id string
+ node ID to pledge consensus mana to
+ -help
+ show this help screen
+ -id string
+ delegation ID that should be reclaimed
+ -to-addr string
+ optional address where to send reclaimed funds, wallet receive address by default
+```
+
+To reclaim the funds delegated in the previous section, simply run:
+```bash
+./cli-wallet reclaim-delegated -id tGoTKjt2y277ssKax9stsZXfLGdf8bPj3TZFaUDcAEwK
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Reclaimed delegation ID is: tGoTKjt2y277ssKax9stsZXfLGdf8bPj3TZFaUDcAEwK
+Reclaiming delegated fund... [DONE]
+```
+The balance should appear in the `Available Balances` section of the balance page:
+```bash
+./cli-wallet balance
+```
+```
+IOTA Pollen CLI-Wallet 0.2
+
+Available Token Balances
+
+STATUS BALANCE COLOR TOKEN NAME
+------ --------------- -------------------------------------------- -------------------------
+[ OK ] 500 MUT HJdkZkn6MKda9fNuXFQZ8Dzdzu1wvuSUQp8QX1AMH4wn MyUniqueToken
+[ OK ] 1996500 I IOTA IOTA
+```
+
+## Common Flags
+
+As you may have noticed, there are some universal flags in many commands, namely:
+ - `-help` that brings up the command usage and help information,
+ - `access-mana-id` that is the nodeID to which the transaction should pledge access mana to, and
+ - `consensus-mana-id` that is the nodeID to which the transaction should pledge consensus mana to.
+
+The latter teo are determined by default by your wallet depending on which node you connect it to. However, if that node
+doesn't filter user submitted transactions based on the mana pledge IDs, you are free to define which node to pledge
+mana to.
+
+## Command Reference
+
+### balance
+Show the balances held by this wallet.
+### send-funds
+Initiate a transfer of tokens or assets (funds).
+### consolidate-funds
+Consolidate all available funds to one wallet address.
+### claim-conditional
+Claim (move) conditionally owned funds into the wallet.
+### request-funds
+Request funds from the testnet-faucet.
+### create-asset
+Create an asset in the form of colored coins.
+### delegate-funds
+Delegate funds to an address.
+### reclaim-delegated
+Reclaim previously delegated funds.
+### create-nft
+Create an NFT as an unforkable alias output.
+### transfer-nft
+Transfer the ownership of an NFT.
+### destroy-nft
+Destroy an NFT.
+### deposit-to-nft
+Deposit funds into an NFT.
+### withdraw-from-nft
+Withdraw funds from an NFT.
+### sweep-nft-owned-funds
+Sweep all available funds owned by NFT into the wallet.
+### sweep-nft-owned-nfts
+weep all available NFTs owned by NFT into the wallet.
+### address
+Start the address manager of this wallet.
+### init
+Generate a new wallet using a random seed.
+### server-status
+Display the server status.
+### pending-mana
+Display current pending mana of all outputs in the wallet grouped by address.
+### pledge-id
+Query nodeIDs accepted as pledge IDs in transaction by the node (server).
+### help
+Display this help screen.
diff --git a/go.mod b/go.mod
index 56bb49ede8..edecd43126 100644
--- a/go.mod
+++ b/go.mod
@@ -12,7 +12,6 @@ require (
github.com/drand/kyber v1.1.2
github.com/gin-gonic/gin v1.6.3
github.com/go-ole/go-ole v1.2.4 // indirect
- github.com/gobuffalo/packr/v2 v2.2.0
github.com/golang/protobuf v1.4.3
github.com/golang/snappy v0.0.2 // indirect
github.com/gorilla/websocket v1.4.2
@@ -41,6 +40,7 @@ require (
golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb // indirect
golang.org/x/sys v0.0.0-20210224231101-5640770f5e4e // indirect
golang.org/x/text v0.3.4 // indirect
+ golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
google.golang.org/genproto v0.0.0-20201203001206-6486ece9c497 // indirect
google.golang.org/grpc v1.34.0
google.golang.org/protobuf v1.25.0
diff --git a/go.sum b/go.sum
index 6d0182fe35..258920bf0c 100644
--- a/go.sum
+++ b/go.sum
@@ -235,7 +235,6 @@ github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTq
github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY=
github.com/gobuffalo/depgen v0.1.0/go.mod h1:+ifsuy7fhi15RWncXQQKjWS9JPkdah5sZvtHc2RXGlg=
github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
-github.com/gobuffalo/envy v1.7.0 h1:GlXgaiBkmrYMHco6t4j7SacKO4XUjvh5pwXh0f4uxXU=
github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI=
github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs=
github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI=
@@ -243,27 +242,20 @@ github.com/gobuffalo/flect v0.1.3/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj
github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk=
github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28=
github.com/gobuffalo/genny v0.1.0/go.mod h1:XidbUqzak3lHdS//TPu2OgiFB+51Ur5f7CSnXZ/JDvo=
-github.com/gobuffalo/genny v0.1.1 h1:iQ0D6SpNXIxu52WESsD+KoQ7af2e3nCfnSBoSF/hKe0=
github.com/gobuffalo/genny v0.1.1/go.mod h1:5TExbEyY48pfunL4QSXxlDOmdsD44RRq4mVZ0Ex28Xk=
github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw=
github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360=
github.com/gobuffalo/gogen v0.1.0/go.mod h1:8NTelM5qd8RZ15VjQTFkAW6qOMx5wBbW4dSCS3BY8gg=
-github.com/gobuffalo/gogen v0.1.1 h1:dLg+zb+uOyd/mKeQUYIbwbNmfRsr9hd/WtYWepmayhI=
github.com/gobuffalo/gogen v0.1.1/go.mod h1:y8iBtmHmGc4qa3urIyo1shvOD8JftTtfcKi+71xfDNE=
github.com/gobuffalo/here v0.6.0 h1:hYrd0a6gDmWxBM4TnrGw8mQg24iSVoIkHEk7FodQcBI=
github.com/gobuffalo/here v0.6.0/go.mod h1:wAG085dHOYqUpf+Ap+WOdrPTp5IYcDAs/x7PLa8Y5fM=
-github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2 h1:8thhT+kUJMTMy3HlX4+y9Da+BNJck+p109tqqKp7WDs=
github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8=
github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
-github.com/gobuffalo/mapi v1.0.2 h1:fq9WcL1BYrm36SzK6+aAnZ8hcp+SrmnDyAxhNx8dvJk=
github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc=
github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
-github.com/gobuffalo/packd v0.1.0 h1:4sGKOD8yaYJ+dek1FDkwcxCHA40M4kfKgFHx8N2kwbU=
github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4=
github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ=
-github.com/gobuffalo/packr/v2 v2.2.0 h1:Ir9W9XIm9j7bhhkKE9cokvtTl1vBm62A/fene/ZCj6A=
github.com/gobuffalo/packr/v2 v2.2.0/go.mod h1:CaAwI0GPIAv+5wKLtv8Afwl+Cm78K/I/VCm/3ptBN+0=
-github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754 h1:tpom+2CJmpzAWj5/VEHync2rJGi+epHNIeRSWjzGA+4=
github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw=
github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
@@ -482,7 +474,6 @@ github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q
github.com/kabukky/httpscerts v0.0.0-20150320125433-617593d7dcb3/go.mod h1:BYpt4ufZiIGv2nXn4gMxnfKV306n3mWXgNu/d2TqdTU=
github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d/go.mod h1:P2viExyCEfeWGU259JnaQ34Inuec4R38JCyBx2edgD0=
github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4=
-github.com/karrick/godirwalk v1.10.3 h1:lOpSw2vJP0y5eLBW906QwKsUK/fe/QDyoqM5rnnuPDY=
github.com/karrick/godirwalk v1.10.3/go.mod h1:RoGL9dQei4vP9ilrpETWE8CLOZ1kiN0LhBygSwrAsHA=
github.com/kataras/golog v0.0.9/go.mod h1:12HJgwBIZFNGL0EJnMRhmvGA0PQGx8VFwrZtM4CqbAk=
github.com/kataras/iris/v12 v12.0.1/go.mod h1:udK4vLQKkdDqMGJJVd/msuMtN6hpYJhg/lSzuxjhO+U=
@@ -657,11 +648,9 @@ github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czP
github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4=
github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2 h1:JgVTCPf0uBVcUSWpyXmGpgOc62nK5HWUBKAGc3Qqa5k=
github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE=
github.com/markbates/pkger v0.17.1 h1:/MKEtWqtc0mZvu9OinB9UzVN9iYCwLWuyUv4Bw+PCno=
github.com/markbates/pkger v0.17.1/go.mod h1:0JoVlrol20BSywW79rN3kdFFsE5xYM+rSCQDXbLhiuI=
-github.com/markbates/safe v1.0.1 h1:yjZkbvRM6IzKj9tlu/zMJLS0n/V351OZWRnF3QfaUxI=
github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0=
github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
@@ -875,7 +864,6 @@ github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6So
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
diff --git a/packages/gossip/manager.go b/packages/gossip/manager.go
index d24dda5036..9066afb2f0 100644
--- a/packages/gossip/manager.go
+++ b/packages/gossip/manager.go
@@ -1,6 +1,7 @@
package gossip
import (
+ "context"
"fmt"
"net"
"runtime"
@@ -144,13 +145,13 @@ func (m *Manager) stop() {
}
// AddOutbound tries to add a neighbor by connecting to that peer.
-func (m *Manager) AddOutbound(p *peer.Peer, group NeighborsGroup) error {
- return m.addNeighbor(p, group, m.srv.DialPeer)
+func (m *Manager) AddOutbound(ctx context.Context, p *peer.Peer, group NeighborsGroup) error {
+ return m.addNeighbor(ctx, p, group, m.srv.DialPeer)
}
// AddInbound tries to add a neighbor by accepting an incoming connection from that peer.
-func (m *Manager) AddInbound(p *peer.Peer, group NeighborsGroup) error {
- return m.addNeighbor(p, group, m.srv.AcceptPeer)
+func (m *Manager) AddInbound(ctx context.Context, p *peer.Peer, group NeighborsGroup) error {
+ return m.addNeighbor(ctx, p, group, m.srv.AcceptPeer)
}
// DropNeighbor disconnects the neighbor with the given ID.
@@ -223,7 +224,7 @@ func (m *Manager) send(b []byte, to ...identity.ID) {
}
}
-func (m *Manager) addNeighbor(p *peer.Peer, group NeighborsGroup, connectorFunc func(*peer.Peer) (net.Conn, error),
+func (m *Manager) addNeighbor(ctx context.Context, p *peer.Peer, group NeighborsGroup, connectorFunc func(context.Context, *peer.Peer) (net.Conn, error),
) error {
m.mu.Lock()
defer m.mu.Unlock()
@@ -235,7 +236,7 @@ func (m *Manager) addNeighbor(p *peer.Peer, group NeighborsGroup, connectorFunc
return ErrNotRunning
}
- conn, err := connectorFunc(p)
+ conn, err := connectorFunc(ctx, p)
if err != nil {
m.neighborsEvents[group].ConnectionFailed.Trigger(p, err)
return err
diff --git a/packages/gossip/manager_test.go b/packages/gossip/manager_test.go
index 8abc6eaee9..8356ede773 100644
--- a/packages/gossip/manager_test.go
+++ b/packages/gossip/manager_test.go
@@ -1,6 +1,7 @@
package gossip
import (
+ "context"
"net"
"sync"
"testing"
@@ -51,13 +52,13 @@ func TestClosedConnection(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -91,13 +92,13 @@ func TestP2PSend(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -138,13 +139,13 @@ func TestP2PSendTwice(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -189,23 +190,23 @@ func TestBroadcast(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerC, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerC, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
go func() {
defer wg.Done()
- err := mgrC.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrC.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -250,23 +251,23 @@ func TestSingleSend(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerC, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerC, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
go func() {
defer wg.Done()
- err := mgrC.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrC.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -303,7 +304,7 @@ func TestDropUnsuccessfulAccept(t *testing.T) {
mgrA.On("connectionFailed", peerB, mock.Anything).Once()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.Error(t, err)
mgrA.AssertExpectations(t)
@@ -324,13 +325,13 @@ func TestMessageRequest(t *testing.T) {
go func() {
defer wg.Done()
- err := mgrA.AddInbound(peerB, NeighborsGroupAuto)
+ err := mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)
assert.NoError(t, err)
}()
time.Sleep(graceTime)
go func() {
defer wg.Done()
- err := mgrB.AddOutbound(peerA, NeighborsGroupAuto)
+ err := mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)
assert.NoError(t, err)
}()
@@ -377,8 +378,8 @@ func TestDropNeighbor(t *testing.T) {
mgrB.NeighborsEvents(NeighborsGroupAuto).NeighborAdded.Attach(signal)
defer mgrB.NeighborsEvents(NeighborsGroupAuto).NeighborAdded.Detach(signal)
- go func() { assert.NoError(t, mgrA.AddInbound(peerB, NeighborsGroupAuto)) }()
- go func() { assert.NoError(t, mgrB.AddOutbound(peerA, NeighborsGroupAuto)) }()
+ go func() { assert.NoError(t, mgrA.AddInbound(context.Background(), peerB, NeighborsGroupAuto)) }()
+ go func() { assert.NoError(t, mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupAuto)) }()
wg.Wait() // wait until the events were triggered and the peers are connected
}
// close connection
@@ -437,8 +438,8 @@ func TestDropNeighborDifferentGroup(t *testing.T) {
mgrB.NeighborsEvents(NeighborsGroupManual).NeighborAdded.Attach(signal)
defer mgrB.NeighborsEvents(NeighborsGroupManual).NeighborAdded.Detach(signal)
- go func() { assert.NoError(t, mgrA.AddInbound(peerB, NeighborsGroupManual)) }()
- go func() { assert.NoError(t, mgrB.AddOutbound(peerA, NeighborsGroupManual)) }()
+ go func() { assert.NoError(t, mgrA.AddInbound(context.Background(), peerB, NeighborsGroupManual)) }()
+ go func() { assert.NoError(t, mgrB.AddOutbound(context.Background(), peerA, NeighborsGroupManual)) }()
wg.Wait() // wait until the events were triggered and the peers are connected
}
// close connection
diff --git a/packages/gossip/server/server.go b/packages/gossip/server/server.go
index 64eb77421e..5b2732ac00 100644
--- a/packages/gossip/server/server.go
+++ b/packages/gossip/server/server.go
@@ -3,6 +3,7 @@ package server
import (
"bytes"
"container/list"
+ "context"
"fmt"
"io"
"net"
@@ -36,10 +37,10 @@ var (
// connection timeouts
const (
- dialTimeout = 1 * time.Second // timeout for net.Dial
- handshakeTimeout = 500 * time.Millisecond // read/write timeout of the handshake packages
- acceptTimeout = 3 * time.Second // timeout to accept incoming connections
- connectionTimeout = acceptTimeout + 2*handshakeTimeout // timeout after which the connection must be established
+ defaultDialTimeout = 1 * time.Second // timeout for net.Dial
+ handshakeTimeout = 500 * time.Millisecond // read/write timeout of the handshake packages
+ acceptTimeout = 3 * time.Second // timeout to accept incoming connections
+ defaultConnectionTimeout = acceptTimeout + 2*handshakeTimeout // timeout after which the connection must be established
maxHandshakePacketSize = 256
)
@@ -53,8 +54,10 @@ type TCP struct {
listener *net.TCPListener
log *zap.SugaredLogger
- addAcceptMatcher chan *acceptMatcher
- acceptReceived chan accept
+ addAcceptMatcherCh chan *acceptMatcher
+ acceptReceivedCh chan accept
+ matchersList *list.List
+ matchersMutex sync.RWMutex
closeOnce sync.Once
wg sync.WaitGroup
@@ -68,9 +71,28 @@ type connect struct {
}
type acceptMatcher struct {
- peer *peer.Peer // connecting peer
- deadline time.Time // deadline for the incoming call
- connected chan connect // result of the connection is signaled here
+ ctx context.Context
+ peer *peer.Peer // connecting peer
+
+ connectOnce sync.Once
+ connect connect
+ connectDone chan struct{}
+}
+
+func newAcceptMatcher(ctx context.Context, p *peer.Peer) *acceptMatcher {
+ return &acceptMatcher{ctx: ctx, peer: p, connectDone: make(chan struct{})}
+}
+
+func (am *acceptMatcher) setConnect(c connect) {
+ am.connectOnce.Do(func() {
+ am.connect = c
+ close(am.connectDone)
+ })
+}
+
+func (am *acceptMatcher) waitAndGetConnect() connect {
+ <-am.connectDone
+ return am.connect
}
type accept struct {
@@ -82,12 +104,13 @@ type accept struct {
// ServeTCP creates the object and starts listening for incoming connections.
func ServeTCP(local *peer.Local, listener *net.TCPListener, log *zap.SugaredLogger) *TCP {
t := &TCP{
- local: local,
- listener: listener,
- log: log,
- addAcceptMatcher: make(chan *acceptMatcher),
- acceptReceived: make(chan accept),
- closing: make(chan struct{}),
+ local: local,
+ listener: listener,
+ log: log,
+ addAcceptMatcherCh: make(chan *acceptMatcher),
+ acceptReceivedCh: make(chan accept),
+ matchersList: list.New(),
+ closing: make(chan struct{}),
}
t.log.Debugw("server started",
@@ -95,7 +118,6 @@ func ServeTCP(local *peer.Local, listener *net.TCPListener, log *zap.SugaredLogg
"address", listener.Addr().String(),
)
- t.wg.Add(2)
go t.run()
go t.listenLoop()
@@ -120,7 +142,7 @@ func (t *TCP) LocalAddr() net.Addr {
// DialPeer establishes a gossip connection to the given peer.
// If the peer does not accept the connection or the handshake fails, an error is returned.
-func (t *TCP) DialPeer(p *peer.Peer) (net.Conn, error) {
+func (t *TCP) DialPeer(ctx context.Context, p *peer.Peer) (net.Conn, error) {
gossipEndpoint := p.Services().Get(service.GossipKey)
if gossipEndpoint == nil {
return nil, ErrNoGossip
@@ -130,7 +152,8 @@ func (t *TCP) DialPeer(p *peer.Peer) (net.Conn, error) {
if err := backoff.Retry(dialRetryPolicy, func() error {
var err error
address := net.JoinHostPort(p.IP().String(), strconv.Itoa(gossipEndpoint.Port()))
- conn, err = net.DialTimeout("tcp", address, dialTimeout)
+ dialer := &net.Dialer{Timeout: defaultDialTimeout}
+ conn, err = dialer.DialContext(ctx, "tcp", address)
if err != nil {
return fmt.Errorf("dial %s / %s failed: %w", address, p.ID(), err)
}
@@ -152,14 +175,14 @@ func (t *TCP) DialPeer(p *peer.Peer) (net.Conn, error) {
// AcceptPeer awaits an incoming connection from the given peer.
// If the peer does not establish the connection or the handshake fails, an error is returned.
-func (t *TCP) AcceptPeer(p *peer.Peer) (net.Conn, error) {
+func (t *TCP) AcceptPeer(ctx context.Context, p *peer.Peer) (net.Conn, error) {
gossipEndpoint := p.Services().Get(service.GossipKey)
if gossipEndpoint == nil {
return nil, ErrNoGossip
}
// wait for the connection
- connected := <-t.acceptPeer(p)
+ connected := t.acceptPeer(ctx, p)
if connected.err != nil {
return nil, fmt.Errorf("accept %s / %s failed: %w", net.JoinHostPort(p.IP().String(), strconv.Itoa(gossipEndpoint.Port())), p.ID(), connected.err)
}
@@ -171,15 +194,20 @@ func (t *TCP) AcceptPeer(p *peer.Peer) (net.Conn, error) {
return connected.c, nil
}
-func (t *TCP) acceptPeer(p *peer.Peer) <-chan connect {
- connected := make(chan connect, 1)
+func (t *TCP) acceptPeer(ctx context.Context, p *peer.Peer) connect {
+ if _, ok := ctx.Deadline(); !ok {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithTimeout(ctx, defaultConnectionTimeout)
+ defer cancel()
+ }
// add the matcher
+ am := newAcceptMatcher(ctx, p)
select {
- case t.addAcceptMatcher <- &acceptMatcher{peer: p, connected: connected}:
+ case t.addAcceptMatcherCh <- am:
case <-t.closing:
- connected <- connect{nil, ErrClosed}
+ am.setConnect(connect{c: nil, err: ErrClosed})
}
- return connected
+ return am.waitAndGetConnect()
}
func (t *TCP) closeConnection(c net.Conn) {
@@ -189,87 +217,94 @@ func (t *TCP) closeConnection(c net.Conn) {
}
func (t *TCP) run() {
+ t.wg.Add(1)
defer t.wg.Done()
-
- var (
- matcherList = list.New()
- timeout = time.NewTimer(0)
- )
- defer timeout.Stop()
-
- <-timeout.C // ignore first timeout
-
for {
- // Set the timer so that it fires when the next accept expires
- if e := matcherList.Front(); e != nil {
- // the first element always has the closest deadline
- m := e.Value.(*acceptMatcher)
- timeout.Reset(time.Until(m.deadline))
- } else {
- timeout.Stop()
- }
-
select {
// add a new matcher to the list
- case m := <-t.addAcceptMatcher:
- m.deadline = time.Now().Add(connectionTimeout)
- matcherList.PushBack(m)
+ case m := <-t.addAcceptMatcherCh:
+ go t.handleAcceptMatcher(m)
// on accept received, check all matchers for a fit
- case a := <-t.acceptReceived:
- matched := false
- for e := matcherList.Front(); e != nil; e = e.Next() {
- m := e.Value.(*acceptMatcher)
- if m.peer.ID() == a.fromID {
- matched = true
- matcherList.Remove(e)
- // finish the handshake
- go t.matchAccept(m, a.req, a.conn)
- }
- }
+ case a := <-t.acceptReceivedCh:
+ matched := t.matchNewConnection(a)
// close the connection if not matched
if !matched {
t.log.Debugw("unexpected connection", "id", a.fromID, "addr", a.conn.RemoteAddr())
t.closeConnection(a.conn)
}
-
- // on timeout, check for expired matchers
- case <-timeout.C:
- now := time.Now()
-
- // notify and remove any expired matchers
- for e := matcherList.Front(); e != nil; e = e.Next() {
- m := e.Value.(*acceptMatcher)
- if now.After(m.deadline) || now.Equal(m.deadline) {
- t.log.Debugw("accept timeout", "id", m.peer.ID())
- m.connected <- connect{nil, ErrTimeout}
- matcherList.Remove(e)
- }
- }
-
- // on close, notify all the matchers
case <-t.closing:
- for e := matcherList.Front(); e != nil; e = e.Next() {
- e.Value.(*acceptMatcher).connected <- connect{nil, ErrClosed}
- }
return
}
}
}
+func (t *TCP) handleAcceptMatcher(m *acceptMatcher) {
+ t.wg.Add(1)
+ defer t.wg.Done()
+ listElem := t.pushAcceptMatcher(m)
+ defer t.removeAcceptMatcher(listElem)
+ select {
+ case <-m.connectDone:
+ return
+ case <-m.ctx.Done():
+ err := m.ctx.Err()
+ if errors.Is(err, context.DeadlineExceeded) {
+ t.log.Debugw("accept timeout", "id", m.peer.ID())
+ m.setConnect(connect{nil, ErrTimeout})
+ } else {
+ t.log.Debugw("context error", "id", m.peer.ID(), "err", err)
+ m.setConnect(connect{nil, err})
+ }
+ return
+ case <-t.closing:
+ m.setConnect(connect{c: nil, err: ErrClosed})
+ return
+ }
+}
+
+func (t *TCP) matchNewConnection(a accept) bool {
+ t.matchersMutex.RLock()
+ defer t.matchersMutex.RUnlock()
+ matched := false
+ for e := t.matchersList.Front(); e != nil; e = e.Next() {
+ m := e.Value.(*acceptMatcher)
+ if m.peer.ID() == a.fromID {
+ matched = true
+ // finish the handshake
+ go t.matchAccept(m, a.req, a.conn)
+ }
+ }
+ return matched
+}
+
+func (t *TCP) pushAcceptMatcher(m *acceptMatcher) *list.Element {
+ t.matchersMutex.Lock()
+ defer t.matchersMutex.Unlock()
+ return t.matchersList.PushBack(m)
+}
+
+func (t *TCP) removeAcceptMatcher(e *list.Element) {
+ t.matchersMutex.Lock()
+ defer t.matchersMutex.Unlock()
+ t.matchersList.Remove(e)
+}
+
func (t *TCP) matchAccept(m *acceptMatcher, req []byte, conn net.Conn) {
t.wg.Add(1)
defer t.wg.Done()
if err := t.writeHandshakeResponse(req, conn); err != nil {
- m.connected <- connect{nil, fmt.Errorf("incoming handshake failed: %w", err)}
+ m.setConnect(connect{nil, fmt.Errorf("incoming handshake failed: %w", err)})
+
t.closeConnection(conn)
return
}
- m.connected <- connect{conn, nil}
+ m.setConnect(connect{conn, nil})
}
func (t *TCP) listenLoop() {
+ t.wg.Add(1)
defer t.wg.Done()
for {
@@ -295,7 +330,7 @@ func (t *TCP) listenLoop() {
}
select {
- case t.acceptReceived <- accept{
+ case t.acceptReceivedCh <- accept{
fromID: identity.NewID(key),
req: req,
conn: conn,
diff --git a/packages/gossip/server/server_test.go b/packages/gossip/server/server_test.go
index 7fa8defa98..efdba2b77c 100644
--- a/packages/gossip/server/server_test.go
+++ b/packages/gossip/server/server_test.go
@@ -1,6 +1,7 @@
package server
import (
+ "context"
"net"
"sync"
"testing"
@@ -31,8 +32,18 @@ func TestUnansweredAccept(t *testing.T) {
transA, closeA := newTestServer(t, "A")
defer closeA()
- _, err := transA.AcceptPeer(getPeer(transA))
- assert.Error(t, err)
+ _, err := transA.AcceptPeer(context.Background(), getPeer(transA))
+ assert.ErrorIs(t, err, ErrTimeout)
+}
+
+func TestCancelledAccept(t *testing.T) {
+ transA, closeA := newTestServer(t, "A")
+ defer closeA()
+ ctx := context.Background()
+ ctx, cancel := context.WithCancel(ctx)
+ cancel()
+ _, err := transA.AcceptPeer(ctx, getPeer(transA))
+ assert.ErrorIs(t, err, context.Canceled)
}
func TestCloseWhileAccepting(t *testing.T) {
@@ -42,7 +53,7 @@ func TestCloseWhileAccepting(t *testing.T) {
wg.Add(1)
go func() {
defer wg.Done()
- _, err := transA.AcceptPeer(getPeer(transA))
+ _, err := transA.AcceptPeer(context.Background(), getPeer(transA))
assert.Error(t, err)
}()
time.Sleep(graceTime)
@@ -60,7 +71,7 @@ func TestUnansweredDial(t *testing.T) {
services.Update(service.GossipKey, "tcp", 0)
unreachablePeer := peer.NewPeer(getPeer(transA).Identity, net.ParseIP("127.0.0.1"), services)
- _, err := transA.DialPeer(unreachablePeer)
+ _, err := transA.DialPeer(context.Background(), unreachablePeer)
assert.Error(t, err)
}
@@ -84,7 +95,7 @@ func TestNoHandshakeResponse(t *testing.T) {
services.Update(service.GossipKey, lis.Addr().Network(), lis.Addr().(*net.TCPAddr).Port)
p := peer.NewPeer(getPeer(transA).Identity, lis.Addr().(*net.TCPAddr).IP, services)
- _, err = transA.DialPeer(p)
+ _, err = transA.DialPeer(context.Background(), p)
assert.Error(t, err)
}
@@ -96,7 +107,7 @@ func TestNoHandshakeRequest(t *testing.T) {
wg.Add(1)
go func() {
defer wg.Done()
- _, err := transA.AcceptPeer(getPeer(transA))
+ _, err := transA.AcceptPeer(context.Background(), getPeer(transA))
assert.Error(t, err)
}()
time.Sleep(graceTime)
@@ -120,7 +131,7 @@ func TestConnect(t *testing.T) {
go func() {
defer wg.Done()
- c, err := transA.AcceptPeer(getPeer(transB))
+ c, err := transA.AcceptPeer(context.Background(), getPeer(transB))
assert.NoError(t, err)
if assert.NotNil(t, c) {
_ = c.Close()
@@ -129,7 +140,7 @@ func TestConnect(t *testing.T) {
time.Sleep(graceTime)
go func() {
defer wg.Done()
- c, err := transB.DialPeer(getPeer(transA))
+ c, err := transB.DialPeer(context.Background(), getPeer(transA))
assert.NoError(t, err)
if assert.NotNil(t, c) {
_ = c.Close()
@@ -153,12 +164,12 @@ func TestWrongConnect(t *testing.T) {
// a expects connection from B, but C is connecting
go func() {
defer wg.Done()
- _, err := transA.AcceptPeer(getPeer(transB))
+ _, err := transA.AcceptPeer(context.Background(), getPeer(transB))
assert.Error(t, err)
}()
go func() {
defer wg.Done()
- _, err := transC.DialPeer(getPeer(transA))
+ _, err := transC.DialPeer(context.Background(), getPeer(transA))
assert.Error(t, err)
}()
diff --git a/packages/ledgerstate/address.go b/packages/ledgerstate/address.go
index e152e603c3..9a2a8e526b 100644
--- a/packages/ledgerstate/address.go
+++ b/packages/ledgerstate/address.go
@@ -1,6 +1,8 @@
package ledgerstate
import (
+ "bytes"
+
"github.com/cockroachdb/errors"
"github.com/iotaledger/hive.go/byteutils"
"github.com/iotaledger/hive.go/cerrors"
@@ -19,6 +21,9 @@ const (
// BLSAddressType represents an Address secured by the BLS signature scheme.
BLSAddressType
+
+ // AliasAddressType represents ID used in AliasOutput and AliasLockOutput
+ AliasAddressType
)
// AddressLength contains the length of an address (type length = 1, digest length = 32).
@@ -32,6 +37,7 @@ func (a AddressType) String() string {
return [...]string{
"AddressTypeED25519",
"AddressTypeBLS",
+ "AliasAddress",
}[a]
}
@@ -50,6 +56,9 @@ type Address interface {
// Clone creates a copy of the Address.
Clone() Address
+ // Equals returns true if the two Addresses are equal.
+ Equals(other Address) bool
+
// Bytes returns a marshaled version of the Address.
Bytes() []byte
@@ -104,12 +113,25 @@ func AddressFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (address Addre
return ED25519AddressFromMarshalUtil(marshalUtil)
case BLSAddressType:
return BLSAddressFromMarshalUtil(marshalUtil)
+ case AliasAddressType:
+ return AliasAddressFromMarshalUtil(marshalUtil)
default:
err = errors.Errorf("unsupported address type (%X): %w", addressType, cerrors.ErrParseBytesFailed)
return
}
}
+// AddressFromSignature returns address corresponding to the signature if it has one (for ed25519 and BLS).
+func AddressFromSignature(sig Signature) (Address, error) {
+ switch s := sig.(type) {
+ case *ED25519Signature:
+ return NewED25519Address(s.PublicKey), nil
+ case *BLSSignature:
+ return NewBLSAddress(s.Signature.PublicKey.Bytes()), nil
+ }
+ return nil, errors.New("signature has no corresponding address")
+}
+
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// region ED25519Address ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -197,6 +219,11 @@ func (e *ED25519Address) Clone() Address {
}
}
+// Equals returns true if the two Addresses are equal.
+func (e *ED25519Address) Equals(other Address) bool {
+ return e.Type() == other.Type() && bytes.Equal(e.digest, other.Digest())
+}
+
// Bytes returns a marshaled version of the Address.
func (e *ED25519Address) Bytes() []byte {
return byteutils.ConcatBytes([]byte{byte(ED25519AddressType)}, e.digest)
@@ -312,6 +339,11 @@ func (b *BLSAddress) Clone() Address {
}
}
+// Equals returns true if the two Addresses are equal.
+func (b *BLSAddress) Equals(other Address) bool {
+ return b.Type() == other.Type() && bytes.Equal(b.digest, other.Digest())
+}
+
// Bytes returns a marshaled version of the Address.
func (b *BLSAddress) Bytes() []byte {
return byteutils.ConcatBytes([]byte{byte(BLSAddressType)}, b.digest)
@@ -341,3 +373,127 @@ func (b *BLSAddress) String() string {
var _ Address = &BLSAddress{}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AliasAddress ///////////////////////////////////////////////////////////////////////////////////////////////////
+
+// AliasAddressDigestSize defines the length of the alias address digest in bytes.
+const AliasAddressDigestSize = 32
+
+// AliasAddress represents a special type of Address which is not backed by a private key directly,
+// but is indirectly backed by a private key defined by corresponding AliasOutput parameters
+type AliasAddress struct {
+ digest [AliasAddressDigestSize]byte
+}
+
+// NewAliasAddress creates a new AliasAddress from the given bytes used as seed.
+// Normally the seed is an OutputID.
+func NewAliasAddress(data []byte) *AliasAddress {
+ return &AliasAddress{
+ digest: blake2b.Sum256(data),
+ }
+}
+
+// AliasAddressFromBytes unmarshals an AliasAddress from a sequence of bytes.
+func AliasAddressFromBytes(data []byte) (address *AliasAddress, consumedBytes int, err error) {
+ marshalUtil := marshalutil.New(data)
+ if address, err = AliasAddressFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse AliasAddress from MarshalUtil: %w", err)
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+// AliasAddressFromBase58EncodedString creates an AliasAddress from a base58 encoded string.
+func AliasAddressFromBase58EncodedString(base58String string) (address *AliasAddress, err error) {
+ data, err := base58.Decode(base58String)
+ if err != nil {
+ err = errors.Errorf("error while decoding base58 encoded AliasAddress (%v): %w", err, cerrors.ErrBase58DecodeFailed)
+ return
+ }
+
+ if address, _, err = AliasAddressFromBytes(data); err != nil {
+ err = errors.Errorf("failed to parse AliasAddress from data: %w", err)
+ return
+ }
+
+ return
+}
+
+// AliasAddressFromMarshalUtil parses a AliasAddress from the given MarshalUtil.
+func AliasAddressFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (address *AliasAddress, err error) {
+ addressType, err := marshalUtil.ReadByte()
+ if err != nil {
+ err = errors.Errorf("error parsing AddressType (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ if AddressType(addressType) != AliasAddressType {
+ err = errors.Errorf("invalid AddressType (%X): %w", addressType, cerrors.ErrParseBytesFailed)
+ return
+ }
+
+ data, err := marshalUtil.ReadBytes(AliasAddressDigestSize)
+ if err != nil {
+ err = errors.Errorf("error parsing digest (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ address = &AliasAddress{}
+ copy(address.digest[:], data)
+ return
+}
+
+// Type returns the AddressType of the Address.
+func (a *AliasAddress) Type() AddressType {
+ return AliasAddressType
+}
+
+// Digest returns the hashed version of the Addresses public key.
+func (a *AliasAddress) Digest() []byte {
+ return a.digest[:]
+}
+
+// Clone creates a copy of the Address.
+func (a *AliasAddress) Clone() Address {
+ return &AliasAddress{digest: a.digest}
+}
+
+// Bytes returns a marshaled version of the Address.
+func (a *AliasAddress) Bytes() []byte {
+ return byteutils.ConcatBytes([]byte{byte(AliasAddressType)}, a.digest[:])
+}
+
+// Array returns an array of bytes that contains the marshaled version of the Address.
+func (a *AliasAddress) Array() (array [AddressLength]byte) {
+ copy(array[:], a.Bytes())
+
+ return
+}
+
+// Equals returns true if the two Addresses are equal.
+func (a *AliasAddress) Equals(other Address) bool {
+ return a.Type() == other.Type() && bytes.Equal(a.Digest(), other.Digest())
+}
+
+// Base58 returns a base58 encoded version of the Address.
+func (a *AliasAddress) Base58() string {
+ return base58.Encode(a.Bytes())
+}
+
+// String returns a human readable version of the addresses for debug purposes.
+func (a *AliasAddress) String() string {
+ return stringify.Struct("AliasAddress",
+ stringify.StructField("Digest", a.Digest()),
+ stringify.StructField("Base58", a.Base58()),
+ )
+}
+
+// IsNil returns if the alias address is zero value (uninitialized).
+func (a *AliasAddress) IsNil() bool {
+ return a.digest == [32]byte{}
+}
+
+// code contract (make sure the struct implements all required methods)
+var _ Address = &AliasAddress{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/ledgerstate/address_test.go b/packages/ledgerstate/address_test.go
index b83152d203..b77b12ff52 100644
--- a/packages/ledgerstate/address_test.go
+++ b/packages/ledgerstate/address_test.go
@@ -64,3 +64,21 @@ func TestBLSAddress(t *testing.T) {
assert.Equal(t, address.Type(), addressFromBase58.Type())
assert.Equal(t, address.Digest(), addressFromBase58.Digest())
}
+
+func TestAliasAddressClone(t *testing.T) {
+ d := [33]byte{}
+ a := NewAliasAddress(d[:])
+ b := a.Clone()
+ assert.NotSame(t, a, b)
+ assert.Equal(t, a.Array(), b.Array())
+}
+
+func TestAliasAddressIsNil(t *testing.T) {
+ nilAddr := AliasAddress{}
+ require.True(t, nilAddr.IsNil())
+ pNilAddr := &nilAddr
+ require.True(t, pNilAddr.IsNil())
+ notNilAddr := NewAliasAddress([]byte("data"))
+ require.False(t, notNilAddr.IsNil())
+ require.True(t, nilAddr.Equals(&AliasAddress{}))
+}
diff --git a/packages/ledgerstate/color.go b/packages/ledgerstate/color.go
index 396f977039..58927e7d27 100644
--- a/packages/ledgerstate/color.go
+++ b/packages/ledgerstate/color.go
@@ -110,7 +110,11 @@ func NewColoredBalances(balances map[Color]uint64) (coloredBalances *ColoredBala
// deterministically sort colors
sortedColors := make([]Color, 0, len(balances))
- for color := range balances {
+ for color, balance := range balances {
+ if balance == 0 {
+ // drop zero balances
+ continue
+ }
sortedColors = append(sortedColors, color)
}
sort.Slice(sortedColors, func(i, j int) bool { return sortedColors[i].Compare(sortedColors[j]) < 0 })
@@ -142,6 +146,10 @@ func ColoredBalancesFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (color
err = errors.Errorf("failed to parse element count (%v): %w", err, cerrors.ErrParseBytesFailed)
return
}
+ if balancesCount == 0 {
+ err = errors.Errorf("empty balances in output")
+ return
+ }
var previousColor *Color
coloredBalances = NewColoredBalances(nil)
@@ -163,6 +171,10 @@ func ColoredBalancesFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (color
err = errors.Errorf("failed to parse balance of Color %s (%v): %w", color.String(), balanceErr, cerrors.ErrParseBytesFailed)
return
}
+ if balance == 0 {
+ err = errors.Errorf("zero balance found for color %s", color.String())
+ return
+ }
coloredBalances.balances.Set(color, balance)
diff --git a/packages/ledgerstate/output.go b/packages/ledgerstate/output.go
index d4ac9544cb..d51439534c 100644
--- a/packages/ledgerstate/output.go
+++ b/packages/ledgerstate/output.go
@@ -10,6 +10,7 @@ import (
"time"
"github.com/cockroachdb/errors"
+ "github.com/iotaledger/hive.go/bitmask"
"github.com/iotaledger/hive.go/byteutils"
"github.com/iotaledger/hive.go/cerrors"
"github.com/iotaledger/hive.go/marshalutil"
@@ -51,6 +52,12 @@ const (
// SigLockedColoredOutputType represents an Output that holds colored coins that gets unlocked by a signature.
SigLockedColoredOutputType
+
+ // AliasOutputType represents an Output which makes a chain with optional governance
+ AliasOutputType
+
+ // ExtendedLockedOutputType represents an Output which extends SigLockedColoredOutput with alias locking and fallback
+ ExtendedLockedOutputType
)
// String returns a human readable representation of the OutputType.
@@ -58,9 +65,25 @@ func (o OutputType) String() string {
return [...]string{
"SigLockedSingleOutputType",
"SigLockedColoredOutputType",
+ "AliasOutputType",
+ "ExtendedLockedOutputType",
}[o]
}
+// OutputTypeFromString returns the output type from a string.
+func OutputTypeFromString(ot string) (OutputType, error) {
+ res, ok := map[string]OutputType{
+ "SigLockedSingleOutputType": SigLockedSingleOutputType,
+ "SigLockedColoredOutputType": SigLockedColoredOutputType,
+ "AliasOutputType": AliasOutputType,
+ "ExtendedLockedOutputType": ExtendedLockedOutputType,
+ }[ot]
+ if !ok {
+ return res, errors.New(fmt.Sprintf("unsupported output type: %s", ot))
+ }
+ return res, nil
+}
+
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// region OutputID /////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -188,7 +211,11 @@ type Output interface {
// UnlockValid determines if the given Transaction and the corresponding UnlockBlock are allowed to spend the
// Output.
- UnlockValid(tx *Transaction, unlockBlock UnlockBlock) (bool, error)
+ UnlockValid(tx *Transaction, unlockBlock UnlockBlock, inputs []Output) (bool, error)
+
+ // UpdateMintingColor replaces the ColorMint in the balances of the Output with the hash of the OutputID. It returns a
+ // copy of the original Output with the modified balances.
+ UpdateMintingColor() Output
// Input returns an Input that references the Output.
Input() Input
@@ -241,6 +268,17 @@ func OutputFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (output Output,
err = errors.Errorf("failed to parse SigLockedColoredOutput: %w", err)
return
}
+ case AliasOutputType:
+ if output, err = AliasOutputFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse AliasOutput: %w", err)
+ return
+ }
+ case ExtendedLockedOutputType:
+ if output, err = ExtendedOutputFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse ExtendedOutput: %w", err)
+ return
+ }
+
default:
err = errors.Errorf("unsupported OutputType (%X): %w", outputType, cerrors.ErrParseBytesFailed)
return
@@ -601,14 +639,31 @@ func (s *SigLockedSingleOutput) Balances() *ColoredBalances {
}
// UnlockValid determines if the given Transaction and the corresponding UnlockBlock are allowed to spend the Output.
-func (s *SigLockedSingleOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock) (unlockValid bool, err error) {
- signatureUnlockBlock, correctType := unlockBlock.(*SignatureUnlockBlock)
- if !correctType {
- err = errors.Errorf("UnlockBlock does not match expected OutputType: %w", cerrors.ErrParseBytesFailed)
- return
- }
+func (s *SigLockedSingleOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock, inputs []Output) (unlockValid bool, err error) {
+ switch blk := unlockBlock.(type) {
+ case *SignatureUnlockBlock:
+ // unlocking by signature
+ unlockValid = blk.AddressSignatureValid(s.address, tx.Essence().Bytes())
+
+ case *AliasUnlockBlock:
+ // unlocking by alias reference. The unlock is valid if:
+ // - referenced alias output has same alias address
+ // - it is not unlocked for governance
+ if s.address.Type() != AliasAddressType {
+ return false, errors.Errorf("SigLockedSingleOutput: %s address can't be unlocked by alias reference", s.address.Type().String())
+ }
+ refAliasOutput, isAlias := inputs[blk.AliasInputIndex()].(*AliasOutput)
+ if !isAlias {
+ return false, errors.New("SigLockedSingleOutput: referenced input must be AliasOutput")
+ }
+ if !s.address.Equals(refAliasOutput.GetAliasAddress()) {
+ return false, errors.New("SigLockedSingleOutput: wrong alias referenced")
+ }
+ unlockValid = !refAliasOutput.hasToBeUnlockedForGovernanceUpdate(tx)
- unlockValid = signatureUnlockBlock.AddressSignatureValid(s.address, tx.Essence().Bytes())
+ default:
+ err = errors.Errorf("SigLockedSingleOutput: unsupported unlock block type: %w", cerrors.ErrParseBytesFailed)
+ }
return
}
@@ -646,6 +701,11 @@ func (s *SigLockedSingleOutput) Update(objectstorage.StorableObject) {
panic("updates disabled")
}
+// UpdateMintingColor does nothing for SigLockedSingleOutput
+func (s *SigLockedSingleOutput) UpdateMintingColor() Output {
+ return s
+}
+
// ObjectStorageKey returns the key that is used to store the object in the database. It is required to match the
// StorableObject interface.
func (s *SigLockedSingleOutput) ObjectStorageKey() []byte {
@@ -772,14 +832,31 @@ func (s *SigLockedColoredOutput) Balances() *ColoredBalances {
}
// UnlockValid determines if the given Transaction and the corresponding UnlockBlock are allowed to spend the Output.
-func (s *SigLockedColoredOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock) (unlockValid bool, err error) {
- signatureUnlockBlock, correctType := unlockBlock.(*SignatureUnlockBlock)
- if !correctType {
- err = errors.Errorf("UnlockBlock does not match expected OutputType: %w", cerrors.ErrParseBytesFailed)
- return
- }
+func (s *SigLockedColoredOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock, inputs []Output) (unlockValid bool, err error) {
+ switch blk := unlockBlock.(type) {
+ case *SignatureUnlockBlock:
+ // unlocking by signature
+ unlockValid = blk.AddressSignatureValid(s.address, tx.Essence().Bytes())
+
+ case *AliasUnlockBlock:
+ // unlocking by alias reference. The unlock is valid if:
+ // - referenced alias output has same alias address
+ // - it is not unlocked for governance
+ if s.address.Type() != AliasAddressType {
+ return false, errors.Errorf("SigLockedColoredOutput: %s address can't be unlocked by alias reference", s.address.Type().String())
+ }
+ refAliasOutput, isAlias := inputs[blk.AliasInputIndex()].(*AliasOutput)
+ if !isAlias {
+ return false, errors.New("SigLockedColoredOutput: referenced input must be AliasOutput")
+ }
+ if !s.address.Equals(refAliasOutput.GetAliasAddress()) {
+ return false, errors.New("SigLockedColoredOutput: wrong alias referenced")
+ }
+ unlockValid = !refAliasOutput.hasToBeUnlockedForGovernanceUpdate(tx)
- unlockValid = signatureUnlockBlock.AddressSignatureValid(s.address, tx.Essence().Bytes())
+ default:
+ err = errors.Errorf("SigLockedColoredOutput: unsupported unlock block type: %w", cerrors.ErrParseBytesFailed)
+ }
return
}
@@ -809,7 +886,7 @@ func (s *SigLockedColoredOutput) Clone() Output {
// UpdateMintingColor replaces the ColorMint in the balances of the Output with the hash of the OutputID. It returns a
// copy of the original Output with the modified balances.
-func (s *SigLockedColoredOutput) UpdateMintingColor() (updatedOutput *SigLockedColoredOutput) {
+func (s *SigLockedColoredOutput) UpdateMintingColor() (updatedOutput Output) {
coloredBalances := s.Balances().Map()
if mintedCoins, mintedCoinsExist := coloredBalances[ColorMint]; mintedCoinsExist {
delete(coloredBalances, ColorMint)
@@ -867,6 +944,1277 @@ var _ Output = &SigLockedColoredOutput{}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+// region AliasOutput ///////////////////////////////////////////////////////////////////////////////////////
+
+// DustThresholdAliasOutputIOTA is minimum number of iotas enforced for the output to be correct
+// TODO protocol-wide dust threshold configuration
+const DustThresholdAliasOutputIOTA = uint64(100)
+
+// MaxOutputPayloadSize size limit on the data payload in the output.
+const MaxOutputPayloadSize = 4 * 1024
+
+// flags use to compress serialized bytes
+const (
+ flagAliasOutputGovernanceUpdate = uint(iota)
+ flagAliasOutputGovernanceSet
+ flagAliasOutputStateDataPresent
+ flagAliasOutputGovernanceMetadataPresent
+ flagAliasOutputImmutableDataPresent
+ flagAliasOutputIsOrigin
+ flagAliasOutputDelegationConstraint
+ flagAliasOutputDelegationTimelockPresent
+)
+
+// AliasOutput represents output which defines as AliasAddress.
+// It can only be used in a chained manner
+type AliasOutput struct {
+ // common for all outputs
+ outputID OutputID
+ outputIDMutex sync.RWMutex
+ balances *ColoredBalances
+
+ // aliasAddress becomes immutable after created for a lifetime. It is returned as Address()
+ aliasAddress AliasAddress
+ // address which controls the state and state data
+ // It can only be changed by governing entity, if set. Otherwise it is self governed.
+ // Can also be an AliasAddress
+ stateAddress Address
+ // state index is enforced incremental counter of state updates. The constraint is:
+ // - start at 0 when chain in minted
+ // - increase by 1 with each new chained output with isGovernanceUpdate == false
+ // - do not change with any new chained output with isGovernanceUpdate == true
+ stateIndex uint32
+ // optional state metadata. nil means absent
+ stateData []byte
+ // optional governance level metadata, that can only be changed with a governance update
+ governanceMetadata []byte
+ // optional immutable data. It is set when AliasOutput is minted and can't be changed since
+ // Useful for NFTs
+ immutableData []byte
+ // if the AliasOutput is chained in the transaction, the flags states if it is updating state or governance data.
+ // unlock validation of the corresponding input depends on it.
+ isGovernanceUpdate bool
+ // governance address if set. It can be any address, unlocked by signature of alias address. Nil means self governed
+ governingAddress Address
+ // true if it is the first output in the chain
+ isOrigin bool
+ // true if the output is subject to the "delegation" constraint: upon transition tokens cannot be changed
+ isDelegated bool
+ // delegation timelock (optional). Before the timelock, only state transition is permitted, after the timelock, only
+ // governance transition
+ delegationTimelock time.Time
+
+ objectstorage.StorableObjectFlags
+}
+
+// NewAliasOutputMint creates new AliasOutput as minting output, i.e. the one which does not contain corresponding input.
+func NewAliasOutputMint(balances map[Color]uint64, stateAddr Address, immutableData ...[]byte) (*AliasOutput, error) {
+ if !IsAboveDustThreshold(balances) {
+ return nil, errors.New("AliasOutput: colored balances are below dust threshold")
+ }
+ if stateAddr == nil {
+ return nil, errors.New("AliasOutput: mandatory state address cannot be nil")
+ }
+ ret := &AliasOutput{
+ balances: NewColoredBalances(balances),
+ stateAddress: stateAddr,
+ isOrigin: true,
+ }
+ if len(immutableData) > 0 {
+ ret.immutableData = immutableData[0]
+ }
+ if err := ret.checkBasicValidity(); err != nil {
+ return nil, err
+ }
+ return ret, nil
+}
+
+// NewAliasOutputNext creates new AliasOutput as state transition from the previous one
+func (a *AliasOutput) NewAliasOutputNext(governanceUpdate ...bool) *AliasOutput {
+ ret := a.clone()
+ ret.isOrigin = false
+ ret.isGovernanceUpdate = false
+ if len(governanceUpdate) > 0 {
+ ret.isGovernanceUpdate = governanceUpdate[0]
+ }
+ if !ret.isGovernanceUpdate {
+ ret.stateIndex = a.stateIndex + 1
+ }
+ return ret
+}
+
+// WithDelegation returns the output as a delegateds alias output.
+func (a *AliasOutput) WithDelegation() *AliasOutput {
+ a.isDelegated = true
+ return a
+}
+
+// WithDelegationAndTimelock returns the output as a delegated alias output and a set delegation timelock.
+func (a *AliasOutput) WithDelegationAndTimelock(lockUntil time.Time) *AliasOutput {
+ a.isDelegated = true
+ a.delegationTimelock = lockUntil
+ return a
+}
+
+// AliasOutputFromMarshalUtil unmarshals a AliasOutput using a MarshalUtil (for easier unmarshaling).
+func AliasOutputFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (*AliasOutput, error) {
+ var ret *AliasOutput
+ outputType, err := marshalUtil.ReadByte()
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse OutputType (%v): %w", err, cerrors.ErrParseBytesFailed)
+ }
+ if OutputType(outputType) != AliasOutputType {
+ return nil, errors.Errorf("AliasOutput: invalid OutputType (%X): %w", outputType, cerrors.ErrParseBytesFailed)
+ }
+ ret = &AliasOutput{}
+ flagsByte, err1 := marshalUtil.ReadByte()
+ if err1 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse AliasOutput flags (%v): %w", err1, cerrors.ErrParseBytesFailed)
+ }
+ flags := bitmask.BitMask(flagsByte)
+ ret.isOrigin = flags.HasBit(flagAliasOutputIsOrigin)
+ ret.isGovernanceUpdate = flags.HasBit(flagAliasOutputGovernanceUpdate)
+ ret.isDelegated = flags.HasBit(flagAliasOutputDelegationConstraint)
+
+ addr, err2 := AliasAddressFromMarshalUtil(marshalUtil)
+ if err2 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse alias address (%v): %w", err2, cerrors.ErrParseBytesFailed)
+ }
+ ret.aliasAddress = *addr
+ cb, err3 := ColoredBalancesFromMarshalUtil(marshalUtil)
+ if err3 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse colored balances: %w", err3)
+ }
+ ret.balances = cb
+ ret.stateAddress, err = AddressFromMarshalUtil(marshalUtil)
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse state address (%v): %w", err, cerrors.ErrParseBytesFailed)
+ }
+ ret.stateIndex, err = marshalUtil.ReadUint32()
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse state address (%v): %w", err, cerrors.ErrParseBytesFailed)
+ }
+ if flags.HasBit(flagAliasOutputStateDataPresent) {
+ size, err4 := marshalUtil.ReadUint16()
+ if err4 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse state data size: %w", err4)
+ }
+ ret.stateData, err = marshalUtil.ReadBytes(int(size))
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse state data: %w", err)
+ }
+ }
+ if flags.HasBit(flagAliasOutputGovernanceMetadataPresent) {
+ size, err5 := marshalUtil.ReadUint16()
+ if err5 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse governance metadata size: %w", err5)
+ }
+ ret.governanceMetadata, err = marshalUtil.ReadBytes(int(size))
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse governance metadata data: %w", err)
+ }
+ }
+ if flags.HasBit(flagAliasOutputImmutableDataPresent) {
+ size, err6 := marshalUtil.ReadUint16()
+ if err6 != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse immutable data size: %w", err6)
+ }
+ ret.immutableData, err = marshalUtil.ReadBytes(int(size))
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse immutable data: %w", err)
+ }
+ }
+ if flags.HasBit(flagAliasOutputGovernanceSet) {
+ ret.governingAddress, err = AddressFromMarshalUtil(marshalUtil)
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse governing address (%v): %w", err, cerrors.ErrParseBytesFailed)
+ }
+ }
+ if flags.HasBit(flagAliasOutputDelegationTimelockPresent) {
+ ret.delegationTimelock, err = marshalUtil.ReadTime()
+ if err != nil {
+ return nil, errors.Errorf("AliasOutput: failed to parse delegation timelock (%v): %w", err, cerrors.ErrParseBytesFailed)
+ }
+ }
+ if err7 := ret.checkBasicValidity(); err7 != nil {
+ return nil, err7
+ }
+ return ret, nil
+}
+
+// SetBalances sets colored balances of the output
+func (a *AliasOutput) SetBalances(balances map[Color]uint64) error {
+ if !IsAboveDustThreshold(balances) {
+ return errors.New("AliasOutput: balances are less than dust threshold")
+ }
+ a.balances = NewColoredBalances(balances)
+ return nil
+}
+
+// GetAliasAddress calculates new ID if it is a minting output. Otherwise it takes stored value
+func (a *AliasOutput) GetAliasAddress() *AliasAddress {
+ if a.aliasAddress.IsNil() {
+ return NewAliasAddress(a.ID().Bytes())
+ }
+ return &a.aliasAddress
+}
+
+// SetAliasAddress sets the alias address of the alias output.
+func (a *AliasOutput) SetAliasAddress(addr *AliasAddress) {
+ a.aliasAddress = *addr
+}
+
+// IsOrigin returns true if it starts the chain
+func (a *AliasOutput) IsOrigin() bool {
+ return a.isOrigin
+}
+
+// SetIsOrigin sets the isOrigin field of the output.
+func (a *AliasOutput) SetIsOrigin(isOrigin bool) {
+ a.isOrigin = isOrigin
+}
+
+// IsDelegated returns true if the output is delegated.
+func (a *AliasOutput) IsDelegated() bool {
+ return a.isDelegated
+}
+
+// SetIsDelegated sets the isDelegated field of the output.
+func (a *AliasOutput) SetIsDelegated(isDelegated bool) {
+ a.isDelegated = isDelegated
+}
+
+// IsSelfGoverned returns if governing address is not set which means that stateAddress is same as governingAddress
+func (a *AliasOutput) IsSelfGoverned() bool {
+ return a.governingAddress == nil
+}
+
+// GetStateAddress return state controlling address
+func (a *AliasOutput) GetStateAddress() Address {
+ return a.stateAddress
+}
+
+// SetStateAddress sets the state controlling address
+func (a *AliasOutput) SetStateAddress(addr Address) error {
+ if addr == nil {
+ return errors.New("AliasOutput: mandatory state address cannot be nil")
+ }
+ a.stateAddress = addr
+ return nil
+}
+
+// SetGoverningAddress sets the governing address or nil for self-governing
+func (a *AliasOutput) SetGoverningAddress(addr Address) {
+ if addr == nil {
+ a.governingAddress = nil
+ return
+ }
+ // calling Array on nil panics
+ if addr.Array() == a.stateAddress.Array() {
+ addr = nil // self governing
+ }
+ a.governingAddress = addr
+}
+
+// GetGoverningAddress return governing address. If self-governed, it is the same as state controlling address
+func (a *AliasOutput) GetGoverningAddress() Address {
+ if a.IsSelfGoverned() {
+ return a.stateAddress
+ }
+ return a.governingAddress
+}
+
+// SetStateData sets state data
+func (a *AliasOutput) SetStateData(data []byte) error {
+ if len(data) > MaxOutputPayloadSize {
+ return errors.New("AliasOutput: state data too big")
+ }
+ a.stateData = make([]byte, len(data))
+ copy(a.stateData, data)
+ return nil
+}
+
+// GetStateData gets the state data
+func (a *AliasOutput) GetStateData() []byte {
+ return a.stateData
+}
+
+// SetGovernanceMetadata sets governance metadata
+func (a *AliasOutput) SetGovernanceMetadata(data []byte) error {
+ if len(data) > MaxOutputPayloadSize {
+ return errors.New("AliasOutput: governance metadata too big")
+ }
+ a.governanceMetadata = make([]byte, len(data))
+ copy(a.governanceMetadata, data)
+ return nil
+}
+
+// GetGovernanceMetadata gets the governance metadata
+func (a *AliasOutput) GetGovernanceMetadata() []byte {
+ return a.governanceMetadata
+}
+
+// SetStateIndex sets the state index in the input. It is enforced to increment by 1 with each state transition
+func (a *AliasOutput) SetStateIndex(index uint32) {
+ a.stateIndex = index
+}
+
+// GetIsGovernanceUpdated returns if the output was unlocked for governance in the transaction.
+func (a *AliasOutput) GetIsGovernanceUpdated() bool {
+ return a.isGovernanceUpdate
+}
+
+// SetIsGovernanceUpdated sets the isGovernanceUpdated flag.
+func (a *AliasOutput) SetIsGovernanceUpdated(i bool) {
+ a.isGovernanceUpdate = i
+}
+
+// GetStateIndex returns the state index
+func (a *AliasOutput) GetStateIndex() uint32 {
+ return a.stateIndex
+}
+
+// GetImmutableData gets the state data
+func (a *AliasOutput) GetImmutableData() []byte {
+ return a.immutableData
+}
+
+// SetImmutableData sets the immutable data field of the alias output.
+func (a *AliasOutput) SetImmutableData(data []byte) error {
+ if len(data) > MaxOutputPayloadSize {
+ return errors.New("AliasOutput: immutable data too big")
+ }
+ a.immutableData = make([]byte, len(data))
+ copy(a.immutableData, data)
+ return nil
+}
+
+// SetDelegationTimelock sets the delegation timelock. An error is returned if the output is not a delegated.
+func (a *AliasOutput) SetDelegationTimelock(timelock time.Time) error {
+ if !a.isDelegated {
+ return errors.Errorf("AliasOutput: delegation timelock can only be set on a delegated output")
+ }
+ a.delegationTimelock = timelock
+ return nil
+}
+
+// DelegationTimelock returns the delegation timelock. If the output is not delegated, or delegation timelock is
+// not set, it returns the zero time object.
+func (a *AliasOutput) DelegationTimelock() time.Time {
+ if !a.isDelegated {
+ return time.Time{}
+ }
+ return a.delegationTimelock
+}
+
+// DelegationTimeLockedNow determines if the alias output is delegation timelocked at a given time.
+func (a *AliasOutput) DelegationTimeLockedNow(nowis time.Time) bool {
+ if !a.isDelegated || a.delegationTimelock.IsZero() {
+ return false
+ }
+ return a.delegationTimelock.After(nowis)
+}
+
+// Clone clones the structure
+func (a *AliasOutput) Clone() Output {
+ return a.clone()
+}
+
+func (a *AliasOutput) clone() *AliasOutput {
+ a.mustValidate()
+ ret := &AliasOutput{
+ outputID: a.outputID,
+ balances: a.balances.Clone(),
+ aliasAddress: *a.GetAliasAddress(),
+ stateAddress: a.stateAddress.Clone(),
+ stateIndex: a.stateIndex,
+ stateData: make([]byte, len(a.stateData)),
+ governanceMetadata: make([]byte, len(a.governanceMetadata)),
+ immutableData: make([]byte, len(a.immutableData)),
+ delegationTimelock: a.delegationTimelock,
+ isOrigin: a.isOrigin,
+ isDelegated: a.isDelegated,
+ isGovernanceUpdate: a.isGovernanceUpdate,
+ }
+ if a.governingAddress != nil {
+ ret.governingAddress = a.governingAddress.Clone()
+ }
+ copy(ret.stateData, a.stateData)
+ copy(ret.governanceMetadata, a.governanceMetadata)
+ copy(ret.immutableData, a.immutableData)
+ ret.mustValidate()
+ return ret
+}
+
+// ID is the ID of the output
+func (a *AliasOutput) ID() OutputID {
+ a.outputIDMutex.RLock()
+ defer a.outputIDMutex.RUnlock()
+
+ return a.outputID
+}
+
+// SetID set the output ID after unmarshalling
+func (a *AliasOutput) SetID(outputID OutputID) Output {
+ a.outputIDMutex.Lock()
+ defer a.outputIDMutex.Unlock()
+
+ a.outputID = outputID
+ return a
+}
+
+// Type return the type of the output
+func (a *AliasOutput) Type() OutputType {
+ return AliasOutputType
+}
+
+// Balances return colored balances of the output
+func (a *AliasOutput) Balances() *ColoredBalances {
+ return a.balances
+}
+
+// Address AliasOutput is searchable in the ledger through its AliasAddress
+func (a *AliasOutput) Address() Address {
+ return a.GetAliasAddress()
+}
+
+// Input makes input from the output
+func (a *AliasOutput) Input() Input {
+ if a.ID() == EmptyOutputID {
+ panic("AliasOutput: Outputs that haven't been assigned an ID, yet cannot be converted to an Input")
+ }
+
+ return NewUTXOInput(a.ID())
+}
+
+// Bytes serialized form
+func (a *AliasOutput) Bytes() []byte {
+ return a.ObjectStorageValue()
+}
+
+// String human readable form
+func (a *AliasOutput) String() string {
+ ret := "AliasOutput:\n"
+ ret += fmt.Sprintf(" address: %s\n", a.Address())
+ ret += fmt.Sprintf(" outputID: %s\n", a.ID())
+ ret += fmt.Sprintf(" balance: %s\n", a.balances.String())
+ ret += fmt.Sprintf(" stateAddress: %s\n", a.stateAddress)
+ ret += fmt.Sprintf(" stateMetadataSize: %d\n", len(a.stateData))
+ ret += fmt.Sprintf(" governingAddress (self-governed=%v): %s\n", a.IsSelfGoverned(), a.GetGoverningAddress())
+ return ret
+}
+
+// Compare the two outputs
+func (a *AliasOutput) Compare(other Output) int {
+ return bytes.Compare(a.Bytes(), other.Bytes())
+}
+
+// Update is disabled
+func (a *AliasOutput) Update(other objectstorage.StorableObject) {
+ panic("AliasOutput: storage object updates disabled")
+}
+
+// ObjectStorageKey a key
+func (a *AliasOutput) ObjectStorageKey() []byte {
+ return a.ID().Bytes()
+}
+
+// ObjectStorageValue binary form
+func (a *AliasOutput) ObjectStorageValue() []byte {
+ flags := a.mustFlags()
+ ret := marshalutil.New().
+ WriteByte(byte(AliasOutputType)).
+ WriteByte(byte(flags)).
+ WriteBytes(a.aliasAddress.Bytes()).
+ WriteBytes(a.balances.Bytes()).
+ WriteBytes(a.stateAddress.Bytes()).
+ WriteUint32(a.stateIndex)
+ if flags.HasBit(flagAliasOutputStateDataPresent) {
+ ret.WriteUint16(uint16(len(a.stateData))).
+ WriteBytes(a.stateData)
+ }
+ if flags.HasBit(flagAliasOutputGovernanceMetadataPresent) {
+ ret.WriteUint16(uint16(len(a.governanceMetadata))).
+ WriteBytes(a.governanceMetadata)
+ }
+ if flags.HasBit(flagAliasOutputImmutableDataPresent) {
+ ret.WriteUint16(uint16(len(a.immutableData))).
+ WriteBytes(a.immutableData)
+ }
+ if flags.HasBit(flagAliasOutputGovernanceSet) {
+ ret.WriteBytes(a.governingAddress.Bytes())
+ }
+ if flags.HasBit(flagAliasOutputDelegationTimelockPresent) {
+ ret.WriteTime(a.delegationTimelock)
+ }
+ return ret.Bytes()
+}
+
+// UnlockValid check unlock and validates chain
+func (a *AliasOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock, inputs []Output) (bool, error) {
+ // find the chained output in the tx
+ chained, err := a.findChainedOutputAndCheckFork(tx)
+ if err != nil {
+ return false, err
+ }
+ switch blk := unlockBlock.(type) {
+ case *SignatureUnlockBlock:
+ // check signatures and validate transition
+ if chained != nil {
+ // chained output is present
+ if chained.isGovernanceUpdate {
+ // check if signature is valid against governing address
+ if !blk.AddressSignatureValid(a.GetGoverningAddress(), tx.Essence().Bytes()) {
+ return false, errors.New("signature is invalid for governance unlock")
+ }
+ } else {
+ // check if signature is valid against state address
+ if !blk.AddressSignatureValid(a.GetStateAddress(), tx.Essence().Bytes()) {
+ return false, errors.New("signature is invalid for state unlock")
+ }
+ }
+ // validate if transition passes the constraints
+ if err := a.validateTransition(chained, tx); err != nil {
+ return false, err
+ }
+ } else {
+ // no chained output found. Alias is being destroyed?
+ // check if governance is unlocked
+ if !blk.AddressSignatureValid(a.GetGoverningAddress(), tx.Essence().Bytes()) {
+ return false, errors.New("signature is invalid for chain output deletion")
+ }
+ // validate deletion constraint
+ if err := a.validateDestroyTransitionNow(tx.Essence().Timestamp()); err != nil {
+ return false, err
+ }
+ }
+ return true, nil
+ case *AliasUnlockBlock:
+ // The referenced alias output should always be unlocked itself for state transition. But since the state address
+ // can be an AliasAddress, the referenced alias may be unlocked by in turn an other referenced alias. This can cause
+ // circular dependency among the unlock blocks, that results in all of them being unlocked without anyone having to
+ // provide a signature. As a consequence, the circular dependencies of the alias unlock blocks is checked before
+ // the UnlockValid() methods are called on any unlock blocks. We assume in this function that there is no such
+ // circular dependency.
+ if chained != nil {
+ // chained output is present
+ if chained.isGovernanceUpdate {
+ if valid, err := a.unlockedGovernanceTransitionByAliasIndex(tx, blk.AliasInputIndex(), inputs); !valid {
+ return false, errors.Errorf("referenced alias does not unlock alias for governance transition: %w", err)
+ }
+ } else {
+ if valid, err := a.unlockedStateTransitionByAliasIndex(tx, blk.AliasInputIndex(), inputs); !valid {
+ return false, errors.Errorf("referenced alias does not unlock alias for state transition: %w", err)
+ }
+ }
+ // validate if transition passes the constraints
+ if err := a.validateTransition(chained, tx); err != nil {
+ return false, err
+ }
+ } else {
+ // no chained output is present. Alias being destroyed?
+ // check if alias is unlocked for governance transition by the referenced
+ if valid, err := a.unlockedGovernanceTransitionByAliasIndex(tx, blk.AliasInputIndex(), inputs); !valid {
+ return false, errors.Errorf("referenced alias does not unlock alias for governance transition: %w", err)
+ }
+ // validate deletion constraint
+ if err := a.validateDestroyTransitionNow(tx.Essence().Timestamp()); err != nil {
+ return false, err
+ }
+ }
+ return true, nil
+ }
+ return false, errors.New("unsupported unlock block type")
+}
+
+// UpdateMintingColor replaces minting code with computed color code, and calculates the alias address if it is a
+// freshly minted alias output
+func (a *AliasOutput) UpdateMintingColor() Output {
+ coloredBalances := a.Balances().Map()
+ if mintedCoins, mintedCoinsExist := coloredBalances[ColorMint]; mintedCoinsExist {
+ delete(coloredBalances, ColorMint)
+ coloredBalances[Color(blake2b.Sum256(a.ID().Bytes()))] = mintedCoins
+ }
+ updatedOutput := a.clone()
+ _ = updatedOutput.SetBalances(coloredBalances)
+ updatedOutput.SetID(a.ID())
+
+ if a.IsOrigin() {
+ updatedOutput.SetAliasAddress(NewAliasAddress(a.ID().Bytes()))
+ }
+
+ return updatedOutput
+}
+
+// checkBasicValidity checks basic validity of the output
+func (a *AliasOutput) checkBasicValidity() error {
+ if !IsAboveDustThreshold(a.balances.Map()) {
+ return errors.New("AliasOutput: balances are below dust threshold")
+ }
+ if a.stateAddress == nil {
+ return errors.New("AliasOutput: state address must not be nil")
+ }
+ if a.IsOrigin() && a.stateIndex != 0 {
+ return errors.New("AliasOutput: origin must have stateIndex == 0")
+ }
+ // a.aliasAddress is not set if the output is origin. It is only set after the output has been included in a tx, and
+ // its outputID is known. To cover this edge case, TransactionFromMarshalUtil() performs the two checks below after
+ // the ID has been set.
+ if a.GetStateAddress().Equals(&a.aliasAddress) {
+ return errors.New("state address cannot be the output's own alias address")
+ }
+ if a.GetGoverningAddress().Equals(&a.aliasAddress) {
+ return errors.New("governing address cannot be the output's own alias address")
+ }
+ if len(a.stateData) > MaxOutputPayloadSize {
+ return errors.Errorf("AliasOutput: size of the stateData (%d) exceeds maximum allowed (%d)",
+ len(a.stateData), MaxOutputPayloadSize)
+ }
+ if len(a.governanceMetadata) > MaxOutputPayloadSize {
+ return errors.Errorf("AliasOutput: size of the governance metadata (%d) exceeds maximum allowed (%d)",
+ len(a.governanceMetadata), MaxOutputPayloadSize)
+ }
+ if len(a.immutableData) > MaxOutputPayloadSize {
+ return errors.Errorf("AliasOutput: size of the immutableData (%d) exceeds maximum allowed (%d)",
+ len(a.immutableData), MaxOutputPayloadSize)
+ }
+ if !a.isDelegated && !a.delegationTimelock.IsZero() {
+ return errors.Errorf("AliasOutput: delegation timelock is present, but output is not delegated")
+ }
+ return nil
+}
+
+// mustValidate internal validity assertion
+func (a *AliasOutput) mustValidate() {
+ if err := a.checkBasicValidity(); err != nil {
+ panic(err)
+ }
+}
+
+// mustFlags produces flags for serialization
+func (a *AliasOutput) mustFlags() bitmask.BitMask {
+ a.mustValidate()
+ var ret bitmask.BitMask
+ if a.isOrigin {
+ ret = ret.SetBit(flagAliasOutputIsOrigin)
+ }
+ if a.isGovernanceUpdate {
+ ret = ret.SetBit(flagAliasOutputGovernanceUpdate)
+ }
+ if len(a.immutableData) > 0 {
+ ret = ret.SetBit(flagAliasOutputImmutableDataPresent)
+ }
+ if len(a.stateData) > 0 {
+ ret = ret.SetBit(flagAliasOutputStateDataPresent)
+ }
+ if a.governingAddress != nil {
+ ret = ret.SetBit(flagAliasOutputGovernanceSet)
+ }
+ if len(a.governanceMetadata) > 0 {
+ ret = ret.SetBit(flagAliasOutputGovernanceMetadataPresent)
+ }
+ if a.isDelegated {
+ ret = ret.SetBit(flagAliasOutputDelegationConstraint)
+ }
+ if !a.delegationTimelock.IsZero() {
+ ret = ret.SetBit(flagAliasOutputDelegationTimelockPresent)
+ }
+ return ret
+}
+
+// findChainedOutputAndCheckFork finds corresponding chained output.
+// If it is not unique, returns an error
+// If there's no such output, return nil and no error
+func (a *AliasOutput) findChainedOutputAndCheckFork(tx *Transaction) (*AliasOutput, error) {
+ var ret *AliasOutput
+ aliasAddress := a.GetAliasAddress()
+ for _, out := range tx.Essence().Outputs() {
+ if out.Type() != AliasOutputType {
+ continue
+ }
+ outAlias := out.(*AliasOutput)
+ if !aliasAddress.Equals(outAlias.GetAliasAddress()) {
+ continue
+ }
+ if ret != nil {
+ return nil, errors.Errorf("duplicated alias output: %s", aliasAddress.String())
+ }
+ ret = outAlias
+ }
+ return ret, nil
+}
+
+// equalColoredBalances utility to compare colored balances
+func equalColoredBalances(b1, b2 *ColoredBalances) bool {
+ allColors := make(map[Color]bool)
+ b1.ForEach(func(col Color, bal uint64) bool {
+ allColors[col] = true
+ return true
+ })
+ b2.ForEach(func(col Color, bal uint64) bool {
+ allColors[col] = true
+ return true
+ })
+ for col := range allColors {
+ v1, ok1 := b1.Get(col)
+ v2, ok2 := b2.Get(col)
+ if ok1 != ok2 || v1 != v2 {
+ return false
+ }
+ }
+ return true
+}
+
+// IsAboveDustThreshold internal utility to check if balances pass dust constraint
+func IsAboveDustThreshold(m map[Color]uint64) bool {
+ if iotas, ok := m[ColorIOTA]; ok && iotas >= DustThresholdAliasOutputIOTA {
+ return true
+ }
+ return false
+}
+
+// IsExactDustMinimum checks if colored balances are exactly what is required by dust constraint
+func IsExactDustMinimum(b *ColoredBalances) bool {
+ bals := b.Map()
+ if len(bals) != 1 {
+ return false
+ }
+ bal, ok := bals[ColorIOTA]
+ if !ok || bal != DustThresholdAliasOutputIOTA {
+ return false
+ }
+ return true
+}
+
+// validateTransition enforces transition constraints between input and output chain outputs
+func (a *AliasOutput) validateTransition(chained *AliasOutput, tx *Transaction) error {
+ // enforce immutability of alias address and immutable data
+ if !a.GetAliasAddress().Equals(chained.GetAliasAddress()) {
+ return errors.New("AliasOutput: can't modify alias address")
+ }
+ if !bytes.Equal(a.immutableData, chained.immutableData) {
+ return errors.New("AliasOutput: can't modify immutable data")
+ }
+ // depending on update type, enforce valid transition
+ if chained.isGovernanceUpdate {
+ // GOVERNANCE TRANSITION
+ // should not modify state data
+ if !bytes.Equal(a.stateData, chained.stateData) {
+ return errors.New("AliasOutput: state data is not unlocked for modification")
+ }
+ // should not modify state index
+ if a.stateIndex != chained.stateIndex {
+ return errors.New("AliasOutput: state index is not unlocked for modification")
+ }
+ // should not modify tokens
+ if !equalColoredBalances(a.balances, chained.balances) {
+ return errors.New("AliasOutput: tokens are not unlocked for modification")
+ }
+ // if delegation timelock is set and active, governance transition is invalid
+ // It means delegating party can't take funds back before timelock deadline
+ if a.IsDelegated() && a.DelegationTimeLockedNow(tx.Essence().Timestamp()) {
+ return errors.Errorf("AliasOutput: governance transition not allowed until %s, transaction timestamp is: %s",
+ a.delegationTimelock.String(), tx.Essence().Timestamp().String())
+ }
+ // can modify state address
+ // can modify governing address
+ // can modify governance metadata
+ // can modify delegation status
+ // can modify delegation timelock
+ } else {
+ // STATE TRANSITION
+ // can modify state data
+ // should increment state index
+ if a.stateIndex+1 != chained.stateIndex {
+ return errors.Errorf("AliasOutput: expected state index is %d found %d", a.stateIndex+1, chained.stateIndex)
+ }
+ // can modify tokens
+ // should not modify stateAddress
+ if !a.stateAddress.Equals(chained.stateAddress) {
+ return errors.New("AliasOutput: state address is not unlocked for modification")
+ }
+ // should not modify governing address
+ if a.IsSelfGoverned() != chained.IsSelfGoverned() ||
+ (a.governingAddress != nil && !a.governingAddress.Equals(chained.governingAddress)) {
+ return errors.New("AliasOutput: governing address is not unlocked for modification")
+ }
+ // should not modify governance metadata
+ if !bytes.Equal(a.governanceMetadata, chained.governanceMetadata) {
+ return errors.New("AliasOutput: governance metadata is not unlocked for modification")
+ }
+ // should not modify token balances if delegation constraint is set
+ if a.IsDelegated() && !equalColoredBalances(a.balances, chained.balances) {
+ return errors.New("AliasOutput: delegated output funds can't be changed")
+ }
+ // should not modify delegation status in state transition
+ if a.IsDelegated() != chained.IsDelegated() {
+ return errors.New("AliasOutput: delegation status can't be changed")
+ }
+ // should not modify delegation timelock
+ if !a.DelegationTimelock().Equal(chained.DelegationTimelock()) {
+ return errors.New("AliasOutput: delegation timelock can't be changed")
+ }
+ // can only be accepted:
+ // - if no delegation timelock, state update can happen whenever
+ // - if delegation timelock is present, need to check if the timelock is active, otherwise state update not allowed
+ if a.IsDelegated() && !a.DelegationTimelock().IsZero() && !a.DelegationTimeLockedNow(tx.Essence().Timestamp()) {
+ return errors.Errorf("AliasOutput: state transition of delegated output not allowed after %s, transaction timestamp is %s",
+ a.delegationTimelock.String(), tx.Essence().Timestamp().String())
+ }
+ }
+ return nil
+}
+
+// validateDestroyTransitionNow check validity if input is not chained (destroyed)
+func (a *AliasOutput) validateDestroyTransitionNow(nowis time.Time) error {
+ if !a.IsDelegated() && !IsExactDustMinimum(a.balances) {
+ // if the output is delegated, it can be destroyed with more than minimum balance
+ return errors.New("AliasOutput: didn't find chained output and there are more tokens then upper limit for non-delegated alias destruction")
+ }
+ if a.IsDelegated() && a.DelegationTimeLockedNow(nowis) {
+ return errors.New("AliasOutput: didn't find expected chained output for delegated output")
+ }
+ return nil
+}
+
+// unlockedGovernanceTransitionByAliasIndex unlocks one step of alias dereference for governance transition
+func (a *AliasOutput) unlockedGovernanceTransitionByAliasIndex(tx *Transaction, refIndex uint16, inputs []Output) (bool, error) {
+ // when output is self governed, a.GetGoverningAddress() returns the state address
+ if a.GetGoverningAddress().Type() != AliasAddressType {
+ return false, errors.New("AliasOutput: expected governing address of AliasAddress type")
+ }
+ if int(refIndex) > len(inputs) {
+ return false, errors.New("AliasOutput: wrong alias reference index")
+ }
+ refInput, ok := inputs[refIndex].(*AliasOutput)
+ if !ok {
+ return false, errors.New("AliasOutput: the referenced output is not of AliasOutput type")
+ }
+ if !refInput.GetAliasAddress().Equals(a.GetGoverningAddress().(*AliasAddress)) {
+ return false, errors.New("AliasOutput: wrong alias reference address")
+ }
+ // the referenced output must be unlocked for state update
+ return !refInput.hasToBeUnlockedForGovernanceUpdate(tx), nil
+}
+
+// unlockedStateTransitionByAliasIndex unlocks one step of alias dereference for state transition
+func (a *AliasOutput) unlockedStateTransitionByAliasIndex(tx *Transaction, refIndex uint16, inputs []Output) (bool, error) {
+ // when output is self governed, a.GetGoverningAddress() returns the state address
+ if a.GetStateAddress().Type() != AliasAddressType {
+ return false, errors.New("AliasOutput: expected state address of AliasAddress type")
+ }
+ if int(refIndex) > len(inputs) {
+ return false, errors.New("AliasOutput: wrong alias reference index")
+ }
+ refInput, ok := inputs[refIndex].(*AliasOutput)
+ if !ok {
+ return false, errors.New("AliasOutput: the referenced output is not of AliasOutput type")
+ }
+ if !refInput.GetAliasAddress().Equals(a.GetStateAddress().(*AliasAddress)) {
+ return false, errors.New("AliasOutput: wrong alias reference address")
+ }
+ // the referenced output must be unlocked for state update
+ return !refInput.hasToBeUnlockedForGovernanceUpdate(tx), nil
+}
+
+// hasToBeUnlockedForGovernanceUpdate finds chained output and checks if it is unlocked governance flags set
+// If there's no chained output it means governance unlock is required to destroy the output
+func (a *AliasOutput) hasToBeUnlockedForGovernanceUpdate(tx *Transaction) bool {
+ chained, err := a.findChainedOutputAndCheckFork(tx)
+ if err != nil {
+ return false
+ }
+ if chained == nil {
+ // the corresponding chained output not found, it means it is being destroyed,
+ // for this we need governance unlock
+ return true
+ }
+ return chained.isGovernanceUpdate
+}
+
+// code contract (make sure the type implements all required methods)
+var _ Output = &AliasOutput{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region ExtendedLockedOutput /////////////////////////////////////////////////////////////////////////////////////////////////
+
+// ExtendedLockedOutput is an Extension of SigLockedColoredOutput. If extended options not enabled,
+// it behaves as SigLockedColoredOutput.
+// In addition it has options:
+// - fallback address and fallback timeout
+// - can be unlocked by AliasUnlockBlock (if address is of AliasAddress type)
+// - can be time locked until deadline
+// - data payload for arbitrary metadata (size limits apply)
+type ExtendedLockedOutput struct {
+ id OutputID
+ idMutex sync.RWMutex
+ balances *ColoredBalances
+ address Address // any address type
+
+ // optional part
+ // Fallback address after timeout. If nil, fallback action not set
+ fallbackAddress Address
+ fallbackDeadline time.Time
+
+ // Deadline since when output can be unlocked
+ timelock time.Time
+
+ // any attached data (subject to size limits)
+ payload []byte
+
+ objectstorage.StorableObjectFlags
+}
+
+const (
+ flagExtendedLockedOutputFallbackPresent = uint(iota)
+ flagExtendedLockedOutputTimeLockPresent
+ flagExtendedLockedOutputPayloadPresent
+)
+
+// NewExtendedLockedOutput is the constructor for a ExtendedLockedOutput.
+func NewExtendedLockedOutput(balances map[Color]uint64, address Address) *ExtendedLockedOutput {
+ return &ExtendedLockedOutput{
+ balances: NewColoredBalances(balances),
+ address: address.Clone(),
+ }
+}
+
+// WithFallbackOptions adds fallback options to the output and returns the updated version.
+func (o *ExtendedLockedOutput) WithFallbackOptions(addr Address, deadline time.Time) *ExtendedLockedOutput {
+ if addr != nil {
+ o.fallbackAddress = addr.Clone()
+ } else {
+ o.fallbackAddress = nil
+ }
+ o.fallbackDeadline = deadline
+ return o
+}
+
+// WithTimeLock adds timelock to the output and returns the updated version.
+func (o *ExtendedLockedOutput) WithTimeLock(timelock time.Time) *ExtendedLockedOutput {
+ o.timelock = timelock
+ return o
+}
+
+// SetPayload sets the payload field of the output.
+func (o *ExtendedLockedOutput) SetPayload(data []byte) error {
+ if len(data) > MaxOutputPayloadSize {
+ return errors.Errorf("ExtendedLockedOutput: data payload size (%d bytes) is bigger than maximum allowed (%d bytes)", len(data), MaxOutputPayloadSize)
+ }
+ o.payload = make([]byte, len(data))
+ copy(o.payload, data)
+ return nil
+}
+
+// ExtendedOutputFromBytes unmarshals a ExtendedLockedOutput from a sequence of bytes.
+func ExtendedOutputFromBytes(data []byte) (output *ExtendedLockedOutput, consumedBytes int, err error) {
+ marshalUtil := marshalutil.New(data)
+ if output, err = ExtendedOutputFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse ExtendedLockedOutput from MarshalUtil: %w", err)
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+// ExtendedOutputFromMarshalUtil unmarshals a ExtendedLockedOutput using a MarshalUtil (for easier unmarshaling).
+func ExtendedOutputFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (output *ExtendedLockedOutput, err error) {
+ outputType, err := marshalUtil.ReadByte()
+ if err != nil {
+ err = errors.Errorf("failed to parse OutputType (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ if OutputType(outputType) != ExtendedLockedOutputType {
+ err = errors.Errorf("invalid OutputType (%X): %w", outputType, cerrors.ErrParseBytesFailed)
+ return
+ }
+
+ output = &ExtendedLockedOutput{}
+ if output.balances, err = ColoredBalancesFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse ColoredBalances: %w", err)
+ return
+ }
+ if output.address, err = AddressFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse Address (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ var flagsByte byte
+ if flagsByte, err = marshalUtil.ReadByte(); err != nil {
+ err = errors.Errorf("failed to parse flags (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ flags := bitmask.BitMask(flagsByte)
+ if flags.HasBit(flagExtendedLockedOutputFallbackPresent) {
+ if output.fallbackAddress, err = AddressFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse fallbackAddress (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ if output.fallbackDeadline, err = marshalUtil.ReadTime(); err != nil {
+ err = errors.Errorf("failed to parse fallbackTimeout (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ }
+ if flags.HasBit(flagExtendedLockedOutputTimeLockPresent) {
+ if output.timelock, err = marshalUtil.ReadTime(); err != nil {
+ err = errors.Errorf("failed to parse timelock (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ }
+ if flags.HasBit(flagExtendedLockedOutputPayloadPresent) {
+ var size uint16
+ size, err = marshalUtil.ReadUint16()
+ if err != nil {
+ err = errors.Errorf("failed to parse payload size (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ output.payload, err = marshalUtil.ReadBytes(int(size))
+ if err != nil {
+ err = errors.Errorf("failed to parse payload (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ }
+ return output, nil
+}
+
+// compressFlags examines the optional fields of the output and returns the combined flags as a byte.
+func (o *ExtendedLockedOutput) compressFlags() bitmask.BitMask {
+ var ret bitmask.BitMask
+ if o.fallbackAddress != nil {
+ ret = ret.SetBit(flagExtendedLockedOutputFallbackPresent)
+ }
+ if !o.timelock.IsZero() {
+ ret = ret.SetBit(flagExtendedLockedOutputTimeLockPresent)
+ }
+ if len(o.payload) > 0 {
+ ret = ret.SetBit(flagExtendedLockedOutputPayloadPresent)
+ }
+ return ret
+}
+
+// ID returns the identifier of the Output that is used to address the Output in the UTXODAG.
+func (o *ExtendedLockedOutput) ID() OutputID {
+ o.idMutex.RLock()
+ defer o.idMutex.RUnlock()
+
+ return o.id
+}
+
+// SetID allows to set the identifier of the Output. We offer a setter for the property since Outputs that are
+// created to become part of a transaction usually do not have an identifier, yet as their identifier depends on
+// the TransactionID that is only determinable after the Transaction has been fully constructed. The ID is therefore
+// only accessed when the Output is supposed to be persisted by the node.
+func (o *ExtendedLockedOutput) SetID(outputID OutputID) Output {
+ o.idMutex.Lock()
+ defer o.idMutex.Unlock()
+
+ o.id = outputID
+
+ return o
+}
+
+// Type returns the type of the Output which allows us to generically handle Outputs of different types.
+func (o *ExtendedLockedOutput) Type() OutputType {
+ return ExtendedLockedOutputType
+}
+
+// Balances returns the funds that are associated with the Output.
+func (o *ExtendedLockedOutput) Balances() *ColoredBalances {
+ return o.balances
+}
+
+// UnlockValid determines if the given Transaction and the corresponding UnlockBlock are allowed to spend the Output.
+func (o *ExtendedLockedOutput) UnlockValid(tx *Transaction, unlockBlock UnlockBlock, inputs []Output) (unlockValid bool, err error) {
+ if o.TimeLockedNow(tx.Essence().Timestamp()) {
+ return false, nil
+ }
+ addr := o.UnlockAddressNow(tx.Essence().Timestamp())
+
+ switch blk := unlockBlock.(type) {
+ case *SignatureUnlockBlock:
+ // unlocking by signature
+ unlockValid = blk.AddressSignatureValid(addr, tx.Essence().Bytes())
+
+ case *AliasUnlockBlock:
+ // unlocking by alias reference. The unlock is valid if:
+ // - referenced alias output has same alias address
+ // - it is not unlocked for governance
+ if addr.Type() != AliasAddressType {
+ return false, errors.Errorf("ExtendedLockedOutput: %s address can't be unlocked by alias reference", addr.Type().String())
+ }
+ refAliasOutput, isAlias := inputs[blk.AliasInputIndex()].(*AliasOutput)
+ if !isAlias {
+ return false, errors.New("ExtendedLockedOutput: referenced input must be AliasOutput")
+ }
+ if !addr.Equals(refAliasOutput.GetAliasAddress()) {
+ return false, errors.New("ExtendedLockedOutput: wrong alias referenced")
+ }
+ unlockValid = !refAliasOutput.hasToBeUnlockedForGovernanceUpdate(tx)
+
+ default:
+ err = errors.Errorf("ExtendedLockedOutput: unsupported unlock block type: %w", cerrors.ErrParseBytesFailed)
+ }
+ return unlockValid, err
+}
+
+// Address returns the Address that the Output is associated to.
+func (o *ExtendedLockedOutput) Address() Address {
+ return o.address
+}
+
+// FallbackAddress returns the fallback address that the Output is associated to.
+func (o *ExtendedLockedOutput) FallbackAddress() (addy Address) {
+ if o.fallbackAddress == nil {
+ return
+ }
+ return o.fallbackAddress
+}
+
+// Input returns an Input that references the Output.
+func (o *ExtendedLockedOutput) Input() Input {
+ if o.ID() == EmptyOutputID {
+ panic("ExtendedLockedOutput: Outputs that haven't been assigned an ID, yet cannot be converted to an Input")
+ }
+
+ return NewUTXOInput(o.ID())
+}
+
+// Clone creates a copy of the Output.
+func (o *ExtendedLockedOutput) Clone() Output {
+ ret := &ExtendedLockedOutput{
+ balances: o.balances.Clone(),
+ address: o.address.Clone(),
+ }
+ copy(ret.id[:], o.id[:])
+ if o.fallbackAddress != nil {
+ ret.fallbackAddress = o.fallbackAddress.Clone()
+ }
+ if !o.fallbackDeadline.IsZero() {
+ ret.fallbackDeadline = o.fallbackDeadline
+ }
+ if !o.timelock.IsZero() {
+ ret.timelock = o.timelock
+ }
+ if o.payload != nil {
+ ret.payload = make([]byte, len(o.payload))
+ copy(ret.payload, o.payload)
+ }
+ return ret
+}
+
+// UpdateMintingColor replaces the ColorMint in the balances of the Output with the hash of the OutputID. It returns a
+// copy of the original Output with the modified balances.
+func (o *ExtendedLockedOutput) UpdateMintingColor() Output {
+ coloredBalances := o.Balances().Map()
+ if mintedCoins, mintedCoinsExist := coloredBalances[ColorMint]; mintedCoinsExist {
+ delete(coloredBalances, ColorMint)
+ coloredBalances[Color(blake2b.Sum256(o.ID().Bytes()))] = mintedCoins
+ }
+ updatedOutput := NewExtendedLockedOutput(coloredBalances, o.Address()).
+ WithFallbackOptions(o.fallbackAddress, o.fallbackDeadline).
+ WithTimeLock(o.timelock)
+ if err := updatedOutput.SetPayload(o.payload); err != nil {
+ panic(errors.Errorf("UpdateMintingColor: %v", err))
+ }
+ updatedOutput.SetID(o.ID())
+
+ return updatedOutput
+}
+
+// Bytes returns a marshaled version of the Output.
+func (o *ExtendedLockedOutput) Bytes() []byte {
+ return o.ObjectStorageValue()
+}
+
+// Update is disabled and panics if it ever gets called - it is required to match the StorableObject interface.
+func (o *ExtendedLockedOutput) Update(objectstorage.StorableObject) {
+ panic("ExtendedLockedOutput: updates disabled")
+}
+
+// ObjectStorageKey returns the key that is used to store the object in the database. It is required to match the
+// StorableObject interface.
+func (o *ExtendedLockedOutput) ObjectStorageKey() []byte {
+ return o.id.Bytes()
+}
+
+// ObjectStorageValue marshals the Output into a sequence of bytes. The ID is not serialized here as it is only used as
+// a key in the ObjectStorage.
+func (o *ExtendedLockedOutput) ObjectStorageValue() []byte {
+ flags := o.compressFlags()
+ ret := marshalutil.New().
+ WriteByte(byte(ExtendedLockedOutputType)).
+ WriteBytes(o.balances.Bytes()).
+ WriteBytes(o.address.Bytes()).
+ WriteByte(byte(flags))
+ if flags.HasBit(flagExtendedLockedOutputFallbackPresent) {
+ ret.WriteBytes(o.fallbackAddress.Bytes()).
+ WriteTime(o.fallbackDeadline)
+ }
+ if flags.HasBit(flagExtendedLockedOutputTimeLockPresent) {
+ ret.WriteTime(o.timelock)
+ }
+ if flags.HasBit(flagExtendedLockedOutputPayloadPresent) {
+ ret.WriteUint16(uint16(len(o.payload))).
+ WriteBytes(o.payload)
+ }
+ return ret.Bytes()
+}
+
+// Compare offers a comparator for Outputs which returns -1 if the other Output is bigger, 1 if it is smaller and 0 if
+// they are the same.
+func (o *ExtendedLockedOutput) Compare(other Output) int {
+ return bytes.Compare(o.Bytes(), other.Bytes())
+}
+
+// String returns a human readable version of the Output.
+func (o *ExtendedLockedOutput) String() string {
+ return stringify.Struct("ExtendedLockedOutput",
+ stringify.StructField("id", o.ID()),
+ stringify.StructField("address", o.address),
+ stringify.StructField("balances", o.balances),
+ stringify.StructField("fallbackAddress", o.fallbackAddress),
+ stringify.StructField("fallbackDeadline", o.fallbackDeadline),
+ stringify.StructField("timelock", o.timelock),
+ )
+}
+
+// GetPayload return a data payload associated with the output
+func (o *ExtendedLockedOutput) GetPayload() []byte {
+ return o.payload
+}
+
+// TimeLock is a time after which output can be unlocked
+func (o *ExtendedLockedOutput) TimeLock() time.Time {
+ return o.timelock
+}
+
+// TimeLockedNow checks if output is unlocked for the specific moment
+func (o *ExtendedLockedOutput) TimeLockedNow(nowis time.Time) bool {
+ return o.TimeLock().After(nowis)
+}
+
+// FallbackOptions returns fallback options of the output. The address is nil if fallback options are not set
+func (o *ExtendedLockedOutput) FallbackOptions() (Address, time.Time) {
+ return o.fallbackAddress, o.fallbackDeadline
+}
+
+// UnlockAddressNow return unlock address which is valid for the specific moment of time
+func (o *ExtendedLockedOutput) UnlockAddressNow(nowis time.Time) Address {
+ if o.fallbackAddress == nil {
+ return o.address
+ }
+ if nowis.After(o.fallbackDeadline) {
+ return o.fallbackAddress
+ }
+ return o.address
+}
+
+// code contract (make sure the type implements all required methods)
+var _ Output = &ExtendedLockedOutput{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
// region CachedOutput /////////////////////////////////////////////////////////////////////////////////////////////////
// CachedOutput is a wrapper for the generic CachedObject returned by the object storage that overrides the accessor
diff --git a/packages/ledgerstate/output_test.go b/packages/ledgerstate/output_test.go
new file mode 100644
index 0000000000..d7d6e2e03b
--- /dev/null
+++ b/packages/ledgerstate/output_test.go
@@ -0,0 +1,2415 @@
+package ledgerstate
+
+import (
+ "bytes"
+ "encoding/binary"
+ "math/rand"
+ "sync"
+ "testing"
+ "time"
+
+ "github.com/iotaledger/hive.go/byteutils"
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "github.com/iotaledger/hive.go/identity"
+ "github.com/iotaledger/hive.go/marshalutil"
+ "github.com/iotaledger/hive.go/objectstorage"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "golang.org/x/crypto/blake2b"
+)
+
+// region AliasOutput Tests
+
+func TestAliasOutput_NewAliasOutputMint(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ stateAddy := randEd25119Address()
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, stateAddy)
+ assert.NoError(t, err)
+ iotaBal, ok := alias.Balances().Get(ColorIOTA)
+ assert.True(t, ok)
+ assert.Equal(t, DustThresholdAliasOutputIOTA, iotaBal)
+ assert.True(t, alias.GetStateAddress().Equals(stateAddy))
+ assert.Nil(t, alias.GetImmutableData())
+ })
+
+ t.Run("CASE: Happy path with immutable data", func(t *testing.T) {
+ stateAddy := randEd25119Address()
+ data := []byte("dummy")
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, stateAddy, data)
+ assert.NoError(t, err)
+ iotaBal, ok := alias.Balances().Get(ColorIOTA)
+ assert.True(t, ok)
+ assert.Equal(t, DustThresholdAliasOutputIOTA, iotaBal)
+ assert.True(t, alias.GetStateAddress().Equals(stateAddy))
+ assert.True(t, bytes.Equal(alias.GetImmutableData(), data))
+ })
+
+ t.Run("CASE: Below dust threshold", func(t *testing.T) {
+ stateAddy := randEd25119Address()
+ data := []byte("dummy")
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA - 1}, stateAddy, data)
+ assert.Error(t, err)
+ assert.Nil(t, alias)
+ })
+
+ t.Run("CASE: State address is an alias", func(t *testing.T) {
+ stateAddy := randAliasAddress()
+ data := []byte("dummy")
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, stateAddy, data)
+ assert.NoError(t, err)
+ assert.NotNil(t, alias)
+ })
+
+ t.Run("CASE: Non existent state address", func(t *testing.T) {
+ data := []byte("dummy")
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, nil, data)
+ assert.Error(t, err)
+ assert.Nil(t, alias)
+ })
+
+ t.Run("CASE: Too big state data", func(t *testing.T) {
+ stateAddy := randAliasAddress()
+ data := make([]byte, MaxOutputPayloadSize+1)
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, stateAddy, data)
+ assert.Error(t, err)
+ assert.Nil(t, alias)
+ })
+}
+
+func TestAliasOutput_NewAliasOutputNext(t *testing.T) {
+ originAlias := dummyAliasOutput()
+
+ t.Run("CASE: Happy path, no governance update", func(t *testing.T) {
+ nextAlias := originAlias.NewAliasOutputNext()
+ assert.True(t, originAlias.GetAliasAddress().Equals(nextAlias.GetAliasAddress()))
+ assert.True(t, originAlias.GetStateAddress().Equals(nextAlias.GetStateAddress()))
+ assert.True(t, originAlias.GetGoverningAddress().Equals(nextAlias.GetGoverningAddress()))
+ // outputid is actually irrelevant here
+ assert.True(t, bytes.Equal(nextAlias.ID().Bytes(), originAlias.ID().Bytes()))
+ assert.Equal(t, originAlias.Balances().Bytes(), nextAlias.Balances().Bytes())
+ assert.Equal(t, originAlias.GetStateIndex()+1, nextAlias.GetStateIndex())
+ assert.Equal(t, originAlias.GetStateData(), nextAlias.GetStateData())
+ assert.Equal(t, originAlias.GetGovernanceMetadata(), nextAlias.GetGovernanceMetadata())
+ assert.Equal(t, originAlias.GetImmutableData(), nextAlias.GetImmutableData())
+ assert.Equal(t, originAlias.GetIsGovernanceUpdated(), nextAlias.GetIsGovernanceUpdated())
+ })
+
+ t.Run("CASE: Happy path, governance update", func(t *testing.T) {
+ nextAlias := originAlias.NewAliasOutputNext(true)
+ assert.True(t, originAlias.GetAliasAddress().Equals(nextAlias.GetAliasAddress()))
+ assert.True(t, originAlias.GetStateAddress().Equals(nextAlias.GetStateAddress()))
+ assert.True(t, originAlias.GetGoverningAddress().Equals(nextAlias.GetGoverningAddress()))
+ // outputid is actually irrelevant here
+ assert.True(t, bytes.Equal(nextAlias.ID().Bytes(), originAlias.ID().Bytes()))
+ assert.Equal(t, originAlias.Balances().Bytes(), nextAlias.Balances().Bytes())
+ assert.Equal(t, originAlias.GetStateIndex(), nextAlias.GetStateIndex())
+ assert.Equal(t, originAlias.GetStateData(), nextAlias.GetStateData())
+ assert.Equal(t, originAlias.GetGovernanceMetadata(), nextAlias.GetGovernanceMetadata())
+ assert.Equal(t, originAlias.GetImmutableData(), nextAlias.GetImmutableData())
+ assert.NotEqual(t, originAlias.GetIsGovernanceUpdated(), nextAlias.GetIsGovernanceUpdated())
+ })
+
+ t.Run("CASE: Previous was governance update, next is not", func(t *testing.T) {
+ originAlias = dummyAliasOutput()
+ // previous output was a governance update
+ originAlias.SetIsGovernanceUpdated(true)
+ nextAlias := originAlias.NewAliasOutputNext()
+ // created output should not be a governance update
+ assert.False(t, nextAlias.GetIsGovernanceUpdated())
+ assert.True(t, originAlias.GetAliasAddress().Equals(nextAlias.GetAliasAddress()))
+ assert.True(t, originAlias.GetStateAddress().Equals(nextAlias.GetStateAddress()))
+ assert.True(t, originAlias.GetGoverningAddress().Equals(nextAlias.GetGoverningAddress()))
+ // outputid is actually irrelevant here
+ assert.True(t, bytes.Equal(nextAlias.ID().Bytes(), originAlias.ID().Bytes()))
+ assert.Equal(t, originAlias.Balances().Bytes(), nextAlias.Balances().Bytes())
+ assert.Equal(t, originAlias.GetStateIndex()+1, nextAlias.GetStateIndex())
+ assert.Equal(t, originAlias.GetStateData(), nextAlias.GetStateData())
+ assert.Equal(t, originAlias.GetGovernanceMetadata(), nextAlias.GetGovernanceMetadata())
+ assert.Equal(t, originAlias.GetImmutableData(), nextAlias.GetImmutableData())
+ })
+
+ t.Run("CASE: Previous was governance update, next as well", func(t *testing.T) {
+ originAlias = dummyAliasOutput()
+ // previous output was a governance update
+ originAlias.SetIsGovernanceUpdated(true)
+ nextAlias := originAlias.NewAliasOutputNext(true)
+ // created output should be a governance update
+ assert.True(t, nextAlias.GetIsGovernanceUpdated())
+ assert.True(t, originAlias.GetAliasAddress().Equals(nextAlias.GetAliasAddress()))
+ assert.True(t, originAlias.GetStateAddress().Equals(nextAlias.GetStateAddress()))
+ assert.True(t, originAlias.GetGoverningAddress().Equals(nextAlias.GetGoverningAddress()))
+ // outputid is actually irrelevant here
+ assert.True(t, bytes.Equal(nextAlias.ID().Bytes(), originAlias.ID().Bytes()))
+ assert.Equal(t, originAlias.Balances().Bytes(), nextAlias.Balances().Bytes())
+ assert.Equal(t, originAlias.GetStateIndex(), nextAlias.GetStateIndex())
+ assert.Equal(t, originAlias.GetStateData(), nextAlias.GetStateData())
+ assert.Equal(t, originAlias.GetGovernanceMetadata(), nextAlias.GetGovernanceMetadata())
+ assert.Equal(t, originAlias.GetImmutableData(), nextAlias.GetImmutableData())
+ })
+}
+
+func TestAliasOutputFromMarshalUtil(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ originAlias := dummyAliasOutput().WithDelegationAndTimelock(time.Now())
+ bytesLength := len(originAlias.Bytes())
+ marshaledAlias, consumed, err := OutputFromBytes(originAlias.Bytes())
+ assert.NoError(t, err)
+ assert.Equal(t, bytesLength, consumed)
+ assert.Equal(t, marshaledAlias.Bytes(), originAlias.Bytes())
+ })
+
+ t.Run("CASE: Wrong type", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originBytes := originAlias.Bytes()
+ // manually change output type byte
+ originBytes[0] = 1
+ marshalUtil := marshalutil.New(originBytes)
+ _, err := AliasOutputFromMarshalUtil(marshalUtil)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Wrong flag for state data", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.ClearBit(flagAliasOutputStateDataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Wrong flag for governance metadata", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.ClearBit(flagAliasOutputGovernanceMetadataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Wrong flag for immutable data", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.ClearBit(flagAliasOutputImmutableDataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Wrong flag for governance address", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.ClearBit(flagAliasOutputGovernanceSet)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, consumedBytes, err := OutputFromBytes(originBytes)
+ assert.NoError(t, err)
+ assert.NotEqual(t, len(originBytes), consumedBytes)
+ })
+
+ t.Run("CASE: Flags provided, state data missing", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ // remove the data
+ _ = originAlias.SetStateData(nil)
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.SetBit(flagAliasOutputStateDataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Flags provided, governance metadata missing", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ // remove the data
+ _ = originAlias.SetGovernanceMetadata(nil)
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.SetBit(flagAliasOutputGovernanceMetadataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Flags provided, immutable data missing", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ // remove the data
+ err := originAlias.SetImmutableData(nil)
+ assert.NoError(t, err)
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.SetBit(flagAliasOutputImmutableDataPresent)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err = OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Flags provided, governing address missing", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ // remove the data
+ originAlias.SetGoverningAddress(originAlias.stateAddress)
+ originBytes := originAlias.Bytes()
+ flags := originAlias.mustFlags()
+ flags = flags.SetBit(flagAliasOutputGovernanceSet)
+ // manually change flags
+ originBytes[1] = byte(flags)
+ _, _, err := OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Invalid balances", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ // remove the data
+ invalidBalancesBytes := NewColoredBalances(map[Color]uint64{ColorIOTA: 99}).Bytes()
+ originBytes := originAlias.Bytes()
+ // serialized balances start at : output type (1 byte) + flags (1 byte) + AliasAddressLength bytes
+ copy(originBytes[1+1+AddressLength:], invalidBalancesBytes)
+ _, _, err := OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Invalid state index for chain starting output", func(t *testing.T) {
+ originAlias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address())
+ assert.NoError(t, err)
+ originBytes := originAlias.Bytes()
+ stateIndexStartIndex := 1 + 1 + AddressLength + len(originAlias.balances.Bytes()) + AddressLength
+ binary.LittleEndian.PutUint32(originBytes[stateIndexStartIndex:], 5)
+ _, _, err = OutputFromBytes(originBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Too much state data", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originAlias.governanceMetadata = nil
+ originAlias.immutableData = nil
+ originAlias.governingAddress = nil
+ originAlias.stateData = []byte{1}
+ originBytes := originAlias.Bytes()
+ stateDataSizeIndex := 1 + 1 + AddressLength + len(originAlias.balances.Bytes()) + AddressLength + 4
+ binary.LittleEndian.PutUint16(originBytes[stateDataSizeIndex:], MaxOutputPayloadSize+1)
+ fakeStateData := make([]byte, MaxOutputPayloadSize)
+ // original one byte state data is left untouched
+ modBytes := byteutils.ConcatBytes(originBytes, fakeStateData)
+ _, _, err := OutputFromBytes(modBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Too much governance metadata", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originAlias.governanceMetadata = []byte{1}
+ originAlias.immutableData = nil
+ originAlias.governingAddress = nil
+ originAlias.stateData = nil
+ originBytes := originAlias.Bytes()
+ governanceMetadataSizeIndex := 1 + 1 + AddressLength + len(originAlias.balances.Bytes()) + AddressLength + 4
+ binary.LittleEndian.PutUint16(originBytes[governanceMetadataSizeIndex:], MaxOutputPayloadSize+1)
+ fakeGovernanceMetadata := make([]byte, MaxOutputPayloadSize)
+ // original one byte governance metadata is left untouched
+ modBytes := byteutils.ConcatBytes(originBytes, fakeGovernanceMetadata)
+ _, _, err := OutputFromBytes(modBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Too much immutable data", func(t *testing.T) {
+ originAlias := dummyAliasOutput()
+ originAlias.governanceMetadata = nil
+ originAlias.immutableData = []byte{1}
+ originAlias.governingAddress = nil
+ originAlias.stateData = nil
+ originBytes := originAlias.Bytes()
+ immutableDataSizeIndex := 1 + 1 + AddressLength + len(originAlias.balances.Bytes()) + AddressLength + 4
+ binary.LittleEndian.PutUint16(originBytes[immutableDataSizeIndex:], MaxOutputPayloadSize+1)
+ fakeImmutableData := make([]byte, MaxOutputPayloadSize)
+ // original one byte state data is left untouched
+ modBytes := byteutils.ConcatBytes(originBytes, fakeImmutableData)
+ _, _, err := OutputFromBytes(modBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_SetBalances(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ err := alias.SetBalances(map[Color]uint64{ColorIOTA: 1337})
+ assert.NoError(t, err)
+ cBalBytes := alias.Balances().Bytes()
+ assert.Equal(t, NewColoredBalances(map[Color]uint64{ColorIOTA: 1337}).Bytes(), cBalBytes)
+ })
+
+ t.Run("CASE: Below threshold", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ err := alias.SetBalances(map[Color]uint64{ColorIOTA: 99})
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_SetAliasAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ newAliAddy := randAliasAddress()
+ alias.SetAliasAddress(newAliAddy)
+ assert.True(t, alias.aliasAddress.Equals(newAliAddy))
+ })
+}
+
+func TestAliasOutput_Balances(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.Equal(t, NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}).Bytes(), alias.Balances().Bytes())
+ })
+}
+
+func TestAliasOutput_Bytes(t *testing.T) {
+ t.Run("Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ aBytes := alias.Bytes()
+ mUtil := marshalutil.New(aBytes)
+ restoredAlias, err := AliasOutputFromMarshalUtil(mUtil)
+ assert.NoError(t, err)
+ assert.True(t, alias.GetAliasAddress().Equals(restoredAlias.GetAliasAddress()))
+ assert.True(t, alias.GetStateAddress().Equals(restoredAlias.GetStateAddress()))
+ assert.True(t, alias.GetGoverningAddress().Equals(restoredAlias.GetGoverningAddress()))
+ assert.Equal(t, alias.Balances().Bytes(), restoredAlias.Balances().Bytes())
+ assert.Equal(t, alias.GetStateIndex(), restoredAlias.GetStateIndex())
+ assert.Equal(t, alias.GetStateData(), restoredAlias.GetStateData())
+ assert.Equal(t, alias.GetGovernanceMetadata(), restoredAlias.GetGovernanceMetadata())
+ assert.Equal(t, alias.GetImmutableData(), restoredAlias.GetImmutableData())
+ assert.Equal(t, alias.GetIsGovernanceUpdated(), restoredAlias.GetIsGovernanceUpdated())
+ })
+}
+
+func TestAliasOutput_Compare(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ aBytes := alias.Bytes()
+ mUtil := marshalutil.New(aBytes)
+ restoredAlias, err := AliasOutputFromMarshalUtil(mUtil)
+ assert.NoError(t, err)
+ assert.True(t, alias.Compare(restoredAlias) == 0)
+ })
+}
+
+func TestAliasOutput_GetGoverningAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ governingAddy := alias.GetGoverningAddress()
+ assert.True(t, governingAddy.Equals(alias.governingAddress))
+ })
+
+ t.Run("CASE: Self governed", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.governingAddress = nil
+ governingAddy := alias.GetGoverningAddress()
+ assert.True(t, governingAddy.Equals(alias.stateAddress))
+ })
+}
+
+func TestAliasOutput_GetGovernanceMetadata(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := alias.GetGovernanceMetadata()
+ assert.Equal(t, data, alias.governanceMetadata)
+ })
+
+ t.Run("CASE: No data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.governanceMetadata = nil
+ data := alias.GetGovernanceMetadata()
+ assert.Equal(t, data, alias.governanceMetadata)
+ })
+}
+
+func TestAliasOutput_GetImmutableData(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := alias.GetImmutableData()
+ assert.Equal(t, data, alias.immutableData)
+ })
+
+ t.Run("CASE: No data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.immutableData = nil
+ data := alias.GetImmutableData()
+ assert.Equal(t, data, alias.immutableData)
+ })
+}
+
+func TestAliasOutput_GetIsGovernanceUpdated(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ isGovUpdate := alias.GetIsGovernanceUpdated()
+ assert.Equal(t, isGovUpdate, alias.isGovernanceUpdate)
+ })
+
+ t.Run("CASE: Happy path, false", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.isGovernanceUpdate = false
+ isGovUpdate := alias.GetIsGovernanceUpdated()
+ assert.Equal(t, isGovUpdate, alias.isGovernanceUpdate)
+ })
+}
+
+func TestAliasOutput_IsDelegated(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ isDelegated := alias.IsDelegated()
+ assert.Equal(t, isDelegated, alias.isDelegated)
+ })
+
+ t.Run("CASE: Happy path, true", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.isDelegated = true
+ isDelegated := alias.IsDelegated()
+ assert.Equal(t, isDelegated, alias.isDelegated)
+ })
+}
+
+func TestAliasOutput_GetStateAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ stateAddy := alias.GetStateAddress()
+ assert.True(t, stateAddy.Equals(alias.stateAddress))
+ })
+}
+
+func TestAliasOutput_GetStateData(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := alias.GetStateData()
+ assert.Equal(t, data, alias.stateData)
+ })
+
+ t.Run("CASE: No data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.stateData = nil
+ data := alias.GetStateData()
+ assert.Equal(t, data, alias.stateData)
+ })
+}
+
+func TestAliasOutput_GetStateIndex(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.stateIndex = 5
+ sIndex := alias.GetStateIndex()
+ assert.Equal(t, sIndex, alias.stateIndex)
+ })
+}
+
+func TestAliasOutput_ID(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ id := alias.ID()
+ assert.Equal(t, id, alias.outputID)
+ })
+}
+
+func TestAliasOutput_Input(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ input := alias.Input()
+ assert.Equal(t, input.Base58(), NewUTXOInput(alias.outputID).Base58())
+ })
+
+ t.Run("CASE: No output id yet", func(t *testing.T) {
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address())
+ assert.NoError(t, err)
+ assert.Panics(t, func() {
+ _ = alias.Input()
+ })
+ })
+}
+
+func TestAliasOutput_IsOrigin(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.False(t, alias.IsOrigin())
+ })
+
+ t.Run("CASE: Is origin", func(t *testing.T) {
+ alias, err := NewAliasOutputMint(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address())
+ assert.NoError(t, err)
+ assert.True(t, alias.IsOrigin())
+ })
+
+ t.Run("CASE: Check IsOrigin after booking", func(t *testing.T) {
+ tokens := map[Color]uint64{ColorIOTA: 200}
+ pub, _, err := ed25519.GenerateKey()
+ require.NoError(t, err)
+ addr := NewED25519Address(pub)
+ out, err := NewAliasOutputMint(tokens, addr)
+ require.NoError(t, err)
+ require.True(t, out.IsOrigin())
+ // imitate booking
+ out.SetID(OutputID{})
+ outUpd := out.UpdateMintingColor().(*AliasOutput)
+ require.True(t, outUpd.IsOrigin())
+ })
+}
+
+func TestAliasOutput_IsSelfGoverned(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.False(t, alias.IsSelfGoverned())
+ })
+
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.governingAddress = nil
+ assert.True(t, alias.IsSelfGoverned())
+ })
+}
+
+func TestAliasOutput_ObjectStorageKey(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.Equal(t, alias.outputID.Bytes(), alias.ObjectStorageKey())
+ })
+}
+
+func TestAliasOutput_ObjectStorageValue(t *testing.T) {
+ // same as Bytes()
+}
+
+func TestAliasOutput_DelegationTimelock(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ // not a delegated aliasoutput,
+ assert.True(t, alias.DelegationTimelock().IsZero())
+ // is a delegated output, but no timelock set
+ alias.isDelegated = true
+ assert.True(t, alias.DelegationTimelock().IsZero())
+ // delegated output, timelock set
+ timelock := time.Now()
+ alias.delegationTimelock = timelock
+ assert.True(t, timelock.Equal(alias.DelegationTimelock()))
+ })
+}
+
+func TestAliasOutput_DelegationTimeLockedNow(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ timelock := time.Now()
+ alias := dummyAliasOutput()
+ alias.isDelegated = true
+ err := alias.SetDelegationTimelock(timelock)
+ assert.NoError(t, err)
+
+ assert.True(t, alias.DelegationTimeLockedNow(timelock.Add(-time.Second)))
+ assert.False(t, alias.DelegationTimeLockedNow(timelock.Add(time.Second)))
+ })
+
+ t.Run("CASE: Delegation without timelock", func(t *testing.T) {
+ timelock := time.Now()
+ alias := dummyAliasOutput()
+ alias.isDelegated = true
+
+ assert.False(t, alias.DelegationTimeLockedNow(timelock.Add(-time.Second)))
+ assert.False(t, alias.DelegationTimeLockedNow(timelock.Add(time.Second)))
+ })
+}
+
+func TestAliasOutput_SetDelegationTimelock(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ timelock := time.Now()
+ alias := dummyAliasOutput()
+ // not delegated,
+ err := alias.SetDelegationTimelock(timelock)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.True(t, alias.DelegationTimelock().IsZero())
+ // delegated
+ alias.isDelegated = true
+ err = alias.SetDelegationTimelock(timelock)
+ assert.NoError(t, err)
+ assert.True(t, alias.DelegationTimelock().Equal(timelock))
+ })
+}
+
+func TestAliasOutput_SetGoverningAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ newAddy := randAliasAddress()
+ alias.SetGoverningAddress(newAddy)
+ assert.True(t, alias.GetGoverningAddress().Equals(newAddy))
+ })
+}
+
+func TestAliasOutput_SetID(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ newID := randOutputID()
+ alias.SetID(newID)
+ assert.Equal(t, alias.ID().Bytes(), newID.Bytes())
+ })
+}
+
+func TestAliasOutput_SetImmutableData(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := []byte("new dummy nft data")
+ err := alias.SetImmutableData(data)
+ assert.NoError(t, err)
+ assert.Equal(t, alias.GetImmutableData(), data)
+ })
+
+ t.Run("CASE: Too much data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := make([]byte, MaxOutputPayloadSize+1)
+ err := alias.SetImmutableData(data)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_SetGovernanceMetadata(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := []byte("new dummy gov metadata")
+ err := alias.SetGovernanceMetadata(data)
+ assert.NoError(t, err)
+ assert.Equal(t, alias.GetGovernanceMetadata(), data)
+ })
+
+ t.Run("CASE: Too much data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := make([]byte, MaxOutputPayloadSize+1)
+ err := alias.SetGovernanceMetadata(data)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_SetIsGovernanceUpdated(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.SetIsGovernanceUpdated(true)
+ assert.Equal(t, alias.GetIsGovernanceUpdated(), true)
+ })
+}
+
+func TestAliasOutput_SetIsOrigin(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.Equal(t, false, alias.isOrigin)
+ alias.SetIsOrigin(true)
+ assert.Equal(t, true, alias.isOrigin)
+ })
+}
+
+func TestAliasOutput_SetIsDelegated(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ isDelegated := true
+ alias.SetIsDelegated(isDelegated)
+ assert.Equal(t, alias.isDelegated, isDelegated)
+ })
+}
+
+func TestAliasOutput_SetStateAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ newAliasAddy := randAliasAddress()
+ newAddy := randEd25119Address()
+ err := alias.SetStateAddress(newAliasAddy)
+ assert.NoError(t, err)
+ err = alias.SetStateAddress(newAddy)
+ assert.NoError(t, err)
+ assert.True(t, alias.GetStateAddress().Equals(newAddy))
+ })
+}
+
+func TestAliasOutput_SetStateData(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := []byte("new dummy nft data")
+ err := alias.SetStateData(data)
+ assert.NoError(t, err)
+ assert.Equal(t, alias.GetStateData(), data)
+ })
+
+ t.Run("CASE: Too much data", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ data := make([]byte, MaxOutputPayloadSize+1)
+ err := alias.SetStateData(data)
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_SetStateIndex(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.SetStateIndex(5)
+ assert.Equal(t, alias.GetStateIndex(), uint32(5))
+ })
+}
+
+func TestAliasOutput_Type(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ assert.Equal(t, alias.Type(), AliasOutputType)
+ })
+}
+
+func TestAliasOutput_Update(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ other := dummyAliasOutput()
+ assert.Panics(t, func() {
+ alias.Update(other)
+ })
+ })
+}
+
+func TestAliasOutput_UpdateMintingColor(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.balances = NewColoredBalances(map[Color]uint64{
+ ColorIOTA: DustThresholdAliasOutputIOTA,
+ ColorMint: 500,
+ })
+ updated := alias.UpdateMintingColor()
+ balance, ok := updated.Balances().Get(blake2b.Sum256(alias.ID().Bytes()))
+ assert.True(t, ok)
+ assert.Equal(t, uint64(500), balance)
+ assert.True(t, updated.Address().Equals(alias.GetAliasAddress()))
+ })
+
+ t.Run("CASE: No mint", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.balances = NewColoredBalances(map[Color]uint64{
+ ColorIOTA: DustThresholdAliasOutputIOTA,
+ })
+ updated := alias.UpdateMintingColor()
+ balance, ok := updated.Balances().Get(blake2b.Sum256(alias.ID().Bytes()))
+ assert.False(t, ok)
+ assert.Equal(t, uint64(0), balance)
+ balance, ok = updated.Balances().Get(ColorIOTA)
+ assert.True(t, ok)
+ assert.Equal(t, DustThresholdAliasOutputIOTA, balance)
+ assert.True(t, updated.Address().Equals(alias.GetAliasAddress()))
+ })
+
+ t.Run("CASE: Alias address is updated", func(t *testing.T) {
+ alias := dummyAliasOutput(true)
+ alias.aliasAddress = AliasAddress{}
+ alias.balances = NewColoredBalances(map[Color]uint64{
+ ColorIOTA: DustThresholdAliasOutputIOTA,
+ ColorMint: 500,
+ })
+ updated := alias.UpdateMintingColor()
+ balance, ok := updated.Balances().Get(blake2b.Sum256(alias.ID().Bytes()))
+ assert.True(t, ok)
+ assert.Equal(t, uint64(500), balance)
+ assert.True(t, updated.Address().Equals(NewAliasAddress(alias.ID().Bytes())))
+ })
+}
+
+func TestAliasOutput_checkBasicValidity(t *testing.T) {
+ t.Run("CASE: state address nil", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.stateAddress = nil
+ err := alias.checkBasicValidity()
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: state address same as alias address", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.stateAddress = alias.GetAliasAddress()
+ err := alias.checkBasicValidity()
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: governing address same as alias address", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.governingAddress = alias.GetAliasAddress()
+ err := alias.checkBasicValidity()
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: delegation timelock for non delegated output", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.isDelegated = false
+ alias.delegationTimelock = time.Now()
+ err := alias.checkBasicValidity()
+ t.Log(err)
+ assert.Error(t, err)
+ })
+}
+
+func TestAliasOutput_mustValidate(t *testing.T) {
+ t.Run("CASE: did not validate", func(t *testing.T) {
+ alias := dummyAliasOutput()
+ alias.stateAddress = nil
+ assert.Panics(t, func() {
+ alias.mustValidate()
+ })
+ })
+}
+
+func TestAliasOutput_validateTransition(t *testing.T) {
+ t.Run("CASE: Happy path, state transition", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Happy path, governance transition", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Modified alias address", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.aliasAddress = *randAliasAddress()
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Modified immutable data", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.immutableData = []byte("something new")
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified state data", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.stateData = []byte("something new")
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified state index", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.stateIndex = prev.stateIndex + 1
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified balance", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ newBalance := prev.Balances().Map()
+ newBalance[ColorIOTA]++
+ next.balances = NewColoredBalances(newBalance)
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified state address", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.stateAddress = randEd25119Address()
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified governance address", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.governingAddress = randAliasAddress()
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified governance metadata", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.governanceMetadata = []byte("chain is run by another VM")
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Gov update, modified delegation status", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(true)
+ next.isDelegated = true
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Gov update, delegation without delegation lock", func(t *testing.T) {
+ prev := dummyAliasOutput().WithDelegation()
+ next := prev.NewAliasOutputNext(true)
+ assert.Equal(t, true, next.IsDelegated())
+ err := prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: time.Now()}})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Gov update, delegation with delegation lock", func(t *testing.T) {
+ timelock := time.Now()
+ prev := dummyAliasOutput().WithDelegationAndTimelock(timelock)
+ next := prev.NewAliasOutputNext(true)
+ assert.Equal(t, true, next.IsDelegated())
+ // happy case, timelock expired
+ err := prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: timelock.Add(time.Second)}})
+ assert.NoError(t, err)
+ // not happy case, timelock is still active
+ err = prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: timelock.Add(-time.Second)}})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, delegation without timelock", func(t *testing.T) {
+ prev := dummyAliasOutput().WithDelegation()
+ next := prev.NewAliasOutputNext(false)
+ err := prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: time.Now()}})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: State update, delegation with timelock", func(t *testing.T) {
+ timelock := time.Now()
+ prev := dummyAliasOutput().WithDelegationAndTimelock(timelock)
+ next := prev.NewAliasOutputNext(false)
+ // timelock is active state transition allowed
+ err := prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: timelock.Add(-time.Second)}})
+ assert.NoError(t, err)
+ // timelock expired, state transition should fail
+ err = prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: timelock.Add(time.Second)}})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, delegated, delegation timelock changed", func(t *testing.T) {
+ prev := dummyAliasOutput().WithDelegation()
+ next := prev.NewAliasOutputNext(false)
+ next.delegationTimelock = time.Now()
+ err := prev.validateTransition(next, &Transaction{essence: &TransactionEssence{timestamp: time.Now()}})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, modified delegation status", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.isDelegated = true
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update of delegated output, modified balance status", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ prev.isDelegated = true
+ next := prev.NewAliasOutputNext(false)
+ bal := next.balances.Map()
+ bal[ColorIOTA]++
+ next.balances = NewColoredBalances(bal)
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, wrong state index", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.stateIndex = prev.GetStateIndex() + 2
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, modify state address", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.stateAddress = randEd25119Address()
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, modify governance address", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.governingAddress = randAliasAddress()
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, modify governance metadata", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.governanceMetadata = []byte("chain is run by another VM")
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, was self governed", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ prev.governingAddress = nil
+ next := prev.NewAliasOutputNext(false)
+ next.governingAddress = randAliasAddress()
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, was not self governed", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.governingAddress = nil
+ err := prev.validateTransition(next, &Transaction{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: State update, modify state data", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ next.stateData = []byte("new state data")
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: State update, modify balances", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := prev.NewAliasOutputNext(false)
+ newBalance := prev.Balances().Map()
+ newBalance[ColorIOTA]++
+ next.balances = NewColoredBalances(newBalance)
+ err := prev.validateTransition(next, &Transaction{})
+ assert.NoError(t, err)
+ })
+}
+
+func TestAliasOutput_validateDestroyTransition(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ err := prev.validateDestroyTransitionNow(time.Time{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: More balance than minimum", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ newBalance := prev.Balances().Map()
+ newBalance[ColorIOTA]++
+ prev.balances = NewColoredBalances(newBalance)
+ err := prev.validateDestroyTransitionNow(time.Time{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Delegated output, more balance than minimum", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ newBalance := prev.Balances().Map()
+ newBalance[ColorIOTA]++
+ prev.balances = NewColoredBalances(newBalance)
+ prev.isDelegated = true
+ err := prev.validateDestroyTransitionNow(time.Time{})
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: More color balance than minimum", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ newBalance := prev.Balances().Map()
+ newBalance[Color{8}] = 1
+ prev.balances = NewColoredBalances(newBalance)
+ err := prev.validateDestroyTransitionNow(time.Time{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Only color balance", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ prev.balances = NewColoredBalances(map[Color]uint64{{8}: DustThresholdAliasOutputIOTA})
+ err := prev.validateDestroyTransitionNow(time.Time{})
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Can destroy delegation if not-timelocked", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ prev.SetIsDelegated(true)
+ err := prev.validateDestroyTransitionNow(time.Now())
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Can't destroy timelocked delegation", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ deadline := time.Now()
+ nowis := deadline.Add(-1 * time.Nanosecond)
+ prev.SetIsDelegated(true)
+ err := prev.SetDelegationTimelock(deadline)
+ assert.NoError(t, err)
+ assert.True(t, prev.DelegationTimeLockedNow(nowis))
+ err = prev.validateDestroyTransitionNow(nowis)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Can destroy timeUNlocked delegation", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ deadline := time.Now()
+ nowis := deadline.Add(1 * time.Nanosecond)
+ prev.SetIsDelegated(true)
+ err := prev.SetDelegationTimelock(deadline)
+ assert.NoError(t, err)
+ assert.False(t, prev.DelegationTimeLockedNow(nowis))
+ err = prev.validateDestroyTransitionNow(nowis)
+ assert.NoError(t, err)
+ })
+}
+
+func TestAliasOutput_findChainedOutputAndCheckFork(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained := prev.NewAliasOutputNext(false)
+ outputs := Outputs{chained}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ found, err := prev.findChainedOutputAndCheckFork(tx)
+ assert.NoError(t, err)
+ assert.Equal(t, chained.Bytes(), found.Bytes())
+ })
+
+ t.Run("CASE: No alias output", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ outputs := Outputs{NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ // not found means that returned output is nil, no error
+ found, _ := prev.findChainedOutputAndCheckFork(tx)
+ assert.Nil(t, found)
+ })
+
+ t.Run("CASE: Duplicated alias output", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained1 := prev.NewAliasOutputNext(false)
+ chained2 := prev.NewAliasOutputNext(true)
+ outputs := Outputs{chained1, chained2}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ found, err := prev.findChainedOutputAndCheckFork(tx)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.Nil(t, found)
+ })
+
+ t.Run("CASE: More than one alias in outputs", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained := prev.NewAliasOutputNext(false)
+ chainedFake := prev.NewAliasOutputNext(false)
+ chainedFake.aliasAddress = *randAliasAddress()
+ outputs := Outputs{chained, chainedFake}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ found, err := prev.findChainedOutputAndCheckFork(tx)
+ assert.NoError(t, err)
+ assert.Equal(t, chained.Bytes(), found.Bytes())
+ })
+}
+
+func TestAliasOutput_hasToBeUnlockedForGovernanceUpdate(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained := prev.NewAliasOutputNext(true)
+ outputs := Outputs{chained}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ ok := prev.hasToBeUnlockedForGovernanceUpdate(tx)
+ assert.True(t, ok)
+ })
+
+ t.Run("CASE: No governance update", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained := prev.NewAliasOutputNext(false)
+ outputs := Outputs{chained}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ ok := prev.hasToBeUnlockedForGovernanceUpdate(tx)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: Duplicated alias", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ chained := prev.NewAliasOutputNext(true)
+ chainedDuplicate := chained.clone()
+ chainedDuplicate.stateData = []byte("duplicated")
+ outputs := Outputs{chained, chainedDuplicate}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ ok := prev.hasToBeUnlockedForGovernanceUpdate(tx)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: No alias output found", func(t *testing.T) {
+ prev := dummyAliasOutput()
+ next := NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())
+ outputs := Outputs{next}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(prev.ID())), NewOutputs(outputs...))
+ // unlockblocks are irrelevant now
+ tx := NewTransaction(essence, UnlockBlocks{NewReferenceUnlockBlock(0)})
+
+ ok := prev.hasToBeUnlockedForGovernanceUpdate(tx)
+ assert.True(t, ok)
+ })
+}
+
+func TestAliasOutput_unlockedGovernanceByAliasIndex(t *testing.T) {
+ governingAliasStateWallet := genRandomWallet()
+ governingAlias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: governingAliasStateWallet.address,
+ stateIndex: 10,
+ stateData: []byte("some data"),
+ immutableData: []byte("some data"),
+ isGovernanceUpdate: false,
+ governingAddress: randAliasAddress(),
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+ aliasStateWallet := genRandomWallet()
+ alias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: aliasStateWallet.address,
+ stateIndex: 10,
+ stateData: []byte("some data"),
+ immutableData: []byte("some data"),
+ isGovernanceUpdate: false,
+ governingAddress: governingAlias.GetAliasAddress(),
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ // unlocked for gov transition
+ nextAlias := alias.NewAliasOutputNext(true)
+ // we are updating the state address (simulate committer rotation)
+ nextAlias.stateAddress = randEd25119Address()
+ // unlocked for state transition
+ nextGoverningAlias := governingAlias.NewAliasOutputNext(false)
+
+ outputs := Outputs{nextAlias, nextGoverningAlias}
+ inputs := Outputs{}
+ inputsOfTx := NewInputs(NewUTXOInput(alias.ID()), NewUTXOInput(governingAlias.ID()))
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, inputsOfTx, NewOutputs(outputs...))
+
+ var indexOfAliasInput, indexOfGoverningAliasInput int
+ for i, input := range inputsOfTx {
+ castedInput := input.(*UTXOInput)
+ if castedInput.referencedOutputID == alias.ID() {
+ indexOfAliasInput = i
+ inputs = append(inputs, alias)
+ }
+ if castedInput.referencedOutputID == governingAlias.ID() {
+ indexOfGoverningAliasInput = i
+ inputs = append(inputs, governingAlias)
+ }
+ }
+ unlocks := make(UnlockBlocks, len(inputsOfTx))
+ unlocks[indexOfAliasInput] = NewAliasUnlockBlock(uint16(indexOfGoverningAliasInput))
+ unlocks[indexOfGoverningAliasInput] = NewSignatureUnlockBlock(governingAliasStateWallet.sign(essence))
+
+ tx := NewTransaction(essence, unlocks)
+
+ ok, err := alias.unlockedGovernanceTransitionByAliasIndex(tx, uint16(indexOfGoverningAliasInput), inputs)
+ assert.NoError(t, err)
+ assert.True(t, ok)
+ })
+
+ t.Run("CASE: Self governed alias can't be unlocked by alias reference", func(t *testing.T) {
+ dummyAlias := dummyAliasOutput()
+ dummyAlias.governingAddress = nil
+
+ ok, err := dummyAlias.unlockedGovernanceTransitionByAliasIndex(&Transaction{}, 0, Outputs{})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: Governing address is not alias", func(t *testing.T) {
+ dummyAlias := dummyAliasOutput()
+ dummyAlias.governingAddress = randEd25119Address()
+
+ ok, err := dummyAlias.unlockedGovernanceTransitionByAliasIndex(&Transaction{}, 0, Outputs{})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: Invalid referenced index", func(t *testing.T) {
+ dummyAlias := dummyAliasOutput()
+
+ ok, err := dummyAlias.unlockedGovernanceTransitionByAliasIndex(&Transaction{}, 1, Outputs{})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: Referenced output is not an alias", func(t *testing.T) {
+ dummyAlias := dummyAliasOutput()
+
+ ok, err := dummyAlias.unlockedGovernanceTransitionByAliasIndex(&Transaction{}, 0, Outputs{NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+
+ t.Run("CASE: Referenced output has different alias address", func(t *testing.T) {
+ dummyAlias := dummyAliasOutput()
+ dummyGoverningAlias := dummyAliasOutput()
+
+ ok, err := dummyAlias.unlockedGovernanceTransitionByAliasIndex(&Transaction{}, 0, Outputs{dummyGoverningAlias})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+}
+
+func TestAliasOutput_UnlockValid(t *testing.T) {
+ w := genRandomWallet()
+ governingWallet := genRandomWallet()
+ alias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: w.address,
+ stateIndex: 10,
+ stateData: []byte("some data"),
+ immutableData: []byte("some immutable data"),
+ isGovernanceUpdate: false,
+ governingAddress: governingWallet.address,
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+
+ t.Run("CASE: Alias unlocked by signature", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(false)
+ outputs := Outputs{chained}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := w.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Alias can't be unlocked by invalid signature", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(false)
+ clonedAlias := alias.clone()
+ clonedAlias.stateAddress = randEd25119Address()
+ outputs := Outputs{chained}
+ inputs := Outputs{clonedAlias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(clonedAlias.ID())), NewOutputs(outputs...))
+ // sign with bad signature
+ unlockBlocks := w.unlockBlocks(essence)
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := clonedAlias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Alias output destroyed, no gov update", func(t *testing.T) {
+ outputs := Outputs{NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := w.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Alias output destroyed, gov update", func(t *testing.T) {
+ outputs := Outputs{NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := governingWallet.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Alias output can't be destroyed, gov update", func(t *testing.T) {
+ clonedAlias := alias.clone()
+ clonedAlias.balances = NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA + 1})
+ outputs := Outputs{NewSigLockedSingleOutput(DustThresholdAliasOutputIOTA, randEd25119Address())}
+ inputs := Outputs{clonedAlias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(clonedAlias.ID())), NewOutputs(outputs...))
+ unlockBlocks := governingWallet.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := clonedAlias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Duplicated alias output", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(false)
+ clonedChained := chained.clone()
+ // need to change some bytes not to be considered duplicate already in NewOutputs()
+ clonedChained.stateData = []byte("random data")
+ outputs := Outputs{chained, clonedChained}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := w.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Governance update, sig valid", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(true)
+ outputs := Outputs{chained}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := governingWallet.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Governance update, sig invalid", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(true)
+ outputs := Outputs{chained}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := w.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Governance update, transition invalid", func(t *testing.T) {
+ chained := alias.NewAliasOutputNext(true)
+ chained.stateData = []byte("this should not be changed")
+ outputs := Outputs{chained}
+ inputs := Outputs{alias}
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, NewInputs(NewUTXOInput(alias.ID())), NewOutputs(outputs...))
+ unlockBlocks := governingWallet.unlockBlocks(essence)
+ // w.unlockBlocks puts a signature unlock block for all inputs
+ tx := NewTransaction(essence, unlockBlocks)
+
+ valid, err := alias.UnlockValid(tx, unlockBlocks[0], inputs)
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Unlocked by other alias", func(t *testing.T) {
+ governingAliasStateWallet := genRandomWallet()
+ governingAlias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: governingAliasStateWallet.address,
+ stateIndex: 10,
+ stateData: []byte("some data"),
+ immutableData: []byte("some data"),
+ isGovernanceUpdate: false,
+ governingAddress: randAliasAddress(),
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+ aliasStateWallet := genRandomWallet()
+ governedAlias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: aliasStateWallet.address,
+ stateIndex: 10,
+ stateData: []byte("some data"),
+ immutableData: []byte("some data"),
+ isGovernanceUpdate: false,
+ governingAddress: governingAlias.GetAliasAddress(),
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+ // unlocked for gov transition
+ nextAlias := governedAlias.NewAliasOutputNext(true)
+ // we are updating the state address (simulate committer rotation)
+ nextAlias.stateAddress = randEd25119Address()
+ // unlocked for state transition
+ nextGoverningAlias := governingAlias.NewAliasOutputNext(false)
+
+ outputs := Outputs{nextAlias, nextGoverningAlias}
+ inputs := Outputs{}
+ inputsOfTx := NewInputs(NewUTXOInput(governedAlias.ID()), NewUTXOInput(governingAlias.ID()))
+ essence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, inputsOfTx, NewOutputs(outputs...))
+
+ var indexOfAliasInput, indexOfGoverningAliasInput int
+ for i, input := range inputsOfTx {
+ castedInput := input.(*UTXOInput)
+ if castedInput.referencedOutputID == governedAlias.ID() {
+ indexOfAliasInput = i
+ inputs = append(inputs, governedAlias)
+ }
+ if castedInput.referencedOutputID == governingAlias.ID() {
+ indexOfGoverningAliasInput = i
+ inputs = append(inputs, governingAlias)
+ }
+ }
+ unlocks := make(UnlockBlocks, len(inputsOfTx))
+ unlocks[indexOfAliasInput] = NewAliasUnlockBlock(uint16(indexOfGoverningAliasInput))
+ unlocks[indexOfGoverningAliasInput] = NewSignatureUnlockBlock(governingAliasStateWallet.sign(essence))
+
+ tx := NewTransaction(essence, unlocks)
+
+ ok, err := governedAlias.UnlockValid(tx, unlocks[indexOfAliasInput], inputs)
+ assert.NoError(t, err)
+ assert.True(t, ok)
+ })
+
+ t.Run("CASE: Unsupported unlock block", func(t *testing.T) {
+ txEssence := NewTransactionEssence(0, time.Time{}, identity.ID{}, identity.ID{}, nil, nil)
+ tx := NewTransaction(txEssence, nil)
+ ok, err := alias.UnlockValid(tx, NewReferenceUnlockBlock(0), Outputs{})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, ok)
+ })
+}
+
+func TestAliasOutput_Clone(t *testing.T) {
+ out := dummyAliasOutput()
+ out.isDelegated = true
+ outBack := out.Clone()
+ outBackT, ok := outBack.(*AliasOutput)
+ assert.True(t, ok)
+ assert.True(t, out != outBackT)
+ assert.True(t, out.stateAddress != outBackT.stateAddress)
+ assert.True(t, out.governingAddress != outBackT.governingAddress)
+ assert.True(t, notSameMemory(out.immutableData, outBackT.immutableData))
+ assert.True(t, notSameMemory(out.stateData, outBackT.stateData))
+ assert.EqualValues(t, out.Bytes(), outBack.Bytes())
+}
+
+// endregion
+
+// region ExtendedLockedOutput Tests
+
+func TestExtendedLockedOutput_Address(t *testing.T) {
+ t.Run("CASE: Address is signature backed", func(t *testing.T) {
+ addy := randEd25119Address()
+ o := &ExtendedLockedOutput{address: addy}
+ assert.True(t, o.Address().Equals(addy))
+ })
+
+ t.Run("CASE: Address is alias address", func(t *testing.T) {
+ addy := randAliasAddress()
+ o := &ExtendedLockedOutput{address: addy}
+ assert.True(t, o.Address().Equals(addy))
+ })
+}
+
+func TestExtendedLockedOutput_Balances(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ bal := NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA})
+ o := &ExtendedLockedOutput{balances: bal}
+ assert.Equal(t, bal.Bytes(), o.Balances().Bytes())
+ })
+}
+
+func TestExtendedLockedOutput_Bytes(t *testing.T) {
+ t.Run("CASE: Happy path, all optional fields", func(t *testing.T) {
+ o := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address()).
+ WithFallbackOptions(randEd25119Address(), time.Now().Add(2*time.Hour)).
+ WithTimeLock(time.Now().Add(1 * time.Hour))
+ err := o.SetPayload([]byte("some metadata"))
+ assert.NoError(t, err)
+ oBytes := o.Bytes()
+ var restored Output
+ restored, _, err = OutputFromBytes(oBytes)
+ assert.NoError(t, err)
+ castedRestored, ok := restored.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, o.balances.Bytes(), castedRestored.balances.Bytes())
+ assert.True(t, o.address.Equals(castedRestored.address))
+ assert.Equal(t, o.id.Bytes(), castedRestored.id.Bytes())
+ assert.True(t, o.fallbackDeadline.Equal(castedRestored.fallbackDeadline))
+ assert.True(t, o.fallbackAddress.Equals(castedRestored.fallbackAddress))
+ assert.True(t, o.timelock.Equal(castedRestored.timelock))
+ assert.Equal(t, o.payload, castedRestored.payload)
+ })
+
+ t.Run("CASE: Happy path, no optional fields", func(t *testing.T) {
+ o := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address())
+ oBytes := o.Bytes()
+ restored, _, err := OutputFromBytes(oBytes)
+ assert.NoError(t, err)
+ castedRestored, ok := restored.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, o.balances.Bytes(), castedRestored.balances.Bytes())
+ assert.True(t, o.address.Equals(castedRestored.address))
+ assert.Equal(t, o.id.Bytes(), castedRestored.id.Bytes())
+ assert.True(t, o.fallbackDeadline.Equal(castedRestored.fallbackDeadline))
+ assert.Nil(t, o.fallbackAddress)
+ assert.Nil(t, castedRestored.fallbackAddress)
+ assert.True(t, o.timelock.Equal(castedRestored.timelock))
+ assert.Equal(t, o.payload, castedRestored.payload)
+ })
+
+ t.Run("CASE: Happy path, optional timelock", func(t *testing.T) {
+ o := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address()).
+ WithTimeLock(time.Now().Add(1 * time.Hour))
+ oBytes := o.Bytes()
+ restored, _, err := OutputFromBytes(oBytes)
+ assert.NoError(t, err)
+ castedRestored, ok := restored.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, o.balances.Bytes(), castedRestored.balances.Bytes())
+ assert.True(t, o.address.Equals(castedRestored.address))
+ assert.Equal(t, o.id.Bytes(), castedRestored.id.Bytes())
+ assert.True(t, o.fallbackDeadline.Equal(castedRestored.fallbackDeadline))
+ assert.Nil(t, o.fallbackAddress)
+ assert.Nil(t, castedRestored.fallbackAddress)
+ assert.True(t, o.timelock.Equal(castedRestored.timelock))
+ assert.Equal(t, o.payload, castedRestored.payload)
+ })
+
+ t.Run("CASE: Happy path, optional fallback", func(t *testing.T) {
+ o := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address()).
+ WithFallbackOptions(randEd25119Address(), time.Now().Add(2*time.Hour))
+ oBytes := o.Bytes()
+ restored, _, err := OutputFromBytes(oBytes)
+ assert.NoError(t, err)
+ castedRestored, ok := restored.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, o.balances.Bytes(), castedRestored.balances.Bytes())
+ assert.True(t, o.address.Equals(castedRestored.address))
+ assert.Equal(t, o.id.Bytes(), castedRestored.id.Bytes())
+ assert.True(t, o.fallbackDeadline.Equal(castedRestored.fallbackDeadline))
+ assert.True(t, o.fallbackAddress.Equals(castedRestored.fallbackAddress))
+ assert.True(t, o.timelock.Equal(castedRestored.timelock))
+ assert.Equal(t, o.payload, castedRestored.payload)
+ })
+
+ t.Run("CASE: Happy path, optional payload", func(t *testing.T) {
+ o := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}, randEd25119Address())
+ err := o.SetPayload([]byte("some metadata"))
+ assert.NoError(t, err)
+ oBytes := o.Bytes()
+ var restored Output
+ restored, _, err = OutputFromBytes(oBytes)
+ assert.NoError(t, err)
+ castedRestored, ok := restored.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, o.balances.Bytes(), castedRestored.balances.Bytes())
+ assert.True(t, o.address.Equals(castedRestored.address))
+ assert.Equal(t, o.id.Bytes(), castedRestored.id.Bytes())
+ assert.True(t, o.fallbackDeadline.Equal(castedRestored.fallbackDeadline))
+ assert.Nil(t, o.fallbackAddress)
+ assert.Nil(t, castedRestored.fallbackAddress)
+ assert.True(t, o.timelock.Equal(castedRestored.timelock))
+ assert.Equal(t, o.payload, castedRestored.payload)
+ })
+}
+
+func TestExtendedLockedOutput_Compare(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ clone := output.Clone()
+ assert.Equal(t, 0, output.Compare(clone))
+ })
+
+ t.Run("CASE: Not equal", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ clone := output.Clone()
+ castedClone, ok := clone.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, 0, output.Compare(castedClone))
+ // change one byte
+ castedClone.payload[0] = output.payload[0] + 1
+ assert.NotEqual(t, 0, output.Compare(castedClone))
+ })
+}
+
+func TestExtendedLockedOutput_FallbackAddress(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ assert.True(t, output.FallbackAddress().Equals(output.fallbackAddress))
+ })
+
+ t.Run("CASE: Address nil", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ output.fallbackAddress = nil
+ assert.Nil(t, output.FallbackAddress())
+ })
+}
+
+func TestExtendedLockedOutput_FallbackOptions(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ fAddy, fDeadline := output.FallbackOptions()
+ assert.True(t, fAddy.Equals(output.fallbackAddress))
+ assert.True(t, fDeadline.Equal(output.fallbackDeadline))
+ })
+}
+
+func TestExtendedLockedOutput_GetPayload(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ payload := output.GetPayload()
+ assert.Equal(t, output.payload, payload)
+ output.payload = nil
+ payload = output.GetPayload()
+ assert.Nil(t, payload)
+ })
+}
+
+func TestExtendedLockedOutput_ID(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ id := output.ID()
+ assert.Equal(t, output.id.Bytes(), id.Bytes())
+ })
+}
+
+func TestExtendedLockedOutput_Input(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ input, ok := output.Input().(*UTXOInput)
+ assert.True(t, ok)
+ assert.Equal(t, input.referencedOutputID.Bytes(), output.ID().Bytes())
+ })
+
+ t.Run("CASE: No output id yet", func(t *testing.T) {
+ // serialized form of output doesn't have outputid
+ output, _, err := OutputFromBytes(dummyExtendedLockedOutput().Bytes())
+ assert.NoError(t, err)
+ assert.Panics(t, func() {
+ _, _ = output.Input().(*UTXOInput)
+ })
+ output.SetID(randOutputID())
+ assert.NotPanics(t, func() {
+ _, _ = output.Input().(*UTXOInput)
+ })
+ })
+}
+
+func TestExtendedLockedOutput_ObjectStorageKey(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ assert.Equal(t, output.ID().Bytes(), output.ObjectStorageKey())
+ })
+}
+
+func TestExtendedLockedOutput_ObjectStorageValue(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ assert.Equal(t, output.Bytes(), output.ObjectStorageValue())
+ })
+}
+
+func TestExtendedLockedOutput_SetID(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ newID := randOutputID()
+ var ok bool
+ output, ok = output.SetID(newID).(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, newID.Bytes(), output.ID().Bytes())
+ })
+}
+
+func TestExtendedLockedOutput_SetPayload(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ data := make([]byte, MaxOutputPayloadSize)
+ output := dummyExtendedLockedOutput()
+ err := output.SetPayload(data)
+ assert.NoError(t, err)
+ })
+
+ t.Run("CASE: Too much data", func(t *testing.T) {
+ data := make([]byte, MaxOutputPayloadSize+1)
+ output := dummyExtendedLockedOutput()
+ err := output.SetPayload(data)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+}
+
+func TestExtendedLockedOutput_TimeLock(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ assert.True(t, output.TimeLock().Equal(output.timelock))
+ })
+}
+
+func TestExtendedLockedOutput_TimeLockedNow(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ timelockDate := time.Now()
+ output.timelock = timelockDate
+ assert.True(t, output.TimeLockedNow(timelockDate.Add(-time.Minute)))
+ assert.True(t, output.TimeLockedNow(timelockDate.Add(-time.Nanosecond)))
+ assert.False(t, output.TimeLockedNow(timelockDate))
+ assert.False(t, output.TimeLockedNow(timelockDate.Add(time.Second)))
+ })
+}
+
+func TestExtendedLockedOutput_Type(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := &ExtendedLockedOutput{}
+ assert.Equal(t, ExtendedLockedOutputType, output.Type())
+ })
+}
+
+func TestExtendedLockedOutput_UnlockAddressNow(t *testing.T) {
+ fallbackDeadline := time.Now()
+ fallbackAddress := randEd25119Address()
+
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithFallbackOptions(fallbackAddress, fallbackDeadline)
+ assert.True(t, output.UnlockAddressNow(fallbackDeadline.Add(-time.Minute)).Equals(output.Address()))
+ assert.True(t, output.UnlockAddressNow(fallbackDeadline.Add(time.Minute)).Equals(output.FallbackAddress()))
+ })
+
+ t.Run("CASE: No fallback address", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithFallbackOptions(nil, fallbackDeadline)
+ assert.True(t, output.UnlockAddressNow(fallbackDeadline.Add(-time.Minute)).Equals(output.Address()))
+ assert.True(t, output.UnlockAddressNow(fallbackDeadline.Add(time.Minute)).Equals(output.Address()))
+ })
+}
+
+func TestExtendedLockedOutput_Update(t *testing.T) {
+ t.Run("CASE: Update panics", func(t *testing.T) {
+ output := &ExtendedLockedOutput{}
+ assert.Panics(t, func() {
+ output.Update(&ExtendedLockedOutput{})
+ })
+ })
+}
+
+func TestExtendedLockedOutput_UpdateMintingColor(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ output.balances = NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA, ColorMint: 100})
+ updated, ok := output.UpdateMintingColor().(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, output.id.Bytes(), updated.id.Bytes())
+ assert.True(t, updated.address.Equals(output.address))
+ assert.True(t, updated.fallbackAddress.Equals(output.fallbackAddress))
+ assert.True(t, updated.fallbackDeadline.Equal(output.fallbackDeadline))
+ assert.True(t, updated.timelock.Equal(output.timelock))
+ assert.Equal(t, output.payload, updated.payload)
+ mintBalance, valid := output.Balances().Get(ColorMint)
+ assert.True(t, valid)
+ coloredBalance, uValid := updated.Balances().Get(blake2b.Sum256(output.ID().Bytes()))
+ assert.True(t, uValid)
+ assert.Equal(t, mintBalance, coloredBalance)
+ })
+
+ t.Run("CASE: No color mint", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ output.balances = NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA, {8}: 100})
+ updated, ok := output.UpdateMintingColor().(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.Equal(t, output.id.Bytes(), updated.id.Bytes())
+ assert.True(t, updated.address.Equals(output.address))
+ assert.True(t, updated.fallbackAddress.Equals(output.fallbackAddress))
+ assert.True(t, updated.fallbackDeadline.Equal(output.fallbackDeadline))
+ assert.True(t, updated.timelock.Equal(output.timelock))
+ assert.Equal(t, output.payload, updated.payload)
+ assert.Equal(t, updated.Balances().Bytes(), output.Balances().Bytes())
+ })
+
+ t.Run("CASE: Output had too big payload", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ output.balances = NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA, {8}: 100})
+ output.payload = make([]byte, MaxOutputPayloadSize+1)
+ assert.Panics(t, func() {
+ output.UpdateMintingColor()
+ })
+ })
+}
+
+func TestExtendedLockedOutput_WithFallbackOptions(t *testing.T) {
+ fallbackDeadline := time.Now()
+ fallbackAddress := randEd25119Address()
+
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := (&ExtendedLockedOutput{}).WithFallbackOptions(fallbackAddress, fallbackDeadline)
+ assert.True(t, fallbackAddress.Equals(output.FallbackAddress()))
+ assert.True(t, fallbackDeadline.Equal(output.fallbackDeadline))
+ })
+
+ t.Run("CASE: nil fallback address", func(t *testing.T) {
+ output := (&ExtendedLockedOutput{}).WithFallbackOptions(nil, fallbackDeadline)
+ assert.Nil(t, output.FallbackAddress())
+ assert.True(t, fallbackDeadline.Equal(output.fallbackDeadline))
+ })
+}
+
+func TestExtendedLockedOutput_WithTimeLock(t *testing.T) {
+ timelock := time.Now()
+
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := (&ExtendedLockedOutput{}).WithTimeLock(timelock)
+ assert.True(t, timelock.Equal(output.TimeLock()))
+ })
+}
+
+func TestNewExtendedLockedOutput(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ addy := randAliasAddress()
+ balances := NewColoredBalances(map[Color]uint64{ColorIOTA: 1})
+ output := NewExtendedLockedOutput(balances.Map(), addy)
+ assert.Equal(t, balances.Bytes(), output.Balances().Bytes())
+ assert.True(t, addy.Equals(output.Address()))
+ })
+}
+
+func TestExtendedOutputFromMarshalUtil(t *testing.T) {
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ outputBytes := output.Bytes()
+ marshalUtil := marshalutil.New(outputBytes)
+ restored, err := ExtendedOutputFromMarshalUtil(marshalUtil)
+ assert.NoError(t, err)
+ assert.Equal(t, len(outputBytes), marshalUtil.ReadOffset())
+ assert.Equal(t, outputBytes, restored.Bytes())
+ })
+
+ t.Run("CASE: Wrong type", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ outputBytes := output.Bytes()
+ outputBytes[0] = byte(AliasOutputType)
+ marshalUtil := marshalutil.New(outputBytes)
+ _, err := ExtendedOutputFromMarshalUtil(marshalUtil)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Fallback flag provided, missing data", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithFallbackOptions(nil, time.Time{})
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.SetBit(flagExtendedLockedOutputFallbackPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ _, _, err := OutputFromBytes(outputBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Timelock flag provided, missing data", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithTimeLock(time.Time{})
+ err := output.SetPayload(nil)
+ assert.NoError(t, err)
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.SetBit(flagExtendedLockedOutputTimeLockPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ _, _, err = OutputFromBytes(outputBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Payload flag provided, missing data", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ err := output.SetPayload(nil)
+ assert.NoError(t, err)
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.SetBit(flagExtendedLockedOutputPayloadPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ _, _, err = OutputFromBytes(outputBytes)
+ t.Log(err)
+ assert.Error(t, err)
+ })
+
+ t.Run("CASE: Fallback present, wrong flag", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithTimeLock(time.Time{})
+ err := output.SetPayload(nil)
+ assert.NoError(t, err)
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.ClearBit(flagExtendedLockedOutputFallbackPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ var consumedBytes int
+ _, consumedBytes, err = OutputFromBytes(outputBytes)
+ assert.NoError(t, err)
+ // we did not consume all bytes
+ assert.NotEqual(t, len(outputBytes), consumedBytes)
+ })
+
+ t.Run("CASE: Timelock present, wrong flag", func(t *testing.T) {
+ output := dummyExtendedLockedOutput().WithTimeLock(time.Now()).WithFallbackOptions(nil, time.Time{})
+ err := output.SetPayload(nil)
+ assert.NoError(t, err)
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.ClearBit(flagExtendedLockedOutputTimeLockPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ var consumedBytes int
+ _, consumedBytes, err = OutputFromBytes(outputBytes)
+ assert.NoError(t, err)
+ // we did not consume all bytes
+ assert.NotEqual(t, len(outputBytes), consumedBytes)
+ })
+
+ t.Run("CASE: Payload present, wrong flag", func(t *testing.T) {
+ output := dummyExtendedLockedOutput()
+ outputBytes := output.Bytes()
+ flags := output.compressFlags()
+ flags = flags.ClearBit(flagExtendedLockedOutputPayloadPresent)
+ outputBytes[1+len(output.balances.Bytes())+AddressLength] = byte(flags)
+ _, consumedBytes, err := OutputFromBytes(outputBytes)
+ assert.NoError(t, err)
+ // we did not consume all bytes
+ assert.NotEqual(t, len(outputBytes), consumedBytes)
+ })
+}
+
+func TestExtendedLockedOutput_UnlockValid(t *testing.T) {
+ t.Run("CASE: Happy path, unlocked by sig", func(t *testing.T) {
+ w := genRandomWallet()
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, w.address)
+ input.SetID(randOutputID())
+ output := NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{ColorIOTA: 1}), randEd25119Address())
+ essence := NewTransactionEssence(0, time.Now(), identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock := NewSignatureUnlockBlock(w.sign(essence))
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Happy path, unlocked by alias", func(t *testing.T) {
+ w := genRandomWallet()
+ alias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: w.address, // alias state controller is our wallet
+ stateIndex: 10,
+ }
+ nextAlias := alias.NewAliasOutputNext(false)
+ toBeConsumedExtended := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, alias.GetAliasAddress())
+ toBeConsumedExtended.SetID(randOutputID())
+ nextAliasBalance := alias.Balances().Map()
+ // add 1 more iota from consumed extended output
+ nextAliasBalance[ColorIOTA]++
+ err := nextAlias.SetBalances(nextAliasBalance)
+ assert.NoError(t, err)
+
+ essence := NewTransactionEssence(0, time.Now(), identity.ID{}, identity.ID{}, NewInputs(toBeConsumedExtended.Input(), alias.Input()), NewOutputs(nextAlias))
+ // which input index did the alias get?
+ var aliasInputIndex uint16
+ orderedInputs := make(Outputs, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ casted := input.(*UTXOInput)
+ if casted.ReferencedOutputID() == alias.ID() {
+ aliasInputIndex = uint16(i)
+ orderedInputs[i] = alias
+ }
+ if casted.ReferencedOutputID() == toBeConsumedExtended.ID() {
+ orderedInputs[i] = toBeConsumedExtended
+ }
+ }
+ // create mapping from outputID to unlockBlock
+ inputToUnlockMapping := make(map[OutputID]UnlockBlock)
+ inputToUnlockMapping[alias.ID()] = NewSignatureUnlockBlock(w.sign(essence))
+ inputToUnlockMapping[toBeConsumedExtended.ID()] = NewAliasUnlockBlock(aliasInputIndex)
+
+ // fill unlock blocks
+ unlocks := make(UnlockBlocks, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ unlocks[i] = inputToUnlockMapping[input.(*UTXOInput).ReferencedOutputID()]
+ }
+
+ tx := NewTransaction(essence, unlocks)
+
+ valid, uErr := toBeConsumedExtended.UnlockValid(tx, inputToUnlockMapping[toBeConsumedExtended.ID()], orderedInputs)
+ assert.NoError(t, uErr)
+ assert.True(t, valid)
+ valid, uErr = alias.UnlockValid(tx, inputToUnlockMapping[alias.ID()], orderedInputs)
+ assert.NoError(t, uErr)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Referenced input not alias", func(t *testing.T) {
+ w := genRandomWallet()
+ nowis := time.Now()
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, w.address)
+ input.SetID(randOutputID())
+ output := NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{ColorIOTA: 1}), randEd25119Address())
+ essence := NewTransactionEssence(0, nowis, identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock := NewAliasUnlockBlock(0)
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{input})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Referenced wrong alias", func(t *testing.T) {
+ alias := &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: randEd25119Address(), // alias state controller is our wallet
+ stateIndex: 10,
+ }
+ nowis := time.Now()
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, randAliasAddress())
+ input.SetID(randOutputID())
+ // for the sake of this test, tx doesn't have to be valid
+ essence := NewTransactionEssence(0, nowis, identity.ID{}, identity.ID{}, NewInputs(alias.Input()), NewOutputs(input))
+ // important is that we reference an alias that has different aliasAddress
+ unlockBlock := NewAliasUnlockBlock(0)
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{alias})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Output is timelocked, can't spend", func(t *testing.T) {
+ w := genRandomWallet()
+ nowis := time.Now()
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, w.address).WithTimeLock(nowis.Add(time.Hour))
+ input.SetID(randOutputID())
+ output := NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{ColorIOTA: 1}), randEd25119Address())
+ // tx timestamp before timelock
+ essence := NewTransactionEssence(0, nowis, identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock := NewSignatureUnlockBlock(w.sign(essence))
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Output is timelocked, spend after", func(t *testing.T) {
+ w := genRandomWallet()
+ nowis := time.Now()
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, w.address).WithTimeLock(nowis.Add(time.Hour))
+ input.SetID(randOutputID())
+ output := NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{ColorIOTA: 1}), randEd25119Address())
+ // tx timestamp is exactly timelock, output is allowed to be spent from that moment on
+ essence := NewTransactionEssence(0, nowis.Add(time.Hour), identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock := NewSignatureUnlockBlock(w.sign(essence))
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+
+ t.Run("CASE: Unsupported unlock block", func(t *testing.T) {
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, randAliasAddress())
+ unlockBlock := NewReferenceUnlockBlock(0)
+
+ valid, err := input.UnlockValid(&Transaction{essence: &TransactionEssence{}}, unlockBlock, Outputs{input})
+ t.Log(err)
+ assert.Error(t, err)
+ assert.False(t, valid)
+ })
+
+ t.Run("CASE: Fallback address present", func(t *testing.T) {
+ destWallet := genRandomWallet()
+ myWallet := genRandomWallet()
+ nowis := time.Now()
+ // until nowis+30 minutes, only w wallet can spend it, after that, only myWallet
+ input := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, destWallet.address).WithFallbackOptions(myWallet.address, nowis.Add(30*time.Minute))
+ input.SetID(randOutputID())
+ output := NewSigLockedColoredOutput(NewColoredBalances(map[Color]uint64{ColorIOTA: 1}), randEd25119Address())
+
+ // t =< nowis + 30 mins, destWallet can spend it
+ essence := NewTransactionEssence(0, nowis, identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock := NewSignatureUnlockBlock(destWallet.sign(essence))
+ tx := NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err := input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.True(t, valid)
+
+ // t =< nowis + 30 mins, myWallet can't spend it
+ essence = NewTransactionEssence(0, nowis, identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock = NewSignatureUnlockBlock(myWallet.sign(essence))
+ tx = NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err = input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.False(t, valid)
+
+ // t > nowis + 30 mins, destWallet can't spend it
+ essence = NewTransactionEssence(0, nowis.Add(30*time.Minute).Add(time.Nanosecond), identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock = NewSignatureUnlockBlock(destWallet.sign(essence))
+ tx = NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err = input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.False(t, valid)
+
+ // t > nowis + 30 mins, myWallet can spend it
+ essence = NewTransactionEssence(0, nowis.Add(30*time.Minute).Add(time.Nanosecond), identity.ID{}, identity.ID{}, NewInputs(input.Input()), NewOutputs(output))
+ unlockBlock = NewSignatureUnlockBlock(myWallet.sign(essence))
+ tx = NewTransaction(essence, UnlockBlocks{unlockBlock})
+
+ valid, err = input.UnlockValid(tx, unlockBlock, Outputs{input})
+ assert.NoError(t, err)
+ assert.True(t, valid)
+ })
+}
+
+func TestExtendedLockedOutput_Clone(t *testing.T) {
+ out := dummyExtendedLockedOutput()
+ outBack := out.Clone()
+ outBackT, ok := outBack.(*ExtendedLockedOutput)
+ assert.True(t, ok)
+ assert.True(t, out != outBackT)
+ assert.True(t, notSameMemory(out.payload, outBackT.payload))
+ assert.True(t, out.address != outBackT.address)
+ assert.True(t, out.fallbackAddress != outBackT.fallbackAddress)
+ assert.EqualValues(t, out.Bytes(), outBack.Bytes())
+}
+
+// endregion
+
+// region test utils
+
+func genRandomWallet() wallet {
+ kp := ed25519.GenerateKeyPair()
+ return wallet{
+ kp,
+ NewED25519Address(kp.PublicKey),
+ }
+}
+
+func notSameMemory(s1, s2 []byte) bool {
+ if s1 == nil || s2 == nil {
+ return true
+ }
+ return &s1[cap(s1)-1] != &s2[cap(s2)-1]
+}
+
+func dummyAliasOutput(origin ...bool) *AliasOutput {
+ orig := false
+ if len(origin) > 0 {
+ orig = origin[0]
+ }
+ return &AliasOutput{
+ outputID: randOutputID(),
+ outputIDMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: randEd25119Address(),
+ stateIndex: 0,
+ stateData: []byte("initial"),
+ governanceMetadata: []byte("This chain runs EVM v0.0.0"),
+ immutableData: []byte("don't touch this"),
+ isGovernanceUpdate: false,
+ isOrigin: orig,
+ isDelegated: false,
+ governingAddress: randAliasAddress(),
+ delegationTimelock: time.Time{},
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+}
+
+func dummyExtendedLockedOutput() *ExtendedLockedOutput {
+ return &ExtendedLockedOutput{
+ id: randOutputID(),
+ idMutex: sync.RWMutex{},
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: 1}),
+ address: randEd25119Address(),
+ fallbackAddress: randEd25119Address(),
+ fallbackDeadline: time.Unix(1001, 0),
+ timelock: time.Unix(2000, 0),
+ payload: []byte("a payload"),
+ StorableObjectFlags: objectstorage.StorableObjectFlags{},
+ }
+}
+
+func randEd25119Address() *ED25519Address {
+ keyPair := ed25519.GenerateKeyPair()
+ return NewED25519Address(keyPair.PublicKey)
+}
+
+func randAliasAddress() *AliasAddress {
+ randOutputIDBytes := make([]byte, 32)
+ _, _ = rand.Read(randOutputIDBytes)
+ return NewAliasAddress(randOutputIDBytes)
+}
+
+func randOutputID() OutputID {
+ randOutputIDBytes := make([]byte, 34)
+ _, _ = rand.Read(randOutputIDBytes)
+ outputID, _, _ := OutputIDFromBytes(randOutputIDBytes)
+ return outputID
+}
+
+// endregion
diff --git a/packages/ledgerstate/transaction.go b/packages/ledgerstate/transaction.go
index a796c1edcc..a408461f9f 100644
--- a/packages/ledgerstate/transaction.go
+++ b/packages/ledgerstate/transaction.go
@@ -176,6 +176,20 @@ func NewTransaction(essence *TransactionEssence, unlockBlocks UnlockBlocks) (tra
for i, output := range essence.Outputs() {
output.SetID(NewOutputID(transaction.ID(), uint16(i)))
+ // check if an alias output is deadlocked to itself
+ // for origin alias outputs, alias address is only known once the ID of the output is set. However unlikely it is,
+ // it is still possible to pre-mine a transaction with an origin alias output that has its governing or state
+ // address set as the later determined alias address. Hence this check here.
+ if output.Type() == AliasOutputType {
+ alias := output.(*AliasOutput)
+ aliasAddress := alias.GetAliasAddress()
+ if alias.GetStateAddress().Equals(aliasAddress) {
+ panic(fmt.Sprintf("state address of alias output at index %d (id: %s) cannot be its own alias address", i, alias.ID().Base58()))
+ }
+ if alias.GetGoverningAddress().Equals(aliasAddress) {
+ panic(fmt.Sprintf("governing address of alias output at index %d (id: %s) cannot be its own alias address", i, alias.ID().Base58()))
+ }
+ }
}
return
@@ -239,16 +253,38 @@ func TransactionFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (transacti
maxReferencedUnlockIndex := len(transaction.essence.Inputs()) - 1
for i, unlockBlock := range transaction.unlockBlocks {
- if unlockBlock.Type() == ReferenceUnlockBlockType {
+ switch unlockBlock.Type() {
+ case SignatureUnlockBlockType:
+ continue
+ case ReferenceUnlockBlockType:
if unlockBlock.(*ReferenceUnlockBlock).ReferencedIndex() > uint16(maxReferencedUnlockIndex) {
err = errors.Errorf("unlock block %d references non-existent unlock block at index %d", i, unlockBlock.(*ReferenceUnlockBlock).ReferencedIndex())
return
}
+ case AliasUnlockBlockType:
+ if unlockBlock.(*AliasUnlockBlock).AliasInputIndex() > uint16(maxReferencedUnlockIndex) {
+ err = errors.Errorf("unlock block %d references non-existent chain input at index %d", i, unlockBlock.(*AliasUnlockBlock).AliasInputIndex())
+ return
+ }
}
}
for i, output := range transaction.essence.Outputs() {
output.SetID(NewOutputID(transaction.ID(), uint16(i)))
+ // check if an alias output is deadlocked to itself
+ // for origin alias outputs, alias address is only known once the ID of the output is set
+ if output.Type() == AliasOutputType {
+ alias := output.(*AliasOutput)
+ aliasAddress := alias.GetAliasAddress()
+ if alias.GetStateAddress().Equals(aliasAddress) {
+ err = errors.Errorf("state address of alias output at index %d (id: %s) cannot be its own alias address", i, alias.ID().Base58())
+ return
+ }
+ if alias.GetGoverningAddress().Equals(aliasAddress) {
+ err = errors.Errorf("governing address of alias output at index %d (id: %s) cannot be its own alias address", i, alias.ID().Base58())
+ return
+ }
+ }
}
return
diff --git a/packages/ledgerstate/unlockblock.go b/packages/ledgerstate/unlockblock.go
index e4e49befa7..c69336ea5e 100644
--- a/packages/ledgerstate/unlockblock.go
+++ b/packages/ledgerstate/unlockblock.go
@@ -19,6 +19,9 @@ const (
// ReferenceUnlockBlockType represents the type of a ReferenceUnlockBlock.
ReferenceUnlockBlockType
+
+ // AliasUnlockBlockType represents the type of a AliasUnlockBlock
+ AliasUnlockBlockType
)
// UnlockBlockType represents the type of the UnlockBlock. Different types of UnlockBlocks can unlock different types of
@@ -30,6 +33,7 @@ func (a UnlockBlockType) String() string {
return [...]string{
"SignatureUnlockBlockType",
"ReferenceUnlockBlockType",
+ "AliasUnlockBlockType",
}[a]
}
@@ -82,6 +86,12 @@ func UnlockBlockFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (unlockBlo
err = errors.Errorf("failed to parse ReferenceUnlockBlock from MarshalUtil: %w", err)
return
}
+ case AliasUnlockBlockType:
+ if unlockBlock, err = AliasUnlockBlockFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse AliasUnlockBlock from MarshalUtil: %w", err)
+ return
+ }
+
default:
err = errors.Errorf("unsupported UnlockBlockType (%X): %w", unlockBlockType, cerrors.ErrParseBytesFailed)
return
@@ -133,7 +143,9 @@ func UnlockBlocksFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (unlockBl
return
}
- if unlockBlock.Type() != ReferenceUnlockBlockType && !seenUnlockBlocks.Add(unlockBlockBytes) {
+ if unlockBlock.Type() != ReferenceUnlockBlockType &&
+ unlockBlock.Type() != AliasUnlockBlockType &&
+ !seenUnlockBlocks.Add(unlockBlockBytes) {
err = errors.Errorf("duplicate UnlockBlock detected at index %d: %w", i, cerrors.ErrParseBytesFailed)
return
}
@@ -235,6 +247,11 @@ func (s *SignatureUnlockBlock) String() string {
)
}
+// Signature return the signature itself
+func (s *SignatureUnlockBlock) Signature() Signature {
+ return s.signature
+}
+
// code contract (make sure the type implements all required methods)
var _ UnlockBlock = &SignatureUnlockBlock{}
@@ -316,3 +333,79 @@ func (r *ReferenceUnlockBlock) String() string {
var _ UnlockBlock = &ReferenceUnlockBlock{}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region AliasUnlockBlock /////////////////////////////////////////////////////////////////////////////////////////
+
+// AliasUnlockBlock defines an UnlockBlock which contains an index of corresponding AliasOutput
+type AliasUnlockBlock struct {
+ referencedIndex uint16
+}
+
+// NewAliasUnlockBlock is the constructor for AliasUnlockBlocks.
+func NewAliasUnlockBlock(chainInputIndex uint16) *AliasUnlockBlock {
+ return &AliasUnlockBlock{
+ referencedIndex: chainInputIndex,
+ }
+}
+
+// AliasUnlockBlockFromBytes unmarshals a AliasUnlockBlock from a sequence of bytes.
+func AliasUnlockBlockFromBytes(bytes []byte) (unlockBlock *AliasUnlockBlock, consumedBytes int, err error) {
+ marshalUtil := marshalutil.New(bytes)
+ if unlockBlock, err = AliasUnlockBlockFromMarshalUtil(marshalUtil); err != nil {
+ err = errors.Errorf("failed to parse AliasUnlockBlock from MarshalUtil: %w", err)
+ return
+ }
+ consumedBytes = marshalUtil.ReadOffset()
+
+ return
+}
+
+// AliasUnlockBlockFromMarshalUtil unmarshals a AliasUnlockBlock using a MarshalUtil (for easier unmarshaling).
+func AliasUnlockBlockFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (unlockBlock *AliasUnlockBlock, err error) {
+ unlockBlockType, err := marshalUtil.ReadByte()
+ if err != nil {
+ err = errors.Errorf("failed to parse UnlockBlockType (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ if UnlockBlockType(unlockBlockType) != AliasUnlockBlockType {
+ err = errors.Errorf("invalid UnlockBlockType (%X): %w", unlockBlockType, cerrors.ErrParseBytesFailed)
+ return
+ }
+
+ unlockBlock = &AliasUnlockBlock{}
+ if unlockBlock.referencedIndex, err = marshalUtil.ReadUint16(); err != nil {
+ err = errors.Errorf("failed to parse referencedIndex (%v): %w", err, cerrors.ErrParseBytesFailed)
+ return
+ }
+ return
+}
+
+// AliasInputIndex returns the index of the input, the AliasOutput which contains AliasAddress
+func (r *AliasUnlockBlock) AliasInputIndex() uint16 {
+ return r.referencedIndex
+}
+
+// Type returns the UnlockBlockType of the UnlockBlock.
+func (r *AliasUnlockBlock) Type() UnlockBlockType {
+ return AliasUnlockBlockType
+}
+
+// Bytes returns a marshaled version of the UnlockBlock.
+func (r *AliasUnlockBlock) Bytes() []byte {
+ return marshalutil.New(1 + marshalutil.Uint16Size).
+ WriteByte(byte(AliasUnlockBlockType)).
+ WriteUint16(r.referencedIndex).
+ Bytes()
+}
+
+// String returns a human readable version of the UnlockBlock.
+func (r *AliasUnlockBlock) String() string {
+ return stringify.Struct("AliasUnlockBlock",
+ stringify.StructField("referencedIndex", int(r.referencedIndex)),
+ )
+}
+
+// code contract (make sure the type implements all required methods)
+var _ UnlockBlock = &AliasUnlockBlock{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/ledgerstate/utils.go b/packages/ledgerstate/utils.go
index 4ab6fd8dd1..e470902638 100644
--- a/packages/ledgerstate/utils.go
+++ b/packages/ledgerstate/utils.go
@@ -2,6 +2,8 @@ package ledgerstate
import (
"math"
+
+ "github.com/cockroachdb/errors"
)
// TransactionBalancesValid is an internal utility function that checks if the sum of the balance changes equals to 0.
@@ -49,20 +51,35 @@ func TransactionBalancesValid(inputs Outputs, outputs Outputs) (valid bool) {
// UnlockBlocksValid is an internal utility function that checks if the UnlockBlocks are matching the referenced Inputs.
func UnlockBlocksValid(inputs Outputs, transaction *Transaction) (valid bool) {
+ unlockValid, unlockErr := UnlockBlocksValidWithError(inputs, transaction)
+
+ return unlockValid && unlockErr == nil
+}
+
+// UnlockBlocksValidWithError is an internal utility function that checks if the UnlockBlocks are matching the referenced Inputs.
+// In case an unlockblock is invalid, it returns the error that caused it.
+func UnlockBlocksValidWithError(inputs Outputs, transaction *Transaction) (bool, error) {
unlockBlocks := transaction.UnlockBlocks()
+ cyclePresent, err := checkReferenceCycle(unlockBlocks)
+ if err != nil {
+ return false, errors.Errorf("unlock blocks are semantically invalid: %w", err)
+ }
+ if cyclePresent {
+ return false, errors.New("unlock blocks contain cyclic dependency, no signature present for an unlock path")
+ }
for i, input := range inputs {
currentUnlockBlock := unlockBlocks[i]
if currentUnlockBlock.Type() == ReferenceUnlockBlockType {
currentUnlockBlock = unlockBlocks[unlockBlocks[i].(*ReferenceUnlockBlock).ReferencedIndex()]
}
- unlockValid, unlockErr := input.UnlockValid(transaction, currentUnlockBlock)
+ unlockValid, unlockErr := input.UnlockValid(transaction, currentUnlockBlock, inputs)
if !unlockValid || unlockErr != nil {
- return false
+ return false, unlockErr
}
}
- return true
+ return true, nil
}
// SafeAddUint64 adds two uint64 values. It returns the result and a valid flag that indicates whether the addition is
@@ -80,3 +97,96 @@ func SafeSubUint64(a uint64, b uint64) (result uint64, valid bool) {
result = a - b
return
}
+
+// checkReferenceCycle builds a graph from the unlock block references and detects circular referencing. It returns an error
+// if unlock block references are semantically invalid.
+func checkReferenceCycle(blocks UnlockBlocks) (bool, error) {
+ // build graph
+ unlockGraph, err := NewUnlockGraph(blocks)
+ if err != nil {
+ return false, err
+ }
+ // check for cycle
+ return unlockGraph.IsCycleDetected(), nil
+}
+
+// UnlockGraph builds a graph from the references of the unlock blocks with the aim of detecting cycles.
+type UnlockGraph struct {
+ // Vertices are the unlock blocks themselves, identified by their index
+ // uint16 is enough
+ Vertices []uint16
+ // maps unlockBlock to referenced unlocked block
+ // each vertex has at most 1 referenced unlock block, so one outgoing edge
+ Edges map[uint16]uint16
+}
+
+// NewUnlockGraph creates a new UnlockGraph and checks semantic validity of the unlock block references.
+func NewUnlockGraph(blocks UnlockBlocks) (*UnlockGraph, error) {
+ if len(blocks) > MaxInputCount {
+ return nil, errors.Errorf("number of unlock blocks %d exceeds max input count %d", len(blocks), MaxInputCount)
+ }
+ g := &UnlockGraph{
+ Vertices: make([]uint16, len(blocks)),
+ Edges: make(map[uint16]uint16, len(blocks)),
+ }
+ for i, block := range blocks {
+ g.Vertices[i] = uint16(i)
+ switch block.Type() {
+ case SignatureUnlockBlockType:
+ // no adjacent vertex as a SignatureUnlockBlockType can't reference an other one
+ case ReferenceUnlockBlockType:
+ // a reference unlock block can not point to another reference unlock block
+ refIndex := block.(*ReferenceUnlockBlock).ReferencedIndex()
+ if blocks[refIndex].Type() == ReferenceUnlockBlockType {
+ return nil, errors.Errorf("reference unlock block %d points to another reference unlock block %d", i, refIndex)
+ }
+ g.Edges[uint16(i)] = refIndex
+ case AliasUnlockBlockType:
+ g.Edges[uint16(i)] = block.(*AliasUnlockBlock).AliasInputIndex()
+ default:
+ return nil, errors.Errorf("unknown unlock block type at index %d", i)
+ }
+ }
+ return g, nil
+}
+
+// IsCycleDetected checks if a cycle is detected by checking the dfs paths from every node.
+func (g *UnlockGraph) IsCycleDetected() bool {
+ visited := make([]bool, len(g.Vertices))
+ recursionStack := make([]bool, len(g.Vertices))
+
+ for _, node := range g.Vertices {
+ if !visited[node] {
+ // visit node
+ if g.dfs(node, visited, recursionStack) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// dfs does a depth-first traversal and looks for back edges (cycles).
+func (g *UnlockGraph) dfs(node uint16, visited []bool, recursionStack []bool) bool {
+ // mark current node visited
+ visited[node] = true
+ // add to recursion stack
+ recursionStack[node] = true
+
+ // recursively visit path from node
+ referenced, hasReferenced := g.Edges[node]
+ if hasReferenced {
+ if !visited[referenced] {
+ if g.dfs(referenced, visited, recursionStack) {
+ return true
+ }
+ } else if recursionStack[referenced] {
+ // we arrived at a cycle
+ return true
+ }
+ }
+
+ // pop node from recursion stack before return (backtracking)
+ recursionStack[node] = false
+ return false
+}
diff --git a/packages/ledgerstate/utxo_dag.go b/packages/ledgerstate/utxo_dag.go
index 24bab9daa8..0a5b225e7b 100644
--- a/packages/ledgerstate/utxo_dag.go
+++ b/packages/ledgerstate/utxo_dag.go
@@ -590,15 +590,13 @@ func (u *UTXODAG) bookConsumers(inputsMetadata OutputsMetadata, transactionID Tr
func (u *UTXODAG) bookOutputs(transaction *Transaction, targetBranch BranchID) {
for _, output := range transaction.Essence().Outputs() {
// replace ColorMint color with unique color based on OutputID
- if output.Type() == SigLockedColoredOutputType {
- output = output.(*SigLockedColoredOutput).UpdateMintingColor()
- }
+ updatedOutput := output.UpdateMintingColor()
// store Output
- u.outputStorage.Store(output).Release()
+ u.outputStorage.Store(updatedOutput).Release()
// store OutputMetadata
- metadata := NewOutputMetadata(output.ID())
+ metadata := NewOutputMetadata(updatedOutput.ID())
metadata.SetBranchID(targetBranch)
metadata.SetSolid(true)
u.outputMetadataStorage.Store(metadata).Release()
diff --git a/packages/ledgerstate/utxo_dag_test.go b/packages/ledgerstate/utxo_dag_test.go
index 39df6ee490..e98b21b3b0 100644
--- a/packages/ledgerstate/utxo_dag_test.go
+++ b/packages/ledgerstate/utxo_dag_test.go
@@ -786,6 +786,123 @@ func TestAddressOutputMapping(t *testing.T) {
assert.Equal(t, 1, len(res))
}
+func TestUTXODAG_CheckTransaction(t *testing.T) {
+ branchDAG, utxoDAG := setupDependencies(t)
+ defer branchDAG.Shutdown()
+ defer utxoDAG.Shutdown()
+
+ w := genRandomWallet()
+ governingWallet := genRandomWallet()
+ alias := &AliasOutput{
+ outputID: randOutputID(),
+ balances: NewColoredBalances(map[Color]uint64{ColorIOTA: DustThresholdAliasOutputIOTA}),
+ aliasAddress: *randAliasAddress(),
+ stateAddress: w.address, // alias state controller is our wallet
+ stateIndex: 10,
+ governingAddress: governingWallet.address,
+ }
+ nextAlias := alias.NewAliasOutputNext(false)
+ toBeConsumedExtended := NewExtendedLockedOutput(map[Color]uint64{ColorIOTA: 1}, alias.GetAliasAddress())
+ toBeConsumedExtended.SetID(randOutputID())
+ inputs := NewOutputs(alias, toBeConsumedExtended)
+ // book manually the outputs into utxoDAG
+ for _, output := range inputs {
+ // replace ColorMint color with unique color based on OutputID
+ output = output.UpdateMintingColor()
+
+ // store Output
+ utxoDAG.outputStorage.Store(output).Release()
+
+ // store OutputMetadata
+ metadata := NewOutputMetadata(output.ID())
+ metadata.SetBranchID(MasterBranchID)
+ metadata.SetSolid(true)
+ utxoDAG.outputMetadataStorage.Store(metadata).Release()
+ }
+
+ nextAliasBalance := alias.Balances().Map()
+ // add 1 more iota from consumed extended output
+ nextAliasBalance[ColorIOTA]++
+ err := nextAlias.SetBalances(nextAliasBalance)
+ assert.NoError(t, err)
+
+ essence := NewTransactionEssence(0, time.Now(), identity.ID{}, identity.ID{}, NewInputs(toBeConsumedExtended.Input(), alias.Input()), NewOutputs(nextAlias))
+ // which input index did the alias get?
+ var aliasInputIndex uint16
+ orderedInputs := make(Outputs, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ casted := input.(*UTXOInput)
+ if casted.ReferencedOutputID() == alias.ID() {
+ aliasInputIndex = uint16(i)
+ orderedInputs[i] = alias
+ }
+ if casted.ReferencedOutputID() == toBeConsumedExtended.ID() {
+ orderedInputs[i] = toBeConsumedExtended
+ }
+ }
+
+ t.Run("CASE: Happy path", func(t *testing.T) {
+ // create mapping from outputID to unlockBlock
+ inputToUnlockMapping := make(map[OutputID]UnlockBlock)
+ inputToUnlockMapping[alias.ID()] = NewSignatureUnlockBlock(w.sign(essence))
+ inputToUnlockMapping[toBeConsumedExtended.ID()] = NewAliasUnlockBlock(aliasInputIndex)
+
+ // fill unlock blocks
+ unlocks := make(UnlockBlocks, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ unlocks[i] = inputToUnlockMapping[input.(*UTXOInput).ReferencedOutputID()]
+ }
+
+ tx := NewTransaction(essence, unlocks)
+
+ bErr := utxoDAG.CheckTransaction(tx)
+ assert.NoError(t, bErr)
+ })
+
+ t.Run("CASE: Tx not okay, wrong signature", func(t *testing.T) {
+ // create mapping from outputID to unlockBlock
+ inputToUnlockMapping := make(map[OutputID]UnlockBlock)
+ inputToUnlockMapping[alias.ID()] = NewSignatureUnlockBlock(genRandomWallet().sign(essence))
+ inputToUnlockMapping[toBeConsumedExtended.ID()] = NewAliasUnlockBlock(aliasInputIndex)
+
+ // fill unlock blocks
+ unlocks := make(UnlockBlocks, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ unlocks[i] = inputToUnlockMapping[input.(*UTXOInput).ReferencedOutputID()]
+ }
+
+ tx := NewTransaction(essence, unlocks)
+
+ bErr := utxoDAG.CheckTransaction(tx)
+ t.Log(bErr)
+ assert.Error(t, bErr)
+ })
+
+ t.Run("CASE: Tx not okay, alias unlocked for governance", func(t *testing.T) {
+ // tx alias output will be unlocked for governance
+ nextAlias = alias.NewAliasOutputNext(true)
+ essence.outputs = NewOutputs(nextAlias, NewSigLockedSingleOutput(1, randEd25119Address()))
+
+ // create mapping from outputID to unlockBlock
+ inputToUnlockMapping := make(map[OutputID]UnlockBlock)
+ inputToUnlockMapping[alias.ID()] = NewSignatureUnlockBlock(governingWallet.sign(essence))
+ inputToUnlockMapping[toBeConsumedExtended.ID()] = NewAliasUnlockBlock(aliasInputIndex)
+
+ // fill unlock blocks
+ unlocks := make(UnlockBlocks, len(essence.Inputs()))
+ for i, input := range essence.Inputs() {
+ unlocks[i] = inputToUnlockMapping[input.(*UTXOInput).ReferencedOutputID()]
+ }
+
+ tx := NewTransaction(essence, unlocks)
+
+ bErr := utxoDAG.CheckTransaction(tx)
+ t.Log(bErr)
+ assert.Error(t, bErr)
+ })
+
+}
+
func setupDependencies(t *testing.T) (*BranchDAG, *UTXODAG) {
store := mapdb.NewMapDB()
branchDAG := NewBranchDAG(store)
diff --git a/packages/ledgerstate/utxodb/doc.go b/packages/ledgerstate/utxodb/doc.go
new file mode 100644
index 0000000000..afa77f9103
--- /dev/null
+++ b/packages/ledgerstate/utxodb/doc.go
@@ -0,0 +1,7 @@
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+// Package utxodb mocks Value Tangle ledger by implementing fully synchronous in-memory database
+// of Goshimmer value transactions. It ensures consistency of the ledger validity and all transactions
+// added to the UTXODB by checking inputs, outputs and signatures.
+package utxodb
diff --git a/packages/ledgerstate/utxodb/gendata_test.go b/packages/ledgerstate/utxodb/gendata_test.go
new file mode 100644
index 0000000000..d938ee3837
--- /dev/null
+++ b/packages/ledgerstate/utxodb/gendata_test.go
@@ -0,0 +1,22 @@
+package utxodb
+
+import (
+ "testing"
+
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "github.com/mr-tron/base58"
+ "github.com/stretchr/testify/assert"
+)
+
+func TestGenSeed(t *testing.T) {
+ seed := ed25519.NewSeed()
+ seedStr := base58.Encode(seed.Bytes())
+ t.Logf("seed: %s", seedStr)
+
+ seedBin, err := base58.Decode(seedStr)
+ assert.NoError(t, err)
+
+ seedRecover := ed25519.NewSeed(seedBin)
+ seedRecoverStr := base58.Encode(seedRecover.Bytes())
+ assert.EqualValues(t, seedStr, seedRecoverStr)
+}
diff --git a/packages/ledgerstate/utxodb/genesis.go b/packages/ledgerstate/utxodb/genesis.go
new file mode 100644
index 0000000000..07f0745d85
--- /dev/null
+++ b/packages/ledgerstate/utxodb/genesis.go
@@ -0,0 +1,146 @@
+package utxodb
+
+import (
+ "math/rand"
+ "sync"
+ "time"
+
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "github.com/iotaledger/hive.go/identity"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+const (
+ defaultSupplyInt = 2779530283000000
+ defaultSupply = uint64(defaultSupplyInt)
+ genesisIndex = 31415926535
+
+ // RequestFundsAmount is how many iotas are returned from the faucet
+ RequestFundsAmount = 1000000 // 1Mi
+)
+
+var essenceVersion = ledgerstate.TransactionEssenceVersion(0)
+
+// UtxoDB is the structure which contains all UTXODB transactions and ledger
+type UtxoDB struct {
+ seed *ed25519.Seed
+ supply uint64
+ genesisKeyPair *ed25519.KeyPair
+ genesisAddress ledgerstate.Address
+ transactions map[ledgerstate.TransactionID]*ledgerstate.Transaction
+ utxo map[ledgerstate.OutputID]ledgerstate.Output
+ consumedOutputs map[ledgerstate.OutputID]ledgerstate.Output
+ consumedBy map[ledgerstate.OutputID]ledgerstate.TransactionID
+ mutex *sync.RWMutex
+ genesisTxID ledgerstate.TransactionID
+}
+
+// New creates new UTXODB instance
+func newUtxodb(seed *ed25519.Seed, supply uint64, timestamp time.Time) *UtxoDB {
+ genesisKeyPair := seed.KeyPair(uint64(genesisIndex))
+ genesisAddress := ledgerstate.NewED25519Address(genesisKeyPair.PublicKey)
+ u := &UtxoDB{
+ seed: seed,
+ supply: supply,
+ genesisKeyPair: genesisKeyPair,
+ genesisAddress: genesisAddress,
+ transactions: make(map[ledgerstate.TransactionID]*ledgerstate.Transaction),
+ utxo: make(map[ledgerstate.OutputID]ledgerstate.Output),
+ consumedOutputs: make(map[ledgerstate.OutputID]ledgerstate.Output),
+ consumedBy: make(map[ledgerstate.OutputID]ledgerstate.TransactionID),
+ mutex: &sync.RWMutex{},
+ }
+ u.genesisInit(timestamp)
+ return u
+}
+
+// New creates new utxodb instance with predefined genesis seed and optional supply.
+// Supply defaults to the standard IOTA supply
+func New(supply ...uint64) *UtxoDB {
+ s := defaultSupply
+ if len(supply) > 0 {
+ s = supply[0]
+ }
+ return newUtxodb(ed25519.NewSeed([]byte("EFonzaUz5ngYeDxbRKu8qV5aoSogUQ5qVSTSjn7hJ8FQ")), s, time.Now())
+}
+
+func NewWithTimestamp(timestamp time.Time, supply ...uint64) *UtxoDB {
+ s := defaultSupply
+ if len(supply) > 0 {
+ s = supply[0]
+ }
+ return newUtxodb(ed25519.NewSeed([]byte("EFonzaUz5ngYeDxbRKu8qV5aoSogUQ5qVSTSjn7hJ8FQ")), s, timestamp)
+}
+
+// NewRandom creates utxodb with random genesis seed
+func NewRandom(supply ...uint64) *UtxoDB {
+ s := defaultSupply
+ if len(supply) > 0 {
+ s = supply[0]
+ }
+ var rnd [32]byte
+ rand.Read(rnd[:])
+ return newUtxodb(ed25519.NewSeed(rnd[:]), s, time.Now())
+}
+
+// NewKeyPairByIndex creates key pair and address generated from the seed and the index
+func (u *UtxoDB) NewKeyPairByIndex(index int) (*ed25519.KeyPair, *ledgerstate.ED25519Address) {
+ kp := u.seed.KeyPair(uint64(index))
+ return kp, ledgerstate.NewED25519Address(kp.PublicKey)
+}
+
+func (u *UtxoDB) genesisInit(timestamp time.Time) {
+ // create genesis transaction
+ inputs := ledgerstate.NewInputs(ledgerstate.NewUTXOInput(ledgerstate.NewOutputID(ledgerstate.TransactionID{}, 0)))
+ output := ledgerstate.NewSigLockedSingleOutput(defaultSupply, u.GetGenesisAddress())
+ outputs := ledgerstate.NewOutputs(output)
+ essence := ledgerstate.NewTransactionEssence(essenceVersion, timestamp, identity.ID{}, identity.ID{}, inputs, outputs)
+ signature := ledgerstate.NewED25519Signature(u.genesisKeyPair.PublicKey, u.genesisKeyPair.PrivateKey.Sign(essence.Bytes()))
+ unlockBlock := ledgerstate.NewSignatureUnlockBlock(signature)
+ genesisTx := ledgerstate.NewTransaction(essence, ledgerstate.UnlockBlocks{unlockBlock})
+
+ u.genesisTxID = genesisTx.ID()
+ u.transactions[u.genesisTxID] = genesisTx
+ u.utxo[output.ID()] = output.Clone()
+}
+
+func (u *UtxoDB) GenesisTransactionID() ledgerstate.TransactionID {
+ return u.genesisTxID
+}
+
+// GetGenesisKeyPair return signature scheme used by creator of genesis
+func (u *UtxoDB) GetGenesisKeyPair() *ed25519.KeyPair {
+ return u.genesisKeyPair
+}
+
+// GetGenesisAddress return address of genesis
+func (u *UtxoDB) GetGenesisAddress() ledgerstate.Address {
+ return u.genesisAddress
+}
+
+func (u *UtxoDB) mustRequestFundsTx(target ledgerstate.Address, timestamp time.Time) *ledgerstate.Transaction {
+ sourceOutputs := u.GetAddressOutputs(u.GetGenesisAddress())
+ if len(sourceOutputs) != 1 {
+ panic("number of genesis outputs must be 1")
+ }
+ reminder, _ := sourceOutputs[0].Balances().Get(ledgerstate.ColorIOTA)
+ o1 := ledgerstate.NewSigLockedSingleOutput(RequestFundsAmount, target)
+ o2 := ledgerstate.NewSigLockedSingleOutput(reminder-RequestFundsAmount, u.GetGenesisAddress())
+ outputs := ledgerstate.NewOutputs(o1, o2)
+ inputs := ledgerstate.NewInputs(ledgerstate.NewUTXOInput(sourceOutputs[0].ID()))
+ essence := ledgerstate.NewTransactionEssence(0, timestamp, identity.ID{}, identity.ID{}, inputs, outputs)
+ signature := ledgerstate.NewED25519Signature(u.genesisKeyPair.PublicKey, u.genesisKeyPair.PrivateKey.Sign(essence.Bytes()))
+ unlockBlocks := []ledgerstate.UnlockBlock{ledgerstate.NewSignatureUnlockBlock(signature)}
+ return ledgerstate.NewTransaction(essence, unlockBlocks)
+}
+
+// RequestFunds implements faucet: it sends 1337 IOTA tokens from genesis to the given address.
+func (u *UtxoDB) RequestFunds(target ledgerstate.Address, timestamp ...time.Time) (*ledgerstate.Transaction, error) {
+ t := time.Now()
+ if len(timestamp) > 0 {
+ t = timestamp[0]
+ }
+ tx := u.mustRequestFundsTx(target, t)
+ return tx, u.AddTransaction(tx)
+}
diff --git a/packages/ledgerstate/utxodb/utxodb.go b/packages/ledgerstate/utxodb/utxodb.go
new file mode 100644
index 0000000000..1ba86a4068
--- /dev/null
+++ b/packages/ledgerstate/utxodb/utxodb.go
@@ -0,0 +1,263 @@
+package utxodb
+
+import (
+ "golang.org/x/xerrors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// Supply returns supply of the instance
+func (u *UtxoDB) Supply() uint64 {
+ return u.supply
+}
+
+// IsConfirmed checks if the transaction is in the UTXODB ledger
+func (u *UtxoDB) IsConfirmed(txid *ledgerstate.TransactionID) bool {
+ u.mutex.Lock()
+ defer u.mutex.Unlock()
+ _, ok := u.transactions[*txid]
+ return ok
+}
+
+// GetOutput finds an output by ID (either spent or unspent)
+func (u *UtxoDB) GetOutput(outID ledgerstate.OutputID, f func(ledgerstate.Output)) bool {
+ out, ok := u.utxo[outID]
+ if ok {
+ f(out)
+ return true
+ }
+ out, ok = u.consumedOutputs[outID]
+ if ok {
+ f(out)
+ return true
+ }
+ return false
+}
+
+// GetOutputMetadata finds an output by ID and returns its (mocked) metadata
+func (u *UtxoDB) GetOutputMetadata(outID ledgerstate.OutputID, f func(*ledgerstate.OutputMetadata)) bool {
+ var out ledgerstate.Output
+ u.GetOutput(outID, func(o ledgerstate.Output) {
+ out = o
+ })
+ if out == nil {
+ return false
+ }
+ meta := ledgerstate.NewOutputMetadata(outID)
+ txID, consumed := u.consumedBy[outID]
+ if consumed {
+ meta.RegisterConsumer(txID)
+ }
+ meta.SetFinalized(true)
+ meta.SetSolid(true)
+ f(meta)
+ return true
+}
+
+// AddTransaction adds transaction to UTXODB or return an error.
+// The function ensures consistency of the UTXODB ledger
+func (u *UtxoDB) AddTransaction(tx *ledgerstate.Transaction) error {
+ u.mutex.Lock()
+ defer u.mutex.Unlock()
+
+ // serialize/deserialize for proper semantic check
+ tx, _, err := ledgerstate.TransactionFromBytes(tx.Bytes())
+ if err != nil {
+ return err
+ }
+ if err := u.CheckNewTransaction(tx, false); err != nil {
+ return err
+ }
+ // delete consumed (referenced) outputs from the ledger
+ for _, inp := range tx.Essence().Inputs() {
+ utxoInp := inp.(*ledgerstate.UTXOInput)
+
+ consumed, ok := u.findUnspentOutputByID(utxoInp.ReferencedOutputID())
+ if !ok {
+ return xerrors.Errorf("deleting UTXO: corresponding output does not exists: %s", utxoInp.ReferencedOutputID().String())
+ }
+ delete(u.utxo, utxoInp.ReferencedOutputID())
+ u.consumedOutputs[utxoInp.ReferencedOutputID()] = consumed
+ u.consumedBy[utxoInp.ReferencedOutputID()] = tx.ID()
+ }
+ // add outputs to the ledger
+ for _, out := range tx.Essence().Outputs() {
+ if out.ID().TransactionID() != tx.ID() {
+ panic("utxodb.AddTransaction: incorrect output ID")
+ }
+ u.utxo[out.ID()] = out.UpdateMintingColor()
+ }
+ u.transactions[tx.ID()] = tx
+ u.checkLedgerBalance()
+ return nil
+}
+
+// GetTransaction retrieves value transaction by its hash (ID)
+func (u *UtxoDB) GetTransaction(id ledgerstate.TransactionID) (*ledgerstate.Transaction, bool) {
+ u.mutex.RLock()
+ defer u.mutex.RUnlock()
+
+ return u.getTransaction(id)
+}
+
+// MustGetTransaction same as GetTransaction only panics if transaction is not in UTXODB
+func (u *UtxoDB) MustGetTransaction(id ledgerstate.TransactionID) *ledgerstate.Transaction {
+ u.mutex.RLock()
+ defer u.mutex.RUnlock()
+ return u.mustGetTransaction(id)
+}
+
+// GetAddressOutputs returns unspent outputs contained in the address
+func (u *UtxoDB) GetAddressOutputs(addr ledgerstate.Address) []ledgerstate.Output {
+ u.mutex.RLock()
+ defer u.mutex.RUnlock()
+
+ return u.getAddressOutputs(addr)
+}
+
+// GetAddressBalances return all colored balances of the address
+func (u *UtxoDB) GetAddressBalances(addr ledgerstate.Address) map[ledgerstate.Color]uint64 {
+ ret := make(map[ledgerstate.Color]uint64)
+ outputs := u.GetAddressOutputs(addr)
+ for _, out := range outputs {
+ out.Balances().ForEach(func(col ledgerstate.Color, bal uint64) bool {
+ s := ret[col]
+ ret[col] = s + bal
+ return true
+ })
+ }
+ return ret
+}
+
+// Balance returns balances of specific color
+func (u *UtxoDB) Balance(addr ledgerstate.Address, color ledgerstate.Color) uint64 {
+ bals := u.GetAddressBalances(addr)
+ ret := bals[color]
+ return ret
+}
+
+// BalanceIOTA number of iotas in the address
+func (u *UtxoDB) BalanceIOTA(addr ledgerstate.Address) uint64 {
+ return u.Balance(addr, ledgerstate.ColorIOTA)
+}
+
+// CollectUnspentOutputsFromInputs returns unspent outputs by inputs of the transaction
+func (u *UtxoDB) CollectUnspentOutputsFromInputs(essence *ledgerstate.TransactionEssence) ([]ledgerstate.Output, error) {
+ u.mutex.RLock()
+ defer u.mutex.RUnlock()
+
+ return u.collectUnspentOutputsFromInputs(essence)
+}
+
+// CheckNewTransaction checks consistency of the transaction the same way as ledgerstate
+func (u *UtxoDB) CheckNewTransaction(tx *ledgerstate.Transaction, lock ...bool) error {
+ if len(lock) > 0 && lock[0] {
+ u.mutex.RLock()
+ defer u.mutex.RUnlock()
+ }
+ inputs, err := u.collectUnspentOutputsFromInputs(tx.Essence())
+ if err != nil {
+ return err
+ }
+ if !ledgerstate.TransactionBalancesValid(inputs, tx.Essence().Outputs()) {
+ return xerrors.Errorf("sum of consumed and spent balances is not 0")
+ }
+ if ok, err := ledgerstate.UnlockBlocksValidWithError(inputs, tx); !ok || err != nil {
+ return xerrors.Errorf("CheckNewTransaction: input unlocking failed: %v", err)
+ }
+ return nil
+}
+
+// GetAliasOutputs collects all outputs of type ledgerstate.AliasOutput for the transaction
+func (u *UtxoDB) GetAliasOutputs(addr ledgerstate.Address) []*ledgerstate.AliasOutput {
+ outs := u.GetAddressOutputs(addr)
+ ret := make([]*ledgerstate.AliasOutput, 0)
+ for _, out := range outs {
+ if o, ok := out.(*ledgerstate.AliasOutput); ok {
+ ret = append(ret, o)
+ }
+ }
+ return ret
+}
+
+// findUnspentOutputByID returns unspent output with existence flag
+func (u *UtxoDB) findUnspentOutputByID(id ledgerstate.OutputID) (ledgerstate.Output, bool) {
+ if out, ok := u.utxo[id]; ok {
+ return out, true
+ }
+ return nil, false
+}
+
+func (u *UtxoDB) getTransaction(id ledgerstate.TransactionID) (*ledgerstate.Transaction, bool) {
+ tx, ok := u.transactions[id]
+ return tx, ok
+}
+
+func (u *UtxoDB) mustGetTransaction(id ledgerstate.TransactionID) *ledgerstate.Transaction {
+ tx, ok := u.transactions[id]
+ if !ok {
+ panic(xerrors.Errorf("utxodb.mustGetTransaction: tx id doesn't exist: %s", id.String()))
+ }
+ return tx
+}
+
+func (u *UtxoDB) getAddressOutputs(addr ledgerstate.Address) []ledgerstate.Output {
+ addrArr := addr.Array()
+ ret := make([]ledgerstate.Output, 0)
+ for _, out := range u.utxo {
+ if out.Address().Array() == addrArr {
+ ret = append(ret, out)
+ }
+ }
+ return ret
+}
+
+func (u *UtxoDB) getOutputTotal(outid ledgerstate.OutputID) (uint64, error) {
+ out, ok := u.utxo[outid]
+ if !ok {
+ return 0, xerrors.Errorf("getOutputTotal: no such output: %s", outid.String())
+ }
+ ret := uint64(0)
+ out.Balances().ForEach(func(_ ledgerstate.Color, bal uint64) bool {
+ ret += bal
+ return true
+ })
+ return ret, nil
+}
+
+func (u *UtxoDB) checkLedgerBalance() {
+ total := uint64(0)
+ for outp := range u.utxo {
+ b, err := u.getOutputTotal(outp)
+ if err != nil {
+ panic("utxodb: wrong ledger balance: " + err.Error())
+ }
+ total += b
+ }
+ if total != defaultSupply {
+ panic("utxodb: wrong ledger balance")
+ }
+}
+
+func (u *UtxoDB) collectUnspentOutputsFromInputs(essence *ledgerstate.TransactionEssence) ([]ledgerstate.Output, error) {
+ ret := make([]ledgerstate.Output, len(essence.Inputs()))
+ for i, inp := range essence.Inputs() {
+ if inp.Type() != ledgerstate.UTXOInputType {
+ return nil, xerrors.New("CollectUnspentOutputsFromInputs: wrong input type")
+ }
+ utxoInp := inp.(*ledgerstate.UTXOInput)
+ var ok bool
+ oid := utxoInp.ReferencedOutputID()
+ if ret[i], ok = u.findUnspentOutputByID(oid); !ok {
+ return nil, xerrors.Errorf("CollectUnspentOutputsFromInputs: unspent output does not exist: %s", oid.String())
+ }
+ otx, ok := u.getTransaction(oid.TransactionID())
+ if !ok {
+ return nil, xerrors.Errorf("CollectUnspentOutputsFromInputs: input transaction not found: %s", oid.TransactionID())
+ }
+ if essence.Timestamp().Before(otx.Essence().Timestamp()) {
+ return nil, xerrors.Errorf("CollectUnspentOutputsFromInputs: transaction timestamp is before input timestamp: %s", oid.TransactionID())
+ }
+ }
+ return ret, nil
+}
diff --git a/packages/ledgerstate/utxodb/utxodb_test.go b/packages/ledgerstate/utxodb/utxodb_test.go
new file mode 100644
index 0000000000..d1efec75da
--- /dev/null
+++ b/packages/ledgerstate/utxodb/utxodb_test.go
@@ -0,0 +1,101 @@
+package utxodb
+
+import (
+ "testing"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestBasic(t *testing.T) {
+ u := New()
+ genTx, ok := u.GetTransaction(u.genesisTxID)
+ require.True(t, ok)
+ require.EqualValues(t, genTx.ID(), u.genesisTxID)
+}
+
+func TestGenesis(t *testing.T) {
+ u := New()
+ require.EqualValues(t, u.Supply(), u.BalanceIOTA(u.GetGenesisAddress()))
+ u.checkLedgerBalance()
+}
+
+func TestRequestFunds(t *testing.T) {
+ u := New()
+ _, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, RequestFundsAmount, u.BalanceIOTA(addr))
+ u.checkLedgerBalance()
+}
+
+func TestAddTransactionFail(t *testing.T) {
+ u := New()
+
+ _, addr := u.NewKeyPairByIndex(2)
+ tx, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, RequestFundsAmount, u.BalanceIOTA(addr))
+ u.checkLedgerBalance()
+ err = u.AddTransaction(tx)
+ require.Error(t, err)
+ u.checkLedgerBalance()
+}
+
+func TestGetOutput(t *testing.T) {
+ u := New()
+ originOutputID := ledgerstate.NewOutputID(u.GenesisTransactionID(), 0)
+
+ succ := u.GetOutputMetadata(originOutputID, func(metadata *ledgerstate.OutputMetadata) {
+ require.EqualValues(t, 0, metadata.ConsumerCount())
+ })
+ require.True(t, succ)
+
+ _, addr := u.NewKeyPairByIndex(2)
+ tx, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, RequestFundsAmount, u.BalanceIOTA(addr))
+ u.checkLedgerBalance()
+
+ succ = u.GetOutputMetadata(originOutputID, func(metadata *ledgerstate.OutputMetadata) {
+ require.EqualValues(t, 1, metadata.ConsumerCount())
+ })
+ require.True(t, succ)
+
+ outid0 := ledgerstate.NewOutputID(tx.ID(), 0)
+ outid1 := ledgerstate.NewOutputID(tx.ID(), 1)
+ outidFail := ledgerstate.NewOutputID(tx.ID(), 5)
+
+ var out0, out1 ledgerstate.Output
+ succ = u.GetOutput(outid0, func(output ledgerstate.Output) {
+ out0 = output
+ })
+ require.True(t, succ)
+ bal, ok := out0.Balances().Get(ledgerstate.ColorIOTA)
+ require.True(t, ok)
+ require.EqualValues(t, RequestFundsAmount, bal)
+
+ succ = u.GetOutput(outid1, func(output ledgerstate.Output) {
+ out1 = output
+ })
+ require.True(t, succ)
+ bal, ok = out1.Balances().Get(ledgerstate.ColorIOTA)
+ require.True(t, ok)
+ require.EqualValues(t, u.Supply()-RequestFundsAmount, bal)
+
+ require.NotPanics(t, func() {
+ succ = u.GetOutput(outidFail, nil)
+ })
+ require.False(t, succ)
+
+ succ = u.GetOutputMetadata(outid0, func(metadata *ledgerstate.OutputMetadata) {
+ require.True(t, metadata.Finalized())
+ require.True(t, metadata.Solid())
+ require.Equal(t, 0, metadata.ConsumerCount())
+ })
+ require.True(t, succ)
+}
diff --git a/packages/ledgerstate/utxotest/alias_test.go b/packages/ledgerstate/utxotest/alias_test.go
new file mode 100644
index 0000000000..db36acc586
--- /dev/null
+++ b/packages/ledgerstate/utxotest/alias_test.go
@@ -0,0 +1,483 @@
+package utxotest
+
+import (
+ "fmt"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/ledgerstate/utxodb"
+ "github.com/iotaledger/goshimmer/packages/ledgerstate/utxoutil"
+)
+
+func TestAliasMint(t *testing.T) {
+ u := utxodb.NewRandom()
+ user, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr))
+
+ _, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ outputs := u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+ require.True(t, chained.IsOrigin())
+ require.EqualValues(t, chained.ID().TransactionID(), tx.ID())
+
+ t.Logf("Chained output: %s", chained)
+ t.Logf("newly created alias address: %s", chained.GetAliasAddress().Base58())
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+}
+
+func TestChainForkFail(t *testing.T) {
+ u := utxodb.NewRandom()
+ user, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr))
+
+ userStateControl, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ // mint chain output
+ outputs := u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ // determine newly created alias address
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+ require.EqualValues(t, 0, int(chained.GetStateIndex()))
+
+ aliasAddress := chained.GetAliasAddress()
+ t.Logf("newly created alias address: %s", aliasAddress.Base58())
+
+ // add some 200 iotas to newly minted alias
+ outputs = u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.AddExtendedOutputConsume(aliasAddress, nil, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 200})
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(user)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-300, int(u.BalanceIOTA(addr)))
+ require.EqualValues(t, 300, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ // create transaction with forked alias output
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 2, len(outputs))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ // create first alias output
+ err = txb.ConsumeAliasInput(aliasAddress)
+ require.NoError(t, err)
+ err = txb.AddAliasOutputAsRemainder(aliasAddress, nil)
+ require.NoError(t, err)
+
+ // create another identical and modify slightly with adding dummy data
+ // This creates forked chain
+ chainedFork, err := txb.AliasNextChainedOutput(aliasAddress)
+ require.NoError(t, err)
+ err = chainedFork.SetStateData([]byte("qq"))
+ require.NoError(t, err)
+
+ succ := txb.ConsumeAmounts(chainedFork.Balances().Map())
+ require.True(t, succ)
+ err = txb.AddOutputAndSpendUnspent(chainedFork)
+ require.NoError(t, err)
+
+ err = txb.AddRemainderOutputIfNeeded(aliasAddress, nil)
+ require.NoError(t, err)
+
+ tx, err = txb.BuildWithED25519(userStateControl)
+ require.NoError(t, err)
+
+ // adding forked chain must fail
+ err = u.AddTransaction(tx)
+ require.Error(t, err)
+}
+
+const chainLength = 10
+
+func TestAlias1(t *testing.T) {
+ u := utxodb.NewRandom()
+ user, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr))
+
+ userStateControl, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ outputs := u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ // mint chain output
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+ require.True(t, chained.IsOrigin())
+
+ aliasAddress := chained.GetAliasAddress()
+ t.Logf("newly created alias address: %s", aliasAddress.Base58())
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-100, int(u.BalanceIOTA(addr)))
+ require.EqualValues(t, 100, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ for i := 0; i < chainLength; i++ {
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 1, len(outputs))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.ConsumeAliasInput(aliasAddress)
+ require.NoError(t, err)
+ err = txb.AddAliasOutputAsRemainder(aliasAddress, nil)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(userStateControl)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.False(t, chained.IsOrigin())
+ require.True(t, chained.GetAliasAddress().Equals(aliasAddress))
+ require.True(t, chained.GetStateAddress().Equals(addrStateControl))
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(aliasAddress))
+
+ require.EqualValues(t, 100, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+ }
+}
+
+func TestAlias3(t *testing.T) {
+ u := utxodb.NewRandom()
+ user, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr))
+
+ userStateControl, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ outputs := u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ // mint chain output
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+
+ aliasAddress := chained.GetAliasAddress()
+ t.Logf("newly created alias address: %s", aliasAddress.Base58())
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-100, int(u.BalanceIOTA(addr)))
+ require.EqualValues(t, 100, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ for i := 0; i < chainLength; i++ {
+ outputs = u.GetAddressOutputs(addr)
+ // transfer 1 more iota to alias address
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddExtendedOutputConsume(aliasAddress, nil, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 1})
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ // continue chain without consuming ExtendedOutputs
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 1+i+1, len(outputs))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.ConsumeAliasInput(aliasAddress)
+ require.NoError(t, err)
+ err = txb.AddAliasOutputAsRemainder(aliasAddress, nil)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(userStateControl)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err = utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(aliasAddress))
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.EqualValues(t, i+1, int(chained.GetStateIndex()))
+
+ require.EqualValues(t, 100+i+1, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+ }
+}
+
+func TestAliasWithExtendedOutput(t *testing.T) {
+ u := utxodb.NewRandom()
+ user, addr := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addr)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr))
+
+ userStateControl, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ outputs := u.GetAddressOutputs(addr)
+ require.EqualValues(t, 1, len(outputs))
+
+ // mint chain output
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+
+ aliasAddress := chained.GetAliasAddress()
+ t.Logf("newly created alias address: %s", aliasAddress.Base58())
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-100, int(u.BalanceIOTA(addr)))
+ require.EqualValues(t, 100, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ for i := 0; i < chainLength; i++ {
+ // transfer 1 more iota to alias address
+ outputs = u.GetAddressOutputs(addr)
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.AddExtendedOutputConsume(aliasAddress, nil, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 1})
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr))
+
+ // continue chain with consuming ExtendedOutput
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 2, len(outputs))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.ConsumeAliasInput(aliasAddress)
+ require.NoError(t, err)
+ err = txb.AddAliasOutputAsRemainder(aliasAddress, nil, true)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(userStateControl)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err = utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(aliasAddress))
+
+ require.EqualValues(t, 100+i+1, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+ }
+}
+
+func TestRequestSendingPattern(t *testing.T) {
+ u := utxodb.NewRandom()
+ userRequester, addrRequester := u.NewKeyPairByIndex(2)
+ _, err := u.RequestFunds(addrRequester)
+ require.NoError(t, err)
+ require.EqualValues(t, u.Supply()-utxodb.RequestFundsAmount, u.BalanceIOTA(u.GetGenesisAddress()))
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addrRequester))
+
+ // start chain with 100 iotas on it
+ userStateControl, addrStateControl := u.NewKeyPairByIndex(3)
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ require.NoError(t, err)
+
+ outputs := u.GetAddressOutputs(addrRequester)
+ require.EqualValues(t, 1, len(outputs))
+
+ // mint chain output
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(bals1, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addrRequester, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(userRequester)
+ require.NoError(t, err)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addrRequester))
+
+ chained, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ require.NotNil(t, chained)
+
+ aliasAddress := chained.GetAliasAddress()
+ t.Logf("newly created alias address: %s", aliasAddress.Base58())
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-100, int(u.BalanceIOTA(addrRequester)))
+ require.EqualValues(t, 100, u.BalanceIOTA(aliasAddress))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ const numRequests = 10
+ for i := 0; i < numRequests; i++ {
+ // send request with 1 iota and some data to alias address
+ outputs = u.GetAddressOutputs(addrRequester)
+ txb = utxoutil.NewBuilder(outputs...)
+ data := []byte(fmt.Sprintf("#%d", i))
+ err = txb.AddExtendedOutputConsume(aliasAddress, data, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 1})
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addrRequester, nil)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(userRequester)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err = utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addrRequester))
+ }
+ // continue chain with consuming ExtendedOutput
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 1+numRequests, len(outputs))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+ require.EqualValues(t, 100+numRequests, int(u.BalanceIOTA(aliasAddress)))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.ConsumeAliasInput(aliasAddress)
+ require.NoError(t, err)
+ err = txb.AddAliasOutputAsRemainder(aliasAddress, nil, true)
+ require.NoError(t, err)
+
+ tx, err = txb.BuildWithED25519(userStateControl)
+ require.NoError(t, err)
+ //
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err = utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(aliasAddress))
+
+ require.EqualValues(t, 100+numRequests, int(u.BalanceIOTA(aliasAddress)))
+ require.EqualValues(t, 0, u.BalanceIOTA(addrStateControl))
+
+ outputs = u.GetAddressOutputs(aliasAddress)
+ require.EqualValues(t, 1, len(outputs))
+}
diff --git a/packages/ledgerstate/utxotest/outputs_test.go b/packages/ledgerstate/utxotest/outputs_test.go
new file mode 100644
index 0000000000..70f900c234
--- /dev/null
+++ b/packages/ledgerstate/utxotest/outputs_test.go
@@ -0,0 +1,183 @@
+package utxotest
+
+import (
+ "bytes"
+ "testing"
+
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "github.com/stretchr/testify/require"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+func TestAliasOutputMint(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ _, err := ledgerstate.NewAliasOutputMint(bals1, nil)
+ require.Error(t, err)
+
+ bals0 := map[ledgerstate.Color]uint64{}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ _, err = ledgerstate.NewAliasOutputMint(bals0, addr)
+ require.Error(t, err)
+
+ _, err = ledgerstate.NewAliasOutputMint(bals1, addr)
+ require.NoError(t, err)
+
+ bigData := make([]byte, ledgerstate.MaxOutputPayloadSize+1)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr)
+ require.NoError(t, err)
+ err = out.SetStateData(bigData)
+ require.Error(t, err)
+
+ out, err = ledgerstate.NewAliasOutputMint(bals1, addr)
+ require.NoError(t, err)
+ require.True(t, out.IsSelfGoverned())
+ out.SetGoverningAddress(addr)
+ require.True(t, out.IsSelfGoverned())
+
+ out, err = ledgerstate.NewAliasOutputMint(bals1, addr, []byte("dummy"))
+ require.NoError(t, err)
+ require.True(t, out.IsSelfGoverned())
+ out.SetGoverningAddress(addr)
+ require.True(t, out.IsSelfGoverned())
+ require.EqualValues(t, "dummy", string(out.GetImmutableData()))
+
+ t.Logf("%s", out)
+}
+
+func TestAliasOutputMarshal1(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr)
+ require.NoError(t, err)
+
+ data := out.Bytes()
+ outBack, _, err := ledgerstate.OutputFromBytes(data)
+ require.NoError(t, err)
+
+ require.EqualValues(t, ledgerstate.AliasAddressType, outBack.Type())
+ _, ok := outBack.(*ledgerstate.AliasOutput)
+ require.True(t, ok)
+
+ require.Zero(t, out.Compare(outBack))
+}
+
+func TestAliasOutputMarshal2(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp1 := ed25519.GenerateKeyPair()
+ addr1 := ledgerstate.NewED25519Address(kp1.PublicKey)
+ kp2 := ed25519.GenerateKeyPair()
+ addr2 := ledgerstate.NewED25519Address(kp2.PublicKey)
+
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr1)
+ require.NoError(t, err)
+ require.True(t, out.IsSelfGoverned())
+ out.SetGoverningAddress(addr2)
+ require.False(t, out.IsSelfGoverned())
+
+ data := out.Bytes()
+ outBack, _, err := ledgerstate.OutputFromBytes(data)
+ require.NoError(t, err)
+
+ require.EqualValues(t, ledgerstate.AliasAddressType, outBack.Type())
+ _, ok := outBack.(*ledgerstate.AliasOutput)
+ require.True(t, ok)
+
+ require.Zero(t, out.Compare(outBack))
+}
+
+func TestAliasOutputMarshal3(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr)
+ out.SetGoverningAddress(addr)
+ require.NoError(t, err)
+ err = out.SetStateData([]byte("dummy..."))
+ require.NoError(t, err)
+
+ data := out.Bytes()
+ outBack, _, err := ledgerstate.OutputFromBytes(data)
+ require.NoError(t, err)
+
+ require.EqualValues(t, ledgerstate.AliasAddressType, outBack.Type())
+ _, ok := outBack.(*ledgerstate.AliasOutput)
+ require.True(t, ok)
+
+ require.Zero(t, out.Compare(outBack))
+}
+
+func TestAliasOutputMarshal4(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr, []byte("dummy NFT..."))
+ out.SetGoverningAddress(addr)
+ require.NoError(t, err)
+ err = out.SetStateData([]byte("dummy state..."))
+ require.NoError(t, err)
+
+ data := out.Bytes()
+ outBack, _, err := ledgerstate.OutputFromBytes(data)
+ require.NoError(t, err)
+
+ require.EqualValues(t, ledgerstate.AliasAddressType, outBack.Type())
+ _, ok := outBack.(*ledgerstate.AliasOutput)
+ require.True(t, ok)
+
+ require.Zero(t, out.Compare(outBack))
+}
+
+func TestStateTransition1(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr)
+ require.NoError(t, err)
+
+ oid := ledgerstate.NewOutputID(ledgerstate.TransactionID{}, 42)
+ out.SetID(oid)
+ out.SetAliasAddress(out.GetAliasAddress())
+
+ outNext := out.NewAliasOutputNext()
+
+ require.Zero(t, bytes.Compare(out.GetAliasAddress().Bytes(), outNext.GetAliasAddress().Bytes()))
+ outNext1, _, err := ledgerstate.OutputFromBytes(outNext.Bytes())
+ require.NoError(t, err)
+ require.Zero(t, outNext.Compare(outNext1))
+ require.Zero(t, bytes.Compare(outNext.Bytes(), outNext1.Bytes()))
+}
+
+func TestStateTransition2(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+ out, err := ledgerstate.NewAliasOutputMint(bals1, addr, []byte("dummy NFT"))
+ require.NoError(t, err)
+
+ oid := ledgerstate.NewOutputID(ledgerstate.TransactionID{}, 42)
+ out.SetID(oid)
+ out.SetAliasAddress(out.GetAliasAddress())
+
+ outNext := out.NewAliasOutputNext()
+
+ require.Zero(t, bytes.Compare(out.GetAliasAddress().Bytes(), outNext.GetAliasAddress().Bytes()))
+ outNext1, _, err := ledgerstate.OutputFromBytes(outNext.Bytes())
+ require.NoError(t, err)
+ require.Zero(t, outNext.Compare(outNext1))
+ require.Zero(t, bytes.Compare(outNext.Bytes(), outNext1.Bytes()))
+ require.EqualValues(t, "dummy NFT", string(outNext.GetImmutableData()))
+}
+
+func TestExtendedOutput(t *testing.T) {
+ bals1 := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100}
+ kp := ed25519.GenerateKeyPair()
+ addr := ledgerstate.NewED25519Address(kp.PublicKey)
+
+ out := ledgerstate.NewExtendedLockedOutput(bals1, addr)
+ outBack, _, err := ledgerstate.OutputFromBytes(out.Bytes())
+ require.NoError(t, err)
+ require.Zero(t, outBack.Compare(out))
+}
diff --git a/packages/ledgerstate/utxotest/siglock_test.go b/packages/ledgerstate/utxotest/siglock_test.go
new file mode 100644
index 0000000000..130c2e604e
--- /dev/null
+++ b/packages/ledgerstate/utxotest/siglock_test.go
@@ -0,0 +1,214 @@
+package utxotest
+
+import (
+ "testing"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate/utxodb"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate/utxoutil"
+)
+
+func TestSendIotas(t *testing.T) {
+ u := utxodb.New()
+ user1, addr1 := u.NewKeyPairByIndex(1)
+ _, err := u.RequestFunds(addr1)
+ require.NoError(t, err)
+
+ _, addr2 := u.NewKeyPairByIndex(2)
+
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ outputs := u.GetAddressOutputs(addr1)
+ require.EqualValues(t, 1, len(outputs))
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr2, 42)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr1, nil)
+ require.NoError(t, err)
+
+ tx, err := txb.BuildWithED25519(user1)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-42, u.BalanceIOTA(addr1))
+ require.EqualValues(t, 42, u.BalanceIOTA(addr2))
+}
+
+const howMany = uint64(42)
+
+func TestSendIotasMany(t *testing.T) {
+ u := utxodb.New()
+ user1, addr1 := u.NewKeyPairByIndex(1)
+ _, err := u.RequestFunds(addr1)
+ require.NoError(t, err)
+
+ _, addr2 := u.NewKeyPairByIndex(2)
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ for i := uint64(0); i < howMany; i++ {
+ outputs := u.GetAddressOutputs(addr1)
+ require.EqualValues(t, 1, len(outputs))
+ txb := utxoutil.NewBuilder(outputs...)
+
+ err = txb.AddSigLockedIOTAOutput(addr2, 1)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr1, nil)
+ require.NoError(t, err)
+
+ tx, err1 := txb.BuildWithED25519(user1)
+ require.NoError(t, err1)
+
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err2 := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err2)
+ require.True(t, addr1.Equals(sender))
+ }
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany, u.BalanceIOTA(addr2))
+}
+
+func TestSendIotas1FromMany(t *testing.T) {
+ u := utxodb.New()
+ user1, addr1 := u.NewKeyPairByIndex(1)
+ _, err := u.RequestFunds(addr1)
+ require.NoError(t, err)
+
+ user2, addr2 := u.NewKeyPairByIndex(2)
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ const outputAmount = 5
+
+ for i := uint64(0); i < howMany; i++ {
+ outputs := u.GetAddressOutputs(addr1)
+ require.EqualValues(t, 1, len(outputs))
+
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr2, outputAmount)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr1, nil)
+ require.NoError(t, err)
+
+ tx, bErr := txb.BuildWithED25519(user1)
+ require.NoError(t, bErr)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, sErr := utxoutil.GetSingleSender(tx)
+ require.NoError(t, sErr)
+ require.True(t, sender.Equals(addr1))
+ }
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany*outputAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany*outputAmount, u.BalanceIOTA(addr2))
+
+ // transfer 1 back
+ outputs := u.GetAddressOutputs(addr2)
+ require.EqualValues(t, howMany, len(outputs))
+
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr1, outputAmount)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr2, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user2)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany*outputAmount+outputAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany*outputAmount-outputAmount, u.BalanceIOTA(addr2))
+
+ // transfer 3 more back
+ outputs = u.GetAddressOutputs(addr2)
+ require.EqualValues(t, howMany-1, len(outputs))
+
+ txb = utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr1, 3)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr2, nil)
+ require.NoError(t, err)
+ tx, err = txb.BuildWithED25519(user2)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err = utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany*outputAmount+outputAmount+3, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany*outputAmount-outputAmount-3, u.BalanceIOTA(addr2))
+}
+
+func TestSendIotasManyFromMany(t *testing.T) {
+ u := utxodb.New()
+ user1, addr1 := u.NewKeyPairByIndex(1)
+ _, err := u.RequestFunds(addr1)
+ require.NoError(t, err)
+
+ user2, addr2 := u.NewKeyPairByIndex(2)
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, 0, u.BalanceIOTA(addr2))
+
+ const outputAmount = 5
+
+ for i := uint64(0); i < howMany; i++ {
+ outputs := u.GetAddressOutputs(addr1)
+ require.EqualValues(t, 1, len(outputs))
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr2, outputAmount)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr1, nil)
+ require.NoError(t, err)
+ tx, err1 := txb.BuildWithED25519(user1)
+ require.NoError(t, err1)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err2 := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err2)
+ require.True(t, sender.Equals(addr1))
+ }
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany*outputAmount, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany*outputAmount, u.BalanceIOTA(addr2))
+
+ outputs := u.GetAddressOutputs(addr2)
+ require.EqualValues(t, howMany, len(outputs))
+
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddSigLockedIOTAOutput(addr1, howMany*outputAmount/2)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(user2)
+ require.NoError(t, err)
+ err = u.AddTransaction(tx)
+ require.NoError(t, err)
+
+ sender, err := utxoutil.GetSingleSender(tx)
+ require.NoError(t, err)
+ require.True(t, sender.Equals(addr2))
+
+ require.EqualValues(t, utxodb.RequestFundsAmount-howMany*outputAmount/2, u.BalanceIOTA(addr1))
+ require.EqualValues(t, howMany*outputAmount/2, u.BalanceIOTA(addr2))
+
+ outputs = u.GetAddressOutputs(addr2)
+ require.EqualValues(t, int(howMany/2), len(outputs))
+}
diff --git a/packages/ledgerstate/utxoutil/build.go b/packages/ledgerstate/utxoutil/build.go
new file mode 100644
index 0000000000..0c6075791b
--- /dev/null
+++ b/packages/ledgerstate/utxoutil/build.go
@@ -0,0 +1,452 @@
+package utxoutil
+
+import (
+ "time"
+
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "github.com/iotaledger/hive.go/identity"
+ "golang.org/x/xerrors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// Builder builder implements a structure and interface to build transactions
+// Initial input is a list of outputs which can be used as consumable inputs
+// Balances are tracked by "consuming" tokens from inputs and then "spending" them to outputs
+// "consuming" tokens from inputs means:
+// - tracking "remaining" part of tokens in each consumable output
+// - placing consumed token into the "consumedUnspent"
+// - By SpendConsumedUnspent all tokens are cleared from "consumedUnspent" and can be used as a token payload to
+// the output
+type Builder struct {
+ version ledgerstate.TransactionEssenceVersion
+ accessPledgeID identity.ID
+ consensusPledgeID identity.ID
+ timestamp time.Time
+ // tracks remaining tokens for each consumable output
+ consumables []*ConsumableOutput
+ outputs []ledgerstate.Output
+ // buffer of consumed but unspent yet tokens
+ consumedUnspent map[ledgerstate.Color]uint64
+}
+
+// NewBuilder creates new builder for outputs
+func NewBuilder(inputs ...ledgerstate.Output) *Builder {
+ ret := &Builder{
+ timestamp: time.Now(),
+ consumables: make([]*ConsumableOutput, len(inputs)),
+ outputs: make([]ledgerstate.Output, 0),
+ consumedUnspent: make(map[ledgerstate.Color]uint64),
+ }
+ ret.consumables = NewConsumables(inputs...)
+ return ret
+}
+
+// Clone creates deep copy of the builder
+func (b *Builder) Clone() *Builder {
+ ret := *b
+ ret.consumables = make([]*ConsumableOutput, len(b.consumables))
+ ret.outputs = make([]ledgerstate.Output, len(b.outputs))
+ ret.consumedUnspent = make(map[ledgerstate.Color]uint64)
+ for i := range ret.consumables {
+ ret.consumables[i] = b.consumables[i].Clone()
+ }
+ for i := range ret.outputs {
+ ret.outputs[i] = b.outputs[i].Clone()
+ }
+ for col, bal := range b.consumedUnspent {
+ ret.consumedUnspent[col] = bal
+ }
+ return &ret
+}
+
+// WithVersion sets Version property
+func (b *Builder) WithVersion(v ledgerstate.TransactionEssenceVersion) *Builder {
+ b.version = v
+ return b
+}
+
+// WithTimestamp sets timestamp
+func (b *Builder) WithTimestamp(t time.Time) *Builder {
+ b.timestamp = t
+ return b
+}
+
+// WithAccessPledge sets the access mana pledge
+func (b *Builder) WithAccessPledge(id identity.ID) *Builder {
+ b.accessPledgeID = id
+ return b
+}
+
+// WithConsensusPledge sets the consensus mana pledge
+func (b *Builder) WithConsensusPledge(id identity.ID) *Builder {
+ b.consensusPledgeID = id
+ return b
+}
+
+// AddOutputAndSpendUnspent spends the consumed-unspent tokens and adds output
+func (b *Builder) AddOutputAndSpendUnspent(out ledgerstate.Output) error {
+ b.SpendConsumedUnspent()
+ return b.addOutput(out)
+}
+
+func (b *Builder) addOutput(out ledgerstate.Output) error {
+ for _, o := range b.outputs {
+ if out.Compare(o) == 0 {
+ return xerrors.New("duplicate outputs not allowed")
+ }
+ }
+ b.outputs = append(b.outputs, out)
+ return nil
+}
+
+func (b *Builder) addToConsumedUnspent(bals map[ledgerstate.Color]uint64) {
+ for col, bal := range bals {
+ s := b.consumedUnspent[col]
+ b.consumedUnspent[col] = s + bal
+ }
+}
+
+// ConsumeAmounts consumes specified amounts and adds it to consumed-unspent pool
+func (b *Builder) ConsumeAmounts(amounts map[ledgerstate.Color]uint64) bool {
+ if !ConsumeMany(amounts, b.consumables...) {
+ return false
+ }
+ b.addToConsumedUnspent(amounts)
+ return true
+}
+
+func (b *Builder) ensureEnoughUnspendAmounts(amounts map[ledgerstate.Color]uint64) bool {
+ missing := make(map[ledgerstate.Color]uint64)
+ for col, bal := range amounts {
+ if s := b.consumedUnspent[col]; s < bal {
+ missing[col] = bal - s
+ }
+ }
+ if len(missing) > 0 {
+ if !b.ConsumeAmounts(missing) {
+ return false
+ }
+ }
+ return true
+}
+
+func (b *Builder) mustSpendAmounts(amounts map[ledgerstate.Color]uint64) {
+ for col, bal := range amounts {
+ if s := b.consumedUnspent[col]; s >= bal {
+ if s == bal {
+ delete(b.consumedUnspent, col)
+ } else {
+ b.consumedUnspent[col] = s - bal
+ }
+ } else {
+ panic("mustSpendAmounts: not enough unspent amounts")
+ }
+ }
+}
+
+// SpendConsumedUnspent spends all consumed-unspent pool (empties it) and returns what was spent
+func (b *Builder) SpendConsumedUnspent() map[ledgerstate.Color]uint64 {
+ ret := b.consumedUnspent
+ b.consumedUnspent = make(map[ledgerstate.Color]uint64)
+ return ret
+}
+
+// Spend spends from consumed-unspend. Return an error if not enough funds
+func (b *Builder) Spend(spend map[ledgerstate.Color]uint64) error {
+ // check if enough
+ for color, needed := range spend {
+ available := b.consumedUnspent[color]
+ if available < needed {
+ return xerrors.New("Spend: not enough consumed-unspend funds")
+ }
+ }
+ for col, bal := range spend {
+ b.consumedUnspent[col] -= bal
+ }
+ return nil
+}
+
+// AddExtendedOutputSpend adds extended output using unspent amounts and spends it. Fails of not enough.
+// Do not consume inputs
+func (b *Builder) AddExtendedOutputSpend(targetAddress ledgerstate.Address, data []byte, amounts map[ledgerstate.Color]uint64, mint ...uint64) error {
+ for col, needed := range amounts {
+ available := b.consumedUnspent[col]
+ if available < needed {
+ return xerrors.New("AddExtendedOutputSpend: not enough consumed-unspent funds")
+ }
+ }
+ if err := b.Spend(amounts); err != nil {
+ return err
+ }
+ output := ledgerstate.NewExtendedLockedOutput(amounts, targetAddress)
+ if err := output.SetPayload(data); err != nil {
+ return err
+ }
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// prepareColoredBalancesOutput:
+// - ensures enough tokens in unspentAmounts
+// - spends them
+// - handles minting of new colors (if any) and returns final map of tokens with valid minting
+func (b *Builder) prepareColoredBalancesOutput(amounts map[ledgerstate.Color]uint64, mint ...uint64) (map[ledgerstate.Color]uint64, error) {
+ if len(amounts) == 0 {
+ return nil, xerrors.New("prepareColoredBalancesOutput: no tokens to transfer")
+ }
+ minting := len(mint) > 0 && mint[0] > 0
+ iotas := amounts[ledgerstate.ColorIOTA]
+ if minting && iotas < mint[0] {
+ return nil, xerrors.Errorf("prepareColoredBalancesOutput: not enough iotas (%d) to mint %d new colored tokens", iotas, mint[0])
+ }
+ // check if it is enough consumed unspent amounts
+ if !b.ensureEnoughUnspendAmounts(amounts) {
+ return nil, xerrors.New("prepareColoredBalancesOutput: not enough balance")
+ }
+ b.mustSpendAmounts(amounts)
+ amountsCopy := make(map[ledgerstate.Color]uint64)
+ for col, bal := range amounts {
+ if bal == 0 {
+ return nil, xerrors.New("prepareColoredBalancesOutput: zero tokens in input not allowed")
+ }
+ amountsCopy[col] = bal
+ }
+ if minting {
+ amountsCopy[ledgerstate.ColorMint] = mint[0]
+ amountsCopy[ledgerstate.ColorIOTA] = iotas - mint[0]
+ if amountsCopy[ledgerstate.ColorIOTA] == 0 {
+ delete(amountsCopy, ledgerstate.ColorIOTA)
+ }
+ }
+ return amountsCopy, nil
+}
+
+// AddSigLockedColoredOutput creates output, consumes inputs if needed
+func (b *Builder) AddSigLockedColoredOutput(targetAddress ledgerstate.Address, amounts map[ledgerstate.Color]uint64, mint ...uint64) error {
+ balances, err := b.prepareColoredBalancesOutput(amounts, mint...)
+ if err != nil {
+ return err
+ }
+ bals := ledgerstate.NewColoredBalances(balances)
+ output := ledgerstate.NewSigLockedColoredOutput(bals, targetAddress)
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// AddSigLockedIOTAOutput adds output with iotas by consuming inputs
+// supports minting (coloring) of part of consumed iotas
+func (b *Builder) AddSigLockedIOTAOutput(targetAddress ledgerstate.Address, amount uint64, mint ...uint64) error {
+ balances, err := b.prepareColoredBalancesOutput(map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: amount}, mint...)
+ if err != nil {
+ return err
+ }
+ var output ledgerstate.Output
+ if _, ok := balances[ledgerstate.ColorMint]; ok {
+ output = ledgerstate.NewSigLockedColoredOutput(ledgerstate.NewColoredBalances(balances), targetAddress)
+ } else {
+ output = ledgerstate.NewSigLockedSingleOutput(amount, targetAddress)
+ }
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// AddExtendedOutputConsume add new output. Ensures enough unspent funds by consuming if necessary
+func (b *Builder) AddExtendedOutputConsume(targetAddress ledgerstate.Address, data []byte, amounts map[ledgerstate.Color]uint64, mint ...uint64) error {
+ balances, err := b.prepareColoredBalancesOutput(amounts, mint...)
+ if err != nil {
+ return err
+ }
+ output := ledgerstate.NewExtendedLockedOutput(balances, targetAddress)
+ if err := output.SetPayload(data); err != nil {
+ return err
+ }
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// AddRemainderOutputIfNeeded consumes already touched inputs and spends consumed-unspend.
+// Creates reminder output if needed
+func (b *Builder) AddRemainderOutputIfNeeded(remainderAddr ledgerstate.Address, data []byte, compress ...bool) error {
+ compr := false
+ if len(compress) > 0 {
+ compr = compress[0]
+ }
+ b.ConsumeRemainingBalances(compr)
+ unspent := b.ConsumedUnspent()
+ if len(unspent) == 0 {
+ // no need for reminder output
+ return nil
+ }
+ return b.AddExtendedOutputConsume(remainderAddr, data, unspent)
+}
+
+// AddMintingOutputConsume mints new tokens. Consumes additional iotas if needed
+func (b *Builder) AddMintingOutputConsume(targetAddress ledgerstate.Address, amount uint64, payload ...[]byte) error {
+ amounts := map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: amount}
+ if !b.ensureEnoughUnspendAmounts(amounts) {
+ return xerrors.New("AddMintingOutputConsumer: not enough balance")
+ }
+ b.mustSpendAmounts(amounts)
+ // iotas replaced with minting color
+ amounts = map[ledgerstate.Color]uint64{ledgerstate.ColorMint: amount}
+ output := ledgerstate.NewExtendedLockedOutput(amounts, targetAddress)
+ if len(payload) > 0 {
+ if err := output.SetPayload(payload[0]); err != nil {
+ return err
+ }
+ }
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// AddNewAliasMint creates new self governed chain.
+// The identity of the chain is not known until the full transaction is produced
+func (b *Builder) AddNewAliasMint(balances map[ledgerstate.Color]uint64, stateAddress ledgerstate.Address, stateData []byte) error {
+ output, err := ledgerstate.NewAliasOutputMint(balances, stateAddress)
+ if err != nil {
+ return err
+ }
+ if err := output.SetStateData(stateData); err != nil {
+ return err
+ }
+ if !b.ensureEnoughUnspendAmounts(balances) {
+ return xerrors.New("AddNewAliasMint: not enough tokens")
+ }
+ b.SpendConsumedUnspent()
+ if err := b.addOutput(output); err != nil {
+ return err
+ }
+ return nil
+}
+
+// ConsumedUnspent return consumed-unspend pool
+func (b *Builder) ConsumedUnspent() map[ledgerstate.Color]uint64 {
+ ret := make(map[ledgerstate.Color]uint64)
+ for col, bal := range b.consumedUnspent {
+ if bal != 0 {
+ ret[col] = bal
+ }
+ }
+ return ret
+}
+
+// ConsumeAliasInput consumes chain input by alias
+func (b *Builder) ConsumeAliasInput(addressAlias ledgerstate.Address) error {
+ out, _, ok := FindAliasConsumableInput(addressAlias, b.consumables...)
+ if !ok {
+ return xerrors.Errorf("ConsumeAliasInput: can't find chain input for %s", addressAlias)
+ }
+ if err := b.ConsumeInputByOutputID(out.ID()); err != nil {
+ return err
+ }
+ return nil
+}
+
+// AliasNextChainedOutput creates chained output without consuming it
+func (b *Builder) AliasNextChainedOutput(addressAlias ledgerstate.Address) (*ledgerstate.AliasOutput, error) {
+ out, _, ok := FindAliasConsumableInput(addressAlias, b.consumables...)
+ if !ok {
+ return nil, xerrors.Errorf("can't find chain input for %s", addressAlias)
+ }
+ return out.NewAliasOutputNext(false), nil
+}
+
+// AddAliasOutputAsRemainder forms an reminder by creating new alias output
+func (b *Builder) AddAliasOutputAsRemainder(addressAlias ledgerstate.Address, stateData []byte, compress ...bool) error {
+ out, _, ok := FindAliasConsumableInput(addressAlias, b.consumables...)
+ if !ok {
+ return xerrors.Errorf("can't find chain input for %s", addressAlias)
+ }
+ if err := b.ConsumeInputByOutputID(out.ID()); err != nil {
+ return err
+ }
+ compr := false
+ if len(compress) > 0 {
+ compr = compress[0]
+ }
+ b.ConsumeRemainingBalances(compr)
+ chained := out.NewAliasOutputNext()
+ if err := chained.SetBalances(b.ConsumedUnspent()); err != nil {
+ return err
+ }
+ if err := chained.SetStateData(stateData); err != nil {
+ return err
+ }
+ if err := b.AddOutputAndSpendUnspent(chained); err != nil {
+ return err
+ }
+ return nil
+}
+
+// ConsumeInputByOutputID consumes input by outputID
+func (b *Builder) ConsumeInputByOutputID(id ledgerstate.OutputID) error {
+ for _, consumable := range b.consumables {
+ if consumable.output.ID() == id {
+ b.addToConsumedUnspent(ConsumeRemaining(consumable))
+ return nil
+ }
+ }
+ return xerrors.Errorf("ConsumeInputByOutputID: output not found")
+}
+
+// ConsumeRemainingBalances consumes touched balances
+func (b *Builder) ConsumeRemainingBalances(compress bool) []*ConsumableOutput {
+ inputConsumables := b.consumables
+ if !compress {
+ inputConsumables = SelectConsumed(b.consumables...)
+ }
+ b.addToConsumedUnspent(ConsumeRemaining(inputConsumables...))
+ return inputConsumables
+}
+
+// BuildEssence builds essence of the transaction.
+// Compress option:
+// - true means take all consumable inputs
+// - false means take only touched (consumed) outputs. This is the default
+func (b *Builder) BuildEssence(compress ...bool) (*ledgerstate.TransactionEssence, []ledgerstate.Output, error) {
+ if len(b.consumedUnspent) > 0 {
+ return nil, nil, xerrors.New("BuildEssence: not all consumed balances were spent")
+ }
+ compr := false
+ if len(compress) > 0 {
+ compr = compress[0]
+ }
+ inputConsumables := b.consumables
+ if !compr {
+ inputConsumables = SelectConsumed(b.consumables...)
+ }
+ for _, consumable := range inputConsumables {
+ if !consumable.NothingRemains() {
+ return nil, nil, xerrors.New("BuildEssence: not all inputs were completely were consumed")
+ }
+ }
+ // NewOutputs sorts the outputs and changes indices -> impossible to know indexUnlocked of a particular output
+ outputs := ledgerstate.NewOutputs(b.outputs...)
+ inputs, consumedOutputs := MakeUTXOInputs(inputConsumables...)
+ ret := ledgerstate.NewTransactionEssence(b.version, b.timestamp, b.accessPledgeID, b.consensusPledgeID, inputs, outputs)
+ return ret, consumedOutputs, nil
+}
+
+// BuildWithED25519 build complete transaction and signs/unlocks with provided keys
+func (b *Builder) BuildWithED25519(keyPairs ...*ed25519.KeyPair) (*ledgerstate.Transaction, error) {
+ essence, consumedOutputs, err := b.BuildEssence()
+ if err != nil {
+ return nil, err
+ }
+ unlockBlocks, err2 := UnlockInputsWithED25519KeyPairs(consumedOutputs, essence, keyPairs...)
+ if err2 != nil {
+ return nil, err2
+ }
+ return ledgerstate.NewTransaction(essence, unlockBlocks), nil
+}
diff --git a/packages/ledgerstate/utxoutil/consumable.go b/packages/ledgerstate/utxoutil/consumable.go
new file mode 100644
index 0000000000..75ae370a2f
--- /dev/null
+++ b/packages/ledgerstate/utxoutil/consumable.go
@@ -0,0 +1,216 @@
+// Package utxoutil is used to build value transaction
+package utxoutil
+
+import (
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// ConsumableOutput represents a wrapper of the output object. It allows 'consume' tokens and track
+// how many remain to be consumed
+type ConsumableOutput struct {
+ output ledgerstate.Output
+ remaining map[ledgerstate.Color]uint64
+ wasConsumed bool
+}
+
+// NewConsumables creates a slice of consumables out of slice of output objects
+func NewConsumables(out ...ledgerstate.Output) []*ConsumableOutput {
+ ret := make([]*ConsumableOutput, len(out))
+ for i, o := range out {
+ ret[i] = &ConsumableOutput{
+ output: o,
+ remaining: make(map[ledgerstate.Color]uint64),
+ }
+ o.Balances().ForEach(func(col ledgerstate.Color, bal uint64) bool {
+ ret[i].remaining[col] = bal
+ return true
+ })
+ }
+ return ret
+}
+
+// ToOutputs extracts output objects from consumables into the slice
+func ToOutputs(consumables ...*ConsumableOutput) []ledgerstate.Output {
+ ret := make([]ledgerstate.Output, len(consumables))
+ for i, c := range consumables {
+ ret[i] = c.output
+ }
+ return ret
+}
+
+// Clone clones the consumable
+func (o *ConsumableOutput) Clone() *ConsumableOutput {
+ ret := &ConsumableOutput{
+ output: o.output.Clone(),
+ remaining: make(map[ledgerstate.Color]uint64),
+ wasConsumed: o.wasConsumed,
+ }
+ for col, bal := range o.remaining {
+ ret.remaining[col] = bal
+ }
+ return ret
+}
+
+// ConsumableBalance return number of tokens remaining to consume on the consumable
+func (o *ConsumableOutput) ConsumableBalance(color ledgerstate.Color) uint64 {
+ ret := o.remaining[color]
+ return ret
+}
+
+// WasConsumed return true if consumable was 'touched', it some tokens were already consumed
+func (o *ConsumableOutput) WasConsumed() bool {
+ return o.wasConsumed
+}
+
+// NothingRemains returns true if no tokens remain to be consumed
+func (o *ConsumableOutput) NothingRemains() bool {
+ for _, bal := range o.remaining {
+ if bal != 0 {
+ return false
+ }
+ }
+ return true
+}
+
+// ConsumableBalance returns how many tokens of the given color can be consumed from remaining
+func ConsumableBalance(color ledgerstate.Color, consumables ...*ConsumableOutput) uint64 {
+ ret := uint64(0)
+ for _, out := range consumables {
+ ret += out.ConsumableBalance(color)
+ }
+ return ret
+}
+
+// EnoughBalance checks if it is enough tokens of the given color remains in the consumables
+func EnoughBalance(color ledgerstate.Color, amount uint64, consumables ...*ConsumableOutput) bool {
+ consumable := ConsumableBalance(color, consumables...)
+ return consumable >= amount
+}
+
+// EnoughBalances checks is it is enough remaining tokens to consume whole collection of balances
+func EnoughBalances(amounts map[ledgerstate.Color]uint64, consumables ...*ConsumableOutput) bool {
+ for color, amount := range amounts {
+ if !EnoughBalance(color, amount, consumables...) {
+ return false
+ }
+ }
+ return true
+}
+
+// ConsumeColored specified amount of colored tokens sequentially from specified ConsumableOutputs
+// return nil if it was a success.
+// In case of failure ConsumableOutputs remaining unchanged
+func ConsumeColored(color ledgerstate.Color, amount uint64, consumables ...*ConsumableOutput) bool {
+ if !EnoughBalance(color, amount, consumables...) {
+ return false
+ }
+ MustConsumeColored(color, amount, consumables...)
+ return true
+}
+
+// MustConsumeColored same as as ConsumeColor only panics on unsuccessful consume
+func MustConsumeColored(color ledgerstate.Color, amount uint64, consumables ...*ConsumableOutput) {
+ remaining := amount
+ for _, out := range consumables {
+ if remaining == 0 {
+ break
+ }
+ rem := out.remaining[color]
+ if rem == 0 {
+ continue
+ }
+ if rem >= remaining {
+ out.remaining[color] = rem - remaining
+ remaining = 0
+ } else {
+ out.remaining[color] = 0
+ remaining -= rem
+ }
+ out.wasConsumed = true
+ }
+ if remaining != 0 {
+ panic("ConsumeColored: internal error")
+ }
+}
+
+// ConsumeMany consumes whole collection of colored balances
+func ConsumeMany(amounts map[ledgerstate.Color]uint64, consumables ...*ConsumableOutput) bool {
+ if !EnoughBalances(amounts, consumables...) {
+ return false
+ }
+ for color, amount := range amounts {
+ MustConsumeColored(color, amount, consumables...)
+ }
+ return true
+}
+
+// ConsumeRemaining consumes all remaining tokens and return map of wasConsumed balances
+func ConsumeRemaining(consumables ...*ConsumableOutput) map[ledgerstate.Color]uint64 {
+ ret := make(map[ledgerstate.Color]uint64)
+ for _, out := range consumables {
+ for col, bal := range out.remaining {
+ if bal == 0 {
+ continue
+ }
+ ConsumeColored(col, bal, out)
+ total := ret[col]
+ ret[col] = total + bal
+ }
+ }
+ return ret
+}
+
+// SelectConsumed filters out untouched consumables and returns those which were consumed
+func SelectConsumed(consumables ...*ConsumableOutput) []*ConsumableOutput {
+ ret := make([]*ConsumableOutput, 0)
+ for _, out := range consumables {
+ if out.WasConsumed() {
+ ret = append(ret, out)
+ }
+ }
+ return ret
+}
+
+// MakeUTXOInputs from the list of consumables makes sorted inputs with NewInputs() and returns corresponding
+// outputs in the same (changed) order
+func MakeUTXOInputs(consumables ...*ConsumableOutput) (ledgerstate.Inputs, []ledgerstate.Output) {
+ inputs := make(ledgerstate.Inputs, len(consumables))
+ origOrderOfInputs := make([]ledgerstate.OutputID, len(inputs))
+ for i, out := range consumables {
+ inp := ledgerstate.NewUTXOInput(out.output.ID())
+ origOrderOfInputs[i] = inp.ReferencedOutputID()
+ inputs[i] = inp
+ }
+ // Sorts!!! So we have to track corresponding outputs too
+ retInputs := ledgerstate.NewInputs(inputs...)
+ if len(retInputs) != len(origOrderOfInputs) {
+ panic("duplicate inputs")
+ }
+ permutation := getPermutation(retInputs)
+ retConsumedOutputs := make([]ledgerstate.Output, len(retInputs))
+ for _, out := range consumables {
+ retConsumedOutputs[permutation[out.output.ID()]] = out.output
+ }
+ return retInputs, retConsumedOutputs
+}
+
+// getPermutation utility function return mapping from outputID to its index in the slice
+func getPermutation(inputs ledgerstate.Inputs) map[ledgerstate.OutputID]int {
+ ret := make(map[ledgerstate.OutputID]int)
+ for i := range inputs {
+ ret[inputs[i].(*ledgerstate.UTXOInput).ReferencedOutputID()] = i
+ }
+ return ret
+}
+
+// FindAliasConsumableInput finds chain output with given alias address
+func FindAliasConsumableInput(aliasAddr ledgerstate.Address, consumables ...*ConsumableOutput) (*ledgerstate.AliasOutput, int, bool) {
+ for i, out := range consumables {
+ if out.output.Address().Equals(aliasAddr) {
+ if ret, ok := out.output.(*ledgerstate.AliasOutput); ok {
+ return ret, i, true
+ }
+ }
+ }
+ return nil, 0, false
+}
diff --git a/packages/ledgerstate/utxoutil/doc.go b/packages/ledgerstate/utxoutil/doc.go
new file mode 100644
index 0000000000..62bdfacee3
--- /dev/null
+++ b/packages/ledgerstate/utxoutil/doc.go
@@ -0,0 +1,10 @@
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+// Package utxoutil contains number of utility functions useful while manipulating outputs and
+// constructing transactions.
+// The ConsumableOutput is a wrapper of an ledgerstate.Output which allows 'consuming' tokens and tracking
+// remaining balances.
+// The Builder is a flexible tansaction builder tool. It use ConsumableOutput -s to build
+// arbitrary transactions along 'consume->spend' scheme.
+package utxoutil
diff --git a/packages/ledgerstate/utxoutil/util.go b/packages/ledgerstate/utxoutil/util.go
new file mode 100644
index 0000000000..d620b09985
--- /dev/null
+++ b/packages/ledgerstate/utxoutil/util.go
@@ -0,0 +1,224 @@
+package utxoutil
+
+import (
+ "github.com/iotaledger/hive.go/crypto/ed25519"
+ "golang.org/x/crypto/blake2b"
+ "golang.org/x/xerrors"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// signatureUnlockBlockWithIndex internal structure used to track signature and indices where it was used in the transaction
+type signatureUnlockBlockWithIndex struct {
+ unlockBlock *ledgerstate.SignatureUnlockBlock
+ indexUnlocked int
+}
+
+// UnlockInputsWithED25519KeyPairs signs the transaction essence with provided ED25519 pair. Then it unlocks
+// inputs provided as a list of outputs using those signatures and returns a list of unlock blocks in the same
+// order as inputs.
+// It only uses no more signatures as it is needed to unlock all inputs. Other unlock blocks are references
+// The function unlocks the following output types:
+// - ledgerstate.AliasOutput
+// - ledgerstate.ExtendedLockedOutput
+// - ledgerstate.SigLockedSingleOutput
+// - ledgerstate.SigLockedColoredOutput
+// It unlocks inputs by using the following unlock block types:
+// - ledgerstate.SignatureUnlockBlock
+// - ledgerstate.ReferenceUnlockBlock
+// - ledgerstate.AliasUnlockBlock
+func UnlockInputsWithED25519KeyPairs(inputs []ledgerstate.Output, essence *ledgerstate.TransactionEssence, keyPairs ...*ed25519.KeyPair) ([]ledgerstate.UnlockBlock, error) {
+ sigs := make(map[[33]byte]*signatureUnlockBlockWithIndex)
+ for _, keyPair := range keyPairs {
+ addr := ledgerstate.NewED25519Address(keyPair.PublicKey)
+ data := essence.Bytes()
+ signature := ledgerstate.NewED25519Signature(keyPair.PublicKey, keyPair.PrivateKey.Sign(data))
+ if !signature.AddressSignatureValid(addr, data) {
+ panic("SigUnlockBlockED25519: internal error, unlockBlock invalid")
+ }
+ sigs[addr.Array()] = &signatureUnlockBlockWithIndex{
+ unlockBlock: ledgerstate.NewSignatureUnlockBlock(signature),
+ indexUnlocked: -1,
+ }
+ }
+ return unlockInputsWithSignatureBlocks(inputs, sigs)
+}
+
+// unlockInputsWithSignatureBlocks does the optimized unlocking
+func unlockInputsWithSignatureBlocks(inputs []ledgerstate.Output, sigUnlockBlocks map[[33]byte]*signatureUnlockBlockWithIndex) ([]ledgerstate.UnlockBlock, error) {
+ // unlock ChainOutputs
+ ret := make([]ledgerstate.UnlockBlock, len(inputs))
+ for index, out := range inputs {
+ if ret[index] != nil {
+ continue
+ }
+ switch ot := out.(type) {
+ case *ledgerstate.AliasOutput:
+ sig, ok := sigUnlockBlocks[ot.GetStateAddress().Array()]
+ if !ok {
+ return nil, xerrors.New("chain input can't be unlocked for state update")
+ }
+ if sig.indexUnlocked >= 0 {
+ // signature already included
+ ret[index] = ledgerstate.NewAliasUnlockBlock(uint16(sig.indexUnlocked))
+ } else {
+ // signature is included here
+ ret[index] = sig.unlockBlock
+ sig.indexUnlocked = index
+ }
+ // assign unlock blocks for all alias locked inputs
+ for i, o := range inputs {
+ eot, ok := o.(*ledgerstate.ExtendedLockedOutput)
+ if !ok {
+ continue
+ }
+ if !ot.GetAliasAddress().Equals(eot.Address()) {
+ continue
+ }
+ ret[i] = ledgerstate.NewAliasUnlockBlock(uint16(index))
+ }
+
+ case *ledgerstate.ExtendedLockedOutput:
+ sig, ok := sigUnlockBlocks[ot.Address().Array()]
+ if !ok {
+ // no corresponding signature, it probably is an alias
+ continue
+ }
+ if sig.indexUnlocked >= 0 {
+ // signature already included
+ ret[index] = ledgerstate.NewReferenceUnlockBlock(uint16(sig.indexUnlocked))
+ } else {
+ // signature is included here
+ ret[index] = sig.unlockBlock
+ sig.indexUnlocked = index
+ }
+
+ case *ledgerstate.SigLockedSingleOutput:
+ sig, ok := sigUnlockBlocks[ot.Address().Array()]
+ if !ok {
+ return nil, xerrors.New("sig locked input can't be unlocked")
+ }
+ if sig.indexUnlocked >= 0 {
+ // signature already included
+ ret[index] = ledgerstate.NewReferenceUnlockBlock(uint16(sig.indexUnlocked))
+ } else {
+ // signature is included here
+ ret[index] = sig.unlockBlock
+ sig.indexUnlocked = index
+ }
+ case *ledgerstate.SigLockedColoredOutput:
+ sig, ok := sigUnlockBlocks[ot.Address().Array()]
+ if !ok {
+ return nil, xerrors.New("sig locked input can't be unlocked")
+ }
+ if sig.indexUnlocked >= 0 {
+ // signature already included
+ ret[index] = ledgerstate.NewReferenceUnlockBlock(uint16(sig.indexUnlocked))
+ } else {
+ // signature is included here
+ ret[index] = sig.unlockBlock
+ sig.indexUnlocked = index
+ }
+ default:
+ return nil, xerrors.Errorf("unsupported output type at index %d", index)
+ }
+ }
+ for _, b := range ret {
+ if b == nil {
+ return nil, xerrors.New("failed to unlock some inputs")
+ }
+ }
+ return ret, nil
+}
+
+// collectAliasOutputs scans all outputs and collects ledgerstate.AliasOutput into a map by the Address.Array
+// Returns an error if finds duplicate
+func collectAliasOutputs(tx *ledgerstate.Transaction) (map[[33]byte]*ledgerstate.AliasOutput, error) {
+ ret := make(map[[33]byte]*ledgerstate.AliasOutput)
+ for i, o := range tx.Essence().Outputs() {
+ out, ok := o.(*ledgerstate.AliasOutput)
+ if !ok {
+ continue
+ }
+ if _, ok := ret[out.GetAliasAddress().Array()]; ok {
+ return nil, xerrors.New("duplicate chain output")
+ }
+ o = o.SetID(ledgerstate.NewOutputID(tx.ID(), uint16(i))).UpdateMintingColor()
+ ret[out.GetAliasAddress().Array()] = o.(*ledgerstate.AliasOutput)
+ }
+ return ret, nil
+}
+
+// GetSingleChainedAliasOutput expects exactly one chained output in the transaction and returns it
+// returns:
+// - nil and no error if found none
+// - error if there's more than 1
+func GetSingleChainedAliasOutput(tx *ledgerstate.Transaction) (*ledgerstate.AliasOutput, error) {
+ ch, err := collectAliasOutputs(tx)
+ if err != nil {
+ return nil, err
+ }
+ if len(ch) == 0 {
+ return nil, nil
+ }
+ if len(ch) > 1 {
+ return nil, xerrors.New("more than one chained output was found")
+ }
+ for _, out := range ch {
+ return out, nil
+ }
+ panic("shouldn't be here")
+}
+
+// GetSingleSender analyzes transaction and signatures and retrieves single address which is consistent
+// to be a 'sender':
+// if it do not have alias input, the address corresponding to the only signature is returned
+// if it has a single alias input (i.e. output is not an origin) it returns a alias address of the chain
+func GetSingleSender(tx *ledgerstate.Transaction) (ledgerstate.Address, error) {
+ // only accepting one signature in the transaction
+ var sigBlock *ledgerstate.SignatureUnlockBlock
+ for _, blk := range tx.UnlockBlocks() {
+ t, ok := blk.(*ledgerstate.SignatureUnlockBlock)
+ if !ok {
+ continue
+ }
+ if sigBlock != nil {
+ return nil, xerrors.New("GetSingleSender: exactly one signature block expected")
+ }
+ sigBlock = t
+ }
+ if sigBlock == nil {
+ panic("GetSingleSender: exactly one signature block expected")
+ }
+ addr, err := ledgerstate.AddressFromSignature(sigBlock.Signature())
+ if err != nil {
+ return nil, err
+ }
+ chained, err := GetSingleChainedAliasOutput(tx)
+ if err != nil {
+ return nil, err
+ }
+ if chained == nil || chained.IsOrigin() {
+ // no chained output means the address is the sender
+ // if chained output is origin (i.e. has no corresponding input)
+ // the address is the sender
+ return addr, nil
+ }
+ return chained.GetAliasAddress(), nil
+}
+
+// GetMintedAmounts analyzes outputs and extracts information of new colors
+// which were minted and respective amounts of tokens
+func GetMintedAmounts(tx *ledgerstate.Transaction) map[ledgerstate.Color]uint64 {
+ ret := make(map[ledgerstate.Color]uint64)
+ for _, out := range tx.Essence().Outputs() {
+ out.Balances().ForEach(func(col ledgerstate.Color, bal uint64) bool {
+ if col == ledgerstate.ColorMint {
+ ret[ledgerstate.Color(blake2b.Sum256(out.ID().Bytes()))] = bal
+ return false
+ }
+ return true
+ })
+ }
+ return ret
+}
diff --git a/packages/manualpeering/manualpeering.go b/packages/manualpeering/manualpeering.go
index 6356449325..e193a214ef 100644
--- a/packages/manualpeering/manualpeering.go
+++ b/packages/manualpeering/manualpeering.go
@@ -1,6 +1,7 @@
package manualpeering
import (
+ "context"
"sync"
"time"
@@ -238,11 +239,11 @@ func (m *Manager) connectNeighbor(p *peer.Peer) error {
}
switch connDirection {
case connDirectionOutbound:
- if err := m.gm.AddOutbound(p, gossip.NeighborsGroupManual); err != nil {
+ if err := m.gm.AddOutbound(context.Background(), p, gossip.NeighborsGroupManual); err != nil {
return errors.Wrapf(err, "failed to connect an outbound neighbor; publicKey=%s", p.PublicKey())
}
case connDirectionInbound:
- if err := m.gm.AddInbound(p, gossip.NeighborsGroupManual); err != nil {
+ if err := m.gm.AddInbound(context.Background(), p, gossip.NeighborsGroupManual); err != nil {
return errors.Wrapf(err, "failed to connect an inbound neighbor; publicKey=%s", p.PublicKey())
}
default:
diff --git a/packages/remotelogmetrics/events.go b/packages/remotelogmetrics/events.go
index e4d237c6b1..27a5e9d43c 100644
--- a/packages/remotelogmetrics/events.go
+++ b/packages/remotelogmetrics/events.go
@@ -47,6 +47,44 @@ type FPCConflictRecord struct {
Opinions []int32 `json:"opinions" bson:"opinions"`
// Outcome defines final opinion of the conflict.
Outcome int32 `json:"outcome,omitempty" bson:"outcome,omitempty"`
- // Time defines the time when the conflict has been finalized.
+ // Time defines the time when the voting round has been finalized.
Time time.Time `json:"datetime" bson:"datetime"`
+ // ConflictCreationTime points to time when the context has been created
+ ConflictCreationTime time.Time `json:"conflictStart" bson:"conflictStart"`
+}
+
+// TransactionMetrics defines the transaction metrics record to sent be to remote logger.
+type TransactionMetrics struct {
+ Type string `json:"type" bson:"type"`
+ MessageID string `json:"messageID" bson:"messageID"`
+ TransactionID string `json:"transactionID" bson:"transactionID"`
+ IssuedTimestamp time.Time `json:"issuedTimestamp" bson:"issuedTimestamp"`
+ SolidTimestamp time.Time `json:"solidTimestamp" bson:"solidTimestamp"`
+ ScheduledTimestamp time.Time `json:"scheduledTimestamp" bson:"scheduledTimestamp"`
+ BookedTimestamp time.Time `json:"bookedTimestamp" bson:"bookedTimestamp"`
+ ConfirmedTimestamp time.Time `json:"confirmedTimestamp" bson:"confirmedTimestamp"`
+}
+
+// DRNGMetrics defines the DRNG metrics record to sent be to remote logger.
+type DRNGMetrics struct {
+ Type string `json:"type" bson:"type"`
+ InstanceID uint32 `json:"instanceID" bson:"instanceID"`
+ Round uint64 `json:"round" bson:"round"`
+ IssuedTimestamp time.Time `json:"issuedTimestamp" bson:"issuedTimestamp"`
+ ReceivedTimestamp time.Time `json:"receivedTimestamp" bson:"receivedTimestamp"`
+}
+
+// StatementLog defines the statement metrics record to sent be to remote logger.
+type StatementLog struct {
+ NodeID string `json:"nodeID"`
+ MsgID string `json:"msgID"`
+ IssuerID string `json:"issuerID"`
+ IssuedTime time.Time `json:"issuedTime"`
+ ArrivalTime time.Time `json:"arrivalTime"`
+ SolidTime time.Time `json:"solidTime"`
+ DeltaArrival int64 `json:"deltaArrival"`
+ DeltaSolid int64 `json:"deltaSolid"`
+ Clock bool `json:"clock"`
+ Sync bool `json:"sync"`
+ Type string `json:"type"`
}
diff --git a/packages/shutdown/order.go b/packages/shutdown/order.go
index be48d53245..02c524165c 100644
--- a/packages/shutdown/order.go
+++ b/packages/shutdown/order.go
@@ -31,10 +31,14 @@ const (
PriorityDashboard
// PrioritySynchronization defines the shutdown priority for synchronization.
PrioritySynchronization
+ // PriorityManaRefresher defines the shutdown priority for the manarefresher plugin.
+ PriorityManaRefresher
// PriorityActivity defines the shutdown priority for the activity plugin.
PriorityActivity
// PrioritySpammer defines the shutdown priority for spammer.
PrioritySpammer
// PriorityBootstrap defines the shutdown priority for bootstrap.
PriorityBootstrap
+ // PriorityTXStream defines the shutdown priority for realtime.
+ PriorityTXStream
)
diff --git a/packages/spammer/spammer.go b/packages/spammer/spammer.go
index 5ba40b1c00..04064f0799 100644
--- a/packages/spammer/spammer.go
+++ b/packages/spammer/spammer.go
@@ -12,7 +12,7 @@ import (
)
// IssuePayloadFunc is a function which issues a payload.
-type IssuePayloadFunc = func(payload payload.Payload) (*tangle.Message, error)
+type IssuePayloadFunc = func(payload payload.Payload, parentsCount ...int) (*tangle.Message, error)
// Spammer spams messages with a static data payload.
type Spammer struct {
diff --git a/packages/tangle/booker.go b/packages/tangle/booker.go
index 3f306ca7ae..2feb54d8f2 100644
--- a/packages/tangle/booker.go
+++ b/packages/tangle/booker.go
@@ -245,7 +245,25 @@ func (b *Booker) bookPayload(message *Message) (branchID ledgerstate.BranchID, e
}
for _, output := range transaction.Essence().Outputs() {
- b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(output.Address(), output.ID())
+ switch output.Type() {
+ case ledgerstate.AliasOutputType:
+ castedOutput := output.(*ledgerstate.AliasOutput)
+ // if it is an origin alias output, we don't have the aliasaddress from the parsed bytes.
+ // that happens in utxodag output booking, so we calculate the alias address here
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(castedOutput.GetAliasAddress(), output.ID())
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(castedOutput.GetStateAddress(), output.ID())
+ if !castedOutput.IsSelfGoverned() {
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(castedOutput.GetGoverningAddress(), output.ID())
+ }
+ case ledgerstate.ExtendedLockedOutputType:
+ castedOutput := output.(*ledgerstate.ExtendedLockedOutput)
+ if castedOutput.FallbackAddress() != nil {
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(castedOutput.FallbackAddress(), output.ID())
+ }
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(output.Address(), output.ID())
+ default:
+ b.tangle.LedgerState.UTXODAG.StoreAddressOutputMapping(output.Address(), output.ID())
+ }
}
if attachment, stored := b.tangle.Storage.StoreAttachment(transaction.ID(), message.ID()); stored {
diff --git a/packages/tangle/consensusmanager.go b/packages/tangle/consensusmanager.go
index 3636cdcd93..a3a7c3ac4d 100644
--- a/packages/tangle/consensusmanager.go
+++ b/packages/tangle/consensusmanager.go
@@ -20,6 +20,7 @@ func NewConsensusManager(tangle *Tangle) (opinionFormer *ConsensusManager) {
opinionFormer = &ConsensusManager{
Events: &ConsensusManagerEvents{
MessageOpinionFormed: events.NewEvent(MessageIDCaller),
+ StatementProcessed: events.NewEvent(MessageCaller),
},
tangle: tangle,
@@ -97,6 +98,8 @@ func (o *ConsensusManager) SetTransactionLiked(transactionID ledgerstate.Transac
type ConsensusManagerEvents struct {
// Fired when an opinion of a message is formed.
MessageOpinionFormed *events.Event
+ // Fired when after a received statement is processed.
+ StatementProcessed *events.Event
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/tangle/ledgerstate.go b/packages/tangle/ledgerstate.go
index b7b9e0eb4a..1da0152ad5 100644
--- a/packages/tangle/ledgerstate.go
+++ b/packages/tangle/ledgerstate.go
@@ -15,6 +15,8 @@ type LedgerState struct {
tangle *Tangle
BranchDAG *ledgerstate.BranchDAG
UTXODAG *ledgerstate.UTXODAG
+
+ totalSupply uint64
}
// NewLedgerState is the constructor of the LedgerState component.
@@ -160,11 +162,18 @@ func (l *LedgerState) BranchID(transactionID ledgerstate.TransactionID) (branchI
// LoadSnapshot creates a set of outputs in the UTXO-DAG, that are forming the genesis for future transactions.
func (l *LedgerState) LoadSnapshot(snapshot *ledgerstate.Snapshot) {
l.UTXODAG.LoadSnapshot(snapshot)
- for txID := range snapshot.Transactions {
+ for txID, essence := range snapshot.Transactions {
attachment, _ := l.tangle.Storage.StoreAttachment(txID, EmptyMessageID)
if attachment != nil {
attachment.Release()
}
+ // The following only works assuming that the snapshot contains all of the unspent outputs.
+ for _, output := range essence.Outputs() {
+ output.Balances().ForEach(func(color ledgerstate.Color, balance uint64) bool {
+ l.totalSupply += balance
+ return true
+ })
+ }
}
attachment, _ := l.tangle.Storage.StoreAttachment(ledgerstate.GenesisTransactionID, EmptyMessageID)
if attachment != nil {
@@ -205,4 +214,9 @@ func (l *LedgerState) Consumers(outputID ledgerstate.OutputID) (cachedTransactio
return l.UTXODAG.Consumers(outputID)
}
+// TotalSupply returns the total supply.
+func (l *LedgerState) TotalSupply() (totalSupply uint64) {
+ return l.totalSupply
+}
+
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/tangle/messagefactory.go b/packages/tangle/messagefactory.go
index f582adb6bb..b65cd7de66 100644
--- a/packages/tangle/messagefactory.go
+++ b/packages/tangle/messagefactory.go
@@ -64,7 +64,7 @@ func (f *MessageFactory) SetWorker(worker Worker) {
// IssuePayload creates a new message including sequence number and tip selection and returns it.
// It also triggers the MessageConstructed event once it's done, which is for example used by the plugins to listen for
// messages that shall be attached to the tangle.
-func (f *MessageFactory) IssuePayload(p payload.Payload, t ...*Tangle) (*Message, error) {
+func (f *MessageFactory) IssuePayload(p payload.Payload, parentsCount ...int) (*Message, error) {
payloadLen := len(p.Bytes())
if payloadLen > payload.MaxSize {
err := fmt.Errorf("maximum payload size of %d bytes exceeded", payloadLen)
@@ -81,7 +81,12 @@ func (f *MessageFactory) IssuePayload(p payload.Payload, t ...*Tangle) (*Message
return nil, err
}
- strongParents, weakParents, err := f.selector.Tips(p, 2, 2)
+ countStrongParents := 2
+ if len(parentsCount) > 0 {
+ countStrongParents = parentsCount[0]
+ }
+
+ strongParents, weakParents, err := f.selector.Tips(p, countStrongParents, 2)
if err != nil {
err = errors.Errorf("tips could not be selected: %w", err)
f.Events.Error.Trigger(err)
@@ -91,21 +96,20 @@ func (f *MessageFactory) IssuePayload(p payload.Payload, t ...*Tangle) (*Message
issuingTime := clock.SyncedTime()
// due to the ParentAge check we must ensure that we set the right issuing time.
- if t != nil {
- for _, parent := range strongParents {
- t[0].Storage.Message(parent).Consume(func(msg *Message) {
- if msg.ID() != EmptyMessageID && !msg.IssuingTime().Before(issuingTime) {
- issuingTime = msg.IssuingTime()
- }
- })
- }
- for _, parent := range weakParents {
- t[0].Storage.Message(parent).Consume(func(msg *Message) {
- if msg.ID() != EmptyMessageID && !msg.IssuingTime().Before(issuingTime) {
- issuingTime = msg.IssuingTime()
- }
- })
- }
+
+ for _, parent := range strongParents {
+ f.tangle.Storage.Message(parent).Consume(func(msg *Message) {
+ if msg.ID() != EmptyMessageID && !msg.IssuingTime().Before(issuingTime) {
+ issuingTime = msg.IssuingTime()
+ }
+ })
+ }
+ for _, parent := range weakParents {
+ f.tangle.Storage.Message(parent).Consume(func(msg *Message) {
+ if msg.ID() != EmptyMessageID && !msg.IssuingTime().Before(issuingTime) {
+ issuingTime = msg.IssuingTime()
+ }
+ })
}
issuerPublicKey := f.localIdentity.PublicKey()
diff --git a/packages/tangle/tangle.go b/packages/tangle/tangle.go
index b3e534209a..73a212ba2f 100644
--- a/packages/tangle/tangle.go
+++ b/packages/tangle/tangle.go
@@ -127,15 +127,15 @@ func (t *Tangle) ProcessGossipMessage(messageBytes []byte, peer *peer.Peer) {
}
// IssuePayload allows to attach a payload (i.e. a Transaction) to the Tangle.
-func (t *Tangle) IssuePayload(payload payload.Payload) (message *Message, err error) {
+func (t *Tangle) IssuePayload(p payload.Payload, parentsCount ...int) (message *Message, err error) {
if !t.Synced() {
err = errors.Errorf("can't issue payload: %w", ErrNotSynced)
return
}
- if payload.Type() == ledgerstate.TransactionType {
+ if p.Type() == ledgerstate.TransactionType {
var invalidInputs []string
- transaction := payload.(*ledgerstate.Transaction)
+ transaction := p.(*ledgerstate.Transaction)
for _, input := range transaction.Essence().Inputs() {
if input.Type() == ledgerstate.UTXOInputType {
t.LedgerState.OutputMetadata(input.(*ledgerstate.UTXOInput).ReferencedOutputID()).Consume(func(outputMetadata *ledgerstate.OutputMetadata) {
@@ -152,7 +152,7 @@ func (t *Tangle) IssuePayload(payload payload.Payload) (message *Message, err er
}
}
- return t.MessageFactory.IssuePayload(payload, t)
+ return t.MessageFactory.IssuePayload(p, parentsCount...)
}
// Synced returns a boolean value that indicates if the node is fully synced and the Tangle has solidified all messages
@@ -206,6 +206,11 @@ func MessageIDCaller(handler interface{}, params ...interface{}) {
handler.(func(MessageID))(params[0].(MessageID))
}
+// MessageCaller is the caller function for events that hand over a Message.
+func MessageCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*Message))(params[0].(*Message))
+}
+
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
// region Options //////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/tangle/timemanager.go b/packages/tangle/timemanager.go
index 5154ab0f89..ade68023ac 100644
--- a/packages/tangle/timemanager.go
+++ b/packages/tangle/timemanager.go
@@ -4,16 +4,15 @@ import (
"sync"
"time"
- "github.com/cockroachdb/errors"
+ "github.com/iotaledger/goshimmer/packages/clock"
+ "github.com/iotaledger/goshimmer/packages/markers"
+ "github.com/cockroachdb/errors"
"github.com/iotaledger/hive.go/cerrors"
"github.com/iotaledger/hive.go/events"
"github.com/iotaledger/hive.go/kvstore"
"github.com/iotaledger/hive.go/marshalutil"
"github.com/iotaledger/hive.go/stringify"
-
- "github.com/iotaledger/goshimmer/packages/clock"
- "github.com/iotaledger/goshimmer/packages/markers"
)
const (
@@ -26,40 +25,47 @@ const (
// entire network as it tracks the time of the last confirmed message. Comparing the issuing time of the last confirmed
// message to the node's current wall clock time then yields a reasonable assessment of how much in sync the node is.
type TimeManager struct {
- tangle *Tangle
-
- lastConfirmedMessage LastConfirmedMessage
- lastConfirmedMutex sync.RWMutex
+ Events *TimeManagerEvents
+ tangle *Tangle
startSynced bool
+
+ lastConfirmedMutex sync.RWMutex
+ lastConfirmedMessage LastConfirmedMessage
+ lastSynced bool
}
// NewTimeManager is the constructor for TimeManager.
-func NewTimeManager(tangle *Tangle) (timeManager *TimeManager) {
- timeManager = &TimeManager{
+func NewTimeManager(tangle *Tangle) *TimeManager {
+ t := &TimeManager{
+ Events: &TimeManagerEvents{
+ SyncChanged: events.NewEvent(SyncChangedCaller),
+ },
tangle: tangle,
startSynced: tangle.Options.StartSynced,
}
+ // initialize with Genesis
+ t.lastConfirmedMessage = LastConfirmedMessage{
+ MessageID: EmptyMessageID,
+ Time: time.Unix(DefaultGenesisTime, 0),
+ }
+
marshaledLastConfirmedMessage, err := tangle.Options.Store.Get(kvstore.Key(lastConfirmedKey))
if err != nil && !errors.Is(err, kvstore.ErrKeyNotFound) {
panic(err)
}
- // Load from storage if key was found.
+ // load from storage if key was found
if marshaledLastConfirmedMessage != nil {
- if timeManager.lastConfirmedMessage, _, err = lastConfirmedMessageFromBytes(marshaledLastConfirmedMessage); err != nil {
+ if t.lastConfirmedMessage, _, err = lastConfirmedMessageFromBytes(marshaledLastConfirmedMessage); err != nil {
panic(err)
}
- return
}
- // Initialize with Genesis if not found in storage.
- timeManager.lastConfirmedMessage = LastConfirmedMessage{
- MessageID: EmptyMessageID,
- Time: time.Unix(DefaultGenesisTime, 0),
- }
+ // initialize the synced status
+ t.lastSynced = t.synced()
- return
+ return t
}
// Setup sets up the behavior of the component by making it attach to the relevant events of other components.
@@ -100,6 +106,10 @@ func (t *TimeManager) Synced() bool {
t.lastConfirmedMutex.RLock()
defer t.lastConfirmedMutex.RUnlock()
+ return t.lastSynced
+}
+
+func (t *TimeManager) synced() bool {
if t.startSynced && t.lastConfirmedMessage.Time.Unix() == DefaultGenesisTime {
return true
}
@@ -124,6 +134,12 @@ func (t *TimeManager) updateTime(marker markers.Marker, newLevel int, transition
MessageID: messageID,
Time: message.IssuingTime(),
}
+
+ if newSynced := t.synced(); t.lastSynced != newSynced {
+ t.lastSynced = newSynced
+ // trigger the event inside the lock to assure that the status is still correct
+ t.Events.SyncChanged.Trigger(&SyncChangedEvent{Synced: newSynced})
+ }
}
})
}
@@ -183,3 +199,23 @@ func (l LastConfirmedMessage) String() string {
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region TimeManagerEvents ////////////////////////////////////////////////////////////////////////////////////////////
+
+// TimeManagerEvents represents events happening in the TimeManager.
+type TimeManagerEvents struct {
+ // Fired when the nodes sync status changes.
+ SyncChanged *events.Event
+}
+
+// SyncChangedEvent represents a syn changed event.
+type SyncChangedEvent struct {
+ Synced bool
+}
+
+// SyncChangedCaller is the caller function for sync changed event.
+func SyncChangedCaller(handler interface{}, params ...interface{}) {
+ handler.(func(ev *SyncChangedEvent))(params[0].(*SyncChangedEvent))
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/txstream/chopper/chopper.go b/packages/txstream/chopper/chopper.go
new file mode 100644
index 0000000000..263ea769b1
--- /dev/null
+++ b/packages/txstream/chopper/chopper.go
@@ -0,0 +1,181 @@
+// Package chopper helps splitting messages into smaller pieces and reassemble them
+package chopper
+
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import (
+ "bytes"
+ "fmt"
+ "sync"
+ "time"
+)
+
+const (
+ // for the final data packet to be not bigger than tangle.MaxMessageSize
+ // 4 - chunk id, 1 seq nr, 1 num chunks, 2 - data len
+ chunkHeaderSize = 4 + 1 + 1 + 2
+ maxTTL = 5 * time.Minute
+ cleanupLoopInterval = 10 * time.Second
+)
+
+// Chopper handles the splitting and joining of large messages
+type Chopper struct {
+ nextID uint32
+ mutex sync.Mutex
+ chunks map[uint32]*dataInProgress
+ closeCh chan bool
+}
+
+type dataInProgress struct {
+ buffer [][]byte
+ ttl time.Time
+ numReceived int
+}
+
+// NewChopper creates a new chopper instance
+func NewChopper() *Chopper {
+ c := Chopper{
+ nextID: 0,
+ chunks: make(map[uint32]*dataInProgress),
+ closeCh: make(chan bool),
+ }
+ go c.cleanupLoop()
+ return &c
+}
+
+// Close stops the internal cleanup goroutine
+func (c *Chopper) Close() {
+ close(c.closeCh)
+}
+
+func (c *Chopper) cleanupLoop() {
+ for {
+ select {
+ case <-c.closeCh:
+ return
+ case <-time.After(cleanupLoopInterval):
+ toDelete := make([]uint32, 0)
+ nowis := time.Now()
+ c.mutex.Lock()
+ for id, dip := range c.chunks {
+ if nowis.After(dip.ttl) {
+ toDelete = append(toDelete, id)
+ }
+ }
+ for _, id := range toDelete {
+ delete(c.chunks, id)
+ }
+ c.mutex.Unlock()
+ }
+ }
+}
+
+func (c *Chopper) getNextMsgID() uint32 {
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+ c.nextID++
+ return c.nextID
+}
+
+// NumChunks returns the expected amount of chunks for the given data length
+func NumChunks(dataLen, maxMsgSize, includingChoppingOverhead int) (byte, int, error) {
+ if dataLen <= maxMsgSize {
+ return 0, 0, nil // no need to split
+ }
+ maxChunkSize := maxMsgSize - includingChoppingOverhead
+ maxSizeWithoutHeader := maxChunkSize - chunkHeaderSize
+ if dataLen > maxChunkSize*255 {
+ return 0, 0, fmt.Errorf("chopper.NumChunks: too long data to chop")
+ }
+ numChunks := dataLen / maxSizeWithoutHeader
+ if dataLen%maxSizeWithoutHeader > 0 {
+ numChunks++
+ }
+ if numChunks < 2 {
+ panic("ChopData: internal inconsistency")
+ }
+ return byte(numChunks), maxChunkSize, nil
+}
+
+// ChopData chops data into pieces (not more than 255) and adds chopper header to each piece
+// for IncomingChunk function to reassemble it
+func (c *Chopper) ChopData(data []byte, maxMsgSize, includingChoppingOverhead int) ([][]byte, bool, error) {
+ numChunks, maxChunkSize, err := NumChunks(len(data), maxMsgSize, includingChoppingOverhead)
+ if err != nil {
+ return nil, false, err
+ }
+ if numChunks == 0 {
+ return nil, false, nil
+ }
+ maxSizeWithoutHeader := maxChunkSize - chunkHeaderSize
+ id := c.getNextMsgID()
+ ret := make([][]byte, 0, numChunks)
+ var d []byte
+ for i := byte(0); i < numChunks; i++ {
+ if len(data) > maxSizeWithoutHeader {
+ d = data[:maxSizeWithoutHeader]
+ data = data[maxSizeWithoutHeader:]
+ } else {
+ d = data
+ }
+ chunk := &msgChunk{
+ msgID: id,
+ chunkSeqNum: i,
+ numChunks: numChunks,
+ data: d,
+ }
+ dtmp := chunk.encode()
+ if len(dtmp) > maxMsgSize {
+ panic("ChopData: internal inconsistency 2")
+ }
+ ret = append(ret, dtmp)
+ }
+ return ret, true, nil
+}
+
+// IncomingChunk collects all incoming chunks.
+// Returned != nil value of the reassembled data
+// maxChunkSize parameter must be the same on both sides
+func (c *Chopper) IncomingChunk(data []byte, maxMsgSize, includingChoppingOverhead int) ([]byte, error) {
+ maxChunkSize := maxMsgSize - includingChoppingOverhead
+ maxSizeWithoutHeader := maxChunkSize - chunkHeaderSize
+ msg := msgChunk{}
+ if err := msg.decode(data, maxSizeWithoutHeader); err != nil {
+ return nil, err
+ }
+ switch {
+ case len(msg.data) > maxChunkSize:
+ return nil, fmt.Errorf("IncomingChunk: too long data chunk")
+
+ case msg.chunkSeqNum >= msg.numChunks:
+ return nil, fmt.Errorf("IncomingChunk: wrong incoming data chunk seq number")
+ }
+
+ c.mutex.Lock()
+ defer c.mutex.Unlock()
+
+ dip, ok := c.chunks[msg.msgID]
+ if !ok {
+ dip = &dataInProgress{
+ buffer: make([][]byte, int(msg.numChunks)),
+ ttl: time.Now().Add(maxTTL),
+ }
+ c.chunks[msg.msgID] = dip
+ } else if dip.buffer[msg.chunkSeqNum] != nil {
+ return nil, fmt.Errorf("IncomingChunk: repeating seq number")
+ }
+ dip.buffer[msg.chunkSeqNum] = msg.data
+ dip.numReceived++
+
+ if dip.numReceived != len(dip.buffer) {
+ return nil, nil
+ }
+ // finished assembly of data chunks
+ var buf bytes.Buffer
+ for _, d := range dip.buffer {
+ buf.Write(d)
+ }
+ delete(c.chunks, msg.msgID)
+ return buf.Bytes(), nil
+}
diff --git a/packages/txstream/chopper/chopper_test.go b/packages/txstream/chopper/chopper_test.go
new file mode 100644
index 0000000000..a846b5fa79
--- /dev/null
+++ b/packages/txstream/chopper/chopper_test.go
@@ -0,0 +1,133 @@
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+package chopper_test
+
+import (
+ "bytes"
+ "crypto/rand"
+ "testing"
+
+ "github.com/iotaledger/goshimmer/packages/txstream/chopper"
+
+ "github.com/stretchr/testify/assert"
+)
+
+const choppingOverhead = 3
+
+//goland:noinspection ALL
+func testParameters(t *testing.T, maxMsgSize, dataLen int, expectChopped bool, expectNumChunks int) {
+ c := chopper.NewChopper()
+
+ data := make([]byte, dataLen)
+ rand.Read(data)
+
+ chopped, ok, err := c.ChopData(data, maxMsgSize, choppingOverhead)
+ assert.NoError(t, err)
+ assert.EqualValues(t, ok, expectChopped)
+ if !ok {
+ return
+ }
+ assert.Equal(t, expectNumChunks, len(chopped))
+ assert.True(t, checkChunkLengths(chopped, maxMsgSize))
+ for _, piece := range chopped {
+ ret, err := c.IncomingChunk(piece, maxMsgSize, choppingOverhead)
+ assert.NoError(t, err)
+ if ret != nil {
+ assert.True(t, bytes.Equal(data, ret))
+ }
+ }
+}
+
+func checkChunkLengths(chopped [][]byte, maxChunkSize int) bool {
+ for _, d := range chopped {
+ if len(d) > maxChunkSize {
+ return false
+ }
+ }
+ return true
+}
+
+func Test16K(t *testing.T) {
+ maxMsgSize := 16 * 1024
+ testParameters(t, maxMsgSize, 100, false, -1)
+ testParameters(t, maxMsgSize, 200, false, -1)
+ testParameters(t, maxMsgSize, 2000, false, -1)
+ num, _, _ := chopper.NumChunks(30000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 30000, true, int(num))
+ num, _, _ = chopper.NumChunks(1000000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 1000000, true, int(num))
+ testParameters(t, maxMsgSize, maxMsgSize-2, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize-1, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize+1, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+2, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+3, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+4, true, 2)
+ testParameters(t, maxMsgSize, 2*maxMsgSize, true, 3)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, 4)
+ num, _, _ = chopper.NumChunks(3*maxMsgSize, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, int(num))
+}
+
+func Test500B(t *testing.T) {
+ maxMsgSize := 500
+ testParameters(t, maxMsgSize, 100, false, -1)
+ testParameters(t, maxMsgSize, 200, false, -1)
+ testParameters(t, maxMsgSize, 2000, true, 5)
+ num, _, _ := chopper.NumChunks(30000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 30000, true, int(num))
+ num, _, _ = chopper.NumChunks(100000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 100000, true, int(num))
+ testParameters(t, maxMsgSize, maxMsgSize-2, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize-1, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize+1, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+2, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+3, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+4, true, 2)
+ testParameters(t, maxMsgSize, 2*maxMsgSize, true, 3)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, 4)
+ num, _, _ = chopper.NumChunks(3*maxMsgSize, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, int(num))
+}
+
+func TestMaxTangleMessage(t *testing.T) {
+ maxMsgSize := 64 * 1024
+ testParameters(t, maxMsgSize, 100, false, -1)
+ testParameters(t, maxMsgSize, 200, false, -1)
+ testParameters(t, maxMsgSize, 2000, false, -1)
+ num, _, _ := chopper.NumChunks(66000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 66000, true, int(num))
+ num, _, _ = chopper.NumChunks(1000000, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 1000000, true, int(num))
+ testParameters(t, maxMsgSize, maxMsgSize-2, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize-1, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize, false, -1)
+ testParameters(t, maxMsgSize, maxMsgSize+1, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+2, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+3, true, 2)
+ testParameters(t, maxMsgSize, maxMsgSize+4, true, 2)
+ testParameters(t, maxMsgSize, 2*maxMsgSize, true, 3)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, 4)
+ num, _, _ = chopper.NumChunks(3*maxMsgSize, maxMsgSize, choppingOverhead)
+ testParameters(t, maxMsgSize, 3*maxMsgSize, true, int(num))
+}
+
+//goland:noinspection ALL
+func TestTooLongData(t *testing.T) {
+ tooLong := 1000000
+ short := 10000
+ chunk := 500
+ assert.True(t, tooLong/chunk+1 > 255)
+
+ dataLong := make([]byte, tooLong)
+ rand.Read(dataLong)
+ c := chopper.NewChopper()
+ _, _, err := c.ChopData(dataLong, 500, choppingOverhead)
+ assert.Error(t, err)
+
+ dataShort := make([]byte, short)
+ rand.Read(dataShort)
+ _, _, err = c.ChopData(dataShort, 500, choppingOverhead)
+ assert.NoError(t, err)
+}
diff --git a/packages/txstream/chopper/msgChunk.go b/packages/txstream/chopper/msgChunk.go
new file mode 100644
index 0000000000..32e265cd26
--- /dev/null
+++ b/packages/txstream/chopper/msgChunk.go
@@ -0,0 +1,56 @@
+package chopper
+
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import (
+ "fmt"
+
+ "github.com/iotaledger/hive.go/marshalutil"
+)
+
+// msgChunk is a special wrapper message for chunks of larger than buffer messages
+type msgChunk struct {
+ msgID uint32
+ chunkSeqNum byte
+ numChunks byte
+ data []byte
+}
+
+func (c *msgChunk) encode() []byte {
+ m := marshalutil.New()
+ m.WriteUint32(c.msgID)
+ m.WriteByte(c.numChunks)
+ m.WriteByte(c.chunkSeqNum)
+ m.WriteUint16(uint16(len(c.data)))
+ m.WriteBytes(c.data)
+ return m.Bytes()
+}
+
+func (c *msgChunk) decode(data []byte, maxChunkSizeWithoutHeader int) error {
+ m := marshalutil.New(data)
+ var err error
+ if c.msgID, err = m.ReadUint32(); err != nil {
+ return err
+ }
+ if c.numChunks, err = m.ReadByte(); err != nil {
+ return err
+ }
+ if c.chunkSeqNum, err = m.ReadByte(); err != nil {
+ return err
+ }
+ var size uint16
+ if size, err = m.ReadUint16(); err != nil {
+ return err
+ }
+ if c.data, err = m.ReadBytes(int(size)); err != nil {
+ return err
+ }
+ if c.chunkSeqNum >= c.numChunks {
+ return fmt.Errorf("wrong data chunk format")
+ }
+ if len(c.data) != maxChunkSizeWithoutHeader && c.chunkSeqNum != c.numChunks-1 {
+ return fmt.Errorf("wrong data chunk length")
+ }
+ return nil
+}
diff --git a/packages/txstream/client/client.go b/packages/txstream/client/client.go
new file mode 100644
index 0000000000..a9c767805e
--- /dev/null
+++ b/packages/txstream/client/client.go
@@ -0,0 +1,93 @@
+package client
+
+import (
+ "net"
+
+ "github.com/iotaledger/hive.go/events"
+ "github.com/iotaledger/hive.go/logger"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+)
+
+// Client represents the client-side connection to a txstream server
+type Client struct {
+ clientID string
+ log *logger.Logger
+ chSend chan txstream.Message
+ chSubscribe chan ledgerstate.Address
+ chUnsubscribe chan ledgerstate.Address
+ shutdown chan bool
+ Events Events
+}
+
+// Events contains all events emitted by the Client
+type Events struct {
+ // TransactionReceived is triggered when a transaction message is received from the server
+ TransactionReceived *events.Event
+ // InclusionStateReceived is triggered when an inclusion state message is received from the server
+ InclusionStateReceived *events.Event
+ // OutputReceived is triggered whenever individual output is received
+ OutputReceived *events.Event
+ // UnspentAliasOutputReceived is triggered whenever an unspent AliasOutput is received
+ UnspentAliasOutputReceived *events.Event
+ // Connected is triggered when the client connects successfully to the server
+ Connected *events.Event
+}
+
+// DialFunc is a function that performs the TCP connection to the server
+type DialFunc func() (addr string, conn net.Conn, err error)
+
+func handleTransactionReceived(handler interface{}, params ...interface{}) {
+ handler.(func(*txstream.MsgTransaction))(params[0].(*txstream.MsgTransaction))
+}
+
+func handleOutputReceived(handler interface{}, params ...interface{}) {
+ handler.(func(output *txstream.MsgOutput))(params[0].(*txstream.MsgOutput))
+}
+
+func handleUnspentAliasOutputReceived(handler interface{}, params ...interface{}) {
+ handler.(func(output *txstream.MsgUnspentAliasOutput))(params[0].(*txstream.MsgUnspentAliasOutput))
+}
+
+func handleInclusionStateReceived(handler interface{}, params ...interface{}) {
+ handler.(func(*txstream.MsgTxInclusionState))(params[0].(*txstream.MsgTxInclusionState))
+}
+
+func handleConnected(handler interface{}, params ...interface{}) {
+ handler.(func())()
+}
+
+// New creates a new client
+func New(clientID string, log *logger.Logger, dial DialFunc) *Client {
+ n := &Client{
+ clientID: clientID,
+ log: log,
+ chSend: make(chan txstream.Message),
+ chSubscribe: make(chan ledgerstate.Address),
+ chUnsubscribe: make(chan ledgerstate.Address),
+ shutdown: make(chan bool),
+ Events: Events{
+ TransactionReceived: events.NewEvent(handleTransactionReceived),
+ InclusionStateReceived: events.NewEvent(handleInclusionStateReceived),
+ OutputReceived: events.NewEvent(handleOutputReceived),
+ UnspentAliasOutputReceived: events.NewEvent(handleUnspentAliasOutputReceived),
+ Connected: events.NewEvent(handleConnected),
+ },
+ }
+
+ go n.subscriptionsLoop()
+ go n.connectLoop(dial)
+
+ return n
+}
+
+// Close shuts down the client
+func (n *Client) Close() {
+ close(n.shutdown)
+ n.Events.TransactionReceived.DetachAll()
+ n.Events.InclusionStateReceived.DetachAll()
+ n.Events.OutputReceived.DetachAll()
+ n.Events.UnspentAliasOutputReceived.DetachAll()
+ n.Events.Connected.DetachAll()
+}
diff --git a/packages/txstream/client/client_test.go b/packages/txstream/client/client_test.go
new file mode 100644
index 0000000000..fedb689459
--- /dev/null
+++ b/packages/txstream/client/client_test.go
@@ -0,0 +1,306 @@
+package client
+
+import (
+ "net"
+ "testing"
+ "time"
+
+ "github.com/iotaledger/hive.go/events"
+ "github.com/iotaledger/hive.go/logger"
+ "github.com/stretchr/testify/require"
+ "go.uber.org/zap"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/ledgerstate/utxoutil"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+ "github.com/iotaledger/goshimmer/packages/txstream/server"
+ "github.com/iotaledger/goshimmer/packages/txstream/utxodbledger"
+)
+
+const (
+ creatorIndex = 2
+ stateControlIndex = 3
+)
+
+var log = initLog()
+
+func initLog() *logger.Logger {
+ log, err := zap.NewDevelopment()
+ if err != nil {
+ panic(err)
+ }
+ return log.Sugar()
+}
+
+func start(t *testing.T) (*utxodbledger.UtxoDBLedger, *Client) {
+ t.Helper()
+
+ ledger := utxodbledger.New()
+ t.Cleanup(ledger.Detach)
+
+ done := make(chan struct{})
+ t.Cleanup(func() { close(done) })
+
+ dial := DialFunc(func() (string, net.Conn, error) {
+ conn1, conn2 := net.Pipe()
+ go server.Run(conn2, log.Named("txstream/server"), ledger, done)
+ return "pipe", conn1, nil
+ })
+
+ n := New("test", log.Named("txstream/client"), dial)
+ t.Cleanup(n.Close)
+
+ return ledger, n
+}
+
+func send(t *testing.T, n *Client, sendMsg func(), callback func(msg txstream.Message) bool) {
+ t.Helper()
+
+ received := make(chan txstream.Message)
+ enqueueMessage := func(msg txstream.Message) { received <- msg }
+
+ {
+ cl := events.NewClosure(func(msg *txstream.MsgTransaction) { go enqueueMessage(msg) })
+ n.Events.TransactionReceived.Attach(cl)
+ defer n.Events.TransactionReceived.Detach(cl)
+ }
+ {
+ cl := events.NewClosure(func(msg *txstream.MsgTxInclusionState) { go enqueueMessage(msg) })
+ n.Events.InclusionStateReceived.Attach(cl)
+ defer n.Events.InclusionStateReceived.Detach(cl)
+ }
+ {
+ cl := events.NewClosure(func(msg *txstream.MsgOutput) { go enqueueMessage(msg) })
+ n.Events.OutputReceived.Attach(cl)
+ defer n.Events.OutputReceived.Detach(cl)
+ }
+ {
+ cl := events.NewClosure(func(msg *txstream.MsgUnspentAliasOutput) { go enqueueMessage(msg) })
+ n.Events.UnspentAliasOutputReceived.Attach(cl)
+ defer n.Events.OutputReceived.Detach(cl)
+ }
+
+ sendMsg()
+
+ for {
+ select {
+ case msg := <-received:
+ if callback(msg) {
+ return
+ }
+ case <-time.After(10 * time.Second):
+ t.Fatalf("timeout")
+ }
+ }
+}
+
+func createAliasChain(t *testing.T, u *utxodbledger.UtxoDBLedger, creatorIndex, stateControlIndex int, balances map[ledgerstate.Color]uint64) (*ledgerstate.Transaction, *ledgerstate.AliasAddress) {
+ t.Helper()
+
+ creatorKP, creatorAddr := u.NewKeyPairByIndex(creatorIndex)
+ err := u.RequestFunds(creatorAddr)
+ require.NoError(t, err)
+
+ _, addrStateControl := u.NewKeyPairByIndex(stateControlIndex)
+ outputs := u.GetAddressOutputs(creatorAddr)
+ txb := utxoutil.NewBuilder(outputs...)
+ err = txb.AddNewAliasMint(balances, addrStateControl, nil)
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(creatorAddr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(creatorKP)
+ require.NoError(t, err)
+
+ err = u.PostTransaction(tx)
+ require.NoError(t, err)
+
+ chainOutput, err := utxoutil.GetSingleChainedAliasOutput(tx)
+ require.NoError(t, err)
+ chainAddress := chainOutput.GetAliasAddress()
+ t.Logf("chain address: %s", chainAddress.Base58())
+
+ return tx, chainAddress
+}
+
+func TestRequestBacklog(t *testing.T) {
+ ledger, n := start(t)
+
+ tx, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+
+ // request backlog for chainAddress
+ var resp *txstream.MsgTransaction
+ send(t, n,
+ func() {
+ n.RequestBacklog(chainAddress)
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgTransaction); ok {
+ resp = msg
+ return true
+ }
+ return false
+ },
+ )
+
+ // assert response message
+ require.EqualValues(t, chainAddress.Base58(), resp.Address.Base58())
+
+ _, creatorAddr := ledger.NewKeyPairByIndex(creatorIndex)
+ t.Logf("creator address: %s", creatorAddr.Base58())
+
+ require.Equal(t, tx.ID(), resp.Tx.ID())
+
+ chainOutput, err := utxoutil.GetSingleChainedAliasOutput(resp.Tx)
+ require.NoError(t, err)
+ require.EqualValues(t, chainAddress.Base58(), chainOutput.Address().Base58())
+}
+
+func postRequest(t *testing.T, u *utxodbledger.UtxoDBLedger, fromIndex int, chainAddress *ledgerstate.AliasAddress) *ledgerstate.Transaction {
+ kp, addr := u.NewKeyPairByIndex(fromIndex)
+
+ outs := u.GetAddressOutputs(addr)
+
+ txb := utxoutil.NewBuilder(outs...)
+ err := txb.AddExtendedOutputConsume(chainAddress, []byte{1, 3, 3, 7}, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 1})
+ require.NoError(t, err)
+ err = txb.AddRemainderOutputIfNeeded(addr, nil)
+ require.NoError(t, err)
+ tx, err := txb.BuildWithED25519(kp)
+ require.NoError(t, err)
+
+ err = u.PostTransaction(tx)
+ require.NoError(t, err)
+
+ return tx
+}
+
+func TestPostRequest(t *testing.T) {
+ ledger, n := start(t)
+
+ createTx, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+
+ reqTx := postRequest(t, ledger, 2, chainAddress)
+
+ // request backlog for chainAddress
+ seen := make(map[ledgerstate.TransactionID]bool)
+ send(t, n,
+ func() {
+ n.RequestBacklog(chainAddress)
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgTransaction); ok {
+ seen[msg.Tx.ID()] = true
+ if len(seen) == 2 {
+ return true
+ }
+ }
+ return false
+ },
+ )
+
+ require.Equal(t, 2, len(seen))
+ require.True(t, seen[createTx.ID()])
+ require.True(t, seen[reqTx.ID()])
+}
+
+func TestRequestInclusionLevel(t *testing.T) {
+ ledger, n := start(t)
+ createTx, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+
+ // request inclusion level
+ var resp *txstream.MsgTxInclusionState
+ send(t, n,
+ func() {
+ n.RequestTxInclusionState(chainAddress, createTx.ID())
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgTxInclusionState); ok {
+ resp = msg
+ return true
+ }
+ return false
+ },
+ )
+
+ require.EqualValues(t, ledgerstate.Confirmed, resp.State)
+}
+
+func TestRequestOutput(t *testing.T) {
+ ledger, n := start(t)
+ createTx, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+ chainOutput, err := utxoutil.GetSingleChainedAliasOutput(createTx)
+ require.NoError(t, err)
+
+ // request chain output
+ var resp *txstream.MsgOutput
+ send(t, n,
+ func() {
+ n.RequestConfirmedOutput(chainAddress, chainOutput.ID())
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgOutput); ok {
+ resp = msg
+ return true
+ }
+ return false
+ },
+ )
+
+ require.True(t, chainAddress.Equals(resp.Address))
+ require.True(t, chainOutput.Compare(resp.Output) == 0)
+ require.Zero(t, resp.OutputMetadata.ConsumerCount())
+}
+
+func TestRequestAliasOutput(t *testing.T) {
+ ledger, n := start(t)
+ createTx, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+ chainOutput, err := utxoutil.GetSingleChainedAliasOutput(createTx)
+ require.NoError(t, err)
+
+ // request chain output
+ var resp *txstream.MsgUnspentAliasOutput
+ send(t, n,
+ func() {
+ n.RequestUnspentAliasOutput(chainAddress)
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgUnspentAliasOutput); ok {
+ resp = msg
+ return true
+ }
+ return false
+ },
+ )
+
+ require.True(t, chainAddress.Equals(resp.AliasAddress))
+ require.True(t, chainOutput.Compare(resp.AliasOutput) == 0)
+ require.Zero(t, resp.OutputMetadata.ConsumerCount())
+}
+
+func TestSubscribe(t *testing.T) {
+ ledger, n := start(t)
+ _, chainAddress := createAliasChain(t, ledger, creatorIndex, stateControlIndex, map[ledgerstate.Color]uint64{ledgerstate.ColorIOTA: 100})
+
+ // subscribe to chain address
+ n.Subscribe(chainAddress)
+
+ // post a request to chain, expect to receive notification
+ var reqTx *ledgerstate.Transaction
+ var txMsg *txstream.MsgTransaction
+
+ send(t, n,
+ func() {
+ reqTx = postRequest(t, ledger, 2, chainAddress)
+ },
+ func(msg txstream.Message) bool {
+ if msg, ok := msg.(*txstream.MsgTransaction); ok {
+ if msg.Tx.ID() == reqTx.ID() {
+ txMsg = msg
+ return true
+ }
+ }
+ return false
+ },
+ )
+ require.EqualValues(t, txMsg.Tx.ID(), reqTx.ID())
+}
diff --git a/packages/txstream/client/connection.go b/packages/txstream/client/connection.go
new file mode 100644
index 0000000000..006cf38652
--- /dev/null
+++ b/packages/txstream/client/connection.go
@@ -0,0 +1,185 @@
+package client
+
+import (
+ "fmt"
+ "io"
+ "net"
+ "strings"
+ "time"
+
+ "github.com/iotaledger/hive.go/backoff"
+ "github.com/iotaledger/hive.go/events"
+ "github.com/iotaledger/hive.go/netutil/buffconn"
+
+ "github.com/iotaledger/goshimmer/packages/tangle"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+ "github.com/iotaledger/goshimmer/packages/txstream/chopper"
+)
+
+const (
+ dialRetries = 10
+ backoffDelay = 500 * time.Millisecond
+ retryAfter = 8 * time.Second
+)
+
+// retry net.Dial once, on fail after 0.5s
+var dialRetryPolicy = backoff.ConstantBackOff(backoffDelay).With(backoff.MaxRetries(dialRetries))
+
+func (n *Client) connectLoop(dial DialFunc) {
+ msgChopper := chopper.NewChopper()
+ for {
+ retry := n.connect(dial, msgChopper)
+ if !retry {
+ return
+ }
+ n.log.Infof("disconnected from server - will retry reconnecting after %v", retryAfter)
+ select {
+ case <-n.shutdown:
+ return
+ case <-time.After(retryAfter):
+ }
+ }
+}
+
+// dials outbound address and established connection
+func (n *Client) connect(dial DialFunc, msgChopper *chopper.Chopper) bool {
+ var addr string
+ var conn net.Conn
+ if err := backoff.Retry(dialRetryPolicy, func() error {
+ var err error
+ addr, conn, err = dial()
+ if err != nil {
+ return fmt.Errorf("can't connect with the server: %v", err)
+ }
+ return nil
+ }); err != nil {
+ n.log.Warn(err)
+ // retry
+ return true
+ }
+
+ bconn := buffconn.NewBufferedConnection(conn, tangle.MaxMessageSize)
+ defer func() {
+ n.log.Debugf("closing bconn")
+ bconn.Close()
+ }()
+ n.Events.Connected.Trigger()
+
+ n.log.Debugf("established connection with server at %s", addr)
+
+ dataReceived := make(chan []byte)
+ {
+ cl := events.NewClosure(func(data []byte) {
+ // data slice is from internal buffconn buffer
+ d := make([]byte, len(data))
+ copy(d, data)
+ dataReceived <- d
+ })
+ bconn.Events.ReceiveMessage.Attach(cl)
+ defer bconn.Events.ReceiveMessage.Detach(cl)
+ }
+
+ connectionClosed := make(chan bool)
+ {
+ cl := events.NewClosure(func() {
+ n.log.Errorf("lost connection with %s", addr)
+ close(connectionClosed)
+ })
+ bconn.Events.Close.Attach(cl)
+ defer bconn.Events.Close.Detach(cl)
+ }
+
+ // read loop
+ go func() {
+ if err := bconn.Read(); err != nil {
+ if err != io.EOF && !strings.Contains(err.Error(), "use of closed network connection") {
+ n.log.Warnw("bconn read error", "err", err)
+ }
+ }
+ }()
+
+ // send client ID
+ if err := n.send(&txstream.MsgSetID{ClientID: n.clientID}, bconn, msgChopper); err != nil {
+ n.log.Errorf("sending client ID to server: %v", err)
+ }
+
+ // r/w loop
+ for {
+ select {
+ case msg := <-n.chSend:
+ if err := n.send(msg, bconn, msgChopper); err != nil {
+ n.log.Errorf("sending message to server (%T): %v", msg, err)
+ }
+ case d := <-dataReceived:
+ if err := n.decodeReceivedMessage(d, msgChopper); err != nil {
+ n.log.Errorf("decoding message from server: %v", err)
+ }
+ case <-n.shutdown:
+ return false
+ case <-connectionClosed:
+ return true // retry
+ }
+ }
+}
+
+func (n *Client) decodeReceivedMessage(data []byte, msgChopper *chopper.Chopper) error {
+ msg, err := txstream.DecodeMsg(data, txstream.FlagServerToClient)
+ if err != nil {
+ return fmt.Errorf("txstream.DecodeMsg: %w", err)
+ }
+
+ switch msg := msg.(type) {
+ case *txstream.MsgChunk:
+ finalData, err := msgChopper.IncomingChunk(msg.Data, tangle.MaxMessageSize, txstream.ChunkMessageHeaderSize)
+ if err != nil {
+ return fmt.Errorf("receiving msgchunk: %w", err)
+ }
+ if finalData != nil {
+ return n.decodeReceivedMessage(finalData, msgChopper)
+ }
+ case *txstream.MsgTransaction:
+ n.log.Debugf("received message from server: %T", msg)
+ n.Events.TransactionReceived.Trigger(msg)
+
+ case *txstream.MsgTxInclusionState:
+ n.log.Debugf("received message from server: %T", msg)
+ n.Events.InclusionStateReceived.Trigger(msg)
+
+ case *txstream.MsgOutput:
+ n.log.Debugf("received message from server: %T", msg)
+ n.Events.OutputReceived.Trigger(msg)
+
+ case *txstream.MsgUnspentAliasOutput:
+ n.log.Debugf("received message from server: %T", msg)
+ n.Events.UnspentAliasOutputReceived.Trigger(msg)
+
+ default:
+ n.log.Errorf("received unknkwn message from server: %T", msg)
+ }
+ return nil
+}
+
+// sendMessage is a thread-safe request to send a message to the server
+func (n *Client) sendMessage(msg txstream.Message) {
+ n.chSend <- msg
+}
+
+// send writes a message into the server connection
+func (n *Client) send(msg txstream.Message, bconn *buffconn.BufferedConnection, msgChopper *chopper.Chopper) error {
+ n.log.Debugf("sending message to server: %T", msg)
+ data := txstream.EncodeMsg(msg)
+ choppedData, chopped, err := msgChopper.ChopData(data, tangle.MaxMessageSize, txstream.ChunkMessageHeaderSize)
+ if err != nil {
+ return err
+ }
+ if !chopped {
+ _, err = bconn.Write(data)
+ return err
+ }
+ for _, piece := range choppedData {
+ if _, err = bconn.Write(txstream.EncodeMsg(&txstream.MsgChunk{Data: piece})); err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/packages/txstream/client/send.go b/packages/txstream/client/send.go
new file mode 100644
index 0000000000..10bf7cd85e
--- /dev/null
+++ b/packages/txstream/client/send.go
@@ -0,0 +1,47 @@
+package client
+
+import (
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+)
+
+// RequestBacklog requests the backlog for a given address
+func (n *Client) RequestBacklog(addr ledgerstate.Address) {
+ n.sendMessage(&txstream.MsgGetBacklog{Address: addr})
+}
+
+// RequestConfirmedTransaction requests a specific confirmed transaction
+func (n *Client) RequestConfirmedTransaction(addr ledgerstate.Address, txid ledgerstate.TransactionID) {
+ n.sendMessage(&txstream.MsgGetConfirmedTransaction{
+ Address: addr,
+ TxID: txid,
+ })
+}
+
+// RequestTxInclusionState requests the inclusion state of a transaction
+func (n *Client) RequestTxInclusionState(addr ledgerstate.Address, txid ledgerstate.TransactionID) {
+ n.sendMessage(&txstream.MsgGetTxInclusionState{
+ Address: addr,
+ TxID: txid,
+ })
+}
+
+// RequestConfirmedOutput requests a specific confirmed output
+func (n *Client) RequestConfirmedOutput(addr ledgerstate.Address, outputID ledgerstate.OutputID) {
+ n.sendMessage(&txstream.MsgGetConfirmedOutput{
+ Address: addr,
+ OutputID: outputID,
+ })
+}
+
+// RequestUnspentAliasOutput requests the unique unspent alias output for the given AliasAddress
+func (n *Client) RequestUnspentAliasOutput(addr *ledgerstate.AliasAddress) {
+ n.sendMessage(&txstream.MsgGetUnspentAliasOutput{
+ AliasAddress: addr,
+ })
+}
+
+// PostTransaction posts a transaction to the ledger
+func (n *Client) PostTransaction(tx *ledgerstate.Transaction) {
+ n.sendMessage(&txstream.MsgPostTransaction{Tx: tx})
+}
diff --git a/packages/txstream/client/subscribe.go b/packages/txstream/client/subscribe.go
new file mode 100644
index 0000000000..67e94d087d
--- /dev/null
+++ b/packages/txstream/client/subscribe.go
@@ -0,0 +1,62 @@
+package client
+
+import (
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+)
+
+// Subscribe subscribes to real-time updates for the given address
+func (n *Client) Subscribe(addr ledgerstate.Address) {
+ n.chSubscribe <- addr
+}
+
+// Unsubscribe unsubscribes the address
+func (n *Client) Unsubscribe(addr ledgerstate.Address) {
+ n.chUnsubscribe <- addr
+}
+
+func (n *Client) subscriptionsLoop() {
+ subscriptions := make(map[[ledgerstate.AddressLength]byte]ledgerstate.Address)
+
+ ticker1m := time.NewTicker(time.Minute)
+ defer ticker1m.Stop()
+
+ for {
+ select {
+ case <-n.shutdown:
+ return
+ case addr := <-n.chSubscribe:
+ addrBytes := addr.Array()
+ if _, ok := subscriptions[addrBytes]; !ok {
+ // new address is subscribed
+ n.log.Infof("subscribed to address %s", addr.Base58())
+ subscriptions[addrBytes] = addr
+ n.sendSubscriptions(subscriptions)
+ }
+ case addr := <-n.chUnsubscribe:
+ delete(subscriptions, addr.Array())
+ case <-ticker1m.C:
+ // send subscriptions once every minute
+ n.sendSubscriptions(subscriptions)
+ }
+ }
+}
+
+func (n *Client) sendSubscriptions(subscriptions map[[ledgerstate.AddressLength]byte]ledgerstate.Address) {
+ if len(subscriptions) == 0 {
+ return
+ }
+
+ addrs := make([]ledgerstate.Address, len(subscriptions))
+ {
+ i := 0
+ for _, addr := range subscriptions {
+ addrs[i] = addr
+ i++
+ }
+ }
+
+ n.sendMessage(&txstream.MsgUpdateSubscriptions{Addresses: addrs})
+}
diff --git a/packages/txstream/ledger.go b/packages/txstream/ledger.go
new file mode 100644
index 0000000000..c59e8f70e4
--- /dev/null
+++ b/packages/txstream/ledger.go
@@ -0,0 +1,20 @@
+package txstream
+
+import (
+ "github.com/iotaledger/hive.go/events"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// Ledger is the interface between txstream and the underlying value tangle
+type Ledger interface {
+ GetUnspentOutputs(addr ledgerstate.Address, f func(ledgerstate.Output))
+ GetOutput(outID ledgerstate.OutputID, f func(ledgerstate.Output)) bool
+ GetOutputMetadata(outID ledgerstate.OutputID, f func(*ledgerstate.OutputMetadata)) bool
+ GetConfirmedTransaction(txid ledgerstate.TransactionID, f func(*ledgerstate.Transaction)) bool
+ GetTxInclusionState(txid ledgerstate.TransactionID) (ledgerstate.InclusionState, error)
+ EventTransactionConfirmed() *events.Event
+ EventTransactionBooked() *events.Event
+ PostTransaction(tx *ledgerstate.Transaction) error
+ Detach()
+}
diff --git a/packages/txstream/msg.go b/packages/txstream/msg.go
new file mode 100644
index 0000000000..ca035a569e
--- /dev/null
+++ b/packages/txstream/msg.go
@@ -0,0 +1,492 @@
+package txstream
+
+import (
+ "fmt"
+ "time"
+
+ "github.com/iotaledger/hive.go/marshalutil"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+)
+
+// MessageType represents the type of a message in the txstream protocol
+type MessageType byte
+
+const (
+ // FlagClientToServer is set in a message type if the message is client to server
+ FlagClientToServer = byte(0x80)
+ // FlagServerToClient is set in a message type if the message is server to client
+ FlagServerToClient = byte(0x40)
+
+ msgTypeChunk = MessageType((FlagClientToServer | FlagServerToClient) + iota)
+
+ msgTypePostTransaction = MessageType(FlagClientToServer + iota)
+ msgTypeSubscribe
+ msgTypeGetConfirmedTransaction
+ msgTypeGetConfirmedOutput
+ msgTypeGetUnspentAliasOutput
+ msgTypeGetTxInclusionState
+ msgTypeGetBacklog
+ msgTypeSetID
+
+ msgTypeTransaction = MessageType(FlagServerToClient + iota)
+ msgTypeTxInclusionState
+ msgTypeOutput
+ msgTypeUnspentAliasOutput
+)
+
+// Message is the common interface of all messages in the txstream protocol
+type Message interface {
+ Write(w *marshalutil.MarshalUtil)
+ Read(r *marshalutil.MarshalUtil) error
+ Type() MessageType
+}
+
+// ChunkMessageHeaderSize is the amount of bytes added by MsgChunk as overhead to each chunk
+const ChunkMessageHeaderSize = 3
+
+// MsgChunk is a special message for big data packets chopped into pieces
+type MsgChunk struct {
+ Data []byte
+}
+
+// region client --> server
+
+// MsgPostTransaction is a request from the client to post a
+// transaction in the ledger.
+// No reply from server.
+type MsgPostTransaction struct {
+ Tx *ledgerstate.Transaction
+}
+
+// MsgUpdateSubscriptions is a request from the client to subscribe to
+// requests/transactions for the given addresses. Server will send
+// all transactions containing unspent outputs to the address,
+// and then whenever a relevant transaction is confirmed
+// in the ledger, i will be sent in real-time.
+type MsgUpdateSubscriptions struct {
+ Addresses []ledgerstate.Address
+}
+
+// MsgGetConfirmedTransaction is a request to get a specific confirmed
+// transaction from the ledger. Server replies with MsgTransaction.
+type MsgGetConfirmedTransaction struct {
+ Address ledgerstate.Address
+ TxID ledgerstate.TransactionID
+}
+
+// MsgGetConfirmedOutput is a request to get a specific confirmed output from the ledger.
+// It may or may not be consumed
+type MsgGetConfirmedOutput struct {
+ Address ledgerstate.Address
+ OutputID ledgerstate.OutputID
+}
+
+// MsgGetUnspentAliasOutput is a request to get the unique unspent AliasOutput for the given AliasAddress.
+type MsgGetUnspentAliasOutput struct {
+ AliasAddress *ledgerstate.AliasAddress
+}
+
+// MsgGetTxInclusionState is a request to get the inclusion state for a transaction.
+// Server replies with MsgTxInclusionState.
+type MsgGetTxInclusionState struct {
+ Address ledgerstate.Address
+ TxID ledgerstate.TransactionID
+}
+
+// MsgGetBacklog is a request to get the backlog for the given address. Server replies
+// sending one MsgTransaction for each transaction with unspent outputs targeted
+// to the address.
+type MsgGetBacklog struct {
+ Address ledgerstate.Address
+}
+
+// MsgSetID is a message from client informing its ID, used mostly for tracing/loging.
+type MsgSetID struct {
+ ClientID string
+}
+
+// endregion
+
+// region server --> client
+
+// MsgTransaction informs the client of a given confirmed transaction in the ledger.
+type MsgTransaction struct {
+ // Address is the address that requested the transaction
+ Address ledgerstate.Address
+ // Tx is the transaction being sent
+ Tx *ledgerstate.Transaction
+}
+
+// MsgTxInclusionState informs the client with the inclusion state of a given
+// transaction as a response from the given address.
+type MsgTxInclusionState struct {
+ Address ledgerstate.Address
+ TxID ledgerstate.TransactionID
+ State ledgerstate.InclusionState
+}
+
+// MsgOutput is the response for MsgGetConfirmedOutput
+type MsgOutput struct {
+ Address ledgerstate.Address
+ Output ledgerstate.Output
+ OutputMetadata *ledgerstate.OutputMetadata
+}
+
+// MsgUnspentAliasOutput is the response for MsgGetUnspentAliasOutput
+type MsgUnspentAliasOutput struct {
+ AliasAddress *ledgerstate.AliasAddress
+ AliasOutput *ledgerstate.AliasOutput
+ OutputMetadata *ledgerstate.OutputMetadata
+ Timestamp time.Time
+}
+
+// endregion
+
+// EncodeMsg encodes the given Message as a byte slice
+func EncodeMsg(msg Message) []byte {
+ m := marshalutil.New()
+ m.WriteByte(byte(msg.Type()))
+ msg.Write(m)
+ return m.Bytes()
+}
+
+// DecodeMsg decodes a Message from the given bytes
+func DecodeMsg(data []byte, expectedFlags uint8) (interface{}, error) {
+ if len(data) < 1 {
+ return nil, fmt.Errorf("wrong message")
+ }
+ var ret Message
+
+ msgType := MessageType(data[0])
+ if uint8(msgType)&expectedFlags == 0 {
+ return nil, fmt.Errorf("unexpected message")
+ }
+
+ switch msgType {
+ case msgTypeChunk:
+ ret = &MsgChunk{}
+
+ case msgTypePostTransaction:
+ ret = &MsgPostTransaction{}
+
+ case msgTypeSubscribe:
+ ret = &MsgUpdateSubscriptions{}
+
+ case msgTypeGetConfirmedTransaction:
+ ret = &MsgGetConfirmedTransaction{}
+
+ case msgTypeGetTxInclusionState:
+ ret = &MsgGetTxInclusionState{}
+
+ case msgTypeGetBacklog:
+ ret = &MsgGetBacklog{}
+
+ case msgTypeSetID:
+ ret = &MsgSetID{}
+
+ case msgTypeTransaction:
+ ret = &MsgTransaction{}
+
+ case msgTypeTxInclusionState:
+ ret = &MsgTxInclusionState{}
+
+ case msgTypeGetConfirmedOutput:
+ ret = &MsgGetConfirmedOutput{}
+
+ case msgTypeGetUnspentAliasOutput:
+ ret = &MsgGetUnspentAliasOutput{}
+
+ case msgTypeOutput:
+ ret = &MsgOutput{}
+
+ case msgTypeUnspentAliasOutput:
+ ret = &MsgUnspentAliasOutput{}
+
+ default:
+ return nil, fmt.Errorf("unknown message type %d", msgType)
+ }
+ if err := ret.Read(marshalutil.New(data[1:])); err != nil {
+ return nil, err
+ }
+ return ret, nil
+}
+
+func (msg *MsgPostTransaction) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Tx)
+}
+
+func (msg *MsgPostTransaction) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Tx, err = ledgerstate.TransactionFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgPostTransaction) Type() MessageType {
+ return msgTypePostTransaction
+}
+
+func (msg *MsgUpdateSubscriptions) Write(w *marshalutil.MarshalUtil) {
+ w.WriteUint16(uint16(len(msg.Addresses)))
+ for _, addr := range msg.Addresses {
+ w.Write(addr)
+ }
+}
+
+func (msg *MsgUpdateSubscriptions) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ var size uint16
+ if size, err = m.ReadUint16(); err != nil {
+ return err
+ }
+ msg.Addresses = make([]ledgerstate.Address, size)
+ for i := uint16(0); i < size; i++ {
+ if msg.Addresses[i], err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgUpdateSubscriptions) Type() MessageType {
+ return msgTypeSubscribe
+}
+
+func (msg *MsgGetConfirmedTransaction) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.TxID)
+}
+
+func (msg *MsgGetConfirmedTransaction) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ msg.TxID, err = ledgerstate.TransactionIDFromMarshalUtil(m)
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgGetConfirmedTransaction) Type() MessageType {
+ return msgTypeGetConfirmedTransaction
+}
+
+func (msg *MsgGetTxInclusionState) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.TxID)
+}
+
+func (msg *MsgGetTxInclusionState) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.TxID, err = ledgerstate.TransactionIDFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgGetTxInclusionState) Type() MessageType {
+ return msgTypeGetTxInclusionState
+}
+
+func (msg *MsgGetBacklog) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+}
+
+func (msg *MsgGetBacklog) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ msg.Address, err = ledgerstate.AddressFromMarshalUtil(m)
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgGetBacklog) Type() MessageType {
+ return msgTypeGetBacklog
+}
+
+func (msg *MsgSetID) Write(w *marshalutil.MarshalUtil) {
+ w.WriteUint16(uint16(len(msg.ClientID)))
+ w.WriteBytes([]byte(msg.ClientID))
+}
+
+func (msg *MsgSetID) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ var size uint16
+ if size, err = m.ReadUint16(); err != nil {
+ return err
+ }
+ var clientID []byte
+ if clientID, err = m.ReadBytes(int(size)); err != nil {
+ return err
+ }
+ msg.ClientID = string(clientID)
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgSetID) Type() MessageType {
+ return msgTypeSetID
+}
+
+func (msg *MsgTransaction) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.Tx)
+}
+
+func (msg *MsgTransaction) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.Tx, err = ledgerstate.TransactionFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgTransaction) Type() MessageType {
+ return msgTypeTransaction
+}
+
+func (msg *MsgTxInclusionState) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.State)
+ w.Write(msg.TxID)
+}
+
+func (msg *MsgTxInclusionState) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.State, err = ledgerstate.InclusionStateFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.TxID, err = ledgerstate.TransactionIDFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Type returns the Message type
+func (msg *MsgTxInclusionState) Type() MessageType {
+ return msgTypeTxInclusionState
+}
+
+func (msg *MsgGetConfirmedOutput) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.OutputID)
+}
+
+func (msg *MsgGetConfirmedOutput) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ msg.OutputID, err = ledgerstate.OutputIDFromMarshalUtil(m)
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgGetConfirmedOutput) Type() MessageType {
+ return msgTypeGetConfirmedOutput
+}
+
+func (msg *MsgGetUnspentAliasOutput) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.AliasAddress)
+}
+
+func (msg *MsgGetUnspentAliasOutput) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.AliasAddress, err = ledgerstate.AliasAddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgGetUnspentAliasOutput) Type() MessageType {
+ return msgTypeGetUnspentAliasOutput
+}
+
+func (msg *MsgOutput) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.Address)
+ w.Write(msg.Output)
+ w.Write(msg.OutputMetadata)
+}
+
+func (msg *MsgOutput) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.Address, err = ledgerstate.AddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.Output, err = ledgerstate.OutputFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.OutputMetadata, err = ledgerstate.OutputMetadataFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgOutput) Type() MessageType {
+ return msgTypeOutput
+}
+
+func (msg *MsgUnspentAliasOutput) Write(w *marshalutil.MarshalUtil) {
+ w.Write(msg.AliasAddress)
+ w.Write(msg.AliasOutput)
+ w.WriteTime(msg.Timestamp)
+ w.Write(msg.OutputMetadata)
+}
+
+func (msg *MsgUnspentAliasOutput) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ if msg.AliasAddress, err = ledgerstate.AliasAddressFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.AliasOutput, err = ledgerstate.AliasOutputFromMarshalUtil(m); err != nil {
+ return err
+ }
+ if msg.Timestamp, err = m.ReadTime(); err != nil {
+ return err
+ }
+ if msg.OutputMetadata, err = ledgerstate.OutputMetadataFromMarshalUtil(m); err != nil {
+ return err
+ }
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgUnspentAliasOutput) Type() MessageType {
+ return msgTypeUnspentAliasOutput
+}
+
+func (msg *MsgChunk) Write(w *marshalutil.MarshalUtil) {
+ w.WriteUint16(uint16(len(msg.Data)))
+ w.WriteBytes(msg.Data)
+}
+
+func (msg *MsgChunk) Read(m *marshalutil.MarshalUtil) error {
+ var err error
+ var size uint16
+ if size, err = m.ReadUint16(); err != nil {
+ return err
+ }
+ msg.Data, err = m.ReadBytes(int(size))
+ return err
+}
+
+// Type returns the Message type
+func (msg *MsgChunk) Type() MessageType {
+ return msgTypeChunk
+}
diff --git a/packages/txstream/server/msgfromclient.go b/packages/txstream/server/msgfromclient.go
new file mode 100644
index 0000000000..c0c5256c01
--- /dev/null
+++ b/packages/txstream/server/msgfromclient.go
@@ -0,0 +1,72 @@
+package server
+
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import (
+ "github.com/iotaledger/goshimmer/packages/tangle"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+
+ "golang.org/x/xerrors"
+)
+
+// process first message from client
+func (c *Connection) receiveClientID(data []byte) (string, error) {
+ msg, err := txstream.DecodeMsg(data, txstream.FlagClientToServer)
+ if err != nil {
+ return "", xerrors.Errorf("DecodeMsg: %v", err)
+ }
+
+ if msg, ok := msg.(*txstream.MsgSetID); ok {
+ return msg.ClientID, nil
+ }
+ return "", xerrors.Errorf("wrong msg type: %T", msg)
+}
+
+// process messages received from the clien
+func (c *Connection) processMessageFromClient(data []byte) error {
+ msg, err := txstream.DecodeMsg(data, txstream.FlagClientToServer)
+ if err != nil {
+ return xerrors.Errorf("DecodeMsg: %v", err)
+ }
+
+ switch msg := msg.(type) {
+ case *txstream.MsgChunk:
+ finalMsg, err := c.chopper.IncomingChunk(msg.Data, tangle.MaxMessageSize, txstream.ChunkMessageHeaderSize)
+ if err != nil {
+ return xerrors.Errorf("IncomingChunk: %v", err)
+ }
+ if finalMsg != nil {
+ return c.processMessageFromClient(finalMsg)
+ }
+
+ case *txstream.MsgPostTransaction:
+ c.postTransaction(msg.Tx)
+
+ case *txstream.MsgUpdateSubscriptions:
+ newAddrs := c.setSubscriptions(msg.Addresses)
+ // send backlogs of newly subscribed addresses
+ for _, addr := range newAddrs {
+ c.getBacklog(addr)
+ }
+
+ case *txstream.MsgGetConfirmedTransaction:
+ c.pushTransaction(msg.TxID, msg.Address)
+
+ case *txstream.MsgGetTxInclusionState:
+ c.getTxInclusionState(msg.TxID, msg.Address)
+
+ case *txstream.MsgGetBacklog:
+ c.getBacklog(msg.Address)
+
+ case *txstream.MsgGetConfirmedOutput:
+ c.sendOutput(msg.OutputID, msg.Address)
+
+ case *txstream.MsgGetUnspentAliasOutput:
+ c.sendUnspentAliasOutput(msg.AliasAddress)
+
+ default:
+ return xerrors.Errorf("wrong msg type: %T", msg)
+ }
+ return nil
+}
diff --git a/packages/txstream/server/msgtoclient.go b/packages/txstream/server/msgtoclient.go
new file mode 100644
index 0000000000..60c2f8fcf0
--- /dev/null
+++ b/packages/txstream/server/msgtoclient.go
@@ -0,0 +1,114 @@
+package server
+
+// Copyright 2020 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+import (
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/tangle"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+)
+
+func (c *Connection) sendMsgToClient(msg txstream.Message) {
+ var err error
+ defer func() {
+ if err != nil {
+ c.log.Errorf("sending message to client (%T): %v", msg, err)
+ }
+ }()
+
+ data := txstream.EncodeMsg(msg)
+ choppedData, chopped, err := c.chopper.ChopData(data, tangle.MaxMessageSize, txstream.ChunkMessageHeaderSize)
+ if err != nil {
+ return
+ }
+ if !chopped {
+ _, err = c.bconn.Write(data)
+ return
+ }
+
+ // sending piece by piece wrapped in MsgChunk
+ for _, piece := range choppedData {
+ dataToSend := txstream.EncodeMsg(&txstream.MsgChunk{Data: piece})
+ if len(dataToSend) > tangle.MaxMessageSize {
+ c.log.Panicf("sendMsgToClient: internal inconsistency: size too big: %d", len(dataToSend))
+ }
+ _, err = c.bconn.Write(dataToSend)
+ if err != nil {
+ return
+ }
+ }
+}
+
+func (c *Connection) sendTxInclusionState(txid ledgerstate.TransactionID, addr ledgerstate.Address, state ledgerstate.InclusionState) {
+ c.sendMsgToClient(&txstream.MsgTxInclusionState{
+ Address: addr,
+ TxID: txid,
+ State: state,
+ })
+}
+
+func (c *Connection) pushTransaction(txid ledgerstate.TransactionID, addr ledgerstate.Address) {
+ found := c.ledger.GetConfirmedTransaction(txid, func(tx *ledgerstate.Transaction) {
+ c.sendMsgToClient(&txstream.MsgTransaction{
+ Address: addr,
+ Tx: tx,
+ })
+ })
+ if !found {
+ c.log.Warnf("pushTransaction: not found %c", txid.String())
+ }
+}
+
+func (c *Connection) sendOutput(outputID ledgerstate.OutputID, addr ledgerstate.Address) {
+ validOutput := true
+ foundTx := c.ledger.GetConfirmedTransaction(outputID.TransactionID(), func(tx *ledgerstate.Transaction) {
+ idx := outputID.OutputIndex()
+ if int(idx) >= len(tx.Essence().Outputs()) {
+ validOutput = false
+ return
+ }
+ validOutput = c.ledger.GetOutputMetadata(outputID, func(meta *ledgerstate.OutputMetadata) {
+ c.sendMsgToClient(&txstream.MsgOutput{
+ Address: addr,
+ Output: tx.Essence().Outputs()[outputID.OutputIndex()].UpdateMintingColor(),
+ OutputMetadata: meta,
+ })
+ })
+ })
+ if !foundTx || !validOutput {
+ c.log.Warnf("sendOutput: not found output %s", outputID.String())
+ }
+}
+
+func (c *Connection) sendUnspentAliasOutput(addr *ledgerstate.AliasAddress) {
+ found := false
+ c.ledger.GetUnspentOutputs(addr, func(out ledgerstate.Output) {
+ if found {
+ return
+ }
+ if aliasOut, ok := out.(*ledgerstate.AliasOutput); ok {
+ var timestamp time.Time
+ c.ledger.GetConfirmedTransaction(aliasOut.ID().TransactionID(), func(tx *ledgerstate.Transaction) {
+ timestamp = tx.Essence().Timestamp()
+ })
+ c.ledger.GetOutputMetadata(out.ID(), func(meta *ledgerstate.OutputMetadata) {
+ if meta.ConsumerCount() != 0 {
+ return
+ }
+ found = true
+ c.sendMsgToClient(&txstream.MsgUnspentAliasOutput{
+ AliasAddress: addr,
+ AliasOutput: aliasOut,
+ OutputMetadata: meta,
+ Timestamp: timestamp,
+ })
+ })
+ }
+ })
+ if !found {
+ c.log.Warnf("sendUnspentAliasOutput: not found alias output for address %s", addr.Base58())
+ }
+}
diff --git a/packages/txstream/server/server.go b/packages/txstream/server/server.go
new file mode 100644
index 0000000000..6f865fecba
--- /dev/null
+++ b/packages/txstream/server/server.go
@@ -0,0 +1,251 @@
+package server
+
+import (
+ "fmt"
+ "io"
+ "net"
+ "strings"
+ "time"
+
+ "github.com/iotaledger/hive.go/events"
+ "github.com/iotaledger/hive.go/logger"
+ "github.com/iotaledger/hive.go/netutil/buffconn"
+
+ "github.com/iotaledger/goshimmer/packages/ledgerstate"
+ "github.com/iotaledger/goshimmer/packages/tangle"
+ "github.com/iotaledger/goshimmer/packages/txstream"
+ "github.com/iotaledger/goshimmer/packages/txstream/chopper"
+)
+
+// Connection handles the server-side part of the txstream protocol
+type Connection struct {
+ bconn *buffconn.BufferedConnection
+ chopper *chopper.Chopper
+ subscriptions map[[ledgerstate.AddressLength]byte]bool
+ ledger txstream.Ledger
+ log *logger.Logger
+}
+
+type (
+ wrapConfirmedTx *ledgerstate.Transaction
+ wrapBookedTx *ledgerstate.Transaction
+)
+
+const rcvClientIDTimeout = 5 * time.Second
+
+// Listen starts a TCP listener and starts a Connection for each accepted connection
+func Listen(ledger txstream.Ledger, bindAddress string, log *logger.Logger, shutdownSignal <-chan struct{}) error {
+ listener, err := net.Listen("tcp", bindAddress)
+ if err != nil {
+ return fmt.Errorf("failed to start TXStream daemon: %w", err)
+ }
+
+ go func() {
+ for {
+ conn, err := listener.Accept()
+ if err != nil {
+ return
+ }
+ log.Debugf("accepted connection from %s", conn.RemoteAddr().String())
+ go Run(conn, log, ledger, shutdownSignal)
+ }
+ }()
+
+ go func() {
+ defer listener.Close()
+
+ <-shutdownSignal
+
+ log.Infof("Detaching TXStream from the Value Tangle..")
+ log.Infof("Detaching TXStream from the Value Tangle..Done")
+ }()
+
+ return nil
+}
+
+// Run starts the server-side handling code for an already accepted connection from a client
+func Run(conn net.Conn, log *logger.Logger, ledger txstream.Ledger, shutdownSignal <-chan struct{}) {
+ c := &Connection{
+ bconn: buffconn.NewBufferedConnection(conn, tangle.MaxMessageSize),
+ chopper: chopper.NewChopper(),
+ subscriptions: make(map[[ledgerstate.AddressLength]byte]bool),
+ ledger: ledger,
+ log: log,
+ }
+
+ defer c.bconn.Close()
+ defer c.chopper.Close()
+
+ bconnDataReceived, bconnClosed := c.bconnReadLoop()
+
+ // expect first message received from client == MsgSetID
+ select {
+ case data := <-bconnDataReceived:
+ id, err := c.receiveClientID(data)
+ if err != nil {
+ c.log.Errorf("first message from client: %v", err)
+ return
+ }
+ c.log = c.log.Named(id)
+ c.log.Infof("client connection id has been set to '%s' for '%s'", id, c.bconn.RemoteAddr().String())
+ case <-shutdownSignal:
+ c.log.Infof("shutdown signal received")
+ return
+ case <-bconnClosed:
+ c.log.Errorf("connection lost")
+ return
+ case <-time.After(rcvClientIDTimeout):
+ c.log.Errorf("timeout receiving client ID")
+ return
+ }
+
+ txFromLedgerQueue := make(chan interface{})
+
+ {
+ cl := events.NewClosure(func(tx *ledgerstate.Transaction) {
+ c.log.Debugf("on transaction confirmed: %s", tx.ID().Base58())
+ txFromLedgerQueue <- wrapConfirmedTx(tx)
+ })
+ c.ledger.EventTransactionConfirmed().Attach(cl)
+ defer c.ledger.EventTransactionConfirmed().Detach(cl)
+ }
+
+ {
+ cl := events.NewClosure(func(tx *ledgerstate.Transaction) {
+ c.log.Debugf("on transaction booked: %s", tx.ID().Base58())
+ txFromLedgerQueue <- wrapBookedTx(tx)
+ })
+ c.ledger.EventTransactionBooked().Attach(cl)
+ defer c.ledger.EventTransactionBooked().Detach(cl)
+ }
+
+ c.log.Debugf("started txstream")
+ defer c.log.Debugf("stopped txstream")
+
+ // single-threaded r/w loop
+ for {
+ select {
+ case tx := <-txFromLedgerQueue:
+ switch tx := tx.(type) {
+ case wrapConfirmedTx:
+ c.processConfirmedTransaction(tx)
+ case wrapBookedTx:
+ c.processBookedTransaction(tx)
+ default:
+ c.log.Panicf("wrong type")
+ }
+ case data := <-bconnDataReceived:
+ if err := c.processMessageFromClient(data); err != nil {
+ c.log.Errorf("processMessageFromClient: %v", err)
+ }
+ case <-shutdownSignal:
+ c.log.Infof("shutdown signal received")
+ return
+ case <-bconnClosed:
+ c.log.Errorf("connection lost")
+ return
+ }
+ }
+}
+
+func (c *Connection) bconnReadLoop() (chan []byte, chan bool) {
+ bconnDataReceived := make(chan []byte)
+ bconnClosed := make(chan bool)
+
+ // bconn read loop
+ go func() {
+ {
+ cl := events.NewClosure(func() { close(bconnClosed) })
+ c.bconn.Events.Close.Attach(cl)
+ defer c.bconn.Events.Close.Detach(cl)
+ }
+
+ {
+ cl := events.NewClosure(func(data []byte) {
+ // data slice is from internal buffconn buffer
+ d := make([]byte, len(data))
+ copy(d, data)
+ bconnDataReceived <