diff --git a/CHANGELOG.md b/CHANGELOG.md
index 408bd8bc7..bc3a88e5d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -101,11 +101,18 @@ tests for race conditions within funtoken precompile
 - [#2101](https://github.com/NibiruChain/nibiru/pull/2101) - fix(evm): tx receipt proper marshalling
 - [#2105](https://github.com/NibiruChain/nibiru/pull/2105) - test(evm): precompile call with revert
 - [#2106](https://github.com/NibiruChain/nibiru/pull/2106) - chore: scheduled basic e2e tests for evm testnet endpoint
-- [#2107](https://github.com/NibiruChain/nibiru/pull/2107) -
-feat(evm-funtoken-precompile): Implement methods: balance, bankBalance, whoAmI
+- [#2107](https://github.com/NibiruChain/nibiru/pull/2107) - feat(evm-funtoken-precompile): Implement methods: balance, bankBalance, whoAmI
 - [#2108](https://github.com/NibiruChain/nibiru/pull/2108) - fix(evm): removed deprecated root key from eth_getTransactionReceipt
 - [#2110](https://github.com/NibiruChain/nibiru/pull/2110) - fix(evm): Restore StateDB to its state prior to ApplyEvmMsg call to ensure deterministic gas usage. This fixes an issue where the StateDB pointer field in NibiruBankKeeper was being updated during readonly query endpoints like eth_estimateGas, leading to non-deterministic gas usage in subsequent transactions.
 - [#2111](https://github.com/NibiruChain/nibiru/pull/2111) - fix: e2e-evm-cron.yml
+- [#2114](https://github.com/NibiruChain/nibiru/pull/2114) - fix(evm): make gas cost zero in conditional bank keeper flow
+- [#2116](https://github.com/NibiruChain/nibiru/pull/2116) - fix(precompile-funtoken.go): Fixes a bug where the err != nil check is missing in the bankBalance precompile method
+- [#2117](https://github.com/NibiruChain/nibiru/pull/2117) - fix(oracle): The
+timestamps resulting from ctx.WithBlock* don't actually correspond to the block
+header information from specified blocks in the chain's history, so the oracle
+exchange rates need a way to correctly retrieve this information. This change
+fixes that discrepency, giving the expected block timesamp for the EVM's oracle
+precompiled contract. The change also simplifies and corrects the code in x/oracle.
 
 #### Nibiru EVM | Before Audit 1 - 2024-10-18
 
@@ -235,7 +242,7 @@ feat(evm-funtoken-precompile): Implement methods: balance, bankBalance, whoAmI
 - Bump `github.com/holiman/uint256` from 1.2.3 to 1.2.4 ([#1730](https://github.com/NibiruChain/nibiru/pull/1730))
 - Bump `github.com/dvsekhvalnov/jose2go` from 1.5.0 to 1.6.0 ([#1733](https://github.com/NibiruChain/nibiru/pull/1733))
 - Bump `github.com/spf13/cast` from 1.5.1 to 1.6.0 ([#1689](https://github.com/NibiruChain/nibiru/pull/1689))
-- Bump `cosmossdk.io/math` from 1.1.2 to 1.2.0 ([#1676](https://github.com/NibiruChain/nibiru/pull/1676))
+- Bump `cosmossdk.io/math` from 1.1.2 to 1.4.0 ([#1676](https://github.com/NibiruChain/nibiru/pull/1676), [#2115](https://github.com/NibiruChain/nibiru/pull/2115))
 - Bump `github.com/grpc-ecosystem/grpc-gateway/v2` from 2.18.0 to 2.18.1 ([#1675](https://github.com/NibiruChain/nibiru/pull/1675))
 - Bump `actions/setup-go` from 4 to 5 ([#1696](https://github.com/NibiruChain/nibiru/pull/1696))
 - Bump `golang` from 1.19 to 1.21 ([#1698](https://github.com/NibiruChain/nibiru/pull/1698))
diff --git a/app/wasmext/stargate_query.go b/app/wasmext/stargate_query.go
index bd1567175..2d90b6d58 100644
--- a/app/wasmext/stargate_query.go
+++ b/app/wasmext/stargate_query.go
@@ -120,7 +120,6 @@ func WasmAcceptedStargateQueries() wasmkeeper.AcceptedStargateQueries {
 
 		// nibiru oracle
 		"/nibiru.oracle.v1.Query/ExchangeRate":      new(oracle.QueryExchangeRateResponse),
-		"/nibiru.oracle.v1.Query/DatedExchangeRate": new(oracle.QueryDatedExchangeRateResponse),
 		"/nibiru.oracle.v1.Query/ExchangeRateTwap":  new(oracle.QueryExchangeRateResponse),
 		"/nibiru.oracle.v1.Query/ExchangeRates":     new(oracle.QueryExchangeRatesResponse),
 		"/nibiru.oracle.v1.Query/Actives":           new(oracle.QueryActivesResponse),
diff --git a/eth/rpc/backend/blocks_test.go b/eth/rpc/backend/blocks_test.go
index 4bb5d6511..918bb8794 100644
--- a/eth/rpc/backend/blocks_test.go
+++ b/eth/rpc/backend/blocks_test.go
@@ -16,7 +16,9 @@ func (s *BackendSuite) TestBlockNumber() {
 	latestHeight, _ := s.network.LatestHeight()
 	resp, err := s.backend.BlockNumber()
 	s.Require().NoError(err, resp)
-	s.Require().Equal(uint64(latestHeight), uint64(blockHeight))
+	// Rather than checking exact equality, which might not be true due to
+	// latency. Add a cushion of 2 blocks.
+	s.Require().LessOrEqual(uint64(latestHeight)-uint64(blockHeight), uint64(2))
 }
 
 func (s *BackendSuite) TestGetBlockByNumberr() {
diff --git a/evm-e2e/justfile b/evm-e2e/justfile
index ce1a88523..396488f58 100644
--- a/evm-e2e/justfile
+++ b/evm-e2e/justfile
@@ -23,3 +23,6 @@ test-basic:
 # Format
 fmt: 
   npm run format
+
+gen-types:
+  npx hardhat typechain
diff --git a/go.mod b/go.mod
index c4546c826..4c44032c7 100644
--- a/go.mod
+++ b/go.mod
@@ -21,7 +21,7 @@ require (
 require (
 	cosmossdk.io/api v0.7.0 // indirect
 	cosmossdk.io/errors v1.0.1
-	cosmossdk.io/math v1.3.0
+	cosmossdk.io/math v1.4.0
 	cosmossdk.io/simapp v0.0.0-20230608160436-666c345ad23d
 	github.com/MakeNowJust/heredoc/v2 v2.0.1
 	github.com/armon/go-metrics v0.4.1
diff --git a/go.sum b/go.sum
index a4fec943d..b484ceb50 100644
--- a/go.sum
+++ b/go.sum
@@ -200,8 +200,8 @@ cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0=
 cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U=
 cosmossdk.io/log v1.3.1 h1:UZx8nWIkfbbNEWusZqzAx3ZGvu54TZacWib3EzUYmGI=
 cosmossdk.io/log v1.3.1/go.mod h1:2/dIomt8mKdk6vl3OWJcPk2be3pGOS8OQaLUM/3/tCM=
-cosmossdk.io/math v1.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
-cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
+cosmossdk.io/math v1.4.0 h1:XbgExXFnXmF/CccPPEto40gOO7FpWu9yWNAZPN3nkNQ=
+cosmossdk.io/math v1.4.0/go.mod h1:O5PkD4apz2jZs4zqFdTr16e1dcaQCc5z6lkEnrrppuk=
 cosmossdk.io/simapp v0.0.0-20230608160436-666c345ad23d h1:E/8y0oG3u9hBR8l4F9MtC0LdZIamPCUwUoLlrHrX86I=
 cosmossdk.io/simapp v0.0.0-20230608160436-666c345ad23d/go.mod h1:xbjky3L3DJEylaho6gXplkrMvJ5sFgv+qNX+Nn47bzY=
 cosmossdk.io/tools/rosetta v0.2.1 h1:ddOMatOH+pbxWbrGJKRAawdBkPYLfKXutK9IETnjYxw=
diff --git a/proto/nibiru/oracle/v1/oracle.proto b/proto/nibiru/oracle/v1/oracle.proto
index 6978d3bc7..76378ff90 100644
--- a/proto/nibiru/oracle/v1/oracle.proto
+++ b/proto/nibiru/oracle/v1/oracle.proto
@@ -130,7 +130,7 @@ message ExchangeRateTuple {
   ];
 }
 
-message DatedPrice {
+message ExchangeRateAtBlock {
   string exchange_rate = 1 [
     (gogoproto.moretags) = "yaml:\"exchange_rate\"",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
@@ -138,6 +138,11 @@ message DatedPrice {
   ];
 
   uint64 created_block = 2 [ (gogoproto.moretags) = "yaml:\"created_block\"" ];
+
+  // Block timestamp for the block where the oracle came to consensus for this
+  // price. This timestamp is a conventional Unix millisecond time, i.e. the
+  // number of milliseconds elapsed since January 1, 1970 UTC. 
+  int64 block_timestamp_ms = 3 [ (gogoproto.moretags) = "yaml:\"block_timestamp_ms\"" ];
 }
 
 // Rewards defines a credit object towards validators
diff --git a/proto/nibiru/oracle/v1/query.proto b/proto/nibiru/oracle/v1/query.proto
index 3be464a1a..925042721 100644
--- a/proto/nibiru/oracle/v1/query.proto
+++ b/proto/nibiru/oracle/v1/query.proto
@@ -10,7 +10,8 @@ option go_package = "github.com/NibiruChain/nibiru/v2/x/oracle/types";
 
 // Query defines the gRPC querier service.
 service Query {
-  // ExchangeRate returns exchange rate of a pair
+  // ExchangeRate returns exchange rate of a pair along with the block height and
+  // block time that the exchange rate was set by the oracle module.
   rpc ExchangeRate(QueryExchangeRateRequest)
       returns (QueryExchangeRateResponse) {
     option (google.api.http).get = "/nibiru/oracle/v1beta1/exchange_rate";
@@ -22,12 +23,6 @@ service Query {
     option (google.api.http).get = "/nibiru/oracle/v1beta1/exchange_rate_twap";
   }
 
-  // DatedExchangeRate returns latest price of a pair
-  rpc DatedExchangeRate(QueryExchangeRateRequest)
-      returns (QueryDatedExchangeRateResponse) {
-    option (google.api.http).get = "/nibiru/oracle/v1beta1/dated_exchange_rate";
-  }
-
   // ExchangeRates returns exchange rates of all pairs
   rpc ExchangeRates(QueryExchangeRatesRequest)
       returns (QueryExchangeRatesResponse) {
@@ -114,20 +109,6 @@ message QueryExchangeRateResponse {
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.nullable) = false
   ];
-}
-
-// QueryExchangeRatesRequest is the request type for the Query/ExchangeRates RPC
-// method.
-message QueryExchangeRatesRequest {
-}
-
-// QueryDatedExchangeRateResponse is the request type for the 
-// Query/DatedExchangeRate RPC method.
-message QueryDatedExchangeRateResponse {
-  string price = 1 [
-    (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
-    (gogoproto.nullable) = false
-  ];
 
   // Block timestamp for the block where the oracle came to consensus for this
   // price. This timestamp is a conventional Unix millisecond time, i.e. the
@@ -138,6 +119,11 @@ message QueryDatedExchangeRateResponse {
   uint64 block_height = 3;
 }
 
+// QueryExchangeRatesRequest is the request type for the Query/ExchangeRates RPC
+// method.
+message QueryExchangeRatesRequest {
+}
+
 // QueryExchangeRatesResponse is response type for the
 // Query/ExchangeRates RPC method.
 message QueryExchangeRatesResponse {
diff --git a/x/evm/keeper/bank_extension.go b/x/evm/keeper/bank_extension.go
index da5221cbb..cb94ccc59 100644
--- a/x/evm/keeper/bank_extension.go
+++ b/x/evm/keeper/bank_extension.go
@@ -1,6 +1,7 @@
 package keeper
 
 import (
+	storetypes "github.com/cosmos/cosmos-sdk/store/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	auth "github.com/cosmos/cosmos-sdk/x/auth/types"
 	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
@@ -84,6 +85,14 @@ func (bk *NibiruBankKeeper) SyncStateDBWithAccount(
 	if bk.StateDB == nil {
 		return
 	}
+
+	cachedGasConfig := ctx.KVGasConfig()
+	defer func() {
+		ctx = ctx.WithKVGasConfig(cachedGasConfig)
+	}()
+
+	// set gas cost to zero for this conditional operation
+	ctx = ctx.WithKVGasConfig(storetypes.GasConfig{})
 	balanceWei := evm.NativeToWei(
 		bk.GetBalance(ctx, acc, evm.EVMBankDenom).Amount.BigInt(),
 	)
diff --git a/x/evm/precompile/funtoken.go b/x/evm/precompile/funtoken.go
index 7aa22af09..4407b26d7 100644
--- a/x/evm/precompile/funtoken.go
+++ b/x/evm/precompile/funtoken.go
@@ -118,6 +118,7 @@ func (p precompileFunToken) sendToBank(
 
 	erc20, amount, to, err := p.parseArgsSendToBank(args)
 	if err != nil {
+		err = ErrInvalidArgs(err)
 		return
 	}
 
@@ -376,6 +377,10 @@ func (p precompileFunToken) bankBalance(
 	}
 
 	addrEth, addrBech32, bankDenom, err := p.parseArgsBankBalance(args)
+	if err != nil {
+		err = ErrInvalidArgs(err)
+		return
+	}
 	bankBal := p.evmKeeper.Bank.GetBalance(ctx, addrBech32, bankDenom).Amount.BigInt()
 
 	return method.Outputs.Pack([]any{
@@ -455,7 +460,8 @@ func (p precompileFunToken) whoAmI(
 
 	addrEth, addrBech32, err := p.parseArgsWhoAmI(args)
 	if err != nil {
-		return bz, err
+		err = ErrInvalidArgs(err)
+		return
 	}
 
 	return method.Outputs.Pack([]any{
diff --git a/x/evm/precompile/oracle.go b/x/evm/precompile/oracle.go
index 17894da56..03c71352d 100644
--- a/x/evm/precompile/oracle.go
+++ b/x/evm/precompile/oracle.go
@@ -89,12 +89,16 @@ func (p precompileOracle) queryExchangeRate(
 		return nil, err
 	}
 
-	price, blockTime, blockHeight, err := p.oracleKeeper.GetDatedExchangeRate(ctx, assetPair)
+	priceAtBlock, err := p.oracleKeeper.ExchangeRates.Get(ctx, assetPair)
 	if err != nil {
 		return nil, err
 	}
 
-	return method.Outputs.Pack(price.BigInt(), uint64(blockTime), blockHeight)
+	return method.Outputs.Pack(
+		priceAtBlock.ExchangeRate.BigInt(),
+		uint64(priceAtBlock.BlockTimestampMs),
+		priceAtBlock.CreatedBlock,
+	)
 }
 
 func (p precompileOracle) parseQueryExchangeRateArgs(args []any) (
diff --git a/x/evm/precompile/oracle_test.go b/x/evm/precompile/oracle_test.go
index 1051e12aa..6fad8af7f 100644
--- a/x/evm/precompile/oracle_test.go
+++ b/x/evm/precompile/oracle_test.go
@@ -1,6 +1,7 @@
 package precompile_test
 
 import (
+	"fmt"
 	"math/big"
 	"testing"
 	"time"
@@ -9,6 +10,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/stretchr/testify/suite"
 
+	"github.com/NibiruChain/nibiru/v2/x/evm"
 	"github.com/NibiruChain/nibiru/v2/x/evm/embeds"
 	"github.com/NibiruChain/nibiru/v2/x/evm/evmtest"
 	"github.com/NibiruChain/nibiru/v2/x/evm/precompile"
@@ -56,14 +58,12 @@ func (s *OracleSuite) TestOracle_FailToPackABI() {
 
 func (s *OracleSuite) TestOracle_HappyPath() {
 	deps := evmtest.NewTestDeps()
-
-	s.T().Log("Query exchange rate")
-	{
-		deps.Ctx = deps.Ctx.WithBlockTime(time.Unix(69, 420)).WithBlockHeight(69)
-		deps.App.OracleKeeper.SetPrice(deps.Ctx, "unibi:uusd", sdk.MustNewDecFromStr("0.067"))
-
-		resp, err := deps.EvmKeeper.CallContract(
-			deps.Ctx,
+	runQuery := func(ctx sdk.Context) (
+		resp *evm.MsgEthereumTxResponse,
+		err error,
+	) {
+		return deps.EvmKeeper.CallContract(
+			ctx,
 			embeds.SmartContract_Oracle.ABI,
 			deps.Sender.EthAddr,
 			&precompile.PrecompileAddr_Oracle,
@@ -72,16 +72,47 @@ func (s *OracleSuite) TestOracle_HappyPath() {
 			"queryExchangeRate",
 			"unibi:uusd",
 		)
+	}
+
+	s.T().Log("Query exchange rate")
+	{
+		// 69 seconds + 420 nanoseconds === 69000 milliseconds for the
+		// return value from the UnixMilli() function
+		deps.Ctx = deps.Ctx.WithBlockTime(time.Unix(69, 420)).WithBlockHeight(69)
+		deps.App.OracleKeeper.SetPrice(deps.Ctx, "unibi:uusd", sdk.MustNewDecFromStr("0.067"))
+
+		resp, err := runQuery(deps.Ctx)
 		s.NoError(err)
 
 		// Check the response
-		out, err := embeds.SmartContract_Oracle.ABI.Unpack(string(precompile.OracleMethod_queryExchangeRate), resp.Ret)
+		out, err := embeds.SmartContract_Oracle.ABI.Unpack(
+			string(precompile.OracleMethod_queryExchangeRate), resp.Ret,
+		)
+		s.NoError(err)
+		s.Equal(out[0].(*big.Int), big.NewInt(67_000_000_000_000_000))
+		s.Equal(fmt.Sprintf("%d", out[1].(uint64)), "69000")
+		s.Equal(fmt.Sprintf("%d", out[2].(uint64)), "69")
+	}
+
+	s.T().Log("Query from a later time")
+	{
+		secondsLater := deps.Ctx.BlockTime().Add(100 * time.Second)
+		resp, err := runQuery(deps.Ctx.
+			WithBlockTime(secondsLater).
+			WithBlockHeight(deps.Ctx.BlockHeight() + 50),
+		)
 		s.NoError(err)
 
 		// Check the response
-		s.Equal(out[0].(*big.Int), big.NewInt(67000000000000000))
-		s.Equal(out[1].(uint64), uint64(69000))
-		s.Equal(out[2].(uint64), uint64(69))
+		out, err := embeds.SmartContract_Oracle.ABI.Unpack(
+			string(precompile.OracleMethod_queryExchangeRate), resp.Ret,
+		)
+		s.NoError(err)
+		// These terms should still be equal because the latest exchange rate
+		// has not changed.
+		s.Equal(out[0].(*big.Int), big.NewInt(67_000_000_000_000_000))
+		s.Equal(fmt.Sprintf("%d", out[1].(uint64)), "69000")
+		s.Equal(fmt.Sprintf("%d", out[2].(uint64)), "69")
 	}
 }
 
diff --git a/x/oracle/genesis_test.go b/x/oracle/genesis_test.go
index f0e1c9dfb..13ccdbf7f 100644
--- a/x/oracle/genesis_test.go
+++ b/x/oracle/genesis_test.go
@@ -17,7 +17,12 @@ func TestExportInitGenesis(t *testing.T) {
 
 	input.OracleKeeper.Params.Set(input.Ctx, types.DefaultParams())
 	input.OracleKeeper.FeederDelegations.Insert(input.Ctx, keeper.ValAddrs[0], keeper.Addrs[1])
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, "pair1:pair2", types.DatedPrice{ExchangeRate: math.LegacyNewDec(123), CreatedBlock: 0})
+	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, "pair1:pair2",
+		types.ExchangeRateAtBlock{
+			ExchangeRate:     math.LegacyNewDec(123),
+			CreatedBlock:     0,
+			BlockTimestampMs: 0,
+		})
 	input.OracleKeeper.Prevotes.Insert(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRatePrevote(types.AggregateVoteHash{123}, keeper.ValAddrs[0], uint64(2)))
 	input.OracleKeeper.Votes.Insert(input.Ctx, keeper.ValAddrs[0], types.NewAggregateExchangeRateVote(types.ExchangeRateTuples{{Pair: "foo", ExchangeRate: math.LegacyNewDec(123)}}, keeper.ValAddrs[0]))
 	input.OracleKeeper.WhitelistedPairs.Insert(input.Ctx, "pair1:pair1")
diff --git a/x/oracle/keeper/querier.go b/x/oracle/keeper/grpc_query.go
similarity index 89%
rename from x/oracle/keeper/querier.go
rename to x/oracle/keeper/grpc_query.go
index 6cc7fbd2b..4410fdc7f 100644
--- a/x/oracle/keeper/querier.go
+++ b/x/oracle/keeper/grpc_query.go
@@ -50,12 +50,15 @@ func (q querier) ExchangeRate(c context.Context, req *types.QueryExchangeRateReq
 	}
 
 	ctx := sdk.UnwrapSDKContext(c)
-	exchangeRate, err := q.Keeper.GetExchangeRate(ctx, req.Pair)
+	out, err := q.Keeper.ExchangeRates.Get(ctx, req.Pair)
 	if err != nil {
 		return nil, err
 	}
-
-	return &types.QueryExchangeRateResponse{ExchangeRate: exchangeRate}, nil
+	return &types.QueryExchangeRateResponse{
+		ExchangeRate:     out.ExchangeRate,
+		BlockTimestampMs: out.BlockTimestampMs,
+		BlockHeight:      out.CreatedBlock,
+	}, nil
 }
 
 /*
@@ -79,24 +82,6 @@ func (q querier) ExchangeRateTwap(c context.Context, req *types.QueryExchangeRat
 	return &types.QueryExchangeRateResponse{ExchangeRate: twap}, nil
 }
 
-// get the latest price snapshot from the oracle for a pair
-func (q querier) DatedExchangeRate(c context.Context, req *types.QueryExchangeRateRequest) (response *types.QueryDatedExchangeRateResponse, err error) {
-	if _, err = q.ExchangeRate(c, req); err != nil {
-		return
-	}
-
-	ctx := sdk.UnwrapSDKContext(c)
-	price, blockTime, blockHeight, err := q.Keeper.GetDatedExchangeRate(ctx, req.Pair)
-	if err != nil {
-		return &types.QueryDatedExchangeRateResponse{}, err
-	}
-	return &types.QueryDatedExchangeRateResponse{
-		Price:            price,
-		BlockTimestampMs: blockTime,
-		BlockHeight:      blockHeight,
-	}, nil
-}
-
 // ExchangeRates queries exchange rates of all pairs
 func (q querier) ExchangeRates(c context.Context, _ *types.QueryExchangeRatesRequest) (*types.QueryExchangeRatesResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
diff --git a/x/oracle/keeper/querier_test.go b/x/oracle/keeper/grpc_query_test.go
similarity index 82%
rename from x/oracle/keeper/querier_test.go
rename to x/oracle/keeper/grpc_query_test.go
index 45e39ccdc..c6ff2f4ad 100644
--- a/x/oracle/keeper/querier_test.go
+++ b/x/oracle/keeper/grpc_query_test.go
@@ -10,6 +10,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/stretchr/testify/require"
 
+	"github.com/NibiruChain/nibiru/v2/x/common/set"
 	testutilevents "github.com/NibiruChain/nibiru/v2/x/common/testutil"
 
 	"github.com/NibiruChain/nibiru/v2/x/common/asset"
@@ -37,7 +38,15 @@ func TestQueryExchangeRate(t *testing.T) {
 	querier := NewQuerier(input.OracleKeeper)
 
 	rate := math.LegacyNewDec(1700)
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.ETH, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
+	input.OracleKeeper.ExchangeRates.Insert(
+		input.Ctx,
+		asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+		types.ExchangeRateAtBlock{
+			ExchangeRate:     rate,
+			CreatedBlock:     uint64(input.Ctx.BlockHeight()),
+			BlockTimestampMs: input.Ctx.BlockTime().UnixMilli(),
+		},
+	)
 
 	// empty request
 	_, err := querier.ExchangeRate(ctx, nil)
@@ -77,8 +86,24 @@ func TestQueryExchangeRates(t *testing.T) {
 	querier := NewQuerier(input.OracleKeeper)
 
 	rate := math.LegacyNewDec(1700)
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.ETH, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
+	input.OracleKeeper.ExchangeRates.Insert(
+		input.Ctx,
+		asset.Registry.Pair(denoms.BTC, denoms.NUSD),
+		types.ExchangeRateAtBlock{
+			ExchangeRate:     rate,
+			CreatedBlock:     uint64(input.Ctx.BlockHeight()),
+			BlockTimestampMs: input.Ctx.BlockTime().UnixMilli(),
+		},
+	)
+	input.OracleKeeper.ExchangeRates.Insert(
+		input.Ctx,
+		asset.Registry.Pair(denoms.ETH, denoms.NUSD),
+		types.ExchangeRateAtBlock{
+			ExchangeRate:     rate,
+			CreatedBlock:     uint64(input.Ctx.BlockHeight()),
+			BlockTimestampMs: input.Ctx.BlockTime().UnixMilli(),
+		},
+	)
 
 	res, err := querier.ExchangeRates(ctx, &types.QueryExchangeRatesRequest{})
 	require.NoError(t, err)
@@ -122,9 +147,12 @@ func TestQueryDatedExchangeRate(t *testing.T) {
 	input := CreateTestFixture(t)
 	querier := NewQuerier(input.OracleKeeper)
 
-	// Set initial block time and height
 	initialTime := input.Ctx.BlockTime()
 	initialHeight := input.Ctx.BlockHeight()
+	t.Logf("Set initial block time and height\ninitialTimeSeconds: %d, intialHeight: %d",
+		initialTime.Unix(),
+		initialHeight,
+	)
 
 	// Pair 1: BTC/NUSD
 	pairBTC := asset.Registry.Pair(denoms.BTC, denoms.NUSD)
@@ -148,11 +176,17 @@ func TestQueryDatedExchangeRate(t *testing.T) {
 		},
 	)
 
-	// Advance time and block height
-	input.Ctx = input.Ctx.WithBlockTime(initialTime.Add(1 * time.Second)).
-		WithBlockHeight(initialHeight + 1)
+	blockTime := initialTime.Add(1 * time.Second)
+	blockHeight := initialHeight + 1
+	t.Logf("Advance time and block height\nblockTimeSeconds: %d, blockHeight: %d",
+		blockTime.Unix(),
+		blockHeight,
+	)
+	input.Ctx = input.Ctx.
+		WithBlockTime(blockTime).
+		WithBlockHeight(blockHeight)
 
-	// --- Set first price for ETH/NUSD ---
+	t.Log("Set first price for ETH")
 	input.OracleKeeper.SetPrice(input.Ctx, pairETH, rateETH1)
 	testutilevents.RequireContainsTypedEvent(
 		t,
@@ -164,11 +198,17 @@ func TestQueryDatedExchangeRate(t *testing.T) {
 		},
 	)
 
-	// Advance time and block height
-	input.Ctx = input.Ctx.WithBlockTime(initialTime.Add(2 * time.Second)).
-		WithBlockHeight(initialHeight + 2)
+	blockTime = initialTime.Add(2 * time.Second)
+	blockHeight = initialHeight + 2
+	t.Logf("Advance time and block height\nblockTimeSeconds: %d, blockHeight: %d",
+		blockTime.Unix(),
+		blockHeight,
+	)
+	input.Ctx = input.Ctx.
+		WithBlockTime(blockTime).
+		WithBlockHeight(blockHeight)
 
-	// --- Set second price for BTC/NUSD ---
+	t.Log("Set second price for BTC")
 	input.OracleKeeper.SetPrice(input.Ctx, pairBTC, rateBTC2)
 	testutilevents.RequireContainsTypedEvent(
 		t,
@@ -180,11 +220,12 @@ func TestQueryDatedExchangeRate(t *testing.T) {
 		},
 	)
 
-	// Advance time and block height
-	input.Ctx = input.Ctx.WithBlockTime(initialTime.Add(3 * time.Second)).
+	t.Log("Advance time and block height")
+	input.Ctx = input.Ctx.
+		WithBlockTime(initialTime.Add(3 * time.Second)).
 		WithBlockHeight(initialHeight + 3)
 
-	// --- Set second price for ETH/NUSD ---
+	t.Log("Set second price for ETH")
 	input.OracleKeeper.SetPrice(input.Ctx, pairETH, rateETH2)
 	testutilevents.RequireContainsTypedEvent(
 		t,
@@ -199,28 +240,33 @@ func TestQueryDatedExchangeRate(t *testing.T) {
 	// Wrap context for querying
 	ctx := sdk.WrapSDKContext(input.Ctx)
 
-	// --- Query latest snapshot for BTC/NUSD ---
-	resBTC, err := querier.DatedExchangeRate(
+	t.Log("Query latest snapshot for BTC")
+	resBTC, err := querier.ExchangeRate(
 		ctx,
 		&types.QueryExchangeRateRequest{Pair: pairBTC},
 	)
 	require.NoError(t, err)
-	require.Equal(t, rateBTC2, resBTC.Price)
-	require.Equal(t, input.Ctx.BlockTime().UnixMilli(), resBTC.BlockTimestampMs)
+	res := resBTC
+	require.Equal(t, rateBTC2.String(), resBTC.ExchangeRate.String())
+	require.Equal(t, initialTime.Add(2*time.Second).UnixMilli(), res.BlockTimestampMs)
+	require.Equal(t, uint64(initialHeight+2), res.BlockHeight)
 
-	// --- Query latest snapshot for ETH/NUSD ---
-	resETH, err := querier.DatedExchangeRate(
+	t.Log("Query latest snapshot for ETH")
+	resETH, err := querier.ExchangeRate(
 		ctx,
 		&types.QueryExchangeRateRequest{Pair: pairETH},
 	)
 	require.NoError(t, err)
-	require.Equal(t, rateETH2, resETH.Price)
-	require.Equal(t, input.Ctx.BlockTime().UnixMilli(), resETH.BlockTimestampMs)
-
-	// --- Query a pair with no snapshots (should return an error) ---
-	pairATOM := asset.Registry.Pair(denoms.ATOM, denoms.NUSD)
-	_, err = querier.DatedExchangeRate(ctx, &types.QueryExchangeRateRequest{Pair: pairATOM})
-	require.Error(t, err)
+	res = resETH
+	require.Equal(t, rateETH2, res.ExchangeRate)
+	require.Equal(t, initialTime.Add(3*time.Second).UnixMilli(), res.BlockTimestampMs)
+	require.Equal(t, uint64(initialHeight+3), res.BlockHeight)
+
+	t.Run("Query a pair with no snapshots (should return an error)", func(t *testing.T) {
+		pairATOM := asset.Registry.Pair(denoms.ATOM, denoms.NUSD)
+		_, err = querier.ExchangeRate(ctx, &types.QueryExchangeRateRequest{Pair: pairATOM})
+		require.Error(t, err)
+	})
 }
 
 func TestCalcTwap(t *testing.T) {
@@ -312,20 +358,26 @@ func TestQueryActives(t *testing.T) {
 	queryClient := NewQuerier(input.OracleKeeper)
 
 	rate := math.LegacyNewDec(1700)
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.BTC, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.NIBI, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
-	input.OracleKeeper.ExchangeRates.Insert(input.Ctx, asset.Registry.Pair(denoms.ETH, denoms.NUSD), types.DatedPrice{ExchangeRate: rate, CreatedBlock: uint64(input.Ctx.BlockHeight())})
+	targetPairs := set.New[asset.Pair]()
+	for _, bankDenom := range []string{denoms.BTC, denoms.ETH, denoms.NIBI} {
+		pair := asset.Registry.Pair(bankDenom, denoms.NUSD)
+		targetPairs.Add(pair)
+		input.OracleKeeper.ExchangeRates.Insert(
+			input.Ctx,
+			pair,
+			types.ExchangeRateAtBlock{
+				ExchangeRate:     rate,
+				CreatedBlock:     uint64(input.Ctx.BlockHeight()),
+				BlockTimestampMs: input.Ctx.BlockTime().UnixMilli(),
+			},
+		)
+	}
 
 	res, err := queryClient.Actives(ctx, &types.QueryActivesRequest{})
 	require.NoError(t, err)
-
-	targetPairs := []asset.Pair{
-		asset.Registry.Pair(denoms.BTC, denoms.NUSD),
-		asset.Registry.Pair(denoms.ETH, denoms.NUSD),
-		asset.Registry.Pair(denoms.NIBI, denoms.NUSD),
+	for _, pair := range res.Actives {
+		require.True(t, targetPairs.Has(pair))
 	}
-
-	require.Equal(t, targetPairs, res.Actives)
 }
 
 func TestQueryFeederDelegation(t *testing.T) {
diff --git a/x/oracle/keeper/keeper.go b/x/oracle/keeper/keeper.go
index bbbf31ce9..e7beb8026 100644
--- a/x/oracle/keeper/keeper.go
+++ b/x/oracle/keeper/keeper.go
@@ -35,7 +35,7 @@ type Keeper struct {
 
 	// Module parameters
 	Params            collections.Item[types.Params]
-	ExchangeRates     collections.Map[asset.Pair, types.DatedPrice]
+	ExchangeRates     collections.Map[asset.Pair, types.ExchangeRateAtBlock]
 	FeederDelegations collections.Map[sdk.ValAddress, sdk.AccAddress]
 	MissCounters      collections.Map[sdk.ValAddress, uint64]
 	Prevotes          collections.Map[sdk.ValAddress, types.AggregateExchangeRatePrevote]
@@ -80,7 +80,7 @@ func NewKeeper(
 		sudoKeeper:        sudoKeeper,
 		distrModuleName:   distrName,
 		Params:            collections.NewItem(storeKey, 11, collections.ProtoValueEncoder[types.Params](cdc)),
-		ExchangeRates:     collections.NewMap(storeKey, 1, asset.PairKeyEncoder, collections.ProtoValueEncoder[types.DatedPrice](cdc)),
+		ExchangeRates:     collections.NewMap(storeKey, 1, asset.PairKeyEncoder, collections.ProtoValueEncoder[types.ExchangeRateAtBlock](cdc)),
 		PriceSnapshots:    collections.NewMap(storeKey, 10, collections.PairKeyEncoder(asset.PairKeyEncoder, collections.TimeKeyEncoder), collections.ProtoValueEncoder[types.PriceSnapshot](cdc)),
 		FeederDelegations: collections.NewMap(storeKey, 2, collections.ValAddressKeyEncoder, collections.AccAddressValueEncoder),
 		MissCounters:      collections.NewMap(storeKey, 3, collections.ValAddressKeyEncoder, collections.Uint64ValueEncoder),
@@ -168,7 +168,8 @@ func (k Keeper) GetExchangeRateTwap(ctx sdk.Context, pair asset.Pair) (price sdk
 	for i, s := range snapshots {
 		var nextTimestampMs int64
 		if i == len(snapshots)-1 {
-			// if we're at the last snapshot, then consider that price as ongoing until the current blocktime
+			// if we're at the last snapshot, then consider that price as ongoing
+			// until the current blocktime
 			nextTimestampMs = ctx.BlockTime().UnixMilli()
 		} else {
 			nextTimestampMs = snapshots[i+1].TimestampMs
@@ -181,37 +182,26 @@ func (k Keeper) GetExchangeRateTwap(ctx sdk.Context, pair asset.Pair) (price sdk
 	return cumulativePrice.QuoInt64(ctx.BlockTime().UnixMilli() - firstTimestampMs), nil
 }
 
-func (k Keeper) GetExchangeRate(ctx sdk.Context, pair asset.Pair) (price sdk.Dec, err error) {
-	exchangeRate, err := k.ExchangeRates.Get(ctx, pair)
-	price = exchangeRate.ExchangeRate
-	return
-}
-
-func (k Keeper) GetDatedExchangeRate(ctx sdk.Context, pair asset.Pair) (price sdk.Dec, blockTimeMs int64, BlockHeight uint64, err error) {
-	exchangeRate, err := k.ExchangeRates.Get(ctx, pair)
-	if err != nil {
-		return
-	}
-	time := ctx.WithBlockHeight(int64(exchangeRate.CreatedBlock)).BlockTime()
-
-	return exchangeRate.ExchangeRate, time.UnixMilli(), exchangeRate.CreatedBlock, nil
-}
-
 // SetPrice sets the price for a pair as well as the price snapshot.
 func (k Keeper) SetPrice(ctx sdk.Context, pair asset.Pair, price sdk.Dec) {
-	k.ExchangeRates.Insert(ctx, pair, types.DatedPrice{ExchangeRate: price, CreatedBlock: uint64(ctx.BlockHeight())})
+	blockTimestampMs := ctx.BlockTime().UnixMilli()
+	k.ExchangeRates.Insert(ctx, pair,
+		types.ExchangeRateAtBlock{
+			ExchangeRate:     price,
+			CreatedBlock:     uint64(ctx.BlockHeight()),
+			BlockTimestampMs: blockTimestampMs,
+		})
 
 	key := collections.Join(pair, ctx.BlockTime())
-	timestampMs := ctx.BlockTime().UnixMilli()
 	k.PriceSnapshots.Insert(ctx, key, types.PriceSnapshot{
 		Pair:        pair,
 		Price:       price,
-		TimestampMs: timestampMs,
+		TimestampMs: blockTimestampMs,
 	})
 	if err := ctx.EventManager().EmitTypedEvent(&types.EventPriceUpdate{
 		Pair:        pair.String(),
 		Price:       price,
-		TimestampMs: timestampMs,
+		TimestampMs: blockTimestampMs,
 	}); err != nil {
 		ctx.Logger().Error("failed to emit OraclePriceUpdate", "pair", pair, "error", err)
 	}
diff --git a/x/oracle/keeper/test_utils.go b/x/oracle/keeper/test_utils.go
index 692b52623..5b42f40f7 100644
--- a/x/oracle/keeper/test_utils.go
+++ b/x/oracle/keeper/test_utils.go
@@ -5,7 +5,7 @@ import (
 	"testing"
 	"time"
 
-	"cosmossdk.io/math"
+	sdkmath "cosmossdk.io/math"
 	"github.com/NibiruChain/nibiru/v2/x/common/denoms"
 	"github.com/NibiruChain/nibiru/v2/x/oracle/types"
 	"github.com/NibiruChain/nibiru/v2/x/sudo"
@@ -222,9 +222,7 @@ func CreateTestFixture(t *testing.T) TestFixture {
 
 	distrKeeper.SetFeePool(ctx, distrtypes.InitialFeePool())
 	distrParams := distrtypes.DefaultParams()
-	distrParams.CommunityTax = math.LegacyNewDecWithPrec(2, 2)
-	distrParams.BaseProposerReward = math.LegacyNewDecWithPrec(1, 2)
-	distrParams.BonusProposerReward = math.LegacyNewDecWithPrec(4, 2)
+	distrParams.CommunityTax = sdkmath.LegacyNewDecWithPrec(2, 2)
 	distrKeeper.SetParams(ctx, distrParams)
 	stakingKeeper.SetHooks(stakingtypes.NewMultiStakingHooks(distrKeeper.Hooks()))
 
@@ -283,12 +281,12 @@ func CreateTestFixture(t *testing.T) TestFixture {
 
 // NewTestMsgCreateValidator test msg creator
 func NewTestMsgCreateValidator(
-	address sdk.ValAddress, pubKey cryptotypes.PubKey, amt sdk.Int,
+	address sdk.ValAddress, pubKey cryptotypes.PubKey, amt sdkmath.Int,
 ) *stakingtypes.MsgCreateValidator {
-	commission := stakingtypes.NewCommissionRates(math.LegacyZeroDec(), math.LegacyZeroDec(), math.LegacyZeroDec())
+	commission := stakingtypes.NewCommissionRates(sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec(), sdkmath.LegacyZeroDec())
 	msg, _ := stakingtypes.NewMsgCreateValidator(
 		address, pubKey, sdk.NewCoin(denoms.NIBI, amt),
-		stakingtypes.Description{}, commission, math.OneInt(),
+		stakingtypes.Description{}, commission, sdkmath.OneInt(),
 	)
 
 	return msg
@@ -312,7 +310,7 @@ func AllocateRewards(t *testing.T, input TestFixture, rewards sdk.Coins, votePer
 
 var (
 	testStakingAmt   = sdk.TokensFromConsensusPower(10, sdk.DefaultPowerReduction)
-	testExchangeRate = math.LegacyNewDec(1700)
+	testExchangeRate = sdkmath.LegacyNewDec(1700)
 )
 
 func Setup(t *testing.T) (TestFixture, types.MsgServer) {
diff --git a/x/oracle/types/oracle.pb.go b/x/oracle/types/oracle.pb.go
index 3ada32d99..2585900fd 100644
--- a/x/oracle/types/oracle.pb.go
+++ b/x/oracle/types/oracle.pb.go
@@ -260,23 +260,27 @@ func (m *ExchangeRateTuple) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_ExchangeRateTuple proto.InternalMessageInfo
 
-type DatedPrice struct {
+type ExchangeRateAtBlock struct {
 	ExchangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=exchange_rate,json=exchangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"exchange_rate" yaml:"exchange_rate"`
 	CreatedBlock uint64                                 `protobuf:"varint,2,opt,name=created_block,json=createdBlock,proto3" json:"created_block,omitempty" yaml:"created_block"`
+	// Block timestamp for the block where the oracle came to consensus for this
+	// price. This timestamp is a conventional Unix millisecond time, i.e. the
+	// number of milliseconds elapsed since January 1, 1970 UTC.
+	BlockTimestampMs int64 `protobuf:"varint,3,opt,name=block_timestamp_ms,json=blockTimestampMs,proto3" json:"block_timestamp_ms,omitempty" yaml:"block_timestamp_ms"`
 }
 
-func (m *DatedPrice) Reset()         { *m = DatedPrice{} }
-func (m *DatedPrice) String() string { return proto.CompactTextString(m) }
-func (*DatedPrice) ProtoMessage()    {}
-func (*DatedPrice) Descriptor() ([]byte, []int) {
+func (m *ExchangeRateAtBlock) Reset()         { *m = ExchangeRateAtBlock{} }
+func (m *ExchangeRateAtBlock) String() string { return proto.CompactTextString(m) }
+func (*ExchangeRateAtBlock) ProtoMessage()    {}
+func (*ExchangeRateAtBlock) Descriptor() ([]byte, []int) {
 	return fileDescriptor_43d45df86ea09ed4, []int{4}
 }
-func (m *DatedPrice) XXX_Unmarshal(b []byte) error {
+func (m *ExchangeRateAtBlock) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *DatedPrice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ExchangeRateAtBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_DatedPrice.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ExchangeRateAtBlock.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -286,25 +290,32 @@ func (m *DatedPrice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 		return b[:n], nil
 	}
 }
-func (m *DatedPrice) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_DatedPrice.Merge(m, src)
+func (m *ExchangeRateAtBlock) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ExchangeRateAtBlock.Merge(m, src)
 }
-func (m *DatedPrice) XXX_Size() int {
+func (m *ExchangeRateAtBlock) XXX_Size() int {
 	return m.Size()
 }
-func (m *DatedPrice) XXX_DiscardUnknown() {
-	xxx_messageInfo_DatedPrice.DiscardUnknown(m)
+func (m *ExchangeRateAtBlock) XXX_DiscardUnknown() {
+	xxx_messageInfo_ExchangeRateAtBlock.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_DatedPrice proto.InternalMessageInfo
+var xxx_messageInfo_ExchangeRateAtBlock proto.InternalMessageInfo
 
-func (m *DatedPrice) GetCreatedBlock() uint64 {
+func (m *ExchangeRateAtBlock) GetCreatedBlock() uint64 {
 	if m != nil {
 		return m.CreatedBlock
 	}
 	return 0
 }
 
+func (m *ExchangeRateAtBlock) GetBlockTimestampMs() int64 {
+	if m != nil {
+		return m.BlockTimestampMs
+	}
+	return 0
+}
+
 // Rewards defines a credit object towards validators
 // which provide prices faithfully for different pairs.
 type Rewards struct {
@@ -376,75 +387,77 @@ func init() {
 	proto.RegisterType((*AggregateExchangeRatePrevote)(nil), "nibiru.oracle.v1.AggregateExchangeRatePrevote")
 	proto.RegisterType((*AggregateExchangeRateVote)(nil), "nibiru.oracle.v1.AggregateExchangeRateVote")
 	proto.RegisterType((*ExchangeRateTuple)(nil), "nibiru.oracle.v1.ExchangeRateTuple")
-	proto.RegisterType((*DatedPrice)(nil), "nibiru.oracle.v1.DatedPrice")
+	proto.RegisterType((*ExchangeRateAtBlock)(nil), "nibiru.oracle.v1.ExchangeRateAtBlock")
 	proto.RegisterType((*Rewards)(nil), "nibiru.oracle.v1.Rewards")
 }
 
 func init() { proto.RegisterFile("nibiru/oracle/v1/oracle.proto", fileDescriptor_43d45df86ea09ed4) }
 
 var fileDescriptor_43d45df86ea09ed4 = []byte{
-	// 977 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xcf, 0x6f, 0x1b, 0x45,
-	0x14, 0xf6, 0x26, 0x4e, 0x1a, 0x8f, 0x93, 0x92, 0x4c, 0x53, 0xd8, 0x84, 0xe2, 0x0d, 0x53, 0xa9,
-	0xca, 0x01, 0x76, 0x95, 0x50, 0x84, 0x88, 0xc4, 0x81, 0x6d, 0x08, 0x8a, 0x08, 0xc8, 0x1a, 0x55,
-	0x20, 0x71, 0x59, 0xcd, 0xee, 0x4e, 0xec, 0x21, 0xbb, 0x3b, 0xd6, 0xcc, 0xda, 0x4e, 0x24, 0xc4,
-	0x99, 0x63, 0x4f, 0x88, 0x63, 0xce, 0xdc, 0xb8, 0xf1, 0x27, 0xf4, 0x84, 0x7a, 0x44, 0x3d, 0x6c,
-	0xab, 0xe4, 0x52, 0xc1, 0xcd, 0x7f, 0x01, 0x9a, 0xd9, 0x71, 0xbc, 0xc1, 0x3e, 0x34, 0x20, 0x4e,
-	0xde, 0xf7, 0xbe, 0x99, 0xef, 0x7d, 0xef, 0xc7, 0xcc, 0x18, 0xbc, 0x93, 0xb1, 0x90, 0x89, 0xbe,
-	0xc7, 0x05, 0x89, 0x12, 0xea, 0x0d, 0x76, 0xcc, 0x97, 0xdb, 0x13, 0x3c, 0xe7, 0x70, 0xb5, 0x84,
-	0x5d, 0xe3, 0x1c, 0xec, 0x6c, 0xae, 0x77, 0x78, 0x87, 0x6b, 0xd0, 0x53, 0x5f, 0xe5, 0xba, 0xcd,
-	0x56, 0x87, 0xf3, 0x4e, 0x42, 0x3d, 0x6d, 0x85, 0xfd, 0x63, 0x2f, 0xee, 0x0b, 0x92, 0x33, 0x9e,
-	0x8d, 0xf1, 0x88, 0xcb, 0x94, 0x4b, 0x2f, 0x24, 0x52, 0x05, 0x09, 0x69, 0x4e, 0x76, 0xbc, 0x88,
-	0x33, 0x83, 0xa3, 0xdf, 0x97, 0xc0, 0x62, 0x9b, 0x08, 0x92, 0x4a, 0xf8, 0x11, 0x68, 0x0e, 0x78,
-	0x4e, 0x83, 0x1e, 0x15, 0x8c, 0xc7, 0xb6, 0xb5, 0x65, 0x6d, 0xd7, 0xfd, 0x37, 0x47, 0x85, 0x03,
-	0xcf, 0x48, 0x9a, 0xec, 0xa1, 0x0a, 0x88, 0x30, 0x50, 0x56, 0x5b, 0x1b, 0x30, 0x03, 0xb7, 0x35,
-	0x96, 0x77, 0x05, 0x95, 0x5d, 0x9e, 0xc4, 0xf6, 0xdc, 0x96, 0xb5, 0xdd, 0xf0, 0x3f, 0x7f, 0x5a,
-	0x38, 0xb5, 0xe7, 0x85, 0xf3, 0xa0, 0xc3, 0xf2, 0x6e, 0x3f, 0x74, 0x23, 0x9e, 0x7a, 0x46, 0x4e,
-	0xf9, 0xf3, 0xbe, 0x8c, 0x4f, 0xbc, 0xfc, 0xac, 0x47, 0xa5, 0xbb, 0x4f, 0xa3, 0x51, 0xe1, 0xdc,
-	0xad, 0x44, 0xba, 0x62, 0x43, 0x78, 0x45, 0x39, 0x1e, 0x8f, 0x6d, 0x48, 0x41, 0x53, 0xd0, 0x21,
-	0x11, 0x71, 0x10, 0x92, 0x2c, 0xb6, 0xe7, 0x75, 0xb0, 0xfd, 0x1b, 0x07, 0x33, 0x69, 0x55, 0xa8,
-	0x10, 0x06, 0xa5, 0xe5, 0x93, 0x2c, 0x86, 0xdf, 0x81, 0xc6, 0xb0, 0xcb, 0x72, 0x9a, 0x30, 0x99,
-	0xdb, 0xf5, 0xad, 0xf9, 0xed, 0x86, 0x7f, 0xf4, 0xbc, 0x70, 0x1e, 0x56, 0x02, 0x7c, 0xa5, 0x9b,
-	0xf4, 0xa8, 0x4b, 0x58, 0xe6, 0x99, 0x7e, 0x0e, 0x76, 0xbd, 0x53, 0x2f, 0xe2, 0x69, 0xca, 0x33,
-	0x8f, 0x48, 0x49, 0x73, 0xb7, 0x4d, 0x98, 0x18, 0x15, 0xce, 0x6a, 0x19, 0xee, 0x8a, 0x12, 0xe1,
-	0x09, 0xbd, 0x2a, 0xa1, 0x4c, 0x88, 0xec, 0x06, 0xc7, 0x82, 0x44, 0xaa, 0x7d, 0xf6, 0xc2, 0x7f,
-	0x2b, 0xe1, 0x75, 0x36, 0x84, 0x57, 0xb4, 0xe3, 0xc0, 0xd8, 0x70, 0x0f, 0x2c, 0x97, 0x2b, 0x86,
-	0x2c, 0x8b, 0xf9, 0xd0, 0x5e, 0xd4, 0xcd, 0x7e, 0x6b, 0x54, 0x38, 0x77, 0xaa, 0xfb, 0x4b, 0x14,
-	0xe1, 0xa6, 0x36, 0xbf, 0xd1, 0x16, 0xfc, 0x01, 0xac, 0xa7, 0x2c, 0x0b, 0x06, 0x24, 0x61, 0xb1,
-	0x9a, 0x87, 0x31, 0xc7, 0x2d, 0xad, 0xf8, 0xcb, 0x1b, 0x2b, 0x7e, 0xbb, 0x8c, 0x38, 0x8b, 0x13,
-	0xe1, 0xb5, 0x94, 0x65, 0x5f, 0x2b, 0x6f, 0x9b, 0x0a, 0x13, 0xff, 0x27, 0x0b, 0xac, 0xe7, 0x43,
-	0xd2, 0x0b, 0x12, 0xce, 0x4f, 0x42, 0x12, 0x9d, 0x8c, 0x05, 0x2c, 0x6d, 0x59, 0xdb, 0xcd, 0xdd,
-	0x0d, 0xb7, 0x3c, 0x12, 0xee, 0xf8, 0x48, 0xb8, 0xfb, 0xe6, 0x48, 0xf8, 0x87, 0x4a, 0xdb, 0x9f,
-	0x85, 0xd3, 0x9a, 0xb5, 0xfd, 0x3d, 0x9e, 0xb2, 0x9c, 0xa6, 0xbd, 0xfc, 0x6c, 0xa2, 0x69, 0xd6,
-	0x3a, 0xf4, 0xf3, 0x0b, 0xc7, 0xc2, 0x50, 0x41, 0x47, 0x06, 0x31, 0xc2, 0x1e, 0x02, 0xa0, 0x93,
-	0xe0, 0x39, 0x15, 0xd2, 0x6e, 0xe8, 0x92, 0xde, 0x1d, 0x15, 0xce, 0x5a, 0x25, 0x41, 0x8d, 0x21,
-	0xdc, 0x50, 0x69, 0xe9, 0x6f, 0xf8, 0x3d, 0xb8, 0xa3, 0xd3, 0x26, 0x39, 0x17, 0xc1, 0x31, 0xa5,
-	0x81, 0x16, 0x6b, 0x03, 0x5d, 0xcd, 0xa3, 0x1b, 0x57, 0x73, 0xd3, 0x1c, 0xa1, 0x69, 0x4a, 0x84,
-	0xd7, 0xae, 0xbc, 0x07, 0x94, 0x62, 0xe5, 0x83, 0x87, 0x60, 0x8d, 0x9e, 0xf6, 0x58, 0x59, 0xa0,
-	0x20, 0x4c, 0x78, 0x74, 0x22, 0xed, 0xa6, 0x96, 0x7e, 0x6f, 0x54, 0x38, 0x76, 0xc9, 0x36, 0xb5,
-	0x04, 0xe1, 0xd5, 0x89, 0xcf, 0xd7, 0xae, 0xbd, 0xfa, 0xab, 0x73, 0xc7, 0x42, 0xbf, 0x5a, 0xe0,
-	0xde, 0xa7, 0x9d, 0x8e, 0xa0, 0x1d, 0x92, 0xd3, 0xcf, 0x4e, 0xa3, 0x2e, 0xc9, 0x3a, 0x2a, 0x16,
-	0x6d, 0x0b, 0xaa, 0xb2, 0x87, 0xf7, 0x41, 0xbd, 0x4b, 0x64, 0x57, 0xdf, 0x2f, 0x0d, 0xff, 0x8d,
-	0x51, 0xe1, 0x34, 0xcb, 0x20, 0xca, 0x8b, 0xb0, 0x06, 0xe1, 0x03, 0xb0, 0xa0, 0x4b, 0x65, 0x6e,
-	0x92, 0xd5, 0x51, 0xe1, 0x2c, 0x4f, 0xee, 0x06, 0x81, 0x70, 0x09, 0xeb, 0x39, 0xee, 0x87, 0x29,
-	0xcb, 0x4b, 0x5d, 0xfa, 0x2e, 0xb8, 0x3e, 0xc7, 0x15, 0x54, 0xcd, 0xb1, 0x36, 0xb5, 0xe0, 0xbd,
-	0xa5, 0x1f, 0xcf, 0x9d, 0xda, 0xab, 0x73, 0xa7, 0x86, 0x5e, 0x5a, 0x60, 0x63, 0xa6, 0x66, 0xd5,
-	0x22, 0xf8, 0xc4, 0x02, 0xeb, 0xd4, 0x38, 0x55, 0x25, 0x69, 0x90, 0xf7, 0x7b, 0x09, 0x95, 0xb6,
-	0xb5, 0x35, 0xbf, 0xdd, 0xdc, 0xbd, 0xef, 0xfe, 0xf3, 0xaa, 0x76, 0xab, 0x14, 0x8f, 0xd5, 0x5a,
-	0xff, 0x63, 0xd5, 0xc7, 0xc9, 0x5c, 0xcd, 0xa2, 0x43, 0xbf, 0xbc, 0x70, 0xe0, 0xd4, 0x4e, 0x89,
-	0x21, 0x9d, 0xf2, 0xbd, 0x6e, 0x79, 0x2a, 0x29, 0xfe, 0x65, 0x81, 0xb5, 0x29, 0x72, 0x18, 0x80,
-	0x7a, 0x8f, 0x30, 0x61, 0x7a, 0xf1, 0x85, 0x19, 0xb6, 0x7f, 0x7b, 0xc3, 0x99, 0x3e, 0x2a, 0x46,
-	0x84, 0x35, 0x31, 0x3c, 0x01, 0x2b, 0xd7, 0x72, 0x35, 0x82, 0x0f, 0x6e, 0x3c, 0xd6, 0xeb, 0x33,
-	0x0a, 0x87, 0xf0, 0x72, 0xb5, 0x36, 0x95, 0x6c, 0x7f, 0xb3, 0x00, 0xd8, 0x27, 0x39, 0x8d, 0xdb,
-	0x82, 0x45, 0x74, 0x5a, 0x85, 0xf5, 0xff, 0xa9, 0x80, 0x9f, 0x80, 0x95, 0x48, 0x50, 0x15, 0xdc,
-	0xcc, 0xe4, 0x9c, 0x9e, 0x49, 0x7b, 0xb2, 0xfd, 0x1a, 0x8c, 0xf0, 0xb2, 0xb1, 0xf5, 0x54, 0x22,
-	0x09, 0x6e, 0x61, 0xfd, 0x06, 0x49, 0x78, 0x1b, 0xcc, 0x31, 0xf3, 0x0e, 0xe3, 0x39, 0x16, 0xc3,
-	0x77, 0xc1, 0x72, 0xe5, 0x0d, 0x96, 0x25, 0x31, 0x6e, 0x4e, 0x5e, 0x62, 0x09, 0x3f, 0x04, 0x0b,
-	0xea, 0x71, 0x97, 0xf6, 0xbc, 0x9e, 0xcd, 0x0d, 0xb7, 0x4c, 0xc4, 0x55, 0xcf, 0xbf, 0x6b, 0x9e,
-	0x7f, 0xf7, 0x11, 0x67, 0x99, 0x5f, 0x57, 0xc9, 0xe3, 0x72, 0xb5, 0x7f, 0xf8, 0xf4, 0xa2, 0x65,
-	0x3d, 0xbb, 0x68, 0x59, 0x2f, 0x2f, 0x5a, 0xd6, 0x93, 0xcb, 0x56, 0xed, 0xd9, 0x65, 0xab, 0xf6,
-	0xc7, 0x65, 0xab, 0xf6, 0xad, 0xf7, 0x1a, 0xb3, 0x60, 0xfe, 0xc2, 0xe8, 0x42, 0x85, 0x8b, 0xfa,
-	0xda, 0xfd, 0xe0, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0x89, 0xe7, 0x1a, 0xe9, 0xe0, 0x08, 0x00,
+	// 1009 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
+	0x14, 0xf7, 0x26, 0x4e, 0x1a, 0x8f, 0x93, 0x92, 0x4c, 0x52, 0xd8, 0x84, 0xd6, 0x1b, 0xa6, 0x52,
+	0x95, 0x03, 0xec, 0x2a, 0xa1, 0x08, 0x11, 0x89, 0x43, 0xb7, 0x21, 0x28, 0x6a, 0x8a, 0xa2, 0x51,
+	0x04, 0x12, 0x97, 0xd5, 0x78, 0x77, 0x62, 0x0f, 0xf1, 0xee, 0x58, 0x3b, 0xe3, 0x38, 0x91, 0x10,
+	0x67, 0x4e, 0xa8, 0x27, 0xc4, 0x31, 0x67, 0x6e, 0x7c, 0x8b, 0x9e, 0x50, 0x8f, 0xa8, 0x87, 0x6d,
+	0x95, 0x5c, 0x2a, 0xb8, 0xf9, 0x13, 0xa0, 0xf9, 0xe3, 0x78, 0x83, 0x7d, 0x68, 0x40, 0x9c, 0x76,
+	0xdf, 0x7b, 0x33, 0xbf, 0xf7, 0x7b, 0x7f, 0xe6, 0xcd, 0x80, 0x7b, 0x19, 0x6b, 0xb2, 0xbc, 0x17,
+	0xf0, 0x9c, 0xc4, 0x1d, 0x1a, 0x9c, 0x6c, 0xda, 0x3f, 0xbf, 0x9b, 0x73, 0xc9, 0xe1, 0xa2, 0x31,
+	0xfb, 0x56, 0x79, 0xb2, 0xb9, 0xb6, 0xd2, 0xe2, 0x2d, 0xae, 0x8d, 0x81, 0xfa, 0x33, 0xeb, 0xd6,
+	0x1a, 0x2d, 0xce, 0x5b, 0x1d, 0x1a, 0x68, 0xa9, 0xd9, 0x3b, 0x0a, 0x92, 0x5e, 0x4e, 0x24, 0xe3,
+	0xd9, 0xd0, 0x1e, 0x73, 0x91, 0x72, 0x11, 0x34, 0x89, 0x50, 0x4e, 0x9a, 0x54, 0x92, 0xcd, 0x20,
+	0xe6, 0xcc, 0xda, 0xd1, 0xef, 0x73, 0x60, 0xf6, 0x80, 0xe4, 0x24, 0x15, 0xf0, 0x53, 0x50, 0x3f,
+	0xe1, 0x92, 0x46, 0x5d, 0x9a, 0x33, 0x9e, 0xb8, 0xce, 0xba, 0xb3, 0x51, 0x0d, 0xdf, 0x1d, 0x14,
+	0x1e, 0x3c, 0x23, 0x69, 0x67, 0x1b, 0x95, 0x8c, 0x08, 0x03, 0x25, 0x1d, 0x68, 0x01, 0x66, 0xe0,
+	0xb6, 0xb6, 0xc9, 0x76, 0x4e, 0x45, 0x9b, 0x77, 0x12, 0x77, 0x6a, 0xdd, 0xd9, 0xa8, 0x85, 0x5f,
+	0x3e, 0x2f, 0xbc, 0xca, 0xcb, 0xc2, 0x7b, 0xd0, 0x62, 0xb2, 0xdd, 0x6b, 0xfa, 0x31, 0x4f, 0x03,
+	0x4b, 0xc7, 0x7c, 0x3e, 0x12, 0xc9, 0x71, 0x20, 0xcf, 0xba, 0x54, 0xf8, 0x3b, 0x34, 0x1e, 0x14,
+	0xde, 0x9d, 0x92, 0xa7, 0x2b, 0x34, 0x84, 0x17, 0x94, 0xe2, 0x70, 0x28, 0x43, 0x0a, 0xea, 0x39,
+	0xed, 0x93, 0x3c, 0x89, 0x9a, 0x24, 0x4b, 0xdc, 0x69, 0xed, 0x6c, 0xe7, 0xc6, 0xce, 0x6c, 0x58,
+	0x25, 0x28, 0x84, 0x81, 0x91, 0x42, 0x92, 0x25, 0xf0, 0x3b, 0x50, 0xeb, 0xb7, 0x99, 0xa4, 0x1d,
+	0x26, 0xa4, 0x5b, 0x5d, 0x9f, 0xde, 0xa8, 0x85, 0xfb, 0x2f, 0x0b, 0xef, 0x61, 0xc9, 0xc1, 0x57,
+	0xba, 0x48, 0x8f, 0xdb, 0x84, 0x65, 0x81, 0xad, 0xe7, 0xc9, 0x56, 0x70, 0x1a, 0xc4, 0x3c, 0x4d,
+	0x79, 0x16, 0x10, 0x21, 0xa8, 0xf4, 0x0f, 0x08, 0xcb, 0x07, 0x85, 0xb7, 0x68, 0xdc, 0x5d, 0x41,
+	0x22, 0x3c, 0x82, 0x57, 0x29, 0x14, 0x1d, 0x22, 0xda, 0xd1, 0x51, 0x4e, 0x62, 0x55, 0x3e, 0x77,
+	0xe6, 0xbf, 0xa5, 0xf0, 0x3a, 0x1a, 0xc2, 0x0b, 0x5a, 0xb1, 0x6b, 0x65, 0xb8, 0x0d, 0xe6, 0xcd,
+	0x8a, 0x3e, 0xcb, 0x12, 0xde, 0x77, 0x67, 0x75, 0xb1, 0xdf, 0x1b, 0x14, 0xde, 0x72, 0x79, 0xbf,
+	0xb1, 0x22, 0x5c, 0xd7, 0xe2, 0x37, 0x5a, 0x82, 0x3f, 0x80, 0x95, 0x94, 0x65, 0xd1, 0x09, 0xe9,
+	0xb0, 0x44, 0xf5, 0xc3, 0x10, 0xe3, 0x96, 0x66, 0xfc, 0xf4, 0xc6, 0x8c, 0xdf, 0x37, 0x1e, 0x27,
+	0x61, 0x22, 0xbc, 0x94, 0xb2, 0xec, 0x6b, 0xa5, 0x3d, 0xa0, 0xb9, 0xf5, 0xff, 0xb3, 0x03, 0x56,
+	0x64, 0x9f, 0x74, 0xa3, 0x0e, 0xe7, 0xc7, 0x4d, 0x12, 0x1f, 0x0f, 0x09, 0xcc, 0xad, 0x3b, 0x1b,
+	0xf5, 0xad, 0x55, 0xdf, 0x1c, 0x09, 0x7f, 0x78, 0x24, 0xfc, 0x1d, 0x7b, 0x24, 0xc2, 0x3d, 0xc5,
+	0xed, 0xcf, 0xc2, 0x6b, 0x4c, 0xda, 0xfe, 0x21, 0x4f, 0x99, 0xa4, 0x69, 0x57, 0x9e, 0x8d, 0x38,
+	0x4d, 0x5a, 0x87, 0x7e, 0x79, 0xe5, 0x39, 0x18, 0x2a, 0xd3, 0xbe, 0xb5, 0x58, 0x62, 0x0f, 0x01,
+	0xd0, 0x41, 0x70, 0x49, 0x73, 0xe1, 0xd6, 0x74, 0x4a, 0xef, 0x0c, 0x0a, 0x6f, 0xa9, 0x14, 0xa0,
+	0xb6, 0x21, 0x5c, 0x53, 0x61, 0xe9, 0x7f, 0xf8, 0x3d, 0x58, 0xd6, 0x61, 0x13, 0xc9, 0xf3, 0xe8,
+	0x88, 0xd2, 0x48, 0x93, 0x75, 0x81, 0xce, 0xe6, 0xfe, 0x8d, 0xb3, 0xb9, 0x66, 0x8f, 0xd0, 0x38,
+	0x24, 0xc2, 0x4b, 0x57, 0xda, 0x5d, 0x4a, 0xb1, 0xd2, 0xc1, 0x3d, 0xb0, 0x44, 0x4f, 0xbb, 0xcc,
+	0x24, 0x28, 0x6a, 0x76, 0x78, 0x7c, 0x2c, 0xdc, 0xba, 0xa6, 0x7e, 0x77, 0x50, 0x78, 0xae, 0x41,
+	0x1b, 0x5b, 0x82, 0xf0, 0xe2, 0x48, 0x17, 0x6a, 0xd5, 0x76, 0xf5, 0xcd, 0xb9, 0xe7, 0xa0, 0xdf,
+	0x1c, 0x70, 0xf7, 0x51, 0xab, 0x95, 0xd3, 0x16, 0x91, 0xf4, 0x8b, 0xd3, 0xb8, 0x4d, 0xb2, 0x96,
+	0xf2, 0x45, 0x0f, 0x72, 0xaa, 0xa2, 0x87, 0xf7, 0x41, 0xb5, 0x4d, 0x44, 0x5b, 0xcf, 0x97, 0x5a,
+	0xf8, 0xce, 0xa0, 0xf0, 0xea, 0xc6, 0x89, 0xd2, 0x22, 0xac, 0x8d, 0xf0, 0x01, 0x98, 0xd1, 0xa9,
+	0xb2, 0x93, 0x64, 0x71, 0x50, 0x78, 0xf3, 0xa3, 0xd9, 0x90, 0x23, 0x6c, 0xcc, 0xba, 0x8f, 0x7b,
+	0xcd, 0x94, 0x49, 0xc3, 0x4b, 0xcf, 0x82, 0xeb, 0x7d, 0x5c, 0xb2, 0xaa, 0x3e, 0xd6, 0xa2, 0x26,
+	0xbc, 0x3d, 0xf7, 0xe3, 0xb9, 0x57, 0x79, 0x73, 0xee, 0x55, 0xd0, 0x6b, 0x07, 0xac, 0x4e, 0xe4,
+	0xac, 0x4a, 0x04, 0x9f, 0x39, 0x60, 0x85, 0x5a, 0xa5, 0xca, 0x24, 0x8d, 0x64, 0xaf, 0xdb, 0xa1,
+	0xc2, 0x75, 0xd6, 0xa7, 0x37, 0xea, 0x5b, 0xf7, 0xfd, 0x7f, 0x8e, 0x6a, 0xbf, 0x0c, 0x71, 0xa8,
+	0xd6, 0x86, 0x9f, 0xa9, 0x3a, 0x8e, 0xfa, 0x6a, 0x12, 0x1c, 0xfa, 0xf5, 0x95, 0x07, 0xc7, 0x76,
+	0x0a, 0x0c, 0xe9, 0x98, 0xee, 0x6d, 0xd3, 0x53, 0x0a, 0xf1, 0x2f, 0x07, 0x2c, 0x8d, 0x81, 0xc3,
+	0x08, 0x54, 0xbb, 0x84, 0xe5, 0xb6, 0x16, 0x4f, 0x6c, 0xb3, 0xfd, 0xdb, 0x09, 0x67, 0xeb, 0xa8,
+	0x10, 0x11, 0xd6, 0xc0, 0xf0, 0x18, 0x2c, 0x5c, 0x8b, 0xd5, 0x12, 0xde, 0xbd, 0x71, 0x5b, 0xaf,
+	0x4c, 0x48, 0x1c, 0xc2, 0xf3, 0xe5, 0xdc, 0x94, 0xa2, 0xfd, 0x69, 0x0a, 0x2c, 0x97, 0xa3, 0x7d,
+	0x64, 0x4a, 0x3e, 0x4e, 0xc7, 0xf9, 0xff, 0xe8, 0xc0, 0xcf, 0xc1, 0x42, 0x9c, 0x53, 0x22, 0x69,
+	0x62, 0x9b, 0x73, 0x4a, 0x37, 0xa7, 0x3b, 0xda, 0x7e, 0xcd, 0x8c, 0xf0, 0xbc, 0x95, 0x0d, 0xd7,
+	0x27, 0x00, 0x6a, 0x7d, 0x24, 0x59, 0x4a, 0x85, 0x24, 0x69, 0x37, 0x4a, 0x85, 0x6e, 0xf0, 0xe9,
+	0xf0, 0xde, 0xa0, 0xf0, 0x56, 0x0d, 0xc6, 0xf8, 0x1a, 0x84, 0x17, 0xb5, 0xf2, 0x70, 0xa8, 0x7b,
+	0x2a, 0x90, 0x00, 0xb7, 0xb0, 0xbe, 0xd9, 0x04, 0xbc, 0x0d, 0xa6, 0x98, 0xbd, 0xdd, 0xf1, 0x14,
+	0x4b, 0xe0, 0x07, 0x60, 0xbe, 0x74, 0xb3, 0x0b, 0xc3, 0x12, 0xd7, 0x47, 0xf7, 0xbb, 0x80, 0x9f,
+	0x80, 0x19, 0xf5, 0x64, 0x50, 0xde, 0xa7, 0xf5, 0x84, 0x35, 0x59, 0xf1, 0xd5, 0xa3, 0xc2, 0xb7,
+	0x8f, 0x0a, 0xff, 0x31, 0x67, 0x59, 0x58, 0x55, 0x99, 0xc4, 0x66, 0x75, 0xb8, 0xf7, 0xfc, 0xa2,
+	0xe1, 0xbc, 0xb8, 0x68, 0x38, 0xaf, 0x2f, 0x1a, 0xce, 0xb3, 0xcb, 0x46, 0xe5, 0xc5, 0x65, 0xa3,
+	0xf2, 0xc7, 0x65, 0xa3, 0xf2, 0x6d, 0xf0, 0x16, 0x1d, 0x66, 0x1f, 0x46, 0x3a, 0xeb, 0xcd, 0x59,
+	0x3d, 0xcc, 0x3f, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0xa2, 0x1f, 0x50, 0xdb, 0x36, 0x09, 0x00,
 	0x00,
 }
 
@@ -751,7 +764,7 @@ func (m *ExchangeRateTuple) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *DatedPrice) Marshal() (dAtA []byte, err error) {
+func (m *ExchangeRateAtBlock) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -761,16 +774,21 @@ func (m *DatedPrice) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *DatedPrice) MarshalTo(dAtA []byte) (int, error) {
+func (m *ExchangeRateAtBlock) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *DatedPrice) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ExchangeRateAtBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
 	_ = l
+	if m.BlockTimestampMs != 0 {
+		i = encodeVarintOracle(dAtA, i, uint64(m.BlockTimestampMs))
+		i--
+		dAtA[i] = 0x18
+	}
 	if m.CreatedBlock != 0 {
 		i = encodeVarintOracle(dAtA, i, uint64(m.CreatedBlock))
 		i--
@@ -938,7 +956,7 @@ func (m *ExchangeRateTuple) Size() (n int) {
 	return n
 }
 
-func (m *DatedPrice) Size() (n int) {
+func (m *ExchangeRateAtBlock) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -949,6 +967,9 @@ func (m *DatedPrice) Size() (n int) {
 	if m.CreatedBlock != 0 {
 		n += 1 + sovOracle(uint64(m.CreatedBlock))
 	}
+	if m.BlockTimestampMs != 0 {
+		n += 1 + sovOracle(uint64(m.BlockTimestampMs))
+	}
 	return n
 }
 
@@ -1711,7 +1732,7 @@ func (m *ExchangeRateTuple) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *DatedPrice) Unmarshal(dAtA []byte) error {
+func (m *ExchangeRateAtBlock) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -1734,10 +1755,10 @@ func (m *DatedPrice) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: DatedPrice: wiretype end group for non-group")
+			return fmt.Errorf("proto: ExchangeRateAtBlock: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: DatedPrice: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ExchangeRateAtBlock: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -1793,6 +1814,25 @@ func (m *DatedPrice) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockTimestampMs", wireType)
+			}
+			m.BlockTimestampMs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowOracle
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockTimestampMs |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipOracle(dAtA[iNdEx:])
diff --git a/x/oracle/types/query.pb.go b/x/oracle/types/query.pb.go
index 4149e28c4..9498fb7d9 100644
--- a/x/oracle/types/query.pb.go
+++ b/x/oracle/types/query.pb.go
@@ -77,6 +77,12 @@ var xxx_messageInfo_QueryExchangeRateRequest proto.InternalMessageInfo
 type QueryExchangeRateResponse struct {
 	// exchange_rate defines the exchange rate of assets voted by validators
 	ExchangeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=exchange_rate,json=exchangeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"exchange_rate"`
+	// Block timestamp for the block where the oracle came to consensus for this
+	// price. This timestamp is a conventional Unix millisecond time, i.e. the
+	// number of milliseconds elapsed since January 1, 1970 UTC.
+	BlockTimestampMs int64 `protobuf:"varint,2,opt,name=block_timestamp_ms,json=blockTimestampMs,proto3" json:"block_timestamp_ms,omitempty"`
+	// Block height when the oracle came to consensus for this price.
+	BlockHeight uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
 }
 
 func (m *QueryExchangeRateResponse) Reset()         { *m = QueryExchangeRateResponse{} }
@@ -112,6 +118,20 @@ func (m *QueryExchangeRateResponse) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryExchangeRateResponse proto.InternalMessageInfo
 
+func (m *QueryExchangeRateResponse) GetBlockTimestampMs() int64 {
+	if m != nil {
+		return m.BlockTimestampMs
+	}
+	return 0
+}
+
+func (m *QueryExchangeRateResponse) GetBlockHeight() uint64 {
+	if m != nil {
+		return m.BlockHeight
+	}
+	return 0
+}
+
 // QueryExchangeRatesRequest is the request type for the Query/ExchangeRates RPC
 // method.
 type QueryExchangeRatesRequest struct {
@@ -150,65 +170,6 @@ func (m *QueryExchangeRatesRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryExchangeRatesRequest proto.InternalMessageInfo
 
-// QueryDatedExchangeRateResponse is the request type for the
-// Query/DatedExchangeRate RPC method.
-type QueryDatedExchangeRateResponse struct {
-	Price github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=price,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"price"`
-	// Block timestamp for the block where the oracle came to consensus for this
-	// price. This timestamp is a conventional Unix millisecond time, i.e. the
-	// number of milliseconds elapsed since January 1, 1970 UTC.
-	BlockTimestampMs int64 `protobuf:"varint,2,opt,name=block_timestamp_ms,json=blockTimestampMs,proto3" json:"block_timestamp_ms,omitempty"`
-	// Block height when the oracle came to consensus for this price.
-	BlockHeight uint64 `protobuf:"varint,3,opt,name=block_height,json=blockHeight,proto3" json:"block_height,omitempty"`
-}
-
-func (m *QueryDatedExchangeRateResponse) Reset()         { *m = QueryDatedExchangeRateResponse{} }
-func (m *QueryDatedExchangeRateResponse) String() string { return proto.CompactTextString(m) }
-func (*QueryDatedExchangeRateResponse) ProtoMessage()    {}
-func (*QueryDatedExchangeRateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{3}
-}
-func (m *QueryDatedExchangeRateResponse) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *QueryDatedExchangeRateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_QueryDatedExchangeRateResponse.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *QueryDatedExchangeRateResponse) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_QueryDatedExchangeRateResponse.Merge(m, src)
-}
-func (m *QueryDatedExchangeRateResponse) XXX_Size() int {
-	return m.Size()
-}
-func (m *QueryDatedExchangeRateResponse) XXX_DiscardUnknown() {
-	xxx_messageInfo_QueryDatedExchangeRateResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_QueryDatedExchangeRateResponse proto.InternalMessageInfo
-
-func (m *QueryDatedExchangeRateResponse) GetBlockTimestampMs() int64 {
-	if m != nil {
-		return m.BlockTimestampMs
-	}
-	return 0
-}
-
-func (m *QueryDatedExchangeRateResponse) GetBlockHeight() uint64 {
-	if m != nil {
-		return m.BlockHeight
-	}
-	return 0
-}
-
 // QueryExchangeRatesResponse is response type for the
 // Query/ExchangeRates RPC method.
 type QueryExchangeRatesResponse struct {
@@ -221,7 +182,7 @@ func (m *QueryExchangeRatesResponse) Reset()         { *m = QueryExchangeRatesRe
 func (m *QueryExchangeRatesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryExchangeRatesResponse) ProtoMessage()    {}
 func (*QueryExchangeRatesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{4}
+	return fileDescriptor_16aef2382d1249a8, []int{3}
 }
 func (m *QueryExchangeRatesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -265,7 +226,7 @@ func (m *QueryActivesRequest) Reset()         { *m = QueryActivesRequest{} }
 func (m *QueryActivesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryActivesRequest) ProtoMessage()    {}
 func (*QueryActivesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{5}
+	return fileDescriptor_16aef2382d1249a8, []int{4}
 }
 func (m *QueryActivesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -305,7 +266,7 @@ func (m *QueryActivesResponse) Reset()         { *m = QueryActivesResponse{} }
 func (m *QueryActivesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryActivesResponse) ProtoMessage()    {}
 func (*QueryActivesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{6}
+	return fileDescriptor_16aef2382d1249a8, []int{5}
 }
 func (m *QueryActivesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -343,7 +304,7 @@ func (m *QueryVoteTargetsRequest) Reset()         { *m = QueryVoteTargetsRequest
 func (m *QueryVoteTargetsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryVoteTargetsRequest) ProtoMessage()    {}
 func (*QueryVoteTargetsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{7}
+	return fileDescriptor_16aef2382d1249a8, []int{6}
 }
 func (m *QueryVoteTargetsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -384,7 +345,7 @@ func (m *QueryVoteTargetsResponse) Reset()         { *m = QueryVoteTargetsRespon
 func (m *QueryVoteTargetsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryVoteTargetsResponse) ProtoMessage()    {}
 func (*QueryVoteTargetsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{8}
+	return fileDescriptor_16aef2382d1249a8, []int{7}
 }
 func (m *QueryVoteTargetsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -424,7 +385,7 @@ func (m *QueryFeederDelegationRequest) Reset()         { *m = QueryFeederDelegat
 func (m *QueryFeederDelegationRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryFeederDelegationRequest) ProtoMessage()    {}
 func (*QueryFeederDelegationRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{9}
+	return fileDescriptor_16aef2382d1249a8, []int{8}
 }
 func (m *QueryFeederDelegationRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -464,7 +425,7 @@ func (m *QueryFeederDelegationResponse) Reset()         { *m = QueryFeederDelega
 func (m *QueryFeederDelegationResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryFeederDelegationResponse) ProtoMessage()    {}
 func (*QueryFeederDelegationResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{10}
+	return fileDescriptor_16aef2382d1249a8, []int{9}
 }
 func (m *QueryFeederDelegationResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -511,7 +472,7 @@ func (m *QueryMissCounterRequest) Reset()         { *m = QueryMissCounterRequest
 func (m *QueryMissCounterRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryMissCounterRequest) ProtoMessage()    {}
 func (*QueryMissCounterRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{11}
+	return fileDescriptor_16aef2382d1249a8, []int{10}
 }
 func (m *QueryMissCounterRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -551,7 +512,7 @@ func (m *QueryMissCounterResponse) Reset()         { *m = QueryMissCounterRespon
 func (m *QueryMissCounterResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryMissCounterResponse) ProtoMessage()    {}
 func (*QueryMissCounterResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{12}
+	return fileDescriptor_16aef2382d1249a8, []int{11}
 }
 func (m *QueryMissCounterResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -598,7 +559,7 @@ func (m *QueryAggregatePrevoteRequest) Reset()         { *m = QueryAggregatePrev
 func (m *QueryAggregatePrevoteRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePrevoteRequest) ProtoMessage()    {}
 func (*QueryAggregatePrevoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{13}
+	return fileDescriptor_16aef2382d1249a8, []int{12}
 }
 func (m *QueryAggregatePrevoteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -639,7 +600,7 @@ func (m *QueryAggregatePrevoteResponse) Reset()         { *m = QueryAggregatePre
 func (m *QueryAggregatePrevoteResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePrevoteResponse) ProtoMessage()    {}
 func (*QueryAggregatePrevoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{14}
+	return fileDescriptor_16aef2382d1249a8, []int{13}
 }
 func (m *QueryAggregatePrevoteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -684,7 +645,7 @@ func (m *QueryAggregatePrevotesRequest) Reset()         { *m = QueryAggregatePre
 func (m *QueryAggregatePrevotesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePrevotesRequest) ProtoMessage()    {}
 func (*QueryAggregatePrevotesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{15}
+	return fileDescriptor_16aef2382d1249a8, []int{14}
 }
 func (m *QueryAggregatePrevotesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -725,7 +686,7 @@ func (m *QueryAggregatePrevotesResponse) Reset()         { *m = QueryAggregatePr
 func (m *QueryAggregatePrevotesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregatePrevotesResponse) ProtoMessage()    {}
 func (*QueryAggregatePrevotesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{16}
+	return fileDescriptor_16aef2382d1249a8, []int{15}
 }
 func (m *QueryAggregatePrevotesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -772,7 +733,7 @@ func (m *QueryAggregateVoteRequest) Reset()         { *m = QueryAggregateVoteReq
 func (m *QueryAggregateVoteRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregateVoteRequest) ProtoMessage()    {}
 func (*QueryAggregateVoteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{17}
+	return fileDescriptor_16aef2382d1249a8, []int{16}
 }
 func (m *QueryAggregateVoteRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -813,7 +774,7 @@ func (m *QueryAggregateVoteResponse) Reset()         { *m = QueryAggregateVoteRe
 func (m *QueryAggregateVoteResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregateVoteResponse) ProtoMessage()    {}
 func (*QueryAggregateVoteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{18}
+	return fileDescriptor_16aef2382d1249a8, []int{17}
 }
 func (m *QueryAggregateVoteResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -858,7 +819,7 @@ func (m *QueryAggregateVotesRequest) Reset()         { *m = QueryAggregateVotesR
 func (m *QueryAggregateVotesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregateVotesRequest) ProtoMessage()    {}
 func (*QueryAggregateVotesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{19}
+	return fileDescriptor_16aef2382d1249a8, []int{18}
 }
 func (m *QueryAggregateVotesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -899,7 +860,7 @@ func (m *QueryAggregateVotesResponse) Reset()         { *m = QueryAggregateVotes
 func (m *QueryAggregateVotesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAggregateVotesResponse) ProtoMessage()    {}
 func (*QueryAggregateVotesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{20}
+	return fileDescriptor_16aef2382d1249a8, []int{19}
 }
 func (m *QueryAggregateVotesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -943,7 +904,7 @@ func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
 func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsRequest) ProtoMessage()    {}
 func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{21}
+	return fileDescriptor_16aef2382d1249a8, []int{20}
 }
 func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -982,7 +943,7 @@ func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
 func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsResponse) ProtoMessage()    {}
 func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_16aef2382d1249a8, []int{22}
+	return fileDescriptor_16aef2382d1249a8, []int{21}
 }
 func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1022,7 +983,6 @@ func init() {
 	proto.RegisterType((*QueryExchangeRateRequest)(nil), "nibiru.oracle.v1.QueryExchangeRateRequest")
 	proto.RegisterType((*QueryExchangeRateResponse)(nil), "nibiru.oracle.v1.QueryExchangeRateResponse")
 	proto.RegisterType((*QueryExchangeRatesRequest)(nil), "nibiru.oracle.v1.QueryExchangeRatesRequest")
-	proto.RegisterType((*QueryDatedExchangeRateResponse)(nil), "nibiru.oracle.v1.QueryDatedExchangeRateResponse")
 	proto.RegisterType((*QueryExchangeRatesResponse)(nil), "nibiru.oracle.v1.QueryExchangeRatesResponse")
 	proto.RegisterType((*QueryActivesRequest)(nil), "nibiru.oracle.v1.QueryActivesRequest")
 	proto.RegisterType((*QueryActivesResponse)(nil), "nibiru.oracle.v1.QueryActivesResponse")
@@ -1047,84 +1007,80 @@ func init() {
 func init() { proto.RegisterFile("nibiru/oracle/v1/query.proto", fileDescriptor_16aef2382d1249a8) }
 
 var fileDescriptor_16aef2382d1249a8 = []byte{
-	// 1218 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x98, 0xcf, 0x6f, 0x1b, 0x45,
-	0x14, 0xc7, 0x3d, 0x4d, 0x9a, 0xc2, 0x73, 0x1c, 0x9c, 0x21, 0x08, 0xd7, 0x4d, 0xec, 0x74, 0x69,
-	0xa2, 0x34, 0x3f, 0x76, 0x49, 0x52, 0x15, 0x05, 0x8a, 0x20, 0x3f, 0xa8, 0x28, 0x6a, 0x20, 0x98,
-	0x28, 0x42, 0xbd, 0x58, 0xe3, 0xf5, 0x74, 0xb3, 0xaa, 0xbd, 0xbb, 0xdd, 0x19, 0x9b, 0x46, 0x85,
-	0x4b, 0x05, 0x88, 0x23, 0x12, 0x42, 0xdc, 0xa0, 0x17, 0x24, 0xc4, 0x99, 0x1f, 0x67, 0x6e, 0x3d,
-	0x56, 0xe2, 0x82, 0x38, 0x14, 0x94, 0x70, 0x40, 0xfc, 0x15, 0x68, 0x67, 0xc7, 0xce, 0xae, 0xd7,
-	0xa3, 0x6c, 0x5d, 0x38, 0xb5, 0x9a, 0xf7, 0xf6, 0xbd, 0xcf, 0x7c, 0x35, 0x33, 0xef, 0xeb, 0xc0,
-	0xa4, 0x63, 0xd7, 0x6c, 0xbf, 0x65, 0xb8, 0x3e, 0x31, 0x1b, 0xd4, 0x68, 0x2f, 0x1b, 0xb7, 0x5b,
-	0xd4, 0x3f, 0xd0, 0x3d, 0xdf, 0xe5, 0x2e, 0xce, 0x87, 0x51, 0x3d, 0x8c, 0xea, 0xed, 0xe5, 0xe2,
-	0x84, 0xe5, 0x5a, 0xae, 0x08, 0x1a, 0xc1, 0xff, 0xc2, 0xbc, 0xe2, 0xa4, 0xe5, 0xba, 0x56, 0x83,
-	0x1a, 0xc4, 0xb3, 0x0d, 0xe2, 0x38, 0x2e, 0x27, 0xdc, 0x76, 0x1d, 0x26, 0xa3, 0x53, 0x89, 0x1e,
-	0xb2, 0x5e, 0x18, 0x2e, 0x99, 0x2e, 0x6b, 0xba, 0xcc, 0xa8, 0x11, 0x16, 0x04, 0x6b, 0x94, 0x93,
-	0x65, 0xc3, 0x74, 0x6d, 0x27, 0x8c, 0x6b, 0x6d, 0x28, 0xbc, 0x1b, 0x30, 0xbd, 0x71, 0xc7, 0xdc,
-	0x27, 0x8e, 0x45, 0x2b, 0x84, 0xd3, 0x0a, 0xbd, 0xdd, 0xa2, 0x8c, 0xe3, 0x1d, 0x18, 0xf6, 0x88,
-	0xed, 0x17, 0xd0, 0x34, 0x9a, 0x7b, 0x7a, 0xe3, 0xca, 0x83, 0x47, 0xe5, 0xcc, 0xef, 0x8f, 0xca,
-	0x97, 0x2c, 0x9b, 0xef, 0xb7, 0x6a, 0xba, 0xe9, 0x36, 0x8d, 0xb7, 0x45, 0xef, 0xcd, 0x7d, 0x62,
-	0x3b, 0x86, 0xe4, 0x68, 0xaf, 0x18, 0x77, 0x0c, 0xd3, 0x6d, 0x36, 0x5d, 0xc7, 0x20, 0x8c, 0x51,
-	0xae, 0xef, 0x10, 0xdb, 0xaf, 0x88, 0x4a, 0x2f, 0x3f, 0xf5, 0xd9, 0xfd, 0x72, 0xe6, 0xef, 0xfb,
-	0xe5, 0x8c, 0xe6, 0xc1, 0xd9, 0x3e, 0x7d, 0x99, 0xe7, 0x3a, 0x8c, 0xe2, 0xf7, 0x20, 0x47, 0xe5,
-	0x7a, 0xd5, 0x27, 0x9c, 0x4a, 0x02, 0x5d, 0x12, 0xcc, 0x46, 0x08, 0xe4, 0xf6, 0xc2, 0x7f, 0x96,
-	0x58, 0xfd, 0x96, 0xc1, 0x0f, 0x3c, 0xca, 0xf4, 0x2d, 0x6a, 0x56, 0x46, 0x69, 0xa4, 0xb8, 0x76,
-	0xae, 0x4f, 0x47, 0x26, 0xb7, 0xaa, 0xfd, 0x8c, 0xa0, 0x24, 0xa2, 0x5b, 0x84, 0xd3, 0x7a, 0x5f,
-	0xa8, 0x2d, 0x38, 0xed, 0xf9, 0xb6, 0x39, 0x28, 0x4c, 0xf8, 0x31, 0x5e, 0x04, 0x5c, 0x6b, 0xb8,
-	0xe6, 0xad, 0x2a, 0xb7, 0x9b, 0x94, 0x71, 0xd2, 0xf4, 0xaa, 0x4d, 0x56, 0x38, 0x35, 0x8d, 0xe6,
-	0x86, 0x2a, 0x79, 0x11, 0xd9, 0xed, 0x04, 0xb6, 0x19, 0x3e, 0x0f, 0xa3, 0x61, 0xf6, 0x3e, 0xb5,
-	0xad, 0x7d, 0x5e, 0x18, 0x9a, 0x46, 0x73, 0xc3, 0x95, 0xac, 0x58, 0x7b, 0x53, 0x2c, 0x69, 0x1f,
-	0x23, 0x28, 0xf6, 0xdb, 0x97, 0xa4, 0xbe, 0x09, 0x63, 0x31, 0x29, 0x59, 0x01, 0x4d, 0x0f, 0xcd,
-	0x65, 0x57, 0x5e, 0xd0, 0x7b, 0x4f, 0x9f, 0x1e, 0x2d, 0xb0, 0xdb, 0xf2, 0x1a, 0x74, 0xa3, 0x18,
-	0xec, 0xf1, 0xfb, 0x3f, 0xca, 0x38, 0x11, 0x62, 0x95, 0x5c, 0x54, 0x5c, 0xa6, 0x3d, 0x07, 0xcf,
-	0x0a, 0x8a, 0x75, 0x93, 0xdb, 0xed, 0x63, 0x5d, 0x1d, 0x98, 0x88, 0x2f, 0x4b, 0xac, 0x3d, 0x38,
-	0x43, 0xc2, 0x25, 0xc1, 0xf3, 0xa4, 0xa7, 0xab, 0x53, 0x4c, 0x3b, 0x0b, 0xcf, 0x8b, 0x7e, 0x7b,
-	0x2e, 0xa7, 0xbb, 0xc4, 0xb7, 0x28, 0xef, 0xa2, 0xdc, 0x95, 0x27, 0x3d, 0x16, 0x92, 0x38, 0x55,
-	0x18, 0x6d, 0xbb, 0x9c, 0x56, 0x79, 0xb8, 0xfe, 0x9f, 0x30, 0x65, 0xdb, 0xc7, 0x8d, 0xb4, 0x77,
-	0x60, 0x52, 0x34, 0xbf, 0x4a, 0x69, 0x9d, 0xfa, 0x5b, 0xb4, 0x41, 0x2d, 0x71, 0x8b, 0x3b, 0x57,
-	0x6d, 0x06, 0xc6, 0xda, 0xa4, 0x61, 0xd7, 0x09, 0x77, 0xfd, 0x2a, 0xa9, 0xd7, 0xe5, 0xa5, 0xab,
-	0xe4, 0xba, 0xab, 0xeb, 0xf5, 0x7a, 0xf4, 0xfe, 0xbc, 0x0e, 0x53, 0x8a, 0x82, 0x72, 0x4b, 0x65,
-	0xc8, 0xde, 0x14, 0xb1, 0x68, 0x39, 0x08, 0x97, 0x82, 0x5a, 0xda, 0x5b, 0x52, 0xaa, 0x6d, 0x9b,
-	0xb1, 0x4d, 0xb7, 0xe5, 0x70, 0xea, 0x0f, 0x4c, 0xf3, 0xaa, 0xd4, 0x36, 0x56, 0x4b, 0x82, 0x9c,
-	0x87, 0xd1, 0xa6, 0xcd, 0x58, 0xd5, 0x0c, 0xd7, 0x45, 0xa9, 0xe1, 0x4a, 0xb6, 0x79, 0x9c, 0xda,
-	0x55, 0x67, 0xdd, 0xb2, 0xfc, 0x60, 0x1f, 0x74, 0xc7, 0xa7, 0x81, 0x7a, 0x03, 0xf3, 0xdc, 0x43,
-	0x52, 0x9e, 0x64, 0x45, 0x49, 0x45, 0x60, 0x9c, 0x74, 0x62, 0x55, 0x2f, 0x0c, 0x8a, 0xaa, 0xd9,
-	0x15, 0x3d, 0x79, 0x35, 0xba, 0x65, 0xa2, 0x17, 0x41, 0x96, 0xdc, 0x18, 0x0e, 0x8e, 0x49, 0x25,
-	0x4f, 0x7a, 0x5a, 0x69, 0x65, 0x05, 0x43, 0xf7, 0x44, 0x7e, 0xd2, 0x79, 0x74, 0xfa, 0x64, 0x48,
-	0x4c, 0x13, 0x70, 0x02, 0xb3, 0x73, 0x85, 0x07, 0xe3, 0x1c, 0xef, 0xe5, 0x64, 0xda, 0x75, 0xf9,
-	0x32, 0x76, 0xbf, 0xde, 0x7b, 0x12, 0xed, 0xdb, 0xf2, 0x3d, 0xea, 0xa9, 0x26, 0x37, 0xf4, 0x3e,
-	0x8c, 0x1d, 0x6f, 0x28, 0x22, 0xfa, 0x42, 0xca, 0xcd, 0xec, 0x1d, 0xef, 0x24, 0x47, 0xa2, 0x1d,
-	0xb4, 0xc9, 0x7e, 0x7d, 0xbb, 0x5a, 0x1f, 0xc0, 0xb9, 0xbe, 0x51, 0x89, 0x75, 0x03, 0x9e, 0x89,
-	0x63, 0x75, 0x44, 0x1e, 0x80, 0x6b, 0x2c, 0xc6, 0xc5, 0xb4, 0x09, 0xc0, 0xa2, 0xf5, 0x0e, 0xf1,
-	0x49, 0xb3, 0x0b, 0xb4, 0x2d, 0x1f, 0xcc, 0xce, 0xaa, 0x04, 0xb9, 0x0c, 0x23, 0x9e, 0x58, 0x91,
-	0xba, 0x14, 0x92, 0xfd, 0xc3, 0x2f, 0x64, 0x33, 0x99, 0xbd, 0xf2, 0x4f, 0x1e, 0x4e, 0x8b, 0x7a,
-	0xf8, 0x4b, 0x04, 0xa3, 0x51, 0x32, 0x3c, 0x9f, 0x2c, 0xa1, 0x1a, 0xf9, 0xc5, 0x85, 0x54, 0xb9,
-	0x21, 0xab, 0xb6, 0x78, 0xef, 0xd7, 0xbf, 0xbe, 0x38, 0x35, 0x8b, 0x2f, 0x18, 0xbd, 0x1e, 0x24,
-	0xb4, 0x19, 0xb1, 0xc1, 0x83, 0xbf, 0x46, 0x90, 0x8f, 0xcd, 0x91, 0x0f, 0x88, 0xf7, 0xff, 0xb1,
-	0x2d, 0x0b, 0xb6, 0x05, 0x7c, 0x31, 0x0d, 0x5b, 0x95, 0x07, 0x2c, 0xdf, 0x22, 0x18, 0x4f, 0x8c,
-	0xff, 0xc7, 0x22, 0x7c, 0x51, 0x91, 0xab, 0x34, 0x15, 0xda, 0x8a, 0xc0, 0x5c, 0xc4, 0xf3, 0x0a,
-	0xcc, 0x7a, 0xf0, 0x65, 0x35, 0x2e, 0xe4, 0x37, 0x08, 0x72, 0xb1, 0x61, 0x8f, 0xd3, 0x28, 0xd3,
-	0x39, 0x78, 0xc5, 0xc5, 0x74, 0xc9, 0x12, 0x70, 0x55, 0x00, 0x2e, 0xe1, 0x05, 0x05, 0x60, 0x60,
-	0xeb, 0x58, 0x5c, 0x4d, 0x86, 0x3f, 0x45, 0x70, 0x46, 0x4e, 0x7c, 0x3c, 0xa3, 0x68, 0x17, 0x37,
-	0x0a, 0xc5, 0xd9, 0x93, 0xd2, 0x52, 0x9e, 0xb9, 0x90, 0x47, 0xda, 0x01, 0xfc, 0x15, 0x82, 0x6c,
-	0x64, 0xde, 0xe3, 0x8b, 0x8a, 0x2e, 0x49, 0xbb, 0x50, 0x9c, 0x4f, 0x93, 0x9a, 0xf2, 0xb0, 0x85,
-	0x50, 0x51, 0x87, 0x81, 0x7f, 0x42, 0x90, 0xef, 0x9d, 0xdd, 0x58, 0x57, 0xf4, 0x54, 0xb8, 0x86,
-	0xa2, 0x91, 0x3a, 0x5f, 0x82, 0xae, 0x0b, 0xd0, 0x57, 0xf0, 0x9a, 0x02, 0xb4, 0xfb, 0xa6, 0x33,
-	0xe3, 0x6e, 0xfc, 0xd5, 0xff, 0xc8, 0x08, 0xad, 0x43, 0x70, 0x4b, 0xb2, 0x91, 0x31, 0xaf, 0x94,
-	0x34, 0x69, 0x2b, 0x94, 0x92, 0xf6, 0x71, 0x0d, 0xda, 0x6b, 0x82, 0x74, 0x0d, 0xbf, 0x34, 0x00,
-	0x69, 0x60, 0x2d, 0xf0, 0x2f, 0x08, 0xf2, 0xbd, 0x73, 0x55, 0x29, 0xb0, 0xc2, 0x78, 0x28, 0x05,
-	0x56, 0xd9, 0x0a, 0xed, 0xba, 0xc0, 0xbe, 0x8a, 0xb7, 0x06, 0xc0, 0x4e, 0x0c, 0x7a, 0xfc, 0x03,
-	0x82, 0xf1, 0x84, 0x37, 0xc0, 0x69, 0xa1, 0xd8, 0x49, 0xcf, 0x92, 0xd2, 0x76, 0x68, 0x57, 0xc4,
-	0x36, 0x2e, 0xe3, 0x4b, 0x27, 0x6f, 0x23, 0x69, 0x4f, 0xf0, 0x8f, 0x08, 0x72, 0xb1, 0x39, 0xab,
-	0x7c, 0xa0, 0xfa, 0x39, 0x0e, 0xe5, 0x03, 0xd5, 0xd7, 0x50, 0x68, 0xd7, 0x04, 0xea, 0x26, 0x5e,
-	0x57, 0xa3, 0xd6, 0xed, 0x13, 0x15, 0x17, 0x72, 0x7f, 0x87, 0x60, 0x2c, 0xee, 0x0f, 0x70, 0x2a,
-	0x96, 0xae, 0xd0, 0x4b, 0x29, 0xb3, 0x25, 0xfa, 0x9a, 0x40, 0x5f, 0xc5, 0xcb, 0x8f, 0xa3, 0x72,
-	0x28, 0xf1, 0x87, 0x30, 0x12, 0xda, 0x00, 0x7c, 0x41, 0xd1, 0x33, 0xe6, 0x36, 0x8a, 0x33, 0x27,
-	0x64, 0x49, 0xa2, 0x19, 0x41, 0x54, 0xc6, 0x53, 0xca, 0x87, 0x4c, 0x58, 0x8f, 0x6b, 0x0f, 0x0e,
-	0x4b, 0xe8, 0xe1, 0x61, 0x09, 0xfd, 0x79, 0x58, 0x42, 0x9f, 0x1f, 0x95, 0x32, 0x0f, 0x8f, 0x4a,
-	0x99, 0xdf, 0x8e, 0x4a, 0x99, 0x1b, 0x46, 0x8a, 0x9f, 0x4a, 0xb2, 0xa6, 0xf8, 0x69, 0x5c, 0x1b,
-	0x11, 0x7f, 0x86, 0x58, 0xfd, 0x37, 0x00, 0x00, 0xff, 0xff, 0xb7, 0xc9, 0xcd, 0x87, 0x2b, 0x11,
-	0x00, 0x00,
+	// 1166 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x97, 0xcf, 0x6f, 0x1b, 0x45,
+	0x1b, 0xc7, 0x3d, 0x4d, 0xde, 0xf4, 0xe5, 0x71, 0x9c, 0x3a, 0x43, 0x10, 0xae, 0x9b, 0xd8, 0xe9,
+	0xd2, 0x44, 0x69, 0x93, 0xec, 0x92, 0xa4, 0x2a, 0x0a, 0x14, 0x41, 0x7e, 0x50, 0x51, 0xd4, 0x40,
+	0x30, 0x51, 0x84, 0x7a, 0xb1, 0xc6, 0xeb, 0xe9, 0x66, 0x55, 0x7b, 0xd7, 0xdd, 0x19, 0x9b, 0x46,
+	0x85, 0x4b, 0x05, 0x88, 0x23, 0x12, 0x42, 0xdc, 0xa0, 0x17, 0x24, 0xc4, 0x19, 0xb8, 0x97, 0x53,
+	0x8f, 0x95, 0xb8, 0x20, 0x0e, 0x05, 0x25, 0x1c, 0xf8, 0x33, 0xd0, 0xce, 0x8e, 0xd7, 0xbb, 0x5e,
+	0x8f, 0xb2, 0xb8, 0x70, 0x4a, 0x34, 0xcf, 0xb3, 0xcf, 0xf3, 0x79, 0xbe, 0x3b, 0x33, 0x5f, 0x2f,
+	0x4c, 0x3b, 0x76, 0xcd, 0xf6, 0xda, 0x86, 0xeb, 0x11, 0xb3, 0x41, 0x8d, 0xce, 0x8a, 0x71, 0xa7,
+	0x4d, 0xbd, 0x43, 0xbd, 0xe5, 0xb9, 0xdc, 0xc5, 0xf9, 0x20, 0xaa, 0x07, 0x51, 0xbd, 0xb3, 0x52,
+	0x9c, 0xb2, 0x5c, 0xcb, 0x15, 0x41, 0xc3, 0xff, 0x2f, 0xc8, 0x2b, 0x4e, 0x5b, 0xae, 0x6b, 0x35,
+	0xa8, 0x41, 0x5a, 0xb6, 0x41, 0x1c, 0xc7, 0xe5, 0x84, 0xdb, 0xae, 0xc3, 0x64, 0x74, 0x26, 0xd1,
+	0x43, 0xd6, 0x0b, 0xc2, 0x25, 0xd3, 0x65, 0x4d, 0x97, 0x19, 0x35, 0xc2, 0xfc, 0x60, 0x8d, 0x72,
+	0xb2, 0x62, 0x98, 0xae, 0xed, 0x04, 0x71, 0xad, 0x03, 0x85, 0x77, 0x7d, 0xa6, 0x37, 0xee, 0x9a,
+	0x07, 0xc4, 0xb1, 0x68, 0x85, 0x70, 0x5a, 0xa1, 0x77, 0xda, 0x94, 0x71, 0xbc, 0x0b, 0xa3, 0x2d,
+	0x62, 0x7b, 0x05, 0x34, 0x8b, 0x16, 0x9e, 0xd9, 0xbc, 0xfa, 0xe8, 0x49, 0x39, 0xf3, 0xdb, 0x93,
+	0xf2, 0x65, 0xcb, 0xe6, 0x07, 0xed, 0x9a, 0x6e, 0xba, 0x4d, 0xe3, 0x6d, 0xd1, 0x7b, 0xeb, 0x80,
+	0xd8, 0x8e, 0x21, 0x39, 0x3a, 0xab, 0xc6, 0x5d, 0xc3, 0x74, 0x9b, 0x4d, 0xd7, 0x31, 0x08, 0x63,
+	0x94, 0xeb, 0xbb, 0xc4, 0xf6, 0x2a, 0xa2, 0xd2, 0xcb, 0xff, 0xff, 0xec, 0x41, 0x39, 0xf3, 0xd7,
+	0x83, 0x72, 0x46, 0x7b, 0x88, 0xe0, 0xec, 0x80, 0xc6, 0xac, 0xe5, 0x3a, 0x8c, 0xe2, 0xf7, 0x20,
+	0x47, 0xe5, 0x7a, 0xd5, 0x23, 0x9c, 0x4a, 0x04, 0x5d, 0x22, 0xcc, 0x47, 0x10, 0xe4, 0x7c, 0xc1,
+	0x9f, 0x65, 0x56, 0xbf, 0x6d, 0xf0, 0xc3, 0x16, 0x65, 0xfa, 0x36, 0x35, 0x2b, 0xe3, 0x34, 0x52,
+	0x1c, 0x2f, 0x01, 0xae, 0x35, 0x5c, 0xf3, 0x76, 0x95, 0xdb, 0x4d, 0xca, 0x38, 0x69, 0xb6, 0xaa,
+	0x4d, 0x56, 0x38, 0x35, 0x8b, 0x16, 0x46, 0x2a, 0x79, 0x11, 0xd9, 0xeb, 0x06, 0x76, 0x18, 0x3e,
+	0x0f, 0xe3, 0x41, 0xf6, 0x01, 0xb5, 0xad, 0x03, 0x5e, 0x18, 0x99, 0x45, 0x0b, 0xa3, 0x95, 0xac,
+	0x58, 0x7b, 0x53, 0x2c, 0x69, 0xe7, 0x06, 0x8c, 0xc0, 0xa4, 0x78, 0xda, 0xc7, 0x08, 0x8a, 0x83,
+	0xa2, 0x72, 0xc2, 0x5b, 0x30, 0x11, 0x9b, 0x90, 0x15, 0xd0, 0xec, 0xc8, 0x42, 0x76, 0xf5, 0x05,
+	0xbd, 0x7f, 0x57, 0xe8, 0xd1, 0x02, 0x7b, 0xed, 0x56, 0x83, 0x6e, 0x16, 0x7d, 0x1d, 0xbe, 0xff,
+	0xbd, 0x8c, 0x13, 0x21, 0x56, 0xc9, 0x45, 0x67, 0x66, 0xda, 0x73, 0xf0, 0xac, 0xa0, 0xd8, 0x30,
+	0xb9, 0xdd, 0xe9, 0xd1, 0x39, 0x30, 0x15, 0x5f, 0x96, 0x58, 0xfb, 0x70, 0x9a, 0x04, 0x4b, 0x82,
+	0xe7, 0x69, 0xdf, 0x7a, 0xb7, 0x98, 0x76, 0x16, 0x9e, 0x17, 0xfd, 0xf6, 0x5d, 0x4e, 0xf7, 0x88,
+	0x67, 0x51, 0x1e, 0xa2, 0xdc, 0x93, 0x3b, 0x30, 0x16, 0x92, 0x38, 0x55, 0x18, 0xef, 0xb8, 0x9c,
+	0x56, 0x79, 0xb0, 0xfe, 0xaf, 0x30, 0x65, 0x3b, 0xbd, 0x46, 0xda, 0x3b, 0x30, 0x2d, 0x9a, 0x5f,
+	0xa3, 0xb4, 0x4e, 0xbd, 0x6d, 0xda, 0xa0, 0x96, 0x38, 0x5d, 0xdd, 0x23, 0x30, 0x07, 0x13, 0x1d,
+	0xd2, 0xb0, 0xeb, 0x84, 0xbb, 0x5e, 0x95, 0xd4, 0xeb, 0xf2, 0x30, 0x54, 0x72, 0xe1, 0xea, 0x46,
+	0xbd, 0x1e, 0xdd, 0xd7, 0xaf, 0xc3, 0x8c, 0xa2, 0xa0, 0x1c, 0xa9, 0x0c, 0xd9, 0x5b, 0x22, 0x16,
+	0x2d, 0x07, 0xc1, 0x92, 0x5f, 0x4b, 0x7b, 0x4b, 0x4a, 0xb5, 0x63, 0x33, 0xb6, 0xe5, 0xb6, 0x1d,
+	0x4e, 0xbd, 0xa1, 0x69, 0x5e, 0x95, 0xda, 0xc6, 0x6a, 0x49, 0x90, 0xf3, 0x30, 0xde, 0xb4, 0x19,
+	0xab, 0x9a, 0xc1, 0xba, 0x28, 0x35, 0x5a, 0xc9, 0x36, 0x7b, 0xa9, 0xa1, 0x3a, 0x1b, 0x96, 0xe5,
+	0xf9, 0x73, 0xd0, 0x5d, 0x8f, 0xfa, 0xea, 0x0d, 0xcd, 0x73, 0x1f, 0x49, 0x79, 0x92, 0x15, 0x25,
+	0x15, 0x81, 0x49, 0xd2, 0x8d, 0x55, 0x5b, 0x41, 0x50, 0x54, 0xcd, 0xae, 0xea, 0xc9, 0xa3, 0x11,
+	0x96, 0x89, 0x1e, 0x04, 0x59, 0x72, 0x73, 0xd4, 0xdf, 0x26, 0x95, 0x3c, 0xe9, 0x6b, 0xa5, 0x95,
+	0x15, 0x0c, 0xe1, 0x8e, 0xfc, 0x04, 0x41, 0x49, 0x95, 0x21, 0x31, 0x4d, 0xc0, 0x09, 0xcc, 0xee,
+	0x11, 0x1e, 0x8e, 0x73, 0xb2, 0x9f, 0x93, 0x69, 0x37, 0xe4, 0xfd, 0x12, 0x3e, 0xbd, 0xff, 0x34,
+	0xda, 0x77, 0xe4, 0x7d, 0xd4, 0x57, 0x4d, 0x0e, 0xf4, 0x3e, 0x4c, 0xf4, 0x06, 0x8a, 0x88, 0xbe,
+	0x98, 0x72, 0x98, 0xfd, 0xde, 0x24, 0x39, 0x12, 0xed, 0xa0, 0x4d, 0x0f, 0xea, 0x1b, 0x6a, 0x7d,
+	0x08, 0xe7, 0x06, 0x46, 0x25, 0xd6, 0x4d, 0x38, 0x13, 0xc7, 0xea, 0x8a, 0x3c, 0x04, 0xd7, 0x44,
+	0x8c, 0x8b, 0x69, 0x53, 0x80, 0x45, 0xeb, 0x5d, 0xe2, 0x91, 0x66, 0x08, 0xb4, 0x23, 0x2f, 0xcc,
+	0xee, 0xaa, 0x04, 0xb9, 0x02, 0x63, 0x2d, 0xb1, 0x22, 0x75, 0x29, 0x24, 0xfb, 0x07, 0x4f, 0xc8,
+	0x66, 0x32, 0x7b, 0xf5, 0xe7, 0x33, 0xf0, 0x3f, 0x51, 0x0f, 0x7f, 0x89, 0x60, 0x3c, 0x4a, 0x86,
+	0x2f, 0x25, 0x4b, 0xa8, 0xac, 0xb8, 0xb8, 0x98, 0x2a, 0x37, 0x60, 0xd5, 0x96, 0xee, 0xff, 0xf2,
+	0xe7, 0x17, 0xa7, 0xe6, 0xf1, 0x05, 0xa3, 0xff, 0xb7, 0x41, 0x60, 0xff, 0x31, 0xe3, 0xc1, 0x5f,
+	0x23, 0xc8, 0xc7, 0x7c, 0xe4, 0x03, 0xd2, 0xfa, 0xef, 0xd8, 0x56, 0x04, 0xdb, 0x22, 0xbe, 0x98,
+	0x86, 0xad, 0xca, 0x7d, 0x96, 0x6f, 0x10, 0xe4, 0x62, 0x26, 0x8a, 0xd3, 0x74, 0xec, 0xbe, 0xd0,
+	0xe2, 0x52, 0xba, 0x64, 0xc9, 0xb7, 0x26, 0xf8, 0x96, 0xf1, 0xa2, 0x82, 0xcf, 0xff, 0x19, 0xc3,
+	0xe2, 0x94, 0x0c, 0x7f, 0x8a, 0xe0, 0xb4, 0x74, 0x52, 0x3c, 0xa7, 0x68, 0x17, 0x37, 0xe0, 0xe2,
+	0xfc, 0x49, 0x69, 0x29, 0xdf, 0x65, 0xc0, 0x23, 0x6d, 0x16, 0x7f, 0x85, 0x20, 0x1b, 0xf1, 0x51,
+	0x7c, 0x51, 0xd1, 0x25, 0x69, 0xc3, 0xc5, 0x4b, 0x69, 0x52, 0x53, 0xbe, 0xc4, 0x00, 0x2a, 0xea,
+	0xdc, 0xf8, 0x27, 0x04, 0xf9, 0x7e, 0x4f, 0xc4, 0xba, 0xa2, 0xa7, 0xc2, 0x8d, 0x8b, 0x46, 0xea,
+	0x7c, 0x09, 0xba, 0x21, 0x40, 0x5f, 0xc1, 0xeb, 0x0a, 0xd0, 0xf0, 0xae, 0x64, 0xc6, 0xbd, 0xf8,
+	0x6d, 0xfa, 0x91, 0x11, 0x58, 0x32, 0xfe, 0x16, 0x41, 0x36, 0x62, 0x9f, 0x4a, 0x49, 0x93, 0x76,
+	0xad, 0x94, 0x74, 0x80, 0x1b, 0x6b, 0xaf, 0x09, 0xd2, 0x75, 0xfc, 0xd2, 0x10, 0xa4, 0xbe, 0x65,
+	0xe3, 0x87, 0x08, 0xf2, 0xfd, 0x7e, 0xa5, 0x14, 0x58, 0x61, 0xe8, 0x4a, 0x81, 0x55, 0x76, 0xad,
+	0xdd, 0x10, 0xd8, 0xd7, 0xf0, 0xf6, 0x10, 0xd8, 0x09, 0x03, 0xc5, 0x3f, 0x20, 0x98, 0x4c, 0x78,
+	0x2e, 0x4e, 0x0b, 0x15, 0x6e, 0xe5, 0x17, 0xd3, 0x3f, 0x20, 0xc7, 0xb8, 0x2a, 0xc6, 0xb8, 0x82,
+	0x2f, 0x9f, 0x3c, 0x46, 0xd2, 0xf6, 0xf1, 0x8f, 0x08, 0x72, 0x31, 0xff, 0x52, 0x5e, 0x50, 0x83,
+	0x9c, 0x5c, 0x79, 0x41, 0x0d, 0x34, 0x6a, 0xed, 0xba, 0x40, 0xdd, 0xc2, 0x1b, 0x6a, 0xd4, 0xba,
+	0x7d, 0xa2, 0xe2, 0x42, 0xee, 0xef, 0x10, 0x4c, 0xc4, 0x7d, 0x17, 0xa7, 0x62, 0x09, 0x85, 0x5e,
+	0x4e, 0x99, 0x2d, 0xd1, 0xd7, 0x05, 0xfa, 0x1a, 0x5e, 0xf9, 0x27, 0x2a, 0x07, 0x12, 0x7f, 0x08,
+	0x63, 0x81, 0xbd, 0xe2, 0x0b, 0x8a, 0x9e, 0x31, 0x17, 0x2f, 0xce, 0x9d, 0x90, 0x25, 0x89, 0xe6,
+	0x04, 0x51, 0x19, 0xcf, 0x28, 0x2f, 0x32, 0x61, 0xe9, 0xd7, 0x1f, 0x1d, 0x95, 0xd0, 0xe3, 0xa3,
+	0x12, 0xfa, 0xe3, 0xa8, 0x84, 0x3e, 0x3f, 0x2e, 0x65, 0x1e, 0x1f, 0x97, 0x32, 0xbf, 0x1e, 0x97,
+	0x32, 0x37, 0x8d, 0x14, 0x9f, 0x20, 0xb2, 0xa6, 0xf8, 0x2c, 0xad, 0x8d, 0x89, 0xcf, 0xee, 0xb5,
+	0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x14, 0xd6, 0x3e, 0x1e, 0x1b, 0x10, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -1139,12 +1095,11 @@ const _ = grpc.SupportPackageIsVersion4
 //
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type QueryClient interface {
-	// ExchangeRate returns exchange rate of a pair
+	// ExchangeRate returns exchange rate of a pair along with the block height and
+	// block time that the exchange rate was set by the oracle module.
 	ExchangeRate(ctx context.Context, in *QueryExchangeRateRequest, opts ...grpc.CallOption) (*QueryExchangeRateResponse, error)
 	// ExchangeRateTwap returns twap exchange rate of a pair
 	ExchangeRateTwap(ctx context.Context, in *QueryExchangeRateRequest, opts ...grpc.CallOption) (*QueryExchangeRateResponse, error)
-	// DatedExchangeRate returns latest price of a pair
-	DatedExchangeRate(ctx context.Context, in *QueryExchangeRateRequest, opts ...grpc.CallOption) (*QueryDatedExchangeRateResponse, error)
 	// ExchangeRates returns exchange rates of all pairs
 	ExchangeRates(ctx context.Context, in *QueryExchangeRatesRequest, opts ...grpc.CallOption) (*QueryExchangeRatesResponse, error)
 	// Actives returns all active pairs
@@ -1193,15 +1148,6 @@ func (c *queryClient) ExchangeRateTwap(ctx context.Context, in *QueryExchangeRat
 	return out, nil
 }
 
-func (c *queryClient) DatedExchangeRate(ctx context.Context, in *QueryExchangeRateRequest, opts ...grpc.CallOption) (*QueryDatedExchangeRateResponse, error) {
-	out := new(QueryDatedExchangeRateResponse)
-	err := c.cc.Invoke(ctx, "/nibiru.oracle.v1.Query/DatedExchangeRate", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *queryClient) ExchangeRates(ctx context.Context, in *QueryExchangeRatesRequest, opts ...grpc.CallOption) (*QueryExchangeRatesResponse, error) {
 	out := new(QueryExchangeRatesResponse)
 	err := c.cc.Invoke(ctx, "/nibiru.oracle.v1.Query/ExchangeRates", in, out, opts...)
@@ -1294,12 +1240,11 @@ func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts .
 
 // QueryServer is the server API for Query service.
 type QueryServer interface {
-	// ExchangeRate returns exchange rate of a pair
+	// ExchangeRate returns exchange rate of a pair along with the block height and
+	// block time that the exchange rate was set by the oracle module.
 	ExchangeRate(context.Context, *QueryExchangeRateRequest) (*QueryExchangeRateResponse, error)
 	// ExchangeRateTwap returns twap exchange rate of a pair
 	ExchangeRateTwap(context.Context, *QueryExchangeRateRequest) (*QueryExchangeRateResponse, error)
-	// DatedExchangeRate returns latest price of a pair
-	DatedExchangeRate(context.Context, *QueryExchangeRateRequest) (*QueryDatedExchangeRateResponse, error)
 	// ExchangeRates returns exchange rates of all pairs
 	ExchangeRates(context.Context, *QueryExchangeRatesRequest) (*QueryExchangeRatesResponse, error)
 	// Actives returns all active pairs
@@ -1332,9 +1277,6 @@ func (*UnimplementedQueryServer) ExchangeRate(ctx context.Context, req *QueryExc
 func (*UnimplementedQueryServer) ExchangeRateTwap(ctx context.Context, req *QueryExchangeRateRequest) (*QueryExchangeRateResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ExchangeRateTwap not implemented")
 }
-func (*UnimplementedQueryServer) DatedExchangeRate(ctx context.Context, req *QueryExchangeRateRequest) (*QueryDatedExchangeRateResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method DatedExchangeRate not implemented")
-}
 func (*UnimplementedQueryServer) ExchangeRates(ctx context.Context, req *QueryExchangeRatesRequest) (*QueryExchangeRatesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method ExchangeRates not implemented")
 }
@@ -1406,24 +1348,6 @@ func _Query_ExchangeRateTwap_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }
 
-func _Query_DatedExchangeRate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(QueryExchangeRateRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(QueryServer).DatedExchangeRate(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/nibiru.oracle.v1.Query/DatedExchangeRate",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(QueryServer).DatedExchangeRate(ctx, req.(*QueryExchangeRateRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _Query_ExchangeRates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryExchangeRatesRequest)
 	if err := dec(in); err != nil {
@@ -1616,10 +1540,6 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "ExchangeRateTwap",
 			Handler:    _Query_ExchangeRateTwap_Handler,
 		},
-		{
-			MethodName: "DatedExchangeRate",
-			Handler:    _Query_DatedExchangeRate_Handler,
-		},
 		{
 			MethodName: "ExchangeRates",
 			Handler:    _Query_ExchangeRates_Handler,
@@ -1718,6 +1638,16 @@ func (m *QueryExchangeRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	_ = i
 	var l int
 	_ = l
+	if m.BlockHeight != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.BlockHeight))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.BlockTimestampMs != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.BlockTimestampMs))
+		i--
+		dAtA[i] = 0x10
+	}
 	{
 		size := m.ExchangeRate.Size()
 		i -= size
@@ -1754,49 +1684,6 @@ func (m *QueryExchangeRatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, erro
 	return len(dAtA) - i, nil
 }
 
-func (m *QueryDatedExchangeRateResponse) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *QueryDatedExchangeRateResponse) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *QueryDatedExchangeRateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.BlockHeight != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.BlockHeight))
-		i--
-		dAtA[i] = 0x18
-	}
-	if m.BlockTimestampMs != 0 {
-		i = encodeVarintQuery(dAtA, i, uint64(m.BlockTimestampMs))
-		i--
-		dAtA[i] = 0x10
-	}
-	{
-		size := m.Price.Size()
-		i -= size
-		if _, err := m.Price.MarshalTo(dAtA[i:]); err != nil {
-			return 0, err
-		}
-		i = encodeVarintQuery(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0xa
-	return len(dAtA) - i, nil
-}
-
 func (m *QueryExchangeRatesResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2404,32 +2291,21 @@ func (m *QueryExchangeRateResponse) Size() (n int) {
 	_ = l
 	l = m.ExchangeRate.Size()
 	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
-func (m *QueryExchangeRatesRequest) Size() (n int) {
-	if m == nil {
-		return 0
+	if m.BlockTimestampMs != 0 {
+		n += 1 + sovQuery(uint64(m.BlockTimestampMs))
+	}
+	if m.BlockHeight != 0 {
+		n += 1 + sovQuery(uint64(m.BlockHeight))
 	}
-	var l int
-	_ = l
 	return n
 }
 
-func (m *QueryDatedExchangeRateResponse) Size() (n int) {
+func (m *QueryExchangeRatesRequest) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	l = m.Price.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	if m.BlockTimestampMs != 0 {
-		n += 1 + sovQuery(uint64(m.BlockTimestampMs))
-	}
-	if m.BlockHeight != 0 {
-		n += 1 + sovQuery(uint64(m.BlockHeight))
-	}
 	return n
 }
 
@@ -2816,56 +2692,44 @@ func (m *QueryExchangeRateResponse) Unmarshal(dAtA []byte) error {
 				return err
 			}
 			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipQuery(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockTimestampMs", wireType)
 			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *QueryExchangeRatesRequest) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowQuery
+			m.BlockTimestampMs = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockTimestampMs |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
 			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
+			m.BlockHeight = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.BlockHeight |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
 			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: QueryExchangeRatesRequest: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryExchangeRatesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
@@ -2887,7 +2751,7 @@ func (m *QueryExchangeRatesRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *QueryDatedExchangeRateResponse) Unmarshal(dAtA []byte) error {
+func (m *QueryExchangeRatesRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -2910,84 +2774,12 @@ func (m *QueryDatedExchangeRateResponse) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: QueryDatedExchangeRateResponse: wiretype end group for non-group")
+			return fmt.Errorf("proto: QueryExchangeRatesRequest: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: QueryDatedExchangeRateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: QueryExchangeRatesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Price", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthQuery
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthQuery
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if err := m.Price.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockTimestampMs", wireType)
-			}
-			m.BlockTimestampMs = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BlockTimestampMs |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 3:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field BlockHeight", wireType)
-			}
-			m.BlockHeight = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowQuery
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.BlockHeight |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
 		default:
 			iNdEx = preIndex
 			skippy, err := skipQuery(dAtA[iNdEx:])
diff --git a/x/oracle/types/query.pb.gw.go b/x/oracle/types/query.pb.gw.go
index c9436368d..f8af1a4f8 100644
--- a/x/oracle/types/query.pb.gw.go
+++ b/x/oracle/types/query.pb.gw.go
@@ -105,42 +105,6 @@ func local_request_Query_ExchangeRateTwap_0(ctx context.Context, marshaler runti
 
 }
 
-var (
-	filter_Query_DatedExchangeRate_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
-)
-
-func request_Query_DatedExchangeRate_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq QueryExchangeRateRequest
-	var metadata runtime.ServerMetadata
-
-	if err := req.ParseForm(); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DatedExchangeRate_0); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-
-	msg, err := client.DatedExchangeRate(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_Query_DatedExchangeRate_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq QueryExchangeRateRequest
-	var metadata runtime.ServerMetadata
-
-	if err := req.ParseForm(); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_DatedExchangeRate_0); err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-
-	msg, err := server.DatedExchangeRate(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
 func request_Query_ExchangeRates_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq QueryExchangeRatesRequest
 	var metadata runtime.ServerMetadata
@@ -517,29 +481,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
-	mux.Handle("GET", pattern_Query_DatedExchangeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_Query_DatedExchangeRate_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_Query_DatedExchangeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_Query_ExchangeRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -851,26 +792,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
-	mux.Handle("GET", pattern_Query_DatedExchangeRate_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_Query_DatedExchangeRate_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_Query_DatedExchangeRate_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	mux.Handle("GET", pattern_Query_ExchangeRates_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1079,8 +1000,6 @@ var (
 
 	pattern_Query_ExchangeRateTwap_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "oracle", "v1beta1", "exchange_rate_twap"}, "", runtime.AssumeColonVerbOpt(false)))
 
-	pattern_Query_DatedExchangeRate_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"nibiru", "oracle", "v1beta1", "dated_exchange_rate"}, "", runtime.AssumeColonVerbOpt(false)))
-
 	pattern_Query_ExchangeRates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"nibiru", "oracle", "v1beta1", "pairs", "exchange_rates"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_Actives_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"nibiru", "oracle", "v1beta1", "pairs", "actives"}, "", runtime.AssumeColonVerbOpt(false)))
@@ -1107,8 +1026,6 @@ var (
 
 	forward_Query_ExchangeRateTwap_0 = runtime.ForwardResponseMessage
 
-	forward_Query_DatedExchangeRate_0 = runtime.ForwardResponseMessage
-
 	forward_Query_ExchangeRates_0 = runtime.ForwardResponseMessage
 
 	forward_Query_Actives_0 = runtime.ForwardResponseMessage