feat(examples): Voting Realm: A Bitmap and Nonce-based Approach

examples/gno.land/p/demo/bitmap/bitmap.gno

@@ -0,0 +1,58 @@
+package bitmap
+
+import (
+	"gno.land/p/demo/ufmt"
+)
+
+// A simple implementation of Bitmap
+
+// Bitmap represents a bitmap using a slice of bytes
+type Bitmap struct {
+	data []byte
+}
+
+// NewBitmap creates a new Bitmap with a specific size (in bits)
+func New(size uint64) *Bitmap {
+	byteSize := (size + 7) / 8 // Calculate the number of bytes needed
+	return &Bitmap{
+		data: make([]byte, byteSize),
+	}
+}
+
+// MustSet sets the bit at the given index (0-based) and returns an error if out of bounds
+func (b *Bitmap) Set(index uint64) error {
+	if index >= uint64(len(b.data))*8 {
+		return ufmt.Errorf("Index out of bounds")
+	}
+
+	byteIndex := index / 8
+	bitIndex := index % 8
+
+	b.data[byteIndex] |= 1 << uint(bitIndex) // Set the corresponding bit using bitwise OR
+
+	return nil
+}
+
+// Set sets the bit at the given index (0-based)
+func (b *Bitmap) MustSet(index uint64) {
+	if index >= uint64(len(b.data))*8 {
+		panic("Index out of bounds")
+	}
+
+	byteIndex := index / 8
+	bitIndex := index % 8
+
+	b.data[byteIndex] |= 1 << uint(bitIndex) // Set the corresponding bit using bitwise OR
+}
+
+// Get checks if the bit at the given index is set
+func (b *Bitmap) Get(index uint64) bool {
+	if index >= uint64(len(b.data))*8 {
+		panic("Index out of bounds")
+	}
+
+	byteIndex := index / 8
+	bitIndex := index % 8
+
+	return b.data[byteIndex]&(1<<uint(bitIndex)) > 0 // Check if the corresponding bit is set using bitwise AND
+}

examples/gno.land/p/demo/bitmap/bitmap_test.gno

@@ -0,0 +1,96 @@
+package bitmap
+
+import (
+	"testing"
+)
+
+func TestBitmap_New(t *testing.T) {
+	size := uint64(16)
+	bm := New(size)
+
+	if len(bm.data)*8 != int(size) {
+		t.Errorf("Expected bitmap size: %d, got: %d", size, len(bm.data)*8)
+	}
+}
+
+func TestBitmap_SetAndGet(t *testing.T) {
+	bm := New(16)
+
+	// Test setting and getting bits within bounds
+	err := bm.Set(2)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if !bm.Get(2) {
+		t.Errorf("Expected bit at index 2 to be set")
+	}
+
+	err = bm.Set(15)
+	if err != nil {
+		t.Errorf("Expected no error, got: %v", err)
+	}
+
+	if !bm.Get(15) {
+		t.Errorf("Expected bit at index 15 to be set")
+	}
+
+	// Test setting and getting bits out of bounds
+	err = bm.Set(16)
+	if err == nil {
+		t.Errorf("Expected error, got: nil")
+	}
+}
+
+func TestBitmap_MustSet(t *testing.T) {
+	bm := New(16)
+
+	// Test setting bits within bounds
+	defer func() {
+		if r := recover(); r != nil {
+			t.Errorf("Expected no panic, but got panic: %v", r)
+		}
+	}()
+
+	bm.MustSet(2)
+	if !bm.Get(2) {
+		t.Errorf("Expected bit at index 2 to be set")
+	}
+
+	bm.MustSet(15)
+	if !bm.Get(15) {
+		t.Errorf("Expected bit at index 15 to be set")
+	}
+
+	// Test setting bits out of bounds
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("Expected panic, but no panic occurred")
+		}
+	}()
+
+	bm.MustSet(16 * 8)
+}
+
+func TestBitmap_Get(t *testing.T) {
+	bm := New(16)
+
+	// Test getting bits within bounds
+	bm.MustSet(2)
+	if !bm.Get(2) {
+		t.Errorf("Expected bit at index 2 to be set")
+	}
+
+	if bm.Get(3) {
+		t.Errorf("Expected bit at index 3 to be unset")
+	}
+
+	// Test getting bits out of bounds
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("Expected panic, but no panic occurred")
+		}
+	}()
+
+	bm.Get(16 * 8)
+}

examples/gno.land/p/demo/bitmap/gno.mod

@@ -0,0 +1,3 @@
+module gno.land/p/demo/bitmap
+
+require gno.land/p/demo/ufmt v0.0.0-latest

examples/gno.land/p/demo/nonce/gno.mod

@@ -0,0 +1,6 @@
+module gno.land/p/demo/nonce
+
+require (
+	gno.land/p/demo/avl v0.0.0-latest
+	gno.land/p/demo/testutils v0.0.0-latest
+)

examples/gno.land/p/demo/nonce/nonce.gno

@@ -0,0 +1,45 @@
+package nonce
+
+import (
+	"std"
+
+	"gno.land/p/demo/avl"
+)
+
+type Manager struct {
+	nonces *avl.Tree
+}
+
+// New creates a new instance of Manager
+func New() *Manager {
+	return &Manager{
+		nonces: avl.NewTree(),
+	}
+}
+
+// GetNonce returns the next unused nonce for an address
+func (m *Manager) GetNonce(addr std.Address) uint64 {
+	key := addr.String()
+
+	nonce, found := m.nonces.Get(key)
+	if !found {
+		m.nonces.Set(key, uint64(0))
+		return 0
+	}
+
+	return nonce.(uint64)
+}
+
+// UseNonce consumes a nonce and returns the current value, then increments the nonce
+func (m *Manager) UseNonce(addr std.Address) {
+	key := addr.String()
+
+	var currentNonce uint64 = 0
+
+	val, found := m.nonces.Get(key)
+	if found {
+		currentNonce = val.(uint64)
+	}
+
+	m.nonces.Set(key, currentNonce+1)
+}

examples/gno.land/p/demo/nonce/nonce_test.gno

@@ -0,0 +1,73 @@
+package nonce
+
+import (
+	"testing"
+
+	"gno.land/p/demo/testutils"
+)
+
+// TestNonceManager tests the Manager functions
+func TestNonceManager(t *testing.T) {
+	nm := New()
+
+	// Use a dummy address for testing
+	address := testutils.TestAddress("dummy")
+
+	// Test GetNonce method
+	if nonce := nm.GetNonce(address); nonce != 0 {
+		t.Errorf("expected nonce to be 0, got %d", nonce)
+	}
+
+	// Test UseNonce method
+	nm.UseNonce(address)
+	if newNonce := nm.GetNonce(address); newNonce != 1 {
+		t.Errorf("expected new nonce to be 1, got %d", newNonce)
+	}
+
+	nm.UseNonce(address)
+	if finalNonce := nm.GetNonce(address); finalNonce != 2 {
+		t.Errorf("expected final nonce to be 2, got %d", finalNonce)
+	}
+}
+
+func TestMultipleAddresses(t *testing.T) {
+	nm := New()
+
+	// Use dummy addresses for testing
+	address1 := testutils.TestAddress("bob")
+	address2 := testutils.TestAddress("alice")
+
+	// Test UseNonce with multiple addresses
+
+	if nonce := nm.GetNonce(address1); nonce != 0 {
+		t.Errorf("expected final nonce to be 0, got %d", nonce)
+	}
+
+	if nonce := nm.GetNonce(address2); nonce != 0 {
+		t.Errorf("expected final nonce to be 0, got %d", nonce)
+	}
+
+	nm.UseNonce(address1)
+	if nonce := nm.GetNonce(address1); nonce != 1 {
+		t.Errorf("expected used nonce to be 1 for address1, got %d", nonce)
+	}
+
+	nm.UseNonce(address2)
+	if nonce := nm.GetNonce(address2); nonce != 1 {
+		t.Errorf("expected used nonce to be 1 for address2, got %d", nonce)
+	}
+}
+
+func TestConcurrentUse(t *testing.T) {
+	nm := New()
+	address := testutils.TestAddress("dummy")
+
+	for i := 0; i < 10; i++ {
+		t.Parallel()
+
+		nm.UseNonce(address)
+		if nonce := nm.GetNonce(address); nonce != uint64(i+1) {
+			t.Errorf("expected used nonce to be %d, got %d", i+1, nonce)
+		}
+	}
+}

examples/gno.land/r/demo/voting/gno.mod

@@ -0,0 +1,9 @@
+module gno.land/r/demo/voting
+
+require (
+	gno.land/p/demo/avl v0.0.0-latest
+	gno.land/p/demo/bitmap v0.0.0-latest
+	gno.land/p/demo/nonce v0.0.0-latest
+	gno.land/p/demo/seqid v0.0.0-latest
+	gno.land/p/demo/testutils v0.0.0-latest
+)