storagecost_test.gno

  1package storagecost
  2
  3import (
  4	"testing"
  5
  6	"gno.land/p/nt/uassert/v0"
  7)
  8
  9func TestRefund(t *testing.T) {
 10	tests := []struct {
 11		name  string
 12		bytes int64
 13		price int64
 14		want  int64
 15	}{
 16		{"one byte at the default price", 1, DefaultStoragePrice, 100},
 17		{"the measured reap", 17835, DefaultStoragePrice, 1783500},
 18		{"the measured compact", 830, DefaultStoragePrice, 83000},
 19		{"zero bytes", 0, DefaultStoragePrice, 0},
 20		{"negative bytes are not a credit", -100, DefaultStoragePrice, 0},
 21		{"a free chain refunds nothing", 1000, 0, 0},
 22		{"a ten-fold price rise", 1000, 1000, 1000000},
 23	}
 24	for _, tt := range tests {
 25		t.Run(tt.name, func(t *testing.T) {
 26			uassert.Equal(t, tt.want, Refund(tt.bytes, tt.price))
 27		})
 28	}
 29}
 30
 31func TestBreakEvenBytes(t *testing.T) {
 32	tests := []struct {
 33		name string
 34		fee  int64
 35		want int64
 36	}{
 37		// A 2.6M gas call at the floor costs 2,600 ugnot, so 26 bytes.
 38		{"the canonical 2.6M gas call", 2600, 26},
 39		{"rounds up, never down", 101, 2},
 40		{"exactly one byte", 100, 1},
 41		{"a fee below one byte still needs a byte", 1, 1},
 42		{"no fee, no threshold", 0, 0},
 43	}
 44	for _, tt := range tests {
 45		t.Run(tt.name, func(t *testing.T) {
 46			got := BreakEvenBytes(tt.fee, DefaultStoragePrice)
 47			uassert.Equal(t, tt.want, got)
 48			// The definition: this many bytes covers the fee, one fewer does not.
 49			if tt.want > 0 {
 50				uassert.True(t, Refund(got, DefaultStoragePrice) >= tt.fee)
 51				uassert.False(t, Refund(got-1, DefaultStoragePrice) >= tt.fee)
 52			}
 53		})
 54	}
 55	uassert.Equal(t, int64(0), BreakEvenBytes(1000, 0))
 56}
 57
 58func TestGasFee(t *testing.T) {
 59	// The floor mainnet has actually accepted: 1 ugnot per 1000 gas.
 60	uassert.Equal(t, int64(5000), FloorGasFee(5_000_000))
 61	uassert.Equal(t, int64(2500), FloorGasFee(2_500_000))
 62	// Rounds up, so a fee is never short.
 63	uassert.Equal(t, int64(1), FloorGasFee(1))
 64	uassert.Equal(t, int64(0), FloorGasFee(0))
 65	// The harness price used in the measurements, 1.2 ugnot per gas.
 66	uassert.Equal(t, int64(6_000_000), GasFee(5_000_000, 12, 10))
 67	uassert.Equal(t, int64(0), GasFee(5_000_000, 0, 10))
 68	uassert.Equal(t, int64(0), GasFee(5_000_000, 1, 0))
 69}
 70
 71func TestEvaluateReproducesTheMeasuredReap(t *testing.T) {
 72	// The measured run: 17,835 bytes freed by a call that used 4,120,876 gas,
 73	// so gas_wanted 5,000,000 at the floor. Net +1,778,500 ugnot.
 74	q := EvaluateAtFloor(17835, 5_000_000)
 75	uassert.Equal(t, int64(1783500), q.Refund)
 76	uassert.Equal(t, int64(5000), q.Fee)
 77	uassert.Equal(t, int64(1778500), q.Net)
 78	uassert.Equal(t, int64(50), q.BreakEven)
 79	uassert.True(t, q.Worth())
 80}
 81
 82func TestEvaluateReproducesTheMeasuredCompact(t *testing.T) {
 83	q := EvaluateAtFloor(830, 2_500_000)
 84	uassert.Equal(t, int64(83000), q.Refund)
 85	uassert.Equal(t, int64(2500), q.Fee)
 86	uassert.Equal(t, int64(80500), q.Net)
 87	uassert.True(t, q.Worth())
 88}
 89
 90func TestEvaluateAtTheHarnessPriceIsALoss(t *testing.T) {
 91	// The same reap priced at 1.2 ugnot/gas, 1200x the floor, loses money.
 92	// This is why the gas price cannot be baked into a contract.
 93	q := Evaluate(17835, DefaultStoragePrice, 5_000_000, 12, 10)
 94	uassert.Equal(t, int64(6_000_000), q.Fee)
 95	uassert.False(t, q.Worth())
 96	uassert.True(t, q.Net < 0)
 97}
 98
 99func TestQuoteString(t *testing.T) {
100	worth := EvaluateAtFloor(17835, 5_000_000)
101	uassert.Equal(t,
102		"17835 bytes, refunds 1.7835 GNOT against 0.005 GNOT of gas, break-even 50 bytes: worth 1.7785 GNOT",
103		worth.String())
104
105	loss := Evaluate(10, DefaultStoragePrice, 5_000_000, 12, 10)
106	uassert.Equal(t,
107		"10 bytes, refunds 0.001 GNOT against 6 GNOT of gas, break-even 60000 bytes: not worth it yet",
108		loss.String())
109}
110
111func TestFormatGNOT(t *testing.T) {
112	tests := []struct {
113		amount int64
114		want   string
115	}{
116		{0, "0 GNOT"},
117		{1, "0.000001 GNOT"},
118		{100, "0.0001 GNOT"},
119		{1_000_000, "1 GNOT"},
120		{1_500_000, "1.5 GNOT"},
121		{1_783_500, "1.7835 GNOT"},
122		{978_743_800, "978.7438 GNOT"},
123		{-2_100, "-0.0021 GNOT"},
124		{1_000_001, "1.000001 GNOT"},
125	}
126	for _, tt := range tests {
127		uassert.Equal(t, tt.want, FormatGNOT(tt.amount))
128	}
129}
130
131func TestEstimateBytes(t *testing.T) {
132	// Measured: a 1,024-byte payload occupied 1,898 bytes of realm state.
133	uassert.Equal(t, int64(1894), EstimateBytes(1024))
134	uassert.Equal(t, int64(0), EstimateBytes(0))
135	uassert.Equal(t, int64(0), EstimateBytes(-5))
136	// Monotonic, which is all a bounty estimate really needs.
137	uassert.True(t, EstimateBytes(2048) > EstimateBytes(1024))
138}