feat: support millisecond block times (#22)

`gastime.Time.FastForwardTo()` now supports fractional seconds, and
`proxytime.ConvertMilliseconds()` is added to provide a conversion from
ms to rate-denominated fractions. These are to be called at the
beginning of a block, before transaction execution.

Closes #16

---------

Signed-off-by: Arran Schlosberg <[email protected]>
Co-authored-by: Michael Kaplan <[email protected]>

Author: ARR4N

gastime/gastime.go

@@ -134,8 +134,8 @@ func (tm *Time) Tick(g gas.Gas) {
 
 // FastForwardTo is equivalent to [proxytime.Time.FastForwardTo] except that it
 // may also update the gas excess.
-func (tm *Time) FastForwardTo(to uint64) {
-	sec, frac := tm.Time.FastForwardTo(to)
+func (tm *Time) FastForwardTo(to uint64, toFrac gas.Gas) {
+	sec, frac := tm.Time.FastForwardTo(to, toFrac)
 	if sec == 0 && frac.Numerator == 0 {
 		return
 	}

gastime/gastime_test.go

@@ -177,9 +177,10 @@ func TestExcess(t *testing.T) {
 	steps := []struct {
 		desc string
 		// Only one of fast-forwarding or ticking per step.
-		ffToBefore uint64
-		tickBefore gas.Gas
-		want       state
+		ffToBefore     uint64
+		ffToBeforeFrac gas.Gas
+		tickBefore     gas.Gas
+		want           state
 	}{
 		{
 			desc:       "initial tick 1/2s",
@@ -235,6 +236,26 @@ func TestExcess(t *testing.T) {
 				Excess:             45*rate/8 - 7*rate/8,
 			},
 		},
+		{
+			desc:           "fast forward 0.5s to 13.5s",
+			ffToBefore:     55,
+			ffToBeforeFrac: rate / 2,
+			want: state{
+				UnixTime:           55,
+				ConsumedThisSecond: frac(rate / 2),
+				Excess:             45*rate/8 - 7*rate/8 - (rate/2)/2,
+			},
+		},
+		{
+			desc:           "fast forward 0.75s to 14.25s",
+			ffToBefore:     56,
+			ffToBeforeFrac: rate / 4,
+			want: state{
+				UnixTime:           56,
+				ConsumedThisSecond: frac(rate / 4),
+				Excess:             45*rate/8 - 7*rate/8 - (rate/2)/2 - 3*(rate/4)/2,
+			},
+		},
 		{
 			desc:       "fast forward causes overflow when seconds multiplied by R",
 			ffToBefore: math.MaxUint64,
@@ -247,13 +268,16 @@ func TestExcess(t *testing.T) {
 	}
 
 	for _, s := range steps {
-		switch ff, tk := s.ffToBefore, s.tickBefore; {
-		case ff > 0 && tk > 0:
+		ffSec, ffFrac := s.ffToBefore, s.ffToBeforeFrac
+		tick := s.tickBefore
+
+		switch ff := (ffSec > 0 || ffFrac > 0); {
+		case ff && tick > 0:
 			t.Fatalf("Bad test setup (%q) only FastForward() or Tick() before", s.desc)
-		case ff > 0:
-			tm.FastForwardTo(ff)
-		case tk > 0:
-			tm.Tick(tk)
+		case ff:
+			tm.FastForwardTo(ffSec, ffFrac)
+		case tick > 0:
+			tm.Tick(tick)
 		}
 		tm.requireState(t, s.desc, s.want, ignore)
 	}

proxytime/proxytime.go

@@ -89,25 +89,55 @@ func (tm *Time[D]) Tick(d D) {
 	tm.fraction = D(rem)
 }
 
-// FastForwardTo sets the time to the specified Unix timestamp if it is in the
-// future, returning the integer and fraction number of seconds by which the
-// time was advanced. The fraction is always denominated in [Time.Rate].
-func (tm *Time[D]) FastForwardTo(to uint64) (uint64, FractionalSecond[D]) {
-	if to <= tm.seconds {
+// FastForwardTo sets the time to the specified Unix timestamp and fraction of a
+// second, if it is in the future, returning the integer and fraction number of
+// seconds by which the time was advanced. Both the incoming argument and the
+// returned fraction are denominated in [Time.Rate]. Behaviour is undefined if
+// `to + toFrac / tm.Rate()` overflows 64 bits, which is impossible in practice.
+func (tm *Time[D]) FastForwardTo(to uint64, toFrac D) (uint64, FractionalSecond[D]) {
+	to += uint64(toFrac / tm.hertz)
+	toFrac %= tm.hertz
+
+	if !tm.isFuture(to, toFrac) {
 		return 0, FractionalSecond[D]{0, tm.hertz}
 	}
 
-	sec := to - tm.seconds
-	var frac D
-	if tm.fraction > 0 {
-		frac = tm.hertz - tm.fraction
-		sec--
+	ffSec := to - tm.seconds
+	ffFrac := FractionalSecond[D]{
+		Denominator: tm.hertz,
+	}
+
+	if tm.fraction > toFrac {
+		ffSec--
+		ffFrac.Numerator = tm.hertz - (tm.fraction - toFrac)
+	} else {
+		ffFrac.Numerator = toFrac - tm.fraction
 	}
 
 	tm.seconds = to
-	tm.fraction = 0
+	tm.fraction = toFrac
+
+	return ffSec, ffFrac
+}
 
-	return sec, FractionalSecond[D]{frac, tm.hertz}
+func (tm *Time[D]) isFuture(sec uint64, num D) bool {
+	if sec != tm.seconds {
+		return sec > tm.seconds
+	}
+	return num > tm.fraction
+}
+
+// ConvertMilliseconds returns `ms` as a number of seconds and a fraction of a
+// second, denominated in `rate` and rounded down if `rate` is not a multiple of
+// 1000.
+func ConvertMilliseconds[D Duration](rate D, ms uint64) (sec uint64, _ FractionalSecond[D]) {
+	sec = ms / 1000
+	ms %= 1000
+	frac := FractionalSecond[D]{
+		Denominator: rate,
+	}
+	frac.Numerator, _, _ = intmath.MulDiv(D(ms), rate, 1000) // overflow is impossible as ms < 1000
+	return sec, frac
 }
 
 // SetRate changes the unit rate at which time passes. The requisite integer

proxytime/proxytime_test.go

@@ -246,9 +246,16 @@ func TestFastForward(t *testing.T) {
 	steps := []struct {
 		tickBefore uint64
 		ffTo       uint64
+		ffToFrac   uint64
 		wantSec    uint64
 		wantFrac   FractionalSecond[uint64]
 	}{
+		{
+			tickBefore: 0,
+			ffTo:       41, // in the past
+			wantSec:    0,
+			wantFrac:   frac(0, rate),
+		},
 		{
 			tickBefore: 100, // 42.100
 			ffTo:       42,  // in the past
@@ -273,20 +280,101 @@ func TestFastForward(t *testing.T) {
 			wantSec:    5,
 			wantFrac:   frac(800, rate),
 		},
+		{
+			tickBefore: 0, // 50.000
+			ffTo:       50,
+			ffToFrac:   900,
+			wantSec:    0,
+			wantFrac:   frac(900, rate),
+		},
+		{
+			tickBefore: 0, // 50.900
+			ffTo:       51,
+			ffToFrac:   100,
+			wantSec:    0,
+			wantFrac:   frac(200, rate),
+		},
+		{
+			tickBefore: 100, // 51.200
+			ffTo:       51,
+			ffToFrac:   200,
+			wantSec:    0,
+			wantFrac:   frac(0, rate),
+		},
 	}
 
 	for _, s := range steps {
 		tm.Tick(s.tickBefore)
-		gotSec, gotFrac := tm.FastForwardTo(s.ffTo)
-		assert.Equal(t, s.wantSec, gotSec)
-		assert.Equal(t, s.wantFrac, gotFrac)
+		gotSec, gotFrac := tm.FastForwardTo(s.ffTo, s.ffToFrac)
+		assert.Equal(t, s.wantSec, gotSec, "Fast-forwarded seconds")
+		assert.Equal(t, s.wantFrac, gotFrac, "Fast-forwarded fractional numerator")
 
 		if t.Failed() {
 			t.FailNow()
 		}
 	}
 }
 
+func TestConvertMilliseconds(t *testing.T) {
+	type Hz uint64
+
+	tests := []struct {
+		rate          Hz
+		ms            uint64
+		wantSec       uint64
+		wantNumerator Hz // ms * (rate / 1000)
+	}{
+		{
+			rate:          1000,
+			ms:            42,
+			wantNumerator: 42,
+		},
+		{
+			rate:          1234 * 2,
+			ms:            1000 / 2,
+			wantNumerator: 1234,
+		},
+		{
+			rate:          98765 * 4,
+			ms:            1000 / 4,
+			wantNumerator: 98765,
+		},
+		{
+			rate:          142857 * 1000,
+			ms:            1,
+			wantNumerator: 142857,
+		},
+		{
+			rate:          1_001,
+			ms:            500,
+			wantNumerator: 500,
+		},
+		{
+			rate:          1000,
+			ms:            1001,
+			wantSec:       1,
+			wantNumerator: 1,
+		},
+		{
+			rate:          1000,
+			ms:            314_159,
+			wantSec:       314,
+			wantNumerator: 159,
+		},
+	}
+
+	for _, tt := range tests {
+		gotSec, gotFrac := ConvertMilliseconds(tt.rate, tt.ms)
+		wantFrac := FractionalSecond[Hz]{
+			Numerator:   tt.wantNumerator,
+			Denominator: tt.rate,
+		}
+		if gotSec != tt.wantSec || gotFrac != wantFrac {
+			t.Errorf("ConvertMilliseconds(%d, %d) got (%v, %v); want (%v, %v)", tt.ms, tt.rate, gotSec, gotFrac, tt.wantSec, wantFrac)
+		}
+	}
+}
+
 func TestCmpUnix(t *testing.T) {
 	tests := []struct {
 		tm         *Time[uint64]