feat: Oracle packages and Github verification realm

agent/devmock/avl/tree.go

@@ -0,0 +1,82 @@
+package avl
+
+type IterCbFn func(key string, value interface{}) bool
+
+//----------------------------------------
+// Tree
+
+// The zero struct can be used as an empty tree.
+type Tree struct {
+	node *Node
+}
+
+func NewTree() *Tree {
+	return &Tree{
+		node: nil,
+	}
+}
+
+func (tree *Tree) Size() int {
+	return tree.node.Size()
+}
+
+func (tree *Tree) Has(key string) (has bool) {
+	return tree.node.Has(key)
+}
+
+func (tree *Tree) Get(key string) (value interface{}, exists bool) {
+	_, value, exists = tree.node.Get(key)
+	return
+}
+
+func (tree *Tree) GetByIndex(index int) (key string, value interface{}) {
+	return tree.node.GetByIndex(index)
+}
+
+func (tree *Tree) Set(key string, value interface{}) (updated bool) {
+	newnode, updated := tree.node.Set(key, value)
+	tree.node = newnode
+	return updated
+}
+
+func (tree *Tree) Remove(key string) (value interface{}, removed bool) {
+	newnode, _, value, removed := tree.node.Remove(key)
+	tree.node = newnode
+	return value, removed
+}
+
+// Shortcut for TraverseInRange.
+func (tree *Tree) Iterate(start, end string, cb IterCbFn) bool {
+	return tree.node.TraverseInRange(start, end, true, true,
+		func(node *Node) bool {
+			return cb(node.Key(), node.Value())
+		},
+	)
+}
+
+// Shortcut for TraverseInRange.
+func (tree *Tree) ReverseIterate(start, end string, cb IterCbFn) bool {
+	return tree.node.TraverseInRange(start, end, false, true,
+		func(node *Node) bool {
+			return cb(node.Key(), node.Value())
+		},
+	)
+}
+
+// Shortcut for TraverseByOffset.
+func (tree *Tree) IterateByOffset(offset int, count int, cb IterCbFn) bool {
+	return tree.node.TraverseByOffset(offset, count, true, true,
+		func(node *Node) bool {
+			return cb(node.Key(), node.Value())
+		},
+	)
+}
+
+// Shortcut for TraverseByOffset.
+func (tree *Tree) ReverseIterateByOffset(offset int, count int, cb IterCbFn) bool {
+	return tree.node.TraverseByOffset(offset, count, false, true,
+		func(node *Node) bool {
+			return cb(node.Key(), node.Value())
+		},
+	)
+}

agent/devmock/go.mod

@@ -0,0 +1 @@
+package devmock

agent/devmock/std/std.go

@@ -0,0 +1,7 @@
+package std
+
+type Address string
+
+func GetOrigCaller() Address {
+	return ""
+}

agent/p/agent/agent.go

@@ -0,0 +1,133 @@
+package agent
+
+import (
+	// TODO: replace with std
+
+	"strings"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/std"
+)
+
+var (
+	tasks *avl.Tree
+
+	// Not sure this is necessary.
+	adminAddress string
+)
+
+const (
+	FunctionFinish  = "finish"
+	FunctionRequest = "request"
+	FunctionSubmit  = "submit"
+)
+
+type PostRequestAction func(function string, task Task)
+
+func HandleRequest(payload string, post PostRequestAction) string {
+	payloadParts := strings.SplitN(payload, ",", 1)
+	if len(payloadParts) != 2 {
+		panic("invalid agent payload")
+	}
+
+	switch function := payloadParts[0]; function {
+	case FunctionFinish:
+		task := FinishTask(payloadParts[1])
+		if post != nil {
+			post(function, task)
+		}
+	case FunctionRequest:
+		return RequestTasks()
+	case FunctionSubmit:
+		submitArgs := strings.SplitN(payloadParts[1], ",", 1)
+		if len(submitArgs) != 2 {
+			panic("invalid agent submission payload")
+		}
+
+		SubmitTaskValue(submitArgs[0], submitArgs[1])
+		if post != nil {
+			post(function, nil)
+		}
+	default:
+		panic("unknown function " + function)
+	}
+
+	return ""
+}
+
+func FinishTask(id string) Task {
+	task, ok := tasks.Get(id)
+	if !ok {
+		panic("task not found")
+	}
+
+	task.(Task).Finish(string(std.GetOrigCaller()))
+	return task.(Task)
+}
+
+func RequestTasks() string {
+	buf := new(strings.Builder)
+	buf.WriteString("[")
+	first := true
+	tasks.Iterate("", "", func(_ string, value interface{}) bool {
+		if !first {
+			buf.WriteString(",")
+		}
+
+		task := value.(Task)
+		taskBytes, err := task.MarshalJSON()
+		if err != nil {
+			panic(err)
+		}
+
+		// Guard against any tasks that shouldn't be returned; maybe they are not active because they have
+		// already been completed.
+		if len(taskBytes) == 0 {
+			return true
+		}
+
+		first = false
+		buf.Write(taskBytes)
+		return true
+	})
+	buf.WriteString("]")
+	return buf.String()
+}
+
+func SubmitTaskValue(id, value string) Task {
+	task, ok := tasks.Get(id)
+	if !ok {
+		panic("task not found")
+	}
+
+	task.(Task).SubmitResult(string(std.GetOrigCaller()), value)
+	return task.(Task)
+}
+
+func AddTask(task Task) {
+	if tasks.Has(task.ID()) {
+		panic("task id " + task.ID() + " already exists")
+	}
+
+	tasks.Set(task.ID(), task)
+}
+
+func RemoveTask(id string) {
+	if _, removed := tasks.Remove(id); !removed {
+		panic("task id " + id + " not found")
+	}
+}
+
+func Init(admin std.Address, newTasks ...Task) {
+	if tasks != nil {
+		panic("already initialized")
+	}
+
+	adminAddress = string(admin)
+	tasks = avl.NewTree()
+	for _, task := range newTasks {
+		if updated := tasks.Set(task.ID(), task); updated {
+			panic("task id " + task.ID() + " already exists")
+		}
+	}
+}

agent/p/agent/github/verification/task/definition.go

@@ -0,0 +1,30 @@
+package task
+
+import (
+	"bufio"
+	"bytes"
+)
+
+const Type string = "gh-verification"
+
+type Definition struct {
+	Handle  string
+	Address string
+}
+
+func (d Definition) MarshalJSON() ([]byte, error) {
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+
+	w.WriteString(
+		`{"handle":"` + d.Handle +
+			`","address":"` + d.Address + `"}`,
+	)
+
+	w.Flush()
+	return buf.Bytes(), nil
+}
+
+func (d Definition) Type() string {
+	return Type
+}

agent/p/agent/pricefeed/task/definition.go

@@ -0,0 +1,6 @@
+package task
+
+type Definition struct {
+	Pair              string // USD/CAD
+	AcceptedDeviation float64
+}

agent/p/agent/random/task/aggregator.go

@@ -0,0 +1,31 @@
+package task
+
+import (
+	"math"
+	"strconv"
+)
+
+type Aggregator struct {
+	sum            uint64
+	taskDefinition *Definition
+}
+
+func (a *Aggregator) Aggregate() string {
+	randomValue := a.taskDefinition.RangeStart + a.sum%a.taskDefinition.RangeEnd
+	a.sum = 0
+	return strconv.FormatUint(randomValue, 10)
+}
+
+func (a *Aggregator) AddValue(value string) {
+	intValue, err := strconv.ParseUint(value, 10, 64)
+	if err != nil {
+		panic("value needs to be type uint64: " + err.Error())
+	}
+
+	// Account for overflow.
+	if diff := math.MaxUint64 - a.sum; diff < intValue {
+		a.sum = intValue - diff
+	} else {
+		a.sum += intValue
+	}
+}

agent/p/agent/random/task/definition.go

@@ -0,0 +1,32 @@
+package task
+
+import (
+	"bufio"
+	"bytes"
+	"strconv"
+)
+
+const Type string = "random"
+
+// Input in this range.
+type Definition struct {
+	RangeStart uint64
+	RangeEnd   uint64
+}
+
+func (d Definition) MarshalJSON() ([]byte, error) {
+	buf := new(bytes.Buffer)
+	w := bufio.NewWriter(buf)
+
+	w.WriteString(
+		`{"start":` + strconv.FormatUint(d.RangeStart, 10) +
+			`,"end":` + strconv.FormatUint(d.RangeEnd, 10) + `}`,
+	)
+
+	w.Flush()
+	return buf.Bytes(), nil
+}
+
+func (d Definition) Type() string {
+	return Type
+}

agent/p/agent/task.go

@@ -0,0 +1,12 @@
+package agent
+
+import "github.com/gnolang/gno/agent/p/agent/task"
+
+type Task interface {
+	Definition() task.Definition
+	Finish(origCaller string)
+	GetResult() (result task.Result, hasResult bool)
+	ID() string
+	MarshalJSON() ([]byte, error)
+	SubmitResult(origCaller, value string)
+}

agent/p/agent/task/aggregator.go

@@ -0,0 +1,8 @@
+package task
+
+type Aggregator interface {
+	// Aggregate runs an aggregation on all values written using the AddValue method.
+	// It returns the aggregated value as a string.
+	Aggregate() string
+	AddValue(value string)
+}

agent/p/agent/task/definition.go

@@ -0,0 +1,6 @@
+package task
+
+type Definition interface {
+	MarshalJSON() ([]byte, error)
+	Type() string
+}

agent/p/agent/task/history.go

@@ -0,0 +1,16 @@
+package task
+
+type History struct {
+	Size       int
+	NumRemoved int
+	Results    []Result
+}
+
+func (h *History) AddResult(result Result) {
+	h.Results = append(h.Results, result)
+	if numResults := len(h.Results); numResults > h.Size {
+		numToRemove := numResults - h.Size
+		h.Results = h.Results[numToRemove:]
+		h.NumRemoved += numToRemove
+	}
+}

agent/p/agent/task/result.go

@@ -0,0 +1,8 @@
+package task
+
+import "time"
+
+type Result struct {
+	Value string
+	Time  time.Time
+}