feat: github oracle

Co-authored-by: Miguel Victoria Villaquiran <[email protected]>

examples/gno.land/r/demo/teritori/gh/account.gno

@@ -1,6 +1,11 @@
 package gh
 
-import "errors"
+
+import (
+	"std"
+	"errors"
+	"gno.land/p/demo/avl"
+)
 
 // Account represents a GitHub user account or organization.
 type Account struct {
@@ -27,7 +32,7 @@ func (a Account) Validate() error {
 	if a.login == "" {
 		return errors.New("empty login")
 	}
-	if a.kind == "" {
+	if a.kind == ""  || (a.kind != UserAccount && a.kind != OrgAccount){
 		return errors.New("empty kind")
 	}
 	if a.name == "" {

examples/gno.land/r/demo/teritori/gh/admin.gno

@@ -0,0 +1,25 @@
+package gh
+
+import (
+	"std"
+)
+
+var(
+	adminAddr      std.Address = "g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq" 
+)
+
+
+func assertIsAdmin() {
+	if std.GetOrigCaller() != adminAddr {
+		panic("restricted area")
+	}
+}
+
+func setAdminAddress(address std.Address) {
+	adminAddr = address
+}
+
+func SetAdminAddress(address std.Address) {
+	assertIsAdmin()
+	setAdminAddress(address)
+}

examples/gno.land/r/demo/teritori/gh/admin_test.gno

@@ -0,0 +1,22 @@
+package gh
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/testutils"
+)
+
+func TestAssertIsAdmin(t *testing.T) {
+	adminAddr = "g1test1234" 
+	randomuser := testutils.TestAddress("g1unknown_player")
+	defer func() {
+        if r := recover(); r != nil {
+        }
+    }()
+	std.TestSetOrigCaller(randomuser)
+	assertIsAdmin()
+	t.Fatalf("should fail because not admin")
+}
+

examples/gno.land/r/demo/teritori/gh/oracle.gno

@@ -11,13 +11,12 @@ import (
 var (
 	accounts       avl.Tree    // uri -> Account
 	lastUpdateTime time.Time   // used by the bot to only upload the diff
-	oracleAddr     std.Address = "g1eunnckcl6r8ncwj0lrpxu9g5062xcvwxqlrf29"
-	adminAddr      std.Address = "g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq" 
+	oracleAddr     std.Address
 )
 
 func OracleLastUpdated() time.Time { return lastUpdateTime }
 
-func OracleUpsertAccount(id, name, kind string) {
+func OracleUpsertAccount(id, login, name, kind string) {
 	assertIsOracle()
 	lastUpdateTime = time.Now()
 
@@ -33,6 +32,7 @@ func OracleUpsertAccount(id, name, kind string) {
 	// update fields
 	account.name = name
 	account.kind = kind
+	account.login = login
 
 	if err := account.Validate(); err != nil {
 		panic(err)
@@ -47,14 +47,6 @@ func AdminSetOracleAddr(new std.Address) {
 	oracleAddr = new
 }
 
-func AdminGetOracleAddr() std.Address { return oracleAddr }
-
-func assertIsAdmin() {
-	if std.GetOrigCaller() != adminAddr {
-		panic("restricted area")
-	}
-}
-
 func assertIsOracle() {
 	if std.GetOrigCaller() != oracleAddr {
 		panic("restricted area")

examples/gno.land/r/demo/teritori/gh/oracle_test.gno

@@ -0,0 +1,60 @@
+package gh
+
+import (
+	"std"
+	"testing"
+	"time"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/testutils"
+)
+
+func TestOracleUpsertUserIsNotOracle(t *testing.T) {
+	oracleAddr = "g1test1234" 
+	var randomuser = "g1unknown_player"
+	user := testutils.TestAddress("user")
+	defer func() {
+		if r := recover(); r != nil {
+		}
+	}()
+	OracleUpsertAccount("acountID", "villaquiranm","john doe","user")
+	t.Fatalf("should fail because not admin")
+}
+
+func TestOracleUpsertUserOk(t *testing.T) {
+	oracleAddr = "g1random" 
+	if accounts.Size() != 0 {
+		t.Fatalf("Accounts is not empty")
+	}
+	now := time.Now()
+
+	std.TestSetOrigCaller(oracleAddr)
+
+	var randomuser = "g1unknown_player"
+	OracleUpsertAccount("acountID", "villaquiranm","john doe","user")
+
+	if accounts.Size() != 1 {
+		t.Fatalf("User was not created")
+	}
+
+	OracleUpsertAccount("acountID", "villaquiranm","john doe","user")
+
+	if accounts.Size() != 1 {
+		t.Fatalf("User was created more than once")
+	}
+
+	if OracleLastUpdated().Unix() < now.Unix() {
+		t.Fatalf("OracleLastUpdated was not changed")
+	}
+}
+
+func TestAssertIsOracle(t *testing.T) {
+	std.TestSetOrigCaller(adminAddr)
+	AdminSetOracleAddr("g1random123")
+	defer func() {
+        if r := recover(); r != nil {
+        }
+    }()
+	assertIsOracle()
+	t.Fatalf("should fail because user is not oracle")
+}

examples/gno.land/r/demo/teritori/gh/public.gno

@@ -1,20 +1,36 @@
 package gh
+
+import (
+	"fmt"
+	"std"
+	"gno.land/p/demo/avl"
+)
 var (
-addressesToAccount avl.Tree    // address -> AccountLink
-adminAddr      std.Address = "g1u7y667z64x2h7vc6fmpcprgey4ck233jaww9zq" 
+	addressToAccount avl.Tree    // address -> AccountLink
+	guardian 	   std.Address // guardian address
 ) 
-func LinkAccount(accountID string, address std.Address) {
+
+func init() {
+	setAdminAddress(std.GetOrigCaller())
+}
+
+//Todo maybe we should gave multi guardian
+func SetGuardian(address std.Address) {
 	assertIsAdmin()
-	account := AccountByID(id string)
+	guardian = address
+}
+
+func LinkAccount(accountID string, address std.Address, signature string) {
+	verifySignature(fmt.Sprintf("%s %s", accountID, address.String()), signature)
+
+	account := AccountByID(accountID)
 	if account == nil {
 		panic("account not found")
 	}
 
-	addressesToAccount.Set(address, account)
+	addressToAccount.Set(address.String(), account)
 }
 
-func assertIsAdmin() {
-	if std.GetOrigCaller() != adminAddr {
-		panic("restricted area")
-	}
-}
+func verifySignature(message, signature string) bool {
+	return true
+}

examples/gno.land/r/demo/teritori/gh/public_test.gno

@@ -0,0 +1,31 @@
+package gh
+
+import (
+	"std"
+	"testing"
+
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/testutils"
+)
+
+func TestLinkAccount(t *testing.T) {
+	adminAddr = "g1test1234" 
+
+	user := testutils.TestAddress("user")
+	admin := testutils.TestAddress("admin")
+
+	std.TestSetOrigCaller(admin)
+	setAdminAddress(admin)
+	AdminSetOracleAddr(admin)	
+
+	OracleUpsertAccount("123","user", "user", UserAccount)
+	LinkAccount("123", user, "signature")
+	accountInPublic, ok := addressToAccount.Get(user.String())
+	if !ok {
+		t.Fatalf("account not found")
+	}
+	account := AccountByID("123")
+	if accountInPublic != account {
+		t.Fatalf("account is not same")
+	}
+}