TWAP logic

app/apptesting/test_suite.go

@@ -66,7 +66,7 @@ func (s *KeeperTestHelper) Commit() {
 	oldHeight := s.Ctx.BlockHeight()
 	oldHeader := s.Ctx.BlockHeader()
 	s.App.Commit()
-	newHeader := tmtypes.Header{Height: oldHeight + 1, ChainID: oldHeader.ChainID, Time: time.Now().UTC()}
+	newHeader := tmtypes.Header{Height: oldHeight + 1, ChainID: oldHeader.ChainID, Time: oldHeader.Time.Add(time.Second)}
 	s.App.BeginBlock(abci.RequestBeginBlock{Header: newHeader})
 	s.Ctx = s.App.GetBaseApp().NewContext(false, newHeader)
 }

app/upgrades/v12/upgrades.go

@@ -42,6 +42,14 @@ func CreateUpgradeHandler(
 			bpm.StoreConsensusParams(ctx, cp)
 		}
 
+		// Initialize TWAP state
+		// TODO: Get allPoolIds from gamm keeper, and write test for migration.
+		allPoolIds := []uint64{}
+		err := keepers.TwapKeeper.MigrateExistingPools(ctx, allPoolIds)
+		if err != nil {
+			return nil, err
+		}
+
 		return mm.RunMigrations(ctx, configurator, fromVM)
 	}
 }

osmoutils/dec_helper.go

@@ -6,6 +6,8 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+var ThreePlusOneThird sdk.Dec = sdk.MustNewDecFromStr("3.333333333333333333")
+
 // intended to be used with require/assert:  require.True(DecEq(...))
 // TODO: Replace with function in SDK types package when we update
 func DecApproxEq(t *testing.T, d1 sdk.Dec, d2 sdk.Dec, tol sdk.Dec) (*testing.T, bool, string, string, string) {

x/gamm/pool-models/balancer/pool.go

@@ -607,7 +607,8 @@ func (p *Pool) applySwap(ctx sdk.Context, tokensIn sdk.Coins, tokensOut sdk.Coin
 // this is equivalent to spot_price = (Base_supply / Weight_base) / (Quote_supply / Weight_quote)
 // but cancels out the common term in weight.
 //
-// panics if pool is misconfigured and has any weight as 0.
+// panics if the pool in state is incorrect, and has any weight that is 0.
+// TODO: Come back and improve docs for this.
 func (p Pool) SpotPrice(ctx sdk.Context, baseAsset, quoteAsset string) (sdk.Dec, error) {
 	quote, base, err := p.parsePoolAssetsByDenoms(quoteAsset, baseAsset)
 	if err != nil {

x/gamm/twap/api.go

@@ -0,0 +1,91 @@
+package twap
+
+import (
+	"fmt"
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/osmosis-labs/osmosis/v10/x/gamm/twap/types"
+)
+
+// GetArithmeticTwap returns an arithmetic time weighted average price.
+// The returned twap is the time weighted average price (TWAP) of:
+// * the base asset, in units of the quote asset (1 unit of base = x units of quote)
+// * from (startTime, endTime),
+// * as determined by prices from AMM pool `poolId`.
+//
+// startTime and endTime do not have to be real block times that occurred,
+// the state machine will interpolate the accumulator values for those times
+// from the latest Twap accumulation record prior to the provided time.
+//
+// startTime must be within 48 hours of ctx.BlockTime(), if you need older TWAPs,
+// you will have to maintain the accumulator yourself.
+//
+// This function will error if:
+// * startTime > endTime
+// * endTime in the future
+// * startTime older than 48 hours OR pool creation
+// * pool with id poolId does not exist, or does not contain quoteAssetDenom, baseAssetDenom
+//
+// N.B. If there is a notable use case, the state machine could maintain more historical records, e.g. at one per hour.
+func (k Keeper) GetArithmeticTwap(
+	ctx sdk.Context,
+	poolId uint64,
+	baseAssetDenom string,
+	quoteAssetDenom string,
+	startTime time.Time,
+	endTime time.Time) (sdk.Dec, error) {
+	if startTime.After(endTime) {
+		return sdk.Dec{}, fmt.Errorf("called GetArithmeticTwap with a start time that is after the end time."+
+			" (start time %s, end time %s)", startTime, endTime)
+	}
+	if endTime.Equal(ctx.BlockTime()) {
+		return k.GetArithmeticTwapToNow(ctx, poolId, baseAssetDenom, quoteAssetDenom, startTime)
+	} else if endTime.After(ctx.BlockTime()) {
+		return sdk.Dec{}, fmt.Errorf("called GetArithmeticTwap with an end time in the future."+
+			" (end time %s, current time %s)", endTime, ctx.BlockTime())
+	}
+	startRecord, err := k.getInterpolatedRecord(ctx, poolId, startTime, baseAssetDenom, quoteAssetDenom)
+	if err != nil {
+		return sdk.Dec{}, err
+	}
+	endRecord, err := k.getInterpolatedRecord(ctx, poolId, endTime, baseAssetDenom, quoteAssetDenom)
+	if err != nil {
+		return sdk.Dec{}, err
+	}
+	twap := computeArithmeticTwap(startRecord, endRecord, quoteAssetDenom)
+	return twap, nil
+}
+
+// GetArithmeticTwapToNow returns GetArithmeticTwap on the input, with endTime being fixed to ctx.BlockTime()
+func (k Keeper) GetArithmeticTwapToNow(
+	ctx sdk.Context,
+	poolId uint64,
+	baseAssetDenom string,
+	quoteAssetDenom string,
+	startTime time.Time) (sdk.Dec, error) {
+	startRecord, err := k.getInterpolatedRecord(ctx, poolId, startTime, baseAssetDenom, quoteAssetDenom)
+	if err != nil {
+		return sdk.Dec{}, err
+	}
+	endRecord, err := k.GetBeginBlockAccumulatorRecord(ctx, poolId, baseAssetDenom, quoteAssetDenom)
+	if err != nil {
+		return sdk.Dec{}, err
+	}
+	twap := computeArithmeticTwap(startRecord, endRecord, quoteAssetDenom)
+	return twap, nil
+}
+
+// GetCurrentAccumulatorRecord returns a TwapRecord struct corresponding to the state of pool `poolId`
+// as of the beginning of the block this is called on.
+// This uses the state of the beginning of the block, as if there were swaps since the block has started,
+// these swaps have had no time to be arbitraged back.
+// This accumulator can be stored, to compute wider ranged twaps.
+func (k Keeper) GetBeginBlockAccumulatorRecord(ctx sdk.Context, poolId uint64, asset0Denom string, asset1Denom string) (types.TwapRecord, error) {
+	// correct ordering of args for db
+	if asset1Denom > asset0Denom {
+		asset0Denom, asset1Denom = asset1Denom, asset0Denom
+	}
+	return k.getMostRecentRecord(ctx, poolId, asset0Denom, asset1Denom)
+}

x/gamm/twap/api_test.go

@@ -0,0 +1,196 @@
+package twap_test
+
+import (
+	"time"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/osmosis-labs/osmosis/v10/osmoutils"
+	"github.com/osmosis-labs/osmosis/v10/x/gamm/twap/types"
+)
+
+func (s *TestSuite) TestGetBeginBlockAccumulatorRecord() {
+	poolId, denomA, denomB := s.setupDefaultPool()
+	initStartRecord := newRecord(s.Ctx.BlockTime(), sdk.OneDec(), sdk.ZeroDec(), sdk.ZeroDec())
+	initStartRecord.PoolId, initStartRecord.Height = poolId, s.Ctx.BlockHeight()
+	initStartRecord.Asset0Denom, initStartRecord.Asset1Denom = denomA, denomB
+
+	zeroAccumTenPoint1Record := recordWithUpdatedSpotPrice(initStartRecord, sdk.NewDec(10), sdk.NewDecWithPrec(1, 1))
+
+	tests := map[string]struct {
+		// if start record is blank, don't do any sets
+		startRecord types.TwapRecord
+		// We set it to have the updated time
+		expRecord  types.TwapRecord
+		time       time.Time
+		poolId     uint64
+		quoteDenom string
+		baseDenom  string
+		expError   bool
+	}{
+		"no record (wrong pool ID)": {initStartRecord, initStartRecord, baseTime, 4, denomA, denomB, true},
+		"default record":            {initStartRecord, initStartRecord, baseTime, 1, denomA, denomB, false},
+		"one second later record":   {initStartRecord, recordWithUpdatedAccum(initStartRecord, OneSec, OneSec), tPlusOne, 1, denomA, denomB, false},
+		"idempotent overwrite":      {initStartRecord, initStartRecord, baseTime, 1, denomA, denomB, false},
+		"idempotent overwrite2":     {initStartRecord, recordWithUpdatedAccum(initStartRecord, OneSec, OneSec), tPlusOne, 1, denomA, denomB, false},
+		"diff spot price": {zeroAccumTenPoint1Record,
+			recordWithUpdatedAccum(zeroAccumTenPoint1Record, OneSec.MulInt64(10), OneSec.QuoInt64(10)),
+			tPlusOne, 1, denomA, denomB, false},
+		// TODO: Overflow
+	}
+	for name, tc := range tests {
+		s.Run(name, func() {
+			// setup time
+			s.Ctx = s.Ctx.WithBlockTime(tc.time)
+			tc.expRecord.Time = tc.time
+
+			s.twapkeeper.StoreNewRecord(s.Ctx, tc.startRecord)
+
+			actualRecord, err := s.twapkeeper.GetBeginBlockAccumulatorRecord(s.Ctx, tc.poolId, tc.baseDenom, tc.quoteDenom)
+
+			if tc.expError {
+				s.Require().Error(err)
+				return
+			}
+			s.Require().NoError(err)
+			s.Require().Equal(tc.expRecord, actualRecord)
+		})
+	}
+}
+
+func (s *TestSuite) TestGetArithmeticTwap() {
+	type getTwapInput struct {
+		poolId          uint64
+		quoteAssetDenom string
+		baseAssetDenom  string
+		startTime       time.Time
+		endTime         time.Time
+	}
+
+	makeSimpleTwapInput := func(startTime time.Time, endTime time.Time, isQuoteTokenA bool) getTwapInput {
+		quoteAssetDenom, baseAssetDenom := denom0, denom1
+		if isQuoteTokenA {
+			baseAssetDenom, quoteAssetDenom = quoteAssetDenom, baseAssetDenom
+		}
+		return getTwapInput{1, quoteAssetDenom, baseAssetDenom, startTime, endTime}
+	}
+
+	quoteAssetA := true
+	quoteAssetB := false
+	// base record is a record with t=baseTime, sp0=10, sp1=.1, accumulators set to 0
+	baseRecord := newTwapRecordWithDefaults(baseTime, sdk.NewDec(10), sdk.ZeroDec(), sdk.ZeroDec())
+	// record with t=baseTime+10, sp0=5, sp1=.2, accumulators updated from baseRecord
+	// accum0 = 10 seconds * (spot price = 10), accum1 = 10 seconds * (spot price = .1)
+	accum0, accum1 := OneSec.MulInt64(10*10), OneSec
+	tPlus10sp5Record := newTwapRecordWithDefaults(
+		baseTime.Add(10*time.Second), sdk.NewDec(5), accum0, accum1)
+	// TODO: Make use of the below for test cases:
+	// record with t=baseTime+20, sp0=2, sp1=.5, accumulators updated from tPlus10sp5Record
+	// tPlus20sp2Record := newTwapRecordWithDefaults(
+	// 	baseTime.Add(20*time.Second), sdk.NewDec(2), OneSec.MulInt64(10*10+5*10), OneSec.MulInt64(3))
+
+	tests := map[string]struct {
+		recordsToSet []types.TwapRecord
+		ctxTime      time.Time
+		input        getTwapInput
+		expTwap      sdk.Dec
+		expErrorStr  string
+	}{
+		"(1 record) start and end point to same record": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, tPlusOne, quoteAssetA),
+			expTwap:      sdk.NewDec(10),
+		},
+		"(1 record) start and end point to same record, use sp1": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, tPlusOne, quoteAssetB),
+			expTwap:      sdk.NewDecWithPrec(1, 1),
+		},
+		"(1 record) start and end point to same record, end time = now": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, baseTime.Add(time.Minute), quoteAssetA),
+			expTwap:      sdk.NewDec(10),
+		},
+
+		"(2 record) start and end point to same record": {
+			recordsToSet: []types.TwapRecord{baseRecord, tPlus10sp5Record},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, tPlusOne, quoteAssetA),
+			expTwap:      sdk.NewDec(10),
+		},
+		"(2 record) start and end exact, different records": {
+			recordsToSet: []types.TwapRecord{baseRecord, tPlus10sp5Record},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, baseTime.Add(10*time.Second), quoteAssetA),
+			expTwap:      sdk.NewDec(10),
+		},
+		"(2 record) start exact, end after second record": {
+			recordsToSet: []types.TwapRecord{baseRecord, tPlus10sp5Record},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, baseTime.Add(20*time.Second), quoteAssetA),
+			expTwap:      sdk.NewDecWithPrec(75, 1), // 10 for 10s, 5 for 10s
+		},
+		"(2 record) start exact, end after second record, sp1": {
+			recordsToSet: []types.TwapRecord{baseRecord, tPlus10sp5Record},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime, baseTime.Add(20*time.Second), quoteAssetB),
+			expTwap:      sdk.NewDecWithPrec(15, 2), // .1 for 10s, .2 for 10s
+		},
+		"(2 record) start and end interpolated": {
+			recordsToSet: []types.TwapRecord{baseRecord, tPlus10sp5Record},
+			ctxTime:      baseTime.Add(time.Minute),
+			input:        makeSimpleTwapInput(baseTime.Add(5*time.Second), baseTime.Add(20*time.Second), quoteAssetA),
+			// 10 for 5s, 5 for 10s = 100/15 = 6 + 2/3 = 6.66666666
+			expTwap: osmoutils.ThreePlusOneThird.MulInt64(2),
+		},
+
+		// error catching
+		"end time in future": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime,
+			input:        makeSimpleTwapInput(baseTime, tPlusOne, quoteAssetA),
+			expErrorStr:  "future",
+		},
+		"start time after end time": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime,
+			input:        makeSimpleTwapInput(tPlusOne, baseTime, quoteAssetA),
+			expErrorStr:  "after",
+		},
+		"start time too old (end time = now)": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime,
+			input:        makeSimpleTwapInput(baseTime.Add(-time.Hour), baseTime, quoteAssetA),
+			expErrorStr:  "too old",
+		},
+		"start time too old": {
+			recordsToSet: []types.TwapRecord{baseRecord},
+			ctxTime:      baseTime.Add(time.Second),
+			input:        makeSimpleTwapInput(baseTime.Add(-time.Hour), baseTime, quoteAssetA),
+			expErrorStr:  "too old",
+		},
+		// TODO: overflow tests, multi-asset pool handling, make more record interpolation cases
+	}
+	for name, test := range tests {
+		s.Run(name, func() {
+			s.SetupTest()
+			for _, record := range test.recordsToSet {
+				s.twapkeeper.StoreNewRecord(s.Ctx, record)
+			}
+			s.Ctx = s.Ctx.WithBlockTime(test.ctxTime)
+			twap, err := s.twapkeeper.GetArithmeticTwap(s.Ctx, test.input.poolId,
+				test.input.quoteAssetDenom, test.input.baseAssetDenom,
+				test.input.startTime, test.input.endTime)
+			if test.expErrorStr != "" {
+				s.Require().Error(err)
+				s.Require().Contains(err.Error(), test.expErrorStr)
+				return
+			}
+			s.Require().NoError(err)
+			s.Require().Equal(test.expTwap, twap)
+		})
+	}
+}

x/gamm/twap/export_test.go

@@ -32,14 +32,14 @@ func (k Keeper) GetChangedPools(ctx sdk.Context) []uint64 {
 	return k.getChangedPools(ctx)
 }
 
-// func (k Keeper) UpdateRecord(ctx sdk.Context, record types.TwapRecord) types.TwapRecord {
-// 	return k.updateRecord(ctx, record)
-// }
+func (k Keeper) UpdateRecord(ctx sdk.Context, record types.TwapRecord) types.TwapRecord {
+	return k.updateRecord(ctx, record)
+}
 
-// func ComputeArithmeticTwap(startRecord types.TwapRecord, endRecord types.TwapRecord, quoteAsset string) sdk.Dec {
-// 	return computeArithmeticTwap(startRecord, endRecord, quoteAsset)
-// }
+func ComputeArithmeticTwap(startRecord, endRecord types.TwapRecord, quoteAsset string) sdk.Dec {
+	return computeArithmeticTwap(startRecord, endRecord, quoteAsset)
+}
 
-// func InterpolateRecord(record types.TwapRecord, t time.Time) types.TwapRecord {
-// 	return interpolateRecord(record, t)
-// }
+func RecordWithUpdatedAccumulators(record types.TwapRecord, t time.Time) types.TwapRecord {
+	return recordWithUpdatedAccumulators(record, t)
+}