From 9d9f7318da0e012367b388a8ec8819776a4585e2 Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Mon, 22 May 2023 16:23:13 -0500 Subject: [PATCH 1/9] single synth lock per lock ID --- proto/osmosis/lockup/query.proto | 14 +- x/lockup/client/cli/query.go | 10 +- x/lockup/keeper/grpc_query.go | 11 +- x/lockup/keeper/lock.go | 26 +- x/lockup/keeper/lock_test.go | 17 +- x/lockup/keeper/msg_server.go | 7 +- x/lockup/keeper/synthetic_lock.go | 47 +-- x/lockup/keeper/synthetic_lock_test.go | 40 ++- x/lockup/types/errors.go | 2 +- x/lockup/types/query.pb.go | 398 ++++++++++----------- x/lockup/types/query.pb.gw.go | 28 +- x/superfluid/keeper/export_test.go | 2 +- x/superfluid/keeper/migrate.go | 24 +- x/superfluid/keeper/migrate_test.go | 14 +- x/superfluid/keeper/stake.go | 16 +- x/superfluid/types/expected_keepers.go | 2 +- x/valset-pref/types/expected_interfaces.go | 2 +- x/valset-pref/validator_set.go | 7 +- 18 files changed, 348 insertions(+), 319 deletions(-) diff --git a/proto/osmosis/lockup/query.proto b/proto/osmosis/lockup/query.proto index e48433e8a97..de4d8ba5d68 100644 --- a/proto/osmosis/lockup/query.proto +++ b/proto/osmosis/lockup/query.proto @@ -88,11 +88,11 @@ service Query { option (google.api.http).get = "/osmosis/lockup/v1beta1/next_lock_id"; } - // Returns synthetic lockups by native lockup id - rpc SyntheticLockupsByLockupID(SyntheticLockupsByLockupIDRequest) - returns (SyntheticLockupsByLockupIDResponse) { + // Returns synthetic lockup by native lockup id + rpc SyntheticLockupByLockupID(SyntheticLockupByLockupIDRequest) + returns (SyntheticLockupByLockupIDResponse) { option (google.api.http).get = - "/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}"; + "/osmosis/lockup/v1beta1/synthetic_lockup_by_lock_id/{lock_id}"; } // Returns account locked records with longer duration @@ -247,9 +247,9 @@ message LockedResponse { PeriodLock lock = 1; }; message NextLockIDRequest {}; message NextLockIDResponse { uint64 lock_id = 1; }; -message SyntheticLockupsByLockupIDRequest { uint64 lock_id = 1; } -message SyntheticLockupsByLockupIDResponse { - repeated SyntheticLock synthetic_locks = 1 [ (gogoproto.nullable) = false ]; +message SyntheticLockupByLockupIDRequest { uint64 lock_id = 1; } +message SyntheticLockupByLockupIDResponse { + SyntheticLock synthetic_lock = 1 [ (gogoproto.nullable) = false ]; } message AccountLockedLongerDurationRequest { diff --git a/x/lockup/client/cli/query.go b/x/lockup/client/cli/query.go index 8041c88ef09..423a02a13b9 100644 --- a/x/lockup/client/cli/query.go +++ b/x/lockup/client/cli/query.go @@ -42,7 +42,7 @@ func GetQueryCmd() *cobra.Command { GetCmdAccountLockedLongerDurationNotUnlockingOnly(), GetCmdAccountLockedLongerDurationDenom(), GetCmdOutputLocksJson(), - GetCmdSyntheticLockupsByLockupID(), + GetCmdSyntheticLockupByLockupID(), GetCmdAccountLockedDuration(), GetCmdNextLockID(), osmocli.GetParams[*types.QueryParamsRequest]( @@ -199,11 +199,11 @@ func GetCmdNextLockID() *cobra.Command { `{{.Short}}`, types.ModuleName, types.NewQueryClient) } -// GetCmdSyntheticLockupsByLockupID returns synthetic lockups by lockup id. -func GetCmdSyntheticLockupsByLockupID() *cobra.Command { - return osmocli.SimpleQueryCmd[*types.SyntheticLockupsByLockupIDRequest]( +// GetCmdSyntheticLockupByLockupID returns synthetic lockup by lockup id. +func GetCmdSyntheticLockupByLockupID() *cobra.Command { + return osmocli.SimpleQueryCmd[*types.SyntheticLockupByLockupIDRequest]( "synthetic-lockups-by-lock-id ", - "Query synthetic lockups by lockup id", + "Query synthetic lock by underlying lockup id", `{{.Short}}`, types.ModuleName, types.NewQueryClient) } diff --git a/x/lockup/keeper/grpc_query.go b/x/lockup/keeper/grpc_query.go index f51d8ca952a..b61a322a605 100644 --- a/x/lockup/keeper/grpc_query.go +++ b/x/lockup/keeper/grpc_query.go @@ -177,15 +177,18 @@ func (q Querier) NextLockID(goCtx context.Context, req *types.NextLockIDRequest) return &types.NextLockIDResponse{LockId: nextLockID}, nil } -// SyntheticLockupsByLockupID returns synthetic lockups by native lockup id. -func (q Querier) SyntheticLockupsByLockupID(goCtx context.Context, req *types.SyntheticLockupsByLockupIDRequest) (*types.SyntheticLockupsByLockupIDResponse, error) { +// SyntheticLockupByLockupID returns synthetic lockup by native lockup id. +func (q Querier) SyntheticLockupByLockupID(goCtx context.Context, req *types.SyntheticLockupByLockupIDRequest) (*types.SyntheticLockupByLockupIDResponse, error) { if req == nil { return nil, status.Error(codes.InvalidArgument, "empty request") } ctx := sdk.UnwrapSDKContext(goCtx) - synthLocks := q.Keeper.GetAllSyntheticLockupsByLockup(ctx, req.LockId) - return &types.SyntheticLockupsByLockupIDResponse{SyntheticLocks: synthLocks}, nil + synthLock, err := q.Keeper.GetSyntheticLockupByUnderlyingLockId(ctx, req.LockId) + if err != nil { + return nil, err + } + return &types.SyntheticLockupByLockupIDResponse{SyntheticLock: synthLock}, nil } // AccountLockedLongerDuration returns locks of an account with duration longer than specified. diff --git a/x/lockup/keeper/lock.go b/x/lockup/keeper/lock.go index 16ec390dcba..ac6dd43ffbc 100644 --- a/x/lockup/keeper/lock.go +++ b/x/lockup/keeper/lock.go @@ -105,9 +105,11 @@ func (k Keeper) AddTokensToLockByID(ctx sdk.Context, lockID uint64, owner sdk.Ac return nil, err } - for _, synthlock := range k.GetAllSyntheticLockupsByLockup(ctx, lock.ID) { - k.accumulationStore(ctx, synthlock.SynthDenom).Increase(accumulationKey(synthlock.Duration), tokensToAdd.Amount) + synthlock, err := k.GetSyntheticLockupByUnderlyingLockId(ctx, lock.ID) + if err != nil { + return nil, err } + k.accumulationStore(ctx, synthlock.SynthDenom).Increase(accumulationKey(synthlock.Duration), tokensToAdd.Amount) if k.hooks == nil { return lock, nil @@ -375,15 +377,20 @@ func (k Keeper) PartialForceUnlock(ctx sdk.Context, lock types.PeriodLock, coins // ForceUnlock ignores unlock duration and immediately unlocks the lock and refunds tokens to lock owner. func (k Keeper) ForceUnlock(ctx sdk.Context, lock types.PeriodLock) error { // Steps: - // 1) Break associated synthetic locks. (Superfluid data) + // 1) Break associated synthetic lock. (Superfluid data) // 2) If lock is bonded, move it to unlocking // 3) Run logic to delete unlocking metadata, and send tokens to owner. - synthLocks := k.GetAllSyntheticLockupsByLockup(ctx, lock.ID) - err := k.DeleteAllSyntheticLocks(ctx, lock, synthLocks) + synthLock, err := k.GetSyntheticLockupByUnderlyingLockId(ctx, lock.ID) if err != nil { return err } + if synthLock != (types.SyntheticLock{}) { + err = k.DeleteSyntheticLockup(ctx, lock.ID, synthLock.SynthDenom) + if err != nil { + return err + } + } if !lock.IsUnlocking() { _, err := k.BeginUnlock(ctx, lock.ID, nil) @@ -727,13 +734,14 @@ func (k Keeper) removeTokensFromLock(ctx sdk.Context, lock *types.PeriodLock, co } // increase synthetic lockup's accumulation store - synthLocks := k.GetAllSyntheticLockupsByLockup(ctx, lock.ID) + synthLock, err := k.GetSyntheticLockupByUnderlyingLockId(ctx, lock.ID) + if err != nil { + return err + } // Note: since synthetic lockup deletion is using native lockup's coins to reduce accumulation store // all the synthetic lockups' accumulation should be decreased - for _, synthlock := range synthLocks { - k.accumulationStore(ctx, synthlock.SynthDenom).Decrease(accumulationKey(synthlock.Duration), coins[0].Amount) - } + k.accumulationStore(ctx, synthLock.SynthDenom).Decrease(accumulationKey(synthLock.Duration), coins[0].Amount) return nil } diff --git a/x/lockup/keeper/lock_test.go b/x/lockup/keeper/lock_test.go index c1433f60211..8808d732734 100644 --- a/x/lockup/keeper/lock_test.go +++ b/x/lockup/keeper/lock_test.go @@ -8,6 +8,7 @@ import ( cl "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity" cltypes "github.com/osmosis-labs/osmosis/v15/x/concentrated-liquidity/types" "github.com/osmosis-labs/osmosis/v15/x/lockup/types" + lockuptypes "github.com/osmosis-labs/osmosis/v15/x/lockup/types" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -852,11 +853,12 @@ func (s *KeeperTestSuite) AddTokensToLockForSynth() { for i, synthlock := range s.App.LockupKeeper.GetAllSyntheticLockups(s.Ctx) { s.Require().Equal(synthlock, synthlocks[i]) } - // by GetAllSyntheticLockupsByLockup + // by GetSyntheticLockupByUnderlyingLockId for i := uint64(1); i <= 3; i++ { - for j, synthlockByLockup := range s.App.LockupKeeper.GetAllSyntheticLockupsByLockup(s.Ctx, i) { - s.Require().Equal(synthlockByLockup, synthlocks[(int(i)-1)*3+j]) - } + synthlockByLockup, err := s.App.LockupKeeper.GetSyntheticLockupByUnderlyingLockId(s.Ctx, i) + s.Require().NoError(err) + s.Require().Equal(synthlockByLockup, synthlocks[(int(i)-1)*3+int(i)]) + } // by GetAllSyntheticLockupsByAddr for i, synthlock := range s.App.LockupKeeper.GetAllSyntheticLockupsByAddr(s.Ctx, addr1) { @@ -1313,9 +1315,10 @@ func (s *KeeperTestSuite) TestForceUnlock() { s.Require().Equal(balances, coinsToLock) // if it was superfluid delegated lock, - // confirm that we don't have associated synth locks - synthLocks := s.App.LockupKeeper.GetAllSyntheticLockupsByLockup(s.Ctx, lock.ID) - s.Require().Equal(0, len(synthLocks)) + // confirm that we don't have associated synth locks + synthLock, err := s.App.LockupKeeper.GetSyntheticLockupByUnderlyingLockId(s.Ctx, lock.ID) + s.Require().NoError(err) + s.Require().Equal((lockuptypes.SyntheticLock{}), synthLock) // check if lock is deleted by checking trying to get lock ID _, err = s.App.LockupKeeper.GetLockByID(s.Ctx, lock.ID) diff --git a/x/lockup/keeper/msg_server.go b/x/lockup/keeper/msg_server.go index 35755b464d6..0f5b912d09e 100644 --- a/x/lockup/keeper/msg_server.go +++ b/x/lockup/keeper/msg_server.go @@ -208,8 +208,11 @@ func (server msgServer) ForceUnlock(goCtx context.Context, msg *types.MsgForceUn } // check that given lock is not superfluid staked - synthLocks := server.keeper.GetAllSyntheticLockupsByLockup(ctx, lock.ID) - if len(synthLocks) > 0 { + synthLock, err := server.keeper.GetSyntheticLockupByUnderlyingLockId(ctx, lock.ID) + if err != nil { + return &types.MsgForceUnlockResponse{Success: false}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + } + if synthLock != (types.SyntheticLock{}) { return &types.MsgForceUnlockResponse{Success: false}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "superfluid delegation exists for lock") } diff --git a/x/lockup/keeper/synthetic_lock.go b/x/lockup/keeper/synthetic_lock.go index 5fb79401c55..828884b2955 100644 --- a/x/lockup/keeper/synthetic_lock.go +++ b/x/lockup/keeper/synthetic_lock.go @@ -36,8 +36,11 @@ func (k Keeper) GetSyntheticLockup(ctx sdk.Context, lockID uint64, synthdenom st return &synthLock, err } -// GetAllSyntheticLockupsByLockup gets all the synthetic lockup object of the original lockup. -func (k Keeper) GetAllSyntheticLockupsByLockup(ctx sdk.Context, lockID uint64) []types.SyntheticLock { +// GetSyntheticLockupByUnderlyingLockId gets the synthetic lockup object connected to the underlying lock ID. +// Error is returned if: +// - there are more than one synthetic lockup objects with the same underlying lock ID. +// - there is no synthetic lockup object with the given underlying lock ID. +func (k Keeper) GetSyntheticLockupByUnderlyingLockId(ctx sdk.Context, lockID uint64) (types.SyntheticLock, error) { store := ctx.KVStore(k.storeKey) iterator := sdk.KVStorePrefixIterator(store, combineKeys(types.KeyPrefixSyntheticLockup, sdk.Uint64ToBigEndian(lockID))) defer iterator.Close() @@ -47,11 +50,17 @@ func (k Keeper) GetAllSyntheticLockupsByLockup(ctx sdk.Context, lockID uint64) [ synthLock := types.SyntheticLock{} err := proto.Unmarshal(iterator.Value(), &synthLock) if err != nil { - panic(err) + return types.SyntheticLock{}, err } synthLocks = append(synthLocks, synthLock) } - return synthLocks + if len(synthLocks) > 1 { + return types.SyntheticLock{}, fmt.Errorf("synthetic lockup with same lock id should not exist") + } + if len(synthLocks) == 0 { + return types.SyntheticLock{}, nil + } + return synthLocks[0], nil } // GetAllSyntheticLockupsByAddr gets all the synthetic lockups from all the locks owned by the given address. @@ -59,7 +68,11 @@ func (k Keeper) GetAllSyntheticLockupsByAddr(ctx sdk.Context, owner sdk.AccAddre synthLocks := []types.SyntheticLock{} locks := k.GetAccountPeriodLocks(ctx, owner) for _, lock := range locks { - synthLocks = append(synthLocks, k.GetAllSyntheticLockupsByLockup(ctx, lock.ID)...) + synthLock, err := k.GetSyntheticLockupByUnderlyingLockId(ctx, lock.ID) + if err != nil { + panic(err) + } + synthLocks = append(synthLocks, synthLock) } return synthLocks } @@ -96,8 +109,11 @@ func (k Keeper) CreateSyntheticLockup(ctx sdk.Context, lockID uint64, synthDenom // There is no relationship between unbonding and bonding synthetic lockup, it's managed separately // A separate accumulation store is incremented with the synth denom. - _, err := k.GetSyntheticLockup(ctx, lockID, synthDenom) - if err == nil { + synthLock, err := k.GetSyntheticLockupByUnderlyingLockId(ctx, lockID) + if err != nil { + return err + } + if synthLock != (types.SyntheticLock{}) { return types.ErrSyntheticLockupAlreadyExists } @@ -115,7 +131,7 @@ func (k Keeper) CreateSyntheticLockup(ctx sdk.Context, lockID uint64, synthDenom } // set synthetic lockup object - synthLock := types.SyntheticLock{ + synthLock = types.SyntheticLock{ UnderlyingLockId: lockID, SynthDenom: synthDenom, EndTime: endTime, @@ -141,21 +157,6 @@ func (k Keeper) CreateSyntheticLockup(ctx sdk.Context, lockID uint64, synthDenom return nil } -// DeleteAllSyntheticLocks iterates over given array of synthetic locks and deletes all individual synthetic locks. -func (k Keeper) DeleteAllSyntheticLocks(ctx sdk.Context, lock types.PeriodLock, synthLocks []types.SyntheticLock) error { - if len(synthLocks) == 0 { - return nil - } - - for _, synthLock := range synthLocks { - err := k.DeleteSyntheticLockup(ctx, lock.ID, synthLock.SynthDenom) - if err != nil { - return err - } - } - return nil -} - // DeleteSyntheticLockup delete synthetic lockup with lock id and synthdenom. // Synthetic lock has three relevant state entries. // - synthetic lock object itself diff --git a/x/lockup/keeper/synthetic_lock_test.go b/x/lockup/keeper/synthetic_lock_test.go index 92781c184b6..14f6da566b9 100644 --- a/x/lockup/keeper/synthetic_lock_test.go +++ b/x/lockup/keeper/synthetic_lock_test.go @@ -4,6 +4,7 @@ import ( "time" "github.com/osmosis-labs/osmosis/v15/x/lockup/types" + lockuptypes "github.com/osmosis-labs/osmosis/v15/x/lockup/types" sdk "github.com/cosmos/cosmos-sdk/types" ) @@ -15,12 +16,16 @@ func (s *KeeperTestSuite) TestSyntheticLockupCreation() { addr1 := sdk.AccAddress([]byte("addr1---------------")) coins := sdk.Coins{sdk.NewInt64Coin("stake", 10)} s.LockTokens(addr1, coins, time.Second) + s.LockTokens(addr1, coins, time.Second) + s.LockTokens(addr1, coins, time.Second) // check locks locks, err := s.App.LockupKeeper.GetPeriodLocks(s.Ctx) s.Require().NoError(err) - s.Require().Len(locks, 1) + s.Require().Len(locks, 3) s.Require().Equal(locks[0].Coins, coins) + s.Require().Equal(locks[1].Coins, coins) + s.Require().Equal(locks[2].Coins, coins) // create not unbonding synthetic lockup err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "suffix1", time.Second, false) @@ -30,12 +35,16 @@ func (s *KeeperTestSuite) TestSyntheticLockupCreation() { err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "suffix1", time.Second, true) s.Require().Error(err) - // create unbonding synthetic lockup + // create unbonding synthetic lockup, lock already has a synthetic lock associated with it so it should fail err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "suffix2", time.Second, true) + s.Require().Error(err) + + // create unbonding synthetic lockup with new lock id, should succeed + err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 2, "suffix2", time.Second, true) s.Require().NoError(err) // try creating unbonding synthetic lockup that is long than native lockup unbonding duration - err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "suffix3", time.Second*2, true) + err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 3, "suffix3", time.Second*2, true) s.Require().Error(err) } @@ -127,12 +136,13 @@ func (s *KeeperTestSuite) TestSyntheticLockupCreateGetDeleteAccumulation() { Duration: time.Second, }) - expectedSynthLocks := []types.SyntheticLock{*synthLock} - synthLocks := s.App.LockupKeeper.GetAllSyntheticLockupsByLockup(s.Ctx, 1) - s.Require().Equal(synthLocks, expectedSynthLocks) + expectedSynthLock := *synthLock + actualSynthLock, err := s.App.LockupKeeper.GetSyntheticLockupByUnderlyingLockId(s.Ctx, 1) + s.Require().NoError(err) + s.Require().Equal(expectedSynthLock, actualSynthLock) - synthLocks = s.App.LockupKeeper.GetAllSyntheticLockups(s.Ctx) - s.Require().Equal(synthLocks, expectedSynthLocks) + allSynthLocks := s.App.LockupKeeper.GetAllSyntheticLockups(s.Ctx) + s.Require().Equal([]lockuptypes.SyntheticLock{expectedSynthLock}, allSynthLocks) // check accumulation store is correctly updated for synthetic lockup accum = s.App.LockupKeeper.GetPeriodLocksAccumulation(s.Ctx, types.QueryCondition{ @@ -216,17 +226,19 @@ func (s *KeeperTestSuite) TestSyntheticLockupDeleteAllMaturedSyntheticLocks() { addr1 := sdk.AccAddress([]byte("addr1---------------")) coins := sdk.Coins{sdk.NewInt64Coin("stake", 10)} s.LockTokens(addr1, coins, time.Second) + s.LockTokens(addr1, coins, time.Second) // check locks locks, err := s.App.LockupKeeper.GetPeriodLocks(s.Ctx) s.Require().NoError(err) - s.Require().Len(locks, 1) + s.Require().Len(locks, 2) s.Require().Equal(locks[0].Coins, coins) + s.Require().Equal(locks[1].Coins, coins) err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator1", time.Second, false) s.Require().NoError(err) - err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator2", time.Second, true) + err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 2, "synthstakestakedtovalidator2", time.Second, true) s.Require().NoError(err) synthLock, err := s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator1") @@ -237,10 +249,10 @@ func (s *KeeperTestSuite) TestSyntheticLockupDeleteAllMaturedSyntheticLocks() { EndTime: time.Time{}, Duration: time.Second, }) - synthLock, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator2") + synthLock, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 2, "synthstakestakedtovalidator2") s.Require().NoError(err) s.Require().Equal(*synthLock, types.SyntheticLock{ - UnderlyingLockId: 1, + UnderlyingLockId: 2, SynthDenom: "synthstakestakedtovalidator2", EndTime: s.Ctx.BlockTime().Add(time.Second), Duration: time.Second, @@ -250,7 +262,7 @@ func (s *KeeperTestSuite) TestSyntheticLockupDeleteAllMaturedSyntheticLocks() { _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator1") s.Require().NoError(err) - _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator2") + _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 2, "synthstakestakedtovalidator2") s.Require().NoError(err) s.Ctx = s.Ctx.WithBlockTime(s.Ctx.BlockTime().Add(time.Second * 2)) @@ -258,7 +270,7 @@ func (s *KeeperTestSuite) TestSyntheticLockupDeleteAllMaturedSyntheticLocks() { _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator1") s.Require().NoError(err) - _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator2") + _, err = s.App.LockupKeeper.GetSyntheticLockup(s.Ctx, 2, "synthstakestakedtovalidator2") s.Require().Error(err) } diff --git a/x/lockup/types/errors.go b/x/lockup/types/errors.go index ee98a1ff567..5a16cbada2e 100644 --- a/x/lockup/types/errors.go +++ b/x/lockup/types/errors.go @@ -9,7 +9,7 @@ import ( // x/lockup module sentinel errors. var ( ErrNotLockOwner = errorsmod.Register(ModuleName, 1, "msg sender is not the owner of specified lock") - ErrSyntheticLockupAlreadyExists = errorsmod.Register(ModuleName, 2, "synthetic lockup already exists for same lock and suffix") + ErrSyntheticLockupAlreadyExists = errorsmod.Register(ModuleName, 2, "synthetic lockup already exists for same lock") ErrSyntheticDurationLongerThanNative = errorsmod.Register(ModuleName, 3, "synthetic lockup duration should be shorter than native lockup duration") ErrLockupNotFound = errorsmod.Register(ModuleName, 4, "lockup not found") ) diff --git a/x/lockup/types/query.pb.go b/x/lockup/types/query.pb.go index b8312026eb5..73de31a2c2a 100644 --- a/x/lockup/types/query.pb.go +++ b/x/lockup/types/query.pb.go @@ -1116,22 +1116,22 @@ func (m *NextLockIDResponse) GetLockId() uint64 { return 0 } -type SyntheticLockupsByLockupIDRequest struct { +type SyntheticLockupByLockupIDRequest struct { LockId uint64 `protobuf:"varint,1,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"` } -func (m *SyntheticLockupsByLockupIDRequest) Reset() { *m = SyntheticLockupsByLockupIDRequest{} } -func (m *SyntheticLockupsByLockupIDRequest) String() string { return proto.CompactTextString(m) } -func (*SyntheticLockupsByLockupIDRequest) ProtoMessage() {} -func (*SyntheticLockupsByLockupIDRequest) Descriptor() ([]byte, []int) { +func (m *SyntheticLockupByLockupIDRequest) Reset() { *m = SyntheticLockupByLockupIDRequest{} } +func (m *SyntheticLockupByLockupIDRequest) String() string { return proto.CompactTextString(m) } +func (*SyntheticLockupByLockupIDRequest) ProtoMessage() {} +func (*SyntheticLockupByLockupIDRequest) Descriptor() ([]byte, []int) { return fileDescriptor_e906fda01cffd91a, []int{24} } -func (m *SyntheticLockupsByLockupIDRequest) XXX_Unmarshal(b []byte) error { +func (m *SyntheticLockupByLockupIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyntheticLockupsByLockupIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SyntheticLockupByLockupIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyntheticLockupsByLockupIDRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_SyntheticLockupByLockupIDRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1141,41 +1141,41 @@ func (m *SyntheticLockupsByLockupIDRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *SyntheticLockupsByLockupIDRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyntheticLockupsByLockupIDRequest.Merge(m, src) +func (m *SyntheticLockupByLockupIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyntheticLockupByLockupIDRequest.Merge(m, src) } -func (m *SyntheticLockupsByLockupIDRequest) XXX_Size() int { +func (m *SyntheticLockupByLockupIDRequest) XXX_Size() int { return m.Size() } -func (m *SyntheticLockupsByLockupIDRequest) XXX_DiscardUnknown() { - xxx_messageInfo_SyntheticLockupsByLockupIDRequest.DiscardUnknown(m) +func (m *SyntheticLockupByLockupIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SyntheticLockupByLockupIDRequest.DiscardUnknown(m) } -var xxx_messageInfo_SyntheticLockupsByLockupIDRequest proto.InternalMessageInfo +var xxx_messageInfo_SyntheticLockupByLockupIDRequest proto.InternalMessageInfo -func (m *SyntheticLockupsByLockupIDRequest) GetLockId() uint64 { +func (m *SyntheticLockupByLockupIDRequest) GetLockId() uint64 { if m != nil { return m.LockId } return 0 } -type SyntheticLockupsByLockupIDResponse struct { - SyntheticLocks []SyntheticLock `protobuf:"bytes,1,rep,name=synthetic_locks,json=syntheticLocks,proto3" json:"synthetic_locks"` +type SyntheticLockupByLockupIDResponse struct { + SyntheticLock SyntheticLock `protobuf:"bytes,1,opt,name=synthetic_lock,json=syntheticLock,proto3" json:"synthetic_lock"` } -func (m *SyntheticLockupsByLockupIDResponse) Reset() { *m = SyntheticLockupsByLockupIDResponse{} } -func (m *SyntheticLockupsByLockupIDResponse) String() string { return proto.CompactTextString(m) } -func (*SyntheticLockupsByLockupIDResponse) ProtoMessage() {} -func (*SyntheticLockupsByLockupIDResponse) Descriptor() ([]byte, []int) { +func (m *SyntheticLockupByLockupIDResponse) Reset() { *m = SyntheticLockupByLockupIDResponse{} } +func (m *SyntheticLockupByLockupIDResponse) String() string { return proto.CompactTextString(m) } +func (*SyntheticLockupByLockupIDResponse) ProtoMessage() {} +func (*SyntheticLockupByLockupIDResponse) Descriptor() ([]byte, []int) { return fileDescriptor_e906fda01cffd91a, []int{25} } -func (m *SyntheticLockupsByLockupIDResponse) XXX_Unmarshal(b []byte) error { +func (m *SyntheticLockupByLockupIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *SyntheticLockupsByLockupIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *SyntheticLockupByLockupIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_SyntheticLockupsByLockupIDResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_SyntheticLockupByLockupIDResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1185,23 +1185,23 @@ func (m *SyntheticLockupsByLockupIDResponse) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *SyntheticLockupsByLockupIDResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_SyntheticLockupsByLockupIDResponse.Merge(m, src) +func (m *SyntheticLockupByLockupIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyntheticLockupByLockupIDResponse.Merge(m, src) } -func (m *SyntheticLockupsByLockupIDResponse) XXX_Size() int { +func (m *SyntheticLockupByLockupIDResponse) XXX_Size() int { return m.Size() } -func (m *SyntheticLockupsByLockupIDResponse) XXX_DiscardUnknown() { - xxx_messageInfo_SyntheticLockupsByLockupIDResponse.DiscardUnknown(m) +func (m *SyntheticLockupByLockupIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SyntheticLockupByLockupIDResponse.DiscardUnknown(m) } -var xxx_messageInfo_SyntheticLockupsByLockupIDResponse proto.InternalMessageInfo +var xxx_messageInfo_SyntheticLockupByLockupIDResponse proto.InternalMessageInfo -func (m *SyntheticLockupsByLockupIDResponse) GetSyntheticLocks() []SyntheticLock { +func (m *SyntheticLockupByLockupIDResponse) GetSyntheticLock() SyntheticLock { if m != nil { - return m.SyntheticLocks + return m.SyntheticLock } - return nil + return SyntheticLock{} } type AccountLockedLongerDurationRequest struct { @@ -1713,8 +1713,8 @@ func init() { proto.RegisterType((*LockedResponse)(nil), "osmosis.lockup.LockedResponse") proto.RegisterType((*NextLockIDRequest)(nil), "osmosis.lockup.NextLockIDRequest") proto.RegisterType((*NextLockIDResponse)(nil), "osmosis.lockup.NextLockIDResponse") - proto.RegisterType((*SyntheticLockupsByLockupIDRequest)(nil), "osmosis.lockup.SyntheticLockupsByLockupIDRequest") - proto.RegisterType((*SyntheticLockupsByLockupIDResponse)(nil), "osmosis.lockup.SyntheticLockupsByLockupIDResponse") + proto.RegisterType((*SyntheticLockupByLockupIDRequest)(nil), "osmosis.lockup.SyntheticLockupByLockupIDRequest") + proto.RegisterType((*SyntheticLockupByLockupIDResponse)(nil), "osmosis.lockup.SyntheticLockupByLockupIDResponse") proto.RegisterType((*AccountLockedLongerDurationRequest)(nil), "osmosis.lockup.AccountLockedLongerDurationRequest") proto.RegisterType((*AccountLockedLongerDurationResponse)(nil), "osmosis.lockup.AccountLockedLongerDurationResponse") proto.RegisterType((*AccountLockedDurationRequest)(nil), "osmosis.lockup.AccountLockedDurationRequest") @@ -1730,104 +1730,103 @@ func init() { func init() { proto.RegisterFile("osmosis/lockup/query.proto", fileDescriptor_e906fda01cffd91a) } var fileDescriptor_e906fda01cffd91a = []byte{ - // 1541 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x93, 0x13, 0xd5, - 0x16, 0x9f, 0x0b, 0xcc, 0xbc, 0xc7, 0xe1, 0xf1, 0xf1, 0x2e, 0x03, 0x6f, 0xa6, 0x07, 0x92, 0xa1, - 0x81, 0x79, 0x51, 0x27, 0xdd, 0xcc, 0x80, 0x80, 0xd4, 0xf0, 0x15, 0x46, 0xac, 0xd1, 0x88, 0x10, - 0x50, 0xca, 0xaf, 0x4a, 0x75, 0x92, 0x4b, 0xe8, 0x22, 0xe9, 0x1b, 0xd2, 0x1d, 0x24, 0x52, 0x88, - 0x82, 0x4b, 0x17, 0x58, 0x6e, 0x2c, 0x17, 0x96, 0xba, 0xd3, 0x85, 0xe5, 0xc6, 0x05, 0xe5, 0xde, - 0xa2, 0xb4, 0xca, 0xa2, 0xca, 0x8d, 0xe5, 0x62, 0xb0, 0x18, 0xff, 0x02, 0x56, 0x2e, 0xad, 0xbe, - 0xf7, 0x76, 0x4f, 0xfa, 0x33, 0x9d, 0x44, 0xa6, 0x66, 0x35, 0x93, 0x3e, 0xe7, 0x9e, 0xf3, 0xfb, - 0x9d, 0x7b, 0xfa, 0x9e, 0xfb, 0x6b, 0x90, 0xa8, 0x59, 0xa7, 0xa6, 0x6e, 0xaa, 0x35, 0x5a, 0xbe, - 0xd2, 0x6a, 0xa8, 0x57, 0x5b, 0xa4, 0xd9, 0x56, 0x1a, 0x4d, 0x6a, 0x51, 0xbc, 0x49, 0xd8, 0x14, - 0x6e, 0x93, 0x46, 0xab, 0xb4, 0x4a, 0x99, 0x49, 0xb5, 0xff, 0xe3, 0x5e, 0x52, 0xaa, 0xcc, 0xdc, - 0xd4, 0x92, 0x66, 0x12, 0xf5, 0xda, 0x4c, 0x89, 0x58, 0xda, 0x8c, 0x5a, 0xa6, 0xba, 0x21, 0xec, - 0x3b, 0xaa, 0x94, 0x56, 0x6b, 0x44, 0xd5, 0x1a, 0xba, 0xaa, 0x19, 0x06, 0xb5, 0x34, 0x4b, 0xa7, - 0x86, 0x29, 0xac, 0x69, 0x61, 0x65, 0xbf, 0x4a, 0xad, 0x4b, 0xaa, 0xa5, 0xd7, 0x89, 0x69, 0x69, - 0xf5, 0x86, 0x13, 0xde, 0xef, 0x50, 0x69, 0x35, 0x59, 0x04, 0x61, 0x1f, 0xf7, 0x11, 0xb0, 0xff, - 0x08, 0xd3, 0x84, 0xcf, 0xd4, 0xd0, 0x9a, 0x5a, 0x5d, 0x24, 0x96, 0xb7, 0xc3, 0xe8, 0xcb, 0xb4, - 0xd2, 0xaa, 0x91, 0x9c, 0x56, 0xd3, 0x8c, 0x32, 0x29, 0x90, 0xab, 0x2d, 0x62, 0x5a, 0xf2, 0xbb, - 0xb0, 0xcd, 0xf7, 0xdc, 0x6c, 0x50, 0xc3, 0x24, 0x58, 0x83, 0x61, 0x9b, 0x95, 0x39, 0x86, 0x26, - 0xd7, 0x66, 0x36, 0xcc, 0x8e, 0x2b, 0x9c, 0xb7, 0x62, 0xf3, 0x56, 0x04, 0x6f, 0xe5, 0x14, 0xd5, - 0x8d, 0xdc, 0xbe, 0xfb, 0x8b, 0xe9, 0xa1, 0x6f, 0x1e, 0xa6, 0x33, 0x55, 0xdd, 0xba, 0xdc, 0x2a, - 0x29, 0x65, 0x5a, 0x57, 0x45, 0x91, 0xf8, 0x9f, 0xac, 0x59, 0xb9, 0xa2, 0x5a, 0xed, 0x06, 0x31, - 0xd9, 0x02, 0xb3, 0xc0, 0x23, 0xcb, 0x13, 0x30, 0xce, 0x73, 0xe7, 0x69, 0xf9, 0x0a, 0xa9, 0x9c, - 0xac, 0xd3, 0x96, 0x61, 0x39, 0xc0, 0x6e, 0x81, 0x14, 0x66, 0x5c, 0x39, 0x74, 0x2f, 0xc0, 0xce, - 0x93, 0xe5, 0xb2, 0x9d, 0xf5, 0x55, 0xc3, 0xae, 0xa8, 0x56, 0xaa, 0x11, 0xee, 0xc0, 0x11, 0xe2, - 0x29, 0x18, 0xa6, 0xef, 0x18, 0xa4, 0x39, 0x86, 0x26, 0x51, 0x66, 0x7d, 0x6e, 0xcb, 0xe3, 0xc5, - 0xf4, 0x7f, 0xda, 0x5a, 0xbd, 0x76, 0x44, 0x66, 0x8f, 0xe5, 0x02, 0x37, 0xcb, 0x77, 0x10, 0xa4, - 0xa2, 0x22, 0xad, 0x1c, 0x9d, 0xd3, 0xb0, 0xc3, 0x03, 0x42, 0x37, 0xaa, 0x7d, 0xb1, 0xb9, 0x8d, - 0x7c, 0x75, 0x59, 0x0e, 0xb4, 0x72, 0x64, 0x4e, 0xc1, 0xb8, 0xc0, 0xc0, 0xbb, 0xa3, 0x2f, 0x26, - 0xb7, 0x40, 0x0a, 0x0b, 0xb2, 0x72, 0x2c, 0x3e, 0x47, 0xee, 0x9e, 0x70, 0x04, 0x67, 0x35, 0xd3, - 0xba, 0xa0, 0xd7, 0x49, 0x8f, 0x4c, 0xf0, 0x6b, 0xb0, 0xde, 0x3d, 0x47, 0xc6, 0xd6, 0x4c, 0xa2, - 0xcc, 0x86, 0x59, 0x49, 0xe1, 0x07, 0x89, 0xe2, 0x1c, 0x24, 0xca, 0x05, 0xc7, 0x23, 0xb7, 0xc3, - 0x06, 0xfc, 0x78, 0x31, 0xbd, 0x85, 0xc7, 0x72, 0x97, 0xca, 0x77, 0x1f, 0xa6, 0x51, 0x61, 0x39, - 0x94, 0x7c, 0xd1, 0xdd, 0x6a, 0x3f, 0x3e, 0x51, 0xa4, 0x83, 0x30, 0x6c, 0xb7, 0x80, 0x53, 0x24, - 0x49, 0xf1, 0x1e, 0xa1, 0xca, 0x59, 0xd2, 0xd4, 0x69, 0xc5, 0x5e, 0x9c, 0x5b, 0x67, 0x27, 0x2d, - 0x70, 0x77, 0xf9, 0x5b, 0x04, 0xd3, 0xa1, 0x91, 0xcf, 0xd0, 0xe5, 0xae, 0x7a, 0xc5, 0xa8, 0xb5, - 0x57, 0x4b, 0x25, 0xaa, 0x90, 0x4d, 0x88, 0x77, 0xc0, 0xca, 0x7c, 0x85, 0x60, 0xd2, 0xf3, 0x7a, - 0x91, 0x4a, 0x8e, 0x5c, 0xa2, 0x4d, 0xb2, 0x9a, 0xfa, 0xe2, 0x4d, 0xd8, 0x15, 0x83, 0x71, 0xc0, - 0x0a, 0xdc, 0x43, 0x6e, 0x74, 0x6f, 0xad, 0xe7, 0x89, 0x41, 0xeb, 0xab, 0xa4, 0x04, 0x78, 0x14, - 0x86, 0x2b, 0x36, 0x9e, 0xb1, 0xb5, 0x76, 0xfe, 0x02, 0xff, 0x21, 0xbf, 0x05, 0x72, 0x1c, 0xf4, - 0x01, 0x2b, 0xf3, 0x1e, 0x60, 0x1e, 0xd6, 0x53, 0x09, 0x17, 0x09, 0xea, 0x40, 0x82, 0x0b, 0xf0, - 0x6f, 0xe7, 0xe6, 0x20, 0x68, 0x8f, 0x07, 0x68, 0xcf, 0x0b, 0x87, 0xdc, 0x84, 0x60, 0xbd, 0x99, - 0xb3, 0x76, 0x16, 0xca, 0x9f, 0xda, 0xa4, 0xdd, 0x38, 0xb2, 0x01, 0x5b, 0x3d, 0xf9, 0x05, 0x9d, - 0x8b, 0x30, 0xa2, 0xb1, 0xe9, 0x2c, 0xf6, 0xe2, 0xb8, 0x1d, 0xed, 0xf7, 0xc5, 0xf4, 0x54, 0x82, - 0xf3, 0x70, 0xc1, 0xb0, 0x1e, 0x2f, 0xa6, 0x37, 0xf2, 0xbc, 0x3c, 0x8a, 0x5c, 0x10, 0xe1, 0xe4, - 0x0c, 0x6c, 0xe4, 0xf9, 0x1c, 0xaa, 0xff, 0x83, 0x7f, 0xd9, 0x95, 0x28, 0xea, 0x15, 0x96, 0x6a, - 0x5d, 0x61, 0xc4, 0xfe, 0xb9, 0x50, 0x91, 0x4f, 0xc0, 0x26, 0xc7, 0x53, 0x80, 0x52, 0x60, 0x9d, - 0x6d, 0x63, 0x7e, 0xb1, 0x25, 0x2e, 0x30, 0x3f, 0x79, 0x2b, 0xfc, 0xf7, 0x0c, 0xb9, 0xce, 0xb6, - 0x6d, 0x61, 0xde, 0xb9, 0x83, 0x64, 0x01, 0x77, 0x3e, 0x14, 0xa1, 0x23, 0x51, 0xcc, 0xc1, 0xae, - 0xf3, 0x6d, 0xc3, 0xba, 0x4c, 0x2c, 0xbd, 0x9c, 0x67, 0x79, 0xcc, 0x5c, 0x9b, 0xff, 0xe3, 0xc6, - 0x8c, 0x5e, 0xdd, 0x04, 0x39, 0x6e, 0xb5, 0x48, 0x9e, 0x87, 0xcd, 0xa6, 0xe3, 0x55, 0xec, 0xec, - 0xa2, 0x9d, 0x7e, 0x8a, 0x9e, 0x60, 0xa2, 0x91, 0x36, 0x99, 0x9d, 0x0f, 0x4d, 0xf9, 0x0b, 0xe4, - 0x6b, 0xd8, 0x3c, 0x35, 0xaa, 0xa4, 0xe9, 0x34, 0x46, 0xaf, 0x2f, 0xdb, 0x93, 0x68, 0xba, 0xb7, - 0x61, 0x77, 0x2c, 0xc2, 0x01, 0xdf, 0xa9, 0xcf, 0xfc, 0x33, 0x78, 0x35, 0x71, 0xf7, 0xcf, 0xdf, - 0x7f, 0x8c, 0xf5, 0x77, 0x08, 0x66, 0x63, 0xaa, 0x3a, 0xe8, 0x14, 0x7e, 0x12, 0xb5, 0xa8, 0xc3, - 0xfe, 0x9e, 0x10, 0x0f, 0x58, 0xa1, 0x1f, 0x10, 0xfc, 0x3f, 0x26, 0x5f, 0x5f, 0xb3, 0xe8, 0x09, - 0x94, 0x25, 0x62, 0x0e, 0x95, 0x20, 0xd3, 0x1d, 0xfc, 0x80, 0x15, 0x1a, 0x05, 0x7c, 0xce, 0x56, - 0xcf, 0x67, 0x99, 0xcc, 0x74, 0x8e, 0xcc, 0x97, 0x60, 0xab, 0xe7, 0xa9, 0x48, 0x72, 0x00, 0x46, - 0xb8, 0x1c, 0x15, 0x07, 0xf2, 0xf6, 0x40, 0x16, 0x66, 0x15, 0x19, 0x84, 0xef, 0xec, 0xfb, 0x12, - 0x0c, 0xb3, 0x68, 0xf8, 0x23, 0x04, 0x1b, 0x3d, 0x3a, 0x15, 0xef, 0xf1, 0x47, 0x08, 0x93, 0xb7, - 0xd2, 0xde, 0x2e, 0x5e, 0x1c, 0x9e, 0xac, 0xdc, 0xfe, 0xf5, 0xcf, 0x4f, 0xd6, 0x64, 0xf0, 0x94, - 0xea, 0xd3, 0xd0, 0x8e, 0xc0, 0xaf, 0xb3, 0x65, 0xc5, 0x92, 0x48, 0xfe, 0x25, 0x02, 0x1c, 0x54, - 0xa7, 0xf8, 0xa9, 0xf0, 0x6c, 0x21, 0xf2, 0x56, 0x7a, 0x3a, 0x89, 0xab, 0x40, 0x77, 0x80, 0xa1, - 0x53, 0xf0, 0x74, 0x17, 0x74, 0xfc, 0x2a, 0x56, 0xe4, 0xd3, 0x13, 0xdf, 0x43, 0xb0, 0x3d, 0x5c, - 0x76, 0xe2, 0xac, 0x3f, 0x79, 0xac, 0xd0, 0x95, 0x94, 0xa4, 0xee, 0x02, 0xef, 0x09, 0x86, 0xf7, - 0x08, 0x3e, 0x1c, 0x85, 0x57, 0xe3, 0xeb, 0x8b, 0x2d, 0x37, 0x40, 0x91, 0x29, 0x22, 0xf5, 0x06, - 0x7b, 0x51, 0x6e, 0xe2, 0xef, 0x11, 0x6c, 0x0b, 0x15, 0x99, 0x78, 0x3a, 0x16, 0x8b, 0x4f, 0xd4, - 0x4a, 0xd9, 0x84, 0xde, 0x02, 0xf8, 0x71, 0x06, 0xfc, 0x39, 0x7c, 0x28, 0x19, 0x70, 0xdd, 0xa8, - 0xfa, 0x70, 0x7f, 0x8d, 0x00, 0x07, 0x35, 0x65, 0xb0, 0x2f, 0x22, 0xc5, 0x6b, 0xb0, 0x2f, 0xa2, - 0x25, 0xaa, 0x3c, 0xc7, 0xe0, 0x1e, 0xc4, 0x07, 0xba, 0xc1, 0x15, 0x8d, 0x11, 0x59, 0x63, 0xef, - 0x65, 0x35, 0xb2, 0xc6, 0xa1, 0x22, 0x35, 0xb2, 0xc6, 0xe1, 0x92, 0x31, 0x79, 0x8d, 0x05, 0xe8, - 0x86, 0x66, 0x5a, 0xf6, 0xb5, 0xdb, 0xc5, 0xfd, 0x17, 0x82, 0xbd, 0x89, 0xb4, 0x18, 0x9e, 0x4b, - 0x84, 0x2c, 0x62, 0xd8, 0x49, 0x47, 0xfb, 0x5c, 0x2d, 0x78, 0x16, 0x18, 0xcf, 0x3c, 0x7e, 0xb1, - 0x47, 0x9e, 0x45, 0x83, 0x76, 0xf6, 0x17, 0x35, 0x6a, 0x6d, 0x97, 0xfa, 0x8f, 0xc8, 0xfd, 0xee, - 0x11, 0x14, 0x5e, 0x78, 0x5f, 0x6c, 0xb3, 0x87, 0xe8, 0x48, 0x69, 0xa6, 0x87, 0x15, 0x82, 0xd6, - 0x3c, 0xa3, 0x75, 0x0c, 0xcf, 0x25, 0x7b, 0x45, 0x48, 0xa5, 0x58, 0x62, 0x41, 0x8a, 0x9e, 0x3d, - 0xfc, 0x09, 0xf9, 0xbe, 0xbd, 0x78, 0x84, 0x12, 0x9e, 0x49, 0x54, 0xfa, 0xce, 0x19, 0x2c, 0xcd, - 0xf6, 0xb2, 0x44, 0x70, 0x79, 0x9e, 0x71, 0x39, 0x8e, 0x8f, 0xf6, 0xba, 0x45, 0x6c, 0xc8, 0xba, - 0x64, 0x3e, 0x44, 0xb0, 0xa1, 0x43, 0x17, 0x61, 0xd9, 0x0f, 0x25, 0x28, 0xda, 0xa4, 0xdd, 0xb1, - 0x3e, 0x02, 0xdf, 0x34, 0xc3, 0x37, 0x85, 0xf7, 0x44, 0xe1, 0x13, 0xb8, 0xb8, 0xe2, 0xbb, 0x83, - 0x00, 0x78, 0x94, 0x5c, 0x7b, 0x61, 0x1e, 0xef, 0x0c, 0xcf, 0xe0, 0x00, 0x48, 0x45, 0x99, 0x45, - 0xee, 0x83, 0x2c, 0xf7, 0x3e, 0xac, 0x74, 0xc9, 0x5d, 0x6a, 0x17, 0xf5, 0x8a, 0x7a, 0x43, 0x48, - 0x9a, 0x9b, 0xf8, 0x03, 0x04, 0xb0, 0xac, 0x99, 0xf0, 0x2e, 0x7f, 0x9a, 0x80, 0xc8, 0x92, 0xe4, - 0x38, 0x97, 0xa4, 0x95, 0x30, 0xc8, 0x75, 0xbe, 0x4d, 0x45, 0xbd, 0x82, 0x7f, 0x46, 0x20, 0x45, - 0x4b, 0xa9, 0x60, 0x77, 0x75, 0x15, 0x6d, 0xc1, 0xee, 0xea, 0xae, 0xd4, 0xe4, 0xd3, 0x0c, 0xf3, - 0x09, 0x7c, 0x2c, 0x0a, 0xb3, 0x57, 0xc7, 0xb5, 0x1a, 0xa6, 0x5d, 0x4c, 0xc1, 0xa1, 0xa3, 0xa2, - 0xbf, 0x20, 0x98, 0x88, 0xb9, 0xcc, 0xe1, 0xf8, 0xce, 0x0f, 0x15, 0x74, 0xd2, 0xfe, 0x9e, 0xd6, - 0x24, 0x25, 0xe4, 0x7b, 0x5d, 0x6a, 0x2c, 0x4c, 0xd1, 0xb9, 0xaa, 0x46, 0x0f, 0x1e, 0x97, 0x4a, - 0xfc, 0xe0, 0xf1, 0x93, 0xc8, 0x26, 0xf4, 0xee, 0x73, 0xf0, 0x04, 0x70, 0x7f, 0xbc, 0x06, 0x9e, - 0xe9, 0x41, 0x82, 0xe0, 0x5c, 0x0f, 0x45, 0x8e, 0x1a, 0x42, 0xa7, 0x06, 0x8a, 0x21, 0x98, 0xbf, - 0xce, 0x98, 0x9f, 0xc7, 0xe7, 0xfa, 0xdb, 0xb8, 0xb8, 0x89, 0xb4, 0xb4, 0xfc, 0xb9, 0x32, 0x52, - 0x69, 0xe0, 0x43, 0x3d, 0x90, 0xf0, 0x9c, 0x92, 0x87, 0x7b, 0x5f, 0x28, 0x28, 0xe7, 0x19, 0xe5, - 0xd3, 0x78, 0xbe, 0x4f, 0xca, 0xde, 0x13, 0xbe, 0x0d, 0x23, 0x5c, 0x9f, 0x04, 0xcf, 0xf6, 0xa0, - 0x04, 0x0a, 0x9e, 0xed, 0x21, 0x82, 0x48, 0x9e, 0x62, 0x00, 0x27, 0x71, 0x2a, 0x0a, 0x20, 0x97, - 0x40, 0xb9, 0xfc, 0xfd, 0x47, 0x29, 0xf4, 0xe0, 0x51, 0x0a, 0xfd, 0xf1, 0x28, 0x85, 0xee, 0x2e, - 0xa5, 0x86, 0x1e, 0x2c, 0xa5, 0x86, 0x7e, 0x5b, 0x4a, 0x0d, 0xbd, 0x31, 0xdb, 0xf1, 0x79, 0x4d, - 0xc4, 0xc8, 0xd6, 0xb4, 0x92, 0xe9, 0x06, 0xbc, 0x36, 0xf3, 0xac, 0x7a, 0xdd, 0x09, 0xcb, 0x3e, - 0xb7, 0x95, 0x46, 0x98, 0xce, 0xdc, 0xff, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x4c, 0x44, - 0xce, 0x07, 0x1d, 0x00, 0x00, + // 1535 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x14, 0x45, + 0x14, 0x4f, 0x03, 0x89, 0xf2, 0x30, 0x88, 0x4d, 0xc0, 0x64, 0x02, 0xbb, 0x61, 0x80, 0xb8, 0x6a, + 0x76, 0x86, 0x04, 0x04, 0x44, 0x3e, 0x97, 0x88, 0x15, 0x8c, 0x08, 0x0b, 0x4a, 0xf9, 0x55, 0x5b, + 0xb3, 0xbb, 0xcd, 0x32, 0xc5, 0xee, 0xf4, 0xb2, 0x33, 0x8b, 0xac, 0x14, 0x52, 0x82, 0x47, 0x0f, + 0x58, 0x5e, 0x2c, 0x0f, 0x96, 0x7a, 0xd3, 0x83, 0xe5, 0xc5, 0x03, 0xe5, 0x5d, 0x29, 0x0f, 0x16, + 0x55, 0x5e, 0x2c, 0x0f, 0xc1, 0x22, 0xfe, 0x05, 0x9c, 0x3c, 0x78, 0xb0, 0xa6, 0xbb, 0x67, 0xb2, + 0xf3, 0xb9, 0xb3, 0xbb, 0x92, 0xca, 0x29, 0xd9, 0x79, 0xaf, 0xdf, 0xfb, 0xfd, 0x5e, 0xbf, 0xee, + 0x37, 0xbf, 0x01, 0x89, 0x9a, 0x35, 0x6a, 0xea, 0xa6, 0x5a, 0xa5, 0xa5, 0x4b, 0xcd, 0xba, 0x7a, + 0xb9, 0x49, 0x1a, 0x2d, 0xa5, 0xde, 0xa0, 0x16, 0xc5, 0xeb, 0x85, 0x4d, 0xe1, 0x36, 0x69, 0xa4, + 0x42, 0x2b, 0x94, 0x99, 0x54, 0xfb, 0x3f, 0xee, 0x25, 0xa5, 0x4a, 0xcc, 0x4d, 0x2d, 0x6a, 0x26, + 0x51, 0xaf, 0x4c, 0x17, 0x89, 0xa5, 0x4d, 0xab, 0x25, 0xaa, 0x1b, 0xc2, 0xbe, 0xa5, 0x42, 0x69, + 0xa5, 0x4a, 0x54, 0xad, 0xae, 0xab, 0x9a, 0x61, 0x50, 0x4b, 0xb3, 0x74, 0x6a, 0x98, 0xc2, 0x9a, + 0x16, 0x56, 0xf6, 0xab, 0xd8, 0xbc, 0xa0, 0x5a, 0x7a, 0x8d, 0x98, 0x96, 0x56, 0xab, 0x3b, 0xe1, + 0xfd, 0x0e, 0xe5, 0x66, 0x83, 0x45, 0x10, 0xf6, 0x31, 0x1f, 0x01, 0xfb, 0x8f, 0x30, 0x8d, 0xfb, + 0x4c, 0x75, 0xad, 0xa1, 0xd5, 0x44, 0x62, 0x79, 0x33, 0x8c, 0xbc, 0x46, 0xcb, 0xcd, 0x2a, 0xc9, + 0x69, 0x55, 0xcd, 0x28, 0x91, 0x3c, 0xb9, 0xdc, 0x24, 0xa6, 0x25, 0x7f, 0x00, 0x9b, 0x7c, 0xcf, + 0xcd, 0x3a, 0x35, 0x4c, 0x82, 0x35, 0x18, 0xb4, 0x59, 0x99, 0xa3, 0x68, 0x62, 0x75, 0x66, 0xdd, + 0xcc, 0x98, 0xc2, 0x79, 0x2b, 0x36, 0x6f, 0x45, 0xf0, 0x56, 0x8e, 0x53, 0xdd, 0xc8, 0xed, 0xba, + 0xbb, 0x90, 0x1e, 0xf8, 0xee, 0x7e, 0x3a, 0x53, 0xd1, 0xad, 0x8b, 0xcd, 0xa2, 0x52, 0xa2, 0x35, + 0x55, 0x14, 0x89, 0xff, 0xc9, 0x9a, 0xe5, 0x4b, 0xaa, 0xd5, 0xaa, 0x13, 0x93, 0x2d, 0x30, 0xf3, + 0x3c, 0xb2, 0x3c, 0x0e, 0x63, 0x3c, 0xf7, 0x3c, 0x2d, 0x5d, 0x22, 0xe5, 0x63, 0x35, 0xda, 0x34, + 0x2c, 0x07, 0xd8, 0x0d, 0x90, 0xc2, 0x8c, 0xcb, 0x87, 0xee, 0x15, 0xd8, 0x7a, 0xac, 0x54, 0xb2, + 0xb3, 0xbe, 0x61, 0xd8, 0x15, 0xd5, 0x8a, 0x55, 0xc2, 0x1d, 0x38, 0x42, 0x3c, 0x09, 0x83, 0xf4, + 0x7d, 0x83, 0x34, 0x46, 0xd1, 0x04, 0xca, 0xac, 0xcd, 0x6d, 0x78, 0xb8, 0x90, 0x7e, 0xa2, 0xa5, + 0xd5, 0xaa, 0x07, 0x64, 0xf6, 0x58, 0xce, 0x73, 0xb3, 0x7c, 0x0b, 0x41, 0x2a, 0x2a, 0xd2, 0xf2, + 0xd1, 0x39, 0x01, 0x5b, 0x3c, 0x20, 0x74, 0xa3, 0xd2, 0x13, 0x9b, 0x9b, 0xc8, 0x57, 0x97, 0xa5, + 0x40, 0xcb, 0x47, 0xe6, 0x38, 0x8c, 0x09, 0x0c, 0xbc, 0x3b, 0x7a, 0x62, 0x72, 0x03, 0xa4, 0xb0, + 0x20, 0xcb, 0xc7, 0xe2, 0x4b, 0xe4, 0xee, 0x09, 0x47, 0x70, 0x5a, 0x33, 0xad, 0x73, 0x7a, 0x8d, + 0x74, 0xc9, 0x04, 0xbf, 0x09, 0x6b, 0xdd, 0x7b, 0x64, 0x74, 0xd5, 0x04, 0xca, 0xac, 0x9b, 0x91, + 0x14, 0x7e, 0x91, 0x28, 0xce, 0x45, 0xa2, 0x9c, 0x73, 0x3c, 0x72, 0x5b, 0x6c, 0xc0, 0x0f, 0x17, + 0xd2, 0x1b, 0x78, 0x2c, 0x77, 0xa9, 0x7c, 0xfb, 0x7e, 0x1a, 0xe5, 0x97, 0x42, 0xc9, 0xe7, 0xdd, + 0xad, 0xf6, 0xe3, 0x13, 0x45, 0xda, 0x0b, 0x83, 0x76, 0x0b, 0x38, 0x45, 0x92, 0x14, 0xef, 0x15, + 0xaa, 0x9c, 0x26, 0x0d, 0x9d, 0x96, 0xed, 0xc5, 0xb9, 0x35, 0x76, 0xd2, 0x3c, 0x77, 0x97, 0xbf, + 0x47, 0x30, 0x15, 0x1a, 0xf9, 0x14, 0x5d, 0xea, 0xaa, 0xd7, 0x8d, 0x6a, 0x6b, 0xa5, 0x54, 0xa2, + 0x02, 0xd9, 0x84, 0x78, 0xfb, 0xac, 0xcc, 0x37, 0x08, 0x26, 0x3c, 0xc7, 0x8b, 0x94, 0x73, 0xe4, + 0x02, 0x6d, 0x90, 0x95, 0xd4, 0x17, 0xef, 0xc0, 0xb6, 0x18, 0x8c, 0x7d, 0x56, 0xe0, 0x0e, 0x72, + 0xa3, 0x7b, 0x6b, 0x3d, 0x4b, 0x0c, 0x5a, 0x5b, 0x21, 0x25, 0xc0, 0x23, 0x30, 0x58, 0xb6, 0xf1, + 0x8c, 0xae, 0xb6, 0xf3, 0xe7, 0xf9, 0x0f, 0xf9, 0x5d, 0x90, 0xe3, 0xa0, 0xf7, 0x59, 0x99, 0x0f, + 0x01, 0xf3, 0xb0, 0x9e, 0x4a, 0xb8, 0x48, 0x50, 0x1b, 0x12, 0x9c, 0x87, 0xc7, 0x9d, 0x37, 0x07, + 0x41, 0x7b, 0x2c, 0x40, 0x7b, 0x56, 0x38, 0xe4, 0xc6, 0x05, 0xeb, 0x27, 0x39, 0x6b, 0x67, 0xa1, + 0xfc, 0xb9, 0x4d, 0xda, 0x8d, 0x23, 0x1b, 0xb0, 0xd1, 0x93, 0x5f, 0xd0, 0x39, 0x0f, 0x43, 0x1a, + 0x9b, 0xce, 0x62, 0x2f, 0x8e, 0xd8, 0xd1, 0xfe, 0x5c, 0x48, 0x4f, 0x26, 0xb8, 0x0f, 0xe7, 0x0c, + 0xeb, 0xe1, 0x42, 0x7a, 0x98, 0xe7, 0xe5, 0x51, 0xe4, 0xbc, 0x08, 0x27, 0x67, 0x60, 0x98, 0xe7, + 0x73, 0xa8, 0x3e, 0x0d, 0x8f, 0xd9, 0x95, 0x28, 0xe8, 0x65, 0x96, 0x6a, 0x4d, 0x7e, 0xc8, 0xfe, + 0x39, 0x57, 0x96, 0x8f, 0xc2, 0x7a, 0xc7, 0x53, 0x80, 0x52, 0x60, 0x8d, 0x6d, 0x63, 0x7e, 0xb1, + 0x25, 0xce, 0x33, 0x3f, 0x79, 0x23, 0x3c, 0x75, 0x8a, 0x5c, 0x65, 0xdb, 0x36, 0x37, 0xeb, 0xbc, + 0x83, 0x64, 0x01, 0xb7, 0x3f, 0x14, 0xa1, 0x23, 0x51, 0xbc, 0x04, 0x13, 0x67, 0x5b, 0x86, 0x75, + 0x91, 0x58, 0x7a, 0x69, 0x9e, 0xe5, 0xc9, 0xb5, 0xf8, 0x5f, 0x37, 0x64, 0xf4, 0x62, 0x0a, 0xdb, + 0x62, 0x16, 0x8b, 0xd4, 0x27, 0x61, 0xbd, 0xe9, 0x38, 0x15, 0xda, 0xf8, 0x6d, 0xf5, 0xf3, 0xf3, + 0x84, 0x12, 0x5d, 0x34, 0x6c, 0xb6, 0x3f, 0x94, 0xbf, 0x42, 0xbe, 0x66, 0x9d, 0xa7, 0x46, 0x85, + 0x34, 0x9c, 0xa6, 0xe8, 0xf6, 0xa0, 0x3d, 0x8a, 0x86, 0x7b, 0x0f, 0xb6, 0xc7, 0x22, 0xec, 0xf3, + 0x3c, 0x7d, 0xe1, 0x9f, 0xbf, 0x2b, 0x89, 0xbb, 0x7f, 0xf6, 0xfe, 0x6f, 0xac, 0x7f, 0x40, 0x30, + 0x13, 0x53, 0xd5, 0x7e, 0x27, 0xf0, 0xa3, 0xa8, 0x45, 0x0d, 0x76, 0x77, 0x85, 0xb8, 0xcf, 0x0a, + 0xfd, 0x84, 0xe0, 0x99, 0x98, 0x7c, 0x3d, 0xcd, 0xa1, 0x47, 0x50, 0x96, 0x88, 0x19, 0x54, 0x84, + 0x4c, 0x67, 0xf0, 0x7d, 0x56, 0x68, 0x04, 0xf0, 0x19, 0x5b, 0x39, 0x9f, 0x66, 0x12, 0xd3, 0xb9, + 0x2e, 0x5f, 0x85, 0x8d, 0x9e, 0xa7, 0x22, 0xc9, 0x1e, 0x18, 0xe2, 0x52, 0x54, 0x5c, 0x56, 0x9b, + 0x03, 0x59, 0x98, 0x55, 0x64, 0x10, 0xbe, 0x33, 0xff, 0x8e, 0xc1, 0x20, 0x8b, 0x86, 0x3f, 0x41, + 0x30, 0xec, 0xd1, 0xa8, 0x78, 0x87, 0x3f, 0x42, 0x98, 0xb4, 0x95, 0x76, 0x76, 0xf0, 0xe2, 0xf0, + 0x64, 0xe5, 0xe6, 0xef, 0x7f, 0x7f, 0xb6, 0x2a, 0x83, 0x27, 0x55, 0x9f, 0x7e, 0x76, 0xc4, 0x7d, + 0x8d, 0x2d, 0x2b, 0x14, 0x45, 0xf2, 0xaf, 0x11, 0xe0, 0xa0, 0x32, 0xc5, 0xcf, 0x86, 0x67, 0x0b, + 0x91, 0xb6, 0xd2, 0x73, 0x49, 0x5c, 0x05, 0xba, 0x3d, 0x0c, 0x9d, 0x82, 0xa7, 0x3a, 0xa0, 0xe3, + 0xaf, 0x61, 0x05, 0x3e, 0x39, 0xf1, 0x1d, 0x04, 0x9b, 0xc3, 0x25, 0x27, 0xce, 0xfa, 0x93, 0xc7, + 0x8a, 0x5c, 0x49, 0x49, 0xea, 0x2e, 0xf0, 0x1e, 0x65, 0x78, 0x0f, 0xe0, 0xfd, 0x51, 0x78, 0x35, + 0xbe, 0xbe, 0xd0, 0x74, 0x03, 0x14, 0x98, 0x1a, 0x52, 0xaf, 0xb1, 0x83, 0x72, 0x1d, 0xff, 0x88, + 0x60, 0x53, 0xa8, 0xc0, 0xc4, 0x53, 0xb1, 0x58, 0x7c, 0x82, 0x56, 0xca, 0x26, 0xf4, 0x16, 0xc0, + 0x8f, 0x30, 0xe0, 0x2f, 0xe2, 0x7d, 0xc9, 0x80, 0xeb, 0x46, 0xc5, 0x87, 0xfb, 0x5b, 0x04, 0x38, + 0xa8, 0x27, 0x83, 0x7d, 0x11, 0x29, 0x5c, 0x83, 0x7d, 0x11, 0x2d, 0x4f, 0xe5, 0x83, 0x0c, 0xee, + 0x5e, 0xbc, 0xa7, 0x13, 0x5c, 0xd1, 0x18, 0x91, 0x35, 0xf6, 0xbe, 0xa8, 0x46, 0xd6, 0x38, 0x54, + 0xa0, 0x46, 0xd6, 0x38, 0x5c, 0x2e, 0x26, 0xaf, 0xb1, 0x00, 0x5d, 0xd7, 0x4c, 0xcb, 0x7e, 0xe5, + 0x76, 0x71, 0xff, 0x83, 0x60, 0x67, 0x22, 0x1d, 0x86, 0x0f, 0x26, 0x42, 0x16, 0x31, 0xec, 0xa4, + 0x43, 0x3d, 0xae, 0x16, 0x3c, 0xf3, 0x8c, 0xe7, 0x3c, 0x3e, 0xd9, 0x25, 0xcf, 0x82, 0x41, 0xdb, + 0xfb, 0x8b, 0x1a, 0xd5, 0x96, 0x4b, 0xfd, 0x67, 0xe4, 0x7e, 0xf3, 0x08, 0x8a, 0x2e, 0xbc, 0x2b, + 0xb6, 0xd9, 0x43, 0x34, 0xa4, 0x34, 0xdd, 0xc5, 0x0a, 0x41, 0x6b, 0x96, 0xd1, 0x3a, 0x8c, 0x0f, + 0x26, 0x3b, 0x22, 0xa4, 0x5c, 0x28, 0xb2, 0x20, 0x05, 0xcf, 0x1e, 0xfe, 0x8a, 0x7c, 0xdf, 0x5d, + 0x3c, 0x22, 0x09, 0x4f, 0x27, 0x2a, 0x7d, 0xfb, 0x0c, 0x96, 0x66, 0xba, 0x59, 0x22, 0xb8, 0xbc, + 0xcc, 0xb8, 0x1c, 0xc1, 0x87, 0xba, 0xdd, 0x22, 0x36, 0x64, 0x5d, 0x32, 0x1f, 0x23, 0x58, 0xd7, + 0xa6, 0x89, 0xb0, 0xec, 0x87, 0x12, 0x14, 0x6c, 0xd2, 0xf6, 0x58, 0x1f, 0x81, 0x6f, 0x8a, 0xe1, + 0x9b, 0xc4, 0x3b, 0xa2, 0xf0, 0x09, 0x5c, 0x5c, 0xed, 0xdd, 0x42, 0x00, 0x3c, 0x4a, 0xae, 0x35, + 0x37, 0x8b, 0xb7, 0x86, 0x67, 0x70, 0x00, 0xa4, 0xa2, 0xcc, 0x22, 0xf7, 0x5e, 0x96, 0x7b, 0x17, + 0x56, 0x3a, 0xe4, 0x2e, 0xb6, 0x0a, 0x7a, 0x59, 0xbd, 0x26, 0xf4, 0xcc, 0x75, 0xfc, 0x11, 0x02, + 0x58, 0xd2, 0x4b, 0x78, 0x9b, 0x3f, 0x4d, 0x40, 0x60, 0x49, 0x72, 0x9c, 0x4b, 0xd2, 0x4a, 0x18, + 0xe4, 0x2a, 0xdf, 0xa6, 0x82, 0x5e, 0xc6, 0xbf, 0x20, 0x18, 0x8b, 0xd4, 0x51, 0xc1, 0x63, 0xd2, + 0x49, 0xaf, 0x05, 0x8f, 0x49, 0x47, 0x91, 0xd6, 0xb9, 0xb5, 0xbc, 0x12, 0xae, 0x59, 0xb7, 0x0b, + 0x29, 0xf0, 0xb7, 0x55, 0xf3, 0x37, 0x04, 0xe3, 0x31, 0x2f, 0x72, 0x38, 0xbe, 0xeb, 0x43, 0xc5, + 0x9c, 0xb4, 0xbb, 0xab, 0x35, 0x82, 0xcf, 0x09, 0xc6, 0xe7, 0x28, 0x3e, 0x9c, 0xf0, 0xa8, 0x54, + 0x59, 0x98, 0x82, 0xf3, 0x9a, 0x1a, 0x3d, 0x74, 0x5c, 0x2a, 0xf1, 0x43, 0xc7, 0x4f, 0x22, 0x9b, + 0xd0, 0xbb, 0xc7, 0xa1, 0x13, 0xc0, 0xfd, 0xe9, 0x2a, 0x78, 0xbe, 0x0b, 0xf9, 0x81, 0x73, 0x5d, + 0x14, 0x39, 0x6a, 0x00, 0x1d, 0xef, 0x2b, 0x86, 0x60, 0xfe, 0x16, 0x63, 0x7e, 0x16, 0x9f, 0xe9, + 0x6d, 0xe3, 0xe2, 0xa6, 0xd1, 0xe2, 0xd2, 0x67, 0xca, 0x48, 0x95, 0x81, 0xf7, 0x75, 0x41, 0xc2, + 0x73, 0x43, 0xee, 0xef, 0x7e, 0xa1, 0xa0, 0x3c, 0xcf, 0x28, 0x9f, 0xc0, 0xb3, 0x3d, 0x52, 0xf6, + 0xde, 0xee, 0x2d, 0x18, 0xe2, 0xda, 0x24, 0x78, 0xaf, 0x07, 0xe5, 0x4f, 0xf0, 0x5e, 0x0f, 0x11, + 0x43, 0xf2, 0x24, 0x03, 0x38, 0x81, 0x53, 0x51, 0x00, 0xb9, 0xfc, 0xc9, 0xcd, 0xdf, 0x7d, 0x90, + 0x42, 0xf7, 0x1e, 0xa4, 0xd0, 0x5f, 0x0f, 0x52, 0xe8, 0xf6, 0x62, 0x6a, 0xe0, 0xde, 0x62, 0x6a, + 0xe0, 0x8f, 0xc5, 0xd4, 0xc0, 0xdb, 0x33, 0x6d, 0x9f, 0xd5, 0x44, 0x8c, 0x6c, 0x55, 0x2b, 0x9a, + 0x6e, 0xc0, 0x2b, 0xd3, 0x2f, 0xa8, 0x57, 0x9d, 0xb0, 0xec, 0x33, 0x5b, 0x71, 0x88, 0x69, 0xcc, + 0xdd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x05, 0x5b, 0xfd, 0xff, 0x1c, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1867,8 +1866,8 @@ type QueryClient interface { LockedByID(ctx context.Context, in *LockedRequest, opts ...grpc.CallOption) (*LockedResponse, error) // Returns next lock ID NextLockID(ctx context.Context, in *NextLockIDRequest, opts ...grpc.CallOption) (*NextLockIDResponse, error) - // Returns synthetic lockups by native lockup id - SyntheticLockupsByLockupID(ctx context.Context, in *SyntheticLockupsByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupsByLockupIDResponse, error) + // Returns synthetic lockup by native lockup id + SyntheticLockupByLockupID(ctx context.Context, in *SyntheticLockupByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupByLockupIDResponse, error) // Returns account locked records with longer duration AccountLockedLongerDuration(ctx context.Context, in *AccountLockedLongerDurationRequest, opts ...grpc.CallOption) (*AccountLockedLongerDurationResponse, error) // Returns account locked records with a specific duration @@ -1998,9 +1997,9 @@ func (c *queryClient) NextLockID(ctx context.Context, in *NextLockIDRequest, opt return out, nil } -func (c *queryClient) SyntheticLockupsByLockupID(ctx context.Context, in *SyntheticLockupsByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupsByLockupIDResponse, error) { - out := new(SyntheticLockupsByLockupIDResponse) - err := c.cc.Invoke(ctx, "/osmosis.lockup.Query/SyntheticLockupsByLockupID", in, out, opts...) +func (c *queryClient) SyntheticLockupByLockupID(ctx context.Context, in *SyntheticLockupByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupByLockupIDResponse, error) { + out := new(SyntheticLockupByLockupIDResponse) + err := c.cc.Invoke(ctx, "/osmosis.lockup.Query/SyntheticLockupByLockupID", in, out, opts...) if err != nil { return nil, err } @@ -2079,8 +2078,8 @@ type QueryServer interface { LockedByID(context.Context, *LockedRequest) (*LockedResponse, error) // Returns next lock ID NextLockID(context.Context, *NextLockIDRequest) (*NextLockIDResponse, error) - // Returns synthetic lockups by native lockup id - SyntheticLockupsByLockupID(context.Context, *SyntheticLockupsByLockupIDRequest) (*SyntheticLockupsByLockupIDResponse, error) + // Returns synthetic lockup by native lockup id + SyntheticLockupByLockupID(context.Context, *SyntheticLockupByLockupIDRequest) (*SyntheticLockupByLockupIDResponse, error) // Returns account locked records with longer duration AccountLockedLongerDuration(context.Context, *AccountLockedLongerDurationRequest) (*AccountLockedLongerDurationResponse, error) // Returns account locked records with a specific duration @@ -2134,8 +2133,8 @@ func (*UnimplementedQueryServer) LockedByID(ctx context.Context, req *LockedRequ func (*UnimplementedQueryServer) NextLockID(ctx context.Context, req *NextLockIDRequest) (*NextLockIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NextLockID not implemented") } -func (*UnimplementedQueryServer) SyntheticLockupsByLockupID(ctx context.Context, req *SyntheticLockupsByLockupIDRequest) (*SyntheticLockupsByLockupIDResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method SyntheticLockupsByLockupID not implemented") +func (*UnimplementedQueryServer) SyntheticLockupByLockupID(ctx context.Context, req *SyntheticLockupByLockupIDRequest) (*SyntheticLockupByLockupIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SyntheticLockupByLockupID not implemented") } func (*UnimplementedQueryServer) AccountLockedLongerDuration(ctx context.Context, req *AccountLockedLongerDurationRequest) (*AccountLockedLongerDurationResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method AccountLockedLongerDuration not implemented") @@ -2373,20 +2372,20 @@ func _Query_NextLockID_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } -func _Query_SyntheticLockupsByLockupID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(SyntheticLockupsByLockupIDRequest) +func _Query_SyntheticLockupByLockupID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SyntheticLockupByLockupIDRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(QueryServer).SyntheticLockupsByLockupID(ctx, in) + return srv.(QueryServer).SyntheticLockupByLockupID(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/osmosis.lockup.Query/SyntheticLockupsByLockupID", + FullMethod: "/osmosis.lockup.Query/SyntheticLockupByLockupID", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(QueryServer).SyntheticLockupsByLockupID(ctx, req.(*SyntheticLockupsByLockupIDRequest)) + return srv.(QueryServer).SyntheticLockupByLockupID(ctx, req.(*SyntheticLockupByLockupIDRequest)) } return interceptor(ctx, in, info, handler) } @@ -2534,8 +2533,8 @@ var _Query_serviceDesc = grpc.ServiceDesc{ Handler: _Query_NextLockID_Handler, }, { - MethodName: "SyntheticLockupsByLockupID", - Handler: _Query_SyntheticLockupsByLockupID_Handler, + MethodName: "SyntheticLockupByLockupID", + Handler: _Query_SyntheticLockupByLockupID_Handler, }, { MethodName: "AccountLockedLongerDuration", @@ -3375,7 +3374,7 @@ func (m *NextLockIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *SyntheticLockupsByLockupIDRequest) Marshal() (dAtA []byte, err error) { +func (m *SyntheticLockupByLockupIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3385,12 +3384,12 @@ func (m *SyntheticLockupsByLockupIDRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *SyntheticLockupsByLockupIDRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *SyntheticLockupByLockupIDRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyntheticLockupsByLockupIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SyntheticLockupByLockupIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -3403,7 +3402,7 @@ func (m *SyntheticLockupsByLockupIDRequest) MarshalToSizedBuffer(dAtA []byte) (i return len(dAtA) - i, nil } -func (m *SyntheticLockupsByLockupIDResponse) Marshal() (dAtA []byte, err error) { +func (m *SyntheticLockupByLockupIDResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3413,30 +3412,26 @@ func (m *SyntheticLockupsByLockupIDResponse) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *SyntheticLockupsByLockupIDResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *SyntheticLockupByLockupIDResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *SyntheticLockupsByLockupIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *SyntheticLockupByLockupIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.SyntheticLocks) > 0 { - for iNdEx := len(m.SyntheticLocks) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.SyntheticLocks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintQuery(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa + { + size, err := m.SyntheticLock.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0xa return len(dAtA) - i, nil } @@ -3460,12 +3455,12 @@ func (m *AccountLockedLongerDurationRequest) MarshalToSizedBuffer(dAtA []byte) ( _ = i var l int _ = l - n7, err7 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) - if err7 != nil { - return 0, err7 + n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err8 != nil { + return 0, err8 } - i -= n7 - i = encodeVarintQuery(dAtA, i, uint64(n7)) + i -= n8 + i = encodeVarintQuery(dAtA, i, uint64(n8)) i-- dAtA[i] = 0x12 if len(m.Owner) > 0 { @@ -3535,12 +3530,12 @@ func (m *AccountLockedDurationRequest) MarshalToSizedBuffer(dAtA []byte) (int, e _ = i var l int _ = l - n8, err8 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) - if err8 != nil { - return 0, err8 + n9, err9 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err9 != nil { + return 0, err9 } - i -= n8 - i = encodeVarintQuery(dAtA, i, uint64(n8)) + i -= n9 + i = encodeVarintQuery(dAtA, i, uint64(n9)) i-- dAtA[i] = 0x12 if len(m.Owner) > 0 { @@ -3610,12 +3605,12 @@ func (m *AccountLockedLongerDurationNotUnlockingOnlyRequest) MarshalToSizedBuffe _ = i var l int _ = l - n9, err9 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) - if err9 != nil { - return 0, err9 + n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err10 != nil { + return 0, err10 } - i -= n9 - i = encodeVarintQuery(dAtA, i, uint64(n9)) + i -= n10 + i = encodeVarintQuery(dAtA, i, uint64(n10)) i-- dAtA[i] = 0x12 if len(m.Owner) > 0 { @@ -3692,12 +3687,12 @@ func (m *AccountLockedLongerDurationDenomRequest) MarshalToSizedBuffer(dAtA []by i-- dAtA[i] = 0x1a } - n10, err10 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) - if err10 != nil { - return 0, err10 + n11, err11 := github_com_gogo_protobuf_types.StdDurationMarshalTo(m.Duration, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(m.Duration):]) + if err11 != nil { + return 0, err11 } - i -= n10 - i = encodeVarintQuery(dAtA, i, uint64(n10)) + i -= n11 + i = encodeVarintQuery(dAtA, i, uint64(n11)) i-- dAtA[i] = 0x12 if len(m.Owner) > 0 { @@ -4142,7 +4137,7 @@ func (m *NextLockIDResponse) Size() (n int) { return n } -func (m *SyntheticLockupsByLockupIDRequest) Size() (n int) { +func (m *SyntheticLockupByLockupIDRequest) Size() (n int) { if m == nil { return 0 } @@ -4154,18 +4149,14 @@ func (m *SyntheticLockupsByLockupIDRequest) Size() (n int) { return n } -func (m *SyntheticLockupsByLockupIDResponse) Size() (n int) { +func (m *SyntheticLockupByLockupIDResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if len(m.SyntheticLocks) > 0 { - for _, e := range m.SyntheticLocks { - l = e.Size() - n += 1 + l + sovQuery(uint64(l)) - } - } + l = m.SyntheticLock.Size() + n += 1 + l + sovQuery(uint64(l)) return n } @@ -6386,7 +6377,7 @@ func (m *NextLockIDResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SyntheticLockupsByLockupIDRequest) Unmarshal(dAtA []byte) error { +func (m *SyntheticLockupByLockupIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6409,10 +6400,10 @@ func (m *SyntheticLockupsByLockupIDRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SyntheticLockupsByLockupIDRequest: wiretype end group for non-group") + return fmt.Errorf("proto: SyntheticLockupByLockupIDRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SyntheticLockupsByLockupIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SyntheticLockupByLockupIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -6455,7 +6446,7 @@ func (m *SyntheticLockupsByLockupIDRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *SyntheticLockupsByLockupIDResponse) Unmarshal(dAtA []byte) error { +func (m *SyntheticLockupByLockupIDResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -6478,15 +6469,15 @@ func (m *SyntheticLockupsByLockupIDResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: SyntheticLockupsByLockupIDResponse: wiretype end group for non-group") + return fmt.Errorf("proto: SyntheticLockupByLockupIDResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: SyntheticLockupsByLockupIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: SyntheticLockupByLockupIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SyntheticLocks", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SyntheticLock", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -6513,8 +6504,7 @@ func (m *SyntheticLockupsByLockupIDResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.SyntheticLocks = append(m.SyntheticLocks, SyntheticLock{}) - if err := m.SyntheticLocks[len(m.SyntheticLocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.SyntheticLock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/x/lockup/types/query.pb.gw.go b/x/lockup/types/query.pb.gw.go index cc3f30a7c7d..9db748d13c9 100644 --- a/x/lockup/types/query.pb.gw.go +++ b/x/lockup/types/query.pb.gw.go @@ -627,8 +627,8 @@ func local_request_Query_NextLockID_0(ctx context.Context, marshaler runtime.Mar } -func request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SyntheticLockupsByLockupIDRequest +func request_Query_SyntheticLockupByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SyntheticLockupByLockupIDRequest var metadata runtime.ServerMetadata var ( @@ -649,13 +649,13 @@ func request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marshaler r return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lock_id", err) } - msg, err := client.SyntheticLockupsByLockupID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + msg, err := client.SyntheticLockupByLockupID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) return msg, metadata, err } -func local_request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { - var protoReq SyntheticLockupsByLockupIDRequest +func local_request_Query_SyntheticLockupByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SyntheticLockupByLockupIDRequest var metadata runtime.ServerMetadata var ( @@ -676,7 +676,7 @@ func local_request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marsh return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lock_id", err) } - msg, err := server.SyntheticLockupsByLockupID(ctx, &protoReq) + msg, err := server.SyntheticLockupByLockupID(ctx, &protoReq) return msg, metadata, err } @@ -1269,7 +1269,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) - mux.Handle("GET", pattern_Query_SyntheticLockupsByLockupID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_SyntheticLockupByLockupID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() var stream runtime.ServerTransportStream @@ -1280,7 +1280,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := local_request_Query_SyntheticLockupsByLockupID_0(rctx, inboundMarshaler, server, req, pathParams) + resp, md, err := local_request_Query_SyntheticLockupByLockupID_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 { @@ -1288,7 +1288,7 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv return } - forward_Query_SyntheticLockupsByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_SyntheticLockupByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -1688,7 +1688,7 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) - mux.Handle("GET", pattern_Query_SyntheticLockupsByLockupID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + mux.Handle("GET", pattern_Query_SyntheticLockupByLockupID_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) @@ -1697,14 +1697,14 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) return } - resp, md, err := request_Query_SyntheticLockupsByLockupID_0(rctx, inboundMarshaler, client, req, pathParams) + resp, md, err := request_Query_SyntheticLockupByLockupID_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_SyntheticLockupsByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + forward_Query_SyntheticLockupByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) }) @@ -1836,7 +1836,7 @@ var ( pattern_Query_NextLockID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"osmosis", "lockup", "v1beta1", "next_lock_id"}, "", runtime.AssumeColonVerbOpt(false))) - pattern_Query_SyntheticLockupsByLockupID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "synthetic_lockups_by_lock_id", "lock_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_SyntheticLockupByLockupID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "synthetic_lockup_by_lock_id", "lock_id"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_AccountLockedLongerDuration_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "account_locked_longer_duration", "owner"}, "", runtime.AssumeColonVerbOpt(false))) @@ -1874,7 +1874,7 @@ var ( forward_Query_NextLockID_0 = runtime.ForwardResponseMessage - forward_Query_SyntheticLockupsByLockupID_0 = runtime.ForwardResponseMessage + forward_Query_SyntheticLockupByLockupID_0 = runtime.ForwardResponseMessage forward_Query_AccountLockedLongerDuration_0 = runtime.ForwardResponseMessage diff --git a/x/superfluid/keeper/export_test.go b/x/superfluid/keeper/export_test.go index c830be7462f..a24665b74e0 100644 --- a/x/superfluid/keeper/export_test.go +++ b/x/superfluid/keeper/export_test.go @@ -38,7 +38,7 @@ func (k Keeper) ValidateSharesToMigrateUnlockAndExitBalancerPool(ctx sdk.Context return k.validateSharesToMigrateUnlockAndExitBalancerPool(ctx, sender, poolIdLeaving, lock, sharesToMigrate, tokenOutMins, remainingLockTime) } -func (k Keeper) RouteMigration(ctx sdk.Context, sender sdk.AccAddress, lockId uint64, sharesToMigrate sdk.Coin) (synthLocksBeforeMigration []lockuptypes.SyntheticLock, migrationType MigrationType, err error) { +func (k Keeper) RouteMigration(ctx sdk.Context, sender sdk.AccAddress, lockId uint64, sharesToMigrate sdk.Coin) (synthLockBeforeMigration lockuptypes.SyntheticLock, migrationType MigrationType, err error) { return k.routeMigration(ctx, sender, lockId, sharesToMigrate) } diff --git a/x/superfluid/keeper/migrate.go b/x/superfluid/keeper/migrate.go index 7d001eb27b4..234f8d52ffa 100644 --- a/x/superfluid/keeper/migrate.go +++ b/x/superfluid/keeper/migrate.go @@ -28,16 +28,16 @@ const ( // If the lock is locked or unlocking but not superfluid delegated/undelegating, it will migrate the position and either start unlocking or continue unlocking where it left off. // Errors if the lock is not found, if the lock is not a balancer pool lock, or if the lock is not owned by the sender. func (k Keeper) RouteLockedBalancerToConcentratedMigration(ctx sdk.Context, sender sdk.AccAddress, lockId uint64, sharesToMigrate sdk.Coin, tokenOutMins sdk.Coins) (positionId uint64, amount0, amount1 sdk.Int, liquidity sdk.Dec, joinTime time.Time, poolIdLeaving, poolIdEntering, concentratedLockId uint64, err error) { - synthLocksBeforeMigration, migrationType, err := k.routeMigration(ctx, sender, lockId, sharesToMigrate) + synthLockBeforeMigration, migrationType, err := k.routeMigration(ctx, sender, lockId, sharesToMigrate) if err != nil { return 0, sdk.Int{}, sdk.Int{}, sdk.Dec{}, time.Time{}, 0, 0, 0, err } switch migrationType { case SuperfluidBonded: - positionId, amount0, amount1, liquidity, joinTime, concentratedLockId, poolIdLeaving, poolIdEntering, err = k.migrateSuperfluidBondedBalancerToConcentrated(ctx, sender, lockId, sharesToMigrate, synthLocksBeforeMigration[0].SynthDenom, tokenOutMins) + positionId, amount0, amount1, liquidity, joinTime, concentratedLockId, poolIdLeaving, poolIdEntering, err = k.migrateSuperfluidBondedBalancerToConcentrated(ctx, sender, lockId, sharesToMigrate, synthLockBeforeMigration.SynthDenom, tokenOutMins) case SuperfluidUnbonding: - positionId, amount0, amount1, liquidity, joinTime, concentratedLockId, poolIdLeaving, poolIdEntering, err = k.migrateSuperfluidUnbondingBalancerToConcentrated(ctx, sender, lockId, sharesToMigrate, synthLocksBeforeMigration[0].SynthDenom, tokenOutMins) + positionId, amount0, amount1, liquidity, joinTime, concentratedLockId, poolIdLeaving, poolIdEntering, err = k.migrateSuperfluidUnbondingBalancerToConcentrated(ctx, sender, lockId, sharesToMigrate, synthLockBeforeMigration.SynthDenom, tokenOutMins) case NonSuperfluid: positionId, amount0, amount1, liquidity, joinTime, concentratedLockId, poolIdLeaving, poolIdEntering, err = k.migrateNonSuperfluidLockBalancerToConcentrated(ctx, sender, lockId, sharesToMigrate, tokenOutMins) default: @@ -207,23 +207,23 @@ func (k Keeper) migrateNonSuperfluidLockBalancerToConcentrated(ctx sdk.Context, // routeMigration determines the status of the provided lock which is used to determine the method for migration. // It also returns the underlying synthetic locks of the provided lock, if any exist. -func (k Keeper) routeMigration(ctx sdk.Context, sender sdk.AccAddress, lockId uint64, sharesToMigrate sdk.Coin) (synthLocksBeforeMigration []lockuptypes.SyntheticLock, migrationType MigrationType, err error) { - synthLocksBeforeMigration = k.lk.GetAllSyntheticLockupsByLockup(ctx, lockId) - if len(synthLocksBeforeMigration) > 1 { - return nil, Unsupported, fmt.Errorf("lock %d contains more than one synthetic lock", lockId) +func (k Keeper) routeMigration(ctx sdk.Context, sender sdk.AccAddress, lockId uint64, sharesToMigrate sdk.Coin) (synthLockBeforeMigration lockuptypes.SyntheticLock, migrationType MigrationType, err error) { + synthLockBeforeMigration, err = k.lk.GetSyntheticLockupByUnderlyingLockId(ctx, lockId) + if err != nil { + return lockuptypes.SyntheticLock{}, Unsupported, err } - if len(synthLocksBeforeMigration) == 0 { + if synthLockBeforeMigration == (lockuptypes.SyntheticLock{}) { migrationType = NonSuperfluid - } else if strings.Contains(synthLocksBeforeMigration[0].SynthDenom, "superbonding") { + } else if strings.Contains(synthLockBeforeMigration.SynthDenom, "superbonding") { migrationType = SuperfluidBonded - } else if strings.Contains(synthLocksBeforeMigration[0].SynthDenom, "superunbonding") { + } else if strings.Contains(synthLockBeforeMigration.SynthDenom, "superunbonding") { migrationType = SuperfluidUnbonding } else { - return nil, Unsupported, fmt.Errorf("lock %d contains an unsupported synthetic lock", lockId) + return lockuptypes.SyntheticLock{}, Unsupported, fmt.Errorf("lock %d contains an unsupported synthetic lock", lockId) } - return synthLocksBeforeMigration, migrationType, nil + return synthLockBeforeMigration, migrationType, nil } // validateMigration performs validation for the migration of gamm LP tokens from a Balancer pool to the canonical Concentrated pool. It performs the following steps: diff --git a/x/superfluid/keeper/migrate_test.go b/x/superfluid/keeper/migrate_test.go index e5fd70a5c98..2375937a7f1 100644 --- a/x/superfluid/keeper/migrate_test.go +++ b/x/superfluid/keeper/migrate_test.go @@ -310,10 +310,10 @@ func (s *KeeperTestSuite) TestMigrateSuperfluidBondedBalancerToConcentrated() { // Modify migration inputs if necessary if tc.overwriteValidatorAddress { - synthDenomParts := strings.Split(synthLockBeforeMigration[0].SynthDenom, "/") + synthDenomParts := strings.Split(synthLockBeforeMigration.SynthDenom, "/") synthDenomParts[4] = "osmovaloper1n69ghlk6404gzxtmtq0w7ma59n9vd9ed9dplg" // invalid, too short newSynthDenom := strings.Join(synthDenomParts, "/") - synthLockBeforeMigration[0].SynthDenom = newSynthDenom + synthLockBeforeMigration.SynthDenom = newSynthDenom } if tc.overwriteLockId { @@ -323,7 +323,7 @@ func (s *KeeperTestSuite) TestMigrateSuperfluidBondedBalancerToConcentrated() { balancerDelegationPre, _ := stakingKeeper.GetDelegation(ctx, balancerIntermediaryAcc.GetAccAddress(), valAddr) // System under test. - positionId, amount0, amount1, liquidityMigrated, _, concentratedLockId, poolIdLeaving, poolIdEntering, err := superfluidKeeper.MigrateSuperfluidBondedBalancerToConcentrated(ctx, poolJoinAcc, originalGammLockId, coinsToMigrate, synthLockBeforeMigration[0].SynthDenom, tc.tokenOutMins) + positionId, amount0, amount1, liquidityMigrated, _, concentratedLockId, poolIdLeaving, poolIdEntering, err := superfluidKeeper.MigrateSuperfluidBondedBalancerToConcentrated(ctx, poolJoinAcc, originalGammLockId, coinsToMigrate, synthLockBeforeMigration.SynthDenom, tc.tokenOutMins) if tc.expectedError != nil { s.Require().Error(err) s.Require().ErrorContains(err, tc.expectedError.Error()) @@ -470,14 +470,14 @@ func (s *KeeperTestSuite) TestMigrateSuperfluidUnbondingBalancerToConcentrated() // Modify migration inputs if necessary if tc.overwriteValidatorAddress { - synthDenomParts := strings.Split(synthLockBeforeMigration[0].SynthDenom, "/") + synthDenomParts := strings.Split(synthLockBeforeMigration.SynthDenom, "/") synthDenomParts[4] = "osmovaloper1n69ghlk6404gzxtmtq0w7ma59n9vd9ed9dplg" // invalid, too short newSynthDenom := strings.Join(synthDenomParts, "/") - synthLockBeforeMigration[0].SynthDenom = newSynthDenom + synthLockBeforeMigration.SynthDenom = newSynthDenom } // System under test. - positionId, amount0, amount1, liquidityMigrated, _, concentratedLockId, poolIdLeaving, poolIdEntering, err := superfluidKeeper.MigrateSuperfluidUnbondingBalancerToConcentrated(ctx, poolJoinAcc, originalGammLockId, coinsToMigrate, synthLockBeforeMigration[0].SynthDenom, tc.tokenOutMins) + positionId, amount0, amount1, liquidityMigrated, _, concentratedLockId, poolIdLeaving, poolIdEntering, err := superfluidKeeper.MigrateSuperfluidUnbondingBalancerToConcentrated(ctx, poolJoinAcc, originalGammLockId, coinsToMigrate, synthLockBeforeMigration.SynthDenom, tc.tokenOutMins) if tc.expectedError != nil { s.Require().Error(err) s.Require().ErrorContains(err, tc.expectedError.Error()) @@ -580,7 +580,7 @@ func (s *KeeperTestSuite) TestMigrateNonSuperfluidLockBalancerToConcentrated() { // RouteMigration is called via the migration message router and is always run prior to the migration itself synthLockBeforeMigration, migrationType, err := superfluidKeeper.RouteMigration(ctx, poolJoinAcc, originalGammLockId, coinsToMigrate) s.Require().NoError(err) - s.Require().Equal(0, len(synthLockBeforeMigration)) + s.Require().Equal((lockuptypes.SyntheticLock{}), synthLockBeforeMigration) s.Require().Equal(migrationType, keeper.NonSuperfluid) // System under test. diff --git a/x/superfluid/keeper/stake.go b/x/superfluid/keeper/stake.go index 9fd3fb273f3..e0eeeb64373 100644 --- a/x/superfluid/keeper/stake.go +++ b/x/superfluid/keeper/stake.go @@ -469,11 +469,14 @@ func (k Keeper) unbondLock(ctx sdk.Context, underlyingLockId uint64, sender stri if err != nil { return 0, err } - synthLocks := k.lk.GetAllSyntheticLockupsByLockup(ctx, underlyingLockId) - if len(synthLocks) != 1 { + synthLock, err := k.lk.GetSyntheticLockupByUnderlyingLockId(ctx, underlyingLockId) + if err != nil { + return 0, err + } + if synthLock == (lockuptypes.SyntheticLock{}) { return 0, types.ErrNotSuperfluidUsedLockup } - if !synthLocks[0].IsUnlocking() { + if !synthLock.IsUnlocking() { return 0, types.ErrBondingLockupNotSupported } return k.lk.BeginForceUnlock(ctx, underlyingLockId, coins) @@ -493,8 +496,11 @@ func (k Keeper) alreadySuperfluidStaking(ctx sdk.Context, lockID uint64) bool { return true } - synthLocks := k.lk.GetAllSyntheticLockupsByLockup(ctx, lockID) - return len(synthLocks) > 0 + synthLock, err := k.lk.GetSyntheticLockupByUnderlyingLockId(ctx, lockID) + if err != nil { + return false + } + return synthLock != (lockuptypes.SyntheticLock{}) } // mintOsmoTokensAndDelegate mints osmoAmount of OSMO tokens, and immediately delegate them to validator on behalf of intermediary account. diff --git a/x/superfluid/types/expected_keepers.go b/x/superfluid/types/expected_keepers.go index 394728f3c0d..ec181c2220a 100644 --- a/x/superfluid/types/expected_keepers.go +++ b/x/superfluid/types/expected_keepers.go @@ -41,7 +41,7 @@ type LockupKeeper interface { GetAllSyntheticLockups(ctx sdk.Context) []lockuptypes.SyntheticLock CreateSyntheticLockup(ctx sdk.Context, lockID uint64, suffix string, unlockDuration time.Duration, isUnlocking bool) error DeleteSyntheticLockup(ctx sdk.Context, lockID uint64, suffix string) error - GetAllSyntheticLockupsByLockup(ctx sdk.Context, lockID uint64) []lockuptypes.SyntheticLock + GetSyntheticLockupByUnderlyingLockId(ctx sdk.Context, lockID uint64) (lockuptypes.SyntheticLock, error) } type LockupMsgServer interface { diff --git a/x/valset-pref/types/expected_interfaces.go b/x/valset-pref/types/expected_interfaces.go index 7eb585b4c31..03fe0191332 100644 --- a/x/valset-pref/types/expected_interfaces.go +++ b/x/valset-pref/types/expected_interfaces.go @@ -33,7 +33,7 @@ type DistributionKeeper interface { } type LockupKeeper interface { GetLockByID(ctx sdk.Context, lockID uint64) (*lockuptypes.PeriodLock, error) - GetAllSyntheticLockupsByLockup(ctx sdk.Context, lockID uint64) []lockuptypes.SyntheticLock + GetSyntheticLockupByUnderlyingLockId(ctx sdk.Context, lockID uint64) (lockuptypes.SyntheticLock, error) ForceUnlock(ctx sdk.Context, lock lockuptypes.PeriodLock) error BeginUnlock(ctx sdk.Context, lockID uint64, coins sdk.Coins) (uint64, error) GetPeriodLocks(ctx sdk.Context) ([]lockuptypes.PeriodLock, error) diff --git a/x/valset-pref/validator_set.go b/x/valset-pref/validator_set.go index 4d4d6f2471f..599606696ac 100644 --- a/x/valset-pref/validator_set.go +++ b/x/valset-pref/validator_set.go @@ -353,8 +353,11 @@ func (k Keeper) ForceUnlockBondedOsmo(ctx sdk.Context, lockID uint64, delegatorA } // Ensured the lock has no superfluid relation by checking that there are no synthetic locks - synthLocks := k.lockupKeeper.GetAllSyntheticLockupsByLockup(ctx, lockID) - if len(synthLocks) != 0 { + synthLocks, err := k.lockupKeeper.GetSyntheticLockupByUnderlyingLockId(ctx, lockID) + if err != nil { + return sdk.Coin{}, err + } + if synthLocks != (lockuptypes.SyntheticLock{}) { return sdk.Coin{}, fmt.Errorf("cannot use DelegateBondedTokens being used for superfluid.") } From 95e1f4649d37d853e6020c15b1bdb80ae6f85d16 Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Mon, 22 May 2023 17:51:21 -0500 Subject: [PATCH 2/9] add changelog entry --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e605d96a7e..4f697506fa8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -70,7 +70,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * [#5165](https://github.com/osmosis-labs/osmosis/pull/5165) Improve error message when fully exiting from a pool. * [#5187](https://github.com/osmosis-labs/osmosis/pull/5187) Expand `IncentivizedPools` query to include internally incentivized CL pools. * [#5239](https://github.com/osmosis-labs/osmosis/pull/5239) Implement `GetTotalPoolShares` public keeper function for GAMM. - + * [#5265](https://github.com/osmosis-labs/osmosis/pull/5265) Ensure a lock cannot point to multiple synthetic locks. + ### API breaks * [#4336](https://github.com/osmosis-labs/osmosis/pull/4336) Move epochs module into its own go.mod From 12707bc8dbaa65cf96617e268fbfdf08bbf0307b Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Mon, 22 May 2023 19:10:59 -0500 Subject: [PATCH 3/9] deprecate SyntheticLockupsByLockupID --- CHANGELOG.md | 2 +- proto/osmosis/lockup/query.proto | 14 + x/lockup/keeper/grpc_query.go | 15 + x/lockup/types/query.pb.go | 596 +++++++++++++++++++++++++------ x/lockup/types/query.pb.gw.go | 101 ++++++ 5 files changed, 619 insertions(+), 109 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4f697506fa8..da6ff92dcc3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -70,7 +70,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * [#5165](https://github.com/osmosis-labs/osmosis/pull/5165) Improve error message when fully exiting from a pool. * [#5187](https://github.com/osmosis-labs/osmosis/pull/5187) Expand `IncentivizedPools` query to include internally incentivized CL pools. * [#5239](https://github.com/osmosis-labs/osmosis/pull/5239) Implement `GetTotalPoolShares` public keeper function for GAMM. - * [#5265](https://github.com/osmosis-labs/osmosis/pull/5265) Ensure a lock cannot point to multiple synthetic locks. + * [#5265](https://github.com/osmosis-labs/osmosis/pull/5265) Ensure a lock cannot point to multiple synthetic locks. Deprecates `SyntheticLockupsByLockupID` in favor of `SyntheticLockupByLockupID`. ### API breaks diff --git a/proto/osmosis/lockup/query.proto b/proto/osmosis/lockup/query.proto index de4d8ba5d68..37d29f32958 100644 --- a/proto/osmosis/lockup/query.proto +++ b/proto/osmosis/lockup/query.proto @@ -88,6 +88,15 @@ service Query { option (google.api.http).get = "/osmosis/lockup/v1beta1/next_lock_id"; } + // Returns synthetic lockup by native lockup id + // Deprecated: use SyntheticLockupByLockupID instead + rpc SyntheticLockupsByLockupID(SyntheticLockupsByLockupIDRequest) + returns (SyntheticLockupsByLockupIDResponse) { + option deprecated = true; + option (google.api.http).get = + "/osmosis/lockup/v1beta1/synthetic_lockups_by_lock_id/{lock_id}"; + } + // Returns synthetic lockup by native lockup id rpc SyntheticLockupByLockupID(SyntheticLockupByLockupIDRequest) returns (SyntheticLockupByLockupIDResponse) { @@ -247,6 +256,11 @@ message LockedResponse { PeriodLock lock = 1; }; message NextLockIDRequest {}; message NextLockIDResponse { uint64 lock_id = 1; }; +message SyntheticLockupsByLockupIDRequest { uint64 lock_id = 1; } +message SyntheticLockupsByLockupIDResponse { + repeated SyntheticLock synthetic_locks = 1 [ (gogoproto.nullable) = false ]; +} + message SyntheticLockupByLockupIDRequest { uint64 lock_id = 1; } message SyntheticLockupByLockupIDResponse { SyntheticLock synthetic_lock = 1 [ (gogoproto.nullable) = false ]; diff --git a/x/lockup/keeper/grpc_query.go b/x/lockup/keeper/grpc_query.go index b61a322a605..c8a56cba7c0 100644 --- a/x/lockup/keeper/grpc_query.go +++ b/x/lockup/keeper/grpc_query.go @@ -177,6 +177,21 @@ func (q Querier) NextLockID(goCtx context.Context, req *types.NextLockIDRequest) return &types.NextLockIDResponse{LockId: nextLockID}, nil } +// SyntheticLockupsByLockupID returns synthetic lockups by native lockup id. +// Deprecated: use SyntheticLockupByLockupID instead. +func (q Querier) SyntheticLockupsByLockupID(goCtx context.Context, req *types.SyntheticLockupsByLockupIDRequest) (*types.SyntheticLockupsByLockupIDResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(goCtx) + synthLock, err := q.Keeper.GetSyntheticLockupByUnderlyingLockId(ctx, req.LockId) + if err != nil { + return nil, err + } + return &types.SyntheticLockupsByLockupIDResponse{SyntheticLocks: []types.SyntheticLock{synthLock}}, nil +} + // SyntheticLockupByLockupID returns synthetic lockup by native lockup id. func (q Querier) SyntheticLockupByLockupID(goCtx context.Context, req *types.SyntheticLockupByLockupIDRequest) (*types.SyntheticLockupByLockupIDResponse, error) { if req == nil { diff --git a/x/lockup/types/query.pb.go b/x/lockup/types/query.pb.go index 73de31a2c2a..445432e8457 100644 --- a/x/lockup/types/query.pb.go +++ b/x/lockup/types/query.pb.go @@ -1116,6 +1116,94 @@ func (m *NextLockIDResponse) GetLockId() uint64 { return 0 } +type SyntheticLockupsByLockupIDRequest struct { + LockId uint64 `protobuf:"varint,1,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"` +} + +func (m *SyntheticLockupsByLockupIDRequest) Reset() { *m = SyntheticLockupsByLockupIDRequest{} } +func (m *SyntheticLockupsByLockupIDRequest) String() string { return proto.CompactTextString(m) } +func (*SyntheticLockupsByLockupIDRequest) ProtoMessage() {} +func (*SyntheticLockupsByLockupIDRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_e906fda01cffd91a, []int{24} +} +func (m *SyntheticLockupsByLockupIDRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyntheticLockupsByLockupIDRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyntheticLockupsByLockupIDRequest.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 *SyntheticLockupsByLockupIDRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyntheticLockupsByLockupIDRequest.Merge(m, src) +} +func (m *SyntheticLockupsByLockupIDRequest) XXX_Size() int { + return m.Size() +} +func (m *SyntheticLockupsByLockupIDRequest) XXX_DiscardUnknown() { + xxx_messageInfo_SyntheticLockupsByLockupIDRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_SyntheticLockupsByLockupIDRequest proto.InternalMessageInfo + +func (m *SyntheticLockupsByLockupIDRequest) GetLockId() uint64 { + if m != nil { + return m.LockId + } + return 0 +} + +type SyntheticLockupsByLockupIDResponse struct { + SyntheticLocks []SyntheticLock `protobuf:"bytes,1,rep,name=synthetic_locks,json=syntheticLocks,proto3" json:"synthetic_locks"` +} + +func (m *SyntheticLockupsByLockupIDResponse) Reset() { *m = SyntheticLockupsByLockupIDResponse{} } +func (m *SyntheticLockupsByLockupIDResponse) String() string { return proto.CompactTextString(m) } +func (*SyntheticLockupsByLockupIDResponse) ProtoMessage() {} +func (*SyntheticLockupsByLockupIDResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_e906fda01cffd91a, []int{25} +} +func (m *SyntheticLockupsByLockupIDResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SyntheticLockupsByLockupIDResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SyntheticLockupsByLockupIDResponse.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 *SyntheticLockupsByLockupIDResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_SyntheticLockupsByLockupIDResponse.Merge(m, src) +} +func (m *SyntheticLockupsByLockupIDResponse) XXX_Size() int { + return m.Size() +} +func (m *SyntheticLockupsByLockupIDResponse) XXX_DiscardUnknown() { + xxx_messageInfo_SyntheticLockupsByLockupIDResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_SyntheticLockupsByLockupIDResponse proto.InternalMessageInfo + +func (m *SyntheticLockupsByLockupIDResponse) GetSyntheticLocks() []SyntheticLock { + if m != nil { + return m.SyntheticLocks + } + return nil +} + type SyntheticLockupByLockupIDRequest struct { LockId uint64 `protobuf:"varint,1,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"` } @@ -1124,7 +1212,7 @@ func (m *SyntheticLockupByLockupIDRequest) Reset() { *m = SyntheticLocku func (m *SyntheticLockupByLockupIDRequest) String() string { return proto.CompactTextString(m) } func (*SyntheticLockupByLockupIDRequest) ProtoMessage() {} func (*SyntheticLockupByLockupIDRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{24} + return fileDescriptor_e906fda01cffd91a, []int{26} } func (m *SyntheticLockupByLockupIDRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1168,7 +1256,7 @@ func (m *SyntheticLockupByLockupIDResponse) Reset() { *m = SyntheticLock func (m *SyntheticLockupByLockupIDResponse) String() string { return proto.CompactTextString(m) } func (*SyntheticLockupByLockupIDResponse) ProtoMessage() {} func (*SyntheticLockupByLockupIDResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{25} + return fileDescriptor_e906fda01cffd91a, []int{27} } func (m *SyntheticLockupByLockupIDResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1213,7 +1301,7 @@ func (m *AccountLockedLongerDurationRequest) Reset() { *m = AccountLocke func (m *AccountLockedLongerDurationRequest) String() string { return proto.CompactTextString(m) } func (*AccountLockedLongerDurationRequest) ProtoMessage() {} func (*AccountLockedLongerDurationRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{26} + return fileDescriptor_e906fda01cffd91a, []int{28} } func (m *AccountLockedLongerDurationRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1264,7 +1352,7 @@ func (m *AccountLockedLongerDurationResponse) Reset() { *m = AccountLock func (m *AccountLockedLongerDurationResponse) String() string { return proto.CompactTextString(m) } func (*AccountLockedLongerDurationResponse) ProtoMessage() {} func (*AccountLockedLongerDurationResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{27} + return fileDescriptor_e906fda01cffd91a, []int{29} } func (m *AccountLockedLongerDurationResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1309,7 +1397,7 @@ func (m *AccountLockedDurationRequest) Reset() { *m = AccountLockedDurat func (m *AccountLockedDurationRequest) String() string { return proto.CompactTextString(m) } func (*AccountLockedDurationRequest) ProtoMessage() {} func (*AccountLockedDurationRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{28} + return fileDescriptor_e906fda01cffd91a, []int{30} } func (m *AccountLockedDurationRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1360,7 +1448,7 @@ func (m *AccountLockedDurationResponse) Reset() { *m = AccountLockedDura func (m *AccountLockedDurationResponse) String() string { return proto.CompactTextString(m) } func (*AccountLockedDurationResponse) ProtoMessage() {} func (*AccountLockedDurationResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{29} + return fileDescriptor_e906fda01cffd91a, []int{31} } func (m *AccountLockedDurationResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1409,7 +1497,7 @@ func (m *AccountLockedLongerDurationNotUnlockingOnlyRequest) String() string { } func (*AccountLockedLongerDurationNotUnlockingOnlyRequest) ProtoMessage() {} func (*AccountLockedLongerDurationNotUnlockingOnlyRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{30} + return fileDescriptor_e906fda01cffd91a, []int{32} } func (m *AccountLockedLongerDurationNotUnlockingOnlyRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1464,7 +1552,7 @@ func (m *AccountLockedLongerDurationNotUnlockingOnlyResponse) String() string { } func (*AccountLockedLongerDurationNotUnlockingOnlyResponse) ProtoMessage() {} func (*AccountLockedLongerDurationNotUnlockingOnlyResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{31} + return fileDescriptor_e906fda01cffd91a, []int{33} } func (m *AccountLockedLongerDurationNotUnlockingOnlyResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1512,7 +1600,7 @@ func (m *AccountLockedLongerDurationDenomRequest) Reset() { func (m *AccountLockedLongerDurationDenomRequest) String() string { return proto.CompactTextString(m) } func (*AccountLockedLongerDurationDenomRequest) ProtoMessage() {} func (*AccountLockedLongerDurationDenomRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{32} + return fileDescriptor_e906fda01cffd91a, []int{34} } func (m *AccountLockedLongerDurationDenomRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1572,7 +1660,7 @@ func (m *AccountLockedLongerDurationDenomResponse) Reset() { func (m *AccountLockedLongerDurationDenomResponse) String() string { return proto.CompactTextString(m) } func (*AccountLockedLongerDurationDenomResponse) ProtoMessage() {} func (*AccountLockedLongerDurationDenomResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_e906fda01cffd91a, []int{33} + return fileDescriptor_e906fda01cffd91a, []int{35} } func (m *AccountLockedLongerDurationDenomResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1615,7 +1703,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_e906fda01cffd91a, []int{34} + return fileDescriptor_e906fda01cffd91a, []int{36} } func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1652,7 +1740,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_e906fda01cffd91a, []int{35} + return fileDescriptor_e906fda01cffd91a, []int{37} } func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1713,6 +1801,8 @@ func init() { proto.RegisterType((*LockedResponse)(nil), "osmosis.lockup.LockedResponse") proto.RegisterType((*NextLockIDRequest)(nil), "osmosis.lockup.NextLockIDRequest") proto.RegisterType((*NextLockIDResponse)(nil), "osmosis.lockup.NextLockIDResponse") + proto.RegisterType((*SyntheticLockupsByLockupIDRequest)(nil), "osmosis.lockup.SyntheticLockupsByLockupIDRequest") + proto.RegisterType((*SyntheticLockupsByLockupIDResponse)(nil), "osmosis.lockup.SyntheticLockupsByLockupIDResponse") proto.RegisterType((*SyntheticLockupByLockupIDRequest)(nil), "osmosis.lockup.SyntheticLockupByLockupIDRequest") proto.RegisterType((*SyntheticLockupByLockupIDResponse)(nil), "osmosis.lockup.SyntheticLockupByLockupIDResponse") proto.RegisterType((*AccountLockedLongerDurationRequest)(nil), "osmosis.lockup.AccountLockedLongerDurationRequest") @@ -1730,103 +1820,107 @@ func init() { func init() { proto.RegisterFile("osmosis/lockup/query.proto", fileDescriptor_e906fda01cffd91a) } var fileDescriptor_e906fda01cffd91a = []byte{ - // 1535 bytes of a gzipped FileDescriptorProto + // 1593 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x14, 0x45, - 0x14, 0x4f, 0x03, 0x89, 0xf2, 0x30, 0x88, 0x4d, 0xc0, 0x64, 0x02, 0xbb, 0x61, 0x80, 0xb8, 0x6a, - 0x76, 0x86, 0x04, 0x04, 0x44, 0x3e, 0x97, 0x88, 0x15, 0x8c, 0x08, 0x0b, 0x4a, 0xf9, 0x55, 0x5b, - 0xb3, 0xbb, 0xcd, 0x32, 0xc5, 0xee, 0xf4, 0xb2, 0x33, 0x8b, 0xac, 0x14, 0x52, 0x82, 0x47, 0x0f, - 0x58, 0x5e, 0x2c, 0x0f, 0x96, 0x7a, 0xd3, 0x83, 0xe5, 0xc5, 0x03, 0xe5, 0x5d, 0x29, 0x0f, 0x16, - 0x55, 0x5e, 0x2c, 0x0f, 0xc1, 0x22, 0xfe, 0x05, 0x9c, 0x3c, 0x78, 0xb0, 0xa6, 0xbb, 0x67, 0xb2, - 0xf3, 0xb9, 0xb3, 0xbb, 0x92, 0xca, 0x29, 0xd9, 0x79, 0xaf, 0xdf, 0xfb, 0xfd, 0x5e, 0xbf, 0xee, - 0x37, 0xbf, 0x01, 0x89, 0x9a, 0x35, 0x6a, 0xea, 0xa6, 0x5a, 0xa5, 0xa5, 0x4b, 0xcd, 0xba, 0x7a, - 0xb9, 0x49, 0x1a, 0x2d, 0xa5, 0xde, 0xa0, 0x16, 0xc5, 0xeb, 0x85, 0x4d, 0xe1, 0x36, 0x69, 0xa4, - 0x42, 0x2b, 0x94, 0x99, 0x54, 0xfb, 0x3f, 0xee, 0x25, 0xa5, 0x4a, 0xcc, 0x4d, 0x2d, 0x6a, 0x26, - 0x51, 0xaf, 0x4c, 0x17, 0x89, 0xa5, 0x4d, 0xab, 0x25, 0xaa, 0x1b, 0xc2, 0xbe, 0xa5, 0x42, 0x69, - 0xa5, 0x4a, 0x54, 0xad, 0xae, 0xab, 0x9a, 0x61, 0x50, 0x4b, 0xb3, 0x74, 0x6a, 0x98, 0xc2, 0x9a, - 0x16, 0x56, 0xf6, 0xab, 0xd8, 0xbc, 0xa0, 0x5a, 0x7a, 0x8d, 0x98, 0x96, 0x56, 0xab, 0x3b, 0xe1, - 0xfd, 0x0e, 0xe5, 0x66, 0x83, 0x45, 0x10, 0xf6, 0x31, 0x1f, 0x01, 0xfb, 0x8f, 0x30, 0x8d, 0xfb, - 0x4c, 0x75, 0xad, 0xa1, 0xd5, 0x44, 0x62, 0x79, 0x33, 0x8c, 0xbc, 0x46, 0xcb, 0xcd, 0x2a, 0xc9, - 0x69, 0x55, 0xcd, 0x28, 0x91, 0x3c, 0xb9, 0xdc, 0x24, 0xa6, 0x25, 0x7f, 0x00, 0x9b, 0x7c, 0xcf, - 0xcd, 0x3a, 0x35, 0x4c, 0x82, 0x35, 0x18, 0xb4, 0x59, 0x99, 0xa3, 0x68, 0x62, 0x75, 0x66, 0xdd, - 0xcc, 0x98, 0xc2, 0x79, 0x2b, 0x36, 0x6f, 0x45, 0xf0, 0x56, 0x8e, 0x53, 0xdd, 0xc8, 0xed, 0xba, - 0xbb, 0x90, 0x1e, 0xf8, 0xee, 0x7e, 0x3a, 0x53, 0xd1, 0xad, 0x8b, 0xcd, 0xa2, 0x52, 0xa2, 0x35, - 0x55, 0x14, 0x89, 0xff, 0xc9, 0x9a, 0xe5, 0x4b, 0xaa, 0xd5, 0xaa, 0x13, 0x93, 0x2d, 0x30, 0xf3, - 0x3c, 0xb2, 0x3c, 0x0e, 0x63, 0x3c, 0xf7, 0x3c, 0x2d, 0x5d, 0x22, 0xe5, 0x63, 0x35, 0xda, 0x34, - 0x2c, 0x07, 0xd8, 0x0d, 0x90, 0xc2, 0x8c, 0xcb, 0x87, 0xee, 0x15, 0xd8, 0x7a, 0xac, 0x54, 0xb2, - 0xb3, 0xbe, 0x61, 0xd8, 0x15, 0xd5, 0x8a, 0x55, 0xc2, 0x1d, 0x38, 0x42, 0x3c, 0x09, 0x83, 0xf4, - 0x7d, 0x83, 0x34, 0x46, 0xd1, 0x04, 0xca, 0xac, 0xcd, 0x6d, 0x78, 0xb8, 0x90, 0x7e, 0xa2, 0xa5, - 0xd5, 0xaa, 0x07, 0x64, 0xf6, 0x58, 0xce, 0x73, 0xb3, 0x7c, 0x0b, 0x41, 0x2a, 0x2a, 0xd2, 0xf2, - 0xd1, 0x39, 0x01, 0x5b, 0x3c, 0x20, 0x74, 0xa3, 0xd2, 0x13, 0x9b, 0x9b, 0xc8, 0x57, 0x97, 0xa5, - 0x40, 0xcb, 0x47, 0xe6, 0x38, 0x8c, 0x09, 0x0c, 0xbc, 0x3b, 0x7a, 0x62, 0x72, 0x03, 0xa4, 0xb0, - 0x20, 0xcb, 0xc7, 0xe2, 0x4b, 0xe4, 0xee, 0x09, 0x47, 0x70, 0x5a, 0x33, 0xad, 0x73, 0x7a, 0x8d, - 0x74, 0xc9, 0x04, 0xbf, 0x09, 0x6b, 0xdd, 0x7b, 0x64, 0x74, 0xd5, 0x04, 0xca, 0xac, 0x9b, 0x91, - 0x14, 0x7e, 0x91, 0x28, 0xce, 0x45, 0xa2, 0x9c, 0x73, 0x3c, 0x72, 0x5b, 0x6c, 0xc0, 0x0f, 0x17, - 0xd2, 0x1b, 0x78, 0x2c, 0x77, 0xa9, 0x7c, 0xfb, 0x7e, 0x1a, 0xe5, 0x97, 0x42, 0xc9, 0xe7, 0xdd, - 0xad, 0xf6, 0xe3, 0x13, 0x45, 0xda, 0x0b, 0x83, 0x76, 0x0b, 0x38, 0x45, 0x92, 0x14, 0xef, 0x15, - 0xaa, 0x9c, 0x26, 0x0d, 0x9d, 0x96, 0xed, 0xc5, 0xb9, 0x35, 0x76, 0xd2, 0x3c, 0x77, 0x97, 0xbf, - 0x47, 0x30, 0x15, 0x1a, 0xf9, 0x14, 0x5d, 0xea, 0xaa, 0xd7, 0x8d, 0x6a, 0x6b, 0xa5, 0x54, 0xa2, - 0x02, 0xd9, 0x84, 0x78, 0xfb, 0xac, 0xcc, 0x37, 0x08, 0x26, 0x3c, 0xc7, 0x8b, 0x94, 0x73, 0xe4, - 0x02, 0x6d, 0x90, 0x95, 0xd4, 0x17, 0xef, 0xc0, 0xb6, 0x18, 0x8c, 0x7d, 0x56, 0xe0, 0x0e, 0x72, - 0xa3, 0x7b, 0x6b, 0x3d, 0x4b, 0x0c, 0x5a, 0x5b, 0x21, 0x25, 0xc0, 0x23, 0x30, 0x58, 0xb6, 0xf1, - 0x8c, 0xae, 0xb6, 0xf3, 0xe7, 0xf9, 0x0f, 0xf9, 0x5d, 0x90, 0xe3, 0xa0, 0xf7, 0x59, 0x99, 0x0f, - 0x01, 0xf3, 0xb0, 0x9e, 0x4a, 0xb8, 0x48, 0x50, 0x1b, 0x12, 0x9c, 0x87, 0xc7, 0x9d, 0x37, 0x07, - 0x41, 0x7b, 0x2c, 0x40, 0x7b, 0x56, 0x38, 0xe4, 0xc6, 0x05, 0xeb, 0x27, 0x39, 0x6b, 0x67, 0xa1, - 0xfc, 0xb9, 0x4d, 0xda, 0x8d, 0x23, 0x1b, 0xb0, 0xd1, 0x93, 0x5f, 0xd0, 0x39, 0x0f, 0x43, 0x1a, - 0x9b, 0xce, 0x62, 0x2f, 0x8e, 0xd8, 0xd1, 0xfe, 0x5c, 0x48, 0x4f, 0x26, 0xb8, 0x0f, 0xe7, 0x0c, - 0xeb, 0xe1, 0x42, 0x7a, 0x98, 0xe7, 0xe5, 0x51, 0xe4, 0xbc, 0x08, 0x27, 0x67, 0x60, 0x98, 0xe7, - 0x73, 0xa8, 0x3e, 0x0d, 0x8f, 0xd9, 0x95, 0x28, 0xe8, 0x65, 0x96, 0x6a, 0x4d, 0x7e, 0xc8, 0xfe, - 0x39, 0x57, 0x96, 0x8f, 0xc2, 0x7a, 0xc7, 0x53, 0x80, 0x52, 0x60, 0x8d, 0x6d, 0x63, 0x7e, 0xb1, - 0x25, 0xce, 0x33, 0x3f, 0x79, 0x23, 0x3c, 0x75, 0x8a, 0x5c, 0x65, 0xdb, 0x36, 0x37, 0xeb, 0xbc, - 0x83, 0x64, 0x01, 0xb7, 0x3f, 0x14, 0xa1, 0x23, 0x51, 0xbc, 0x04, 0x13, 0x67, 0x5b, 0x86, 0x75, - 0x91, 0x58, 0x7a, 0x69, 0x9e, 0xe5, 0xc9, 0xb5, 0xf8, 0x5f, 0x37, 0x64, 0xf4, 0x62, 0x0a, 0xdb, - 0x62, 0x16, 0x8b, 0xd4, 0x27, 0x61, 0xbd, 0xe9, 0x38, 0x15, 0xda, 0xf8, 0x6d, 0xf5, 0xf3, 0xf3, - 0x84, 0x12, 0x5d, 0x34, 0x6c, 0xb6, 0x3f, 0x94, 0xbf, 0x42, 0xbe, 0x66, 0x9d, 0xa7, 0x46, 0x85, - 0x34, 0x9c, 0xa6, 0xe8, 0xf6, 0xa0, 0x3d, 0x8a, 0x86, 0x7b, 0x0f, 0xb6, 0xc7, 0x22, 0xec, 0xf3, - 0x3c, 0x7d, 0xe1, 0x9f, 0xbf, 0x2b, 0x89, 0xbb, 0x7f, 0xf6, 0xfe, 0x6f, 0xac, 0x7f, 0x40, 0x30, - 0x13, 0x53, 0xd5, 0x7e, 0x27, 0xf0, 0xa3, 0xa8, 0x45, 0x0d, 0x76, 0x77, 0x85, 0xb8, 0xcf, 0x0a, - 0xfd, 0x84, 0xe0, 0x99, 0x98, 0x7c, 0x3d, 0xcd, 0xa1, 0x47, 0x50, 0x96, 0x88, 0x19, 0x54, 0x84, - 0x4c, 0x67, 0xf0, 0x7d, 0x56, 0x68, 0x04, 0xf0, 0x19, 0x5b, 0x39, 0x9f, 0x66, 0x12, 0xd3, 0xb9, - 0x2e, 0x5f, 0x85, 0x8d, 0x9e, 0xa7, 0x22, 0xc9, 0x1e, 0x18, 0xe2, 0x52, 0x54, 0x5c, 0x56, 0x9b, - 0x03, 0x59, 0x98, 0x55, 0x64, 0x10, 0xbe, 0x33, 0xff, 0x8e, 0xc1, 0x20, 0x8b, 0x86, 0x3f, 0x41, - 0x30, 0xec, 0xd1, 0xa8, 0x78, 0x87, 0x3f, 0x42, 0x98, 0xb4, 0x95, 0x76, 0x76, 0xf0, 0xe2, 0xf0, - 0x64, 0xe5, 0xe6, 0xef, 0x7f, 0x7f, 0xb6, 0x2a, 0x83, 0x27, 0x55, 0x9f, 0x7e, 0x76, 0xc4, 0x7d, - 0x8d, 0x2d, 0x2b, 0x14, 0x45, 0xf2, 0xaf, 0x11, 0xe0, 0xa0, 0x32, 0xc5, 0xcf, 0x86, 0x67, 0x0b, - 0x91, 0xb6, 0xd2, 0x73, 0x49, 0x5c, 0x05, 0xba, 0x3d, 0x0c, 0x9d, 0x82, 0xa7, 0x3a, 0xa0, 0xe3, - 0xaf, 0x61, 0x05, 0x3e, 0x39, 0xf1, 0x1d, 0x04, 0x9b, 0xc3, 0x25, 0x27, 0xce, 0xfa, 0x93, 0xc7, - 0x8a, 0x5c, 0x49, 0x49, 0xea, 0x2e, 0xf0, 0x1e, 0x65, 0x78, 0x0f, 0xe0, 0xfd, 0x51, 0x78, 0x35, - 0xbe, 0xbe, 0xd0, 0x74, 0x03, 0x14, 0x98, 0x1a, 0x52, 0xaf, 0xb1, 0x83, 0x72, 0x1d, 0xff, 0x88, - 0x60, 0x53, 0xa8, 0xc0, 0xc4, 0x53, 0xb1, 0x58, 0x7c, 0x82, 0x56, 0xca, 0x26, 0xf4, 0x16, 0xc0, - 0x8f, 0x30, 0xe0, 0x2f, 0xe2, 0x7d, 0xc9, 0x80, 0xeb, 0x46, 0xc5, 0x87, 0xfb, 0x5b, 0x04, 0x38, - 0xa8, 0x27, 0x83, 0x7d, 0x11, 0x29, 0x5c, 0x83, 0x7d, 0x11, 0x2d, 0x4f, 0xe5, 0x83, 0x0c, 0xee, - 0x5e, 0xbc, 0xa7, 0x13, 0x5c, 0xd1, 0x18, 0x91, 0x35, 0xf6, 0xbe, 0xa8, 0x46, 0xd6, 0x38, 0x54, - 0xa0, 0x46, 0xd6, 0x38, 0x5c, 0x2e, 0x26, 0xaf, 0xb1, 0x00, 0x5d, 0xd7, 0x4c, 0xcb, 0x7e, 0xe5, - 0x76, 0x71, 0xff, 0x83, 0x60, 0x67, 0x22, 0x1d, 0x86, 0x0f, 0x26, 0x42, 0x16, 0x31, 0xec, 0xa4, - 0x43, 0x3d, 0xae, 0x16, 0x3c, 0xf3, 0x8c, 0xe7, 0x3c, 0x3e, 0xd9, 0x25, 0xcf, 0x82, 0x41, 0xdb, - 0xfb, 0x8b, 0x1a, 0xd5, 0x96, 0x4b, 0xfd, 0x67, 0xe4, 0x7e, 0xf3, 0x08, 0x8a, 0x2e, 0xbc, 0x2b, - 0xb6, 0xd9, 0x43, 0x34, 0xa4, 0x34, 0xdd, 0xc5, 0x0a, 0x41, 0x6b, 0x96, 0xd1, 0x3a, 0x8c, 0x0f, - 0x26, 0x3b, 0x22, 0xa4, 0x5c, 0x28, 0xb2, 0x20, 0x05, 0xcf, 0x1e, 0xfe, 0x8a, 0x7c, 0xdf, 0x5d, - 0x3c, 0x22, 0x09, 0x4f, 0x27, 0x2a, 0x7d, 0xfb, 0x0c, 0x96, 0x66, 0xba, 0x59, 0x22, 0xb8, 0xbc, - 0xcc, 0xb8, 0x1c, 0xc1, 0x87, 0xba, 0xdd, 0x22, 0x36, 0x64, 0x5d, 0x32, 0x1f, 0x23, 0x58, 0xd7, - 0xa6, 0x89, 0xb0, 0xec, 0x87, 0x12, 0x14, 0x6c, 0xd2, 0xf6, 0x58, 0x1f, 0x81, 0x6f, 0x8a, 0xe1, - 0x9b, 0xc4, 0x3b, 0xa2, 0xf0, 0x09, 0x5c, 0x5c, 0xed, 0xdd, 0x42, 0x00, 0x3c, 0x4a, 0xae, 0x35, - 0x37, 0x8b, 0xb7, 0x86, 0x67, 0x70, 0x00, 0xa4, 0xa2, 0xcc, 0x22, 0xf7, 0x5e, 0x96, 0x7b, 0x17, - 0x56, 0x3a, 0xe4, 0x2e, 0xb6, 0x0a, 0x7a, 0x59, 0xbd, 0x26, 0xf4, 0xcc, 0x75, 0xfc, 0x11, 0x02, - 0x58, 0xd2, 0x4b, 0x78, 0x9b, 0x3f, 0x4d, 0x40, 0x60, 0x49, 0x72, 0x9c, 0x4b, 0xd2, 0x4a, 0x18, - 0xe4, 0x2a, 0xdf, 0xa6, 0x82, 0x5e, 0xc6, 0xbf, 0x20, 0x18, 0x8b, 0xd4, 0x51, 0xc1, 0x63, 0xd2, - 0x49, 0xaf, 0x05, 0x8f, 0x49, 0x47, 0x91, 0xd6, 0xb9, 0xb5, 0xbc, 0x12, 0xae, 0x59, 0xb7, 0x0b, - 0x29, 0xf0, 0xb7, 0x55, 0xf3, 0x37, 0x04, 0xe3, 0x31, 0x2f, 0x72, 0x38, 0xbe, 0xeb, 0x43, 0xc5, - 0x9c, 0xb4, 0xbb, 0xab, 0x35, 0x82, 0xcf, 0x09, 0xc6, 0xe7, 0x28, 0x3e, 0x9c, 0xf0, 0xa8, 0x54, - 0x59, 0x98, 0x82, 0xf3, 0x9a, 0x1a, 0x3d, 0x74, 0x5c, 0x2a, 0xf1, 0x43, 0xc7, 0x4f, 0x22, 0x9b, - 0xd0, 0xbb, 0xc7, 0xa1, 0x13, 0xc0, 0xfd, 0xe9, 0x2a, 0x78, 0xbe, 0x0b, 0xf9, 0x81, 0x73, 0x5d, - 0x14, 0x39, 0x6a, 0x00, 0x1d, 0xef, 0x2b, 0x86, 0x60, 0xfe, 0x16, 0x63, 0x7e, 0x16, 0x9f, 0xe9, - 0x6d, 0xe3, 0xe2, 0xa6, 0xd1, 0xe2, 0xd2, 0x67, 0xca, 0x48, 0x95, 0x81, 0xf7, 0x75, 0x41, 0xc2, - 0x73, 0x43, 0xee, 0xef, 0x7e, 0xa1, 0xa0, 0x3c, 0xcf, 0x28, 0x9f, 0xc0, 0xb3, 0x3d, 0x52, 0xf6, - 0xde, 0xee, 0x2d, 0x18, 0xe2, 0xda, 0x24, 0x78, 0xaf, 0x07, 0xe5, 0x4f, 0xf0, 0x5e, 0x0f, 0x11, - 0x43, 0xf2, 0x24, 0x03, 0x38, 0x81, 0x53, 0x51, 0x00, 0xb9, 0xfc, 0xc9, 0xcd, 0xdf, 0x7d, 0x90, - 0x42, 0xf7, 0x1e, 0xa4, 0xd0, 0x5f, 0x0f, 0x52, 0xe8, 0xf6, 0x62, 0x6a, 0xe0, 0xde, 0x62, 0x6a, - 0xe0, 0x8f, 0xc5, 0xd4, 0xc0, 0xdb, 0x33, 0x6d, 0x9f, 0xd5, 0x44, 0x8c, 0x6c, 0x55, 0x2b, 0x9a, - 0x6e, 0xc0, 0x2b, 0xd3, 0x2f, 0xa8, 0x57, 0x9d, 0xb0, 0xec, 0x33, 0x5b, 0x71, 0x88, 0x69, 0xcc, - 0xdd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xf1, 0x05, 0x5b, 0xfd, 0xff, 0x1c, 0x00, 0x00, + 0x14, 0x4f, 0x07, 0x12, 0xe5, 0x61, 0x02, 0x36, 0x01, 0x93, 0x09, 0xec, 0x86, 0x01, 0x62, 0xd4, + 0xec, 0x0c, 0x09, 0x08, 0x88, 0xe1, 0x6b, 0x89, 0x58, 0xc1, 0x15, 0x61, 0x41, 0x29, 0xbf, 0x6a, + 0x6b, 0x76, 0x77, 0x58, 0xa6, 0xd8, 0x9d, 0x5e, 0x76, 0x66, 0x91, 0x95, 0x42, 0x4a, 0xf0, 0xe0, + 0xc1, 0x03, 0x96, 0x17, 0xcb, 0x83, 0xa5, 0xde, 0xf4, 0x60, 0x79, 0xf1, 0x40, 0x79, 0x57, 0xca, + 0x2a, 0x2d, 0xaa, 0xbc, 0x58, 0x1e, 0x82, 0x45, 0xfc, 0x0b, 0x38, 0x79, 0xb4, 0xa6, 0xbb, 0x67, + 0xb2, 0xf3, 0xb9, 0x33, 0xbb, 0x92, 0xca, 0x69, 0x77, 0xa6, 0x5f, 0xbf, 0xf7, 0xfb, 0xbd, 0x7e, + 0xdd, 0xaf, 0x7f, 0x03, 0x02, 0x31, 0x6a, 0xc4, 0xd0, 0x0c, 0xb9, 0x4a, 0x4a, 0x97, 0x9a, 0x75, + 0xf9, 0x72, 0x53, 0x6d, 0xb4, 0xa4, 0x7a, 0x83, 0x98, 0x04, 0x0f, 0xf3, 0x31, 0x89, 0x8d, 0x09, + 0x23, 0x15, 0x52, 0x21, 0x74, 0x48, 0xb6, 0xfe, 0x31, 0x2b, 0x21, 0x55, 0xa2, 0x66, 0x72, 0x51, + 0x31, 0x54, 0xf9, 0xca, 0x4c, 0x51, 0x35, 0x95, 0x19, 0xb9, 0x44, 0x34, 0x9d, 0x8f, 0x6f, 0xad, + 0x10, 0x52, 0xa9, 0xaa, 0xb2, 0x52, 0xd7, 0x64, 0x45, 0xd7, 0x89, 0xa9, 0x98, 0x1a, 0xd1, 0x0d, + 0x3e, 0x9a, 0xe6, 0xa3, 0xf4, 0xa9, 0xd8, 0xbc, 0x20, 0x9b, 0x5a, 0x4d, 0x35, 0x4c, 0xa5, 0x56, + 0xb7, 0xdd, 0x7b, 0x0d, 0xca, 0xcd, 0x06, 0xf5, 0xc0, 0xc7, 0xc7, 0x3c, 0x04, 0xac, 0x1f, 0x3e, + 0x34, 0xee, 0x19, 0xaa, 0x2b, 0x0d, 0xa5, 0xc6, 0x03, 0x8b, 0x5b, 0x60, 0xe4, 0x55, 0x52, 0x6e, + 0x56, 0xd5, 0xac, 0x52, 0x55, 0xf4, 0x92, 0x9a, 0x57, 0x2f, 0x37, 0x55, 0xc3, 0x14, 0xdf, 0x87, + 0xcd, 0x9e, 0xf7, 0x46, 0x9d, 0xe8, 0x86, 0x8a, 0x15, 0x18, 0xb0, 0x58, 0x19, 0xa3, 0x68, 0x62, + 0xcd, 0xd4, 0xfa, 0xd9, 0x31, 0x89, 0xf1, 0x96, 0x2c, 0xde, 0x12, 0xe7, 0x2d, 0x1d, 0x27, 0x9a, + 0x9e, 0xdd, 0x7d, 0x77, 0x31, 0xdd, 0xf7, 0xdd, 0xfd, 0xf4, 0x54, 0x45, 0x33, 0x2f, 0x36, 0x8b, + 0x52, 0x89, 0xd4, 0x64, 0x9e, 0x24, 0xf6, 0x93, 0x31, 0xca, 0x97, 0x64, 0xb3, 0x55, 0x57, 0x0d, + 0x3a, 0xc1, 0xc8, 0x33, 0xcf, 0xe2, 0x38, 0x8c, 0xb1, 0xd8, 0x39, 0x52, 0xba, 0xa4, 0x96, 0x8f, + 0xd5, 0x48, 0x53, 0x37, 0x6d, 0x60, 0x37, 0x40, 0x08, 0x1a, 0x5c, 0x39, 0x74, 0x2f, 0xc3, 0xb6, + 0x63, 0xa5, 0x92, 0x15, 0xf5, 0x75, 0xdd, 0xca, 0xa8, 0x52, 0xac, 0xaa, 0xcc, 0x80, 0x21, 0xc4, + 0x93, 0x30, 0x40, 0xde, 0xd3, 0xd5, 0xc6, 0x28, 0x9a, 0x40, 0x53, 0xeb, 0xb2, 0x1b, 0x1f, 0x2e, + 0xa6, 0x9f, 0x68, 0x29, 0xb5, 0xea, 0x41, 0x91, 0xbe, 0x16, 0xf3, 0x6c, 0x58, 0xbc, 0x85, 0x20, + 0x15, 0xe6, 0x69, 0xe5, 0xe8, 0x9c, 0x80, 0xad, 0x2e, 0x10, 0x9a, 0x5e, 0xe9, 0x8a, 0xcd, 0x4d, + 0xe4, 0xc9, 0xcb, 0xb2, 0xa3, 0x95, 0x23, 0x73, 0x1c, 0xc6, 0x38, 0x06, 0x56, 0x1d, 0x5d, 0x31, + 0xb9, 0x01, 0x42, 0x90, 0x93, 0x95, 0x63, 0xf1, 0x25, 0x72, 0xd6, 0x84, 0x21, 0x38, 0xad, 0x18, + 0xe6, 0x39, 0xad, 0xa6, 0x26, 0x64, 0x82, 0xdf, 0x80, 0x75, 0xce, 0x39, 0x32, 0xda, 0x3f, 0x81, + 0xa6, 0xd6, 0xcf, 0x0a, 0x12, 0x3b, 0x48, 0x24, 0xfb, 0x20, 0x91, 0xce, 0xd9, 0x16, 0xd9, 0xad, + 0x16, 0xe0, 0x87, 0x8b, 0xe9, 0x8d, 0xcc, 0x97, 0x33, 0x55, 0xbc, 0x7d, 0x3f, 0x8d, 0xf2, 0xcb, + 0xae, 0xc4, 0xf3, 0xce, 0x52, 0x7b, 0xf1, 0xf1, 0x24, 0xed, 0x83, 0x01, 0xab, 0x04, 0xec, 0x24, + 0x09, 0x92, 0xfb, 0x08, 0x95, 0x4e, 0xab, 0x0d, 0x8d, 0x94, 0xad, 0xc9, 0xd9, 0xb5, 0x56, 0xd0, + 0x3c, 0x33, 0x17, 0xbf, 0x47, 0x30, 0x1d, 0xe8, 0xf9, 0x14, 0x59, 0xae, 0xaa, 0xd7, 0xf4, 0x6a, + 0x6b, 0xb5, 0x64, 0xa2, 0x02, 0x99, 0x98, 0x78, 0x7b, 0xcc, 0xcc, 0x37, 0x08, 0x26, 0x5c, 0xdb, + 0x4b, 0x2d, 0x67, 0xd5, 0x0b, 0xa4, 0xa1, 0xae, 0xa6, 0xba, 0x78, 0x1b, 0xb6, 0x47, 0x60, 0xec, + 0x31, 0x03, 0x77, 0x90, 0xe3, 0xdd, 0x9d, 0xeb, 0x79, 0x55, 0x27, 0xb5, 0x55, 0x92, 0x02, 0x3c, + 0x02, 0x03, 0x65, 0x0b, 0xcf, 0xe8, 0x1a, 0x2b, 0x7e, 0x9e, 0x3d, 0x88, 0xef, 0x80, 0x18, 0x05, + 0xbd, 0xc7, 0xcc, 0x7c, 0x00, 0x98, 0xb9, 0x75, 0x65, 0xc2, 0x41, 0x82, 0xda, 0x90, 0xe0, 0x3c, + 0x3c, 0x6e, 0xdf, 0x1c, 0x38, 0xed, 0x31, 0x1f, 0xed, 0x79, 0x6e, 0x90, 0x1d, 0xe7, 0xac, 0x37, + 0x30, 0xd6, 0xf6, 0x44, 0xf1, 0x73, 0x8b, 0xb4, 0xe3, 0x47, 0xd4, 0x61, 0x93, 0x2b, 0x3e, 0xa7, + 0x73, 0x1e, 0x06, 0x15, 0xda, 0x9d, 0xf9, 0x5a, 0x1c, 0xb1, 0xbc, 0xfd, 0xb5, 0x98, 0x9e, 0x8c, + 0x71, 0x1e, 0x2e, 0xe8, 0xe6, 0xc3, 0xc5, 0xf4, 0x10, 0x8b, 0xcb, 0xbc, 0x88, 0x79, 0xee, 0x4e, + 0x9c, 0x82, 0x21, 0x16, 0xcf, 0xa6, 0xfa, 0x14, 0x3c, 0x66, 0x65, 0xa2, 0xa0, 0x95, 0x69, 0xa8, + 0xb5, 0xf9, 0x41, 0xeb, 0x71, 0xa1, 0x2c, 0x1e, 0x85, 0x61, 0xdb, 0x92, 0x83, 0x92, 0x60, 0xad, + 0x35, 0x46, 0xed, 0x22, 0x53, 0x9c, 0xa7, 0x76, 0xe2, 0x26, 0x78, 0xf2, 0x94, 0x7a, 0x95, 0x2e, + 0xdb, 0xc2, 0xbc, 0x7d, 0x07, 0xc9, 0x00, 0x6e, 0x7f, 0xc9, 0x5d, 0x87, 0xa2, 0x98, 0x83, 0xed, + 0x67, 0x5b, 0xba, 0x79, 0x51, 0x35, 0xb5, 0x52, 0x8e, 0xc6, 0x31, 0xb2, 0x2d, 0xf6, 0xc7, 0xf1, + 0x19, 0x3e, 0xbb, 0x01, 0x62, 0xd4, 0x6c, 0x1e, 0x3c, 0x07, 0x1b, 0x0c, 0xdb, 0xaa, 0xd0, 0x5e, + 0x45, 0xdb, 0xbc, 0x14, 0x5d, 0xce, 0x78, 0x21, 0x0d, 0x1b, 0xed, 0x2f, 0x0d, 0xf1, 0x45, 0x98, + 0xf0, 0xc4, 0x4c, 0x00, 0x98, 0xf8, 0xe8, 0x06, 0xe0, 0x3d, 0x09, 0xc3, 0x6e, 0xbc, 0x7c, 0x45, + 0x62, 0xc1, 0x1d, 0x72, 0xc1, 0x15, 0xbf, 0x42, 0x9e, 0xed, 0x95, 0x23, 0x7a, 0x45, 0x6d, 0xd8, + 0x65, 0x9c, 0xf4, 0x68, 0x78, 0x14, 0x5b, 0xe4, 0x5d, 0xd8, 0x11, 0x89, 0xb0, 0xc7, 0x13, 0xe0, + 0x0b, 0xef, 0x8d, 0x61, 0x35, 0x71, 0xf7, 0xde, 0x16, 0xfe, 0x37, 0xd6, 0x3f, 0x20, 0x98, 0x8d, + 0xc8, 0x6a, 0xaf, 0x77, 0x86, 0x47, 0x91, 0x8b, 0x1a, 0xec, 0x49, 0x84, 0xb8, 0xc7, 0x0c, 0xfd, + 0x84, 0xe0, 0xe9, 0x88, 0x78, 0x5d, 0x75, 0xce, 0x47, 0x90, 0x96, 0x90, 0xae, 0x59, 0x84, 0xa9, + 0xce, 0xe0, 0x7b, 0xcc, 0xd0, 0x08, 0xe0, 0x33, 0x96, 0xd6, 0x3f, 0x4d, 0x45, 0xb1, 0x7d, 0xc0, + 0xbf, 0x02, 0x9b, 0x5c, 0x6f, 0x79, 0x90, 0xbd, 0x30, 0xc8, 0xc4, 0x33, 0x3f, 0xac, 0xb6, 0xf8, + 0xa2, 0xd0, 0x51, 0x1e, 0x81, 0xdb, 0xce, 0xfe, 0x36, 0x0e, 0x03, 0xd4, 0x1b, 0xfe, 0x04, 0xc1, + 0x90, 0x4b, 0x55, 0xe3, 0x9d, 0x5e, 0x0f, 0x41, 0x62, 0x5c, 0xd8, 0xd5, 0xc1, 0x8a, 0xc1, 0x13, + 0xa5, 0x9b, 0x7f, 0xfc, 0xf3, 0x59, 0xff, 0x14, 0x9e, 0x94, 0x3d, 0x8a, 0xdf, 0xfe, 0x1c, 0x51, + 0xa3, 0xd3, 0x0a, 0x45, 0x1e, 0xfc, 0x6b, 0x04, 0xd8, 0xaf, 0xa5, 0xf1, 0x33, 0xc1, 0xd1, 0x02, + 0xc4, 0xb8, 0xf0, 0x6c, 0x1c, 0x53, 0x8e, 0x6e, 0x2f, 0x45, 0x27, 0xe1, 0xe9, 0x0e, 0xe8, 0xd8, + 0xc5, 0xb1, 0xc0, 0x7a, 0x3d, 0xbe, 0x83, 0x60, 0x4b, 0xb0, 0x48, 0xc6, 0x19, 0x6f, 0xf0, 0x48, + 0x59, 0x2e, 0x48, 0x71, 0xcd, 0x39, 0xde, 0xa3, 0x14, 0xef, 0x41, 0x7c, 0x20, 0x0c, 0xaf, 0xc2, + 0xe6, 0x17, 0x9a, 0x8e, 0x83, 0x02, 0xd5, 0x6f, 0xf2, 0x35, 0xba, 0x51, 0xae, 0xe3, 0x1f, 0x11, + 0x6c, 0x0e, 0x94, 0xc4, 0x78, 0x3a, 0x12, 0x8b, 0x47, 0x82, 0x0b, 0x99, 0x98, 0xd6, 0x1c, 0xf8, + 0x11, 0x0a, 0xfc, 0x05, 0xbc, 0x3f, 0x1e, 0x70, 0x4d, 0xaf, 0x78, 0x70, 0x7f, 0x8b, 0x00, 0xfb, + 0x15, 0xb0, 0xbf, 0x2e, 0x42, 0xa5, 0xb6, 0xbf, 0x2e, 0xc2, 0x05, 0xb5, 0x38, 0x47, 0xe1, 0xee, + 0xc3, 0x7b, 0x3b, 0xc1, 0xe5, 0x85, 0x11, 0x9a, 0x63, 0xf7, 0xd5, 0x3a, 0x34, 0xc7, 0x81, 0x92, + 0x3a, 0x34, 0xc7, 0xc1, 0x02, 0x37, 0x7e, 0x8e, 0x39, 0xe8, 0xba, 0x62, 0x98, 0x96, 0x48, 0x70, + 0x70, 0xff, 0x8b, 0x60, 0x57, 0x2c, 0xe5, 0x88, 0xe7, 0x62, 0x21, 0x0b, 0x69, 0x76, 0xc2, 0xa1, + 0x2e, 0x67, 0x73, 0x9e, 0x79, 0xca, 0x33, 0x87, 0x4f, 0x26, 0xe4, 0x59, 0xd0, 0x49, 0x7b, 0x7d, + 0x11, 0xbd, 0xda, 0x72, 0xa8, 0xff, 0x8c, 0x9c, 0xaf, 0x34, 0x7e, 0x99, 0x88, 0x77, 0x47, 0x16, + 0x7b, 0x80, 0xea, 0x15, 0x66, 0x12, 0xcc, 0xe0, 0xb4, 0xe6, 0x29, 0xad, 0xc3, 0x78, 0x2e, 0xde, + 0x16, 0x51, 0xcb, 0x85, 0x22, 0x75, 0x52, 0x70, 0xad, 0xe1, 0xaf, 0xc8, 0xf3, 0xa5, 0xc8, 0x25, + 0xeb, 0xf0, 0x4c, 0xac, 0xd4, 0xb7, 0xf7, 0x60, 0x61, 0x36, 0xc9, 0x14, 0xce, 0xe5, 0x25, 0xca, + 0xe5, 0x08, 0x3e, 0x94, 0x74, 0x89, 0x68, 0x93, 0x75, 0xc8, 0x7c, 0x84, 0x60, 0x7d, 0x9b, 0x8a, + 0xc3, 0xa2, 0x17, 0x8a, 0x5f, 0x62, 0x0a, 0x3b, 0x22, 0x6d, 0x38, 0xbe, 0x69, 0x8a, 0x6f, 0x12, + 0xef, 0x0c, 0xc3, 0xc7, 0x71, 0x31, 0x7d, 0x7a, 0x0b, 0x01, 0x30, 0x2f, 0xd9, 0xd6, 0xc2, 0x3c, + 0xde, 0x16, 0x1c, 0xc1, 0x06, 0x90, 0x0a, 0x1b, 0xe6, 0xb1, 0xf7, 0xd1, 0xd8, 0xbb, 0xb1, 0xd4, + 0x21, 0x76, 0xb1, 0x55, 0xd0, 0xca, 0xf2, 0x35, 0xae, 0x67, 0xae, 0xe3, 0x0f, 0x11, 0xc0, 0xb2, + 0xc2, 0xc3, 0xdb, 0xbd, 0x61, 0x7c, 0x92, 0x50, 0x10, 0xa3, 0x4c, 0xe2, 0x66, 0x42, 0x57, 0xaf, + 0xb2, 0x65, 0x2a, 0x68, 0x65, 0xfc, 0x3b, 0x02, 0x21, 0x5c, 0xf8, 0xf9, 0xab, 0xab, 0xa3, 0xc4, + 0xf4, 0x57, 0x57, 0x67, 0x5d, 0x29, 0x2e, 0x50, 0xcc, 0x47, 0xf1, 0xe1, 0x30, 0xcc, 0x6e, 0x15, + 0xd7, 0xac, 0x1b, 0x56, 0x32, 0x39, 0x87, 0xe5, 0x8c, 0x7e, 0xdc, 0x8f, 0xf0, 0x2f, 0x08, 0xc6, + 0x42, 0x85, 0xa1, 0x7f, 0xdf, 0x77, 0x12, 0xa0, 0xc2, 0x4c, 0x82, 0x19, 0x71, 0xf7, 0x8a, 0x97, + 0x4d, 0x20, 0x19, 0x6b, 0x69, 0xc6, 0x23, 0x6e, 0xa6, 0x38, 0x7a, 0x1b, 0x07, 0xaa, 0x53, 0x61, + 0x4f, 0xa2, 0x39, 0x9c, 0xcf, 0x89, 0x4e, 0xab, 0xe3, 0xd9, 0xfb, 0x55, 0xea, 0xa6, 0x60, 0xdf, + 0xbb, 0xc3, 0xbb, 0xa8, 0x43, 0x25, 0xba, 0x8b, 0x7a, 0x49, 0x64, 0x62, 0x5a, 0x77, 0xd9, 0x45, + 0x7d, 0xb8, 0x3f, 0xed, 0x87, 0xe7, 0x12, 0xe8, 0x29, 0x9c, 0x4d, 0x90, 0xe4, 0xb0, 0x8e, 0x7a, + 0xbc, 0x27, 0x1f, 0x9c, 0xf9, 0x9b, 0x94, 0xf9, 0x59, 0x7c, 0xa6, 0xbb, 0x85, 0x8b, 0x6a, 0xaf, + 0x4b, 0xcb, 0x5f, 0x8a, 0x43, 0x65, 0x13, 0xde, 0x9f, 0x80, 0x84, 0xeb, 0xc8, 0x3f, 0x90, 0x7c, + 0x22, 0xa7, 0x9c, 0xa3, 0x94, 0x4f, 0xe0, 0xf9, 0x2e, 0x29, 0xbb, 0xdb, 0x55, 0x0b, 0x06, 0x99, + 0xd8, 0xf2, 0x37, 0x2a, 0xbf, 0x9e, 0xf3, 0x37, 0xaa, 0x00, 0x75, 0x27, 0x4e, 0x52, 0x80, 0x13, + 0x38, 0x15, 0x06, 0x90, 0xe9, 0xb9, 0x6c, 0xee, 0xee, 0x83, 0x14, 0xba, 0xf7, 0x20, 0x85, 0xfe, + 0x7e, 0x90, 0x42, 0xb7, 0x97, 0x52, 0x7d, 0xf7, 0x96, 0x52, 0x7d, 0x7f, 0x2e, 0xa5, 0xfa, 0xde, + 0x9a, 0x6d, 0xfb, 0xb2, 0xc9, 0x7d, 0x64, 0xaa, 0x4a, 0xd1, 0x70, 0x1c, 0x5e, 0x99, 0x79, 0x5e, + 0xbe, 0x6a, 0xbb, 0xa5, 0x5f, 0x3a, 0x8b, 0x83, 0x54, 0x34, 0xef, 0xf9, 0x2f, 0x00, 0x00, 0xff, + 0xff, 0xd4, 0xbc, 0x99, 0xc8, 0x82, 0x1e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1867,6 +1961,9 @@ type QueryClient interface { // Returns next lock ID NextLockID(ctx context.Context, in *NextLockIDRequest, opts ...grpc.CallOption) (*NextLockIDResponse, error) // Returns synthetic lockup by native lockup id + // Deprecated: use SyntheticLockupByLockupID instead + SyntheticLockupsByLockupID(ctx context.Context, in *SyntheticLockupsByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupsByLockupIDResponse, error) + // Returns synthetic lockup by native lockup id SyntheticLockupByLockupID(ctx context.Context, in *SyntheticLockupByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupByLockupIDResponse, error) // Returns account locked records with longer duration AccountLockedLongerDuration(ctx context.Context, in *AccountLockedLongerDurationRequest, opts ...grpc.CallOption) (*AccountLockedLongerDurationResponse, error) @@ -1997,6 +2094,16 @@ func (c *queryClient) NextLockID(ctx context.Context, in *NextLockIDRequest, opt return out, nil } +// Deprecated: Do not use. +func (c *queryClient) SyntheticLockupsByLockupID(ctx context.Context, in *SyntheticLockupsByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupsByLockupIDResponse, error) { + out := new(SyntheticLockupsByLockupIDResponse) + err := c.cc.Invoke(ctx, "/osmosis.lockup.Query/SyntheticLockupsByLockupID", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) SyntheticLockupByLockupID(ctx context.Context, in *SyntheticLockupByLockupIDRequest, opts ...grpc.CallOption) (*SyntheticLockupByLockupIDResponse, error) { out := new(SyntheticLockupByLockupIDResponse) err := c.cc.Invoke(ctx, "/osmosis.lockup.Query/SyntheticLockupByLockupID", in, out, opts...) @@ -2079,6 +2186,9 @@ type QueryServer interface { // Returns next lock ID NextLockID(context.Context, *NextLockIDRequest) (*NextLockIDResponse, error) // Returns synthetic lockup by native lockup id + // Deprecated: use SyntheticLockupByLockupID instead + SyntheticLockupsByLockupID(context.Context, *SyntheticLockupsByLockupIDRequest) (*SyntheticLockupsByLockupIDResponse, error) + // Returns synthetic lockup by native lockup id SyntheticLockupByLockupID(context.Context, *SyntheticLockupByLockupIDRequest) (*SyntheticLockupByLockupIDResponse, error) // Returns account locked records with longer duration AccountLockedLongerDuration(context.Context, *AccountLockedLongerDurationRequest) (*AccountLockedLongerDurationResponse, error) @@ -2133,6 +2243,9 @@ func (*UnimplementedQueryServer) LockedByID(ctx context.Context, req *LockedRequ func (*UnimplementedQueryServer) NextLockID(ctx context.Context, req *NextLockIDRequest) (*NextLockIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method NextLockID not implemented") } +func (*UnimplementedQueryServer) SyntheticLockupsByLockupID(ctx context.Context, req *SyntheticLockupsByLockupIDRequest) (*SyntheticLockupsByLockupIDResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SyntheticLockupsByLockupID not implemented") +} func (*UnimplementedQueryServer) SyntheticLockupByLockupID(ctx context.Context, req *SyntheticLockupByLockupIDRequest) (*SyntheticLockupByLockupIDResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method SyntheticLockupByLockupID not implemented") } @@ -2372,6 +2485,24 @@ func _Query_NextLockID_Handler(srv interface{}, ctx context.Context, dec func(in return interceptor(ctx, in, info, handler) } +func _Query_SyntheticLockupsByLockupID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(SyntheticLockupsByLockupIDRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).SyntheticLockupsByLockupID(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/osmosis.lockup.Query/SyntheticLockupsByLockupID", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).SyntheticLockupsByLockupID(ctx, req.(*SyntheticLockupsByLockupIDRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_SyntheticLockupByLockupID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(SyntheticLockupByLockupIDRequest) if err := dec(in); err != nil { @@ -2532,6 +2663,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "NextLockID", Handler: _Query_NextLockID_Handler, }, + { + MethodName: "SyntheticLockupsByLockupID", + Handler: _Query_SyntheticLockupsByLockupID_Handler, + }, { MethodName: "SyntheticLockupByLockupID", Handler: _Query_SyntheticLockupByLockupID_Handler, @@ -3374,6 +3509,71 @@ func (m *NextLockIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *SyntheticLockupsByLockupIDRequest) 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 *SyntheticLockupsByLockupIDRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyntheticLockupsByLockupIDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LockId != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.LockId)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *SyntheticLockupsByLockupIDResponse) 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 *SyntheticLockupsByLockupIDResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SyntheticLockupsByLockupIDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SyntheticLocks) > 0 { + for iNdEx := len(m.SyntheticLocks) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.SyntheticLocks[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func (m *SyntheticLockupByLockupIDRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4137,6 +4337,33 @@ func (m *NextLockIDResponse) Size() (n int) { return n } +func (m *SyntheticLockupsByLockupIDRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.LockId != 0 { + n += 1 + sovQuery(uint64(m.LockId)) + } + return n +} + +func (m *SyntheticLockupsByLockupIDResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SyntheticLocks) > 0 { + for _, e := range m.SyntheticLocks { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + return n +} + func (m *SyntheticLockupByLockupIDRequest) Size() (n int) { if m == nil { return 0 @@ -6377,6 +6604,159 @@ func (m *NextLockIDResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *SyntheticLockupsByLockupIDRequest) 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 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyntheticLockupsByLockupIDRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyntheticLockupsByLockupIDRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LockId", wireType) + } + m.LockId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LockId |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + 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 + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SyntheticLockupsByLockupIDResponse) 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 + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SyntheticLockupsByLockupIDResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SyntheticLockupsByLockupIDResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SyntheticLocks", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SyntheticLocks = append(m.SyntheticLocks, SyntheticLock{}) + if err := m.SyntheticLocks[len(m.SyntheticLocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + 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 + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *SyntheticLockupByLockupIDRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/lockup/types/query.pb.gw.go b/x/lockup/types/query.pb.gw.go index 9db748d13c9..715754ac318 100644 --- a/x/lockup/types/query.pb.gw.go +++ b/x/lockup/types/query.pb.gw.go @@ -627,6 +627,60 @@ func local_request_Query_NextLockID_0(ctx context.Context, marshaler runtime.Mar } +func request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SyntheticLockupsByLockupIDRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["lock_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "lock_id") + } + + protoReq.LockId, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lock_id", err) + } + + msg, err := client.SyntheticLockupsByLockupID(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_SyntheticLockupsByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq SyntheticLockupsByLockupIDRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["lock_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "lock_id") + } + + protoReq.LockId, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "lock_id", err) + } + + msg, err := server.SyntheticLockupsByLockupID(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_SyntheticLockupByLockupID_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq SyntheticLockupByLockupIDRequest var metadata runtime.ServerMetadata @@ -1269,6 +1323,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_SyntheticLockupsByLockupID_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_SyntheticLockupsByLockupID_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_SyntheticLockupsByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_SyntheticLockupByLockupID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -1688,6 +1765,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_SyntheticLockupsByLockupID_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_SyntheticLockupsByLockupID_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_SyntheticLockupsByLockupID_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_SyntheticLockupByLockupID_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -1836,6 +1933,8 @@ var ( pattern_Query_NextLockID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"osmosis", "lockup", "v1beta1", "next_lock_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_SyntheticLockupsByLockupID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "synthetic_lockups_by_lock_id", "lock_id"}, "", runtime.AssumeColonVerbOpt(false))) + pattern_Query_SyntheticLockupByLockupID_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "synthetic_lockup_by_lock_id", "lock_id"}, "", runtime.AssumeColonVerbOpt(false))) pattern_Query_AccountLockedLongerDuration_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"osmosis", "lockup", "v1beta1", "account_locked_longer_duration", "owner"}, "", runtime.AssumeColonVerbOpt(false))) @@ -1874,6 +1973,8 @@ var ( forward_Query_NextLockID_0 = runtime.ForwardResponseMessage + forward_Query_SyntheticLockupsByLockupID_0 = runtime.ForwardResponseMessage + forward_Query_SyntheticLockupByLockupID_0 = runtime.ForwardResponseMessage forward_Query_AccountLockedLongerDuration_0 = runtime.ForwardResponseMessage From 571bc0eab9153f567f026c10f3455fafbf48f0b7 Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Mon, 22 May 2023 19:30:18 -0500 Subject: [PATCH 4/9] small nits --- x/lockup/keeper/lock_test.go | 2 +- x/lockup/keeper/synthetic_lock_test.go | 28 +++++++++++++++----------- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/x/lockup/keeper/lock_test.go b/x/lockup/keeper/lock_test.go index 8808d732734..15f10c958ad 100644 --- a/x/lockup/keeper/lock_test.go +++ b/x/lockup/keeper/lock_test.go @@ -1315,7 +1315,7 @@ func (s *KeeperTestSuite) TestForceUnlock() { s.Require().Equal(balances, coinsToLock) // if it was superfluid delegated lock, - // confirm that we don't have associated synth locks + // confirm that we don't have associated synth lock synthLock, err := s.App.LockupKeeper.GetSyntheticLockupByUnderlyingLockId(s.Ctx, lock.ID) s.Require().NoError(err) s.Require().Equal((lockuptypes.SyntheticLock{}), synthLock) diff --git a/x/lockup/keeper/synthetic_lock_test.go b/x/lockup/keeper/synthetic_lock_test.go index 14f6da566b9..9cc16207b8c 100644 --- a/x/lockup/keeper/synthetic_lock_test.go +++ b/x/lockup/keeper/synthetic_lock_test.go @@ -11,21 +11,22 @@ import ( func (s *KeeperTestSuite) TestSyntheticLockupCreation() { s.SetupTest() + numLocks := 3 // lock coins addr1 := sdk.AccAddress([]byte("addr1---------------")) coins := sdk.Coins{sdk.NewInt64Coin("stake", 10)} - s.LockTokens(addr1, coins, time.Second) - s.LockTokens(addr1, coins, time.Second) - s.LockTokens(addr1, coins, time.Second) + for i := 0; i < numLocks; i++ { + s.LockTokens(addr1, coins, time.Second) + } // check locks locks, err := s.App.LockupKeeper.GetPeriodLocks(s.Ctx) s.Require().NoError(err) - s.Require().Len(locks, 3) - s.Require().Equal(locks[0].Coins, coins) - s.Require().Equal(locks[1].Coins, coins) - s.Require().Equal(locks[2].Coins, coins) + s.Require().Len(locks, numLocks) + for i := 0; i < numLocks; i++ { + s.Require().Equal(locks[i].Coins, coins) + } // create not unbonding synthetic lockup err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "suffix1", time.Second, false) @@ -221,19 +222,22 @@ func (s *KeeperTestSuite) TestSyntheticLockupCreateGetDeleteAccumulation() { func (s *KeeperTestSuite) TestSyntheticLockupDeleteAllMaturedSyntheticLocks() { s.SetupTest() + numLocks := 2 // lock coins addr1 := sdk.AccAddress([]byte("addr1---------------")) coins := sdk.Coins{sdk.NewInt64Coin("stake", 10)} - s.LockTokens(addr1, coins, time.Second) - s.LockTokens(addr1, coins, time.Second) + for i := 0; i < numLocks; i++ { + s.LockTokens(addr1, coins, time.Second) + } // check locks locks, err := s.App.LockupKeeper.GetPeriodLocks(s.Ctx) s.Require().NoError(err) - s.Require().Len(locks, 2) - s.Require().Equal(locks[0].Coins, coins) - s.Require().Equal(locks[1].Coins, coins) + s.Require().Len(locks, numLocks) + for i := 0; i < numLocks; i++ { + s.Require().Equal(locks[i].Coins, coins) + } err = s.App.LockupKeeper.CreateSyntheticLockup(s.Ctx, 1, "synthstakestakedtovalidator1", time.Second, false) s.Require().NoError(err) From b297f83958079cf03eb3ad7794e54c66520fc15a Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Thu, 25 May 2023 10:46:32 -0500 Subject: [PATCH 5/9] add deprecated to underlying messages --- proto/osmosis/lockup/query.proto | 6 +- x/lockup/types/query.pb.go | 202 ++++++++++++++++--------------- 2 files changed, 107 insertions(+), 101 deletions(-) diff --git a/proto/osmosis/lockup/query.proto b/proto/osmosis/lockup/query.proto index 37d29f32958..7ab93331194 100644 --- a/proto/osmosis/lockup/query.proto +++ b/proto/osmosis/lockup/query.proto @@ -256,8 +256,12 @@ message LockedResponse { PeriodLock lock = 1; }; message NextLockIDRequest {}; message NextLockIDResponse { uint64 lock_id = 1; }; -message SyntheticLockupsByLockupIDRequest { uint64 lock_id = 1; } +message SyntheticLockupsByLockupIDRequest { + option deprecated = true; + uint64 lock_id = 1; +} message SyntheticLockupsByLockupIDResponse { + option deprecated = true; repeated SyntheticLock synthetic_locks = 1 [ (gogoproto.nullable) = false ]; } diff --git a/x/lockup/types/query.pb.go b/x/lockup/types/query.pb.go index 445432e8457..37e4508ee70 100644 --- a/x/lockup/types/query.pb.go +++ b/x/lockup/types/query.pb.go @@ -1116,6 +1116,7 @@ func (m *NextLockIDResponse) GetLockId() uint64 { return 0 } +// Deprecated: Do not use. type SyntheticLockupsByLockupIDRequest struct { LockId uint64 `protobuf:"varint,1,opt,name=lock_id,json=lockId,proto3" json:"lock_id,omitempty"` } @@ -1160,6 +1161,7 @@ func (m *SyntheticLockupsByLockupIDRequest) GetLockId() uint64 { return 0 } +// Deprecated: Do not use. type SyntheticLockupsByLockupIDResponse struct { SyntheticLocks []SyntheticLock `protobuf:"bytes,1,rep,name=synthetic_locks,json=syntheticLocks,proto3" json:"synthetic_locks"` } @@ -1820,107 +1822,107 @@ func init() { func init() { proto.RegisterFile("osmosis/lockup/query.proto", fileDescriptor_e906fda01cffd91a) } var fileDescriptor_e906fda01cffd91a = []byte{ - // 1593 bytes of a gzipped FileDescriptorProto + // 1599 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x14, 0x45, - 0x14, 0x4f, 0x07, 0x12, 0xe5, 0x61, 0x02, 0x36, 0x01, 0x93, 0x09, 0xec, 0x86, 0x01, 0x62, 0xd4, - 0xec, 0x0c, 0x09, 0x08, 0x88, 0xe1, 0x6b, 0x89, 0x58, 0xc1, 0x15, 0x61, 0x41, 0x29, 0xbf, 0x6a, - 0x6b, 0x76, 0x77, 0x58, 0xa6, 0xd8, 0x9d, 0x5e, 0x76, 0x66, 0x91, 0x95, 0x42, 0x4a, 0xf0, 0xe0, - 0xc1, 0x03, 0x96, 0x17, 0xcb, 0x83, 0xa5, 0xde, 0xf4, 0x60, 0x79, 0xf1, 0x40, 0x79, 0x57, 0xca, - 0x2a, 0x2d, 0xaa, 0xbc, 0x58, 0x1e, 0x82, 0x45, 0xfc, 0x0b, 0x38, 0x79, 0xb4, 0xa6, 0xbb, 0x67, - 0xb2, 0xf3, 0xb9, 0x33, 0xbb, 0x92, 0xca, 0x69, 0x77, 0xa6, 0x5f, 0xbf, 0xf7, 0xfb, 0xbd, 0x7e, - 0xdd, 0xaf, 0x7f, 0x03, 0x02, 0x31, 0x6a, 0xc4, 0xd0, 0x0c, 0xb9, 0x4a, 0x4a, 0x97, 0x9a, 0x75, - 0xf9, 0x72, 0x53, 0x6d, 0xb4, 0xa4, 0x7a, 0x83, 0x98, 0x04, 0x0f, 0xf3, 0x31, 0x89, 0x8d, 0x09, - 0x23, 0x15, 0x52, 0x21, 0x74, 0x48, 0xb6, 0xfe, 0x31, 0x2b, 0x21, 0x55, 0xa2, 0x66, 0x72, 0x51, - 0x31, 0x54, 0xf9, 0xca, 0x4c, 0x51, 0x35, 0x95, 0x19, 0xb9, 0x44, 0x34, 0x9d, 0x8f, 0x6f, 0xad, - 0x10, 0x52, 0xa9, 0xaa, 0xb2, 0x52, 0xd7, 0x64, 0x45, 0xd7, 0x89, 0xa9, 0x98, 0x1a, 0xd1, 0x0d, - 0x3e, 0x9a, 0xe6, 0xa3, 0xf4, 0xa9, 0xd8, 0xbc, 0x20, 0x9b, 0x5a, 0x4d, 0x35, 0x4c, 0xa5, 0x56, - 0xb7, 0xdd, 0x7b, 0x0d, 0xca, 0xcd, 0x06, 0xf5, 0xc0, 0xc7, 0xc7, 0x3c, 0x04, 0xac, 0x1f, 0x3e, - 0x34, 0xee, 0x19, 0xaa, 0x2b, 0x0d, 0xa5, 0xc6, 0x03, 0x8b, 0x5b, 0x60, 0xe4, 0x55, 0x52, 0x6e, - 0x56, 0xd5, 0xac, 0x52, 0x55, 0xf4, 0x92, 0x9a, 0x57, 0x2f, 0x37, 0x55, 0xc3, 0x14, 0xdf, 0x87, - 0xcd, 0x9e, 0xf7, 0x46, 0x9d, 0xe8, 0x86, 0x8a, 0x15, 0x18, 0xb0, 0x58, 0x19, 0xa3, 0x68, 0x62, - 0xcd, 0xd4, 0xfa, 0xd9, 0x31, 0x89, 0xf1, 0x96, 0x2c, 0xde, 0x12, 0xe7, 0x2d, 0x1d, 0x27, 0x9a, - 0x9e, 0xdd, 0x7d, 0x77, 0x31, 0xdd, 0xf7, 0xdd, 0xfd, 0xf4, 0x54, 0x45, 0x33, 0x2f, 0x36, 0x8b, - 0x52, 0x89, 0xd4, 0x64, 0x9e, 0x24, 0xf6, 0x93, 0x31, 0xca, 0x97, 0x64, 0xb3, 0x55, 0x57, 0x0d, - 0x3a, 0xc1, 0xc8, 0x33, 0xcf, 0xe2, 0x38, 0x8c, 0xb1, 0xd8, 0x39, 0x52, 0xba, 0xa4, 0x96, 0x8f, - 0xd5, 0x48, 0x53, 0x37, 0x6d, 0x60, 0x37, 0x40, 0x08, 0x1a, 0x5c, 0x39, 0x74, 0x2f, 0xc3, 0xb6, - 0x63, 0xa5, 0x92, 0x15, 0xf5, 0x75, 0xdd, 0xca, 0xa8, 0x52, 0xac, 0xaa, 0xcc, 0x80, 0x21, 0xc4, - 0x93, 0x30, 0x40, 0xde, 0xd3, 0xd5, 0xc6, 0x28, 0x9a, 0x40, 0x53, 0xeb, 0xb2, 0x1b, 0x1f, 0x2e, - 0xa6, 0x9f, 0x68, 0x29, 0xb5, 0xea, 0x41, 0x91, 0xbe, 0x16, 0xf3, 0x6c, 0x58, 0xbc, 0x85, 0x20, - 0x15, 0xe6, 0x69, 0xe5, 0xe8, 0x9c, 0x80, 0xad, 0x2e, 0x10, 0x9a, 0x5e, 0xe9, 0x8a, 0xcd, 0x4d, - 0xe4, 0xc9, 0xcb, 0xb2, 0xa3, 0x95, 0x23, 0x73, 0x1c, 0xc6, 0x38, 0x06, 0x56, 0x1d, 0x5d, 0x31, - 0xb9, 0x01, 0x42, 0x90, 0x93, 0x95, 0x63, 0xf1, 0x25, 0x72, 0xd6, 0x84, 0x21, 0x38, 0xad, 0x18, - 0xe6, 0x39, 0xad, 0xa6, 0x26, 0x64, 0x82, 0xdf, 0x80, 0x75, 0xce, 0x39, 0x32, 0xda, 0x3f, 0x81, - 0xa6, 0xd6, 0xcf, 0x0a, 0x12, 0x3b, 0x48, 0x24, 0xfb, 0x20, 0x91, 0xce, 0xd9, 0x16, 0xd9, 0xad, - 0x16, 0xe0, 0x87, 0x8b, 0xe9, 0x8d, 0xcc, 0x97, 0x33, 0x55, 0xbc, 0x7d, 0x3f, 0x8d, 0xf2, 0xcb, - 0xae, 0xc4, 0xf3, 0xce, 0x52, 0x7b, 0xf1, 0xf1, 0x24, 0xed, 0x83, 0x01, 0xab, 0x04, 0xec, 0x24, - 0x09, 0x92, 0xfb, 0x08, 0x95, 0x4e, 0xab, 0x0d, 0x8d, 0x94, 0xad, 0xc9, 0xd9, 0xb5, 0x56, 0xd0, - 0x3c, 0x33, 0x17, 0xbf, 0x47, 0x30, 0x1d, 0xe8, 0xf9, 0x14, 0x59, 0xae, 0xaa, 0xd7, 0xf4, 0x6a, - 0x6b, 0xb5, 0x64, 0xa2, 0x02, 0x99, 0x98, 0x78, 0x7b, 0xcc, 0xcc, 0x37, 0x08, 0x26, 0x5c, 0xdb, - 0x4b, 0x2d, 0x67, 0xd5, 0x0b, 0xa4, 0xa1, 0xae, 0xa6, 0xba, 0x78, 0x1b, 0xb6, 0x47, 0x60, 0xec, - 0x31, 0x03, 0x77, 0x90, 0xe3, 0xdd, 0x9d, 0xeb, 0x79, 0x55, 0x27, 0xb5, 0x55, 0x92, 0x02, 0x3c, - 0x02, 0x03, 0x65, 0x0b, 0xcf, 0xe8, 0x1a, 0x2b, 0x7e, 0x9e, 0x3d, 0x88, 0xef, 0x80, 0x18, 0x05, - 0xbd, 0xc7, 0xcc, 0x7c, 0x00, 0x98, 0xb9, 0x75, 0x65, 0xc2, 0x41, 0x82, 0xda, 0x90, 0xe0, 0x3c, - 0x3c, 0x6e, 0xdf, 0x1c, 0x38, 0xed, 0x31, 0x1f, 0xed, 0x79, 0x6e, 0x90, 0x1d, 0xe7, 0xac, 0x37, - 0x30, 0xd6, 0xf6, 0x44, 0xf1, 0x73, 0x8b, 0xb4, 0xe3, 0x47, 0xd4, 0x61, 0x93, 0x2b, 0x3e, 0xa7, - 0x73, 0x1e, 0x06, 0x15, 0xda, 0x9d, 0xf9, 0x5a, 0x1c, 0xb1, 0xbc, 0xfd, 0xb5, 0x98, 0x9e, 0x8c, - 0x71, 0x1e, 0x2e, 0xe8, 0xe6, 0xc3, 0xc5, 0xf4, 0x10, 0x8b, 0xcb, 0xbc, 0x88, 0x79, 0xee, 0x4e, - 0x9c, 0x82, 0x21, 0x16, 0xcf, 0xa6, 0xfa, 0x14, 0x3c, 0x66, 0x65, 0xa2, 0xa0, 0x95, 0x69, 0xa8, - 0xb5, 0xf9, 0x41, 0xeb, 0x71, 0xa1, 0x2c, 0x1e, 0x85, 0x61, 0xdb, 0x92, 0x83, 0x92, 0x60, 0xad, - 0x35, 0x46, 0xed, 0x22, 0x53, 0x9c, 0xa7, 0x76, 0xe2, 0x26, 0x78, 0xf2, 0x94, 0x7a, 0x95, 0x2e, - 0xdb, 0xc2, 0xbc, 0x7d, 0x07, 0xc9, 0x00, 0x6e, 0x7f, 0xc9, 0x5d, 0x87, 0xa2, 0x98, 0x83, 0xed, - 0x67, 0x5b, 0xba, 0x79, 0x51, 0x35, 0xb5, 0x52, 0x8e, 0xc6, 0x31, 0xb2, 0x2d, 0xf6, 0xc7, 0xf1, - 0x19, 0x3e, 0xbb, 0x01, 0x62, 0xd4, 0x6c, 0x1e, 0x3c, 0x07, 0x1b, 0x0c, 0xdb, 0xaa, 0xd0, 0x5e, - 0x45, 0xdb, 0xbc, 0x14, 0x5d, 0xce, 0x78, 0x21, 0x0d, 0x1b, 0xed, 0x2f, 0x0d, 0xf1, 0x45, 0x98, - 0xf0, 0xc4, 0x4c, 0x00, 0x98, 0xf8, 0xe8, 0x06, 0xe0, 0x3d, 0x09, 0xc3, 0x6e, 0xbc, 0x7c, 0x45, - 0x62, 0xc1, 0x1d, 0x72, 0xc1, 0x15, 0xbf, 0x42, 0x9e, 0xed, 0x95, 0x23, 0x7a, 0x45, 0x6d, 0xd8, - 0x65, 0x9c, 0xf4, 0x68, 0x78, 0x14, 0x5b, 0xe4, 0x5d, 0xd8, 0x11, 0x89, 0xb0, 0xc7, 0x13, 0xe0, - 0x0b, 0xef, 0x8d, 0x61, 0x35, 0x71, 0xf7, 0xde, 0x16, 0xfe, 0x37, 0xd6, 0x3f, 0x20, 0x98, 0x8d, - 0xc8, 0x6a, 0xaf, 0x77, 0x86, 0x47, 0x91, 0x8b, 0x1a, 0xec, 0x49, 0x84, 0xb8, 0xc7, 0x0c, 0xfd, - 0x84, 0xe0, 0xe9, 0x88, 0x78, 0x5d, 0x75, 0xce, 0x47, 0x90, 0x96, 0x90, 0xae, 0x59, 0x84, 0xa9, - 0xce, 0xe0, 0x7b, 0xcc, 0xd0, 0x08, 0xe0, 0x33, 0x96, 0xd6, 0x3f, 0x4d, 0x45, 0xb1, 0x7d, 0xc0, - 0xbf, 0x02, 0x9b, 0x5c, 0x6f, 0x79, 0x90, 0xbd, 0x30, 0xc8, 0xc4, 0x33, 0x3f, 0xac, 0xb6, 0xf8, - 0xa2, 0xd0, 0x51, 0x1e, 0x81, 0xdb, 0xce, 0xfe, 0x36, 0x0e, 0x03, 0xd4, 0x1b, 0xfe, 0x04, 0xc1, - 0x90, 0x4b, 0x55, 0xe3, 0x9d, 0x5e, 0x0f, 0x41, 0x62, 0x5c, 0xd8, 0xd5, 0xc1, 0x8a, 0xc1, 0x13, - 0xa5, 0x9b, 0x7f, 0xfc, 0xf3, 0x59, 0xff, 0x14, 0x9e, 0x94, 0x3d, 0x8a, 0xdf, 0xfe, 0x1c, 0x51, - 0xa3, 0xd3, 0x0a, 0x45, 0x1e, 0xfc, 0x6b, 0x04, 0xd8, 0xaf, 0xa5, 0xf1, 0x33, 0xc1, 0xd1, 0x02, - 0xc4, 0xb8, 0xf0, 0x6c, 0x1c, 0x53, 0x8e, 0x6e, 0x2f, 0x45, 0x27, 0xe1, 0xe9, 0x0e, 0xe8, 0xd8, - 0xc5, 0xb1, 0xc0, 0x7a, 0x3d, 0xbe, 0x83, 0x60, 0x4b, 0xb0, 0x48, 0xc6, 0x19, 0x6f, 0xf0, 0x48, - 0x59, 0x2e, 0x48, 0x71, 0xcd, 0x39, 0xde, 0xa3, 0x14, 0xef, 0x41, 0x7c, 0x20, 0x0c, 0xaf, 0xc2, - 0xe6, 0x17, 0x9a, 0x8e, 0x83, 0x02, 0xd5, 0x6f, 0xf2, 0x35, 0xba, 0x51, 0xae, 0xe3, 0x1f, 0x11, - 0x6c, 0x0e, 0x94, 0xc4, 0x78, 0x3a, 0x12, 0x8b, 0x47, 0x82, 0x0b, 0x99, 0x98, 0xd6, 0x1c, 0xf8, - 0x11, 0x0a, 0xfc, 0x05, 0xbc, 0x3f, 0x1e, 0x70, 0x4d, 0xaf, 0x78, 0x70, 0x7f, 0x8b, 0x00, 0xfb, - 0x15, 0xb0, 0xbf, 0x2e, 0x42, 0xa5, 0xb6, 0xbf, 0x2e, 0xc2, 0x05, 0xb5, 0x38, 0x47, 0xe1, 0xee, - 0xc3, 0x7b, 0x3b, 0xc1, 0xe5, 0x85, 0x11, 0x9a, 0x63, 0xf7, 0xd5, 0x3a, 0x34, 0xc7, 0x81, 0x92, - 0x3a, 0x34, 0xc7, 0xc1, 0x02, 0x37, 0x7e, 0x8e, 0x39, 0xe8, 0xba, 0x62, 0x98, 0x96, 0x48, 0x70, - 0x70, 0xff, 0x8b, 0x60, 0x57, 0x2c, 0xe5, 0x88, 0xe7, 0x62, 0x21, 0x0b, 0x69, 0x76, 0xc2, 0xa1, - 0x2e, 0x67, 0x73, 0x9e, 0x79, 0xca, 0x33, 0x87, 0x4f, 0x26, 0xe4, 0x59, 0xd0, 0x49, 0x7b, 0x7d, - 0x11, 0xbd, 0xda, 0x72, 0xa8, 0xff, 0x8c, 0x9c, 0xaf, 0x34, 0x7e, 0x99, 0x88, 0x77, 0x47, 0x16, - 0x7b, 0x80, 0xea, 0x15, 0x66, 0x12, 0xcc, 0xe0, 0xb4, 0xe6, 0x29, 0xad, 0xc3, 0x78, 0x2e, 0xde, - 0x16, 0x51, 0xcb, 0x85, 0x22, 0x75, 0x52, 0x70, 0xad, 0xe1, 0xaf, 0xc8, 0xf3, 0xa5, 0xc8, 0x25, - 0xeb, 0xf0, 0x4c, 0xac, 0xd4, 0xb7, 0xf7, 0x60, 0x61, 0x36, 0xc9, 0x14, 0xce, 0xe5, 0x25, 0xca, - 0xe5, 0x08, 0x3e, 0x94, 0x74, 0x89, 0x68, 0x93, 0x75, 0xc8, 0x7c, 0x84, 0x60, 0x7d, 0x9b, 0x8a, - 0xc3, 0xa2, 0x17, 0x8a, 0x5f, 0x62, 0x0a, 0x3b, 0x22, 0x6d, 0x38, 0xbe, 0x69, 0x8a, 0x6f, 0x12, - 0xef, 0x0c, 0xc3, 0xc7, 0x71, 0x31, 0x7d, 0x7a, 0x0b, 0x01, 0x30, 0x2f, 0xd9, 0xd6, 0xc2, 0x3c, - 0xde, 0x16, 0x1c, 0xc1, 0x06, 0x90, 0x0a, 0x1b, 0xe6, 0xb1, 0xf7, 0xd1, 0xd8, 0xbb, 0xb1, 0xd4, - 0x21, 0x76, 0xb1, 0x55, 0xd0, 0xca, 0xf2, 0x35, 0xae, 0x67, 0xae, 0xe3, 0x0f, 0x11, 0xc0, 0xb2, - 0xc2, 0xc3, 0xdb, 0xbd, 0x61, 0x7c, 0x92, 0x50, 0x10, 0xa3, 0x4c, 0xe2, 0x66, 0x42, 0x57, 0xaf, - 0xb2, 0x65, 0x2a, 0x68, 0x65, 0xfc, 0x3b, 0x02, 0x21, 0x5c, 0xf8, 0xf9, 0xab, 0xab, 0xa3, 0xc4, - 0xf4, 0x57, 0x57, 0x67, 0x5d, 0x29, 0x2e, 0x50, 0xcc, 0x47, 0xf1, 0xe1, 0x30, 0xcc, 0x6e, 0x15, - 0xd7, 0xac, 0x1b, 0x56, 0x32, 0x39, 0x87, 0xe5, 0x8c, 0x7e, 0xdc, 0x8f, 0xf0, 0x2f, 0x08, 0xc6, - 0x42, 0x85, 0xa1, 0x7f, 0xdf, 0x77, 0x12, 0xa0, 0xc2, 0x4c, 0x82, 0x19, 0x71, 0xf7, 0x8a, 0x97, - 0x4d, 0x20, 0x19, 0x6b, 0x69, 0xc6, 0x23, 0x6e, 0xa6, 0x38, 0x7a, 0x1b, 0x07, 0xaa, 0x53, 0x61, - 0x4f, 0xa2, 0x39, 0x9c, 0xcf, 0x89, 0x4e, 0xab, 0xe3, 0xd9, 0xfb, 0x55, 0xea, 0xa6, 0x60, 0xdf, - 0xbb, 0xc3, 0xbb, 0xa8, 0x43, 0x25, 0xba, 0x8b, 0x7a, 0x49, 0x64, 0x62, 0x5a, 0x77, 0xd9, 0x45, - 0x7d, 0xb8, 0x3f, 0xed, 0x87, 0xe7, 0x12, 0xe8, 0x29, 0x9c, 0x4d, 0x90, 0xe4, 0xb0, 0x8e, 0x7a, - 0xbc, 0x27, 0x1f, 0x9c, 0xf9, 0x9b, 0x94, 0xf9, 0x59, 0x7c, 0xa6, 0xbb, 0x85, 0x8b, 0x6a, 0xaf, - 0x4b, 0xcb, 0x5f, 0x8a, 0x43, 0x65, 0x13, 0xde, 0x9f, 0x80, 0x84, 0xeb, 0xc8, 0x3f, 0x90, 0x7c, - 0x22, 0xa7, 0x9c, 0xa3, 0x94, 0x4f, 0xe0, 0xf9, 0x2e, 0x29, 0xbb, 0xdb, 0x55, 0x0b, 0x06, 0x99, - 0xd8, 0xf2, 0x37, 0x2a, 0xbf, 0x9e, 0xf3, 0x37, 0xaa, 0x00, 0x75, 0x27, 0x4e, 0x52, 0x80, 0x13, - 0x38, 0x15, 0x06, 0x90, 0xe9, 0xb9, 0x6c, 0xee, 0xee, 0x83, 0x14, 0xba, 0xf7, 0x20, 0x85, 0xfe, - 0x7e, 0x90, 0x42, 0xb7, 0x97, 0x52, 0x7d, 0xf7, 0x96, 0x52, 0x7d, 0x7f, 0x2e, 0xa5, 0xfa, 0xde, - 0x9a, 0x6d, 0xfb, 0xb2, 0xc9, 0x7d, 0x64, 0xaa, 0x4a, 0xd1, 0x70, 0x1c, 0x5e, 0x99, 0x79, 0x5e, - 0xbe, 0x6a, 0xbb, 0xa5, 0x5f, 0x3a, 0x8b, 0x83, 0x54, 0x34, 0xef, 0xf9, 0x2f, 0x00, 0x00, 0xff, - 0xff, 0xd4, 0xbc, 0x99, 0xc8, 0x82, 0x1e, 0x00, 0x00, + 0x1b, 0x4f, 0x07, 0x92, 0xf7, 0xe5, 0xe1, 0x4d, 0xe0, 0x6d, 0x02, 0x26, 0x13, 0xd8, 0x0d, 0x0d, + 0xc4, 0xa8, 0xc9, 0x0c, 0x09, 0x08, 0x88, 0x7c, 0x2e, 0x11, 0x2b, 0xb8, 0x22, 0x2c, 0x28, 0xe5, + 0x57, 0x6d, 0xcd, 0xee, 0x0e, 0xcb, 0x14, 0xbb, 0xd3, 0xcb, 0xce, 0x2c, 0xb2, 0x52, 0x48, 0x09, + 0x1e, 0x3c, 0x78, 0xc0, 0xf2, 0x62, 0x79, 0xb0, 0xd4, 0x9b, 0x1e, 0x2c, 0x2f, 0x1e, 0x28, 0xef, + 0x4a, 0x59, 0xa5, 0x45, 0x95, 0x17, 0xcb, 0x43, 0xb0, 0x88, 0x7f, 0x01, 0x27, 0x8f, 0xd6, 0x74, + 0xf7, 0x4c, 0x76, 0x3e, 0x77, 0x76, 0x57, 0x52, 0x39, 0xed, 0xce, 0xf4, 0xd3, 0xbf, 0xe7, 0xf7, + 0x7b, 0xfa, 0xf3, 0x37, 0x20, 0x51, 0xb3, 0x4a, 0x4d, 0xdd, 0x54, 0x2a, 0xb4, 0x78, 0xb9, 0x51, + 0x53, 0xae, 0x34, 0xb4, 0x7a, 0x53, 0xae, 0xd5, 0xa9, 0x45, 0xf1, 0xb0, 0x68, 0x93, 0x79, 0x9b, + 0x34, 0x52, 0xa6, 0x65, 0xca, 0x9a, 0x14, 0xfb, 0x1f, 0x8f, 0x92, 0x52, 0x45, 0x16, 0xa6, 0x14, + 0x54, 0x53, 0x53, 0xae, 0xce, 0x16, 0x34, 0x4b, 0x9d, 0x55, 0x8a, 0x54, 0x37, 0x44, 0xfb, 0xd6, + 0x32, 0xa5, 0xe5, 0x8a, 0xa6, 0xa8, 0x35, 0x5d, 0x51, 0x0d, 0x83, 0x5a, 0xaa, 0xa5, 0x53, 0xc3, + 0x14, 0xad, 0x69, 0xd1, 0xca, 0x9e, 0x0a, 0x8d, 0x8b, 0x8a, 0xa5, 0x57, 0x35, 0xd3, 0x52, 0xab, + 0x35, 0x07, 0xde, 0x1f, 0x50, 0x6a, 0xd4, 0x19, 0x82, 0x68, 0x1f, 0xf3, 0x09, 0xb0, 0x7f, 0x44, + 0xd3, 0xb8, 0xaf, 0xa9, 0xa6, 0xd6, 0xd5, 0xaa, 0x48, 0x4c, 0xb6, 0xc0, 0xc8, 0xcb, 0xb4, 0xd4, + 0xa8, 0x68, 0x19, 0xb5, 0xa2, 0x1a, 0x45, 0x2d, 0xa7, 0x5d, 0x69, 0x68, 0xa6, 0x45, 0xde, 0x85, + 0xcd, 0xbe, 0xf7, 0x66, 0x8d, 0x1a, 0xa6, 0x86, 0x55, 0x18, 0xb0, 0x55, 0x99, 0xa3, 0x68, 0x62, + 0xcd, 0xd4, 0xfa, 0xb9, 0x31, 0x99, 0xeb, 0x96, 0x6d, 0xdd, 0xb2, 0xd0, 0x2d, 0x9f, 0xa0, 0xba, + 0x91, 0xd9, 0x7d, 0x6f, 0x31, 0xdd, 0xf7, 0xcd, 0x83, 0xf4, 0x54, 0x59, 0xb7, 0x2e, 0x35, 0x0a, + 0x72, 0x91, 0x56, 0x15, 0x51, 0x24, 0xfe, 0x33, 0x63, 0x96, 0x2e, 0x2b, 0x56, 0xb3, 0xa6, 0x99, + 0xac, 0x83, 0x99, 0xe3, 0xc8, 0x64, 0x1c, 0xc6, 0x78, 0xee, 0x2c, 0x2d, 0x5e, 0xd6, 0x4a, 0xc7, + 0xab, 0xb4, 0x61, 0x58, 0x0e, 0xb1, 0x9b, 0x20, 0x85, 0x35, 0xae, 0x1c, 0xbb, 0x17, 0x61, 0xdb, + 0xf1, 0x62, 0xd1, 0xce, 0xfa, 0xaa, 0x61, 0x57, 0x54, 0x2d, 0x54, 0x34, 0x1e, 0xc0, 0x19, 0xe2, + 0x49, 0x18, 0xa0, 0xef, 0x18, 0x5a, 0x7d, 0x14, 0x4d, 0xa0, 0xa9, 0x75, 0x99, 0x8d, 0x8f, 0x16, + 0xd3, 0xff, 0x6b, 0xaa, 0xd5, 0xca, 0x41, 0xc2, 0x5e, 0x93, 0x1c, 0x6f, 0x26, 0xb7, 0x11, 0xa4, + 0xa2, 0x90, 0x56, 0x4e, 0xce, 0x49, 0xd8, 0xea, 0x21, 0xa1, 0x1b, 0xe5, 0xae, 0xd4, 0xdc, 0x42, + 0xbe, 0xba, 0x2c, 0x03, 0xad, 0x9c, 0x98, 0x13, 0x30, 0x26, 0x38, 0xf0, 0xd9, 0xd1, 0x95, 0x92, + 0x9b, 0x20, 0x85, 0x81, 0xac, 0x9c, 0x8a, 0xcf, 0x91, 0x3b, 0x26, 0x9c, 0xc1, 0x19, 0xd5, 0xb4, + 0xce, 0xeb, 0x55, 0xad, 0x43, 0x25, 0xf8, 0x35, 0x58, 0xe7, 0xee, 0x23, 0xa3, 0xfd, 0x13, 0x68, + 0x6a, 0xfd, 0x9c, 0x24, 0xf3, 0x8d, 0x44, 0x76, 0x36, 0x12, 0xf9, 0xbc, 0x13, 0x91, 0xd9, 0x6a, + 0x13, 0x7e, 0xb4, 0x98, 0xde, 0xc8, 0xb1, 0xdc, 0xae, 0xe4, 0xce, 0x83, 0x34, 0xca, 0x2d, 0x43, + 0x91, 0x0b, 0xee, 0x50, 0xfb, 0xf9, 0x89, 0x22, 0xed, 0x83, 0x01, 0x7b, 0x0a, 0x38, 0x45, 0x92, + 0x64, 0xef, 0x16, 0x2a, 0x9f, 0xd1, 0xea, 0x3a, 0x2d, 0xd9, 0x9d, 0x33, 0x6b, 0xed, 0xa4, 0x39, + 0x1e, 0x4e, 0xbe, 0x45, 0x30, 0x1d, 0x8a, 0x7c, 0x9a, 0x2e, 0xcf, 0xaa, 0x57, 0x8c, 0x4a, 0x73, + 0xb5, 0x54, 0xa2, 0x0c, 0x33, 0x09, 0xf9, 0xf6, 0x58, 0x99, 0xaf, 0x10, 0x4c, 0x78, 0x96, 0x97, + 0x56, 0xca, 0x68, 0x17, 0x69, 0x5d, 0x5b, 0x4d, 0xf3, 0xe2, 0x4d, 0xd8, 0x1e, 0xc3, 0xb1, 0xc7, + 0x0a, 0xdc, 0x45, 0x2e, 0xba, 0xb7, 0xd6, 0xf3, 0x9a, 0x41, 0xab, 0xab, 0xa4, 0x04, 0x78, 0x04, + 0x06, 0x4a, 0x36, 0x9f, 0xd1, 0x35, 0x76, 0xfe, 0x1c, 0x7f, 0x20, 0x6f, 0x01, 0x89, 0xa3, 0xde, + 0x63, 0x65, 0xde, 0x03, 0xcc, 0x61, 0x3d, 0x95, 0x70, 0x99, 0xa0, 0x16, 0x26, 0x38, 0x07, 0xff, + 0x75, 0x6e, 0x0e, 0x42, 0xf6, 0x58, 0x40, 0xf6, 0xbc, 0x08, 0xc8, 0x8c, 0x0b, 0xd5, 0x1b, 0xb8, + 0x6a, 0xa7, 0x23, 0xf9, 0xd4, 0x16, 0xed, 0xe2, 0x10, 0x03, 0x36, 0x79, 0xf2, 0x0b, 0x39, 0x17, + 0x60, 0x50, 0x65, 0xa7, 0xb3, 0x18, 0x8b, 0xa3, 0x36, 0xda, 0x1f, 0x8b, 0xe9, 0xc9, 0x04, 0xfb, + 0xe1, 0x82, 0x61, 0x3d, 0x5a, 0x4c, 0x0f, 0xf1, 0xbc, 0x1c, 0x85, 0xe4, 0x04, 0x1c, 0x99, 0x82, + 0x21, 0x9e, 0xcf, 0x91, 0xfa, 0x04, 0xfc, 0xc7, 0xae, 0x44, 0x5e, 0x2f, 0xb1, 0x54, 0x6b, 0x73, + 0x83, 0xf6, 0xe3, 0x42, 0x89, 0x1c, 0x83, 0x61, 0x27, 0x52, 0x90, 0x92, 0x61, 0xad, 0xdd, 0xc6, + 0xe2, 0x62, 0x4b, 0x9c, 0x63, 0x71, 0x64, 0x13, 0xfc, 0xff, 0xb4, 0x76, 0x8d, 0x0d, 0xdb, 0xc2, + 0xbc, 0x73, 0x07, 0x99, 0x01, 0xdc, 0xfa, 0x52, 0x40, 0xc7, 0xb0, 0xd8, 0x7e, 0xae, 0x69, 0x58, + 0x97, 0x34, 0x4b, 0x2f, 0x66, 0x59, 0x1e, 0x33, 0xd3, 0xe4, 0x7f, 0x5c, 0xcc, 0xc8, 0xde, 0x07, + 0xfb, 0x47, 0x11, 0xb9, 0x0a, 0x24, 0x0e, 0x41, 0x10, 0xc8, 0xc2, 0x06, 0xd3, 0x89, 0xca, 0xb7, + 0xce, 0xa4, 0x6d, 0x7e, 0x99, 0x1e, 0x30, 0x31, 0x99, 0x86, 0xcd, 0xd6, 0x97, 0x26, 0xcb, 0xfb, + 0x3c, 0x4c, 0xf8, 0xf2, 0x26, 0x27, 0x4e, 0x68, 0x40, 0x76, 0x08, 0xe7, 0x53, 0x30, 0xec, 0xe5, + 0x2c, 0x46, 0x26, 0x11, 0xe5, 0x21, 0x0f, 0x65, 0xf2, 0x05, 0xf2, 0x2d, 0xb3, 0x2c, 0x35, 0xca, + 0x5a, 0xdd, 0x99, 0xce, 0x9d, 0x6e, 0x11, 0x8f, 0x63, 0xa9, 0xbc, 0x0d, 0x3b, 0x62, 0x19, 0xf6, + 0xb8, 0x13, 0x7c, 0xe6, 0xbf, 0x39, 0xac, 0x26, 0xed, 0xfe, 0x5b, 0xc3, 0xbf, 0xa6, 0xfa, 0x3b, + 0x04, 0x73, 0x31, 0x55, 0xed, 0xf5, 0xee, 0xf0, 0x38, 0x6a, 0x51, 0x85, 0x3d, 0x1d, 0x31, 0xee, + 0xb1, 0x42, 0x3f, 0x20, 0x78, 0x32, 0x26, 0x5f, 0x57, 0x27, 0xe8, 0x63, 0x28, 0x4b, 0xc4, 0xe9, + 0x59, 0x80, 0xa9, 0xf6, 0xe4, 0x7b, 0xac, 0xd0, 0x08, 0xe0, 0xb3, 0xb6, 0xe7, 0x3f, 0xc3, 0xcc, + 0xb1, 0xb3, 0xd1, 0xbf, 0x04, 0x9b, 0x3c, 0x6f, 0x45, 0x92, 0xbd, 0x30, 0xc8, 0x4d, 0xb4, 0xd8, + 0xac, 0xb6, 0x04, 0xb2, 0xb0, 0x56, 0x91, 0x41, 0xc4, 0xce, 0xfd, 0x32, 0x0e, 0x03, 0x0c, 0x0d, + 0x7f, 0x84, 0x60, 0xc8, 0xe3, 0xae, 0xf1, 0x4e, 0x3f, 0x42, 0x98, 0x29, 0x97, 0x76, 0xb5, 0x89, + 0xe2, 0xf4, 0x88, 0x7c, 0xeb, 0xb7, 0xbf, 0x3e, 0xe9, 0x9f, 0xc2, 0x93, 0x8a, 0xcf, 0xf9, 0x3b, + 0x9f, 0x25, 0xaa, 0xac, 0x5b, 0xbe, 0x20, 0x92, 0x7f, 0x89, 0x00, 0x07, 0x3d, 0x35, 0x7e, 0x2a, + 0x3c, 0x5b, 0x88, 0x29, 0x97, 0x9e, 0x4e, 0x12, 0x2a, 0xd8, 0xed, 0x65, 0xec, 0x64, 0x3c, 0xdd, + 0x86, 0x1d, 0xbf, 0x40, 0xe6, 0xf9, 0x99, 0x8f, 0xef, 0x22, 0xd8, 0x12, 0x6e, 0x96, 0xf1, 0x8c, + 0x3f, 0x79, 0xac, 0x3d, 0x97, 0xe4, 0xa4, 0xe1, 0x82, 0xef, 0x31, 0xc6, 0xf7, 0x20, 0x3e, 0x10, + 0xc5, 0x57, 0xe5, 0xfd, 0xf3, 0x0d, 0x17, 0x20, 0xcf, 0x7c, 0x9c, 0x72, 0x9d, 0x2d, 0x94, 0x1b, + 0xf8, 0x7b, 0x04, 0x9b, 0x43, 0xad, 0x31, 0x9e, 0x8e, 0xe5, 0xe2, 0xb3, 0xe2, 0xd2, 0x4c, 0xc2, + 0x68, 0x41, 0xfc, 0x28, 0x23, 0xfe, 0x1c, 0xde, 0x9f, 0x8c, 0xb8, 0x6e, 0x94, 0x7d, 0xbc, 0xbf, + 0x46, 0x80, 0x83, 0x4e, 0x38, 0x38, 0x2f, 0x22, 0x2d, 0x77, 0x70, 0x5e, 0x44, 0x1b, 0x6b, 0x72, + 0x88, 0xd1, 0xdd, 0x87, 0xf7, 0xb6, 0xa3, 0x2b, 0x26, 0x46, 0x64, 0x8d, 0xbd, 0x57, 0xec, 0xc8, + 0x1a, 0x87, 0x5a, 0xeb, 0xc8, 0x1a, 0x87, 0x1b, 0xdd, 0xe4, 0x35, 0x16, 0xa4, 0x6b, 0xaa, 0x69, + 0xd9, 0x66, 0xc1, 0xe5, 0xfd, 0x37, 0x82, 0x5d, 0x89, 0x1c, 0x24, 0x3e, 0x94, 0x88, 0x59, 0xc4, + 0x61, 0x27, 0x1d, 0xee, 0xb2, 0xb7, 0xd0, 0x99, 0x63, 0x3a, 0xb3, 0xf8, 0x54, 0x87, 0x3a, 0xf3, + 0x06, 0x6d, 0x9d, 0x5f, 0xd4, 0xa8, 0x34, 0x5d, 0xe9, 0x3f, 0x22, 0xf7, 0x6b, 0x4d, 0xd0, 0x2e, + 0xe2, 0xdd, 0xb1, 0x93, 0x3d, 0xc4, 0xfd, 0x4a, 0xb3, 0x1d, 0xf4, 0x10, 0xb2, 0xe6, 0x99, 0xac, + 0x23, 0xf8, 0x50, 0xb2, 0x25, 0xa2, 0x95, 0xf2, 0x05, 0x06, 0x92, 0xf7, 0x8c, 0xe1, 0xcf, 0xc8, + 0xf7, 0xc5, 0xc8, 0x63, 0xef, 0xf0, 0x6c, 0xa2, 0xd2, 0xb7, 0x9e, 0xc1, 0xd2, 0x5c, 0x27, 0x5d, + 0x84, 0x96, 0x17, 0x98, 0x96, 0xa3, 0xf8, 0x70, 0xa7, 0x43, 0xc4, 0x0e, 0x59, 0x57, 0xcc, 0x07, + 0x08, 0xd6, 0xb7, 0xb8, 0x39, 0x4c, 0xfc, 0x54, 0x82, 0x56, 0x53, 0xda, 0x11, 0x1b, 0x23, 0xf8, + 0x4d, 0x33, 0x7e, 0x93, 0x78, 0x67, 0x14, 0x3f, 0xc1, 0x8b, 0xfb, 0xd4, 0xdb, 0x08, 0x80, 0xa3, + 0x64, 0x9a, 0x0b, 0xf3, 0x78, 0x5b, 0x78, 0x06, 0x87, 0x40, 0x2a, 0xaa, 0x59, 0xe4, 0xde, 0xc7, + 0x72, 0xef, 0xc6, 0x72, 0x9b, 0xdc, 0x85, 0x66, 0x5e, 0x2f, 0x29, 0xd7, 0x85, 0x9f, 0xb9, 0x81, + 0xdf, 0x47, 0x00, 0xcb, 0x4e, 0x0f, 0x6f, 0xf7, 0xa7, 0x09, 0x58, 0x43, 0x89, 0xc4, 0x85, 0x24, + 0xad, 0x84, 0xa1, 0x5d, 0xe3, 0xc3, 0x94, 0xd7, 0x4b, 0xf8, 0x57, 0x04, 0x52, 0xb4, 0xf9, 0x0b, + 0xce, 0xae, 0xb6, 0x56, 0x33, 0x38, 0xbb, 0xda, 0x7b, 0x4b, 0xb2, 0xc0, 0x38, 0x1f, 0xc3, 0x47, + 0xa2, 0x38, 0x7b, 0x5d, 0x5c, 0xa3, 0x66, 0xda, 0xc5, 0x14, 0x1a, 0x96, 0x2b, 0xfa, 0x61, 0x3f, + 0xc2, 0x3f, 0x21, 0x18, 0x8b, 0x34, 0x86, 0xc1, 0x75, 0xdf, 0xce, 0x80, 0x4a, 0xb3, 0x1d, 0xf4, + 0x48, 0xba, 0x56, 0xfc, 0x6a, 0x42, 0xc5, 0xd8, 0x43, 0x33, 0x1e, 0x73, 0x33, 0xc5, 0xf1, 0xcb, + 0x38, 0xd4, 0x9d, 0x4a, 0x7b, 0x3a, 0xea, 0x23, 0xf4, 0x9c, 0x6c, 0x37, 0x3a, 0xbe, 0xb5, 0x5f, + 0x61, 0x30, 0x79, 0xe7, 0xde, 0x1d, 0x7d, 0x8a, 0xba, 0x52, 0xe2, 0x4f, 0x51, 0xbf, 0x88, 0x99, + 0x84, 0xd1, 0x5d, 0x9e, 0xa2, 0x01, 0xde, 0x1f, 0xf7, 0xc3, 0x33, 0x1d, 0xf8, 0x29, 0x9c, 0xe9, + 0xa0, 0xc8, 0x51, 0x27, 0xea, 0x89, 0x9e, 0x30, 0x84, 0xf2, 0xd7, 0x99, 0xf2, 0x73, 0xf8, 0x6c, + 0x77, 0x03, 0x17, 0x77, 0xbc, 0x2e, 0x2d, 0x7f, 0x31, 0x8e, 0xb4, 0x4d, 0x78, 0x7f, 0x07, 0x22, + 0x3c, 0x5b, 0xfe, 0x81, 0xce, 0x3b, 0x0a, 0xc9, 0x59, 0x26, 0xf9, 0x24, 0x9e, 0xef, 0x52, 0xb2, + 0xf7, 0xb8, 0x6a, 0xc2, 0x20, 0x37, 0x5b, 0xc1, 0x83, 0x2a, 0xe8, 0xe7, 0x82, 0x07, 0x55, 0x88, + 0xbb, 0x23, 0x93, 0x8c, 0xe0, 0x04, 0x4e, 0x45, 0x11, 0xe4, 0x7e, 0x2e, 0x93, 0xbd, 0xf7, 0x30, + 0x85, 0xee, 0x3f, 0x4c, 0xa1, 0x3f, 0x1f, 0xa6, 0xd0, 0x9d, 0xa5, 0x54, 0xdf, 0xfd, 0xa5, 0x54, + 0xdf, 0xef, 0x4b, 0xa9, 0xbe, 0x37, 0xe6, 0x5a, 0xbe, 0x70, 0x0a, 0x8c, 0x99, 0x8a, 0x5a, 0x30, + 0x5d, 0xc0, 0xab, 0xb3, 0xcf, 0x2a, 0xd7, 0x1c, 0x58, 0xf6, 0xc5, 0xb3, 0x30, 0xc8, 0x4c, 0xf3, + 0x9e, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xdd, 0x97, 0x7f, 0x32, 0x8a, 0x1e, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. From e0ecfeade74b85607e3f58a664a5d2b726f20c85 Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Thu, 25 May 2023 10:57:29 -0500 Subject: [PATCH 6/9] remove iterator --- x/lockup/keeper/grpc_query.go | 1 + x/lockup/keeper/synthetic_lock.go | 29 ++++++++--------------------- 2 files changed, 9 insertions(+), 21 deletions(-) diff --git a/x/lockup/keeper/grpc_query.go b/x/lockup/keeper/grpc_query.go index c8a56cba7c0..c28ed459818 100644 --- a/x/lockup/keeper/grpc_query.go +++ b/x/lockup/keeper/grpc_query.go @@ -179,6 +179,7 @@ func (q Querier) NextLockID(goCtx context.Context, req *types.NextLockIDRequest) // SyntheticLockupsByLockupID returns synthetic lockups by native lockup id. // Deprecated: use SyntheticLockupByLockupID instead. +// nolint: staticcheck func (q Querier) SyntheticLockupsByLockupID(goCtx context.Context, req *types.SyntheticLockupsByLockupIDRequest) (*types.SyntheticLockupsByLockupIDResponse, error) { if req == nil { return nil, status.Error(codes.InvalidArgument, "empty request") diff --git a/x/lockup/keeper/synthetic_lock.go b/x/lockup/keeper/synthetic_lock.go index 828884b2955..de82a3817f1 100644 --- a/x/lockup/keeper/synthetic_lock.go +++ b/x/lockup/keeper/synthetic_lock.go @@ -37,30 +37,17 @@ func (k Keeper) GetSyntheticLockup(ctx sdk.Context, lockID uint64, synthdenom st } // GetSyntheticLockupByUnderlyingLockId gets the synthetic lockup object connected to the underlying lock ID. -// Error is returned if: -// - there are more than one synthetic lockup objects with the same underlying lock ID. -// - there is no synthetic lockup object with the given underlying lock ID. +// Error is returned if there is no synthetic lockup object with the given underlying lock ID. func (k Keeper) GetSyntheticLockupByUnderlyingLockId(ctx sdk.Context, lockID uint64) (types.SyntheticLock, error) { + synthLock := types.SyntheticLock{} store := ctx.KVStore(k.storeKey) - iterator := sdk.KVStorePrefixIterator(store, combineKeys(types.KeyPrefixSyntheticLockup, sdk.Uint64ToBigEndian(lockID))) - defer iterator.Close() - - synthLocks := []types.SyntheticLock{} - for ; iterator.Valid(); iterator.Next() { - synthLock := types.SyntheticLock{} - err := proto.Unmarshal(iterator.Value(), &synthLock) - if err != nil { - return types.SyntheticLock{}, err - } - synthLocks = append(synthLocks, synthLock) - } - if len(synthLocks) > 1 { - return types.SyntheticLock{}, fmt.Errorf("synthetic lockup with same lock id should not exist") - } - if len(synthLocks) == 0 { - return types.SyntheticLock{}, nil + synthLockKey := combineKeys(types.KeyPrefixSyntheticLockup, sdk.Uint64ToBigEndian(lockID)) + if !store.Has(synthLockKey) { + return types.SyntheticLock{}, fmt.Errorf("synthetic lock with ID %d does not exist", lockID) } - return synthLocks[0], nil + bz := store.Get(synthLockKey) + err := proto.Unmarshal(bz, &synthLock) + return synthLock, err } // GetAllSyntheticLockupsByAddr gets all the synthetic lockups from all the locks owned by the given address. From dd70c9e078bf96b344521dbbb4e8254e30af2ddb Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Thu, 25 May 2023 11:02:51 -0500 Subject: [PATCH 7/9] add IsNil check --- x/lockup/keeper/lock.go | 2 +- x/lockup/keeper/msg_server.go | 2 +- x/lockup/keeper/synthetic_lock.go | 2 +- x/lockup/types/lock.go | 5 +++++ 4 files changed, 8 insertions(+), 3 deletions(-) diff --git a/x/lockup/keeper/lock.go b/x/lockup/keeper/lock.go index ac6dd43ffbc..885ab53e38f 100644 --- a/x/lockup/keeper/lock.go +++ b/x/lockup/keeper/lock.go @@ -385,7 +385,7 @@ func (k Keeper) ForceUnlock(ctx sdk.Context, lock types.PeriodLock) error { if err != nil { return err } - if synthLock != (types.SyntheticLock{}) { + if !synthLock.IsNil() { err = k.DeleteSyntheticLockup(ctx, lock.ID, synthLock.SynthDenom) if err != nil { return err diff --git a/x/lockup/keeper/msg_server.go b/x/lockup/keeper/msg_server.go index 0f5b912d09e..160acf0037a 100644 --- a/x/lockup/keeper/msg_server.go +++ b/x/lockup/keeper/msg_server.go @@ -212,7 +212,7 @@ func (server msgServer) ForceUnlock(goCtx context.Context, msg *types.MsgForceUn if err != nil { return &types.MsgForceUnlockResponse{Success: false}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) } - if synthLock != (types.SyntheticLock{}) { + if !synthLock.IsNil() { return &types.MsgForceUnlockResponse{Success: false}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "superfluid delegation exists for lock") } diff --git a/x/lockup/keeper/synthetic_lock.go b/x/lockup/keeper/synthetic_lock.go index de82a3817f1..e446f8d3a94 100644 --- a/x/lockup/keeper/synthetic_lock.go +++ b/x/lockup/keeper/synthetic_lock.go @@ -100,7 +100,7 @@ func (k Keeper) CreateSyntheticLockup(ctx sdk.Context, lockID uint64, synthDenom if err != nil { return err } - if synthLock != (types.SyntheticLock{}) { + if !synthLock.IsNil() { return types.ErrSyntheticLockupAlreadyExists } diff --git a/x/lockup/types/lock.go b/x/lockup/types/lock.go index 24cd878115c..aa53681c9be 100644 --- a/x/lockup/types/lock.go +++ b/x/lockup/types/lock.go @@ -29,6 +29,11 @@ func (p SyntheticLock) IsUnlocking() bool { return !p.EndTime.Equal(time.Time{}) } +// IsNil returns if the synthetic lock is nil. +func (p SyntheticLock) IsNil() bool { + return p == (SyntheticLock{}) +} + // OwnerAddress returns locks owner address. func (p PeriodLock) OwnerAddress() sdk.AccAddress { addr, err := sdk.AccAddressFromBech32(p.Owner) From 64f93dd03848927eba5af85497a9a99655ce9e6e Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Thu, 25 May 2023 11:35:05 -0500 Subject: [PATCH 8/9] add back iterator --- x/lockup/keeper/synthetic_lock.go | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/x/lockup/keeper/synthetic_lock.go b/x/lockup/keeper/synthetic_lock.go index e446f8d3a94..7a7a51fc257 100644 --- a/x/lockup/keeper/synthetic_lock.go +++ b/x/lockup/keeper/synthetic_lock.go @@ -36,18 +36,30 @@ func (k Keeper) GetSyntheticLockup(ctx sdk.Context, lockID uint64, synthdenom st return &synthLock, err } -// GetSyntheticLockupByUnderlyingLockId gets the synthetic lockup object connected to the underlying lock ID. -// Error is returned if there is no synthetic lockup object with the given underlying lock ID. +// Error is returned if: +// - there are more than one synthetic lockup objects with the same underlying lock ID. +// - there is no synthetic lockup object with the given underlying lock ID. func (k Keeper) GetSyntheticLockupByUnderlyingLockId(ctx sdk.Context, lockID uint64) (types.SyntheticLock, error) { - synthLock := types.SyntheticLock{} store := ctx.KVStore(k.storeKey) - synthLockKey := combineKeys(types.KeyPrefixSyntheticLockup, sdk.Uint64ToBigEndian(lockID)) - if !store.Has(synthLockKey) { - return types.SyntheticLock{}, fmt.Errorf("synthetic lock with ID %d does not exist", lockID) + iterator := sdk.KVStorePrefixIterator(store, combineKeys(types.KeyPrefixSyntheticLockup, sdk.Uint64ToBigEndian(lockID))) + defer iterator.Close() + + synthLocks := []types.SyntheticLock{} + for ; iterator.Valid(); iterator.Next() { + synthLock := types.SyntheticLock{} + err := proto.Unmarshal(iterator.Value(), &synthLock) + if err != nil { + return types.SyntheticLock{}, err + } + synthLocks = append(synthLocks, synthLock) } - bz := store.Get(synthLockKey) - err := proto.Unmarshal(bz, &synthLock) - return synthLock, err + if len(synthLocks) > 1 { + return types.SyntheticLock{}, fmt.Errorf("synthetic lockup with same lock id should not exist") + } + if len(synthLocks) == 0 { + return types.SyntheticLock{}, nil + } + return synthLocks[0], nil } // GetAllSyntheticLockupsByAddr gets all the synthetic lockups from all the locks owned by the given address. From 7bd39552716c16466babca5293a76c39b5fd714e Mon Sep 17 00:00:00 2001 From: Adam Tucker Date: Thu, 25 May 2023 11:38:22 -0500 Subject: [PATCH 9/9] add back old CLI command --- x/lockup/client/cli/query.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/x/lockup/client/cli/query.go b/x/lockup/client/cli/query.go index 423a02a13b9..715074b1352 100644 --- a/x/lockup/client/cli/query.go +++ b/x/lockup/client/cli/query.go @@ -42,6 +42,7 @@ func GetQueryCmd() *cobra.Command { GetCmdAccountLockedLongerDurationNotUnlockingOnly(), GetCmdAccountLockedLongerDurationDenom(), GetCmdOutputLocksJson(), + GetCmdSyntheticLockupsByLockupID(), GetCmdSyntheticLockupByLockupID(), GetCmdAccountLockedDuration(), GetCmdNextLockID(), @@ -199,10 +200,19 @@ func GetCmdNextLockID() *cobra.Command { `{{.Short}}`, types.ModuleName, types.NewQueryClient) } +// GetCmdSyntheticLockupsByLockupID returns synthetic lockups by lockup id. +// nolint: staticcheck +func GetCmdSyntheticLockupsByLockupID() *cobra.Command { + return osmocli.SimpleQueryCmd[*types.SyntheticLockupsByLockupIDRequest]( + "synthetic-lockups-by-lock-id ", + "Query synthetic lockups by lockup id (is deprecated for synthetic-lockup-by-lock-id)", + `{{.Short}}`, types.ModuleName, types.NewQueryClient) +} + // GetCmdSyntheticLockupByLockupID returns synthetic lockup by lockup id. func GetCmdSyntheticLockupByLockupID() *cobra.Command { return osmocli.SimpleQueryCmd[*types.SyntheticLockupByLockupIDRequest]( - "synthetic-lockups-by-lock-id ", + "synthetic-lockup-by-lock-id ", "Query synthetic lock by underlying lockup id", `{{.Short}}`, types.ModuleName, types.NewQueryClient) }