diff --git a/CHANGELOG.md b/CHANGELOG.md index 24c7e69adad..e1986ddeeba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -47,6 +47,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 * [#3763](https://github.com/osmosis-labs/osmosis/pull/3763) Remove Osmosis gamm and twap `bindings` that were previously supported as custom wasm plugins. * [#3905](https://github.com/osmosis-labs/osmosis/pull/3905) Deprecate gamm queries `NumPools`, `EstimateSwapExactAmountIn` and `EstimateSwapExactAmountOut`. * [#3907](https://github.com/osmosis-labs/osmosis/pull/3907) Add `NumPools`, `EstimateSwapExactAmountIn` and `EstimateSwapExactAmountOut` query in swaprouter module to stargate whitelist. +* [#3880](https://github.com/osmosis-labs/osmosis/pull/3880) Switch usage of proto-generated SwapAmountInRoute and SwapAmountOutRoute in x/gamm to import the structs from x/swaprouter module. ### Bug Fix diff --git a/app/apptesting/gamm.go b/app/apptesting/gamm.go index 84042b88ce7..0a53a7740ba 100644 --- a/app/apptesting/gamm.go +++ b/app/apptesting/gamm.go @@ -8,6 +8,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer" "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/stableswap" gammtypes "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) var DefaultAcctFunds sdk.Coins = sdk.NewCoins( @@ -188,7 +189,7 @@ func (s *KeeperTestHelper) ModifySpotPrice(poolID uint64, targetSpotPrice sdk.De s.FundAcc(s.TestAccs[0], swapIn) msg := gammtypes.MsgSwapExactAmountIn{ Sender: s.TestAccs[0].String(), - Routes: []gammtypes.SwapAmountInRoute{{PoolId: poolID, TokenOutDenom: baseDenom}}, + Routes: []swaproutertypes.SwapAmountInRoute{{PoolId: poolID, TokenOutDenom: baseDenom}}, TokenIn: swapIn[0], TokenOutMinAmount: sdk.ZeroInt(), } @@ -204,7 +205,7 @@ func (s *KeeperTestHelper) ModifySpotPrice(poolID uint64, targetSpotPrice sdk.De s.FundAcc(s.TestAccs[0], sdk.NewCoins(tokenIn)) msg := gammtypes.MsgSwapExactAmountOut{ Sender: s.TestAccs[0].String(), - Routes: []gammtypes.SwapAmountOutRoute{{PoolId: poolID, TokenInDenom: baseDenom}}, + Routes: []swaproutertypes.SwapAmountOutRoute{{PoolId: poolID, TokenInDenom: baseDenom}}, TokenInMaxAmount: sdk.NewInt(int64Max), TokenOut: swapOut[0], } @@ -224,7 +225,7 @@ func (s *KeeperTestHelper) RunBasicSwap(poolId uint64) { msg := gammtypes.MsgSwapExactAmountIn{ Sender: s.TestAccs[0].String(), - Routes: []gammtypes.SwapAmountInRoute{{PoolId: poolId, TokenOutDenom: denoms[1]}}, + Routes: []swaproutertypes.SwapAmountInRoute{{PoolId: poolId, TokenOutDenom: denoms[1]}}, TokenIn: swapIn[0], TokenOutMinAmount: sdk.ZeroInt(), } diff --git a/go.mod b/go.mod index ce107fef5c3..5a158956627 100644 --- a/go.mod +++ b/go.mod @@ -5,7 +5,7 @@ go 1.18 require ( github.com/CosmWasm/wasmd v0.30.0 github.com/cosmos/cosmos-proto v1.0.0-alpha8 - github.com/cosmos/cosmos-sdk v0.45.11 + github.com/cosmos/cosmos-sdk v0.46.7 github.com/cosmos/go-bip39 v1.0.0 github.com/cosmos/ibc-go/v4 v4.2.0 github.com/gogo/protobuf v1.3.3 diff --git a/proto/osmosis/gamm/v1beta1/query.proto b/proto/osmosis/gamm/v1beta1/query.proto index 6eef1b79024..2956b325976 100644 --- a/proto/osmosis/gamm/v1beta1/query.proto +++ b/proto/osmosis/gamm/v1beta1/query.proto @@ -3,6 +3,7 @@ package osmosis.gamm.v1beta1; import "gogoproto/gogo.proto"; import "osmosis/gamm/v1beta1/tx.proto"; +import "osmosis/swaprouter/v1beta1/swap_route.proto"; import "cosmos/base/v1beta1/coin.proto"; import "cosmos/base/query/v1beta1/pagination.proto"; @@ -267,7 +268,7 @@ message QuerySwapExactAmountInRequest { string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; uint64 pool_id = 2 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ]; string token_in = 3 [ (gogoproto.moretags) = "yaml:\"token_in\"" ]; - repeated SwapAmountInRoute routes = 4 [ + repeated osmosis.swaprouter.v1beta1.SwapAmountInRoute routes = 4 [ (gogoproto.moretags) = "yaml:\"routes\"", (gogoproto.nullable) = false ]; @@ -287,7 +288,7 @@ message QuerySwapExactAmountOutRequest { option deprecated = true; string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; uint64 pool_id = 2 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ]; - repeated SwapAmountOutRoute routes = 3 [ + repeated osmosis.swaprouter.v1beta1.SwapAmountOutRoute routes = 3 [ (gogoproto.moretags) = "yaml:\"routes\"", (gogoproto.nullable) = false ]; diff --git a/proto/osmosis/gamm/v1beta1/tx.proto b/proto/osmosis/gamm/v1beta1/tx.proto index 1e0c3b61d10..98e8ec2a0b3 100644 --- a/proto/osmosis/gamm/v1beta1/tx.proto +++ b/proto/osmosis/gamm/v1beta1/tx.proto @@ -3,6 +3,7 @@ package osmosis.gamm.v1beta1; import "gogoproto/gogo.proto"; import "cosmos/base/v1beta1/coin.proto"; +import "osmosis/swaprouter/v1beta1/swap_route.proto"; option go_package = "github.com/osmosis-labs/osmosis/v13/x/gamm/types"; @@ -83,7 +84,8 @@ message SwapAmountInRoute { message MsgSwapExactAmountIn { string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; - repeated SwapAmountInRoute routes = 2 [ (gogoproto.nullable) = false ]; + repeated osmosis.swaprouter.v1beta1.SwapAmountInRoute routes = 2 + [ (gogoproto.nullable) = false ]; cosmos.base.v1beta1.Coin token_in = 3 [ (gogoproto.moretags) = "yaml:\"token_in\"", (gogoproto.nullable) = false @@ -103,16 +105,10 @@ message MsgSwapExactAmountInResponse { ]; } -// ===================== MsgSwapExactAmountOut -message SwapAmountOutRoute { - uint64 pool_id = 1 [ (gogoproto.moretags) = "yaml:\"pool_id\"" ]; - string token_in_denom = 2 - [ (gogoproto.moretags) = "yaml:\"token_out_denom\"" ]; -} - message MsgSwapExactAmountOut { string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; - repeated SwapAmountOutRoute routes = 2 [ (gogoproto.nullable) = false ]; + repeated osmosis.swaprouter.v1beta1.SwapAmountOutRoute routes = 2 + [ (gogoproto.nullable) = false ]; string token_in_max_amount = 3 [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.moretags) = "yaml:\"token_in_max_amount\"", diff --git a/x/gamm/client/cli/cli_test.go b/x/gamm/client/cli/cli_test.go index b291e6b0c18..f5c64c3a068 100644 --- a/x/gamm/client/cli/cli_test.go +++ b/x/gamm/client/cli/cli_test.go @@ -11,6 +11,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/x/gamm/client/cli" "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer" "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" "github.com/cosmos/cosmos-sdk/testutil" "github.com/cosmos/cosmos-sdk/testutil/network" @@ -215,7 +216,7 @@ func TestNewSwapExactAmountOutCmd(t *testing.T) { Cmd: "10stake 20 --swap-route-pool-ids=1 --swap-route-denoms=node0token --from=" + testAddresses[0].String(), ExpectedMsg: &types.MsgSwapExactAmountOut{ Sender: testAddresses[0].String(), - Routes: []types.SwapAmountOutRoute{{PoolId: 1, TokenInDenom: "node0token"}}, + Routes: []swaproutertypes.SwapAmountOutRoute{{PoolId: 1, TokenInDenom: "node0token"}}, TokenInMaxAmount: sdk.NewIntFromUint64(20), TokenOut: sdk.NewInt64Coin("stake", 10), }, @@ -231,7 +232,7 @@ func TestNewSwapExactAmountInCmd(t *testing.T) { Cmd: "10stake 3 --swap-route-pool-ids=1 --swap-route-denoms=node0token --from=" + testAddresses[0].String(), ExpectedMsg: &types.MsgSwapExactAmountIn{ Sender: testAddresses[0].String(), - Routes: []types.SwapAmountInRoute{{PoolId: 1, TokenOutDenom: "node0token"}}, + Routes: []swaproutertypes.SwapAmountInRoute{{PoolId: 1, TokenOutDenom: "node0token"}}, TokenIn: sdk.NewInt64Coin("stake", 10), TokenOutMinAmount: sdk.NewIntFromUint64(3), }, @@ -354,7 +355,7 @@ func TestGetCmdEstimateSwapExactAmountIn(t *testing.T) { Sender: "osm11vmx8jtggpd9u7qr0t8vxclycz85u925sazglr7", PoolId: 1, TokenIn: "10stake", - Routes: []types.SwapAmountInRoute{{PoolId: 2, TokenOutDenom: "node0token"}}, + Routes: []swaproutertypes.SwapAmountInRoute{{PoolId: 2, TokenOutDenom: "node0token"}}, }, }, } @@ -370,7 +371,7 @@ func TestGetCmdEstimateSwapExactAmountOut(t *testing.T) { Sender: "osm11vmx8jtggpd9u7qr0t8vxclycz85u925sazglr7", PoolId: 1, TokenOut: "10stake", - Routes: []types.SwapAmountOutRoute{{PoolId: 2, TokenInDenom: "node0token"}}, + Routes: []swaproutertypes.SwapAmountOutRoute{{PoolId: 2, TokenInDenom: "node0token"}}, }, }, } diff --git a/x/gamm/client/cli/tx.go b/x/gamm/client/cli/tx.go index 0e0964a4e83..8c99549db4e 100644 --- a/x/gamm/client/cli/tx.go +++ b/x/gamm/client/cli/tx.go @@ -14,6 +14,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer" "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/stableswap" "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" "github.com/cosmos/cosmos-sdk/client" sdk "github.com/cosmos/cosmos-sdk/types" @@ -380,7 +381,7 @@ func stringArrayCoinsParser(flagName string, fs *flag.FlagSet) (sdk.Coins, error return coins, nil } -func swapAmountInRoutes(fs *flag.FlagSet) ([]types.SwapAmountInRoute, error) { +func swapAmountInRoutes(fs *flag.FlagSet) ([]swaproutertypes.SwapAmountInRoute, error) { swapRoutePoolIds, err := fs.GetString(FlagSwapRoutePoolIds) swapRoutePoolIdsArray := strings.Split(swapRoutePoolIds, ",") if err != nil { @@ -397,13 +398,13 @@ func swapAmountInRoutes(fs *flag.FlagSet) ([]types.SwapAmountInRoute, error) { return nil, errors.New("swap route pool ids and denoms mismatch") } - routes := []types.SwapAmountInRoute{} + routes := []swaproutertypes.SwapAmountInRoute{} for index, poolIDStr := range swapRoutePoolIdsArray { pID, err := strconv.Atoi(poolIDStr) if err != nil { return nil, err } - routes = append(routes, types.SwapAmountInRoute{ + routes = append(routes, swaproutertypes.SwapAmountInRoute{ PoolId: uint64(pID), TokenOutDenom: swapRouteDenomsArray[index], }) @@ -411,7 +412,7 @@ func swapAmountInRoutes(fs *flag.FlagSet) ([]types.SwapAmountInRoute, error) { return routes, nil } -func swapAmountOutRoutes(fs *flag.FlagSet) ([]types.SwapAmountOutRoute, error) { +func swapAmountOutRoutes(fs *flag.FlagSet) ([]swaproutertypes.SwapAmountOutRoute, error) { swapRoutePoolIds, err := fs.GetString(FlagSwapRoutePoolIds) swapRoutePoolIdsArray := strings.Split(swapRoutePoolIds, ",") if err != nil { @@ -428,13 +429,13 @@ func swapAmountOutRoutes(fs *flag.FlagSet) ([]types.SwapAmountOutRoute, error) { return nil, errors.New("swap route pool ids and denoms mismatch") } - routes := []types.SwapAmountOutRoute{} + routes := []swaproutertypes.SwapAmountOutRoute{} for index, poolIDStr := range swapRoutePoolIdsArray { pID, err := strconv.Atoi(poolIDStr) if err != nil { return nil, err } - routes = append(routes, types.SwapAmountOutRoute{ + routes = append(routes, swaproutertypes.SwapAmountOutRoute{ PoolId: uint64(pID), TokenInDenom: swapRouteDenomsArray[index], }) diff --git a/x/gamm/keeper/grpc_query.go b/x/gamm/keeper/grpc_query.go index 4b4696bb686..51faa277394 100644 --- a/x/gamm/keeper/grpc_query.go +++ b/x/gamm/keeper/grpc_query.go @@ -429,10 +429,7 @@ func (q Querier) EstimateSwapExactAmountIn(ctx context.Context, req *types.Query sdkCtx := sdk.UnwrapSDKContext(ctx) - // TODO: remove this redundancy after making routes be shared between x/gamm and x/swaprouter. - swaprouterRoutes := types.ConvertAmountInRoutes(req.Routes) - - tokenOutAmount, err := q.Keeper.poolManager.MultihopEstimateOutGivenExactAmountIn(sdkCtx, swaprouterRoutes, tokenIn) + tokenOutAmount, err := q.Keeper.poolManager.MultihopEstimateOutGivenExactAmountIn(sdkCtx, req.Routes, tokenIn) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } @@ -461,10 +458,7 @@ func (q Querier) EstimateSwapExactAmountOut(ctx context.Context, req *types.Quer sdkCtx := sdk.UnwrapSDKContext(ctx) - // TODO: remove this redundancy after making routes be shared between x/gamm and x/swaprouter. - swaprouterRoutes := types.ConvertAmountOutRoutes(req.Routes) - - tokenInAmount, err := q.Keeper.poolManager.MultihopEstimateInGivenExactAmountOut(sdkCtx, swaprouterRoutes, tokenOut) + tokenInAmount, err := q.Keeper.poolManager.MultihopEstimateInGivenExactAmountOut(sdkCtx, req.Routes, tokenOut) if err != nil { return nil, status.Error(codes.Internal, err.Error()) } diff --git a/x/gamm/keeper/msg_server.go b/x/gamm/keeper/msg_server.go index 7ff6322144f..8e670316bc9 100644 --- a/x/gamm/keeper/msg_server.go +++ b/x/gamm/keeper/msg_server.go @@ -163,10 +163,7 @@ func (server msgServer) SwapExactAmountIn(goCtx context.Context, msg *types.MsgS return nil, err } - // TODO: remove this redundancy after making routes be shared between x/gamm and x/swaprouter. - swaprouterRoutes := types.ConvertAmountInRoutes(msg.Routes) - - tokenOutAmount, err := server.keeper.poolManager.RouteExactAmountIn(ctx, sender, swaprouterRoutes, msg.TokenIn, msg.TokenOutMinAmount) + tokenOutAmount, err := server.keeper.poolManager.RouteExactAmountIn(ctx, sender, msg.Routes, msg.TokenIn, msg.TokenOutMinAmount) if err != nil { return nil, err } @@ -191,10 +188,7 @@ func (server msgServer) SwapExactAmountOut(goCtx context.Context, msg *types.Msg return nil, err } - // TODO: remove this redundancy after making routes be shared between x/gamm and x/swaprouter. - swaprouterRoutes := types.ConvertAmountOutRoutes(msg.Routes) - - tokenInAmount, err := server.keeper.poolManager.RouteExactAmountOut(ctx, sender, swaprouterRoutes, msg.TokenInMaxAmount, msg.TokenOut) + tokenInAmount, err := server.keeper.poolManager.RouteExactAmountOut(ctx, sender, msg.Routes, msg.TokenInMaxAmount, msg.TokenOut) if err != nil { return nil, err } diff --git a/x/gamm/keeper/msg_server_test.go b/x/gamm/keeper/msg_server_test.go index 662d4650c11..d7fa93fb2f1 100644 --- a/x/gamm/keeper/msg_server_test.go +++ b/x/gamm/keeper/msg_server_test.go @@ -5,6 +5,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/x/gamm/keeper" "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) const ( @@ -22,7 +23,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { ) testcases := map[string]struct { - routes []types.SwapAmountInRoute + routes []swaproutertypes.SwapAmountInRoute tokenIn sdk.Coin tokenOutMinAmount sdk.Int expectError bool @@ -30,13 +31,13 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { expectedMessageEvents int }{ "zero hops": { - routes: []types.SwapAmountInRoute{}, + routes: []swaproutertypes.SwapAmountInRoute{}, tokenIn: sdk.NewCoin("foo", sdk.NewInt(tokenIn)), tokenOutMinAmount: sdk.NewInt(tokenInMinAmount), expectError: true, }, "one hop": { - routes: []types.SwapAmountInRoute{ + routes: []swaproutertypes.SwapAmountInRoute{ { PoolId: 1, TokenOutDenom: "bar", @@ -48,7 +49,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. }, "two hops": { - routes: []types.SwapAmountInRoute{ + routes: []swaproutertypes.SwapAmountInRoute{ { PoolId: 1, TokenOutDenom: "bar", @@ -64,7 +65,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountIn_Events() { expectedMessageEvents: 5, // 1 gamm + 4 events emitted by other keeper methods. }, "invalid - two hops, denom does not exist": { - routes: []types.SwapAmountInRoute{ + routes: []swaproutertypes.SwapAmountInRoute{ { PoolId: 1, TokenOutDenom: "bar", @@ -121,7 +122,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { ) testcases := map[string]struct { - routes []types.SwapAmountOutRoute + routes []swaproutertypes.SwapAmountOutRoute tokenOut sdk.Coin tokenInMaxAmount sdk.Int expectError bool @@ -129,13 +130,13 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { expectedMessageEvents int }{ "zero hops": { - routes: []types.SwapAmountOutRoute{}, + routes: []swaproutertypes.SwapAmountOutRoute{}, tokenOut: sdk.NewCoin("foo", sdk.NewInt(tokenOut)), tokenInMaxAmount: sdk.NewInt(tokenInMaxAmount), expectError: true, }, "one hop": { - routes: []types.SwapAmountOutRoute{ + routes: []swaproutertypes.SwapAmountOutRoute{ { PoolId: 1, TokenInDenom: "bar", @@ -147,7 +148,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { expectedMessageEvents: 3, // 1 gamm + 2 events emitted by other keeper methods. }, "two hops": { - routes: []types.SwapAmountOutRoute{ + routes: []swaproutertypes.SwapAmountOutRoute{ { PoolId: 1, TokenInDenom: "bar", @@ -163,7 +164,7 @@ func (suite *KeeperTestSuite) TestSwapExactAmountOut_Events() { expectedMessageEvents: 5, // 1 gamm + 4 events emitted by other keeper methods. }, "invalid - two hops, denom does not exist": { - routes: []types.SwapAmountOutRoute{ + routes: []swaproutertypes.SwapAmountOutRoute{ { PoolId: 1, TokenInDenom: "bar", diff --git a/x/gamm/simulation/sim_msgs.go b/x/gamm/simulation/sim_msgs.go index 2f8e79c0218..9887a240378 100644 --- a/x/gamm/simulation/sim_msgs.go +++ b/x/gamm/simulation/sim_msgs.go @@ -13,6 +13,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/x/gamm/keeper" balancertypes "github.com/osmosis-labs/osmosis/v13/x/gamm/pool-models/balancer" "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) var PoolCreationFee = sdk.NewInt64Coin("stake", 10_000_000) @@ -129,7 +130,7 @@ func RandomSwapExactAmountIn(k keeper.Keeper, sim *simtypes.SimCtx, ctx sdk.Cont } // set the swap route to use this pool - route := []types.SwapAmountInRoute{{ + route := []swaproutertypes.SwapAmountInRoute{{ PoolId: pool_id, TokenOutDenom: coinOut.Denom, }} @@ -167,7 +168,7 @@ func RandomSwapExactAmountOut(k keeper.Keeper, sim *simtypes.SimCtx, ctx sdk.Con } // set the swap route to use this pool - route := []types.SwapAmountOutRoute{{ + route := []swaproutertypes.SwapAmountOutRoute{{ PoolId: pool_id, TokenInDenom: coinIn.Denom, }} diff --git a/x/gamm/types/msgs_test.go b/x/gamm/types/msgs_test.go index 325aa5f0f8c..98b503ccc81 100644 --- a/x/gamm/types/msgs_test.go +++ b/x/gamm/types/msgs_test.go @@ -12,6 +12,7 @@ import ( "github.com/osmosis-labs/osmosis/v13/app/apptesting" appParams "github.com/osmosis-labs/osmosis/v13/app/params" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) func TestMsgSwapExactAmountIn(t *testing.T) { @@ -23,7 +24,7 @@ func TestMsgSwapExactAmountIn(t *testing.T) { createMsg := func(after func(msg gammtypes.MsgSwapExactAmountIn) gammtypes.MsgSwapExactAmountIn) gammtypes.MsgSwapExactAmountIn { properMsg := gammtypes.MsgSwapExactAmountIn{ Sender: addr1, - Routes: []gammtypes.SwapAmountInRoute{{ + Routes: []swaproutertypes.SwapAmountInRoute{{ PoolId: 0, TokenOutDenom: "test", }, { @@ -80,7 +81,7 @@ func TestMsgSwapExactAmountIn(t *testing.T) { { name: "empty routes2", msg: createMsg(func(msg gammtypes.MsgSwapExactAmountIn) gammtypes.MsgSwapExactAmountIn { - msg.Routes = []gammtypes.SwapAmountInRoute{} + msg.Routes = []swaproutertypes.SwapAmountInRoute{} return msg }), expectPass: false, @@ -153,7 +154,7 @@ func TestMsgSwapExactAmountOut(t *testing.T) { createMsg := func(after func(msg gammtypes.MsgSwapExactAmountOut) gammtypes.MsgSwapExactAmountOut) gammtypes.MsgSwapExactAmountOut { properMsg := gammtypes.MsgSwapExactAmountOut{ Sender: addr1, - Routes: []gammtypes.SwapAmountOutRoute{{ + Routes: []swaproutertypes.SwapAmountOutRoute{{ PoolId: 0, TokenInDenom: "test", }, { @@ -210,7 +211,7 @@ func TestMsgSwapExactAmountOut(t *testing.T) { { name: "empty routes2", msg: createMsg(func(msg gammtypes.MsgSwapExactAmountOut) gammtypes.MsgSwapExactAmountOut { - msg.Routes = []gammtypes.SwapAmountOutRoute{} + msg.Routes = []swaproutertypes.SwapAmountOutRoute{} return msg }), expectPass: false, @@ -931,7 +932,7 @@ func TestAuthzMsg(t *testing.T) { name: "MsgJoinSwapShareAmountOut", gammMsg: &gammtypes.MsgSwapExactAmountIn{ Sender: addr1, - Routes: []gammtypes.SwapAmountInRoute{{ + Routes: []swaproutertypes.SwapAmountInRoute{{ PoolId: 0, TokenOutDenom: "test", }, { @@ -946,7 +947,7 @@ func TestAuthzMsg(t *testing.T) { name: "MsgSwapExactAmountOut", gammMsg: &gammtypes.MsgSwapExactAmountOut{ Sender: addr1, - Routes: []gammtypes.SwapAmountOutRoute{{ + Routes: []swaproutertypes.SwapAmountOutRoute{{ PoolId: 0, TokenInDenom: "test", }, { diff --git a/x/gamm/types/query.pb.go b/x/gamm/types/query.pb.go index 4d0990f0e24..466a3631753 100644 --- a/x/gamm/types/query.pb.go +++ b/x/gamm/types/query.pb.go @@ -14,6 +14,7 @@ import ( _ "github.com/gogo/protobuf/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" + types2 "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" _ "google.golang.org/genproto/googleapis/api/annotations" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" @@ -1184,10 +1185,10 @@ func (m *QuerySpotPriceResponse) GetSpotPrice() string { // // Deprecated: Do not use. type QuerySwapExactAmountInRequest struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` - PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` - TokenIn string `protobuf:"bytes,3,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty" yaml:"token_in"` - Routes []SwapAmountInRoute `protobuf:"bytes,4,rep,name=routes,proto3" json:"routes" yaml:"routes"` + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` + TokenIn string `protobuf:"bytes,3,opt,name=token_in,json=tokenIn,proto3" json:"token_in,omitempty" yaml:"token_in"` + Routes []types2.SwapAmountInRoute `protobuf:"bytes,4,rep,name=routes,proto3" json:"routes" yaml:"routes"` } func (m *QuerySwapExactAmountInRequest) Reset() { *m = QuerySwapExactAmountInRequest{} } @@ -1244,7 +1245,7 @@ func (m *QuerySwapExactAmountInRequest) GetTokenIn() string { return "" } -func (m *QuerySwapExactAmountInRequest) GetRoutes() []SwapAmountInRoute { +func (m *QuerySwapExactAmountInRequest) GetRoutes() []types2.SwapAmountInRoute { if m != nil { return m.Routes } @@ -1293,10 +1294,10 @@ var xxx_messageInfo_QuerySwapExactAmountInResponse proto.InternalMessageInfo // // Deprecated: Do not use. type QuerySwapExactAmountOutRequest struct { - Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` - PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` - Routes []SwapAmountOutRoute `protobuf:"bytes,3,rep,name=routes,proto3" json:"routes" yaml:"routes"` - TokenOut string `protobuf:"bytes,4,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty" yaml:"token_out"` + Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` + PoolId uint64 `protobuf:"varint,2,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` + Routes []types2.SwapAmountOutRoute `protobuf:"bytes,3,rep,name=routes,proto3" json:"routes" yaml:"routes"` + TokenOut string `protobuf:"bytes,4,opt,name=token_out,json=tokenOut,proto3" json:"token_out,omitempty" yaml:"token_out"` } func (m *QuerySwapExactAmountOutRequest) Reset() { *m = QuerySwapExactAmountOutRequest{} } @@ -1346,7 +1347,7 @@ func (m *QuerySwapExactAmountOutRequest) GetPoolId() uint64 { return 0 } -func (m *QuerySwapExactAmountOutRequest) GetRoutes() []SwapAmountOutRoute { +func (m *QuerySwapExactAmountOutRequest) GetRoutes() []types2.SwapAmountOutRoute { if m != nil { return m.Routes } @@ -1514,120 +1515,122 @@ func init() { func init() { proto.RegisterFile("osmosis/gamm/v1beta1/query.proto", fileDescriptor_d9a717df9ca609ef) } var fileDescriptor_d9a717df9ca609ef = []byte{ - // 1806 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x49, 0x6c, 0x1c, 0xc5, - 0x1a, 0x76, 0x8d, 0x97, 0x78, 0xca, 0xf1, 0x56, 0x71, 0x92, 0xc9, 0xd8, 0x99, 0xc9, 0xab, 0x97, - 0xd8, 0x4e, 0x62, 0xf7, 0xc4, 0x4b, 0xf4, 0x9e, 0xfc, 0x5e, 0x16, 0x3b, 0xb1, 0xe3, 0xb1, 0x5e, - 0x62, 0xbf, 0x4e, 0x94, 0x08, 0x38, 0x8c, 0xda, 0x76, 0x67, 0xdc, 0xc9, 0x4c, 0x57, 0x7b, 0xba, - 0x3a, 0xb6, 0x85, 0xa2, 0x48, 0x41, 0x42, 0xb9, 0x81, 0x04, 0x04, 0x81, 0x10, 0x70, 0x40, 0x08, - 0x71, 0x05, 0x89, 0x13, 0x07, 0x84, 0x90, 0x22, 0x4e, 0x91, 0xe0, 0x80, 0x38, 0x0c, 0x28, 0x81, - 0x1b, 0x27, 0x5f, 0xb8, 0xa2, 0x5a, 0x7a, 0x99, 0x7d, 0x81, 0x48, 0xe1, 0x64, 0x4f, 0xfd, 0x4b, - 0x7d, 0xff, 0xf7, 0xff, 0xf5, 0xf7, 0x5f, 0x05, 0x8f, 0x10, 0x3b, 0x4b, 0x6c, 0xc3, 0x4e, 0xa4, - 0xb5, 0x6c, 0x36, 0x71, 0x67, 0x62, 0x55, 0xa7, 0xda, 0x44, 0x62, 0xd3, 0xd1, 0x73, 0x3b, 0x8a, - 0x95, 0x23, 0x94, 0xa0, 0x01, 0xa9, 0xa1, 0x30, 0x0d, 0x45, 0x6a, 0x44, 0x07, 0xd2, 0x24, 0x4d, - 0xb8, 0x42, 0x82, 0xfd, 0x27, 0x74, 0xa3, 0x87, 0xcb, 0x7a, 0xa3, 0xdb, 0x52, 0x1c, 0x5b, 0xe3, - 0xf2, 0xc4, 0xaa, 0x66, 0xeb, 0x9e, 0x74, 0x8d, 0x18, 0xa6, 0x94, 0x9f, 0x08, 0xca, 0x39, 0x06, - 0x4f, 0xcb, 0xd2, 0xd2, 0x86, 0xa9, 0x51, 0x83, 0xb8, 0xba, 0x43, 0x69, 0x42, 0xd2, 0x19, 0x3d, - 0xa1, 0x59, 0x46, 0x42, 0x33, 0x4d, 0x42, 0xb9, 0xd0, 0x96, 0xd2, 0x43, 0x52, 0xca, 0x7f, 0xad, - 0x3a, 0x37, 0x13, 0x9a, 0xb9, 0xe3, 0x8a, 0xc4, 0x26, 0x29, 0x01, 0x5e, 0xfc, 0x10, 0x22, 0x7c, - 0x0e, 0xf6, 0xfd, 0x9f, 0xed, 0xba, 0x42, 0x48, 0x46, 0xd5, 0x37, 0x1d, 0xdd, 0xa6, 0xe8, 0x24, - 0xdc, 0x63, 0x11, 0x92, 0x49, 0x19, 0xeb, 0x11, 0x70, 0x04, 0x8c, 0xb6, 0xcd, 0xa1, 0xdd, 0x7c, - 0xbc, 0x67, 0x47, 0xcb, 0x66, 0x66, 0xb0, 0x14, 0x60, 0xb5, 0x83, 0xfd, 0x97, 0x5c, 0xc7, 0x8b, - 0xb0, 0x3f, 0xe0, 0xc0, 0xb6, 0x88, 0x69, 0xeb, 0x68, 0x0a, 0xb6, 0x31, 0x31, 0x37, 0xef, 0x9a, - 0x1c, 0x50, 0x04, 0x34, 0xc5, 0x85, 0xa6, 0xcc, 0x9a, 0x3b, 0x73, 0xe1, 0x6f, 0x3f, 0x1f, 0x6f, - 0x67, 0x56, 0x49, 0x95, 0x2b, 0xe3, 0x97, 0x02, 0x9e, 0x6c, 0x17, 0xcb, 0x02, 0x84, 0x3e, 0x0f, - 0x91, 0x10, 0xf7, 0x37, 0xac, 0xc8, 0x10, 0x18, 0x69, 0x8a, 0x48, 0x9c, 0x24, 0x4d, 0x59, 0xd1, - 0xd2, 0xba, 0xb4, 0x55, 0x03, 0x96, 0xf8, 0x4d, 0x00, 0x51, 0xd0, 0xbb, 0x04, 0x7a, 0x1a, 0xb6, - 0xb3, 0xbd, 0xed, 0x08, 0x38, 0xd2, 0x5a, 0x0f, 0x52, 0xa1, 0x8d, 0x2e, 0x95, 0x41, 0x35, 0x52, - 0x13, 0x95, 0xd8, 0xb3, 0x00, 0x56, 0x14, 0x0e, 0x70, 0x54, 0x57, 0x9c, 0x6c, 0x30, 0xec, 0x99, - 0x50, 0x04, 0xe0, 0x2b, 0x70, 0x7f, 0x91, 0x4c, 0x82, 0x9e, 0x80, 0x61, 0xd3, 0xc9, 0xa6, 0x5c, - 0xe0, 0x2c, 0x43, 0x03, 0xbb, 0xf9, 0x78, 0x9f, 0xc8, 0x90, 0x27, 0xc2, 0x6a, 0xa7, 0x29, 0x4d, - 0xb9, 0xbf, 0x0b, 0x72, 0x2f, 0xb6, 0x72, 0x6d, 0xc7, 0xd2, 0x9b, 0x4a, 0xf7, 0x92, 0x04, 0xe5, - 0x3b, 0xf1, 0x41, 0x71, 0x65, 0xba, 0x63, 0xe9, 0xdc, 0x4f, 0x38, 0x08, 0xca, 0x13, 0x61, 0xb5, - 0xd3, 0x92, 0xa6, 0xf8, 0x0b, 0x00, 0x63, 0xdc, 0xd9, 0x05, 0x2d, 0xb3, 0xb6, 0x44, 0x0c, 0x93, - 0x39, 0xbd, 0xba, 0xa1, 0xe5, 0x74, 0xbb, 0x19, 0x6c, 0x68, 0x03, 0x86, 0x29, 0xb9, 0xad, 0x9b, - 0x76, 0xca, 0x60, 0x49, 0x61, 0x09, 0x3d, 0x54, 0x90, 0x14, 0x37, 0x1d, 0x17, 0x88, 0x61, 0xce, - 0x9d, 0x7a, 0x94, 0x8f, 0xb7, 0x7c, 0xfa, 0x53, 0x7c, 0x34, 0x6d, 0xd0, 0x0d, 0x67, 0x55, 0x59, - 0x23, 0x59, 0x79, 0x34, 0xe4, 0x9f, 0x71, 0x7b, 0xfd, 0x76, 0x82, 0x61, 0xb6, 0xb9, 0x81, 0xad, - 0x76, 0x0a, 0xef, 0x49, 0x13, 0xdf, 0x0f, 0xc1, 0x78, 0x45, 0xe4, 0x92, 0x10, 0x1b, 0xf6, 0xd9, - 0x6c, 0x25, 0x45, 0x1c, 0x9a, 0xd2, 0xb2, 0xc4, 0x31, 0xa9, 0xe4, 0x25, 0xc9, 0x76, 0xfe, 0x31, - 0x1f, 0x1f, 0xae, 0x63, 0xe7, 0xa4, 0x49, 0x77, 0xf3, 0xf1, 0x83, 0x22, 0xe2, 0x62, 0x7f, 0x58, - 0xed, 0xe1, 0x4b, 0xcb, 0x0e, 0x9d, 0xe5, 0x0b, 0xe8, 0x16, 0x84, 0x92, 0x02, 0xe2, 0xd0, 0x67, - 0xc1, 0x81, 0x64, 0x78, 0xd9, 0xa1, 0xf8, 0x5d, 0x00, 0x47, 0x3c, 0x12, 0xe6, 0xb7, 0x0d, 0xca, - 0x48, 0xe0, 0x5a, 0x0b, 0x39, 0x92, 0x2d, 0xcc, 0xe3, 0xc1, 0xa2, 0x3c, 0x7a, 0x39, 0xbb, 0x0e, - 0x7b, 0x45, 0x54, 0x86, 0xe9, 0x92, 0x14, 0xe2, 0x24, 0x29, 0x8d, 0x91, 0xa4, 0x76, 0x73, 0x37, - 0x49, 0x53, 0x10, 0x81, 0x1f, 0x02, 0x38, 0x5a, 0x1b, 0x9c, 0x4c, 0x55, 0x21, 0x6b, 0xe0, 0x99, - 0xb2, 0x36, 0x0f, 0x0f, 0x78, 0x07, 0x68, 0x45, 0xcb, 0x69, 0xd9, 0xa6, 0x6a, 0x1d, 0x5f, 0x82, - 0x07, 0x4b, 0xdc, 0xc8, 0x68, 0xc6, 0x60, 0x87, 0xc5, 0x57, 0xaa, 0xb5, 0x5f, 0x55, 0xea, 0xe0, - 0xcb, 0xf2, 0x0c, 0x5e, 0x23, 0x54, 0xcb, 0x30, 0x6f, 0xff, 0x33, 0x36, 0x1d, 0x63, 0xdd, 0xa0, - 0x3b, 0x4d, 0xe1, 0xfa, 0x10, 0xc8, 0x93, 0x51, 0xce, 0x9f, 0x04, 0x78, 0x17, 0x86, 0x33, 0xee, - 0x62, 0x6d, 0xb6, 0x2f, 0x32, 0xb6, 0xfd, 0x4e, 0xe2, 0x59, 0xe2, 0xc6, 0x32, 0xe0, 0xdb, 0x2d, - 0x48, 0xea, 0x38, 0xc2, 0xe6, 0xdb, 0x0d, 0x76, 0x60, 0xa4, 0xd4, 0x8f, 0x0c, 0xf1, 0x05, 0xb8, - 0x97, 0xb2, 0xe5, 0x14, 0xaf, 0x4a, 0x37, 0x13, 0x55, 0xa2, 0x1c, 0x94, 0x51, 0xee, 0x13, 0x9b, - 0x05, 0x8d, 0xb1, 0xda, 0x45, 0xfd, 0x2d, 0xf0, 0x97, 0x00, 0x1e, 0x2d, 0xe9, 0x3d, 0x57, 0xc8, - 0xd5, 0x2d, 0xcd, 0xfa, 0x5b, 0xf4, 0xce, 0xdf, 0x01, 0x3c, 0x56, 0x03, 0xbf, 0x24, 0xf1, 0x5e, - 0x63, 0xc7, 0x72, 0x5e, 0x52, 0xd8, 0xef, 0x52, 0xe8, 0x9a, 0xe2, 0x26, 0xcf, 0x2a, 0xba, 0x0c, - 0xa1, 0x48, 0x81, 0xec, 0xa6, 0xcd, 0xf4, 0xa5, 0xb0, 0xf0, 0xc0, 0x8e, 0xfe, 0x6f, 0x40, 0x7e, - 0x3c, 0xaf, 0x5a, 0x84, 0xae, 0xe4, 0x8c, 0xb5, 0xa6, 0x3e, 0xc1, 0x68, 0x1e, 0xf6, 0xb1, 0xe0, - 0x53, 0x9a, 0x6d, 0xeb, 0x34, 0xb5, 0xae, 0x9b, 0x24, 0x2b, 0xb1, 0x0d, 0xfa, 0x9f, 0x8a, 0x62, - 0x0d, 0xac, 0xf6, 0xb0, 0xa5, 0x59, 0xb6, 0x72, 0x91, 0x2d, 0xa0, 0x45, 0xd8, 0xbf, 0xe9, 0x10, - 0x5a, 0xe8, 0xa7, 0x95, 0xfb, 0x19, 0xda, 0xcd, 0xc7, 0x23, 0xc2, 0x4f, 0x89, 0x0a, 0x56, 0x7b, - 0xf9, 0x9a, 0xef, 0x89, 0x0d, 0x17, 0x4b, 0x6d, 0x9d, 0x6d, 0x7d, 0xed, 0x6a, 0xd7, 0x96, 0x41, - 0x37, 0x58, 0x26, 0x17, 0x74, 0x1d, 0x7f, 0x05, 0xe0, 0xa0, 0x3f, 0x72, 0xdd, 0x30, 0xe8, 0xc6, - 0x82, 0x91, 0xa1, 0x7a, 0xce, 0x0d, 0xfa, 0x0c, 0xec, 0xce, 0x1a, 0x66, 0x2a, 0xd8, 0x0a, 0xd8, - 0xe6, 0x91, 0xdd, 0x7c, 0x7c, 0x40, 0x6c, 0x5e, 0x20, 0xc6, 0xea, 0xde, 0xac, 0x61, 0x7a, 0xdd, - 0x04, 0x0d, 0x06, 0x07, 0x0e, 0x1e, 0xbf, 0x3f, 0x5a, 0x14, 0x8d, 0x8d, 0xad, 0x4d, 0x8f, 0x8d, - 0xef, 0x03, 0x38, 0x54, 0x3e, 0x86, 0xe7, 0x64, 0x80, 0x54, 0xe5, 0xe7, 0x24, 0x50, 0x52, 0x12, - 0xd9, 0x34, 0x84, 0xb6, 0x45, 0x68, 0xca, 0x62, 0xab, 0x92, 0xdb, 0xfd, 0xfe, 0xf1, 0xf0, 0x65, - 0x58, 0x0d, 0xdb, 0xae, 0x35, 0x1f, 0x14, 0x5f, 0x09, 0xc1, 0xc3, 0xc2, 0xe9, 0x96, 0x66, 0xcd, - 0x6f, 0x6b, 0x6b, 0x72, 0xba, 0x48, 0x9a, 0x6e, 0xea, 0x8e, 0xc3, 0x0e, 0x5b, 0x37, 0xd7, 0xf5, - 0x9c, 0xf4, 0xdb, 0xbf, 0x9b, 0x8f, 0x77, 0x4b, 0xbf, 0x7c, 0x1d, 0xab, 0x52, 0x21, 0x58, 0xda, - 0xa1, 0x9a, 0xa5, 0xad, 0x40, 0xd1, 0x27, 0x58, 0x13, 0x12, 0xa5, 0xb8, 0x6f, 0x37, 0x1f, 0xef, - 0x0d, 0x1c, 0xe8, 0x94, 0x61, 0x62, 0x75, 0x0f, 0xff, 0x37, 0x69, 0xa2, 0xeb, 0xb0, 0x23, 0x47, - 0x1c, 0xaa, 0xdb, 0x91, 0x36, 0x4e, 0xff, 0x88, 0x52, 0xee, 0xe6, 0xa6, 0xb0, 0x38, 0xbc, 0x10, - 0x98, 0xfe, 0xdc, 0x7e, 0xd9, 0x2b, 0x24, 0x68, 0xe1, 0x04, 0xab, 0xd2, 0x1b, 0x67, 0xe1, 0x1d, - 0x77, 0x3a, 0x2d, 0xc3, 0x82, 0x3f, 0xe2, 0x09, 0x50, 0x7f, 0xdd, 0x88, 0x57, 0xec, 0x0f, 0xab, - 0x3d, 0x7c, 0xc9, 0x1b, 0xf1, 0x38, 0xb6, 0x07, 0xa1, 0xf2, 0xd8, 0x96, 0x1d, 0xfa, 0xac, 0x53, - 0x74, 0xc3, 0xa3, 0xbc, 0x95, 0x53, 0x3e, 0x5a, 0x8b, 0x72, 0x86, 0xa9, 0x0e, 0xce, 0xd9, 0x05, - 0xc2, 0x0b, 0x3e, 0xd2, 0x56, 0x7c, 0x81, 0xf0, 0x44, 0x58, 0x7e, 0x4a, 0x96, 0x1d, 0x41, 0xc5, - 0xdb, 0xee, 0xc0, 0x51, 0x8e, 0x0a, 0x99, 0x27, 0x0b, 0xf6, 0xba, 0xc5, 0x53, 0x98, 0xa6, 0xc5, - 0x86, 0xd3, 0x74, 0xa0, 0xb0, 0x16, 0xbd, 0x2c, 0x75, 0xcb, 0x92, 0x0c, 0x24, 0x69, 0x08, 0x46, - 0xfd, 0xf9, 0xa0, 0x78, 0xaa, 0xc2, 0xef, 0xb9, 0xdd, 0xb1, 0x58, 0xfc, 0x5c, 0x0c, 0x49, 0x93, - 0x9f, 0x0d, 0xc0, 0x76, 0x0e, 0x0f, 0xdd, 0x83, 0xbc, 0x75, 0xd9, 0xa8, 0xc2, 0xe1, 0x2a, 0xb9, - 0xb3, 0x47, 0x47, 0x6b, 0x2b, 0x8a, 0x20, 0xf1, 0x3f, 0xef, 0x7f, 0xf7, 0xcb, 0x1b, 0xa1, 0xc3, - 0x68, 0x30, 0x51, 0xf6, 0x15, 0x45, 0xf4, 0xca, 0xd7, 0x00, 0xec, 0x74, 0xef, 0xc0, 0xe8, 0x44, - 0x15, 0xdf, 0x45, 0x97, 0xe8, 0xe8, 0xc9, 0xba, 0x74, 0x25, 0x94, 0x13, 0x1c, 0xca, 0x3f, 0x50, - 0xbc, 0x3c, 0x14, 0xef, 0x56, 0xfd, 0x20, 0x04, 0xd0, 0x47, 0x00, 0xf6, 0x14, 0xa6, 0x0d, 0x9d, - 0xaa, 0xb2, 0x57, 0xd9, 0x02, 0x88, 0x4e, 0x34, 0x60, 0x21, 0x31, 0x8e, 0x73, 0x8c, 0x23, 0xe8, - 0x58, 0x79, 0x8c, 0x62, 0x68, 0xf4, 0x72, 0x88, 0x3e, 0x06, 0xb0, 0xb7, 0xe8, 0xbb, 0x85, 0x26, - 0x6a, 0xe5, 0xa6, 0xe4, 0x3b, 0x1d, 0x9d, 0x6c, 0xc4, 0x44, 0x22, 0x1d, 0xe3, 0x48, 0x87, 0xd1, - 0xd1, 0xf2, 0x48, 0x6f, 0x72, 0x6d, 0x7d, 0x5d, 0x50, 0x8a, 0x5e, 0x05, 0xb0, 0x8d, 0x79, 0x42, - 0xc3, 0x35, 0xb6, 0x72, 0x21, 0x8d, 0xd4, 0xd4, 0xab, 0x8f, 0x31, 0xbe, 0x7d, 0xe2, 0x65, 0xd9, - 0xe4, 0xee, 0xa2, 0x87, 0x00, 0x76, 0xba, 0x2f, 0x1b, 0x55, 0x4b, 0xad, 0xe8, 0x0d, 0xa5, 0x6a, - 0xa9, 0x15, 0x3f, 0x95, 0xe0, 0x09, 0x0e, 0xea, 0x24, 0x3a, 0x5e, 0x19, 0x14, 0x9f, 0x6a, 0x02, - 0xc0, 0xde, 0x02, 0x30, 0x52, 0x69, 0x5e, 0x46, 0x33, 0x55, 0x36, 0xaf, 0x71, 0x49, 0x88, 0xfe, - 0xa7, 0x29, 0x5b, 0x19, 0x48, 0x0b, 0xfa, 0x1a, 0x40, 0x54, 0xfa, 0x06, 0x82, 0xa6, 0xeb, 0xf4, - 0x5a, 0x88, 0xe5, 0x74, 0x83, 0x56, 0x12, 0xc5, 0x79, 0x4e, 0xe7, 0x0c, 0xfa, 0x77, 0x5d, 0x39, - 0x4e, 0xdc, 0x22, 0x86, 0x99, 0xb2, 0xb7, 0x34, 0x2b, 0xa5, 0xb3, 0xaf, 0x45, 0xca, 0x30, 0xd1, - 0xaf, 0x00, 0x0e, 0x56, 0x79, 0x27, 0x40, 0x67, 0x6a, 0x00, 0xab, 0xfe, 0xf8, 0x11, 0x3d, 0xdb, - 0xac, 0xb9, 0x0c, 0xf0, 0x12, 0x0f, 0x70, 0x16, 0x9d, 0xab, 0x2f, 0x40, 0x7d, 0xdb, 0xa0, 0x22, - 0x40, 0xf1, 0xb2, 0x22, 0x3e, 0x51, 0x2c, 0xce, 0x0f, 0x00, 0x84, 0xfe, 0x83, 0x01, 0x1a, 0xab, - 0x51, 0xb4, 0x05, 0xcf, 0x13, 0xd1, 0xf1, 0x3a, 0xb5, 0x25, 0xe8, 0x69, 0x0e, 0x5a, 0x41, 0x63, - 0xf5, 0x81, 0x16, 0xaf, 0x11, 0xe8, 0x1b, 0x00, 0x51, 0xe9, 0xcb, 0x41, 0xd5, 0x7a, 0xaa, 0xf8, - 0x70, 0x51, 0xb5, 0x9e, 0x2a, 0x3f, 0x4f, 0xe0, 0x39, 0x8e, 0xfc, 0xbf, 0x68, 0xa6, 0x3e, 0xe4, - 0xa2, 0xeb, 0xf2, 0x9f, 0x7e, 0xeb, 0xfd, 0x04, 0xc0, 0xae, 0xc0, 0xbb, 0x00, 0x1a, 0xaf, 0x05, - 0xa5, 0xb0, 0x62, 0x94, 0x7a, 0xd5, 0x25, 0xe4, 0x19, 0x0e, 0x79, 0x1a, 0x4d, 0x36, 0x02, 0x59, - 0x5c, 0x4c, 0x59, 0x51, 0x84, 0xbd, 0xdb, 0x03, 0xaa, 0xd6, 0xc8, 0x8a, 0xaf, 0xad, 0xd1, 0xb1, - 0xfa, 0x94, 0x25, 0xc8, 0x7f, 0x35, 0x58, 0x11, 0xcc, 0x98, 0x7f, 0x6e, 0x1f, 0x03, 0x78, 0x68, - 0xde, 0xa6, 0x46, 0x56, 0xa3, 0x7a, 0xc9, 0x30, 0x8e, 0xa6, 0xaa, 0x81, 0xa8, 0x70, 0x81, 0x89, - 0x4e, 0x37, 0x66, 0x24, 0x23, 0x58, 0xe4, 0x11, 0x9c, 0x43, 0x67, 0xca, 0x47, 0x10, 0x38, 0x82, - 0x12, 0x6d, 0x22, 0xd0, 0x67, 0xbc, 0x63, 0xc8, 0x42, 0xfa, 0x1e, 0xc0, 0x68, 0x85, 0x90, 0x96, - 0x1d, 0x8a, 0x1a, 0x80, 0xe7, 0x8f, 0xfc, 0x55, 0xeb, 0xbd, 0xf2, 0x74, 0x8c, 0x93, 0x3c, 0xaa, - 0xf3, 0xe8, 0xec, 0x9f, 0x88, 0x8a, 0x38, 0xf4, 0x41, 0x08, 0xcc, 0x2d, 0x3d, 0x7a, 0x12, 0x03, - 0x8f, 0x9f, 0xc4, 0xc0, 0xcf, 0x4f, 0x62, 0xe0, 0xf5, 0xa7, 0xb1, 0x96, 0xc7, 0x4f, 0x63, 0x2d, - 0x3f, 0x3c, 0x8d, 0xb5, 0xbc, 0x78, 0x2a, 0x30, 0x84, 0xca, 0x6d, 0xc6, 0x33, 0xda, 0xaa, 0xed, - 0xed, 0x79, 0x67, 0x62, 0x2a, 0xb1, 0x2d, 0x76, 0xe6, 0x23, 0xe9, 0x6a, 0x07, 0xbf, 0x42, 0x4f, - 0xfd, 0x11, 0x00, 0x00, 0xff, 0xff, 0x4e, 0x7f, 0xad, 0xe2, 0xaf, 0x1b, 0x00, 0x00, + // 1830 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x4b, 0x6c, 0x1c, 0x45, + 0x1a, 0x76, 0x8d, 0x1f, 0xf1, 0x94, 0xe3, 0x57, 0xc5, 0x49, 0x26, 0x63, 0x67, 0x26, 0x5b, 0x9b, + 0xd8, 0x4e, 0x6c, 0xf7, 0xc4, 0x8f, 0x68, 0x57, 0xde, 0xcd, 0xc3, 0x4e, 0xec, 0x78, 0xac, 0x4d, + 0xec, 0xed, 0x44, 0xbb, 0xda, 0x07, 0x1a, 0xb5, 0xed, 0xce, 0xb8, 0x93, 0x99, 0xae, 0xf6, 0x74, + 0x75, 0x6c, 0x0b, 0x45, 0x91, 0x72, 0x40, 0xe1, 0x02, 0x48, 0x40, 0x10, 0x08, 0x01, 0x07, 0x84, + 0x10, 0x57, 0x90, 0x38, 0x71, 0x40, 0x08, 0x29, 0xe2, 0x14, 0x09, 0x0e, 0x88, 0xc3, 0x80, 0x12, + 0xb8, 0x71, 0xf2, 0x85, 0x2b, 0xaa, 0x47, 0x3f, 0xe6, 0xfd, 0x80, 0x48, 0xe1, 0x64, 0x4f, 0xfd, + 0x8f, 0xfa, 0xfe, 0xef, 0xff, 0xeb, 0xef, 0xbf, 0x0a, 0x1e, 0x23, 0x76, 0x96, 0xd8, 0x86, 0x9d, + 0x48, 0x6b, 0xd9, 0x6c, 0xe2, 0xf6, 0xe4, 0x9a, 0x4e, 0xb5, 0xc9, 0xc4, 0x96, 0xa3, 0xe7, 0x76, + 0x15, 0x2b, 0x47, 0x28, 0x41, 0x03, 0x52, 0x43, 0x61, 0x1a, 0x8a, 0xd4, 0x88, 0x0e, 0xa4, 0x49, + 0x9a, 0x70, 0x85, 0x04, 0xfb, 0x4f, 0xe8, 0x46, 0x8f, 0x96, 0xf5, 0x46, 0x77, 0xa4, 0x78, 0xcc, + 0x15, 0xdb, 0xdb, 0x9a, 0x95, 0x23, 0x0e, 0xd5, 0x73, 0x9e, 0x12, 0x5b, 0x4a, 0xf1, 0x35, 0xa9, + 0x1c, 0x5b, 0xe7, 0xda, 0x89, 0x35, 0xcd, 0xd6, 0x3d, 0xad, 0x75, 0x62, 0x98, 0x52, 0x7e, 0x2a, + 0x28, 0xe7, 0x80, 0x3d, 0x2d, 0x4b, 0x4b, 0x1b, 0xa6, 0x46, 0x0d, 0xe2, 0xea, 0x0e, 0xa5, 0x09, + 0x49, 0x67, 0xf4, 0x84, 0x66, 0x19, 0x09, 0xcd, 0x34, 0x09, 0xe5, 0x42, 0x5b, 0x4a, 0x8f, 0x48, + 0x29, 0xff, 0xb5, 0xe6, 0xdc, 0x48, 0x68, 0xe6, 0xae, 0x2b, 0x12, 0x9b, 0xa4, 0x44, 0xa4, 0xe2, + 0x87, 0x10, 0xe1, 0xf3, 0xb0, 0xef, 0x9f, 0x6c, 0xd7, 0x55, 0x42, 0x32, 0xaa, 0xbe, 0xe5, 0xe8, + 0x36, 0x45, 0x63, 0x70, 0x9f, 0x45, 0x48, 0x26, 0x65, 0x6c, 0x44, 0xc0, 0x31, 0x30, 0xda, 0x36, + 0x8f, 0xf6, 0xf2, 0xf1, 0x9e, 0x5d, 0x2d, 0x9b, 0x99, 0xc5, 0x52, 0x80, 0xd5, 0x0e, 0xf6, 0x5f, + 0x72, 0x03, 0x2f, 0xc1, 0xfe, 0x80, 0x03, 0xdb, 0x22, 0xa6, 0xad, 0xa3, 0x69, 0xd8, 0xc6, 0xc4, + 0xdc, 0xbc, 0x6b, 0x6a, 0x40, 0x11, 0xd0, 0x14, 0x17, 0x9a, 0x32, 0x67, 0xee, 0xce, 0x87, 0xbf, + 0xfa, 0x64, 0xa2, 0x9d, 0x59, 0x25, 0x55, 0xae, 0x8c, 0xff, 0x17, 0xf0, 0x64, 0xbb, 0x58, 0x16, + 0x21, 0xf4, 0x79, 0x88, 0x84, 0xb8, 0xbf, 0x61, 0x45, 0x86, 0xc0, 0x48, 0x53, 0x44, 0x96, 0x25, + 0x69, 0xca, 0xaa, 0x96, 0xd6, 0xa5, 0xad, 0x1a, 0xb0, 0xc4, 0xaf, 0x01, 0x88, 0x82, 0xde, 0x25, + 0xd0, 0x33, 0xb0, 0x9d, 0xed, 0x6d, 0x47, 0xc0, 0xb1, 0xd6, 0x7a, 0x90, 0x0a, 0x6d, 0x74, 0xb9, + 0x0c, 0xaa, 0x91, 0x9a, 0xa8, 0xc4, 0x9e, 0x05, 0xb0, 0xa2, 0x70, 0x80, 0xa3, 0xba, 0xea, 0x64, + 0x83, 0x61, 0xcf, 0x86, 0x22, 0x00, 0x5f, 0x85, 0x07, 0x8b, 0x64, 0x12, 0xf4, 0x24, 0x0c, 0x9b, + 0x4e, 0x36, 0xe5, 0x02, 0x67, 0x19, 0x1a, 0xd8, 0xcb, 0xc7, 0xfb, 0x44, 0x86, 0x3c, 0x11, 0x56, + 0x3b, 0x4d, 0x69, 0xca, 0xfd, 0x5d, 0x94, 0x7b, 0xb1, 0x95, 0xeb, 0xbb, 0x96, 0xde, 0x54, 0xba, + 0x97, 0x25, 0x28, 0xdf, 0x89, 0x0f, 0x8a, 0x2b, 0xd3, 0x5d, 0x4b, 0xe7, 0x7e, 0xc2, 0x41, 0x50, + 0x9e, 0x08, 0xab, 0x9d, 0x96, 0x34, 0xc5, 0x9f, 0x02, 0x18, 0xe3, 0xce, 0x2e, 0x6a, 0x99, 0xf5, + 0x65, 0x62, 0x98, 0xcc, 0xe9, 0xb5, 0x4d, 0x2d, 0xa7, 0xdb, 0xcd, 0x60, 0x43, 0x9b, 0x30, 0x4c, + 0xc9, 0x2d, 0xdd, 0xb4, 0x53, 0x06, 0x4b, 0x0a, 0x4b, 0xe8, 0x91, 0x82, 0xa4, 0xb8, 0xe9, 0xb8, + 0x48, 0x0c, 0x73, 0xfe, 0xf4, 0xc3, 0x7c, 0xbc, 0xe5, 0xa3, 0xef, 0xe3, 0xa3, 0x69, 0x83, 0x6e, + 0x3a, 0x6b, 0xca, 0x3a, 0xc9, 0xca, 0xa3, 0x21, 0xff, 0x4c, 0xd8, 0x1b, 0xb7, 0x12, 0x0c, 0xb3, + 0xcd, 0x0d, 0x6c, 0xb5, 0x53, 0x78, 0x4f, 0x9a, 0xf8, 0x5e, 0x08, 0xc6, 0x2b, 0x22, 0x97, 0x84, + 0xd8, 0xb0, 0xcf, 0x66, 0x2b, 0x29, 0xe2, 0xd0, 0x94, 0x96, 0x25, 0x8e, 0x49, 0x25, 0x2f, 0x49, + 0xb6, 0xf3, 0x77, 0xf9, 0xf8, 0x70, 0x1d, 0x3b, 0x27, 0x4d, 0xba, 0x97, 0x8f, 0x1f, 0x16, 0x11, + 0x17, 0xfb, 0xc3, 0x6a, 0x0f, 0x5f, 0x5a, 0x71, 0xe8, 0x1c, 0x5f, 0x40, 0x37, 0x21, 0x94, 0x14, + 0x10, 0x87, 0x3e, 0x0d, 0x0e, 0x24, 0xc3, 0x2b, 0x0e, 0xc5, 0x6f, 0x01, 0x38, 0xe2, 0x91, 0xb0, + 0xb0, 0x63, 0x50, 0x46, 0x02, 0xd7, 0x5a, 0xcc, 0x91, 0x6c, 0x61, 0x1e, 0x0f, 0x17, 0xe5, 0xd1, + 0xcb, 0xd9, 0xbf, 0x60, 0xaf, 0x88, 0xca, 0x30, 0x5d, 0x92, 0x42, 0x9c, 0x24, 0xa5, 0x31, 0x92, + 0xd4, 0x6e, 0xee, 0x26, 0x69, 0x0a, 0x22, 0xf0, 0x03, 0x00, 0x47, 0x6b, 0x83, 0x93, 0xa9, 0x2a, + 0x64, 0x0d, 0x3c, 0x55, 0xd6, 0x16, 0xe0, 0x21, 0xef, 0x00, 0xad, 0x6a, 0x39, 0x2d, 0xdb, 0x54, + 0xad, 0xe3, 0xcb, 0xf0, 0x70, 0x89, 0x1b, 0x19, 0xcd, 0x38, 0xec, 0xb0, 0xf8, 0x4a, 0xb5, 0xf6, + 0xab, 0x4a, 0x1d, 0x7c, 0x45, 0x9e, 0xc1, 0xeb, 0x84, 0x6a, 0x19, 0xe6, 0xed, 0x1f, 0xc6, 0x96, + 0x63, 0x6c, 0x18, 0x74, 0xb7, 0x29, 0x5c, 0xef, 0x01, 0x79, 0x32, 0xca, 0xf9, 0x93, 0x00, 0xef, + 0xc0, 0x70, 0xc6, 0x5d, 0xac, 0xcd, 0xf6, 0x25, 0xc6, 0xb6, 0xdf, 0x49, 0x3c, 0x4b, 0xdc, 0x58, + 0x06, 0x7c, 0xbb, 0x45, 0x49, 0x1d, 0x47, 0xd8, 0x7c, 0xbb, 0xc1, 0x0e, 0x8c, 0x94, 0xfa, 0x91, + 0x21, 0xfe, 0x07, 0xee, 0xa7, 0x6c, 0x39, 0xc5, 0xab, 0xd2, 0xcd, 0x44, 0x95, 0x28, 0x07, 0x65, + 0x94, 0x07, 0xc4, 0x66, 0x41, 0x63, 0xac, 0x76, 0x51, 0x7f, 0x0b, 0xfc, 0x19, 0x80, 0xc7, 0x4b, + 0x7a, 0xcf, 0x55, 0x72, 0x6d, 0x5b, 0xb3, 0xfe, 0x10, 0xbd, 0xf3, 0x17, 0x00, 0x4f, 0xd4, 0xc0, + 0x2f, 0x49, 0xbc, 0xdb, 0xd8, 0xb1, 0x5c, 0x90, 0x14, 0xf6, 0xbb, 0x14, 0xba, 0xa6, 0xb8, 0xc9, + 0xb3, 0x8a, 0xae, 0x40, 0x28, 0x52, 0x20, 0xbb, 0x69, 0x33, 0x7d, 0x29, 0x2c, 0x3c, 0xb0, 0xa3, + 0xff, 0x33, 0x90, 0x1f, 0xcf, 0x6b, 0x16, 0xa1, 0xab, 0x39, 0x63, 0xbd, 0xa9, 0x4f, 0x30, 0x5a, + 0x80, 0x7d, 0x2c, 0xf8, 0x94, 0x66, 0xdb, 0x3a, 0x4d, 0x6d, 0xe8, 0x26, 0xc9, 0x4a, 0x6c, 0x83, + 0xfe, 0xa7, 0xa2, 0x58, 0x03, 0xab, 0x3d, 0x6c, 0x69, 0x8e, 0xad, 0x5c, 0x62, 0x0b, 0x68, 0x09, + 0xf6, 0x6f, 0x39, 0x84, 0x16, 0xfa, 0x69, 0xe5, 0x7e, 0x86, 0xf6, 0xf2, 0xf1, 0x88, 0xf0, 0x53, + 0xa2, 0x82, 0xd5, 0x5e, 0xbe, 0xe6, 0x7b, 0x62, 0xc3, 0xc5, 0x72, 0x5b, 0x67, 0x5b, 0x5f, 0xbb, + 0xda, 0xb5, 0x6d, 0xd0, 0x4d, 0x96, 0xc9, 0x45, 0x5d, 0xc7, 0x9f, 0x03, 0x38, 0xe8, 0x8f, 0x5c, + 0xff, 0x36, 0xe8, 0xe6, 0xa2, 0x91, 0xa1, 0x7a, 0xce, 0x0d, 0xfa, 0x2c, 0xec, 0xce, 0x1a, 0x66, + 0x2a, 0xd8, 0x0a, 0xd8, 0xe6, 0x91, 0xbd, 0x7c, 0x7c, 0x40, 0x6c, 0x5e, 0x20, 0xc6, 0xea, 0xfe, + 0xac, 0x61, 0x7a, 0xdd, 0x04, 0x0d, 0x06, 0x07, 0x0e, 0x1e, 0xbf, 0x3f, 0x5a, 0x14, 0x8d, 0x8d, + 0xad, 0x4d, 0x8f, 0x8d, 0xef, 0x00, 0x38, 0x54, 0x3e, 0x86, 0x67, 0x64, 0x80, 0x54, 0xe5, 0xe7, + 0x24, 0x50, 0x52, 0x12, 0xd9, 0x0c, 0x84, 0xb6, 0x45, 0x68, 0xca, 0x62, 0xab, 0x92, 0xdb, 0x83, + 0xfe, 0xf1, 0xf0, 0x65, 0x58, 0x0d, 0xdb, 0xae, 0x35, 0x1f, 0x14, 0x5f, 0x0c, 0xc1, 0xa3, 0xc2, + 0xe9, 0xb6, 0x66, 0x2d, 0xec, 0x68, 0xeb, 0x72, 0xba, 0x48, 0x9a, 0x6e, 0xea, 0x4e, 0xc2, 0x0e, + 0x5b, 0x37, 0x37, 0xf4, 0x9c, 0xf4, 0xdb, 0xbf, 0x97, 0x8f, 0x77, 0x4b, 0xbf, 0x7c, 0x1d, 0xab, + 0x52, 0x21, 0x58, 0xda, 0xa1, 0x9a, 0xa5, 0xad, 0x40, 0xd1, 0x27, 0x58, 0x13, 0x12, 0xa5, 0x78, + 0x60, 0x2f, 0x1f, 0xef, 0x0d, 0x1c, 0xe8, 0x94, 0x61, 0x62, 0x75, 0x1f, 0xff, 0x37, 0x69, 0xa2, + 0xff, 0xc3, 0x0e, 0x7e, 0xd9, 0xb2, 0x23, 0x6d, 0x9c, 0xfe, 0x09, 0xc5, 0xbd, 0xe6, 0xf9, 0x77, + 0x33, 0x8f, 0x43, 0x16, 0x8d, 0x17, 0x08, 0x13, 0xcd, 0x1f, 0x94, 0x1d, 0x43, 0x42, 0x17, 0xae, + 0xb0, 0x2a, 0x7d, 0x72, 0x2e, 0xde, 0x74, 0x67, 0xd4, 0x32, 0x5c, 0xf8, 0x83, 0x9e, 0x80, 0xf6, + 0xfb, 0x0d, 0x7a, 0xc5, 0xfe, 0xb0, 0xda, 0xc3, 0x97, 0xbc, 0x41, 0x8f, 0x63, 0x7b, 0x29, 0x54, + 0x1e, 0xdb, 0x8a, 0x43, 0x9f, 0x76, 0xa2, 0x9e, 0xf3, 0x88, 0x6f, 0xe5, 0xc4, 0x2b, 0xf5, 0x11, + 0xcf, 0x90, 0xd5, 0xc1, 0x3c, 0xbb, 0x4c, 0x78, 0x14, 0x44, 0xda, 0x8a, 0x2f, 0x13, 0x9e, 0x08, + 0xcb, 0xcf, 0xca, 0x8a, 0x23, 0x08, 0x79, 0xc3, 0x1d, 0x3e, 0xca, 0x11, 0x22, 0xb3, 0x65, 0xc1, + 0x5e, 0xb7, 0x90, 0x0a, 0x93, 0xb5, 0xd4, 0x70, 0xb2, 0x0e, 0x15, 0xd6, 0xa5, 0x97, 0xab, 0x6e, + 0x59, 0x9e, 0x81, 0x54, 0x0d, 0xc1, 0xa8, 0x3f, 0x2b, 0x14, 0x4f, 0x58, 0xf8, 0x6d, 0xb7, 0x53, + 0x16, 0x8b, 0x9f, 0x89, 0x81, 0x69, 0xea, 0xe3, 0x01, 0xd8, 0xce, 0xe1, 0xa1, 0xbb, 0x90, 0xb7, + 0x31, 0x1b, 0x8d, 0x28, 0xe5, 0xde, 0x53, 0x94, 0x92, 0xfb, 0x7b, 0x74, 0xb4, 0xb6, 0xa2, 0x08, + 0x12, 0xff, 0xf9, 0xde, 0xd7, 0x3f, 0xbe, 0x1a, 0x3a, 0x8a, 0x06, 0x13, 0x65, 0x9f, 0x5f, 0x44, + 0xdf, 0x7c, 0x19, 0xc0, 0x4e, 0xf7, 0x3e, 0x8c, 0x4e, 0x55, 0xf1, 0x5d, 0x74, 0xa1, 0x8e, 0x8e, + 0xd5, 0xa5, 0x2b, 0xa1, 0x9c, 0xe2, 0x50, 0xfe, 0x84, 0xe2, 0xe5, 0xa1, 0x78, 0x37, 0xec, 0xfb, + 0x21, 0x80, 0xde, 0x07, 0xb0, 0xa7, 0x30, 0x6d, 0xe8, 0x74, 0x95, 0xbd, 0xca, 0x16, 0x40, 0x74, + 0xb2, 0x01, 0x0b, 0x89, 0x71, 0x82, 0x63, 0x1c, 0x41, 0x27, 0xca, 0x63, 0x14, 0x03, 0xa4, 0x97, + 0x43, 0xf4, 0x01, 0x80, 0xbd, 0x45, 0xdf, 0x30, 0x34, 0x59, 0x2b, 0x37, 0x25, 0xdf, 0xec, 0xe8, + 0x54, 0x23, 0x26, 0x12, 0xe9, 0x38, 0x47, 0x3a, 0x8c, 0x8e, 0x97, 0x47, 0x7a, 0x83, 0x6b, 0xeb, + 0x1b, 0x82, 0x52, 0xf4, 0x02, 0x80, 0x6d, 0xcc, 0x13, 0x1a, 0xae, 0xb1, 0x95, 0x0b, 0x69, 0xa4, + 0xa6, 0x5e, 0x7d, 0x8c, 0xf1, 0xed, 0x13, 0xcf, 0xcb, 0x56, 0x77, 0x07, 0x3d, 0x00, 0xb0, 0xd3, + 0x7d, 0xe5, 0xa8, 0x5a, 0x6a, 0x45, 0xef, 0x29, 0x55, 0x4b, 0xad, 0xf8, 0xd9, 0x04, 0x4f, 0x72, + 0x50, 0x63, 0xe8, 0x64, 0x65, 0x50, 0x7c, 0xc2, 0x09, 0x00, 0x7b, 0x1d, 0xc0, 0x48, 0xa5, 0xd9, + 0x19, 0xcd, 0x56, 0xd9, 0xbc, 0xc6, 0x85, 0x21, 0xfa, 0xb7, 0xa6, 0x6c, 0x65, 0x20, 0x2d, 0xe8, + 0x0b, 0x00, 0x51, 0xe9, 0x7b, 0x08, 0x9a, 0xa9, 0xd3, 0x6b, 0x21, 0x96, 0x33, 0x0d, 0x5a, 0x49, + 0x14, 0x17, 0x38, 0x9d, 0xb3, 0xe8, 0xaf, 0x75, 0xe5, 0x38, 0x71, 0x93, 0x18, 0x66, 0x8a, 0xbf, + 0xd9, 0xea, 0xec, 0x6b, 0x91, 0x32, 0x4c, 0xf4, 0x13, 0x80, 0x83, 0x55, 0xde, 0x0c, 0xd0, 0xd9, + 0x1a, 0xc0, 0xaa, 0x3f, 0x84, 0x44, 0xcf, 0x35, 0x6b, 0x2e, 0x03, 0xbc, 0xcc, 0x03, 0x9c, 0x43, + 0xe7, 0xeb, 0x0b, 0x50, 0xdf, 0x31, 0xa8, 0x08, 0x50, 0xbc, 0xb2, 0x88, 0x4f, 0x14, 0x8b, 0xf3, + 0x5d, 0x00, 0xa1, 0xff, 0x78, 0x80, 0xc6, 0x6b, 0x14, 0x6d, 0xc1, 0x53, 0x45, 0x74, 0xa2, 0x4e, + 0x6d, 0x09, 0x7a, 0x86, 0x83, 0x56, 0xd0, 0x78, 0x7d, 0xa0, 0xc5, 0xcb, 0x04, 0xfa, 0x12, 0x40, + 0x54, 0xfa, 0x8a, 0x50, 0xb5, 0x9e, 0x2a, 0x3e, 0x62, 0x54, 0xad, 0xa7, 0xca, 0x4f, 0x15, 0x78, + 0x9e, 0x23, 0xff, 0x3b, 0x9a, 0xad, 0x0f, 0xb9, 0xe8, 0xba, 0xfc, 0xa7, 0xdf, 0x7a, 0x3f, 0x04, + 0xb0, 0x2b, 0xf0, 0x46, 0x80, 0x26, 0x6a, 0x41, 0x29, 0xac, 0x18, 0xa5, 0x5e, 0x75, 0x09, 0x79, + 0x96, 0x43, 0x9e, 0x41, 0x53, 0x8d, 0x40, 0x16, 0x97, 0x54, 0x56, 0x14, 0x61, 0xef, 0x26, 0x81, + 0xaa, 0x35, 0xb2, 0xe2, 0x2b, 0x6c, 0x74, 0xbc, 0x3e, 0x65, 0x09, 0xf2, 0x2f, 0x0d, 0x56, 0x04, + 0x33, 0xe6, 0x9f, 0xdb, 0x47, 0x00, 0x1e, 0x59, 0xb0, 0xa9, 0x91, 0xd5, 0xa8, 0x5e, 0x32, 0x92, + 0xa3, 0xe9, 0x6a, 0x20, 0x2a, 0x5c, 0x66, 0xa2, 0x33, 0x8d, 0x19, 0xc9, 0x08, 0x96, 0x78, 0x04, + 0xe7, 0xd1, 0xd9, 0xf2, 0x11, 0x04, 0x8e, 0xa0, 0x44, 0x9b, 0x08, 0xf4, 0x19, 0xef, 0x18, 0xb2, + 0x90, 0xbe, 0x01, 0x30, 0x5a, 0x21, 0xa4, 0x15, 0x87, 0xa2, 0x06, 0xe0, 0xf9, 0x83, 0x7f, 0xd5, + 0x7a, 0xaf, 0x3c, 0x1d, 0xe3, 0x24, 0x8f, 0xea, 0x02, 0x3a, 0xf7, 0x1b, 0xa2, 0x22, 0x0e, 0xbd, + 0x1f, 0x02, 0xf3, 0xcb, 0x0f, 0x1f, 0xc7, 0xc0, 0xa3, 0xc7, 0x31, 0xf0, 0xc3, 0xe3, 0x18, 0x78, + 0xe5, 0x49, 0xac, 0xe5, 0xd1, 0x93, 0x58, 0xcb, 0xb7, 0x4f, 0x62, 0x2d, 0xff, 0x3d, 0x1d, 0x18, + 0x42, 0xe5, 0x36, 0x13, 0x19, 0x6d, 0xcd, 0xf6, 0xf6, 0xbc, 0x3d, 0x39, 0x9d, 0xd8, 0x11, 0x3b, + 0xf3, 0x91, 0x74, 0xad, 0x83, 0x5f, 0xa7, 0xa7, 0x7f, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x57, 0x86, + 0x10, 0x94, 0xe8, 0x1b, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -6161,7 +6164,7 @@ func (m *QuerySwapExactAmountInRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Routes = append(m.Routes, SwapAmountInRoute{}) + m.Routes = append(m.Routes, types2.SwapAmountInRoute{}) if err := m.Routes[len(m.Routes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -6380,7 +6383,7 @@ func (m *QuerySwapExactAmountOutRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Routes = append(m.Routes, SwapAmountOutRoute{}) + m.Routes = append(m.Routes, types2.SwapAmountOutRoute{}) if err := m.Routes[len(m.Routes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } diff --git a/x/gamm/types/route.go b/x/gamm/types/route.go index daa643ff9f4..7b04e524ab4 100644 --- a/x/gamm/types/route.go +++ b/x/gamm/types/route.go @@ -6,7 +6,7 @@ import ( swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) -type SwapAmountInRoutes []SwapAmountInRoute +type SwapAmountInRoutes []swaproutertypes.SwapAmountInRoute func (routes SwapAmountInRoutes) Validate() error { if len(routes) == 0 { @@ -47,7 +47,7 @@ func (routes SwapAmountInRoutes) Length() int { return len(routes) } -type SwapAmountOutRoutes []SwapAmountOutRoute +type SwapAmountOutRoutes []swaproutertypes.SwapAmountOutRoute func (routes SwapAmountOutRoutes) Validate() error { if len(routes) == 0 { @@ -93,31 +93,3 @@ type MultihopRoute interface { PoolIds() []uint64 IntermediateDenoms() []string } - -// ConvertAmountInRoutes converts gamm swap exact amount in routes to swaprouter routes. -// This is a temporary function to be used until we make the route protos be shared between -// x/gamm and x/swaprouter instead of duplicating them in each module. -func ConvertAmountInRoutes(gammRoutes []SwapAmountInRoute) []swaproutertypes.SwapAmountInRoute { - swaprouterRoutes := make([]swaproutertypes.SwapAmountInRoute, 0, len(gammRoutes)) - for _, route := range gammRoutes { - swaprouterRoutes = append(swaprouterRoutes, swaproutertypes.SwapAmountInRoute{ - PoolId: route.PoolId, - TokenOutDenom: route.TokenOutDenom, - }) - } - return swaprouterRoutes -} - -// ConvertAmountOutRoutes converts gamm swap exact amount out routes to swaprouter routes. -// This is a temporary function to be used until we make the route protos be shared between -// x/gamm and x/swaprouter instead of duplicating them in each module. -func ConvertAmountOutRoutes(gammRoutes []SwapAmountOutRoute) []swaproutertypes.SwapAmountOutRoute { - swaprouterRoutes := make([]swaproutertypes.SwapAmountOutRoute, 0, len(gammRoutes)) - for _, route := range gammRoutes { - swaprouterRoutes = append(swaprouterRoutes, swaproutertypes.SwapAmountOutRoute{ - PoolId: route.PoolId, - TokenInDenom: route.TokenInDenom, - }) - } - return swaprouterRoutes -} diff --git a/x/gamm/types/route_test.go b/x/gamm/types/route_test.go new file mode 100644 index 00000000000..37faf4ab2f0 --- /dev/null +++ b/x/gamm/types/route_test.go @@ -0,0 +1,44 @@ +package types_test + +import ( + "encoding/json" + "testing" + + proto "github.com/gogo/protobuf/proto" + "github.com/stretchr/testify/require" + + gammtypes "github.com/osmosis-labs/osmosis/v13/x/gamm/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" +) + +// TestSwapRoutesSerialization tests that while swap routes +// are proto-generated from different modules, they are identical in terms +// of serialization and deserialization. +func TestSwapRoutes_MarshalUnmarshal(t *testing.T) { + const ( + testPoolId = 2 + testTokenOutDenom = "uosmo" + ) + swapRouterExactAmountInRoute := swaproutertypes.SwapAmountInRoute{ + PoolId: testPoolId, + TokenOutDenom: testTokenOutDenom, + } + gammExactAmountInRoute := gammtypes.SwapAmountInRoute{ + PoolId: testPoolId, + TokenOutDenom: testTokenOutDenom, + } + + swapRouterBz, err := proto.Marshal(&swapRouterExactAmountInRoute) + require.NoError(t, err) + gammBz, err := proto.Marshal(&gammExactAmountInRoute) + require.NoError(t, err) + + require.Equal(t, swapRouterBz, gammBz) + + jsonSwaprouterBz, err := json.Marshal(&swapRouterExactAmountInRoute) + require.NoError(t, err) + + jsonGammBz, err := json.Marshal(&gammExactAmountInRoute) + require.NoError(t, err) + require.Equal(t, jsonSwaprouterBz, jsonGammBz) +} diff --git a/x/gamm/types/tx.pb.go b/x/gamm/types/tx.pb.go index a7580571473..8100a17f2cd 100644 --- a/x/gamm/types/tx.pb.go +++ b/x/gamm/types/tx.pb.go @@ -11,6 +11,7 @@ import ( _ "github.com/gogo/protobuf/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" + types1 "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" @@ -299,7 +300,7 @@ func (m *SwapAmountInRoute) GetTokenOutDenom() string { type MsgSwapExactAmountIn struct { Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` - Routes []SwapAmountInRoute `protobuf:"bytes,2,rep,name=routes,proto3" json:"routes"` + Routes []types1.SwapAmountInRoute `protobuf:"bytes,2,rep,name=routes,proto3" json:"routes"` TokenIn types.Coin `protobuf:"bytes,3,opt,name=token_in,json=tokenIn,proto3" json:"token_in" yaml:"token_in"` TokenOutMinAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=token_out_min_amount,json=tokenOutMinAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"token_out_min_amount" yaml:"token_out_min_amount"` } @@ -344,7 +345,7 @@ func (m *MsgSwapExactAmountIn) GetSender() string { return "" } -func (m *MsgSwapExactAmountIn) GetRoutes() []SwapAmountInRoute { +func (m *MsgSwapExactAmountIn) GetRoutes() []types1.SwapAmountInRoute { if m != nil { return m.Routes } @@ -395,62 +396,9 @@ func (m *MsgSwapExactAmountInResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgSwapExactAmountInResponse proto.InternalMessageInfo -// ===================== MsgSwapExactAmountOut -type SwapAmountOutRoute struct { - PoolId uint64 `protobuf:"varint,1,opt,name=pool_id,json=poolId,proto3" json:"pool_id,omitempty" yaml:"pool_id"` - TokenInDenom string `protobuf:"bytes,2,opt,name=token_in_denom,json=tokenInDenom,proto3" json:"token_in_denom,omitempty" yaml:"token_out_denom"` -} - -func (m *SwapAmountOutRoute) Reset() { *m = SwapAmountOutRoute{} } -func (m *SwapAmountOutRoute) String() string { return proto.CompactTextString(m) } -func (*SwapAmountOutRoute) ProtoMessage() {} -func (*SwapAmountOutRoute) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{7} -} -func (m *SwapAmountOutRoute) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *SwapAmountOutRoute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_SwapAmountOutRoute.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 *SwapAmountOutRoute) XXX_Merge(src proto.Message) { - xxx_messageInfo_SwapAmountOutRoute.Merge(m, src) -} -func (m *SwapAmountOutRoute) XXX_Size() int { - return m.Size() -} -func (m *SwapAmountOutRoute) XXX_DiscardUnknown() { - xxx_messageInfo_SwapAmountOutRoute.DiscardUnknown(m) -} - -var xxx_messageInfo_SwapAmountOutRoute proto.InternalMessageInfo - -func (m *SwapAmountOutRoute) GetPoolId() uint64 { - if m != nil { - return m.PoolId - } - return 0 -} - -func (m *SwapAmountOutRoute) GetTokenInDenom() string { - if m != nil { - return m.TokenInDenom - } - return "" -} - type MsgSwapExactAmountOut struct { Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"` - Routes []SwapAmountOutRoute `protobuf:"bytes,2,rep,name=routes,proto3" json:"routes"` + Routes []types1.SwapAmountOutRoute `protobuf:"bytes,2,rep,name=routes,proto3" json:"routes"` TokenInMaxAmount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,3,opt,name=token_in_max_amount,json=tokenInMaxAmount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"token_in_max_amount" yaml:"token_in_max_amount"` TokenOut types.Coin `protobuf:"bytes,4,opt,name=token_out,json=tokenOut,proto3" json:"token_out" yaml:"token_out"` } @@ -459,7 +407,7 @@ func (m *MsgSwapExactAmountOut) Reset() { *m = MsgSwapExactAmountOut{} } func (m *MsgSwapExactAmountOut) String() string { return proto.CompactTextString(m) } func (*MsgSwapExactAmountOut) ProtoMessage() {} func (*MsgSwapExactAmountOut) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{8} + return fileDescriptor_cfc8fd3ac7df3247, []int{7} } func (m *MsgSwapExactAmountOut) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -495,7 +443,7 @@ func (m *MsgSwapExactAmountOut) GetSender() string { return "" } -func (m *MsgSwapExactAmountOut) GetRoutes() []SwapAmountOutRoute { +func (m *MsgSwapExactAmountOut) GetRoutes() []types1.SwapAmountOutRoute { if m != nil { return m.Routes } @@ -517,7 +465,7 @@ func (m *MsgSwapExactAmountOutResponse) Reset() { *m = MsgSwapExactAmoun func (m *MsgSwapExactAmountOutResponse) String() string { return proto.CompactTextString(m) } func (*MsgSwapExactAmountOutResponse) ProtoMessage() {} func (*MsgSwapExactAmountOutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{9} + return fileDescriptor_cfc8fd3ac7df3247, []int{8} } func (m *MsgSwapExactAmountOutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -559,7 +507,7 @@ func (m *MsgJoinSwapExternAmountIn) Reset() { *m = MsgJoinSwapExternAmou func (m *MsgJoinSwapExternAmountIn) String() string { return proto.CompactTextString(m) } func (*MsgJoinSwapExternAmountIn) ProtoMessage() {} func (*MsgJoinSwapExternAmountIn) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{10} + return fileDescriptor_cfc8fd3ac7df3247, []int{9} } func (m *MsgJoinSwapExternAmountIn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -617,7 +565,7 @@ func (m *MsgJoinSwapExternAmountInResponse) Reset() { *m = MsgJoinSwapEx func (m *MsgJoinSwapExternAmountInResponse) String() string { return proto.CompactTextString(m) } func (*MsgJoinSwapExternAmountInResponse) ProtoMessage() {} func (*MsgJoinSwapExternAmountInResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{11} + return fileDescriptor_cfc8fd3ac7df3247, []int{10} } func (m *MsgJoinSwapExternAmountInResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -659,7 +607,7 @@ func (m *MsgJoinSwapShareAmountOut) Reset() { *m = MsgJoinSwapShareAmoun func (m *MsgJoinSwapShareAmountOut) String() string { return proto.CompactTextString(m) } func (*MsgJoinSwapShareAmountOut) ProtoMessage() {} func (*MsgJoinSwapShareAmountOut) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{12} + return fileDescriptor_cfc8fd3ac7df3247, []int{11} } func (m *MsgJoinSwapShareAmountOut) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -717,7 +665,7 @@ func (m *MsgJoinSwapShareAmountOutResponse) Reset() { *m = MsgJoinSwapSh func (m *MsgJoinSwapShareAmountOutResponse) String() string { return proto.CompactTextString(m) } func (*MsgJoinSwapShareAmountOutResponse) ProtoMessage() {} func (*MsgJoinSwapShareAmountOutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{13} + return fileDescriptor_cfc8fd3ac7df3247, []int{12} } func (m *MsgJoinSwapShareAmountOutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -759,7 +707,7 @@ func (m *MsgExitSwapShareAmountIn) Reset() { *m = MsgExitSwapShareAmount func (m *MsgExitSwapShareAmountIn) String() string { return proto.CompactTextString(m) } func (*MsgExitSwapShareAmountIn) ProtoMessage() {} func (*MsgExitSwapShareAmountIn) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{14} + return fileDescriptor_cfc8fd3ac7df3247, []int{13} } func (m *MsgExitSwapShareAmountIn) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -817,7 +765,7 @@ func (m *MsgExitSwapShareAmountInResponse) Reset() { *m = MsgExitSwapSha func (m *MsgExitSwapShareAmountInResponse) String() string { return proto.CompactTextString(m) } func (*MsgExitSwapShareAmountInResponse) ProtoMessage() {} func (*MsgExitSwapShareAmountInResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{15} + return fileDescriptor_cfc8fd3ac7df3247, []int{14} } func (m *MsgExitSwapShareAmountInResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -858,7 +806,7 @@ func (m *MsgExitSwapExternAmountOut) Reset() { *m = MsgExitSwapExternAmo func (m *MsgExitSwapExternAmountOut) String() string { return proto.CompactTextString(m) } func (*MsgExitSwapExternAmountOut) ProtoMessage() {} func (*MsgExitSwapExternAmountOut) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{16} + return fileDescriptor_cfc8fd3ac7df3247, []int{15} } func (m *MsgExitSwapExternAmountOut) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -916,7 +864,7 @@ func (m *MsgExitSwapExternAmountOutResponse) Reset() { *m = MsgExitSwapE func (m *MsgExitSwapExternAmountOutResponse) String() string { return proto.CompactTextString(m) } func (*MsgExitSwapExternAmountOutResponse) ProtoMessage() {} func (*MsgExitSwapExternAmountOutResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_cfc8fd3ac7df3247, []int{17} + return fileDescriptor_cfc8fd3ac7df3247, []int{16} } func (m *MsgExitSwapExternAmountOutResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -953,7 +901,6 @@ func init() { proto.RegisterType((*SwapAmountInRoute)(nil), "osmosis.gamm.v1beta1.SwapAmountInRoute") proto.RegisterType((*MsgSwapExactAmountIn)(nil), "osmosis.gamm.v1beta1.MsgSwapExactAmountIn") proto.RegisterType((*MsgSwapExactAmountInResponse)(nil), "osmosis.gamm.v1beta1.MsgSwapExactAmountInResponse") - proto.RegisterType((*SwapAmountOutRoute)(nil), "osmosis.gamm.v1beta1.SwapAmountOutRoute") proto.RegisterType((*MsgSwapExactAmountOut)(nil), "osmosis.gamm.v1beta1.MsgSwapExactAmountOut") proto.RegisterType((*MsgSwapExactAmountOutResponse)(nil), "osmosis.gamm.v1beta1.MsgSwapExactAmountOutResponse") proto.RegisterType((*MsgJoinSwapExternAmountIn)(nil), "osmosis.gamm.v1beta1.MsgJoinSwapExternAmountIn") @@ -969,78 +916,78 @@ func init() { func init() { proto.RegisterFile("osmosis/gamm/v1beta1/tx.proto", fileDescriptor_cfc8fd3ac7df3247) } var fileDescriptor_cfc8fd3ac7df3247 = []byte{ - // 1121 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4b, 0x6f, 0x1b, 0x45, - 0x1c, 0xcf, 0xd8, 0x6e, 0x1e, 0x93, 0xe6, 0xb5, 0x4d, 0x1a, 0x67, 0xdb, 0xda, 0xe9, 0x80, 0x20, - 0xa5, 0xea, 0x6e, 0x93, 0x48, 0x80, 0xb8, 0x00, 0x86, 0x20, 0x5c, 0x61, 0xa5, 0xda, 0x5e, 0x2a, - 0x2e, 0xd6, 0x3a, 0x5e, 0xb9, 0xab, 0x66, 0x67, 0x2c, 0xcf, 0x6c, 0x70, 0x85, 0x04, 0x12, 0x8f, - 0x3b, 0x08, 0xf1, 0xf8, 0x04, 0x88, 0xaf, 0xc0, 0x01, 0x0e, 0x70, 0xe9, 0xb1, 0x37, 0x28, 0x07, - 0x0b, 0x25, 0xdf, 0xc0, 0x9f, 0xa0, 0xda, 0x9d, 0xd9, 0xa7, 0x77, 0x63, 0x6f, 0x62, 0x37, 0xa7, - 0xc4, 0x3b, 0xff, 0xf7, 0xff, 0x37, 0xbf, 0xff, 0x7f, 0x17, 0xde, 0x20, 0xd4, 0x22, 0xd4, 0xa4, - 0x6a, 0x4b, 0xb7, 0x2c, 0xf5, 0x68, 0xbb, 0x61, 0x30, 0x7d, 0x5b, 0x65, 0x5d, 0xa5, 0xdd, 0x21, - 0x8c, 0x48, 0xab, 0xe2, 0x58, 0x71, 0x8e, 0x15, 0x71, 0x2c, 0xaf, 0xb6, 0x48, 0x8b, 0xb8, 0x02, - 0xaa, 0xf3, 0x1f, 0x97, 0x95, 0x4b, 0x07, 0xae, 0xb0, 0xda, 0xd0, 0xa9, 0xe1, 0x5b, 0x3a, 0x20, - 0x26, 0xe6, 0xe7, 0xe8, 0x8f, 0x1c, 0x9c, 0xaf, 0xd1, 0xd6, 0x3d, 0x62, 0xe2, 0xfb, 0x84, 0x1c, - 0x4a, 0xb7, 0xe0, 0x34, 0x35, 0x70, 0xd3, 0xe8, 0x14, 0xc1, 0x26, 0xd8, 0x9a, 0xab, 0xac, 0xf4, - 0x7b, 0xe5, 0x85, 0x27, 0xba, 0x75, 0xf8, 0x0e, 0xe2, 0xcf, 0x91, 0x26, 0x04, 0xa4, 0xdb, 0x70, - 0xa6, 0x4d, 0xc8, 0x61, 0xdd, 0x6c, 0x16, 0x73, 0x9b, 0x60, 0xab, 0x50, 0x91, 0xfa, 0xbd, 0xf2, - 0x22, 0x97, 0x15, 0x07, 0x48, 0x9b, 0x76, 0xfe, 0xab, 0x36, 0xa5, 0x0e, 0x5c, 0xa6, 0x8f, 0xf4, - 0x8e, 0x51, 0x27, 0x36, 0xab, 0xeb, 0x16, 0xb1, 0x31, 0x2b, 0xe6, 0x5d, 0x0f, 0x1f, 0x3f, 0xed, - 0x95, 0xa7, 0xfe, 0xeb, 0x95, 0x5f, 0x6b, 0x99, 0xec, 0x91, 0xdd, 0x50, 0x0e, 0x88, 0xa5, 0x8a, - 0xa0, 0xf9, 0x9f, 0x3b, 0xb4, 0xf9, 0x58, 0x65, 0x4f, 0xda, 0x06, 0x55, 0xaa, 0x98, 0xf5, 0x7b, - 0xe5, 0xab, 0x21, 0x1f, 0xdc, 0x94, 0x63, 0x15, 0x69, 0x8b, 0xae, 0x87, 0x7d, 0x9b, 0xbd, 0xef, - 0x3e, 0x94, 0x1a, 0x70, 0x81, 0x91, 0xc7, 0x06, 0xae, 0x9b, 0xb8, 0x6e, 0xe9, 0x5d, 0x5a, 0x2c, - 0x6c, 0xe6, 0xb7, 0xe6, 0x77, 0x36, 0x14, 0x6e, 0x57, 0x71, 0x6a, 0xe2, 0x95, 0x4f, 0xf9, 0x80, - 0x98, 0xb8, 0xf2, 0x8a, 0x13, 0x4b, 0xbf, 0x57, 0xbe, 0xc6, 0x3d, 0x84, 0xb5, 0x85, 0x27, 0x8a, - 0xb4, 0x79, 0xf7, 0x71, 0x15, 0xd7, 0xf4, 0x2e, 0x45, 0xcf, 0x01, 0xbc, 0x12, 0xaa, 0x9f, 0x66, - 0xd0, 0x36, 0xc1, 0xd4, 0x90, 0x68, 0x42, 0xbe, 0xbc, 0xa2, 0xd5, 0xcc, 0xf9, 0xae, 0x8b, 0xfa, - 0xc7, 0xec, 0x0d, 0x26, 0x5c, 0x83, 0xb3, 0x5e, 0xc8, 0xc5, 0xdc, 0xb0, 0x5c, 0xd7, 0x45, 0xae, - 0x4b, 0xd1, 0x5c, 0x91, 0x36, 0x23, 0xf2, 0x43, 0x7f, 0x72, 0x6c, 0xec, 0x75, 0x4d, 0x36, 0x51, - 0x6c, 0xb4, 0xe1, 0x12, 0xcf, 0xcd, 0xc4, 0x63, 0x82, 0x46, 0xcc, 0x1c, 0xd2, 0x16, 0xdc, 0x27, - 0x55, 0x2c, 0x0a, 0x65, 0xc0, 0x45, 0x9e, 0xaf, 0x53, 0x4d, 0xcb, 0xc4, 0x23, 0x40, 0xe3, 0x55, - 0x51, 0xae, 0xeb, 0xe1, 0x72, 0x09, 0xf5, 0x00, 0x1b, 0x97, 0xdd, 0xe7, 0xfb, 0x36, 0xab, 0x99, - 0x98, 0xa2, 0x96, 0x8b, 0x0d, 0xaf, 0x7e, 0x3e, 0x36, 0xee, 0xc3, 0x39, 0x5f, 0xbd, 0x08, 0x86, - 0x39, 0x2e, 0x0a, 0xc7, 0xcb, 0x31, 0xc7, 0x48, 0x9b, 0xf5, 0x9c, 0xa1, 0x6f, 0x00, 0x5c, 0x79, - 0xf0, 0x99, 0xde, 0xe6, 0xe9, 0x55, 0xb1, 0x46, 0x6c, 0x66, 0x84, 0x9b, 0x00, 0x86, 0x36, 0xa1, - 0x02, 0x97, 0x82, 0x9c, 0x9a, 0x06, 0x26, 0x96, 0xdb, 0xb9, 0xb9, 0x8a, 0x1c, 0x94, 0x35, 0x26, - 0x80, 0xb4, 0x05, 0x2f, 0x82, 0x0f, 0xdd, 0xdf, 0xff, 0xe4, 0xe0, 0x6a, 0x8d, 0xb6, 0x9c, 0x48, - 0xf6, 0xba, 0xfa, 0x01, 0xf3, 0xc2, 0xc9, 0x82, 0x9c, 0x3d, 0x38, 0xdd, 0x71, 0xa2, 0xa7, 0x02, - 0xc1, 0xaf, 0x2b, 0x49, 0x6c, 0xa7, 0x0c, 0x64, 0x5b, 0x29, 0x38, 0x75, 0xd2, 0x84, 0x72, 0xe4, - 0x2a, 0x38, 0x60, 0x3a, 0xdf, 0x55, 0x90, 0xbe, 0x80, 0xab, 0x49, 0x1d, 0x2f, 0x16, 0xdc, 0x74, - 0x6a, 0x99, 0x71, 0x7a, 0x2d, 0x1d, 0x45, 0x48, 0x5b, 0x09, 0x81, 0x88, 0xe7, 0x88, 0x7e, 0x00, - 0xf0, 0x7a, 0x52, 0x65, 0xc3, 0x7c, 0x13, 0x18, 0x1b, 0x0f, 0xdf, 0xc4, 0xed, 0x21, 0x6d, 0xd1, - 0x0b, 0x4c, 0x44, 0xf5, 0x35, 0x80, 0x52, 0xd0, 0x88, 0x7d, 0x9b, 0x9d, 0x01, 0x77, 0xef, 0x79, - 0x57, 0xd1, 0xc4, 0x23, 0xc3, 0xee, 0xb2, 0x68, 0x0b, 0x47, 0xdd, 0xf3, 0x1c, 0x5c, 0x1b, 0xac, - 0xcd, 0xbe, 0xcd, 0xb2, 0xc0, 0xee, 0xa3, 0x18, 0xec, 0xb6, 0x86, 0xc1, 0xce, 0xcb, 0x36, 0x86, - 0xbb, 0xcf, 0xe1, 0x95, 0x84, 0xa9, 0x21, 0xf8, 0xec, 0x93, 0xcc, 0xad, 0x90, 0x53, 0x07, 0x11, - 0xd2, 0x96, 0x83, 0x39, 0x24, 0x68, 0x2d, 0x42, 0x2c, 0x85, 0x61, 0xa8, 0x1f, 0x85, 0x58, 0xbe, - 0x07, 0xf0, 0x46, 0x62, 0x6d, 0x7d, 0xe0, 0xb5, 0x3d, 0xde, 0x08, 0x2e, 0x05, 0x38, 0x1f, 0x79, - 0xc7, 0xcc, 0x79, 0x2c, 0xe3, 0x91, 0x37, 0xfa, 0x2b, 0x07, 0x37, 0xc4, 0xc8, 0xe5, 0x71, 0x31, - 0xa3, 0x83, 0xcf, 0x42, 0x35, 0x99, 0x86, 0xd4, 0xf8, 0x09, 0x25, 0x98, 0xe7, 0xe3, 0x23, 0x94, - 0x24, 0x9b, 0x48, 0x5b, 0xf1, 0xf6, 0x84, 0x80, 0x50, 0x7e, 0x01, 0xf0, 0x66, 0x6a, 0x11, 0x2f, - 0x74, 0x8b, 0x41, 0xbf, 0xe6, 0x23, 0xfd, 0x7d, 0xe0, 0x9c, 0x9e, 0xe9, 0x4e, 0x67, 0xea, 0xef, - 0xbb, 0x03, 0x3c, 0xc4, 0xef, 0xec, 0x46, 0xbf, 0x57, 0x5e, 0x8b, 0x01, 0x33, 0x89, 0x86, 0x12, - 0x6b, 0x55, 0x98, 0xf4, 0xc6, 0x97, 0x42, 0x37, 0x97, 0x5e, 0x06, 0xdd, 0xa0, 0x1f, 0xa3, 0x18, - 0x8a, 0x36, 0xea, 0x02, 0x09, 0xe2, 0xb7, 0x3c, 0x2c, 0x8a, 0xbd, 0x2b, 0x16, 0xd7, 0x04, 0xf9, - 0x21, 0x61, 0x7f, 0xca, 0x67, 0xdc, 0x9f, 0x92, 0x16, 0xe1, 0xc2, 0x64, 0x17, 0xe1, 0xb4, 0xbd, - 0xe6, 0xd2, 0x4b, 0xda, 0x6b, 0x7e, 0x06, 0x70, 0x33, 0xad, 0x55, 0x17, 0xbb, 0xdb, 0xfc, 0x9d, - 0x83, 0x72, 0x28, 0xb2, 0x30, 0x41, 0x4e, 0x92, 0x86, 0x22, 0x23, 0x3c, 0x3f, 0x86, 0x11, 0xee, - 0x50, 0x84, 0x8f, 0x82, 0x10, 0x45, 0x14, 0xce, 0x47, 0x11, 0x09, 0x26, 0x91, 0xb6, 0x2c, 0xc0, - 0x15, 0x50, 0xc4, 0x4f, 0x00, 0xa2, 0xf4, 0x2a, 0x86, 0x39, 0x22, 0x0e, 0x7c, 0x30, 0x51, 0xe0, - 0xef, 0xfc, 0x3e, 0x03, 0xf3, 0x35, 0xda, 0x92, 0x1e, 0xc2, 0x59, 0xff, 0xdb, 0xc7, 0xcd, 0xe4, - 0x9d, 0x2f, 0xf4, 0x7a, 0x2f, 0xdf, 0x1a, 0x2a, 0xe2, 0xe7, 0xf4, 0x10, 0xce, 0xfa, 0x6f, 0xce, - 0xe9, 0x96, 0x3d, 0x91, 0x53, 0x2c, 0x0f, 0xbc, 0x3f, 0x52, 0xfe, 0xb2, 0x17, 0x7d, 0xc5, 0x7a, - 0x23, 0x55, 0x7f, 0x40, 0x56, 0xde, 0x19, 0x5d, 0xd6, 0x77, 0x7a, 0xc4, 0x57, 0xfd, 0xd8, 0x86, - 0x7d, 0x7b, 0x54, 0x4b, 0xfb, 0x36, 0x93, 0x77, 0x33, 0x08, 0xfb, 0x7e, 0xbf, 0x02, 0xf0, 0x6a, - 0xca, 0xaa, 0xa7, 0x9e, 0xda, 0x8c, 0x41, 0x05, 0xf9, 0xad, 0x8c, 0x0a, 0x89, 0x41, 0xc4, 0xf6, - 0x91, 0xe1, 0x41, 0x44, 0x15, 0x46, 0x08, 0x22, 0x65, 0x90, 0x7e, 0x0b, 0xe0, 0x7a, 0x1a, 0x1d, - 0xdd, 0x3d, 0x15, 0x3d, 0x09, 0x1a, 0xf2, 0xdb, 0x59, 0x35, 0xfc, 0x38, 0xbe, 0x84, 0x6b, 0xc9, - 0xa3, 0x55, 0x19, 0x6a, 0x32, 0x22, 0x2f, 0xbf, 0x99, 0x4d, 0xde, 0x0b, 0xa0, 0x72, 0xef, 0xe9, - 0x71, 0x09, 0x3c, 0x3b, 0x2e, 0x81, 0xff, 0x8f, 0x4b, 0xe0, 0xbb, 0x93, 0xd2, 0xd4, 0xb3, 0x93, - 0xd2, 0xd4, 0xbf, 0x27, 0xa5, 0xa9, 0x4f, 0xef, 0x86, 0x68, 0x42, 0xd8, 0xbe, 0x73, 0xa8, 0x37, - 0xa8, 0xf7, 0x43, 0x3d, 0xda, 0xde, 0x55, 0xbb, 0xfc, 0xb3, 0xaa, 0x4b, 0x1a, 0x8d, 0x69, 0xf7, - 0x33, 0xe8, 0xee, 0x8b, 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0x91, 0x23, 0xe6, 0x73, 0x15, 0x00, - 0x00, + // 1129 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4d, 0x6f, 0x1b, 0x45, + 0x18, 0xce, 0xd8, 0x6e, 0x9a, 0x4c, 0x9a, 0xaf, 0x6d, 0xd2, 0x38, 0xdb, 0xd6, 0x4e, 0x07, 0x84, + 0x52, 0xa2, 0xec, 0x36, 0x89, 0x04, 0x88, 0x0b, 0xc2, 0x50, 0x09, 0x97, 0x5a, 0xae, 0xb6, 0x97, + 0x8a, 0x8b, 0xb5, 0x8e, 0x57, 0xee, 0xaa, 0xd9, 0x19, 0xcb, 0x33, 0x9b, 0xba, 0x42, 0x02, 0x09, + 0xc1, 0x1d, 0x84, 0xf8, 0xf8, 0x05, 0x88, 0xbf, 0xc0, 0x01, 0x0e, 0x70, 0xe9, 0xb1, 0x47, 0x40, + 0xc2, 0xa0, 0xe4, 0x1f, 0xf8, 0x17, 0xa0, 0xdd, 0x99, 0xfd, 0xf4, 0x6e, 0xec, 0x6d, 0xec, 0xe6, + 0x94, 0x78, 0xf6, 0x9d, 0xf7, 0xf3, 0x79, 0x9f, 0xf7, 0xdd, 0x85, 0x37, 0x09, 0xb5, 0x08, 0x35, + 0xa9, 0xda, 0xd6, 0x2d, 0x4b, 0x3d, 0xde, 0x6b, 0x1a, 0x4c, 0xdf, 0x53, 0x59, 0x4f, 0xe9, 0x74, + 0x09, 0x23, 0xd2, 0x9a, 0x78, 0xac, 0x38, 0x8f, 0x15, 0xf1, 0x58, 0x5e, 0x6b, 0x93, 0x36, 0x71, + 0x05, 0x54, 0xe7, 0x3f, 0x2e, 0x2b, 0x97, 0x0e, 0x5d, 0x61, 0xb5, 0xa9, 0x53, 0xc3, 0xd7, 0x74, + 0x48, 0x4c, 0x2c, 0x9e, 0xef, 0x78, 0xa6, 0xe8, 0x53, 0xbd, 0xd3, 0x25, 0x36, 0x33, 0xba, 0xbe, + 0x98, 0x73, 0xd4, 0x70, 0xcf, 0xb8, 0x30, 0xfa, 0x35, 0x07, 0x17, 0x6a, 0xb4, 0x7d, 0x8f, 0x98, + 0xf8, 0x01, 0x21, 0x47, 0xd2, 0x6d, 0x38, 0x4b, 0x0d, 0xdc, 0x32, 0xba, 0x45, 0xb0, 0x05, 0xb6, + 0xe7, 0x2b, 0xab, 0x83, 0x7e, 0x79, 0xf1, 0x99, 0x6e, 0x1d, 0xbd, 0x8b, 0xf8, 0x39, 0xd2, 0x84, + 0x80, 0xb4, 0x03, 0x2f, 0x77, 0x08, 0x39, 0x6a, 0x98, 0xad, 0x62, 0x6e, 0x0b, 0x6c, 0x17, 0x2a, + 0xd2, 0xa0, 0x5f, 0x5e, 0xe2, 0xb2, 0xe2, 0x01, 0xd2, 0x66, 0x9d, 0xff, 0xaa, 0x2d, 0xa9, 0x0b, + 0x57, 0xe8, 0x63, 0xbd, 0x6b, 0x34, 0x88, 0xcd, 0x1a, 0xba, 0x45, 0x6c, 0xcc, 0x8a, 0x79, 0xd7, + 0xc2, 0x47, 0xcf, 0xfb, 0xe5, 0x99, 0xbf, 0xfb, 0xe5, 0x37, 0xda, 0x26, 0x7b, 0x6c, 0x37, 0x95, + 0x43, 0x62, 0xa9, 0x22, 0x42, 0xfe, 0x67, 0x97, 0xb6, 0x9e, 0xa8, 0xec, 0x59, 0xc7, 0xa0, 0x4a, + 0x15, 0xb3, 0x41, 0xbf, 0x7c, 0x2d, 0x64, 0x83, 0xab, 0x72, 0xb4, 0x22, 0x6d, 0xc9, 0xb5, 0x50, + 0xb7, 0xd9, 0xfb, 0xee, 0xa1, 0xd4, 0x84, 0x8b, 0x8c, 0x3c, 0x31, 0x70, 0xc3, 0xc4, 0x0d, 0x4b, + 0xef, 0xd1, 0x62, 0x61, 0x2b, 0xbf, 0xbd, 0xb0, 0xbf, 0xa9, 0x70, 0xbd, 0x8a, 0x93, 0x40, 0x2f, + 0xd7, 0xca, 0x07, 0xc4, 0xc4, 0x95, 0xd7, 0x1c, 0x5f, 0x06, 0xfd, 0xf2, 0x75, 0x6e, 0x21, 0x7c, + 0x5b, 0x58, 0xa2, 0x48, 0x5b, 0x70, 0x8f, 0xab, 0xb8, 0xa6, 0xf7, 0x28, 0xfa, 0x0b, 0xc0, 0xab, + 0xa1, 0xfc, 0x69, 0x06, 0xed, 0x10, 0x4c, 0x0d, 0x89, 0x26, 0xc4, 0xcb, 0x33, 0x5a, 0xcd, 0x1c, + 0xef, 0x86, 0xc8, 0x7f, 0x4c, 0xdf, 0x70, 0xc0, 0x35, 0x38, 0xe7, 0xb9, 0x5c, 0xcc, 0x8d, 0x8a, + 0x75, 0x43, 0xc4, 0xba, 0x1c, 0x8d, 0x15, 0x69, 0x97, 0x45, 0x7c, 0xe8, 0x37, 0x8e, 0x8d, 0xbb, + 0x3d, 0x93, 0x4d, 0x15, 0x1b, 0x1d, 0xb8, 0xcc, 0x63, 0x33, 0xf1, 0x84, 0xa0, 0x11, 0x53, 0x87, + 0xb4, 0x45, 0xf7, 0xa4, 0x8a, 0x45, 0xa2, 0x0c, 0xb8, 0xc4, 0xe3, 0x75, 0xb2, 0x69, 0x99, 0x78, + 0x0c, 0x68, 0xbc, 0x2e, 0xd2, 0x75, 0x23, 0x9c, 0x2e, 0x71, 0x3d, 0xc0, 0xc6, 0x15, 0xf7, 0xbc, + 0x6e, 0xb3, 0x9a, 0x89, 0x29, 0x6a, 0xbb, 0xd8, 0xf0, 0xf2, 0xe7, 0x63, 0xe3, 0x01, 0x9c, 0xf7, + 0xaf, 0x17, 0xc1, 0x28, 0xc3, 0x45, 0x61, 0x78, 0x25, 0x66, 0x18, 0x69, 0x73, 0x9e, 0x31, 0xf4, + 0x25, 0x80, 0xab, 0x0f, 0x9f, 0xea, 0x1d, 0x1e, 0x5e, 0x15, 0x6b, 0x4e, 0x87, 0x87, 0x8b, 0x00, + 0x46, 0x16, 0xa1, 0x02, 0x97, 0x83, 0x98, 0x5a, 0x06, 0x26, 0x96, 0x5b, 0xb9, 0xf9, 0x8a, 0x1c, + 0xa4, 0x35, 0x26, 0x80, 0xb4, 0x45, 0xcf, 0x83, 0x0f, 0xdd, 0xdf, 0xff, 0xe4, 0xe0, 0x5a, 0x8d, + 0xb6, 0x1d, 0x4f, 0xee, 0xf6, 0xf4, 0x43, 0xe6, 0xb9, 0x93, 0x05, 0x39, 0x1f, 0xc3, 0x59, 0x97, + 0x9f, 0xa8, 0x40, 0xf0, 0xae, 0xe2, 0x51, 0x63, 0x40, 0x67, 0x7e, 0x82, 0x86, 0x62, 0xae, 0x14, + 0x9c, 0x6c, 0x69, 0x42, 0x45, 0xa4, 0x21, 0x1c, 0x48, 0x9d, 0xaf, 0x21, 0xa4, 0xcf, 0xe0, 0x5a, + 0x52, 0xdd, 0x8b, 0x05, 0x37, 0xa8, 0x5a, 0x66, 0xb4, 0x5e, 0x4f, 0xc7, 0x12, 0xd2, 0x56, 0x43, + 0x50, 0xe2, 0x31, 0xa2, 0x6f, 0x01, 0xbc, 0x91, 0x94, 0xdf, 0x30, 0xeb, 0x04, 0xca, 0x26, 0xc3, + 0x3a, 0x71, 0x7d, 0x48, 0x5b, 0xf2, 0x1c, 0x13, 0x5e, 0xfd, 0x9b, 0x83, 0xeb, 0xc3, 0x5e, 0xd5, + 0x6d, 0x96, 0xa5, 0xec, 0xf7, 0x63, 0x65, 0x57, 0xc6, 0x2b, 0x7b, 0xdd, 0x66, 0x49, 0x75, 0xff, + 0x14, 0x5e, 0x4d, 0xe0, 0x6e, 0xc1, 0x2a, 0xf7, 0x33, 0xa7, 0x42, 0x4e, 0x1d, 0x07, 0x48, 0x5b, + 0x09, 0xa6, 0x81, 0x20, 0x97, 0x48, 0x7b, 0x17, 0x46, 0xa1, 0x6e, 0x9c, 0xf6, 0xfe, 0x06, 0xc0, + 0x9b, 0x89, 0x19, 0xf6, 0x0b, 0xdf, 0xf1, 0xba, 0x37, 0x00, 0x25, 0x38, 0x1f, 0x85, 0xc6, 0xd4, + 0x79, 0xbd, 0xee, 0x51, 0x28, 0xfa, 0x3d, 0x07, 0x37, 0xc5, 0xe0, 0xe3, 0x7e, 0x31, 0xa3, 0x8b, + 0x5f, 0xa6, 0xe1, 0x33, 0x8d, 0x8a, 0xc9, 0x37, 0x74, 0x30, 0x55, 0x27, 0xd7, 0xd0, 0x49, 0x3a, + 0x91, 0xb6, 0xea, 0x4d, 0xeb, 0xa0, 0xa1, 0x7f, 0x04, 0xf0, 0x56, 0x6a, 0x12, 0x2f, 0x74, 0x97, + 0x40, 0x3f, 0xe5, 0x23, 0xf5, 0x7d, 0xe8, 0x3c, 0x7d, 0xa9, 0xce, 0xce, 0x54, 0xdf, 0xf7, 0xbc, + 0xc1, 0x6c, 0x62, 0x31, 0x84, 0x78, 0xcf, 0x6e, 0x0e, 0xfa, 0xe5, 0xf5, 0x18, 0x30, 0xc5, 0x0c, + 0xba, 0x22, 0x8a, 0xe9, 0x8e, 0xa0, 0xc4, 0x5c, 0x15, 0xa6, 0xbd, 0x77, 0xa5, 0xd0, 0xcd, 0xa5, + 0x57, 0x41, 0x37, 0xe8, 0xbb, 0x28, 0x86, 0xa2, 0x85, 0xba, 0x40, 0x82, 0xf8, 0x39, 0x0f, 0x8b, + 0x62, 0xfb, 0x89, 0xf9, 0x35, 0x45, 0x7e, 0x48, 0xd8, 0x62, 0xf2, 0x19, 0xb7, 0x98, 0xa4, 0x75, + 0xb4, 0x30, 0xdd, 0x75, 0x34, 0x6d, 0xaf, 0xb8, 0xf4, 0x8a, 0xf6, 0x8a, 0x1f, 0x00, 0xdc, 0x4a, + 0x2b, 0xd5, 0xc5, 0xee, 0x16, 0x7f, 0xe4, 0xa0, 0x1c, 0xf2, 0x2c, 0x4c, 0x90, 0xd3, 0xa4, 0xa1, + 0xc8, 0x08, 0xcf, 0x4f, 0x60, 0x84, 0x3b, 0x14, 0xe1, 0xa3, 0x20, 0x44, 0x11, 0x85, 0xf3, 0x51, + 0x44, 0x82, 0x4a, 0xa4, 0xad, 0x08, 0x70, 0x05, 0x14, 0xf1, 0x3d, 0x80, 0x28, 0x3d, 0x8b, 0x61, + 0x8e, 0x88, 0x03, 0x1f, 0x4c, 0x15, 0xf8, 0xfb, 0xbf, 0x5c, 0x86, 0xf9, 0x1a, 0x6d, 0x4b, 0x8f, + 0xe0, 0x9c, 0xff, 0x05, 0xe2, 0x96, 0x92, 0xf4, 0x2d, 0x44, 0x09, 0xbd, 0x64, 0xcb, 0xb7, 0x47, + 0x8a, 0xf8, 0x31, 0x3d, 0x82, 0x73, 0xfe, 0xfb, 0x6b, 0xba, 0x66, 0x4f, 0xe4, 0x0c, 0xcd, 0x43, + 0x6f, 0x71, 0x94, 0xbf, 0x72, 0x45, 0x5f, 0x74, 0xde, 0x4c, 0xbd, 0x3f, 0x24, 0x2b, 0xef, 0x8f, + 0x2f, 0xeb, 0x1b, 0x3d, 0x86, 0x52, 0xc2, 0x9e, 0xbd, 0x33, 0xae, 0xa6, 0xba, 0xcd, 0xe4, 0x83, + 0x0c, 0xc2, 0xbe, 0xdd, 0x2f, 0x00, 0xbc, 0x96, 0xb2, 0xea, 0xa9, 0x67, 0x16, 0x63, 0xf8, 0x82, + 0xfc, 0x76, 0xc6, 0x0b, 0x89, 0x4e, 0xc4, 0xf6, 0x91, 0xd1, 0x4e, 0x44, 0x2f, 0x8c, 0xe1, 0x44, + 0xca, 0x20, 0xfd, 0x0a, 0xc0, 0x8d, 0x34, 0x3a, 0xba, 0x73, 0x26, 0x7a, 0x12, 0x6e, 0xc8, 0xef, + 0x64, 0xbd, 0xe1, 0xfb, 0xf1, 0x39, 0x5c, 0x4f, 0x1e, 0xad, 0xca, 0x48, 0x95, 0x11, 0x79, 0xf9, + 0xad, 0x6c, 0xf2, 0x9e, 0x03, 0x95, 0x7b, 0xcf, 0x4f, 0x4a, 0xe0, 0xc5, 0x49, 0x09, 0xfc, 0x77, + 0x52, 0x02, 0x5f, 0x9f, 0x96, 0x66, 0x5e, 0x9c, 0x96, 0x66, 0xfe, 0x3c, 0x2d, 0xcd, 0x7c, 0x72, + 0x27, 0x44, 0x13, 0x42, 0xf7, 0xee, 0x91, 0xde, 0xa4, 0xde, 0x0f, 0xf5, 0x78, 0xef, 0x40, 0xed, + 0xf1, 0x2f, 0xa1, 0x2e, 0x69, 0x34, 0x67, 0xdd, 0x8f, 0x91, 0x07, 0xff, 0x07, 0x00, 0x00, 0xff, + 0xff, 0xd2, 0xcf, 0x16, 0xcd, 0x26, 0x15, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1709,41 +1656,6 @@ func (m *MsgSwapExactAmountInResponse) MarshalToSizedBuffer(dAtA []byte) (int, e return len(dAtA) - i, nil } -func (m *SwapAmountOutRoute) 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 *SwapAmountOutRoute) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SwapAmountOutRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.TokenInDenom) > 0 { - i -= len(m.TokenInDenom) - copy(dAtA[i:], m.TokenInDenom) - i = encodeVarintTx(dAtA, i, uint64(len(m.TokenInDenom))) - i-- - dAtA[i] = 0x12 - } - if m.PoolId != 0 { - i = encodeVarintTx(dAtA, i, uint64(m.PoolId)) - i-- - dAtA[i] = 0x8 - } - return len(dAtA) - i, nil -} - func (m *MsgSwapExactAmountOut) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -2348,22 +2260,6 @@ func (m *MsgSwapExactAmountInResponse) Size() (n int) { return n } -func (m *SwapAmountOutRoute) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.PoolId != 0 { - n += 1 + sovTx(uint64(m.PoolId)) - } - l = len(m.TokenInDenom) - if l > 0 { - n += 1 + l + sovTx(uint64(l)) - } - return n -} - func (m *MsgSwapExactAmountOut) Size() (n int) { if m == nil { return 0 @@ -3267,7 +3163,7 @@ func (m *MsgSwapExactAmountIn) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Routes = append(m.Routes, SwapAmountInRoute{}) + m.Routes = append(m.Routes, types1.SwapAmountInRoute{}) if err := m.Routes[len(m.Routes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -3444,107 +3340,6 @@ func (m *MsgSwapExactAmountInResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *SwapAmountOutRoute) 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 ErrIntOverflowTx - } - 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: SwapAmountOutRoute: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: SwapAmountOutRoute: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field PoolId", wireType) - } - m.PoolId = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.PoolId |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field TokenInDenom", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTx - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthTx - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthTx - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.TokenInDenom = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTx(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthTx - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *MsgSwapExactAmountOut) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -3635,7 +3430,7 @@ func (m *MsgSwapExactAmountOut) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Routes = append(m.Routes, SwapAmountOutRoute{}) + m.Routes = append(m.Routes, types1.SwapAmountOutRoute{}) if err := m.Routes[len(m.Routes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } diff --git a/x/protorev/keeper/routes.go b/x/protorev/keeper/routes.go index 03a7f369973..dab3782e0fb 100644 --- a/x/protorev/keeper/routes.go +++ b/x/protorev/keeper/routes.go @@ -7,6 +7,7 @@ import ( gammtypes "github.com/osmosis-labs/osmosis/v13/x/gamm/types" "github.com/osmosis-labs/osmosis/v13/x/protorev/types" + swaproutertypes "github.com/osmosis-labs/osmosis/v13/x/swaprouter/types" ) // BuildRoutes builds all of the possible arbitrage routes given the tokenIn, tokenOut and poolId that were used in the swap @@ -59,12 +60,12 @@ func (k Keeper) BuildHotRoute(ctx sdk.Context, route *types.Route, tokenIn, toke for _, trade := range route.Trades { // 0 is a placeholder for pools swapped on that should be entered into the hot route if trade.Pool == 0 { - newRoute = append(newRoute, gammtypes.SwapAmountInRoute{ + newRoute = append(newRoute, swaproutertypes.SwapAmountInRoute{ PoolId: poolId, TokenOutDenom: trade.TokenOut, }) } else { - newRoute = append(newRoute, gammtypes.SwapAmountInRoute{ + newRoute = append(newRoute, swaproutertypes.SwapAmountInRoute{ PoolId: trade.Pool, TokenOutDenom: trade.TokenOut, }) @@ -122,7 +123,7 @@ func (k Keeper) BuildRoute(ctx sdk.Context, swapDenom, tokenIn, tokenOut string, return gammtypes.SwapAmountInRoutes{}, err } // Create the first swap for the MultiHopSwap Route - entryRoute := gammtypes.SwapAmountInRoute{ + entryRoute := swaproutertypes.SwapAmountInRoute{ PoolId: entryPoolId, TokenOutDenom: tokenOut, } @@ -132,7 +133,7 @@ func (k Keeper) BuildRoute(ctx sdk.Context, swapDenom, tokenIn, tokenOut string, if err != nil { return gammtypes.SwapAmountInRoutes{}, err } - middleRoute := gammtypes.SwapAmountInRoute{ + middleRoute := swaproutertypes.SwapAmountInRoute{ PoolId: poolId, TokenOutDenom: tokenIn, } @@ -146,7 +147,7 @@ func (k Keeper) BuildRoute(ctx sdk.Context, swapDenom, tokenIn, tokenOut string, if err != nil { return gammtypes.SwapAmountInRoutes{}, err } - exitRoute := gammtypes.SwapAmountInRoute{ + exitRoute := swaproutertypes.SwapAmountInRoute{ PoolId: exitPoolId, TokenOutDenom: swapDenom, }