diff --git a/changelog.md b/changelog.md new file mode 100644 index 00000000..6957d5f2 --- /dev/null +++ b/changelog.md @@ -0,0 +1,5 @@ +### Changelog + +9-27-2023 +- Added in Exchange Wide Total Volume tracking for each Denom +- Added in Total Volume tracking for each Pair diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index af28be9a..2805263d 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -30622,6 +30622,20 @@ paths: type: string denom2: type: string + volume1: + type: object + properties: + denom: + type: string + amount: + type: string + volume2: + type: object + properties: + denom: + type: string + amount: + type: string leaders: type: array items: @@ -30759,6 +30773,20 @@ paths: type: string denom2: type: string + volume1: + type: object + properties: + denom: + type: string + amount: + type: string + volume2: + type: object + properties: + denom: + type: string + amount: + type: string leaders: type: array items: @@ -30849,6 +30877,166 @@ paths: type: string tags: - Query + /pendulum-labs/market/market/volume: + get: + summary: Queries all Volumes. + operationId: PendulumlabsMarketMarketVolumeAll + responses: + '200': + description: A successful response. + schema: + type: object + properties: + volumes: + type: array + items: + type: object + properties: + denom: + type: string + amount: + type: string + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: >- + PageResponse is to be embedded in gRPC response messages where + the + + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: pagination.key + description: |- + key is a value returned in PageResponse.next_key to begin + querying the next page most efficiently. Only one of offset or key + should be set. + in: query + required: false + type: string + format: byte + - name: pagination.offset + description: >- + offset is a numeric offset that can be used when key is unavailable. + + It is less efficient than using key. Only one of offset or key + should + + be set. + in: query + required: false + type: string + format: uint64 + - name: pagination.limit + description: >- + limit is the total number of results to be returned in the result + page. + + If left empty it will default to a value to be set by each app. + in: query + required: false + type: string + format: uint64 + - name: pagination.count_total + description: >- + count_total is set to true to indicate that the result set should + include + + a count of the total number of items available for pagination in + UIs. + + count_total is only respected when offset is used. It is ignored + when key + + is set. + in: query + required: false + type: boolean + - name: pagination.reverse + description: >- + reverse is set to true if results are to be returned in the + descending order. + + + Since: cosmos-sdk 0.43 + in: query + required: false + type: boolean + tags: + - Query + '/pendulum-labs/market/market/volume/{denom}': + get: + summary: Queries a Volume by index. + operationId: PendulumlabsMarketMarketVolume + responses: + '200': + description: A successful response. + schema: + type: object + properties: + amount: + type: string + default: + description: An unexpected error response. + schema: + type: object + properties: + code: + type: integer + format: int32 + message: + type: string + details: + type: array + items: + type: object + properties: + '@type': + type: string + additionalProperties: {} + parameters: + - name: denom + in: path + required: true + type: string + tags: + - Query definitions: cosmos.auth.v1beta1.Params: type: object @@ -50194,6 +50382,20 @@ definitions: type: string denom2: type: string + volume1: + type: object + properties: + denom: + type: string + amount: + type: string + volume2: + type: object + properties: + denom: + type: string + amount: + type: string leaders: type: array items: @@ -50308,6 +50510,20 @@ definitions: type: string denom2: type: string + volume1: + type: object + properties: + denom: + type: string + amount: + type: string + volume2: + type: object + properties: + denom: + type: string + amount: + type: string leaders: type: array items: @@ -50347,6 +50563,43 @@ definitions: repeated Bar results = 1; PageResponse page = 2; } + pendulumlabs.market.market.QueryAllVolumeResponse: + type: object + properties: + volumes: + type: array + items: + type: object + properties: + denom: + type: string + amount: + type: string + pagination: + type: object + properties: + next_key: + type: string + format: byte + title: |- + next_key is the key to be passed to PageRequest.key to + query the next page most efficiently + total: + type: string + format: uint64 + title: >- + total is total number of results available if + PageRequest.count_total + + was set, its value is undefined otherwise + description: |- + PageResponse is to be embedded in gRPC response messages where the + corresponding request message has used PageRequest. + + message SomeResponse { + repeated Bar results = 1; + PageResponse page = 2; + } pendulumlabs.market.market.QueryBookResponse: type: object properties: @@ -50571,6 +50824,20 @@ definitions: type: string denom2: type: string + volume1: + type: object + properties: + denom: + type: string + amount: + type: string + volume2: + type: object + properties: + denom: + type: string + amount: + type: string leaders: type: array items: @@ -50815,3 +51082,15 @@ definitions: type: string amount: type: string + pendulumlabs.market.market.QueryVolumeResponse: + type: object + properties: + amount: + type: string + pendulumlabs.market.market.Volume: + type: object + properties: + denom: + type: string + amount: + type: string diff --git a/go.mod b/go.mod index 1a74172f..424ce4f0 100644 --- a/go.mod +++ b/go.mod @@ -64,17 +64,20 @@ require ( github.com/felixge/httpsnoop v1.0.2 // indirect github.com/fsnotify/fsnotify v1.6.0 // indirect github.com/getsentry/sentry-go v0.17.0 // indirect + github.com/ghodss/yaml v1.0.0 // indirect github.com/go-kit/kit v0.12.0 // indirect github.com/go-kit/log v0.2.1 // indirect github.com/go-logfmt/logfmt v0.5.1 // indirect github.com/godbus/dbus v0.0.0-20190726142602-4481cbc300e2 // indirect github.com/gogo/gateway v1.1.0 // indirect + github.com/golang/glog v1.1.0 // indirect github.com/golang/snappy v0.0.4 // indirect github.com/google/btree v1.1.2 // indirect github.com/google/orderedcode v0.0.1 // indirect github.com/gorilla/handlers v1.5.1 // indirect github.com/gorilla/websocket v1.5.0 // indirect github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect + github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.0 // indirect github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c // indirect github.com/gtank/merlin v0.1.1 // indirect github.com/gtank/ristretto255 v0.1.2 // indirect diff --git a/go.sum b/go.sum index 1a226401..d8ae9710 100644 --- a/go.sum +++ b/go.sum @@ -1218,6 +1218,7 @@ github.com/getsentry/sentry-go v0.17.0 h1:UustVWnOoDFHBS7IJUB2QK/nB5pap748ZEp0sw github.com/getsentry/sentry-go v0.17.0/go.mod h1:B82dxtBvxG0KaPD8/hfSV+VcHD+Lg/xUS4JuQn1P4cM= github.com/ghemawat/stream v0.0.0-20171120220530-696b145b53b9/go.mod h1:106OIgooyS7OzLDOpUGgm9fA3bQENb/cFSyyBmMoJDs= github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= @@ -1399,6 +1400,8 @@ github.com/golang-sql/sqlexp v0.0.0-20170517235910-f1bb20e5a188/go.mod h1:vXjM/+ github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k= github.com/golang/geo v0.0.0-20190916061304-5b978397cfec/go.mod h1:QZ0nwyI2jOfgRAoBvP+ab5aRr7c9x7lhGEJrKvBwjWI= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/glog v1.1.0 h1:/d3pCKDPWNnvIWe0vVUpNP32qc8U3PDVxySP/y360qE= +github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP3NQ= github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -1632,6 +1635,8 @@ github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t github.com/grpc-ecosystem/grpc-gateway v1.12.1/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c= github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.0 h1:RtRsiaGvWxcwd8y3BiRZxsylPT8hLWZ5SPcfI+3IDNk= +github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.0/go.mod h1:TzP6duP4Py2pHLVPPQp42aoYI92+PCrVotyR5e8Vqlk= github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c h1:6rhixN/i8ZofjG1Y75iExal34USq5p+wiN1tpie8IrU= github.com/gsterjov/go-libsecret v0.0.0-20161001094733-a6f4afe4910c/go.mod h1:NMPJylDgVpX0MLRlPy15sqSwOFv/U1GZ2m21JhFfek0= diff --git a/proto/market/pool.proto b/proto/market/pool.proto index d0480157..8c828462 100644 --- a/proto/market/pool.proto +++ b/proto/market/pool.proto @@ -10,13 +10,15 @@ option (gogoproto.goproto_getters_all) = false; message Pool { string pair = 1; string denom1 = 2; - string denom2 = 3; - repeated Leader leaders = 4; - string drops = 5 [ + string denom2 = 3; + Volume volume1 = 4; + Volume volume2 = 5; + repeated Leader leaders = 6; + string drops = 7 [ (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false ]; - uint64 history = 6; + uint64 history = 8; } message Leader { @@ -25,4 +27,12 @@ message Leader { (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", (gogoproto.nullable) = false ]; +} + +message Volume { + string denom = 1; + string amount = 2 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; } \ No newline at end of file diff --git a/proto/market/query.proto b/proto/market/query.proto index fdeefd85..2040a183 100644 --- a/proto/market/query.proto +++ b/proto/market/query.proto @@ -36,6 +36,16 @@ service Query { option (google.api.http).get = "/pendulum-labs/market/market/pool"; } + // Queries a Volume by index. + rpc Volume(QueryVolumeRequest) returns (QueryVolumeResponse) { + option (google.api.http).get = "/pendulum-labs/market/market/volume/{denom}"; + } + + // Queries all Volumes. + rpc VolumeAll(QueryAllVolumeRequest) returns (QueryAllVolumeResponse) { + option (google.api.http).get = "/pendulum-labs/market/market/volume"; + } + // Queries a Drop by index. rpc Drop(QueryDropRequest) returns (QueryDropResponse) { option (google.api.http).get = "/pendulum-labs/market/market/drop/{uid}"; @@ -160,6 +170,23 @@ message QueryAllPoolResponse { cosmos.base.query.v1beta1.PageResponse pagination = 2; } +message QueryVolumeRequest { + string denom = 1; +} + +message QueryVolumeResponse { + string amount = 1; +} + +message QueryAllVolumeRequest { + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +message QueryAllVolumeResponse { + repeated Volume volumes = 1 [(gogoproto.nullable) = false]; + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + message QueryBurnedRequest { } diff --git a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/index.ts b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/index.ts index 9c52c3e3..3bac5077 100755 --- a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/index.ts +++ b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/index.ts @@ -12,6 +12,7 @@ import { OrderResponse } from "./module/types/market/order" import { Params } from "./module/types/market/params" import { Pool } from "./module/types/market/pool" import { Leader } from "./module/types/market/pool" +import { Volume } from "./module/types/market/pool" import { QueryDropOwnerPairSumRequest } from "./module/types/market/query" import { QueryDropOwnerPairSumResponse } from "./module/types/market/query" import { QueryDropOwnerPairUidsRequest } from "./module/types/market/query" @@ -21,7 +22,7 @@ import { QueryOrderOwnerPairRequest } from "./module/types/market/query" import { QueryOrderOwnerPairResponse } from "./module/types/market/query" -export { Burnings, Burned, Drop, Drops, DropPairs, Member, Order, Orders, OrderResponse, Params, Pool, Leader, QueryDropOwnerPairSumRequest, QueryDropOwnerPairSumResponse, QueryDropOwnerPairUidsRequest, QueryUidsResponse, QueryDropOwnerPairDetailRequest, QueryOrderOwnerPairRequest, QueryOrderOwnerPairResponse }; +export { Burnings, Burned, Drop, Drops, DropPairs, Member, Order, Orders, OrderResponse, Params, Pool, Leader, Volume, QueryDropOwnerPairSumRequest, QueryDropOwnerPairSumResponse, QueryDropOwnerPairUidsRequest, QueryUidsResponse, QueryDropOwnerPairDetailRequest, QueryOrderOwnerPairRequest, QueryOrderOwnerPairResponse }; async function initTxClient(vuexGetters) { return await txClient(vuexGetters['common/wallet/signer'], { @@ -63,6 +64,8 @@ const getDefaultState = () => { Burned: {}, Pool: {}, PoolAll: {}, + Volume: {}, + VolumeAll: {}, Drop: {}, DropAmounts: {}, DropCoin: {}, @@ -96,6 +99,7 @@ const getDefaultState = () => { Params: getStructure(Params.fromPartial({})), Pool: getStructure(Pool.fromPartial({})), Leader: getStructure(Leader.fromPartial({})), + Volume: getStructure(Volume.fromPartial({})), QueryDropOwnerPairSumRequest: getStructure(QueryDropOwnerPairSumRequest.fromPartial({})), QueryDropOwnerPairSumResponse: getStructure(QueryDropOwnerPairSumResponse.fromPartial({})), QueryDropOwnerPairUidsRequest: getStructure(QueryDropOwnerPairUidsRequest.fromPartial({})), @@ -154,6 +158,18 @@ export default { ( params).query=null } return state.PoolAll[JSON.stringify(params)] ?? {} + }, + getVolume: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.Volume[JSON.stringify(params)] ?? {} + }, + getVolumeAll: (state) => (params = { params: {}}) => { + if (!( params).query) { + ( params).query=null + } + return state.VolumeAll[JSON.stringify(params)] ?? {} }, getDrop: (state) => (params = { params: {}}) => { if (!( params).query) { @@ -400,6 +416,54 @@ export default { + async QueryVolume({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryVolume( key.denom)).data + + + commit('QUERY', { query: 'Volume', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryVolume', payload: { options: { all }, params: {...key},query }}) + return getters['getVolume']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryVolume API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + + + + + + + async QueryVolumeAll({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { + try { + const key = params ?? {}; + const queryClient=await initQueryClient(rootGetters) + let value= (await queryClient.queryVolumeAll(query)).data + + + while (all && ( value).pagination && ( value).pagination.next_key!=null) { + let next_values=(await queryClient.queryVolumeAll({...query, 'pagination.key':( value).pagination.next_key})).data + value = mergeResults(value, next_values); + } + commit('QUERY', { query: 'VolumeAll', key: { params: {...key}, query}, value }) + if (subscribe) commit('SUBSCRIBE', { action: 'QueryVolumeAll', payload: { options: { all }, params: {...key},query }}) + return getters['getVolumeAll']( { params: {...key}, query}) ?? {} + } catch (e) { + throw new Error('QueryClient:QueryVolumeAll API Node Unavailable. Could not perform query: ' + e.message) + + } + }, + + + + + + + async QueryDrop({ commit, rootGetters, getters }, { options: { subscribe, all} = { subscribe:false, all:false}, params, query=null }) { try { const key = params ?? {}; @@ -849,172 +913,172 @@ export default { }, - async sendMsgMarketOrder({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgCreatePool({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgMarketOrder(value) + const msg = await txClient.msgCreatePool(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgMarketOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreatePool:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgMarketOrder:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgCreatePool:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgRedeemDrop({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgCreateDrop({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgRedeemDrop(value) + const msg = await txClient.msgCreateDrop(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgRedeemDrop:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreateDrop:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgRedeemDrop:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgCreateDrop:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgCreatePool({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgCreateOrder({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreatePool(value) + const msg = await txClient.msgCreateOrder(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreatePool:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreateOrder:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgCreatePool:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgCreateOrder:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgCancelOrder({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgMarketOrder({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCancelOrder(value) + const msg = await txClient.msgMarketOrder(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCancelOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgMarketOrder:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgCancelOrder:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgMarketOrder:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgCreateDrop({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgRedeemDrop({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateDrop(value) + const msg = await txClient.msgRedeemDrop(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateDrop:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgRedeemDrop:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgCreateDrop:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgRedeemDrop:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgCreateOrder({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgCancelOrder({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateOrder(value) + const msg = await txClient.msgCancelOrder(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCancelOrder:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgCreateOrder:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgCancelOrder:Send Could not broadcast Tx: '+ e.message) } } }, - async MsgMarketOrder({ rootGetters }, { value }) { + async MsgCreatePool({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgMarketOrder(value) + const msg = await txClient.msgCreatePool(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgMarketOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreatePool:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgMarketOrder:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgCreatePool:Create Could not create message: ' + e.message) } } }, - async MsgRedeemDrop({ rootGetters }, { value }) { + async MsgCreateDrop({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgRedeemDrop(value) + const msg = await txClient.msgCreateDrop(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgRedeemDrop:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreateDrop:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgRedeemDrop:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgCreateDrop:Create Could not create message: ' + e.message) } } }, - async MsgCreatePool({ rootGetters }, { value }) { + async MsgCreateOrder({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreatePool(value) + const msg = await txClient.msgCreateOrder(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreatePool:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCreateOrder:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgCreatePool:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgCreateOrder:Create Could not create message: ' + e.message) } } }, - async MsgCancelOrder({ rootGetters }, { value }) { + async MsgMarketOrder({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCancelOrder(value) + const msg = await txClient.msgMarketOrder(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCancelOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgMarketOrder:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgCancelOrder:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgMarketOrder:Create Could not create message: ' + e.message) } } }, - async MsgCreateDrop({ rootGetters }, { value }) { + async MsgRedeemDrop({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateDrop(value) + const msg = await txClient.msgRedeemDrop(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateDrop:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgRedeemDrop:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgCreateDrop:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgRedeemDrop:Create Could not create message: ' + e.message) } } }, - async MsgCreateOrder({ rootGetters }, { value }) { + async MsgCancelOrder({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateOrder(value) + const msg = await txClient.msgCancelOrder(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateOrder:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgCancelOrder:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgCreateOrder:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgCancelOrder:Create Could not create message: ' + e.message) } } }, diff --git a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/index.ts b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/index.ts index 3f06edd6..7b31115f 100755 --- a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/index.ts +++ b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/index.ts @@ -4,21 +4,21 @@ import { StdFee } from "@cosmjs/launchpad"; import { SigningStargateClient } from "@cosmjs/stargate"; import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"; import { Api } from "./rest"; -import { MsgMarketOrder } from "./types/market/tx"; -import { MsgRedeemDrop } from "./types/market/tx"; import { MsgCreatePool } from "./types/market/tx"; -import { MsgCancelOrder } from "./types/market/tx"; import { MsgCreateDrop } from "./types/market/tx"; import { MsgCreateOrder } from "./types/market/tx"; +import { MsgMarketOrder } from "./types/market/tx"; +import { MsgRedeemDrop } from "./types/market/tx"; +import { MsgCancelOrder } from "./types/market/tx"; const types = [ - ["/pendulumlabs.market.market.MsgMarketOrder", MsgMarketOrder], - ["/pendulumlabs.market.market.MsgRedeemDrop", MsgRedeemDrop], ["/pendulumlabs.market.market.MsgCreatePool", MsgCreatePool], - ["/pendulumlabs.market.market.MsgCancelOrder", MsgCancelOrder], ["/pendulumlabs.market.market.MsgCreateDrop", MsgCreateDrop], ["/pendulumlabs.market.market.MsgCreateOrder", MsgCreateOrder], + ["/pendulumlabs.market.market.MsgMarketOrder", MsgMarketOrder], + ["/pendulumlabs.market.market.MsgRedeemDrop", MsgRedeemDrop], + ["/pendulumlabs.market.market.MsgCancelOrder", MsgCancelOrder], ]; export const MissingWalletError = new Error("wallet is required"); @@ -51,12 +51,12 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions = return { signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo), - msgMarketOrder: (data: MsgMarketOrder): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgMarketOrder", value: MsgMarketOrder.fromPartial( data ) }), - msgRedeemDrop: (data: MsgRedeemDrop): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgRedeemDrop", value: MsgRedeemDrop.fromPartial( data ) }), msgCreatePool: (data: MsgCreatePool): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgCreatePool", value: MsgCreatePool.fromPartial( data ) }), - msgCancelOrder: (data: MsgCancelOrder): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgCancelOrder", value: MsgCancelOrder.fromPartial( data ) }), msgCreateDrop: (data: MsgCreateDrop): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgCreateDrop", value: MsgCreateDrop.fromPartial( data ) }), msgCreateOrder: (data: MsgCreateOrder): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgCreateOrder", value: MsgCreateOrder.fromPartial( data ) }), + msgMarketOrder: (data: MsgMarketOrder): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgMarketOrder", value: MsgMarketOrder.fromPartial( data ) }), + msgRedeemDrop: (data: MsgRedeemDrop): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgRedeemDrop", value: MsgRedeemDrop.fromPartial( data ) }), + msgCancelOrder: (data: MsgCancelOrder): EncodeObject => ({ typeUrl: "/pendulumlabs.market.market.MsgCancelOrder", value: MsgCancelOrder.fromPartial( data ) }), }; }; diff --git a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/rest.ts b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/rest.ts index 4e4371fa..8b46f29a 100644 --- a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/rest.ts +++ b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/rest.ts @@ -128,6 +128,8 @@ export interface MarketPool { pair?: string; denom1?: string; denom2?: string; + volume1?: MarketVolume; + volume2?: MarketVolume; leaders?: MarketLeader[]; drops?: string; @@ -180,6 +182,21 @@ export interface MarketQueryAllPoolResponse { pagination?: V1Beta1PageResponse; } +export interface MarketQueryAllVolumeResponse { + volumes?: MarketVolume[]; + + /** + * PageResponse is to be embedded in gRPC response messages where the + * corresponding request message has used PageRequest. + * + * message SomeResponse { + * repeated Bar results = 1; + * PageResponse page = 2; + * } + */ + pagination?: V1Beta1PageResponse; +} + export interface MarketQueryBookResponse { book?: MarketOrderResponse[]; @@ -322,6 +339,15 @@ export interface MarketQueryQuoteResponse { amount?: string; } +export interface MarketQueryVolumeResponse { + amount?: string; +} + +export interface MarketVolume { + denom?: string; + amount?: string; +} + export interface ProtobufAny { "@type"?: string; } @@ -1068,4 +1094,46 @@ export class Api extends HttpClient + this.request({ + path: `/pendulum-labs/market/market/volume`, + method: "GET", + query: query, + format: "json", + ...params, + }); + + /** + * No description + * + * @tags Query + * @name QueryVolume + * @summary Queries a Volume by index. + * @request GET:/pendulum-labs/market/market/volume/{denom} + */ + queryVolume = (denom: string, params: RequestParams = {}) => + this.request({ + path: `/pendulum-labs/market/market/volume/${denom}`, + method: "GET", + format: "json", + ...params, + }); } diff --git a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/pool.ts b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/pool.ts index 995ce329..72676705 100644 --- a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/pool.ts +++ b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/pool.ts @@ -8,6 +8,8 @@ export interface Pool { pair: string; denom1: string; denom2: string; + volume1: Volume | undefined; + volume2: Volume | undefined; leaders: Leader[]; drops: string; history: number; @@ -18,6 +20,11 @@ export interface Leader { drops: string; } +export interface Volume { + denom: string; + amount: string; +} + const basePool: object = { pair: "", denom1: "", @@ -37,14 +44,20 @@ export const Pool = { if (message.denom2 !== "") { writer.uint32(26).string(message.denom2); } + if (message.volume1 !== undefined) { + Volume.encode(message.volume1, writer.uint32(34).fork()).ldelim(); + } + if (message.volume2 !== undefined) { + Volume.encode(message.volume2, writer.uint32(42).fork()).ldelim(); + } for (const v of message.leaders) { - Leader.encode(v!, writer.uint32(34).fork()).ldelim(); + Leader.encode(v!, writer.uint32(50).fork()).ldelim(); } if (message.drops !== "") { - writer.uint32(42).string(message.drops); + writer.uint32(58).string(message.drops); } if (message.history !== 0) { - writer.uint32(48).uint64(message.history); + writer.uint32(64).uint64(message.history); } return writer; }, @@ -67,12 +80,18 @@ export const Pool = { message.denom2 = reader.string(); break; case 4: - message.leaders.push(Leader.decode(reader, reader.uint32())); + message.volume1 = Volume.decode(reader, reader.uint32()); break; case 5: - message.drops = reader.string(); + message.volume2 = Volume.decode(reader, reader.uint32()); break; case 6: + message.leaders.push(Leader.decode(reader, reader.uint32())); + break; + case 7: + message.drops = reader.string(); + break; + case 8: message.history = longToNumber(reader.uint64() as Long); break; default: @@ -101,6 +120,16 @@ export const Pool = { } else { message.denom2 = ""; } + if (object.volume1 !== undefined && object.volume1 !== null) { + message.volume1 = Volume.fromJSON(object.volume1); + } else { + message.volume1 = undefined; + } + if (object.volume2 !== undefined && object.volume2 !== null) { + message.volume2 = Volume.fromJSON(object.volume2); + } else { + message.volume2 = undefined; + } if (object.leaders !== undefined && object.leaders !== null) { for (const e of object.leaders) { message.leaders.push(Leader.fromJSON(e)); @@ -124,6 +153,14 @@ export const Pool = { message.pair !== undefined && (obj.pair = message.pair); message.denom1 !== undefined && (obj.denom1 = message.denom1); message.denom2 !== undefined && (obj.denom2 = message.denom2); + message.volume1 !== undefined && + (obj.volume1 = message.volume1 + ? Volume.toJSON(message.volume1) + : undefined); + message.volume2 !== undefined && + (obj.volume2 = message.volume2 + ? Volume.toJSON(message.volume2) + : undefined); if (message.leaders) { obj.leaders = message.leaders.map((e) => e ? Leader.toJSON(e) : undefined @@ -154,6 +191,16 @@ export const Pool = { } else { message.denom2 = ""; } + if (object.volume1 !== undefined && object.volume1 !== null) { + message.volume1 = Volume.fromPartial(object.volume1); + } else { + message.volume1 = undefined; + } + if (object.volume2 !== undefined && object.volume2 !== null) { + message.volume2 = Volume.fromPartial(object.volume2); + } else { + message.volume2 = undefined; + } if (object.leaders !== undefined && object.leaders !== null) { for (const e of object.leaders) { message.leaders.push(Leader.fromPartial(e)); @@ -245,6 +292,78 @@ export const Leader = { }, }; +const baseVolume: object = { denom: "", amount: "" }; + +export const Volume = { + encode(message: Volume, writer: Writer = Writer.create()): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.amount !== "") { + writer.uint32(18).string(message.amount); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Volume { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseVolume } as Volume; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.amount = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Volume { + const message = { ...baseVolume } as Volume; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = String(object.amount); + } else { + message.amount = ""; + } + return message; + }, + + toJSON(message: Volume): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + message.amount !== undefined && (obj.amount = message.amount); + return obj; + }, + + fromPartial(object: DeepPartial): Volume { + const message = { ...baseVolume } as Volume; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = object.amount; + } else { + message.amount = ""; + } + return message; + }, +}; + declare var self: any | undefined; declare var window: any | undefined; var globalThis: any = (() => { diff --git a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/query.ts b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/query.ts index fc1d6d7d..aae55ab8 100644 --- a/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/query.ts +++ b/vue/src/store/generated/pendulum-labs/market/pendulumlabs.market.market/module/types/market/query.ts @@ -2,7 +2,7 @@ import { Reader, util, configure, Writer } from "protobufjs/minimal"; import * as Long from "long"; import { Params } from "../market/params"; -import { Pool } from "../market/pool"; +import { Pool, Volume } from "../market/pool"; import { PageRequest, PageResponse, @@ -40,6 +40,23 @@ export interface QueryAllPoolResponse { pagination: PageResponse | undefined; } +export interface QueryVolumeRequest { + denom: string; +} + +export interface QueryVolumeResponse { + amount: string; +} + +export interface QueryAllVolumeRequest { + pagination: PageRequest | undefined; +} + +export interface QueryAllVolumeResponse { + volumes: Volume[]; + pagination: PageResponse | undefined; +} + export interface QueryBurnedRequest {} export interface QueryBurnedResponse { @@ -619,6 +636,277 @@ export const QueryAllPoolResponse = { }, }; +const baseQueryVolumeRequest: object = { denom: "" }; + +export const QueryVolumeRequest = { + encode( + message: QueryVolumeRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryVolumeRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryVolumeRequest } as QueryVolumeRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryVolumeRequest { + const message = { ...baseQueryVolumeRequest } as QueryVolumeRequest; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + return message; + }, + + toJSON(message: QueryVolumeRequest): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + return obj; + }, + + fromPartial(object: DeepPartial): QueryVolumeRequest { + const message = { ...baseQueryVolumeRequest } as QueryVolumeRequest; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + return message; + }, +}; + +const baseQueryVolumeResponse: object = { amount: "" }; + +export const QueryVolumeResponse = { + encode( + message: QueryVolumeResponse, + writer: Writer = Writer.create() + ): Writer { + if (message.amount !== "") { + writer.uint32(10).string(message.amount); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryVolumeResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryVolumeResponse } as QueryVolumeResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.amount = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryVolumeResponse { + const message = { ...baseQueryVolumeResponse } as QueryVolumeResponse; + if (object.amount !== undefined && object.amount !== null) { + message.amount = String(object.amount); + } else { + message.amount = ""; + } + return message; + }, + + toJSON(message: QueryVolumeResponse): unknown { + const obj: any = {}; + message.amount !== undefined && (obj.amount = message.amount); + return obj; + }, + + fromPartial(object: DeepPartial): QueryVolumeResponse { + const message = { ...baseQueryVolumeResponse } as QueryVolumeResponse; + if (object.amount !== undefined && object.amount !== null) { + message.amount = object.amount; + } else { + message.amount = ""; + } + return message; + }, +}; + +const baseQueryAllVolumeRequest: object = {}; + +export const QueryAllVolumeRequest = { + encode( + message: QueryAllVolumeRequest, + writer: Writer = Writer.create() + ): Writer { + if (message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryAllVolumeRequest { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAllVolumeRequest } as QueryAllVolumeRequest; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.pagination = PageRequest.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllVolumeRequest { + const message = { ...baseQueryAllVolumeRequest } as QueryAllVolumeRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllVolumeRequest): unknown { + const obj: any = {}; + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageRequest.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryAllVolumeRequest { + const message = { ...baseQueryAllVolumeRequest } as QueryAllVolumeRequest; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + +const baseQueryAllVolumeResponse: object = {}; + +export const QueryAllVolumeResponse = { + encode( + message: QueryAllVolumeResponse, + writer: Writer = Writer.create() + ): Writer { + for (const v of message.volumes) { + Volume.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.pagination !== undefined) { + PageResponse.encode( + message.pagination, + writer.uint32(18).fork() + ).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): QueryAllVolumeResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseQueryAllVolumeResponse } as QueryAllVolumeResponse; + message.volumes = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.volumes.push(Volume.decode(reader, reader.uint32())); + break; + case 2: + message.pagination = PageResponse.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): QueryAllVolumeResponse { + const message = { ...baseQueryAllVolumeResponse } as QueryAllVolumeResponse; + message.volumes = []; + if (object.volumes !== undefined && object.volumes !== null) { + for (const e of object.volumes) { + message.volumes.push(Volume.fromJSON(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromJSON(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, + + toJSON(message: QueryAllVolumeResponse): unknown { + const obj: any = {}; + if (message.volumes) { + obj.volumes = message.volumes.map((e) => + e ? Volume.toJSON(e) : undefined + ); + } else { + obj.volumes = []; + } + message.pagination !== undefined && + (obj.pagination = message.pagination + ? PageResponse.toJSON(message.pagination) + : undefined); + return obj; + }, + + fromPartial( + object: DeepPartial + ): QueryAllVolumeResponse { + const message = { ...baseQueryAllVolumeResponse } as QueryAllVolumeResponse; + message.volumes = []; + if (object.volumes !== undefined && object.volumes !== null) { + for (const e of object.volumes) { + message.volumes.push(Volume.fromPartial(e)); + } + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromPartial(object.pagination); + } else { + message.pagination = undefined; + } + return message; + }, +}; + const baseQueryBurnedRequest: object = {}; export const QueryBurnedRequest = { @@ -4236,6 +4524,10 @@ export interface Query { Pool(request: QueryGetPoolRequest): Promise; /** Queries a list of Pool items. */ PoolAll(request: QueryAllPoolRequest): Promise; + /** Queries a Volume by index. */ + Volume(request: QueryVolumeRequest): Promise; + /** Queries all Volumes. */ + VolumeAll(request: QueryAllVolumeRequest): Promise; /** Queries a Drop by index. */ Drop(request: QueryDropRequest): Promise; /** Queries a Drop by index. */ @@ -4335,6 +4627,28 @@ export class QueryClientImpl implements Query { ); } + Volume(request: QueryVolumeRequest): Promise { + const data = QueryVolumeRequest.encode(request).finish(); + const promise = this.rpc.request( + "pendulumlabs.market.market.Query", + "Volume", + data + ); + return promise.then((data) => QueryVolumeResponse.decode(new Reader(data))); + } + + VolumeAll(request: QueryAllVolumeRequest): Promise { + const data = QueryAllVolumeRequest.encode(request).finish(); + const promise = this.rpc.request( + "pendulumlabs.market.market.Query", + "VolumeAll", + data + ); + return promise.then((data) => + QueryAllVolumeResponse.decode(new Reader(data)) + ); + } + Drop(request: QueryDropRequest): Promise { const data = QueryDropRequest.encode(request).finish(); const promise = this.rpc.request( diff --git a/x/market/keeper/grpc_query_pool.go b/x/market/keeper/grpc_query_pool.go index 422a5e97..80f74cee 100644 --- a/x/market/keeper/grpc_query_pool.go +++ b/x/market/keeper/grpc_query_pool.go @@ -73,3 +73,47 @@ func (k Keeper) History(c context.Context, req *types.QueryHistoryRequest) (*typ return &types.QueryHistoryResponse{History: val}, nil } + +func (k Keeper) VolumeAll(c context.Context, req *types.QueryAllVolumeRequest) (*types.QueryAllVolumeResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + + var volumes []types.Volume + ctx := sdk.UnwrapSDKContext(c) + + store := ctx.KVStore(k.storeKey) + volumeStore := prefix.NewStore(store, types.KeyPrefix(types.VolumeKeyPrefix)) + + pageRes, err := query.Paginate(volumeStore, req.Pagination, func(key []byte, value []byte) error { + var volume types.Volume + if err := k.cdc.Unmarshal(value, &volume); err != nil { + return err + } + + volumes = append(volumes, volume) + return nil + }) + + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + return &types.QueryAllVolumeResponse{Volumes: volumes, Pagination: pageRes}, nil +} + +func (k Keeper) Volume(c context.Context, req *types.QueryVolumeRequest) (*types.QueryVolumeResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "invalid request") + } + ctx := sdk.UnwrapSDKContext(c) + + val, found := k.GetVolume( + ctx, + req.Denom, + ) + if !found { + return nil, status.Error(codes.InvalidArgument, "not found") + } + + return &types.QueryVolumeResponse{Amount: val.Amount.String()}, nil +} diff --git a/x/market/keeper/msg_server_create_order.go b/x/market/keeper/msg_server_create_order.go index f93c85e3..6e610898 100644 --- a/x/market/keeper/msg_server_create_order.go +++ b/x/market/keeper/msg_server_create_order.go @@ -436,7 +436,18 @@ func ExecuteOverlap(k msgServer, ctx sdk.Context, denomAsk string, denomBid stri limitHeadBid.Next = limitHeadAsk.Uid limitHeadAsk.Prev = limitHeadBid.Uid limitHeadAsk.Next = pool.History + pool.History = limitHeadBid.Uid + if pool.Denom1 == limitHeadBid.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(limitHeadBid.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(limitHeadAsk.Amount) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(limitHeadAsk.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(limitHeadBid.Amount) + } + + k.IncVolume(ctx, limitHeadBid.DenomBid, limitHeadBid.Amount) + k.IncVolume(ctx, limitHeadAsk.DenomBid, limitHeadAsk.Amount) ownerAsk, _ := sdk.AccAddressFromBech32(limitHeadAsk.Owner) ownerBid, _ := sdk.AccAddressFromBech32(limitHeadBid.Owner) @@ -508,6 +519,17 @@ func ExecuteOverlap(k msgServer, ctx sdk.Context, denomAsk string, denomBid stri pool.History = partialFillOrder.Uid + if pool.Denom1 == partialFillOrder.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(partialFillOrder.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(limitHeadAsk.Amount) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(limitHeadAsk.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(partialFillOrder.Amount) + } + + k.IncVolume(ctx, partialFillOrder.DenomBid, partialFillOrder.Amount) + k.IncVolume(ctx, limitHeadAsk.DenomBid, limitHeadAsk.Amount) + limitHeadBid.Amount = limitHeadBid.Amount.Sub(amountDenomBidAskOrder) ownerAsk, _ := sdk.AccAddressFromBech32(limitHeadAsk.Owner) @@ -578,6 +600,17 @@ func ExecuteOverlap(k msgServer, ctx sdk.Context, denomAsk string, denomBid stri pool.History = partialFillOrder.Uid + if pool.Denom1 == limitHeadBid.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(limitHeadBid.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(partialFillOrder.Amount) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(partialFillOrder.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(limitHeadBid.Amount) + } + + k.IncVolume(ctx, limitHeadBid.DenomBid, limitHeadBid.Amount) + k.IncVolume(ctx, partialFillOrder.DenomBid, partialFillOrder.Amount) + limitHeadAsk.Amount = limitHeadAsk.Amount.Sub(amountDenomAskBidOrder) ownerAsk, _ := sdk.AccAddressFromBech32(limitHeadAsk.Owner) @@ -725,6 +758,17 @@ func ExecuteLimit(k msgServer, ctx sdk.Context, denomAsk string, denomBid string pool.History = limitHead.Uid + if pool.Denom1 == limitHead.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(limitHead.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(strikeAmountAsk) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(strikeAmountAsk) + pool.Volume2.Amount = pool.Volume2.Amount.Add(limitHead.Amount) + } + + k.IncVolume(ctx, limitHead.DenomBid, limitHead.Amount) + k.IncVolume(ctx, limitHead.DenomAsk, strikeAmountAsk) + } else { // Add partially filled order to history // Keep remainder of order into book @@ -742,16 +786,27 @@ func ExecuteLimit(k msgServer, ctx sdk.Context, denomAsk string, denomBid string if pool.History == 0 { partialFillOrder.Prev = 0 partialFillOrder.Next = 0 - pool.History = partialFillOrder.Uid } else { prevFilledOrder, _ := k.GetOrder(ctx, pool.History) prevFilledOrder.Prev = partialFillOrder.Uid k.SetOrder(ctx, prevFilledOrder) partialFillOrder.Prev = 0 partialFillOrder.Next = prevFilledOrder.Uid - pool.History = partialFillOrder.Uid } + pool.History = partialFillOrder.Uid + + if pool.Denom1 == partialFillOrder.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(partialFillOrder.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(strikeAmountAsk) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(strikeAmountAsk) + pool.Volume2.Amount = pool.Volume2.Amount.Add(partialFillOrder.Amount) + } + + k.IncVolume(ctx, limitHead.DenomBid, limitHead.Amount) + k.IncVolume(ctx, limitHead.DenomAsk, strikeAmountAsk) + k.SetOrder(ctx, partialFillOrder) k.SetOrderOwner(ctx, limitHead.Owner, limitHead.Uid) } @@ -856,6 +911,17 @@ func ExecuteStop(k msgServer, ctx sdk.Context, denomAsk string, denomBid string, pool, _ := k.GetPool(ctx, memberAsk.Pair) pool.History = stopHead.Uid + if pool.Denom1 == stopHead.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(stopHead.Amount) + pool.Volume2.Amount = pool.Volume2.Amount.Add(strikeAmountAsk) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(strikeAmountAsk) + pool.Volume2.Amount = pool.Volume2.Amount.Add(stopHead.Amount) + } + + k.IncVolume(ctx, stopHead.DenomBid, stopHead.Amount) + k.IncVolume(ctx, stopHead.DenomAsk, strikeAmountAsk) + // order filled // just add the order to history if pool.History == 0 { diff --git a/x/market/keeper/msg_server_create_order_test.go b/x/market/keeper/msg_server_create_order_test.go index 7e9dc2d1..9981c06e 100644 --- a/x/market/keeper/msg_server_create_order_test.go +++ b/x/market/keeper/msg_server_create_order_test.go @@ -261,6 +261,10 @@ func TestCreateOrder_BothFillOverlap(t *testing.T) { require.Equal(t, "40", history[0].Amount) require.Equal(t, "30", history[1].Amount) + volumes := testInput.MarketKeeper.GetAllVolumes(testInput.Context) + require.Equalf(t, "30", volumes[0].Amount.String(), volumes[0].Amount.String()) + require.Equalf(t, "40", volumes[1].Amount.String(), volumes[0].Amount.String()) + require.True(t, len(allorders) == 2) // Validate Order @@ -307,6 +311,10 @@ func TestCreateOrder_OneSide1FillOverlap(t *testing.T) { require.Equal(t, "40", history[0].Amount) require.Equal(t, "30", history[1].Amount) + volumes := testInput.MarketKeeper.GetAllVolumes(testInput.Context) + require.Equalf(t, "30", volumes[0].Amount.String(), volumes[0].Amount.String()) + require.Equalf(t, "40", volumes[1].Amount.String(), volumes[0].Amount.String()) + require.Equal(t, 3, len(allorders)) // Validate Order diff --git a/x/market/keeper/msg_server_create_pool.go b/x/market/keeper/msg_server_create_pool.go index 731e973b..c69f1e13 100644 --- a/x/market/keeper/msg_server_create_pool.go +++ b/x/market/keeper/msg_server_create_pool.go @@ -80,6 +80,14 @@ func (k msgServer) CreatePool(goCtx context.Context, msg *types.MsgCreatePool) ( Leaders: []*types.Leader{&leader}, Denom1: coinPair.GetDenomByIndex(0), Denom2: coinPair.GetDenomByIndex(1), + Volume1: &types.Volume{ + Denom: coinPair.GetDenomByIndex(0), + Amount: sdk.ZeroInt(), + }, + Volume2: &types.Volume{ + Denom: coinPair.GetDenomByIndex(1), + Amount: sdk.ZeroInt(), + }, Drops: drops, History: uint64(0), } diff --git a/x/market/keeper/msg_server_market_order.go b/x/market/keeper/msg_server_market_order.go index 026fca56..1e95fbe4 100644 --- a/x/market/keeper/msg_server_market_order.go +++ b/x/market/keeper/msg_server_market_order.go @@ -113,6 +113,17 @@ func (k msgServer) MarketOrder(goCtx context.Context, msg *types.MsgMarketOrder) pool.History = uid + if pool.Denom1 == msg.DenomBid { + pool.Volume1.Amount = pool.Volume1.Amount.Add(amountBid) + pool.Volume2.Amount = pool.Volume2.Amount.Add(amountAsk) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(amountAsk) + pool.Volume2.Amount = pool.Volume2.Amount.Add(amountBid) + } + + k.IncVolume(ctx, msg.DenomBid, amountBid) + k.IncVolume(ctx, msg.DenomAsk, amountAsk) + k.SetPool(ctx, pool) k.SetUidCount(ctx, uid+1) k.SetOrder(ctx, order) diff --git a/x/market/keeper/profit.go b/x/market/keeper/profit.go index 206270b4..4796bbde 100644 --- a/x/market/keeper/profit.go +++ b/x/market/keeper/profit.go @@ -193,6 +193,17 @@ func (k Keeper) BurnTrade(ctx sdk.Context, burnings types.Burnings) (types.Burni pool.History = uid + if pool.Denom1 == burnings.Denom { + pool.Volume1.Amount = pool.Volume1.Amount.Add(amountBid) + pool.Volume2.Amount = pool.Volume2.Amount.Add(amountAsk) + } else { + pool.Volume1.Amount = pool.Volume1.Amount.Add(amountAsk) + pool.Volume2.Amount = pool.Volume2.Amount.Add(amountBid) + } + + k.IncVolume(ctx, burnings.Denom, amountBid) + k.IncVolume(ctx, burnDenom, amountAsk) + k.SetPool(ctx, pool) k.SetUidCount(ctx, uid+1) k.SetOrder(ctx, order) diff --git a/x/market/keeper/volume.go b/x/market/keeper/volume.go new file mode 100644 index 00000000..9afd2465 --- /dev/null +++ b/x/market/keeper/volume.go @@ -0,0 +1,81 @@ +package keeper + +import ( + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/pendulum-labs/market/x/market/types" +) + +// SetVolume set a specific volume in the store from its index +func (k Keeper) SetVolume(ctx sdk.Context, volume types.Volume) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.VolumeKeyPrefix)) + b := k.cdc.MustMarshal(&volume) + store.Set(types.VolumeKey( + volume.Denom, + ), b) +} + +// GetVolume returns a volume from its index +func (k Keeper) GetVolume( + ctx sdk.Context, + denom string, +) (val types.Volume, found bool) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.VolumeKeyPrefix)) + + b := store.Get(types.VolumeKey( + denom, + )) + if b == nil { + return val, false + } + + k.cdc.MustUnmarshal(b, &val) + return val, true +} + +// GetVolume returns a volume from its index +func (k Keeper) IncVolume( + ctx sdk.Context, + denom string, + amount sdk.Int, +) types.Volume { + volume, found := k.GetVolume(ctx, denom) + + if found { + volume.Amount = volume.Amount.Add(amount) + } else { + volume.Denom = denom + volume.Amount = amount + } + + k.SetVolume(ctx, volume) + + return volume +} + +// RemoveVolume removes a volume from the store +func (k Keeper) RemoveVolume( + ctx sdk.Context, + denom string, +) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.VolumeKeyPrefix)) + store.Delete(types.VolumeKey( + denom, + )) +} + +// GetAllVolume returns all volumes +func (k Keeper) GetAllVolumes(ctx sdk.Context) (list []types.Volume) { + store := prefix.NewStore(ctx.KVStore(k.storeKey), types.KeyPrefix(types.VolumeKeyPrefix)) + iterator := sdk.KVStorePrefixIterator(store, []byte{}) + + defer iterator.Close() + + for ; iterator.Valid(); iterator.Next() { + var val types.Volume + k.cdc.MustUnmarshal(iterator.Value(), &val) + list = append(list, val) + } + + return +} diff --git a/x/market/types/key_volume.go b/x/market/types/key_volume.go new file mode 100644 index 00000000..2571b18e --- /dev/null +++ b/x/market/types/key_volume.go @@ -0,0 +1,26 @@ +package types + +import ( + "encoding/binary" + //github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" +) + +var _ binary.ByteOrder + +const ( + // MemberKeyPrefix is the prefix to retrieve all Volumes + VolumeKeyPrefix = "Volume/value/" +) + +// MemberKey returns the store key to retrieve a Volume +func VolumeKey( + denom string, +) []byte { + var key []byte + + denomBytes := []byte(denom) + key = append(key, denomBytes...) + key = append(key, []byte("/")...) + + return key +} diff --git a/x/market/types/pool.pb.go b/x/market/types/pool.pb.go index 9a09132b..9155701a 100644 --- a/x/market/types/pool.pb.go +++ b/x/market/types/pool.pb.go @@ -28,9 +28,11 @@ type Pool struct { Pair string `protobuf:"bytes,1,opt,name=pair,proto3" json:"pair,omitempty"` Denom1 string `protobuf:"bytes,2,opt,name=denom1,proto3" json:"denom1,omitempty"` Denom2 string `protobuf:"bytes,3,opt,name=denom2,proto3" json:"denom2,omitempty"` - Leaders []*Leader `protobuf:"bytes,4,rep,name=leaders,proto3" json:"leaders,omitempty"` - Drops github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=drops,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"drops"` - History uint64 `protobuf:"varint,6,opt,name=history,proto3" json:"history,omitempty"` + Volume1 *Volume `protobuf:"bytes,4,opt,name=volume1,proto3" json:"volume1,omitempty"` + Volume2 *Volume `protobuf:"bytes,5,opt,name=volume2,proto3" json:"volume2,omitempty"` + Leaders []*Leader `protobuf:"bytes,6,rep,name=leaders,proto3" json:"leaders,omitempty"` + Drops github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,7,opt,name=drops,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"drops"` + History uint64 `protobuf:"varint,8,opt,name=history,proto3" json:"history,omitempty"` } func (m *Pool) Reset() { *m = Pool{} } @@ -104,35 +106,77 @@ func (m *Leader) XXX_DiscardUnknown() { var xxx_messageInfo_Leader proto.InternalMessageInfo +type Volume struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` + Amount github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount"` +} + +func (m *Volume) Reset() { *m = Volume{} } +func (m *Volume) String() string { return proto.CompactTextString(m) } +func (*Volume) ProtoMessage() {} +func (*Volume) Descriptor() ([]byte, []int) { + return fileDescriptor_adb392bd01694df9, []int{2} +} +func (m *Volume) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *Volume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_Volume.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 *Volume) XXX_Merge(src proto.Message) { + xxx_messageInfo_Volume.Merge(m, src) +} +func (m *Volume) XXX_Size() int { + return m.Size() +} +func (m *Volume) XXX_DiscardUnknown() { + xxx_messageInfo_Volume.DiscardUnknown(m) +} + +var xxx_messageInfo_Volume proto.InternalMessageInfo + func init() { proto.RegisterType((*Pool)(nil), "pendulumlabs.market.market.Pool") proto.RegisterType((*Leader)(nil), "pendulumlabs.market.market.Leader") + proto.RegisterType((*Volume)(nil), "pendulumlabs.market.market.Volume") } func init() { proto.RegisterFile("market/pool.proto", fileDescriptor_adb392bd01694df9) } var fileDescriptor_adb392bd01694df9 = []byte{ - // 313 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x51, 0x31, 0x6f, 0xf2, 0x30, - 0x10, 0x8d, 0x21, 0x04, 0x7d, 0xfe, 0xa6, 0x5a, 0x55, 0x65, 0x31, 0x18, 0xc4, 0x50, 0xb1, 0xe0, - 0xa8, 0x74, 0xed, 0x84, 0xba, 0x54, 0xea, 0x80, 0x32, 0x76, 0x0b, 0xd8, 0x02, 0x44, 0xc2, 0x59, - 0xb6, 0x91, 0xca, 0xbf, 0xe8, 0xcf, 0xca, 0xc8, 0x88, 0x3a, 0xa0, 0x92, 0x2c, 0xfd, 0x19, 0x55, - 0x9c, 0xa4, 0x65, 0xe9, 0xd4, 0xe9, 0xee, 0x5e, 0xde, 0x7b, 0x79, 0xbe, 0xc3, 0x57, 0x69, 0xac, - 0x37, 0xd2, 0x86, 0x0a, 0x20, 0xe1, 0x4a, 0x83, 0x05, 0xd2, 0x53, 0x72, 0x2b, 0x76, 0xc9, 0x2e, - 0x4d, 0xe2, 0xb9, 0xe1, 0xd5, 0xf7, 0xba, 0xf4, 0xae, 0x97, 0xb0, 0x04, 0x47, 0x0b, 0xcb, 0xae, - 0x52, 0x0c, 0x3f, 0x11, 0xf6, 0x67, 0x00, 0x09, 0x21, 0xd8, 0x57, 0xf1, 0x5a, 0x53, 0x34, 0x40, - 0xa3, 0x7f, 0x91, 0xeb, 0xc9, 0x0d, 0x0e, 0x84, 0xdc, 0x42, 0x7a, 0x47, 0x5b, 0x0e, 0xad, 0xa7, - 0x6f, 0x7c, 0x42, 0xdb, 0x17, 0xf8, 0x84, 0x3c, 0xe0, 0x6e, 0x22, 0x63, 0x21, 0xb5, 0xa1, 0xfe, - 0xa0, 0x3d, 0xfa, 0x3f, 0x19, 0xf2, 0xdf, 0x03, 0xf1, 0x67, 0x47, 0x8d, 0x1a, 0x09, 0x79, 0xc4, - 0x1d, 0xa1, 0x41, 0x19, 0xda, 0x29, 0x4d, 0xa7, 0x3c, 0x3b, 0xf5, 0xbd, 0xf7, 0x53, 0xff, 0x76, - 0xb9, 0xb6, 0xab, 0xdd, 0x9c, 0x2f, 0x20, 0x0d, 0x17, 0x60, 0x52, 0x30, 0x75, 0x19, 0x1b, 0xb1, - 0x09, 0xed, 0x5e, 0x49, 0xc3, 0x9f, 0xb6, 0x36, 0xaa, 0xc4, 0x84, 0xe2, 0xee, 0x6a, 0x6d, 0x2c, - 0xe8, 0x3d, 0x0d, 0x06, 0x68, 0xe4, 0x47, 0xcd, 0x38, 0x5c, 0xe1, 0xa0, 0xfa, 0x65, 0xc9, 0x89, - 0x85, 0xd0, 0xd2, 0x98, 0xfa, 0xb9, 0xcd, 0xf8, 0x93, 0xa1, 0xf5, 0x87, 0x0c, 0xd3, 0x59, 0x76, - 0x66, 0xde, 0xf1, 0xcc, 0x50, 0x96, 0x33, 0x74, 0xc8, 0x19, 0xfa, 0xc8, 0x19, 0x7a, 0x2b, 0x98, - 0x77, 0x28, 0x98, 0x77, 0x2c, 0x98, 0xf7, 0xc2, 0x2f, 0x0c, 0x9b, 0x15, 0x8d, 0xcb, 0x1d, 0x85, - 0xf5, 0x51, 0x5f, 0x9b, 0xc6, 0x99, 0xcf, 0x03, 0x77, 0xad, 0xfb, 0xaf, 0x00, 0x00, 0x00, 0xff, - 0xff, 0x52, 0xc3, 0x85, 0x3a, 0xf4, 0x01, 0x00, 0x00, + // 366 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x92, 0x31, 0x4f, 0xc2, 0x40, + 0x14, 0xc7, 0x7b, 0x50, 0x8a, 0x9e, 0x93, 0x17, 0x62, 0x2e, 0x0c, 0x47, 0xd3, 0xc1, 0xb0, 0x70, + 0x0d, 0x75, 0x75, 0x22, 0xc6, 0xc4, 0xc4, 0x81, 0x74, 0x70, 0x70, 0x2b, 0xf4, 0x04, 0x42, 0xdb, + 0xd7, 0xf4, 0x5a, 0x23, 0xdf, 0xc2, 0x8f, 0xc5, 0xc8, 0x48, 0x1c, 0x88, 0x80, 0x1f, 0xc4, 0xf4, + 0xda, 0x0a, 0x8b, 0x31, 0xea, 0x74, 0xef, 0xbd, 0xfe, 0x7f, 0xf7, 0x7f, 0xbd, 0xf7, 0xf0, 0x79, + 0xe8, 0x25, 0x73, 0x91, 0xda, 0x31, 0x40, 0xc0, 0xe3, 0x04, 0x52, 0x20, 0xed, 0x58, 0x44, 0x7e, + 0x16, 0x64, 0x61, 0xe0, 0x8d, 0x24, 0x2f, 0xbe, 0x97, 0x47, 0xbb, 0x35, 0x81, 0x09, 0x28, 0x99, + 0x9d, 0x47, 0x05, 0x61, 0x7d, 0xd4, 0xb0, 0x3e, 0x04, 0x08, 0x08, 0xc1, 0x7a, 0xec, 0xcd, 0x12, + 0x8a, 0x4c, 0xd4, 0x3d, 0x75, 0x55, 0x4c, 0x2e, 0xb0, 0xe1, 0x8b, 0x08, 0xc2, 0x3e, 0xad, 0xa9, + 0x6a, 0x99, 0x7d, 0xd5, 0x1d, 0x5a, 0x3f, 0xaa, 0x3b, 0xe4, 0x1a, 0x37, 0x9f, 0x21, 0xc8, 0x42, + 0xd1, 0xa7, 0xba, 0x89, 0xba, 0x67, 0x8e, 0xc5, 0xbf, 0x6f, 0x88, 0x3f, 0x28, 0xa9, 0x5b, 0x21, + 0x07, 0xda, 0xa1, 0x8d, 0xdf, 0xd2, 0xca, 0x3b, 0x10, 0x9e, 0x2f, 0x12, 0x49, 0x0d, 0xb3, 0xfe, + 0x13, 0x7d, 0xaf, 0xa4, 0x6e, 0x85, 0x90, 0x1b, 0xdc, 0xf0, 0x13, 0x88, 0x25, 0x6d, 0xe6, 0x3f, + 0x34, 0xe0, 0xcb, 0x4d, 0x47, 0x7b, 0xdb, 0x74, 0x2e, 0x27, 0xb3, 0x74, 0x9a, 0x8d, 0xf8, 0x18, + 0x42, 0x7b, 0x0c, 0x32, 0x04, 0x59, 0x1e, 0x3d, 0xe9, 0xcf, 0xed, 0x74, 0x11, 0x0b, 0xc9, 0xef, + 0xa2, 0xd4, 0x2d, 0x60, 0x42, 0x71, 0x73, 0x3a, 0x93, 0x29, 0x24, 0x0b, 0x7a, 0x62, 0xa2, 0xae, + 0xee, 0x56, 0xa9, 0x35, 0xc5, 0x46, 0x61, 0x99, 0x6b, 0x3c, 0xdf, 0x4f, 0x84, 0x94, 0xe5, 0x53, + 0x57, 0xe9, 0xa1, 0x87, 0xda, 0x3f, 0x7a, 0xb0, 0x9e, 0xb0, 0x51, 0x3c, 0x0d, 0x69, 0xe1, 0x86, + 0x9a, 0x4b, 0xe9, 0x53, 0x24, 0xe4, 0x16, 0x1b, 0x5e, 0x08, 0x59, 0x94, 0xfe, 0xd1, 0xa6, 0xa4, + 0x07, 0xc3, 0xe5, 0x96, 0x69, 0xeb, 0x2d, 0x43, 0xcb, 0x1d, 0x43, 0xab, 0x1d, 0x43, 0xef, 0x3b, + 0x86, 0x5e, 0xf7, 0x4c, 0x5b, 0xed, 0x99, 0xb6, 0xde, 0x33, 0xed, 0x91, 0x1f, 0xdd, 0x58, 0x8d, + 0xa2, 0x97, 0xcf, 0xc2, 0x2e, 0x17, 0xf7, 0xa5, 0x0a, 0xd4, 0xed, 0x23, 0x43, 0x6d, 0xe4, 0xd5, + 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9b, 0xf2, 0x98, 0x47, 0xd8, 0x02, 0x00, 0x00, } func (m *Pool) Marshal() (dAtA []byte, err error) { @@ -158,7 +202,7 @@ func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) { if m.History != 0 { i = encodeVarintPool(dAtA, i, uint64(m.History)) i-- - dAtA[i] = 0x30 + dAtA[i] = 0x40 } { size := m.Drops.Size() @@ -169,7 +213,7 @@ func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPool(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x2a + dAtA[i] = 0x3a if len(m.Leaders) > 0 { for iNdEx := len(m.Leaders) - 1; iNdEx >= 0; iNdEx-- { { @@ -181,8 +225,32 @@ func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintPool(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x22 + dAtA[i] = 0x32 + } + } + if m.Volume2 != nil { + { + size, err := m.Volume2.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } + if m.Volume1 != nil { + { + size, err := m.Volume1.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintPool(dAtA, i, uint64(size)) } + i-- + dAtA[i] = 0x22 } if len(m.Denom2) > 0 { i -= len(m.Denom2) @@ -248,6 +316,46 @@ func (m *Leader) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *Volume) 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 *Volume) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *Volume) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size := m.Amount.Size() + i -= size + if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintPool(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintPool(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func encodeVarintPool(dAtA []byte, offset int, v uint64) int { offset -= sovPool(v) base := offset @@ -277,6 +385,14 @@ func (m *Pool) Size() (n int) { if l > 0 { n += 1 + l + sovPool(uint64(l)) } + if m.Volume1 != nil { + l = m.Volume1.Size() + n += 1 + l + sovPool(uint64(l)) + } + if m.Volume2 != nil { + l = m.Volume2.Size() + n += 1 + l + sovPool(uint64(l)) + } if len(m.Leaders) > 0 { for _, e := range m.Leaders { l = e.Size() @@ -306,6 +422,21 @@ func (m *Leader) Size() (n int) { return n } +func (m *Volume) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovPool(uint64(l)) + } + l = m.Amount.Size() + n += 1 + l + sovPool(uint64(l)) + return n +} + func sovPool(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -438,6 +569,78 @@ func (m *Pool) Unmarshal(dAtA []byte) error { m.Denom2 = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Volume1", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Volume1 == nil { + m.Volume1 = &Volume{} + } + if err := m.Volume1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Volume2", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPool + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthPool + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Volume2 == nil { + m.Volume2 = &Volume{} + } + if err := m.Volume2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Leaders", wireType) } @@ -471,7 +674,7 @@ func (m *Pool) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 5: + case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Drops", wireType) } @@ -505,7 +708,7 @@ func (m *Pool) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 6: + case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field History", wireType) } @@ -661,6 +864,122 @@ func (m *Leader) Unmarshal(dAtA []byte) error { } return nil } +func (m *Volume) 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 ErrIntOverflowPool + } + 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: Volume: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: Volume: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPool + } + 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 ErrInvalidLengthPool + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowPool + } + 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 ErrInvalidLengthPool + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthPool + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipPool(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthPool + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipPool(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/market/types/query.pb.go b/x/market/types/query.pb.go index ca6a81e0..98f79ca8 100644 --- a/x/market/types/query.pb.go +++ b/x/market/types/query.pb.go @@ -297,6 +297,190 @@ func (m *QueryAllPoolResponse) GetPagination() *query.PageResponse { return nil } +type QueryVolumeRequest struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` +} + +func (m *QueryVolumeRequest) Reset() { *m = QueryVolumeRequest{} } +func (m *QueryVolumeRequest) String() string { return proto.CompactTextString(m) } +func (*QueryVolumeRequest) ProtoMessage() {} +func (*QueryVolumeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_dc4839d34748ebb1, []int{6} +} +func (m *QueryVolumeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryVolumeRequest.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 *QueryVolumeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryVolumeRequest.Merge(m, src) +} +func (m *QueryVolumeRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryVolumeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryVolumeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryVolumeRequest proto.InternalMessageInfo + +func (m *QueryVolumeRequest) GetDenom() string { + if m != nil { + return m.Denom + } + return "" +} + +type QueryVolumeResponse struct { + Amount string `protobuf:"bytes,1,opt,name=amount,proto3" json:"amount,omitempty"` +} + +func (m *QueryVolumeResponse) Reset() { *m = QueryVolumeResponse{} } +func (m *QueryVolumeResponse) String() string { return proto.CompactTextString(m) } +func (*QueryVolumeResponse) ProtoMessage() {} +func (*QueryVolumeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_dc4839d34748ebb1, []int{7} +} +func (m *QueryVolumeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryVolumeResponse.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 *QueryVolumeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryVolumeResponse.Merge(m, src) +} +func (m *QueryVolumeResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryVolumeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryVolumeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryVolumeResponse proto.InternalMessageInfo + +func (m *QueryVolumeResponse) GetAmount() string { + if m != nil { + return m.Amount + } + return "" +} + +type QueryAllVolumeRequest struct { + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllVolumeRequest) Reset() { *m = QueryAllVolumeRequest{} } +func (m *QueryAllVolumeRequest) String() string { return proto.CompactTextString(m) } +func (*QueryAllVolumeRequest) ProtoMessage() {} +func (*QueryAllVolumeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_dc4839d34748ebb1, []int{8} +} +func (m *QueryAllVolumeRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllVolumeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllVolumeRequest.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 *QueryAllVolumeRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllVolumeRequest.Merge(m, src) +} +func (m *QueryAllVolumeRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryAllVolumeRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllVolumeRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllVolumeRequest proto.InternalMessageInfo + +func (m *QueryAllVolumeRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +type QueryAllVolumeResponse struct { + Volumes []Volume `protobuf:"bytes,1,rep,name=volumes,proto3" json:"volumes"` + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryAllVolumeResponse) Reset() { *m = QueryAllVolumeResponse{} } +func (m *QueryAllVolumeResponse) String() string { return proto.CompactTextString(m) } +func (*QueryAllVolumeResponse) ProtoMessage() {} +func (*QueryAllVolumeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_dc4839d34748ebb1, []int{9} +} +func (m *QueryAllVolumeResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryAllVolumeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryAllVolumeResponse.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 *QueryAllVolumeResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryAllVolumeResponse.Merge(m, src) +} +func (m *QueryAllVolumeResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryAllVolumeResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryAllVolumeResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryAllVolumeResponse proto.InternalMessageInfo + +func (m *QueryAllVolumeResponse) GetVolumes() []Volume { + if m != nil { + return m.Volumes + } + return nil +} + +func (m *QueryAllVolumeResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + type QueryBurnedRequest struct { } @@ -304,7 +488,7 @@ func (m *QueryBurnedRequest) Reset() { *m = QueryBurnedRequest{} } func (m *QueryBurnedRequest) String() string { return proto.CompactTextString(m) } func (*QueryBurnedRequest) ProtoMessage() {} func (*QueryBurnedRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{6} + return fileDescriptor_dc4839d34748ebb1, []int{10} } func (m *QueryBurnedRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -342,7 +526,7 @@ func (m *QueryBurnedResponse) Reset() { *m = QueryBurnedResponse{} } func (m *QueryBurnedResponse) String() string { return proto.CompactTextString(m) } func (*QueryBurnedResponse) ProtoMessage() {} func (*QueryBurnedResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{7} + return fileDescriptor_dc4839d34748ebb1, []int{11} } func (m *QueryBurnedResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -393,7 +577,7 @@ func (m *QueryDropRequest) Reset() { *m = QueryDropRequest{} } func (m *QueryDropRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropRequest) ProtoMessage() {} func (*QueryDropRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{8} + return fileDescriptor_dc4839d34748ebb1, []int{12} } func (m *QueryDropRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -439,7 +623,7 @@ func (m *QueryDropCoinRequest) Reset() { *m = QueryDropCoinRequest{} } func (m *QueryDropCoinRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropCoinRequest) ProtoMessage() {} func (*QueryDropCoinRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{9} + return fileDescriptor_dc4839d34748ebb1, []int{13} } func (m *QueryDropCoinRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -498,7 +682,7 @@ func (m *QueryDropCoinResponse) Reset() { *m = QueryDropCoinResponse{} } func (m *QueryDropCoinResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropCoinResponse) ProtoMessage() {} func (*QueryDropCoinResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{10} + return fileDescriptor_dc4839d34748ebb1, []int{14} } func (m *QueryDropCoinResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -549,7 +733,7 @@ func (m *QueryDropResponse) Reset() { *m = QueryDropResponse{} } func (m *QueryDropResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropResponse) ProtoMessage() {} func (*QueryDropResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{11} + return fileDescriptor_dc4839d34748ebb1, []int{15} } func (m *QueryDropResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -593,7 +777,7 @@ func (m *QueryDropAmountsRequest) Reset() { *m = QueryDropAmountsRequest func (m *QueryDropAmountsRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropAmountsRequest) ProtoMessage() {} func (*QueryDropAmountsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{12} + return fileDescriptor_dc4839d34748ebb1, []int{16} } func (m *QueryDropAmountsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -640,7 +824,7 @@ func (m *QueryDropAmountsResponse) Reset() { *m = QueryDropAmountsRespon func (m *QueryDropAmountsResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropAmountsResponse) ProtoMessage() {} func (*QueryDropAmountsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{13} + return fileDescriptor_dc4839d34748ebb1, []int{17} } func (m *QueryDropAmountsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -706,7 +890,7 @@ func (m *QueryDropsToCoinsRequest) Reset() { *m = QueryDropsToCoinsReque func (m *QueryDropsToCoinsRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropsToCoinsRequest) ProtoMessage() {} func (*QueryDropsToCoinsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{14} + return fileDescriptor_dc4839d34748ebb1, []int{18} } func (m *QueryDropsToCoinsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -757,7 +941,7 @@ func (m *QueryDropPairsRequest) Reset() { *m = QueryDropPairsRequest{} } func (m *QueryDropPairsRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropPairsRequest) ProtoMessage() {} func (*QueryDropPairsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{15} + return fileDescriptor_dc4839d34748ebb1, []int{19} } func (m *QueryDropPairsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -801,7 +985,7 @@ func (m *QueryDropPairsResponse) Reset() { *m = QueryDropPairsResponse{} func (m *QueryDropPairsResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropPairsResponse) ProtoMessage() {} func (*QueryDropPairsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{16} + return fileDescriptor_dc4839d34748ebb1, []int{20} } func (m *QueryDropPairsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -847,7 +1031,7 @@ func (m *QueryDropOwnerPairRequest) Reset() { *m = QueryDropOwnerPairReq func (m *QueryDropOwnerPairRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropOwnerPairRequest) ProtoMessage() {} func (*QueryDropOwnerPairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{17} + return fileDescriptor_dc4839d34748ebb1, []int{21} } func (m *QueryDropOwnerPairRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -906,7 +1090,7 @@ func (m *QueryDropOwnerPairSumRequest) Reset() { *m = QueryDropOwnerPair func (m *QueryDropOwnerPairSumRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropOwnerPairSumRequest) ProtoMessage() {} func (*QueryDropOwnerPairSumRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{18} + return fileDescriptor_dc4839d34748ebb1, []int{22} } func (m *QueryDropOwnerPairSumRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -957,7 +1141,7 @@ func (m *QueryDropOwnerPairSumResponse) Reset() { *m = QueryDropOwnerPai func (m *QueryDropOwnerPairSumResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropOwnerPairSumResponse) ProtoMessage() {} func (*QueryDropOwnerPairSumResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{19} + return fileDescriptor_dc4839d34748ebb1, []int{23} } func (m *QueryDropOwnerPairSumResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1003,7 +1187,7 @@ func (m *QueryDropOwnerPairUidsRequest) Reset() { *m = QueryDropOwnerPai func (m *QueryDropOwnerPairUidsRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropOwnerPairUidsRequest) ProtoMessage() {} func (*QueryDropOwnerPairUidsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{20} + return fileDescriptor_dc4839d34748ebb1, []int{24} } func (m *QueryDropOwnerPairUidsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1062,7 +1246,7 @@ func (m *QueryUidsResponse) Reset() { *m = QueryUidsResponse{} } func (m *QueryUidsResponse) String() string { return proto.CompactTextString(m) } func (*QueryUidsResponse) ProtoMessage() {} func (*QueryUidsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{21} + return fileDescriptor_dc4839d34748ebb1, []int{25} } func (m *QueryUidsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1115,7 +1299,7 @@ func (m *QueryDropOwnerPairDetailRequest) Reset() { *m = QueryDropOwnerP func (m *QueryDropOwnerPairDetailRequest) String() string { return proto.CompactTextString(m) } func (*QueryDropOwnerPairDetailRequest) ProtoMessage() {} func (*QueryDropOwnerPairDetailRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{22} + return fileDescriptor_dc4839d34748ebb1, []int{26} } func (m *QueryDropOwnerPairDetailRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1173,7 +1357,7 @@ func (m *QueryAllDropRequest) Reset() { *m = QueryAllDropRequest{} } func (m *QueryAllDropRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllDropRequest) ProtoMessage() {} func (*QueryAllDropRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{23} + return fileDescriptor_dc4839d34748ebb1, []int{27} } func (m *QueryAllDropRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1218,7 +1402,7 @@ func (m *QueryDropsResponse) Reset() { *m = QueryDropsResponse{} } func (m *QueryDropsResponse) String() string { return proto.CompactTextString(m) } func (*QueryDropsResponse) ProtoMessage() {} func (*QueryDropsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{24} + return fileDescriptor_dc4839d34748ebb1, []int{28} } func (m *QueryDropsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1270,7 +1454,7 @@ func (m *QueryGetMemberRequest) Reset() { *m = QueryGetMemberRequest{} } func (m *QueryGetMemberRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetMemberRequest) ProtoMessage() {} func (*QueryGetMemberRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{25} + return fileDescriptor_dc4839d34748ebb1, []int{29} } func (m *QueryGetMemberRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1321,7 +1505,7 @@ func (m *QueryGetMemberResponse) Reset() { *m = QueryGetMemberResponse{} func (m *QueryGetMemberResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetMemberResponse) ProtoMessage() {} func (*QueryGetMemberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{26} + return fileDescriptor_dc4839d34748ebb1, []int{30} } func (m *QueryGetMemberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1365,7 +1549,7 @@ func (m *QueryAllMemberRequest) Reset() { *m = QueryAllMemberRequest{} } func (m *QueryAllMemberRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllMemberRequest) ProtoMessage() {} func (*QueryAllMemberRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{27} + return fileDescriptor_dc4839d34748ebb1, []int{31} } func (m *QueryAllMemberRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1410,7 +1594,7 @@ func (m *QueryAllMemberResponse) Reset() { *m = QueryAllMemberResponse{} func (m *QueryAllMemberResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllMemberResponse) ProtoMessage() {} func (*QueryAllMemberResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{28} + return fileDescriptor_dc4839d34748ebb1, []int{32} } func (m *QueryAllMemberResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1461,7 +1645,7 @@ func (m *QueryGetBurningsRequest) Reset() { *m = QueryGetBurningsRequest func (m *QueryGetBurningsRequest) String() string { return proto.CompactTextString(m) } func (*QueryGetBurningsRequest) ProtoMessage() {} func (*QueryGetBurningsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{29} + return fileDescriptor_dc4839d34748ebb1, []int{33} } func (m *QueryGetBurningsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1505,7 +1689,7 @@ func (m *QueryGetBurningsResponse) Reset() { *m = QueryGetBurningsRespon func (m *QueryGetBurningsResponse) String() string { return proto.CompactTextString(m) } func (*QueryGetBurningsResponse) ProtoMessage() {} func (*QueryGetBurningsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{30} + return fileDescriptor_dc4839d34748ebb1, []int{34} } func (m *QueryGetBurningsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1549,7 +1733,7 @@ func (m *QueryAllBurningsRequest) Reset() { *m = QueryAllBurningsRequest func (m *QueryAllBurningsRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllBurningsRequest) ProtoMessage() {} func (*QueryAllBurningsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{31} + return fileDescriptor_dc4839d34748ebb1, []int{35} } func (m *QueryAllBurningsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1594,7 +1778,7 @@ func (m *QueryAllBurningsResponse) Reset() { *m = QueryAllBurningsRespon func (m *QueryAllBurningsResponse) String() string { return proto.CompactTextString(m) } func (*QueryAllBurningsResponse) ProtoMessage() {} func (*QueryAllBurningsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{32} + return fileDescriptor_dc4839d34748ebb1, []int{36} } func (m *QueryAllBurningsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1645,7 +1829,7 @@ func (m *QueryOrderRequest) Reset() { *m = QueryOrderRequest{} } func (m *QueryOrderRequest) String() string { return proto.CompactTextString(m) } func (*QueryOrderRequest) ProtoMessage() {} func (*QueryOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{33} + return fileDescriptor_dc4839d34748ebb1, []int{37} } func (m *QueryOrderRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1689,7 +1873,7 @@ func (m *QueryOrderResponse) Reset() { *m = QueryOrderResponse{} } func (m *QueryOrderResponse) String() string { return proto.CompactTextString(m) } func (*QueryOrderResponse) ProtoMessage() {} func (*QueryOrderResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{34} + return fileDescriptor_dc4839d34748ebb1, []int{38} } func (m *QueryOrderResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1734,7 +1918,7 @@ func (m *QueryOrdersResponse) Reset() { *m = QueryOrdersResponse{} } func (m *QueryOrdersResponse) String() string { return proto.CompactTextString(m) } func (*QueryOrdersResponse) ProtoMessage() {} func (*QueryOrdersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{35} + return fileDescriptor_dc4839d34748ebb1, []int{39} } func (m *QueryOrdersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1785,7 +1969,7 @@ func (m *QueryAllOrderRequest) Reset() { *m = QueryAllOrderRequest{} } func (m *QueryAllOrderRequest) String() string { return proto.CompactTextString(m) } func (*QueryAllOrderRequest) ProtoMessage() {} func (*QueryAllOrderRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{36} + return fileDescriptor_dc4839d34748ebb1, []int{40} } func (m *QueryAllOrderRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1830,7 +2014,7 @@ func (m *QueryOrderOwnerRequest) Reset() { *m = QueryOrderOwnerRequest{} func (m *QueryOrderOwnerRequest) String() string { return proto.CompactTextString(m) } func (*QueryOrderOwnerRequest) ProtoMessage() {} func (*QueryOrderOwnerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{37} + return fileDescriptor_dc4839d34748ebb1, []int{41} } func (m *QueryOrderOwnerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1882,7 +2066,7 @@ func (m *QueryOrderOwnerUidsResponse) Reset() { *m = QueryOrderOwnerUids func (m *QueryOrderOwnerUidsResponse) String() string { return proto.CompactTextString(m) } func (*QueryOrderOwnerUidsResponse) ProtoMessage() {} func (*QueryOrderOwnerUidsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{38} + return fileDescriptor_dc4839d34748ebb1, []int{42} } func (m *QueryOrderOwnerUidsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1935,7 +2119,7 @@ func (m *QueryOrderOwnerPairRequest) Reset() { *m = QueryOrderOwnerPairR func (m *QueryOrderOwnerPairRequest) String() string { return proto.CompactTextString(m) } func (*QueryOrderOwnerPairRequest) ProtoMessage() {} func (*QueryOrderOwnerPairRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{39} + return fileDescriptor_dc4839d34748ebb1, []int{43} } func (m *QueryOrderOwnerPairRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -1994,7 +2178,7 @@ func (m *QueryOrderOwnerPairResponse) Reset() { *m = QueryOrderOwnerPair func (m *QueryOrderOwnerPairResponse) String() string { return proto.CompactTextString(m) } func (*QueryOrderOwnerPairResponse) ProtoMessage() {} func (*QueryOrderOwnerPairResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{40} + return fileDescriptor_dc4839d34748ebb1, []int{44} } func (m *QueryOrderOwnerPairResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2048,7 +2232,7 @@ func (m *QueryBookRequest) Reset() { *m = QueryBookRequest{} } func (m *QueryBookRequest) String() string { return proto.CompactTextString(m) } func (*QueryBookRequest) ProtoMessage() {} func (*QueryBookRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{41} + return fileDescriptor_dc4839d34748ebb1, []int{45} } func (m *QueryBookRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2114,7 +2298,7 @@ func (m *QueryBookResponse) Reset() { *m = QueryBookResponse{} } func (m *QueryBookResponse) String() string { return proto.CompactTextString(m) } func (*QueryBookResponse) ProtoMessage() {} func (*QueryBookResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{42} + return fileDescriptor_dc4839d34748ebb1, []int{46} } func (m *QueryBookResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2168,7 +2352,7 @@ func (m *QueryBookendsRequest) Reset() { *m = QueryBookendsRequest{} } func (m *QueryBookendsRequest) String() string { return proto.CompactTextString(m) } func (*QueryBookendsRequest) ProtoMessage() {} func (*QueryBookendsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{43} + return fileDescriptor_dc4839d34748ebb1, []int{47} } func (m *QueryBookendsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2238,7 +2422,7 @@ func (m *QueryBookendsResponse) Reset() { *m = QueryBookendsResponse{} } func (m *QueryBookendsResponse) String() string { return proto.CompactTextString(m) } func (*QueryBookendsResponse) ProtoMessage() {} func (*QueryBookendsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{44} + return fileDescriptor_dc4839d34748ebb1, []int{48} } func (m *QueryBookendsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2319,7 +2503,7 @@ func (m *QueryHistoryRequest) Reset() { *m = QueryHistoryRequest{} } func (m *QueryHistoryRequest) String() string { return proto.CompactTextString(m) } func (*QueryHistoryRequest) ProtoMessage() {} func (*QueryHistoryRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{45} + return fileDescriptor_dc4839d34748ebb1, []int{49} } func (m *QueryHistoryRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2378,7 +2562,7 @@ func (m *QueryHistoryResponse) Reset() { *m = QueryHistoryResponse{} } func (m *QueryHistoryResponse) String() string { return proto.CompactTextString(m) } func (*QueryHistoryResponse) ProtoMessage() {} func (*QueryHistoryResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{46} + return fileDescriptor_dc4839d34748ebb1, []int{50} } func (m *QueryHistoryResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2433,7 +2617,7 @@ func (m *QueryQuoteRequest) Reset() { *m = QueryQuoteRequest{} } func (m *QueryQuoteRequest) String() string { return proto.CompactTextString(m) } func (*QueryQuoteRequest) ProtoMessage() {} func (*QueryQuoteRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{47} + return fileDescriptor_dc4839d34748ebb1, []int{51} } func (m *QueryQuoteRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2499,7 +2683,7 @@ func (m *QueryQuoteResponse) Reset() { *m = QueryQuoteResponse{} } func (m *QueryQuoteResponse) String() string { return proto.CompactTextString(m) } func (*QueryQuoteResponse) ProtoMessage() {} func (*QueryQuoteResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_dc4839d34748ebb1, []int{48} + return fileDescriptor_dc4839d34748ebb1, []int{52} } func (m *QueryQuoteResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -2549,6 +2733,10 @@ func init() { proto.RegisterType((*QueryGetPoolResponse)(nil), "pendulumlabs.market.market.QueryGetPoolResponse") proto.RegisterType((*QueryAllPoolRequest)(nil), "pendulumlabs.market.market.QueryAllPoolRequest") proto.RegisterType((*QueryAllPoolResponse)(nil), "pendulumlabs.market.market.QueryAllPoolResponse") + proto.RegisterType((*QueryVolumeRequest)(nil), "pendulumlabs.market.market.QueryVolumeRequest") + proto.RegisterType((*QueryVolumeResponse)(nil), "pendulumlabs.market.market.QueryVolumeResponse") + proto.RegisterType((*QueryAllVolumeRequest)(nil), "pendulumlabs.market.market.QueryAllVolumeRequest") + proto.RegisterType((*QueryAllVolumeResponse)(nil), "pendulumlabs.market.market.QueryAllVolumeResponse") proto.RegisterType((*QueryBurnedRequest)(nil), "pendulumlabs.market.market.QueryBurnedRequest") proto.RegisterType((*QueryBurnedResponse)(nil), "pendulumlabs.market.market.QueryBurnedResponse") proto.RegisterType((*QueryDropRequest)(nil), "pendulumlabs.market.market.QueryDropRequest") @@ -2597,132 +2785,138 @@ func init() { func init() { proto.RegisterFile("market/query.proto", fileDescriptor_dc4839d34748ebb1) } var fileDescriptor_dc4839d34748ebb1 = []byte{ - // 1988 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xcf, 0x8f, 0x1b, 0x49, - 0x15, 0x9e, 0x1a, 0x7b, 0x3c, 0x33, 0x35, 0x80, 0xb2, 0xb5, 0xb3, 0x83, 0x31, 0x61, 0x36, 0x5b, - 0x9b, 0x90, 0x9d, 0x64, 0xc7, 0x1d, 0x7b, 0x12, 0x02, 0x2b, 0x96, 0x5d, 0x3b, 0xa3, 0x4c, 0x58, - 0x81, 0x66, 0xe2, 0x5d, 0xb4, 0xd2, 0x4a, 0xfc, 0x68, 0xc7, 0x2d, 0xa7, 0x35, 0xed, 0x2e, 0xa7, - 0xbb, 0xbd, 0xec, 0x60, 0x99, 0x03, 0x12, 0x07, 0x6e, 0xfc, 0x0a, 0x01, 0x45, 0x28, 0x8a, 0x10, - 0x22, 0x82, 0x80, 0x04, 0x27, 0x04, 0x07, 0xc4, 0x2d, 0xc7, 0x48, 0x08, 0x89, 0x13, 0x42, 0x09, - 0x7f, 0xc8, 0xaa, 0xaa, 0x5e, 0x75, 0x57, 0xdb, 0x1e, 0x77, 0xd9, 0x72, 0x94, 0xd3, 0x54, 0x95, - 0xeb, 0xd5, 0xfb, 0xea, 0x7b, 0x5d, 0xaf, 0x5e, 0x7d, 0x1a, 0x4c, 0x3a, 0x76, 0x70, 0xe8, 0x44, - 0xd6, 0xad, 0x9e, 0x13, 0x1c, 0x95, 0xbb, 0x01, 0x8b, 0x18, 0x29, 0x75, 0x1d, 0xbf, 0xd5, 0xf3, - 0x7a, 0x1d, 0xcf, 0x6e, 0x86, 0x65, 0x39, 0x01, 0xfe, 0x94, 0xd6, 0xdb, 0xac, 0xcd, 0xc4, 0x34, - 0x8b, 0xb7, 0xa4, 0x45, 0xe9, 0x64, 0x9b, 0xb1, 0xb6, 0xe7, 0x58, 0x76, 0xd7, 0xb5, 0x6c, 0xdf, - 0x67, 0x91, 0x1d, 0xb9, 0xcc, 0x0f, 0xe1, 0xd7, 0x73, 0x37, 0x58, 0xd8, 0x61, 0xa1, 0xd5, 0xb4, - 0x43, 0x47, 0x3a, 0xb2, 0x3e, 0xac, 0x34, 0x9d, 0xc8, 0xae, 0x58, 0x5d, 0xbb, 0xed, 0xfa, 0x62, - 0x32, 0xcc, 0x7d, 0x11, 0xf0, 0x74, 0xed, 0xc0, 0xee, 0xa8, 0x05, 0x5e, 0x50, 0x83, 0x8c, 0x79, - 0x43, 0x43, 0xad, 0x80, 0x75, 0x87, 0x4c, 0x3b, 0x4e, 0xa7, 0xe9, 0x04, 0x30, 0xf8, 0x12, 0x0c, - 0x36, 0x7b, 0x81, 0xef, 0xfa, 0x6d, 0xb5, 0xa2, 0xda, 0x36, 0x0b, 0x5a, 0x6a, 0x2a, 0x5d, 0xc7, - 0xe4, 0x3a, 0x07, 0x77, 0x20, 0x5c, 0x37, 0x9c, 0x5b, 0x3d, 0x27, 0x8c, 0xe8, 0xfb, 0xf8, 0xc5, - 0xd4, 0x68, 0xd8, 0x65, 0x7e, 0xe8, 0x90, 0xb7, 0x71, 0x41, 0x42, 0x2c, 0xa2, 0x53, 0xe8, 0xb5, - 0xb5, 0x2a, 0x2d, 0x1f, 0x4f, 0x5a, 0x59, 0xda, 0xd6, 0xf3, 0x8f, 0xfe, 0xfb, 0xf2, 0x42, 0x03, - 0xec, 0xe8, 0x16, 0x2c, 0xbc, 0xe7, 0x44, 0x07, 0x8c, 0x79, 0xe0, 0x8f, 0x10, 0x9c, 0xef, 0xda, - 0x6e, 0x20, 0x96, 0x5d, 0x6d, 0x88, 0x36, 0x6d, 0xe0, 0xf5, 0xf4, 0x54, 0x00, 0xf1, 0x06, 0xce, - 0x73, 0x4a, 0x00, 0xc2, 0xa9, 0x89, 0x10, 0x18, 0xf3, 0x00, 0x80, 0xb0, 0xa1, 0xdf, 0x04, 0xf7, - 0x35, 0xcf, 0xd3, 0xdd, 0x5f, 0xc5, 0x38, 0x89, 0x09, 0x2c, 0xfc, 0xf9, 0xb2, 0x0c, 0x60, 0x99, - 0x07, 0xb0, 0x2c, 0xbf, 0x14, 0x08, 0x60, 0xf9, 0xc0, 0x6e, 0x3b, 0x60, 0xdb, 0xd0, 0x2c, 0xe9, - 0x5d, 0x04, 0x98, 0xe3, 0xf5, 0x47, 0x30, 0xe7, 0xa6, 0xc5, 0x4c, 0xf6, 0x52, 0xe0, 0x16, 0x05, - 0xb8, 0xb3, 0x99, 0xe0, 0xa4, 0xe3, 0x14, 0x3a, 0x15, 0xea, 0x7a, 0x2f, 0xf0, 0x9d, 0x96, 0x0a, - 0xf5, 0x15, 0xa0, 0x44, 0x8d, 0x02, 0xe2, 0x75, 0xbc, 0xd4, 0x72, 0x7c, 0xd6, 0x81, 0x90, 0xc8, - 0x0e, 0xd9, 0xc0, 0x05, 0xbb, 0xc3, 0x7a, 0x7e, 0x24, 0x70, 0xac, 0x36, 0xa0, 0x47, 0x4f, 0xe3, - 0x13, 0x62, 0x91, 0xdd, 0x80, 0x75, 0x15, 0xa9, 0x27, 0x70, 0xae, 0xe7, 0xb6, 0x84, 0x7d, 0xbe, - 0xc1, 0x9b, 0xf4, 0x3b, 0xc0, 0x0e, 0x9f, 0x75, 0x85, 0xb9, 0xbe, 0x9a, 0xb9, 0x81, 0x0b, 0x62, - 0xf9, 0x1a, 0x38, 0x83, 0x5e, 0x3c, 0x5e, 0x57, 0xde, 0x64, 0x8f, 0x14, 0xf1, 0xb2, 0xf4, 0x5b, - 0x2b, 0xe6, 0xc4, 0x0f, 0xaa, 0x4b, 0xf7, 0xf0, 0x4b, 0x43, 0x1e, 0xb4, 0xed, 0x04, 0xac, 0x1b, - 0xc6, 0xdb, 0xe1, 0x9d, 0x64, 0x21, 0xe5, 0x41, 0x75, 0xe9, 0x3e, 0x7e, 0x41, 0xdb, 0x50, 0x12, - 0x45, 0x6e, 0x67, 0xf2, 0xe5, 0x71, 0x3b, 0x15, 0x45, 0x6e, 0x43, 0xcf, 0xe3, 0x4f, 0xc7, 0x0b, - 0xd6, 0x84, 0x93, 0xf0, 0x78, 0xa2, 0xbe, 0x8f, 0x8b, 0xa3, 0x93, 0x01, 0x84, 0x22, 0xa5, 0x92, - 0x22, 0xab, 0x12, 0x8f, 0x57, 0x53, 0x64, 0x55, 0x93, 0x3d, 0x56, 0xd2, 0x64, 0x55, 0x92, 0x5f, - 0xaa, 0xc5, 0xbc, 0xfe, 0x4b, 0x95, 0xee, 0x6a, 0xfe, 0xc3, 0xf7, 0x18, 0x67, 0x32, 0x9c, 0x70, - 0x54, 0x13, 0x76, 0x17, 0x35, 0x76, 0x69, 0x45, 0x0b, 0xc6, 0x81, 0xed, 0x06, 0xf1, 0x12, 0xdc, - 0x71, 0xab, 0x15, 0x38, 0xa1, 0x0a, 0x87, 0xea, 0xd2, 0x32, 0xde, 0x18, 0x36, 0x49, 0x02, 0xc8, - 0x5d, 0x85, 0xe2, 0x08, 0xad, 0x36, 0x64, 0x87, 0xfe, 0x04, 0xe1, 0xcf, 0xc4, 0x06, 0xfb, 0xdf, - 0xf5, 0x9d, 0x80, 0x5b, 0x65, 0xfa, 0x89, 0x37, 0xb1, 0xa8, 0x6d, 0x22, 0x9d, 0x04, 0x72, 0x33, - 0x27, 0x81, 0xaf, 0xe1, 0x93, 0xa3, 0x90, 0xde, 0xed, 0x75, 0x66, 0x42, 0x45, 0x2b, 0xf8, 0x73, - 0xc7, 0xac, 0x06, 0xc4, 0x9c, 0xc0, 0xb9, 0xb0, 0xa7, 0x8e, 0x29, 0x6f, 0xd2, 0xdb, 0x68, 0x9c, - 0xcd, 0x37, 0xdc, 0x56, 0xf8, 0x7c, 0x89, 0xe9, 0xc2, 0x99, 0x92, 0x48, 0x00, 0x3e, 0xc1, 0xf9, - 0x9e, 0xdb, 0x92, 0x61, 0xcd, 0x37, 0x44, 0x7b, 0x7e, 0x19, 0xef, 0x0e, 0xc2, 0x2f, 0x8f, 0x32, - 0xb1, 0xeb, 0x44, 0xb6, 0xeb, 0x3d, 0x5f, 0x2e, 0xb4, 0x8b, 0x48, 0xcf, 0x99, 0x73, 0xbc, 0x88, - 0x48, 0x72, 0x82, 0x63, 0xb2, 0xbf, 0x9c, 0x64, 0xc1, 0xdc, 0x14, 0x19, 0x0c, 0xb2, 0xe5, 0xdc, - 0xc2, 0xa2, 0xb2, 0xf4, 0x9e, 0x13, 0x7d, 0x5d, 0x94, 0x2d, 0xa3, 0x17, 0xc1, 0xe2, 0x31, 0x17, - 0x41, 0x4e, 0xbf, 0x08, 0xe8, 0x07, 0x90, 0x2e, 0xb4, 0x85, 0x92, 0x4a, 0x45, 0x56, 0x44, 0x26, - 0x95, 0x8a, 0xb4, 0x55, 0x95, 0x8a, 0xb4, 0xa3, 0xdf, 0x06, 0x90, 0x35, 0xcf, 0x4b, 0x83, 0x9c, - 0x57, 0x8c, 0x7e, 0x83, 0x00, 0xbd, 0xe6, 0x61, 0x0c, 0xfa, 0xdc, 0x2c, 0xe8, 0xe7, 0x17, 0x2b, - 0x0b, 0xee, 0xad, 0x3d, 0x27, 0xaa, 0x43, 0x35, 0xa9, 0x88, 0x18, 0x5b, 0x22, 0xd0, 0x26, 0xdc, - 0x1d, 0x29, 0x03, 0xd8, 0xd7, 0x55, 0xbc, 0xa2, 0x4a, 0x52, 0x20, 0xee, 0xf4, 0xa4, 0x9d, 0x29, - 0x7b, 0xd8, 0x5b, 0x6c, 0x4b, 0x6d, 0x00, 0x55, 0xf3, 0xbc, 0x61, 0x50, 0xf3, 0x8a, 0xce, 0x1f, - 0x10, 0xec, 0x23, 0xe5, 0x63, 0xec, 0x3e, 0x72, 0xb3, 0xee, 0x63, 0x7e, 0x51, 0x3a, 0x03, 0xa9, - 0x75, 0x9f, 0x57, 0xf6, 0xc7, 0xd7, 0x15, 0xef, 0x42, 0x56, 0x80, 0x69, 0xb0, 0x9b, 0x37, 0xf1, - 0x92, 0x78, 0x11, 0x00, 0x5b, 0xaf, 0x4c, 0xda, 0x8a, 0xb0, 0x54, 0x69, 0x41, 0x58, 0xd1, 0x7b, - 0x08, 0x72, 0x99, 0xf8, 0x2d, 0x21, 0xe9, 0x2d, 0x5c, 0x10, 0x13, 0x14, 0x45, 0xc6, 0xeb, 0x82, - 0xd9, 0xfc, 0xd8, 0xf9, 0x56, 0x52, 0x95, 0xa7, 0x08, 0x9a, 0xd7, 0xb7, 0xf2, 0x3d, 0x38, 0xc8, - 0x62, 0x71, 0x71, 0xcd, 0x64, 0x5f, 0x2e, 0x57, 0xc7, 0x6c, 0x6e, 0x16, 0xdf, 0x0f, 0x10, 0xfe, - 0xec, 0x90, 0xf3, 0xd4, 0xfd, 0xfa, 0xb6, 0x16, 0x85, 0xcc, 0x44, 0x28, 0x23, 0xf8, 0xac, 0xc2, - 0xf0, 0x53, 0x84, 0x4b, 0x43, 0x50, 0x9f, 0x7f, 0xb5, 0xf6, 0xdb, 0x51, 0xfe, 0x24, 0xa8, 0xd1, - 0xc3, 0x91, 0x9b, 0xfe, 0x70, 0xcc, 0x8f, 0xbc, 0x07, 0x08, 0x9e, 0x58, 0x75, 0xc6, 0x0e, 0x67, - 0x7d, 0x38, 0x9d, 0xc4, 0xab, 0x02, 0xd6, 0x7b, 0x47, 0x5d, 0x07, 0xae, 0xd2, 0x64, 0x60, 0x88, - 0xd2, 0xfc, 0xcc, 0x94, 0xde, 0x47, 0x90, 0x8d, 0x24, 0x54, 0x20, 0xf2, 0x0a, 0xce, 0x37, 0x19, - 0x3b, 0x04, 0x1e, 0xb7, 0x32, 0x79, 0x54, 0x86, 0xea, 0x15, 0xc5, 0x8d, 0xe7, 0x47, 0x67, 0x04, - 0x29, 0x81, 0x43, 0x74, 0xfc, 0x96, 0x7e, 0xa7, 0xdd, 0x60, 0xae, 0xaf, 0x08, 0x95, 0x1d, 0x35, - 0xaa, 0xe8, 0x94, 0x9d, 0x0c, 0x36, 0x09, 0xce, 0x07, 0x76, 0xe4, 0x14, 0xf3, 0xe2, 0xbd, 0x22, - 0xda, 0xf4, 0xd7, 0x08, 0x8a, 0x8a, 0xc4, 0x6d, 0xf2, 0xbc, 0x79, 0x76, 0x7e, 0xc5, 0x01, 0x0a, - 0x9c, 0x0f, 0x8b, 0x4b, 0xe2, 0x2a, 0x10, 0x6d, 0x3e, 0xe6, 0x3b, 0x1f, 0x45, 0xc5, 0x82, 0x1c, - 0xe3, 0x6d, 0xfa, 0x23, 0x95, 0xca, 0xaf, 0xb9, 0x61, 0xc4, 0x82, 0xa3, 0x49, 0x6f, 0xbe, 0x0d, - 0x5c, 0xf0, 0x1c, 0xbf, 0x1d, 0xdd, 0x54, 0xdf, 0x98, 0xec, 0xcd, 0xed, 0x60, 0xfe, 0x5e, 0x69, - 0x29, 0x31, 0x16, 0xa0, 0xea, 0xab, 0x78, 0xf9, 0xa6, 0x1c, 0x9a, 0xf5, 0x5b, 0x52, 0xf6, 0xf3, - 0xfb, 0x9c, 0x7e, 0xa8, 0x3e, 0xf9, 0xeb, 0x3d, 0x16, 0xa9, 0xed, 0x90, 0x12, 0x5e, 0x91, 0x07, - 0x32, 0x3c, 0x04, 0xea, 0xe2, 0x7e, 0xfc, 0x5b, 0xdd, 0x6d, 0x01, 0x81, 0x71, 0x9f, 0x9c, 0xc2, - 0x6b, 0x72, 0x9e, 0x94, 0x5a, 0x64, 0x88, 0xf5, 0x21, 0x4d, 0x87, 0xc9, 0xa7, 0x74, 0x98, 0x3a, - 0x5c, 0xf0, 0x00, 0x63, 0x16, 0x2d, 0xa7, 0xfa, 0xef, 0x4d, 0xbc, 0x24, 0x16, 0x21, 0xbf, 0x40, - 0xb8, 0x20, 0x55, 0x3c, 0x52, 0x9e, 0xc4, 0xf1, 0xa8, 0x80, 0x58, 0xb2, 0x8c, 0xe7, 0x4b, 0x8c, - 0xf4, 0xfc, 0x0f, 0xfe, 0xf5, 0xff, 0x9f, 0x2d, 0x9e, 0x21, 0xaf, 0x5a, 0xca, 0x70, 0x9b, 0x5b, - 0x5a, 0x4a, 0xde, 0xd4, 0x05, 0x52, 0x01, 0x4c, 0xea, 0x55, 0x06, 0xc0, 0x52, 0x72, 0x97, 0x01, - 0xb0, 0xb4, 0x10, 0x66, 0x08, 0xac, 0x29, 0xd1, 0xdc, 0x45, 0x38, 0x7f, 0xc0, 0x98, 0x47, 0xb2, - 0xdd, 0xa4, 0x15, 0xd0, 0xd2, 0x05, 0x73, 0x03, 0x00, 0x76, 0x41, 0x00, 0x3b, 0x47, 0x5e, 0x9b, - 0xcc, 0x18, 0x63, 0x9e, 0xd5, 0xe7, 0x27, 0x76, 0x40, 0xee, 0x20, 0xbc, 0xcc, 0x97, 0xa8, 0x79, - 0x26, 0x00, 0xd3, 0x1a, 0xa9, 0x01, 0xc0, 0x21, 0xd1, 0x93, 0x6e, 0x09, 0x80, 0xaf, 0x92, 0x57, - 0x32, 0x01, 0x92, 0x9f, 0x23, 0x9c, 0xe7, 0x0f, 0x4e, 0xf2, 0x7a, 0xa6, 0x17, 0xed, 0xb9, 0x5c, - 0xda, 0x36, 0x9c, 0x0d, 0x80, 0x2c, 0x01, 0x68, 0x8b, 0x9c, 0x9d, 0x08, 0x88, 0x3f, 0x76, 0xad, - 0x7e, 0xcf, 0x6d, 0x0d, 0xc8, 0x9f, 0x11, 0x5e, 0xd3, 0x34, 0x38, 0xb2, 0x63, 0xe4, 0x2f, 0x2d, - 0xef, 0x95, 0x2e, 0x4e, 0x67, 0x04, 0x58, 0x2f, 0x0b, 0xac, 0x15, 0x62, 0x65, 0x63, 0x95, 0xe7, - 0x36, 0x04, 0xcc, 0x7f, 0x47, 0x78, 0x45, 0xc9, 0x9f, 0xe4, 0x82, 0x91, 0x6f, 0x4d, 0x8b, 0x2d, - 0x55, 0xa6, 0xb0, 0x00, 0xa8, 0xef, 0x08, 0xa8, 0xbb, 0xa4, 0x9e, 0x0d, 0x95, 0x5f, 0x60, 0x56, - 0x5f, 0x66, 0xb2, 0x01, 0x34, 0xea, 0x03, 0xab, 0x0f, 0xfa, 0xed, 0x80, 0xfc, 0x0d, 0xe1, 0x4f, - 0xe8, 0xaa, 0x23, 0x31, 0x63, 0x6f, 0x48, 0xa4, 0x9c, 0x91, 0xf3, 0xaf, 0x88, 0x8d, 0x7c, 0x91, - 0x7c, 0xc1, 0x6c, 0x23, 0x21, 0x9c, 0x2b, 0xab, 0x2f, 0xf4, 0x91, 0x01, 0xf9, 0x23, 0xc2, 0xab, - 0xb1, 0x72, 0x49, 0xcc, 0x98, 0xd4, 0x85, 0xd1, 0x52, 0x75, 0x1a, 0x13, 0x00, 0xfd, 0x25, 0x01, - 0x7a, 0x87, 0x54, 0xb2, 0x41, 0x0b, 0xcd, 0xd4, 0xea, 0x43, 0x59, 0x3d, 0x20, 0x7f, 0x41, 0xf8, - 0x93, 0x29, 0x65, 0x8c, 0x5c, 0x32, 0x02, 0x30, 0x5c, 0xba, 0x97, 0xca, 0x66, 0x41, 0x8a, 0x31, - 0xbf, 0x21, 0x30, 0x5f, 0x24, 0x55, 0x83, 0x83, 0xa8, 0xd0, 0xaa, 0x24, 0x76, 0x1b, 0xe1, 0x65, - 0x11, 0x3c, 0xd3, 0x24, 0xa6, 0x27, 0x8c, 0x69, 0x81, 0x9a, 0xa5, 0x30, 0x0e, 0x94, 0xfc, 0x09, - 0xe1, 0x82, 0x94, 0x62, 0x0c, 0x22, 0x3f, 0xac, 0x7c, 0x19, 0x44, 0x7e, 0x44, 0xe3, 0xa2, 0x6f, - 0x0a, 0x70, 0x97, 0xc9, 0xa5, 0x89, 0xe0, 0xa4, 0x20, 0x34, 0x7a, 0xe8, 0xc8, 0x3d, 0x84, 0x57, - 0xe5, 0x8a, 0x9c, 0xca, 0x8a, 0x09, 0x95, 0xd3, 0x62, 0x1e, 0x51, 0xb6, 0x0c, 0x6f, 0x53, 0x10, - 0xb1, 0x1e, 0x22, 0xbc, 0xa2, 0xb4, 0x13, 0x83, 0xdc, 0x3b, 0x2a, 0x51, 0x19, 0xe4, 0x81, 0x31, - 0x32, 0x15, 0xbd, 0x24, 0x40, 0x5a, 0x64, 0x3b, 0xf3, 0xca, 0xe7, 0x66, 0xc0, 0xe8, 0x80, 0xfc, - 0x0e, 0xe1, 0x35, 0xb5, 0x16, 0xa7, 0x74, 0xc7, 0x84, 0x9f, 0xe9, 0x11, 0x8f, 0x11, 0xa4, 0xe8, - 0xb6, 0x40, 0x7c, 0x96, 0x9c, 0x31, 0x42, 0x4c, 0x7e, 0x89, 0xf0, 0x92, 0x28, 0x8c, 0x49, 0xf6, - 0x0d, 0xaa, 0x2b, 0x26, 0x06, 0xe7, 0x27, 0x55, 0x6f, 0x1b, 0xd6, 0x28, 0xe2, 0xf1, 0x02, 0xd7, - 0xd7, 0xaf, 0x10, 0x5e, 0x11, 0x6b, 0x70, 0x06, 0x8d, 0x6a, 0x8e, 0x14, 0x40, 0xcb, 0x0c, 0x60, - 0xc2, 0xdc, 0x39, 0x81, 0xf0, 0x34, 0xa1, 0xd9, 0x08, 0x79, 0x80, 0x71, 0x22, 0x13, 0x90, 0xaa, - 0x99, 0x2f, 0x5d, 0x10, 0x9a, 0x1e, 0xdf, 0x45, 0x81, 0xaf, 0x4c, 0x5e, 0x37, 0x61, 0x30, 0xce, - 0xec, 0x7f, 0x45, 0xf8, 0x53, 0x69, 0x41, 0x68, 0x26, 0xb4, 0x97, 0xa7, 0xb0, 0xd1, 0x55, 0x27, - 0xc3, 0x4b, 0x49, 0xa2, 0xee, 0xb9, 0x2d, 0xfd, 0x52, 0x7a, 0x88, 0x70, 0x9e, 0x3f, 0x8f, 0x0d, - 0x4a, 0x41, 0x4d, 0x0a, 0x31, 0x28, 0x05, 0x75, 0x35, 0x82, 0xee, 0x09, 0x80, 0x35, 0xf2, 0xd6, - 0xe4, 0x03, 0xc3, 0xd8, 0xe1, 0xb8, 0x72, 0x25, 0x7e, 0x6d, 0x0f, 0xc8, 0x3f, 0x79, 0x8e, 0x82, - 0xd7, 0xbc, 0xc1, 0xf7, 0x3a, 0xa4, 0x37, 0x18, 0x94, 0x5b, 0xc3, 0x52, 0x01, 0x3d, 0x10, 0xd0, - 0xdf, 0x21, 0xd7, 0x32, 0xa1, 0x73, 0x33, 0xab, 0x2f, 0xa4, 0x84, 0x81, 0xfc, 0x9b, 0x06, 0x6f, - 0xf5, 0x03, 0x3b, 0x72, 0x06, 0xe4, 0x3e, 0xc2, 0xcb, 0xf0, 0xca, 0x36, 0xb8, 0x52, 0xd3, 0xda, - 0x80, 0xc1, 0xbb, 0x60, 0xe8, 0x01, 0x4f, 0x77, 0xc4, 0x06, 0xb6, 0xc9, 0xf9, 0x89, 0x1b, 0x80, - 0x37, 0xba, 0xba, 0xf6, 0xff, 0x81, 0xf8, 0xab, 0x94, 0x45, 0x8e, 0x41, 0xca, 0xd2, 0x1f, 0xe1, - 0x06, 0x29, 0x2b, 0xf5, 0x58, 0xa6, 0xef, 0x0b, 0x74, 0xd7, 0xc9, 0xfe, 0x44, 0x74, 0xb7, 0xb8, - 0x8d, 0xfa, 0x22, 0xdc, 0x96, 0xfa, 0x38, 0x6a, 0xe1, 0x61, 0xdc, 0x14, 0xc5, 0x65, 0x5c, 0xdb, - 0x0e, 0xea, 0xd7, 0x1e, 0x3d, 0xd9, 0x44, 0x8f, 0x9f, 0x6c, 0xa2, 0xff, 0x3d, 0xd9, 0x44, 0x3f, - 0x7e, 0xba, 0xb9, 0xf0, 0xf8, 0xe9, 0xe6, 0xc2, 0x7f, 0x9e, 0x6e, 0x2e, 0x7c, 0x50, 0x6e, 0xbb, - 0xd1, 0xcd, 0x5e, 0xb3, 0x7c, 0x83, 0x75, 0xc6, 0x3b, 0xfd, 0x48, 0x35, 0xa2, 0xa3, 0xae, 0x13, - 0x36, 0x0b, 0xe2, 0x5f, 0x77, 0x76, 0x3e, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x47, 0xf9, 0x51, 0x7d, - 0xc7, 0x24, 0x00, 0x00, + // 2081 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0xdd, 0x8f, 0x5b, 0x47, + 0x15, 0xcf, 0xac, 0xbd, 0xde, 0xdd, 0x09, 0xa0, 0x74, 0x9a, 0x06, 0x63, 0xc2, 0x36, 0x99, 0x26, + 0xa4, 0x49, 0xba, 0xbe, 0xb1, 0x37, 0x21, 0x50, 0x51, 0x5a, 0x3b, 0xab, 0x6c, 0xa8, 0x40, 0xbb, + 0x71, 0x0b, 0x95, 0x2a, 0xf1, 0x71, 0x9d, 0x7b, 0xe5, 0x5c, 0xed, 0xf5, 0x1d, 0xe7, 0x7e, 0x84, + 0x2e, 0x96, 0x79, 0x40, 0xe2, 0x81, 0x37, 0xbe, 0x4a, 0x8b, 0x2a, 0xa8, 0x2a, 0x54, 0x51, 0x41, + 0x41, 0x82, 0x27, 0x04, 0x0f, 0x88, 0xb7, 0x3e, 0x56, 0xe2, 0x85, 0x27, 0x84, 0x12, 0xfe, 0x10, + 0x34, 0x33, 0x67, 0xee, 0x9d, 0x6b, 0x7b, 0x7d, 0xc7, 0x96, 0xa3, 0x3c, 0xed, 0x9d, 0xf1, 0x9c, + 0x39, 0xbf, 0xf9, 0x9d, 0x99, 0x73, 0x66, 0x7e, 0x5a, 0x4c, 0xfa, 0x76, 0x78, 0xe0, 0xc6, 0xd6, + 0xbd, 0xc4, 0x0d, 0x0f, 0xeb, 0x83, 0x90, 0xc5, 0x8c, 0xd4, 0x06, 0x6e, 0xe0, 0x24, 0x7e, 0xd2, + 0xf7, 0xed, 0x6e, 0x54, 0x97, 0x03, 0xe0, 0x4f, 0xed, 0x64, 0x8f, 0xf5, 0x98, 0x18, 0x66, 0xf1, + 0x2f, 0x69, 0x51, 0x3b, 0xdd, 0x63, 0xac, 0xe7, 0xbb, 0x96, 0x3d, 0xf0, 0x2c, 0x3b, 0x08, 0x58, + 0x6c, 0xc7, 0x1e, 0x0b, 0x22, 0xf8, 0xf5, 0xd2, 0x1d, 0x16, 0xf5, 0x59, 0x64, 0x75, 0xed, 0xc8, + 0x95, 0x8e, 0xac, 0xfb, 0x8d, 0xae, 0x1b, 0xdb, 0x0d, 0x6b, 0x60, 0xf7, 0xbc, 0x40, 0x0c, 0x86, + 0xb1, 0x4f, 0x02, 0x9e, 0x81, 0x1d, 0xda, 0x7d, 0x35, 0xc1, 0x13, 0xaa, 0x93, 0x31, 0x7f, 0xac, + 0xcb, 0x09, 0xd9, 0x60, 0xcc, 0xb4, 0xef, 0xf6, 0xbb, 0x6e, 0x08, 0x9d, 0x4f, 0x41, 0x67, 0x37, + 0x09, 0x03, 0x2f, 0xe8, 0xa9, 0x19, 0xd5, 0xb2, 0x59, 0xe8, 0xa8, 0xa1, 0xf4, 0x24, 0x26, 0xb7, + 0x39, 0xb8, 0x7d, 0xe1, 0xba, 0xe3, 0xde, 0x4b, 0xdc, 0x28, 0xa6, 0xaf, 0xe1, 0x27, 0x73, 0xbd, + 0xd1, 0x80, 0x05, 0x91, 0x4b, 0x5e, 0xc2, 0x15, 0x09, 0xb1, 0x8a, 0xce, 0xa0, 0x67, 0x8f, 0x37, + 0x69, 0xfd, 0x68, 0xd2, 0xea, 0xd2, 0xb6, 0x5d, 0xfe, 0xe8, 0x3f, 0x4f, 0x1f, 0xeb, 0x80, 0x1d, + 0xbd, 0x08, 0x13, 0xef, 0xba, 0xf1, 0x3e, 0x63, 0x3e, 0xf8, 0x23, 0x04, 0x97, 0x07, 0xb6, 0x17, + 0x8a, 0x69, 0x37, 0x3a, 0xe2, 0x9b, 0x76, 0xf0, 0xc9, 0xfc, 0x50, 0x00, 0xf1, 0x3c, 0x2e, 0x73, + 0x4a, 0x00, 0xc2, 0x99, 0x99, 0x10, 0x18, 0xf3, 0x01, 0x80, 0xb0, 0xa1, 0xdf, 0x02, 0xf7, 0x2d, + 0xdf, 0xd7, 0xdd, 0xdf, 0xc4, 0x38, 0x8b, 0x09, 0x4c, 0xfc, 0xf9, 0xba, 0x0c, 0x60, 0x9d, 0x07, + 0xb0, 0x2e, 0x77, 0x0a, 0x04, 0xb0, 0xbe, 0x6f, 0xf7, 0x5c, 0xb0, 0xed, 0x68, 0x96, 0xf4, 0x1d, + 0x04, 0x98, 0xd3, 0xf9, 0x27, 0x30, 0x97, 0xe6, 0xc5, 0x4c, 0x76, 0x73, 0xe0, 0x56, 0x04, 0xb8, + 0x0b, 0x85, 0xe0, 0xa4, 0xe3, 0x1c, 0xba, 0x4b, 0x10, 0xea, 0x6f, 0x32, 0x3f, 0xe9, 0x2b, 0xfc, + 0xe4, 0x24, 0x5e, 0x75, 0xdc, 0x80, 0xf5, 0x81, 0x7b, 0xd9, 0xa0, 0x5b, 0x40, 0x94, 0x1a, 0x0b, + 0xeb, 0x38, 0x85, 0x2b, 0x76, 0x9f, 0x25, 0x41, 0x0c, 0xa3, 0xa1, 0x45, 0xbf, 0x83, 0x9f, 0x52, + 0xeb, 0xce, 0xcf, 0xbe, 0x2c, 0x66, 0xdf, 0x47, 0xf8, 0xd4, 0xb8, 0x07, 0xc0, 0xd4, 0xc6, 0x6b, + 0xf7, 0x45, 0x4f, 0x04, 0xf4, 0xce, 0xdc, 0x95, 0xd2, 0x18, 0x08, 0x56, 0x86, 0xcb, 0xe3, 0x58, + 0x1d, 0xa7, 0x76, 0x12, 0x06, 0xae, 0xa3, 0x8e, 0xd3, 0x0d, 0x60, 0x53, 0xf5, 0x02, 0xf2, 0xa9, + 0xd4, 0x6b, 0x1c, 0xaf, 0xe4, 0x38, 0x3e, 0x87, 0x4f, 0x88, 0x49, 0x76, 0x42, 0x36, 0x50, 0xf4, + 0x9e, 0xc0, 0xa5, 0xc4, 0x73, 0x84, 0x7d, 0xb9, 0xc3, 0x3f, 0xe9, 0x77, 0x61, 0x07, 0xf2, 0x51, + 0x37, 0x98, 0x17, 0xa8, 0x91, 0xa7, 0x70, 0x45, 0x4c, 0xdf, 0x52, 0x91, 0x93, 0xad, 0xb4, 0xbf, + 0xad, 0xbc, 0xc9, 0x16, 0xa9, 0xe2, 0x35, 0xe9, 0xb7, 0x55, 0x2d, 0x89, 0x1f, 0x54, 0x93, 0xee, + 0x42, 0xac, 0x33, 0x0f, 0xda, 0x72, 0x42, 0x36, 0x88, 0xd2, 0xe5, 0xf0, 0x46, 0x36, 0x91, 0xf2, + 0xa0, 0x9a, 0x74, 0x0f, 0x3f, 0xa1, 0x2d, 0x28, 0x3b, 0x29, 0xdc, 0xce, 0xe4, 0x74, 0x73, 0x3b, + 0x75, 0x52, 0xb8, 0x0d, 0xbd, 0x8c, 0x3f, 0x9d, 0x4e, 0xd8, 0x12, 0x4e, 0xa2, 0xa3, 0x89, 0xfa, + 0x01, 0xae, 0x4e, 0x0e, 0xce, 0xb6, 0xb9, 0xa0, 0xa1, 0x91, 0x23, 0xab, 0x91, 0xf6, 0x37, 0x73, + 0x64, 0x35, 0xb3, 0x35, 0x36, 0xf2, 0x64, 0x35, 0xb2, 0x5f, 0x9a, 0xd5, 0xb2, 0xfe, 0x4b, 0x93, + 0xee, 0x68, 0xfe, 0xa3, 0x57, 0x19, 0x67, 0x32, 0x9a, 0x91, 0x0e, 0x33, 0x76, 0x57, 0x34, 0x76, + 0x69, 0x43, 0x0b, 0xc6, 0xbe, 0xed, 0x85, 0xe9, 0x14, 0xdc, 0xb1, 0xe3, 0x84, 0x6e, 0xa4, 0xc2, + 0xa1, 0x9a, 0xb4, 0x0e, 0x27, 0x49, 0x33, 0xc9, 0x02, 0xc8, 0x5d, 0xc9, 0x73, 0xb4, 0xd1, 0x91, + 0x0d, 0xfa, 0x53, 0x84, 0x3f, 0x93, 0x1a, 0xec, 0x7d, 0x2f, 0x70, 0x43, 0x6e, 0x55, 0xe8, 0x27, + 0x5d, 0xc4, 0x8a, 0xb6, 0x88, 0x7c, 0x3a, 0x28, 0x2d, 0x9c, 0x0e, 0xbe, 0x86, 0x4f, 0x4f, 0x42, + 0x7a, 0x25, 0xe9, 0x2f, 0x84, 0x8a, 0x36, 0xf0, 0xe7, 0x8e, 0x98, 0x0d, 0x88, 0x39, 0x81, 0x4b, + 0x51, 0xa2, 0x8e, 0x29, 0xff, 0xa4, 0x6f, 0xa2, 0x69, 0x36, 0xdf, 0xf0, 0x9c, 0xe8, 0xf1, 0x12, + 0x33, 0x80, 0x33, 0x25, 0x91, 0x00, 0x7c, 0x82, 0xcb, 0x89, 0xe7, 0xc8, 0xb0, 0x96, 0x3b, 0xe2, + 0x7b, 0x79, 0x19, 0xef, 0x2d, 0x84, 0x9f, 0x9e, 0x64, 0x62, 0xc7, 0x8d, 0x6d, 0xcf, 0x7f, 0xbc, + 0x5c, 0x68, 0xc5, 0x5e, 0xcf, 0x99, 0x4b, 0x2c, 0xf6, 0x24, 0x3b, 0xc1, 0x29, 0xd9, 0x5f, 0xce, + 0xb2, 0x60, 0x69, 0x8e, 0x0c, 0x06, 0xd9, 0x72, 0x69, 0x61, 0x51, 0x59, 0x7a, 0xd7, 0x8d, 0xbf, + 0x2e, 0xae, 0x86, 0x93, 0x85, 0x60, 0xe5, 0x88, 0x42, 0x50, 0xd2, 0x0b, 0x01, 0x7d, 0x1d, 0xd2, + 0x85, 0x36, 0x51, 0x76, 0x1b, 0x94, 0xb7, 0x4e, 0x93, 0xdb, 0xa0, 0xb4, 0x55, 0xb7, 0x41, 0x69, + 0xa7, 0x5f, 0x1b, 0xf2, 0x20, 0x97, 0x15, 0xa3, 0xdf, 0x6a, 0xd7, 0x86, 0x19, 0xe8, 0x4b, 0x8b, + 0xa0, 0x5f, 0x5e, 0xac, 0x2c, 0xa8, 0x5b, 0xbb, 0x6e, 0xdc, 0x86, 0x1b, 0xfb, 0xec, 0xdb, 0x59, + 0x17, 0x6a, 0x47, 0xce, 0x00, 0xd6, 0x75, 0x13, 0xaf, 0xab, 0x6b, 0x3f, 0x10, 0x77, 0x6e, 0xd6, + 0xca, 0x94, 0x3d, 0xac, 0x2d, 0xb5, 0xa5, 0x36, 0x80, 0x6a, 0xf9, 0xfe, 0x38, 0xa8, 0x65, 0x45, + 0xe7, 0x0f, 0x08, 0xd6, 0x91, 0xf3, 0x31, 0x75, 0x1d, 0xa5, 0x45, 0xd7, 0xb1, 0xbc, 0x28, 0x9d, + 0x87, 0xd4, 0xba, 0xc7, 0x5f, 0x4f, 0x47, 0xdf, 0x2b, 0x5e, 0x81, 0xac, 0x00, 0xc3, 0x60, 0x35, + 0x2f, 0xe0, 0x55, 0xf1, 0xea, 0x02, 0xb6, 0xce, 0xce, 0x5a, 0x8a, 0xb0, 0x54, 0x69, 0x41, 0x58, + 0xd1, 0x77, 0x11, 0xe4, 0x32, 0xf1, 0x5b, 0x46, 0xd2, 0x8b, 0xb8, 0x22, 0x06, 0x28, 0x8a, 0x8c, + 0xe7, 0x05, 0xb3, 0xe5, 0xb1, 0xf3, 0xed, 0xec, 0xe5, 0x93, 0x23, 0x68, 0x59, 0x7b, 0xe5, 0xfb, + 0x70, 0x90, 0xc5, 0xe4, 0xa2, 0xcc, 0x14, 0x17, 0x97, 0x9b, 0x53, 0x16, 0xb7, 0x88, 0xef, 0x0f, + 0x10, 0xfe, 0xec, 0x98, 0xf3, 0x5c, 0x7d, 0x7d, 0x49, 0x8b, 0x42, 0x61, 0x22, 0x94, 0x11, 0x7c, + 0x54, 0x61, 0xf8, 0x19, 0xc2, 0xb5, 0x31, 0xa8, 0x8f, 0xff, 0xb6, 0xf6, 0xfe, 0x24, 0x7f, 0x12, + 0xd4, 0xe4, 0xe1, 0x28, 0xcd, 0x7f, 0x38, 0x96, 0x47, 0xde, 0x07, 0x08, 0x9e, 0x58, 0x6d, 0xc6, + 0x0e, 0x16, 0x7d, 0x38, 0x9d, 0xc6, 0x1b, 0x02, 0xd6, 0xab, 0x87, 0x03, 0x17, 0x4a, 0x69, 0xd6, + 0x31, 0x46, 0x69, 0x79, 0x61, 0x4a, 0xdf, 0x43, 0x90, 0x8d, 0x24, 0x54, 0x20, 0xf2, 0x06, 0x2e, + 0x77, 0x19, 0x3b, 0x00, 0x1e, 0x2f, 0x16, 0xf2, 0xa8, 0x0c, 0xd5, 0x2b, 0x8a, 0x1b, 0x2f, 0x8f, + 0xce, 0x18, 0x52, 0x02, 0x87, 0xe8, 0x06, 0x8e, 0x5e, 0xd3, 0xee, 0x30, 0x2f, 0x50, 0x84, 0xca, + 0x86, 0xea, 0x55, 0x74, 0xca, 0x46, 0x01, 0x9b, 0x04, 0x97, 0x43, 0x3b, 0x76, 0xab, 0x65, 0xf1, + 0x5e, 0x11, 0xdf, 0xf4, 0xd7, 0x08, 0x2e, 0x15, 0x99, 0xdb, 0xec, 0x79, 0xf3, 0xe8, 0xfc, 0x8a, + 0x03, 0x14, 0xba, 0xf7, 0xab, 0xab, 0xa2, 0x14, 0x88, 0x6f, 0xde, 0x17, 0xb8, 0x6f, 0xc4, 0xd5, + 0x8a, 0xec, 0xe3, 0xdf, 0xf4, 0xc7, 0x2a, 0x95, 0xdf, 0xf2, 0xa2, 0x98, 0x85, 0x87, 0xb3, 0xde, + 0x7c, 0xa7, 0x70, 0xc5, 0x77, 0x83, 0x5e, 0x7c, 0x57, 0xed, 0x31, 0xd9, 0x5a, 0xda, 0xc1, 0xfc, + 0xbd, 0xd2, 0xab, 0x52, 0x2c, 0x40, 0xd5, 0x57, 0xf1, 0xda, 0x5d, 0xd9, 0xb5, 0xe8, 0x5e, 0x52, + 0xf6, 0xcb, 0xdb, 0x4e, 0x3f, 0x52, 0x5b, 0xfe, 0x76, 0xc2, 0xe2, 0x54, 0x60, 0xaa, 0xe1, 0x75, + 0x79, 0x20, 0xa3, 0x03, 0xa0, 0x2e, 0x6d, 0xa7, 0xbf, 0xb5, 0x3d, 0x07, 0x08, 0x4c, 0xdb, 0xe4, + 0x0c, 0x3e, 0x2e, 0xc7, 0x49, 0xa9, 0x45, 0x86, 0x58, 0xef, 0xd2, 0x74, 0x98, 0x72, 0x4e, 0x87, + 0x69, 0x43, 0x81, 0x07, 0x18, 0x8b, 0x68, 0x39, 0xcd, 0xb7, 0xcf, 0xe2, 0x55, 0x31, 0x09, 0xf9, + 0x25, 0xc2, 0x15, 0xa9, 0x94, 0x92, 0xfa, 0x2c, 0x8e, 0x27, 0x45, 0xda, 0x9a, 0x65, 0x3c, 0x5e, + 0x62, 0xa4, 0x97, 0x7f, 0xf8, 0xaf, 0xff, 0xfd, 0x7c, 0xe5, 0x3c, 0x79, 0xc6, 0x52, 0x86, 0x5b, + 0xdc, 0xd2, 0x52, 0x12, 0xb2, 0x2e, 0x42, 0x0b, 0x60, 0x52, 0xaf, 0x32, 0x00, 0x96, 0x93, 0xbb, + 0x0c, 0x80, 0xe5, 0x85, 0x30, 0x43, 0x60, 0x5d, 0x89, 0xe6, 0x1d, 0x84, 0xcb, 0xfb, 0x8c, 0xf9, + 0xa4, 0xd8, 0x4d, 0x5e, 0x65, 0xae, 0x5d, 0x31, 0x37, 0x00, 0x60, 0x57, 0x04, 0xb0, 0x4b, 0xe4, + 0xd9, 0xd9, 0x8c, 0x31, 0xe6, 0x5b, 0x43, 0x7e, 0x62, 0x47, 0xe4, 0x2d, 0x84, 0xd7, 0xf8, 0x14, + 0x2d, 0xdf, 0x04, 0x60, 0x5e, 0x87, 0x36, 0x00, 0x38, 0x26, 0x2c, 0xd3, 0x8b, 0x02, 0xe0, 0x33, + 0xe4, 0x6c, 0x21, 0x40, 0xf2, 0x1b, 0x84, 0x2b, 0x52, 0xfd, 0x34, 0x08, 0x68, 0x4e, 0xc5, 0x35, + 0x08, 0x68, 0x5e, 0x93, 0xa5, 0xdb, 0x02, 0xd6, 0x16, 0xb9, 0x3c, 0x13, 0x96, 0x54, 0x5f, 0xad, + 0xa1, 0x38, 0x2b, 0x23, 0xf2, 0x2e, 0xc2, 0x1b, 0x72, 0x1e, 0x4e, 0x5e, 0xc3, 0x84, 0x8b, 0x3c, + 0xcc, 0xe6, 0x3c, 0x26, 0x73, 0x6d, 0x3d, 0x89, 0x94, 0xfc, 0x02, 0xe1, 0x32, 0x7f, 0xb3, 0x93, + 0xe7, 0x0a, 0x3d, 0x69, 0x8a, 0x43, 0x6d, 0xcb, 0x70, 0x34, 0x40, 0xb2, 0x04, 0xa4, 0x8b, 0xe4, + 0xc2, 0x4c, 0x48, 0x4e, 0xc8, 0x06, 0xd6, 0x30, 0xf1, 0x9c, 0x11, 0xf9, 0x33, 0xc2, 0xc7, 0x35, + 0x19, 0x93, 0x6c, 0x1b, 0xf9, 0xcb, 0x2b, 0xa4, 0xb5, 0xab, 0xf3, 0x19, 0x01, 0xd6, 0xeb, 0x02, + 0x6b, 0x83, 0x58, 0xc5, 0x58, 0x65, 0xea, 0x8b, 0x00, 0xf3, 0xdf, 0x11, 0x5e, 0x57, 0x0a, 0x32, + 0xb9, 0x62, 0xe4, 0x5b, 0x93, 0xb3, 0x6b, 0x8d, 0x39, 0x2c, 0x00, 0xea, 0xcb, 0x02, 0xea, 0x0e, + 0x69, 0x17, 0x43, 0xe5, 0x77, 0x00, 0xd8, 0x96, 0xad, 0x11, 0x7c, 0xb4, 0x47, 0xd6, 0x10, 0x24, + 0xf0, 0x11, 0xf9, 0x1b, 0xc2, 0x9f, 0xd0, 0x85, 0x5b, 0x62, 0xc6, 0xde, 0x98, 0xce, 0xbb, 0x20, + 0xe7, 0x5f, 0x11, 0x0b, 0xf9, 0x22, 0xf9, 0x82, 0xd9, 0x42, 0x22, 0x48, 0x4d, 0xd6, 0x50, 0x48, + 0x4c, 0x23, 0xf2, 0x47, 0x84, 0x37, 0x52, 0xf1, 0x97, 0x98, 0x31, 0xa9, 0x6b, 0xcb, 0x06, 0xe7, + 0x6c, 0x42, 0x5b, 0xa6, 0x5f, 0x12, 0xa0, 0xb7, 0x49, 0xa3, 0x18, 0xb4, 0x90, 0x9d, 0xad, 0x21, + 0xbc, 0x4c, 0x46, 0xe4, 0x2f, 0x08, 0x7f, 0x32, 0x27, 0x2e, 0x92, 0x6b, 0x46, 0x00, 0xc6, 0x5f, + 0x3f, 0xb5, 0xba, 0x59, 0x90, 0x52, 0xcc, 0xcf, 0x0b, 0xcc, 0x57, 0x49, 0xd3, 0xe0, 0x20, 0x2a, + 0xb4, 0xaa, 0x0e, 0xbc, 0x89, 0xf0, 0x9a, 0x08, 0x9e, 0x69, 0x1d, 0xd0, 0x13, 0xc6, 0xbc, 0x40, + 0xcd, 0xaa, 0x00, 0x07, 0x4a, 0xfe, 0x84, 0x70, 0x45, 0xaa, 0x59, 0x06, 0x91, 0x1f, 0x17, 0x0f, + 0x0d, 0x22, 0x3f, 0x21, 0x13, 0xd2, 0x17, 0x04, 0xb8, 0xeb, 0xe4, 0xda, 0x4c, 0x70, 0x52, 0x53, + 0x9b, 0x3c, 0x74, 0xa2, 0x2a, 0xc8, 0x19, 0x8d, 0xab, 0xc2, 0xbc, 0x98, 0x27, 0xc4, 0x41, 0xc3, + 0xaa, 0x00, 0x3a, 0xe0, 0x87, 0x08, 0xaf, 0x2b, 0xf9, 0xc9, 0x20, 0xf7, 0x4e, 0xaa, 0x7c, 0x06, + 0x79, 0x60, 0x8a, 0xd2, 0x47, 0xaf, 0x09, 0x90, 0x16, 0xd9, 0x2a, 0xbc, 0x35, 0x71, 0xb3, 0xb4, + 0xcc, 0xfe, 0x0e, 0xe1, 0xe3, 0x6a, 0x2e, 0x4e, 0xe9, 0xb6, 0x09, 0x3f, 0xf3, 0x23, 0x9e, 0xa2, + 0xe9, 0xd1, 0x2d, 0x81, 0xf8, 0x02, 0x39, 0x6f, 0x84, 0x98, 0xbc, 0x8d, 0xf0, 0xaa, 0x78, 0x5b, + 0x90, 0xe2, 0x0a, 0xaa, 0x8b, 0x4e, 0x06, 0xe7, 0x27, 0xf7, 0x64, 0x31, 0xbc, 0xe6, 0x89, 0xf7, + 0x1f, 0x94, 0xaf, 0x5f, 0x21, 0xbc, 0x2e, 0xe6, 0xe0, 0x0c, 0x1a, 0x5d, 0xdb, 0x72, 0x00, 0x2d, + 0x33, 0x80, 0x19, 0x73, 0x97, 0x04, 0xc2, 0x73, 0x84, 0x16, 0x23, 0xe4, 0x01, 0xc6, 0x99, 0xd2, + 0x42, 0x9a, 0x66, 0xbe, 0x74, 0x4d, 0x6d, 0x7e, 0x7c, 0x57, 0x05, 0xbe, 0x3a, 0x79, 0xce, 0x84, + 0xc1, 0x34, 0xb3, 0xff, 0x15, 0xe1, 0x4f, 0xe5, 0x35, 0xb5, 0x85, 0xd0, 0x5e, 0x9f, 0xc3, 0x46, + 0x17, 0xee, 0x0c, 0x8b, 0x92, 0x44, 0x9d, 0x78, 0x8e, 0x5e, 0x94, 0x3e, 0x44, 0xb8, 0xdc, 0x66, + 0xec, 0xc0, 0xe0, 0x2a, 0xa8, 0xa9, 0x49, 0x06, 0x57, 0x41, 0x5d, 0xd0, 0xa1, 0xbb, 0x02, 0x60, + 0x8b, 0xbc, 0x38, 0xfb, 0xc0, 0x30, 0x76, 0x30, 0xed, 0xba, 0x92, 0x0a, 0x16, 0x23, 0xf2, 0x4f, + 0x9e, 0xa3, 0x40, 0x10, 0x31, 0xd8, 0xaf, 0x63, 0x92, 0x8d, 0xc1, 0x75, 0x6b, 0x5c, 0x6d, 0xa1, + 0xfb, 0x02, 0xfa, 0xcb, 0xe4, 0x56, 0x21, 0x74, 0x6e, 0x66, 0x0d, 0x85, 0x1a, 0x33, 0x92, 0x7f, + 0xf3, 0xe0, 0xad, 0x61, 0x68, 0xc7, 0xee, 0x88, 0xbc, 0x87, 0xf0, 0x1a, 0x08, 0x15, 0x06, 0x25, + 0x35, 0x2f, 0xaf, 0x18, 0x3c, 0xad, 0xc6, 0x34, 0x10, 0xc3, 0x37, 0x0c, 0xc8, 0x1c, 0xaa, 0xec, + 0xff, 0x03, 0xf1, 0x87, 0x3d, 0x8b, 0x5d, 0x83, 0x94, 0xa5, 0xeb, 0x18, 0x06, 0x29, 0x2b, 0xa7, + 0x37, 0xd0, 0xd7, 0x04, 0xba, 0xdb, 0x64, 0x6f, 0x26, 0xba, 0x7b, 0xdc, 0x46, 0xed, 0x08, 0xcf, + 0x51, 0x9b, 0xa3, 0x15, 0x1d, 0xa4, 0x9f, 0xe2, 0x72, 0x99, 0xde, 0x6d, 0x47, 0xed, 0x5b, 0x1f, + 0x3d, 0xd8, 0x44, 0x1f, 0x3f, 0xd8, 0x44, 0xff, 0x7d, 0xb0, 0x89, 0x7e, 0xf2, 0x70, 0xf3, 0xd8, + 0xc7, 0x0f, 0x37, 0x8f, 0xfd, 0xfb, 0xe1, 0xe6, 0xb1, 0xd7, 0xeb, 0x3d, 0x2f, 0xbe, 0x9b, 0x74, + 0xeb, 0x77, 0x58, 0x7f, 0xba, 0xd3, 0x37, 0xd4, 0x47, 0x7c, 0x38, 0x70, 0xa3, 0x6e, 0x45, 0xfc, + 0x87, 0xd9, 0xf6, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x22, 0xca, 0x86, 0x6e, 0x27, 0x00, + 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -2745,6 +2939,10 @@ type QueryClient interface { Pool(ctx context.Context, in *QueryGetPoolRequest, opts ...grpc.CallOption) (*QueryGetPoolResponse, error) // Queries a list of Pool items. PoolAll(ctx context.Context, in *QueryAllPoolRequest, opts ...grpc.CallOption) (*QueryAllPoolResponse, error) + // Queries a Volume by index. + Volume(ctx context.Context, in *QueryVolumeRequest, opts ...grpc.CallOption) (*QueryVolumeResponse, error) + // Queries all Volumes. + VolumeAll(ctx context.Context, in *QueryAllVolumeRequest, opts ...grpc.CallOption) (*QueryAllVolumeResponse, error) // Queries a Drop by index. Drop(ctx context.Context, in *QueryDropRequest, opts ...grpc.CallOption) (*QueryDropResponse, error) // Queries a Drop by index. @@ -2829,6 +3027,24 @@ func (c *queryClient) PoolAll(ctx context.Context, in *QueryAllPoolRequest, opts return out, nil } +func (c *queryClient) Volume(ctx context.Context, in *QueryVolumeRequest, opts ...grpc.CallOption) (*QueryVolumeResponse, error) { + out := new(QueryVolumeResponse) + err := c.cc.Invoke(ctx, "/pendulumlabs.market.market.Query/Volume", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) VolumeAll(ctx context.Context, in *QueryAllVolumeRequest, opts ...grpc.CallOption) (*QueryAllVolumeResponse, error) { + out := new(QueryAllVolumeResponse) + err := c.cc.Invoke(ctx, "/pendulumlabs.market.market.Query/VolumeAll", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *queryClient) Drop(ctx context.Context, in *QueryDropRequest, opts ...grpc.CallOption) (*QueryDropResponse, error) { out := new(QueryDropResponse) err := c.cc.Invoke(ctx, "/pendulumlabs.market.market.Query/Drop", in, out, opts...) @@ -3010,6 +3226,10 @@ type QueryServer interface { Pool(context.Context, *QueryGetPoolRequest) (*QueryGetPoolResponse, error) // Queries a list of Pool items. PoolAll(context.Context, *QueryAllPoolRequest) (*QueryAllPoolResponse, error) + // Queries a Volume by index. + Volume(context.Context, *QueryVolumeRequest) (*QueryVolumeResponse, error) + // Queries all Volumes. + VolumeAll(context.Context, *QueryAllVolumeRequest) (*QueryAllVolumeResponse, error) // Queries a Drop by index. Drop(context.Context, *QueryDropRequest) (*QueryDropResponse, error) // Queries a Drop by index. @@ -3066,6 +3286,12 @@ func (*UnimplementedQueryServer) Pool(ctx context.Context, req *QueryGetPoolRequ func (*UnimplementedQueryServer) PoolAll(ctx context.Context, req *QueryAllPoolRequest) (*QueryAllPoolResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PoolAll not implemented") } +func (*UnimplementedQueryServer) Volume(ctx context.Context, req *QueryVolumeRequest) (*QueryVolumeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method Volume not implemented") +} +func (*UnimplementedQueryServer) VolumeAll(ctx context.Context, req *QueryAllVolumeRequest) (*QueryAllVolumeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method VolumeAll not implemented") +} func (*UnimplementedQueryServer) Drop(ctx context.Context, req *QueryDropRequest) (*QueryDropResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Drop not implemented") } @@ -3200,6 +3426,42 @@ func _Query_PoolAll_Handler(srv interface{}, ctx context.Context, dec func(inter return interceptor(ctx, in, info, handler) } +func _Query_Volume_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryVolumeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).Volume(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pendulumlabs.market.market.Query/Volume", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).Volume(ctx, req.(*QueryVolumeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_VolumeAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryAllVolumeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).VolumeAll(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/pendulumlabs.market.market.Query/VolumeAll", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).VolumeAll(ctx, req.(*QueryAllVolumeRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Query_Drop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(QueryDropRequest) if err := dec(in); err != nil { @@ -3562,6 +3824,14 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "PoolAll", Handler: _Query_PoolAll_Handler, }, + { + MethodName: "Volume", + Handler: _Query_Volume_Handler, + }, + { + MethodName: "VolumeAll", + Handler: _Query_VolumeAll_Handler, + }, { MethodName: "Drop", Handler: _Query_Drop_Handler, @@ -3846,7 +4116,7 @@ func (m *QueryAllPoolResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *QueryBurnedRequest) Marshal() (dAtA []byte, err error) { +func (m *QueryVolumeRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -3856,12 +4126,156 @@ func (m *QueryBurnedRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *QueryBurnedRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *QueryVolumeRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *QueryBurnedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *QueryVolumeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Denom) > 0 { + i -= len(m.Denom) + copy(dAtA[i:], m.Denom) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryVolumeResponse) 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 *QueryVolumeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryVolumeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Amount) > 0 { + i -= len(m.Amount) + copy(dAtA[i:], m.Amount) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Amount))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryAllVolumeRequest) 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 *QueryAllVolumeRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllVolumeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.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 *QueryAllVolumeResponse) 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 *QueryAllVolumeResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryAllVolumeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Volumes) > 0 { + for iNdEx := len(m.Volumes) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Volumes[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 *QueryBurnedRequest) 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 *QueryBurnedRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryBurnedRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -4424,20 +4838,20 @@ func (m *QueryUidsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x12 } if len(m.Uids) > 0 { - dAtA10 := make([]byte, len(m.Uids)*10) - var j9 int + dAtA12 := make([]byte, len(m.Uids)*10) + var j11 int for _, num := range m.Uids { for num >= 1<<7 { - dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80) + dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j9++ + j11++ } - dAtA10[j9] = uint8(num) - j9++ + dAtA12[j11] = uint8(num) + j11++ } - i -= j9 - copy(dAtA[i:], dAtA10[:j9]) - i = encodeVarintQuery(dAtA, i, uint64(j9)) + i -= j11 + copy(dAtA[i:], dAtA12[:j11]) + i = encodeVarintQuery(dAtA, i, uint64(j11)) i-- dAtA[i] = 0xa } @@ -5702,6 +6116,64 @@ func (m *QueryAllPoolResponse) Size() (n int) { return n } +func (m *QueryVolumeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryVolumeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Amount) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllVolumeRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryAllVolumeResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Volumes) > 0 { + for _, e := range m.Volumes { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + func (m *QueryBurnedRequest) Size() (n int) { if m == nil { return 0 @@ -6955,6 +7427,376 @@ func (m *QueryAllPoolResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *QueryVolumeRequest) 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: QueryVolumeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryVolumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Denom = string(dAtA[iNdEx:postIndex]) + 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 *QueryVolumeResponse) 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: QueryVolumeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryVolumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Amount = string(dAtA[iNdEx:postIndex]) + 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 *QueryAllVolumeRequest) 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: QueryAllVolumeRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllVolumeRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 + } + if m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.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 *QueryAllVolumeResponse) 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: QueryAllVolumeResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryAllVolumeResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Volumes", 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.Volumes = append(m.Volumes, Volume{}) + if err := m.Volumes[len(m.Volumes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 + } + if m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.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 *QueryBurnedRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/x/market/types/query.pb.gw.go b/x/market/types/query.pb.gw.go index 2dc410c6..815e74a7 100644 --- a/x/market/types/query.pb.gw.go +++ b/x/market/types/query.pb.gw.go @@ -159,6 +159,96 @@ func local_request_Query_PoolAll_0(ctx context.Context, marshaler runtime.Marsha } +func request_Query_Volume_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryVolumeRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := client.Volume(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_Volume_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryVolumeRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["denom"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom") + } + + protoReq.Denom, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err) + } + + msg, err := server.Volume(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_VolumeAll_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_VolumeAll_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllVolumeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_VolumeAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.VolumeAll(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_VolumeAll_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryAllVolumeRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_VolumeAll_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.VolumeAll(ctx, &protoReq) + return msg, metadata, err + +} + func request_Query_Drop_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { var protoReq QueryDropRequest var metadata runtime.ServerMetadata @@ -1587,6 +1677,52 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_Volume_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_Volume_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_Volume_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_VolumeAll_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_VolumeAll_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_VolumeAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Drop_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -2145,6 +2281,46 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_Volume_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_Volume_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_Volume_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_VolumeAll_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_VolumeAll_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_VolumeAll_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + mux.Handle("GET", pattern_Query_Drop_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { ctx, cancel := context.WithCancel(req.Context()) defer cancel() @@ -2537,6 +2713,10 @@ var ( pattern_Query_PoolAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"pendulum-labs", "market", "pool"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_Volume_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"pendulum-labs", "market", "volume", "denom"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_VolumeAll_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2}, []string{"pendulum-labs", "market", "volume"}, "", runtime.AssumeColonVerbOpt(true))) + pattern_Query_Drop_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"pendulum-labs", "market", "drop", "uid"}, "", runtime.AssumeColonVerbOpt(true))) pattern_Query_DropAmounts_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"pendulum-labs", "market", "drop", "amounts", "uid"}, "", runtime.AssumeColonVerbOpt(true))) @@ -2585,6 +2765,10 @@ var ( forward_Query_PoolAll_0 = runtime.ForwardResponseMessage + forward_Query_Volume_0 = runtime.ForwardResponseMessage + + forward_Query_VolumeAll_0 = runtime.ForwardResponseMessage + forward_Query_Drop_0 = runtime.ForwardResponseMessage forward_Query_DropAmounts_0 = runtime.ForwardResponseMessage