Merge branch 'develop' into master

TODO.md

@@ -20,7 +20,7 @@ Done
 - [x] wasp node dashboard: show structure of committee, which SCs are running, etc
 
 Pending
-- [ ] wwallet: Allow more than one instance of same SC
+- [ ] wwallet: separate binaries for admin/client operations
 - [ ] dwf: allow withdrawing colored tokens
 - [ ] BufferedKVStore: Cache DB reads (which should not change in the DB during
       the BufferedKVStore lifetime)
@@ -29,11 +29,17 @@ Pending
 - [ ] Add authentication to web api calls
 
 To discuss/RFC
+- [ ] optimize SC ledger database. Currently key/value is stored twice: in the virtual state and in the batch which
+last updated the value. For small virtual states it is OK. For big ones (data Oracle) it would be better
+to for virtual state keep reference to the last updating mutatation in the batch/state update 
+- [ ] identity system for nodes
+- [ ] secure access to API, to SC admin functions 
 - [ ] refactor 'request code' from uint16 value to string
 - [ ] smart contract state access from outside. The current approach is to provide universal node API to query state. 
 The alternatives would be to expose access functions (like view in Solidity) from the smart contract code itself. 
 Another approach can be expose data schema + generic access   
-- [ ] Merkle proofs of smart contract state elements  
+- [ ] Merkle proofs of smart contract state elements The idea is to have relatively short (logoarithmically) proof
+of some data element is in the virtual state. Currently proof is the whole batch chain, i.e. linear.  
 - [ ] Standard subscription mechanisms for events: (a) VM events (NanoMsg, ZMQ, MQTT) 
 and (b) smart contract events (signalled by request to subscriber smart contract)
 - [ ] balance sheet metaphor in the smart contract state. Ownership concept of BS "liability+equity" items  
@@ -44,14 +50,14 @@ for each committee member with its public key. Option 2: move request data off-t
 Functional testing
 - [ ] test fault-tolerance
 - [ ] test access node function
-- [ ] test several concurrent/interacting contracts
-- [ ] test random confirmation delays (probably not needed if running on Pollen)
+- [X] test several concurrent/interacting contracts
+- [X] test random confirmation delays (probably not needed if running on Pollen)
 - [ ] test big committees (~100 nodes)
-- [ ] test overlapping committees
+- [X] test overlapping committees
 
 Future
 - [ ] rewrite DKG
-- [ ] `Oracle Data Bulletin Board` description. Postponed
+- [ ] `Oracle Data Bulletin Board` specs. Postponed
 - [ ] enable and test 1 node committees
 - [ ] test quorum == 1  
 - [ ] optimize logging

articles/intro/dwf.md

@@ -20,10 +20,10 @@ In the future all smart contract programs will be run on wasm VM)_
 
 The common practice is to display the donation address on a web page for anyone wanting to send us a donation, 
 for example with their Trinity wallet. 
-What if we also want each donor to attach some feedback text to the donation? For example, 
+What if we also want each donor to attach some feedback/comment text to the donation? For example, 
 “Here I send you 2 MIOTA because I like your site”? 
-To support that possibility, we would need some kind of application or an extension of the existing IOTA wallet 
-with a database for feedback messages behind and so on (of course, there is more than one way to do that, including 
+To support that possibility, we would need some kind of application, or an extension of the existing IOTA wallet 
+with a database for comment messages behind and so on (of course, there is more than one way to do that, including 
 embedding the text right into the transaction).
 
 _DonateWithFeedback_ smart contract takes responsibility to handle both the donation 
@@ -53,7 +53,7 @@ The state of any smart contract consists of two parts:
 - The collection of _key-value pairs_ which can be interpreted as variables and their values. 
 It is an **off-tangle** part of the state. In general, it can contain any data of arbitrary size.
 In the _DonateWithFeedback_ smart contract the dashboard displays the generic data of the state in 
-a SC-specific and user-friendly format: 
+an SC-specific and user-friendly format: 
 the statistics of donations and list of feedback messages stored in the log. 
 
 (note that we use [Base58 encoding](https://en.bitcoinwiki.org/wiki/Base58) for binary data of fixed size, like 

main.go

@@ -11,6 +11,7 @@ import (
 	"github.com/iotaledger/wasp/plugins/dashboard"
 	"github.com/iotaledger/wasp/plugins/database"
 	"github.com/iotaledger/wasp/plugins/dispatcher"
+	"github.com/iotaledger/wasp/plugins/examples"
 	"github.com/iotaledger/wasp/plugins/gracefulshutdown"
 	"github.com/iotaledger/wasp/plugins/logger"
 	"github.com/iotaledger/wasp/plugins/nodeconn"
@@ -41,6 +42,7 @@ func main() {
 		runvm.Init(),
 		publisher.Init(),
 		dashboard.Init(),
+		examples.Init(),
 	)
 
 	testPlugins := node.Plugins(

packages/apilib/deploysc.go

@@ -171,8 +171,8 @@ func CreateSC(par CreateSCParams) (*address.Address, *balance.Color, error) {
 		fmt.Fprintf(textout, "checking program metadata: FAILED: %v\n", err)
 		return nil, nil, err
 	}
-	fmt.Fprintf(textout, "checking program metadata: OK. location: '%s', VMType: '%s', description: '%s'\n",
-		md.Location, md.VMType, md.Description)
+	fmt.Fprintf(textout, "checking program metadata: OK. VMType: '%s', description: '%s'\n",
+		md.VMType, md.Description)
 
 	// generate distributed key set on committee nodes
 	scAddr, err := GenerateNewDistributedKeySet(par.CommitteeApiHosts, par.N, par.T)

packages/apilib/progmdata.go → packages/apilib/program.go

@@ -5,58 +5,57 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/http"
+	"time"
+
 	"github.com/iotaledger/wasp/packages/hashing"
-	"github.com/iotaledger/wasp/packages/progmeta"
 	"github.com/iotaledger/wasp/packages/registry"
 	"github.com/iotaledger/wasp/packages/util/multicall"
 	"github.com/iotaledger/wasp/plugins/webapi/admapi"
-	"github.com/iotaledger/wasp/plugins/webapi/misc"
-	"net/http"
-	"time"
 )
 
-// PutProgramMetadata calls node to write ProgramMetadata record
-func PutProgramMetadata(host string, md registry.ProgramMetadata) error {
-	data, err := json.Marshal(&admapi.ProgramMetadataJsonable{
-		ProgramHash: md.ProgramHash.String(),
-		Location:    md.Location,
-		Description: md.Description,
+// PutProgramMetadata calls node to write program code and ProgramMetadata record
+func PutProgram(host string, vmType string, description string, code []byte) (*hashing.HashValue, error) {
+	data, err := json.Marshal(&admapi.PutProgramRequest{
+		ProgramMetadata: admapi.ProgramMetadata{
+			VMType:      vmType,
+			Description: description,
+		},
+		Code: code,
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
-	url := fmt.Sprintf("http://%s/adm/putprogrammetadata", host)
+	url := fmt.Sprintf("http://%s/adm/program", host)
 	resp, err := http.Post(url, "application/json", bytes.NewBuffer(data))
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	var result misc.SimpleResponse
+	var result admapi.PutProgramResponse
 	err = json.NewDecoder(resp.Body).Decode(&result)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if result.Error != "" {
-		err = errors.New(result.Error)
+		return nil, errors.New(result.Error)
 	}
-	return err
-}
-
-// GetProgramMetadata calls node to get ProgramMetadata by program hash
-func GetProgramMetadata(host string, progHash *hashing.HashValue) (*progmeta.ProgramMetadata, error) {
-	data, err := json.Marshal(&admapi.GetProgramMetadataRequest{
-		ProgramHash: progHash.String(),
-	})
+	hash, err := hashing.HashValueFromBase58(result.ProgramHash)
 	if err != nil {
 		return nil, err
 	}
-	url := fmt.Sprintf("http://%s/adm/getprogrammetadata", host)
-	resp, err := http.Post(url, "application/json", bytes.NewBuffer(data))
+	return &hash, nil
+}
+
+// GetProgramMetadata calls node to get ProgramMetadata by program hash
+func GetProgramMetadata(host string, progHash *hashing.HashValue) (*registry.ProgramMetadata, error) {
+	url := fmt.Sprintf("http://%s/adm/program/%s", host, progHash.String())
+	resp, err := http.Get(url)
 	if err != nil {
 		return nil, err
 	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("response status %d", resp.StatusCode)
+	if resp.StatusCode == http.StatusNotFound {
+		return nil, nil
 	}
 	var dresp admapi.GetProgramMetadataResponse
 	err = json.NewDecoder(resp.Body).Decode(&dresp)
@@ -66,27 +65,21 @@ func GetProgramMetadata(host string, progHash *hashing.HashValue) (*progmeta.Pro
 	if dresp.Error != "" {
 		return nil, errors.New(dresp.Error)
 	}
-	if !dresp.ExistsMetadata {
-		return nil, nil
-	}
-	ph, err := hashing.HashValueFromBase58(dresp.ProgramHash)
-	if err != nil {
-		return nil, err
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("response status %d", resp.StatusCode)
 	}
-	return &progmeta.ProgramMetadata{
-		ProgramHash:   ph,
-		Location:      dresp.Location,
-		VMType:        dresp.VMType,
-		Description:   dresp.Description,
-		CodeAvailable: dresp.ExistsCode,
+	return &registry.ProgramMetadata{
+		ProgramHash: *progHash,
+		VMType:      dresp.VMType,
+		Description: dresp.Description,
 	}, nil
 }
 
 // CheckProgramMetadata checks if metadata exists in hosts and is consistent
 // return program meta data from the first host if all consistent, otherwise nil
-func CheckProgramMetadata(hosts []string, progHash *hashing.HashValue) (*progmeta.ProgramMetadata, error) {
+func CheckProgramMetadata(hosts []string, progHash *hashing.HashValue) (*registry.ProgramMetadata, error) {
 	funs := make([]func() error, len(hosts))
-	mdata := make([]*progmeta.ProgramMetadata, len(hosts))
+	mdata := make([]*registry.ProgramMetadata, len(hosts))
 	for i, host := range hosts {
 		var err error
 		h := host
@@ -110,7 +103,7 @@ func CheckProgramMetadata(hosts []string, progHash *hashing.HashValue) (*progmet
 }
 
 // consistentProgramMetadata does not check if code exists
-func consistentProgramMetadata(md1, md2 *progmeta.ProgramMetadata) bool {
+func consistentProgramMetadata(md1, md2 *registry.ProgramMetadata) bool {
 	if md1 == nil || md2 == nil {
 		return false
 	}
@@ -123,8 +116,5 @@ func consistentProgramMetadata(md1, md2 *progmeta.ProgramMetadata) bool {
 	if md1.Description != md2.Description {
 		return false
 	}
-	if md1.Location != md2.Location {
-		return false
-	}
 	return true
 }

packages/committee/consensus/eventproc.go

@@ -57,7 +57,7 @@ func (op *operator) EventStateTransitionMsg(msg *committee.StateTransitionMsg) {
 	progHashStr := progHash.String()
 	op.processorReady = processor.CheckProcessor(progHashStr)
 	if !op.processorReady {
-		processor.LoadProcessorAsync(progHashStr, func(err error) {
+		processor.LoadProcessorAsync(progHash, func(err error) {
 			if err == nil {
 				op.committee.ReceiveMessage(committee.ProcessorIsReady{
 					ProgramHash: progHashStr,

packages/dashboard/util.go

@@ -6,6 +6,15 @@ import (
 	"time"
 )
 
+const maxLength = 150
+
+func Trim(s string) string {
+	if len(s) > maxLength {
+		return s[0:maxLength] + "..."
+	}
+	return s
+}
+
 func FormatTimestamp(ts interface{}) string {
 	t, ok := ts.(time.Time)
 	if !ok {

packages/registry/programcode.go

@@ -0,0 +1,39 @@
+package registry
+
+import (
+	"fmt"
+
+	"github.com/iotaledger/wasp/packages/hashing"
+	"github.com/iotaledger/wasp/plugins/database"
+	"github.com/iotaledger/wasp/plugins/publisher"
+)
+
+func dbkeyProgramCode(progHash *hashing.HashValue) []byte {
+	return database.MakeKey(database.ObjectTypeProgramCode, progHash[:])
+}
+
+// TODO save program code in the smart contract state
+func GetProgramCode(progHash *hashing.HashValue) ([]byte, error) {
+	db := database.GetRegistryPartition()
+	data, err := db.Get(dbkeyProgramCode(progHash))
+	if err != nil {
+		return nil, err
+	}
+	hash := hashing.HashData(data)
+	if *hash != *progHash {
+		return nil, fmt.Errorf("program code is corrupted. Expected: %s. Got: %s", progHash.String(), hash.String())
+	}
+	return data, nil
+}
+
+func SaveProgramCode(programCode []byte) (ret hashing.HashValue, err error) {
+	progHash := hashing.HashData(programCode)
+	db := database.GetRegistryPartition()
+	if err = db.Set(dbkeyProgramCode(progHash), programCode); err != nil {
+		return
+	}
+	ret = *progHash
+
+	defer publisher.Publish("programcode", progHash.String())
+	return
+}