feat: Initial implementation of auction dApp

examples/gno.land/p/demo/auction/auction.gno

@@ -0,0 +1,140 @@
+package auction
+
+import (
+	"std"
+	"strconv"
+	"time"
+
+	"gno.land/p/demo/avl"
+)
+
+// Main struct
+type Auction struct {
+	title       string
+	owner       std.Address
+	description string
+	begin       time.Time
+	end         time.Time
+	price       uint64
+	bids        *avl.Tree // key: std.Address, value: Bid
+}
+
+type Bid struct {
+	bidder std.Address
+	amount uint64
+}
+
+type EventEnd struct {
+	winner std.Address
+	amount uint64
+}
+
+func NewAuction(
+	title string,
+	owner std.Address,
+	description string,
+	begin time.Time,
+	end time.Time,
+	minPrice uint64,
+) *Auction {
+	auction := &Auction{
+		title:       title,
+		description: description,
+		owner:       owner,
+		bids:        avl.NewTree(),
+		begin:       begin,
+		end:         end,
+		price:       minPrice,
+	}
+	// Emit AuctionStart event
+	std.Emit("AuctionStart", "title", title, "time", begin.String())
+	return auction
+}
+
+// GetTitle returns the title of the auction.
+func (a Auction) GetTitle() string {
+	return a.title
+}
+
+// GetDescription returns the description of the auction.
+func (a Auction) GetDescription() string {
+	return a.description
+}
+
+// GetOwner returns the address of the auction owner.
+func (a Auction) GetOwner() std.Address {
+	return a.owner
+}
+
+// GetBegin returns the start time of the auction.
+func (a Auction) GetBegin() time.Time {
+	return a.begin
+}
+
+// GetEnd returns the end time of the auction.
+func (a Auction) GetEnd() time.Time {
+	return a.end
+}
+
+// GetPrice returns the current highest bid amount.
+func (a Auction) GetPrice() uint64 {
+	return a.price
+}
+
+// GetBids returns an array of all the bids made in the auction.
+func (a Auction) GetBids() []*Bid {
+	bids := make([]*Bid, 0, a.bids.Size())
+	a.bids.Iterate("", "", func(key string, value interface{}) bool {
+		bids = append(bids, value.(*Bid))
+		return false
+	})
+	return bids
+}
+
+// IsOwner checks if the given address is the owner of the auction.
+func (a Auction) IsOwner(address std.Address) bool {
+	return address == a.GetOwner()
+}
+
+// NewBid creates a new Bid instance.
+func NewBid(bidder std.Address, amount uint64) *Bid {
+	return &Bid{
+		bidder: bidder,
+		amount: amount,
+	}
+}
+
+// AddBid adds a new bid to the auction.
+func (a *Auction) AddBid(bidder std.Address, amount uint64) {
+	if amount <= a.price {
+		panic("bid amount must be higher than current highest bid")
+	}
+	key := strconv.Itoa(a.bids.Size())
+	bid := NewBid(bidder, amount)
+	a.bids.Set(key, bid)
+	a.price = amount
+	std.Emit("BidPlaced", "bidder", bidder.String(), "amount", strconv.FormatUint(amount, 10))
+}
+
+// GetBidder returns the address of the bidder.
+func (b Bid) GetBidder() std.Address {
+	return b.bidder
+}
+
+// GetAmount returns the amount of the bid.
+func (b Bid) GetAmount() uint64 {
+	return b.amount
+}
+
+// EndAuction ends the auction and emits the AuctionEnded event.
+func (a *Auction) EndAuction() {
+	if time.Now().Before(a.end) {
+		panic("Auction cannot end before the end time")
+	}
+	if a.bids.Size() == 0 {
+		panic("No bids placed")
+	}
+	highestBid := a.GetPrice()
+	winner := a.GetBids()[a.bids.Size()-1].GetBidder()
+	std.Emit("AuctionEnded", "winner", winner.String(), "amount", strconv.FormatUint(highestBid, 10))
+}

examples/gno.land/p/demo/auction/auction_test.gno

@@ -0,0 +1,110 @@
+package auction
+
+import (
+	"std"
+	"testing"
+	"time"
+
+	"gno.land/p/demo/testutils"
+)
+
+// TestBid_new verifies that a new Bid can be initialized correctly
+func TestBid_new(t *testing.T) {
+	var (
+		amount = uint64(100)
+		bidder = testutils.TestAddress("bidder")
+	)
+
+	// Create a new Bid instance
+	B := NewBid(bidder, amount)
+	if B.GetAmount() != amount {
+		t.Fatalf("invalid amount")
+	}
+	if B.GetBidder() != bidder {
+		t.Fatalf("invalid bidder")
+	}
+}
+
+// TestAuction_new verifies that a new Auction can be initialized correctly
+func TestAuction_new(t *testing.T) {
+	var (
+		title       = "auction title"
+		owner       = testutils.TestAddress("owner")
+		description = "description"
+		begin       = time.Now()
+		end         = begin.Add(time.Hour * 24)
+		minPrice    = uint64(1)
+	)
+
+	// Create a new Auction instance
+	A := NewAuction(title, owner, description, begin, end, minPrice)
+	if A.GetTitle() != title {
+		t.Fatalf("invalid title")
+	}
+	if A.GetOwner() != owner {
+		t.Fatalf("invalid owner")
+	}
+	if A.GetDescription() != description {
+		t.Fatalf("invalid description")
+	}
+	if A.GetBegin() != begin {
+		t.Fatalf("invalid begin")
+	}
+	if A.GetEnd() != end {
+		t.Fatalf("invalid end")
+	}
+	if A.GetPrice() != minPrice {
+		t.Fatalf("invalid minPrice")
+	}
+
+	std.TestSetOrigCaller(owner)
+	if !A.IsOwner(owner) {
+		t.Fatalf("invalid owner check")
+	}
+}
+
+// TestAuction_AddBid verifies that bids can be added to an auction correctly
+func TestAuction_AddBid(t *testing.T) {
+	var (
+		title       = "auction title"
+		owner       = testutils.TestAddress("owner")
+		bidder1     = testutils.TestAddress("bidder1")
+		bidder2     = testutils.TestAddress("bidder2")
+		description = "description"
+		begin       = time.Now()
+		end         = begin.Add(time.Hour * 24)
+		minPrice    = uint64(100)
+	)
+
+	// Create a new Auction instance
+	A := NewAuction(title, owner, description, begin, end, minPrice)
+
+	// to do Simulate time to be after auction start
+	//  std.TestSetTime(begin.Add(time.Second))
+
+	// Place first bid
+	std.TestSetOrigCaller(bidder1)
+	A.AddBid(bidder1, 200)
+	if A.GetPrice() != 200 {
+		t.Fatalf("First bid failed")
+	}
+
+	// Place second bid
+	std.TestSetOrigCaller(bidder2)
+	A.AddBid(bidder2, 300)
+	if A.GetPrice() != 300 {
+		t.Fatalf("Second bid failed")
+	}
+
+	// Verify bids
+	bids := A.GetBids()
+	if len(bids) != 2 {
+		t.Fatalf("Expected 2 bids, got %d", len(bids))
+	}
+	if bids[0].GetBidder() != bidder1 || bids[0].GetAmount() != 200 {
+		t.Fatalf("First bid incorrect")
+	}
+	if bids[1].GetBidder() != bidder2 || bids[1].GetAmount() != 300 {
+		t.Fatalf("Second bid incorrect")
+	}
+}

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

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

examples/gno.land/r/demo/auction/auction.gno

@@ -0,0 +1,134 @@
+package auction
+
+import (
+	"bytes"
+	"std"
+	"strconv"
+	"time"
+
+	auctionp "gno.land/p/demo/auction"
+	"gno.land/p/demo/avl"
+	"gno.land/p/demo/ufmt"
+)
+
+var (
+	auctionTree *avl.Tree
+	currentTime time.Time
+)
+
+// Initialize the realm with auction tree
+func init() {
+	auctionTree = avl.NewTree()
+}
+
+// Mockable function to get current time
+func now() time.Time {
+	if !currentTime.IsZero() {
+		return currentTime
+	}
+	return time.Now()
+}
+
+// NewAuction creates a new auction in the realm
+func NewAuction(
+	title string,
+	description string,
+	begin int64,
+	end int64,
+	price uint64,
+) *auctionp.Auction {
+	txSender := std.GetOrigCaller()
+
+	if begin < now().Unix() {
+		panic("begin has to be in the future")
+	}
+	if end <= now().Unix() {
+		panic("end has to be in the future")
+	}
+	if end <= begin {
+		panic("end has to be after begin")
+	}
+	if price <= 0 {
+		panic("price has to be positive")
+	}
+
+	auc := auctionp.NewAuction(
+		title,
+		txSender,
+		description,
+		time.Unix(begin, 0),
+		time.Unix(end, 0),
+		price,
+	)
+	id := strconv.Itoa(auctionTree.Size())
+	auctionTree.Set(id, auc)
+	return auc
+}
+
+// AddBid places a bid in the auction
+func AddBid(auctionID string, price uint64) string {
+	bidder := std.GetOrigCaller()
+	auc, ok := auctionTree.Get(auctionID)
+	if !ok {
+		panic("auction does not exist")
+	}
+	auction := auc.(*auctionp.Auction)
+	if auction.GetBegin().After(now()) {
+		panic("auction is not open yet")
+	}
+	if auction.GetEnd().Before(now()) {
+		panic("auction is closed")
+	}
+	if auction.IsOwner(bidder) {
+		panic("owner cannot bid")
+	}
+	if auction.GetPrice() >= price {
+		panic("price has to be higher than minimum price")
+	}
+
+	auction.AddBid(bidder, price)
+	return "bid placed"
+}
+
+// Render renders the state of the realm
+func Render(path string) string {
+	if path == "" {
+		return renderHomepage()
+	}
+	return "unknown page"
+}
+
+// renderHomepage renders the homepage of the realm
+func renderHomepage() string {
+	var b bytes.Buffer
+	b.WriteString("<h1><center>Auctions</center></h1>\n\n")
+	if auctionTree.Size() == 0 {
+		b.WriteString("## No auctions available\n")
+		return b.String()
+	}
+	auctionTree.Iterate("", "", func(key string, value interface{}) bool {
+		auc := value.(*auctionp.Auction)
+		b.WriteString("## " + auc.GetTitle() + "\n")
+		b.WriteString("### Owner: " + auc.GetOwner().String() + "\n")
+		b.WriteString("### Description: " + auc.GetDescription() + "\n\n")
+		b.WriteString("This auction starts on: " + auc.GetBegin().String() + " and ends on: " + auc.GetEnd().String() + "\n\n")
+		b.WriteString(ufmt.Sprintf("### Bids %d \n", auc.GetPrice()))
+		b.WriteString("## Bids\n")
+		bids := auc.GetBids()
+		for _, bid := range bids {
+			b.WriteString("Bidder: " + bid.GetBidder().String() + ", Amount: " + strconv.FormatUint(bid.GetAmount(), 10) + "\n")
+		}
+		return false
+	})
+	return b.String()
+}
+
+// Helper function to set the mock current time
+func setcurrentTime(t time.Time) {
+	currentTime = t
+}
+
+// Helper function to reset the mock current time
+func resetcurrentTime() {
+	currentTime = time.Time{}
+}