mleku/wasmd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #302 from CosmWasm/code_max_param_289

Browse Source 
Reject wasm code exceeding limit
This commit is contained in:
Alexander Peters
2020-11-09 09:05:20 +01:00
committed by GitHub
parent 41cf73dae9 2efd962984
commit fbd7168cc1
10 changed files with 234 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
x/wasm/internal/keeper/genesis_test.go
View File

@@ -59,7 +59,7 @@ func TestGenesisExportImport(t *testing.T) {
srcKeeper.importContractState(srcCtx, contractAddr, stateModels)
}
var wasmParams types.Params
f.Fuzz(&wasmParams)
f.NilChance(0).Fuzz(&wasmParams)
srcKeeper.setParams(srcCtx, wasmParams)
// export
@@ -369,7 +369,8 @@ func TestImportContractWithCodeHistoryReset(t *testing.T) {
"code_upload_access": {
"permission": "Everybody"
},
"instantiate_default_permission": "Everybody"
"instantiate_default_permission": "Everybody",
"max_wasm_code_size": 500000
},
"codes": [
{

34
x/wasm/internal/keeper/ioutil.go
View File

@@ -5,6 +5,8 @@ import (
"compress/gzip"
"io"
"io/ioutil"
"github.com/CosmWasm/wasmd/x/wasm/internal/types"
)
// magic bytes to identify gzip.
@@ -12,13 +14,13 @@ import (
// and https://github.com/golang/go/blob/master/src/net/http/sniff.go#L186
var gzipIdent = []byte("\x1F\x8B\x08")
// limit max bytes read to prevent gzip bombs
const maxSize = 400 * 1024
// uncompress returns gzip uncompressed content or given src when not gzip.
func uncompress(src []byte) ([]byte, error) {
if len(src) < 3 {
func uncompress(src []byte, limit uint64) ([]byte, error) {
switch n := uint64(len(src)); {
case n < 3:
return src, nil
case n > limit:
return nil, types.ErrLimit
}
if !bytes.Equal(gzipIdent, src[0:3]) {
return src, nil
@@ -28,6 +30,24 @@ func uncompress(src []byte) ([]byte, error) {
return nil, err
}
zr.Multistream(false)
return ioutil.ReadAll(io.LimitReader(zr, maxSize))
defer zr.Close()
return ioutil.ReadAll(LimitReader(zr, int64(limit)))
}
// LimitReader returns a Reader that reads from r
// but stops with types.ErrLimit after n bytes.
// The underlying implementation is a *io.LimitedReader.
func LimitReader(r io.Reader, n int64) io.Reader {
return &LimitedReader{r: &io.LimitedReader{R: r, N: n}}
}
type LimitedReader struct {
r *io.LimitedReader
}
func (l *LimitedReader) Read(p []byte) (n int, err error) {
if l.r.N <= 0 {
return 0, types.ErrLimit
}
return l.r.Read(p)
}

38
x/wasm/internal/keeper/ioutil_test.go
View File

@@ -9,6 +9,7 @@ import (
"strings"
"testing"
"github.com/CosmWasm/wasmd/x/wasm/internal/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -20,6 +21,8 @@ func TestUncompress(t *testing.T) {
wasmGzipped, err := ioutil.ReadFile("./testdata/hackatom.wasm.gzip")
require.NoError(t, err)
const maxSize = 400_000
specs := map[string]struct {
src []byte
expError error
@@ -41,9 +44,13 @@ func TestUncompress(t *testing.T) {
src: []byte{0x1, 0x2},
expResult: []byte{0x1, 0x2},
},
"handle big input slice": {
src: []byte(strings.Repeat("a", maxSize+1)),
expResult: []byte(strings.Repeat("a", maxSize+1)),
"handle input slice exceeding limit": {
src: []byte(strings.Repeat("a", maxSize+1)),
expError: types.ErrLimit,
},
"handle input slice at limit": {
src: []byte(strings.Repeat("a", maxSize)),
expResult: []byte(strings.Repeat("a", maxSize)),
},
"handle gzip identifier only": {
src: gzipIdent,
@@ -57,31 +64,38 @@ func TestUncompress(t *testing.T) {
src: wasmGzipped[:len(wasmGzipped)-5],
expError: io.ErrUnexpectedEOF,
},
"handle limit gzip output": {
src: asGzip(bytes.Repeat([]byte{0x1}, maxSize)),
expResult: bytes.Repeat([]byte{0x1}, maxSize),
},
"handle big gzip output": {
src: asGzip(strings.Repeat("a", maxSize+1)),
expError: io.ErrUnexpectedEOF,
src: asGzip(bytes.Repeat([]byte{0x1}, maxSize+1)),
expError: types.ErrLimit,
},
"handle other big gzip output": {
src: asGzip(strings.Repeat("a", 2*maxSize)),
expError: io.ErrUnexpectedEOF,
src: asGzip(bytes.Repeat([]byte{0x1}, 2*maxSize)),
expError: types.ErrLimit,
},
}
for msg, spec := range specs {
t.Run(msg, func(t *testing.T) {
r, err := uncompress(spec.src)
require.True(t, errors.Is(spec.expError, err), "exp %+v got %+v", spec.expError, err)
r, err := uncompress(spec.src, maxSize)
require.True(t, errors.Is(spec.expError, err), "exp %v got %+v", spec.expError, err)
if spec.expError != nil {
return
}
assert.Equal(t, spec.expResult, r)
})
}
}
func asGzip(src string) []byte {
func asGzip(src []byte) []byte {
var buf bytes.Buffer
if _, err := io.Copy(gzip.NewWriter(&buf), strings.NewReader(src)); err != nil {
zipper := gzip.NewWriter(&buf)
if _, err := io.Copy(zipper, bytes.NewReader(src)); err != nil {
panic(err)
}
if err := zipper.Close(); err != nil {
panic(err)
}
return buf.Bytes()

10
x/wasm/internal/keeper/keeper.go
View File

@@ -110,6 +110,12 @@ func (k Keeper) getInstantiateAccessConfig(ctx sdk.Context) types.AccessType {
return a
}
func (k Keeper) GetMaxWasmCodeSize(ctx sdk.Context) uint64 {
var a uint64
k.paramSpace.Get(ctx, types.ParamStoreKeyMaxWasmCodeSize, &a)
return a
}
// GetParams returns the total set of wasm parameters.
func (k Keeper) GetParams(ctx sdk.Context) types.Params {
var params types.Params
@@ -130,7 +136,7 @@ func (k Keeper) create(ctx sdk.Context, creator sdk.AccAddress, wasmCode []byte,
if !authZ.CanCreateCode(k.getUploadAccessConfig(ctx), creator) {
return 0, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "can not create code")
}
wasmCode, err = uncompress(wasmCode)
wasmCode, err = uncompress(wasmCode, k.GetMaxWasmCodeSize(ctx))
if err != nil {
return 0, sdkerrors.Wrap(types.ErrCreateFailed, err.Error())
}
@@ -155,7 +161,7 @@ func (k Keeper) create(ctx sdk.Context, creator sdk.AccAddress, wasmCode []byte,
}
func (k Keeper) importCode(ctx sdk.Context, codeID uint64, codeInfo types.CodeInfo, wasmCode []byte) error {
wasmCode, err := uncompress(wasmCode)
wasmCode, err := uncompress(wasmCode, k.GetMaxWasmCodeSize(ctx))
if err != nil {
return sdkerrors.Wrap(types.ErrCreateFailed, err.Error())
}

1
x/wasm/internal/keeper/keeper_test.go
View File

@@ -80,6 +80,7 @@ func TestCreateStoresInstantiatePermission(t *testing.T) {
keeper.setParams(ctx, types.Params{
CodeUploadAccess: types.AllowEverybody,
InstantiateDefaultPermission: spec.srcPermission,
MaxWasmCodeSize: types.DefaultMaxWasmCodeSize,
})
fundAccounts(t, ctx, accKeeper, bankKeeper, myAddr, deposit)

24
x/wasm/internal/keeper/proposal_integration_test.go
View File

@@ -18,7 +18,11 @@ import (
func TestStoreCodeProposal(t *testing.T) {
ctx, keepers := CreateTestInput(t, false, "staking", nil, nil)
govKeeper, wasmKeeper := keepers.GovKeeper, keepers.WasmKeeper
wasmKeeper.setParams(ctx, types.Params{CodeUploadAccess: types.AllowNobody, InstantiateDefaultPermission: types.AccessTypeNobody})
wasmKeeper.setParams(ctx, types.Params{
CodeUploadAccess: types.AllowNobody,
InstantiateDefaultPermission: types.AccessTypeNobody,
MaxWasmCodeSize: types.DefaultMaxWasmCodeSize,
})
wasmCode, err := ioutil.ReadFile("./testdata/hackatom.wasm")
require.NoError(t, err)
@@ -55,7 +59,11 @@ func TestStoreCodeProposal(t *testing.T) {
func TestInstantiateProposal(t *testing.T) {
ctx, keepers := CreateTestInput(t, false, "staking", nil, nil)
govKeeper, wasmKeeper := keepers.GovKeeper, keepers.WasmKeeper
wasmKeeper.setParams(ctx, types.Params{CodeUploadAccess: types.AllowNobody, InstantiateDefaultPermission: types.AccessTypeNobody})
wasmKeeper.setParams(ctx, types.Params{
CodeUploadAccess: types.AllowNobody,
InstantiateDefaultPermission: types.AccessTypeNobody,
MaxWasmCodeSize: types.DefaultMaxWasmCodeSize,
})
wasmCode, err := ioutil.ReadFile("./testdata/hackatom.wasm")
require.NoError(t, err)
@@ -107,7 +115,11 @@ func TestInstantiateProposal(t *testing.T) {
func TestMigrateProposal(t *testing.T) {
ctx, keepers := CreateTestInput(t, false, "staking", nil, nil)
govKeeper, wasmKeeper := keepers.GovKeeper, keepers.WasmKeeper
wasmKeeper.setParams(ctx, types.Params{CodeUploadAccess: types.AllowNobody, InstantiateDefaultPermission: types.AccessTypeNobody})
wasmKeeper.setParams(ctx, types.Params{
CodeUploadAccess: types.AllowNobody,
InstantiateDefaultPermission: types.AccessTypeNobody,
MaxWasmCodeSize: types.DefaultMaxWasmCodeSize,
})
wasmCode, err := ioutil.ReadFile("./testdata/hackatom.wasm")
require.NoError(t, err)
@@ -236,7 +248,11 @@ func TestAdminProposals(t *testing.T) {
t.Run(msg, func(t *testing.T) {
ctx, keepers := CreateTestInput(t, false, "staking", nil, nil)
govKeeper, wasmKeeper := keepers.GovKeeper, keepers.WasmKeeper
wasmKeeper.setParams(ctx, types.Params{CodeUploadAccess: types.AllowNobody, InstantiateDefaultPermission: types.AccessTypeNobody})
wasmKeeper.setParams(ctx, types.Params{
CodeUploadAccess: types.AllowNobody,
InstantiateDefaultPermission: types.AccessTypeNobody,
MaxWasmCodeSize: types.DefaultMaxWasmCodeSize,
})
codeInfoFixture := types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode))
require.NoError(t, wasmKeeper.importCode(ctx, 1, codeInfoFixture, wasmCode))

19
x/wasm/internal/types/params.go
View File

@@ -15,10 +15,13 @@ import (
const (
// DefaultParamspace for params keeper
DefaultParamspace = ModuleName
// DefaultMaxWasmCodeSize limit max bytes read to prevent gzip bombs
DefaultMaxWasmCodeSize = 600 * 1024
)
var ParamStoreKeyUploadAccess = []byte("uploadAccess")
var ParamStoreKeyInstantiateAccess = []byte("instantiateAccess")
var ParamStoreKeyMaxWasmCodeSize = []byte("maxWasmCodeSize")
var AllAccessTypes = []AccessType{
AccessTypeNobody,
@@ -95,6 +98,7 @@ func DefaultParams() Params {
return Params{
CodeUploadAccess: AllowEverybody,
InstantiateDefaultPermission: AccessTypeEverybody,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
}
}
@@ -108,6 +112,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
return paramtypes.ParamSetPairs{
paramtypes.NewParamSetPair(ParamStoreKeyUploadAccess, &p.CodeUploadAccess, validateAccessConfig),
paramtypes.NewParamSetPair(ParamStoreKeyInstantiateAccess, &p.InstantiateDefaultPermission, validateAccessType),
paramtypes.NewParamSetPair(ParamStoreKeyMaxWasmCodeSize, &p.MaxWasmCodeSize, validateMaxWasmCodeSize),
}
}
@@ -119,6 +124,9 @@ func (p Params) ValidateBasic() error {
if err := validateAccessConfig(p.CodeUploadAccess); err != nil {
return errors.Wrap(err, "upload access")
}
if err := validateMaxWasmCodeSize(p.MaxWasmCodeSize); err != nil {
return errors.Wrap(err, "max wasm code size")
}
return nil
}
@@ -146,6 +154,17 @@ func validateAccessType(i interface{}) error {
return sdkerrors.Wrapf(ErrInvalid, "unknown type: %q", a)
}
func validateMaxWasmCodeSize(i interface{}) error {
a, ok := i.(uint64)
if !ok {
return sdkerrors.Wrapf(ErrInvalid, "type: %T", i)
}
if a == 0 {
return sdkerrors.Wrap(ErrInvalid, "must be greater 0")
}
return nil
}
func (v AccessConfig) ValidateBasic() error {
switch v.Permission {
case AccessTypeUndefined:

30
x/wasm/internal/types/params_test.go
View File

@@ -4,6 +4,8 @@ import (
"encoding/json"
"testing"
"github.com/cosmos/cosmos-sdk/codec"
codectypes "github.com/cosmos/cosmos-sdk/codec/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -26,23 +28,27 @@ func TestValidateParams(t *testing.T) {
src: Params{
CodeUploadAccess: AllowNobody,
InstantiateDefaultPermission: AccessTypeNobody,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
},
"all good with everybody": {
src: Params{
CodeUploadAccess: AllowEverybody,
InstantiateDefaultPermission: AccessTypeEverybody,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
},
"all good with only address": {
src: Params{
CodeUploadAccess: AccessTypeOnlyAddress.With(anyAddress),
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
},
"reject empty type in instantiate permission": {
src: Params{
CodeUploadAccess: AllowNobody,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
@@ -50,6 +56,7 @@ func TestValidateParams(t *testing.T) {
src: Params{
CodeUploadAccess: AllowNobody,
InstantiateDefaultPermission: 1111,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
@@ -57,6 +64,7 @@ func TestValidateParams(t *testing.T) {
src: Params{
CodeUploadAccess: AccessConfig{Permission: AccessTypeOnlyAddress, Address: invalidAddress},
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
@@ -64,6 +72,7 @@ func TestValidateParams(t *testing.T) {
src: Params{
CodeUploadAccess: AccessConfig{Permission: AccessTypeEverybody, Address: anyAddress},
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
@@ -71,18 +80,29 @@ func TestValidateParams(t *testing.T) {
src: Params{
CodeUploadAccess: AccessConfig{Permission: AccessTypeNobody, Address: anyAddress},
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
"reject empty CodeUploadAccess": {
src: Params{
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
}, "reject undefined permission in CodeUploadAccess": {
},
"reject undefined permission in CodeUploadAccess": {
src: Params{
CodeUploadAccess: AccessConfig{Permission: AccessTypeUndefined},
InstantiateDefaultPermission: AccessTypeOnlyAddress,
MaxWasmCodeSize: DefaultMaxWasmCodeSize,
},
expErr: true,
},
"reject empty max wasm code size": {
src: Params{
CodeUploadAccess: AllowNobody,
InstantiateDefaultPermission: AccessTypeNobody,
},
expErr: true,
},
@@ -147,14 +167,18 @@ func TestParamsUnmarshalJson(t *testing.T) {
"defaults": {
src: `{"code_upload_access": {"permission": "Everybody"},
"instantiate_default_permission": "Everybody"}`,
"instantiate_default_permission": "Everybody",
"max_wasm_code_size": 614400}`,
exp: DefaultParams(),
},
}
for msg, spec := range specs {
t.Run(msg, func(t *testing.T) {
var val Params
err := ModuleCdc.UnmarshalJSON([]byte(spec.src), &val)
interfaceRegistry := codectypes.NewInterfaceRegistry()
marshaler := codec.NewProtoCodec(interfaceRegistry)
err := marshaler.UnmarshalJSON([]byte(spec.src), &val)
require.NoError(t, err)
assert.Equal(t, spec.exp, val)
})

220
x/wasm/internal/types/types.pb.go
View File

@@ -164,6 +164,7 @@ var xxx_messageInfo_AccessConfig proto.InternalMessageInfo
type Params struct {
CodeUploadAccess AccessConfig `protobuf:"bytes,1,opt,name=code_upload_access,json=codeUploadAccess,proto3" json:"code_upload_access" yaml:"code_upload_access"`
InstantiateDefaultPermission AccessType `protobuf:"varint,2,opt,name=instantiate_default_permission,json=instantiateDefaultPermission,proto3,enum=wasmd.x.wasmd.v1beta1.AccessType" json:"instantiate_default_permission,omitempty" yaml:"instantiate_default_permission"`
MaxWasmCodeSize uint64 `protobuf:"varint,3,opt,name=max_wasm_code_size,json=maxWasmCodeSize,proto3" json:"max_wasm_code_size,omitempty" yaml:"max_wasm_code_size"`
}
func (m *Params) Reset() { *m = Params{} }
@@ -248,8 +249,7 @@ type ContractInfo struct {
Label string `protobuf:"bytes,4,opt,name=label,proto3" json:"label,omitempty"`
// never show this in query results, just use for sorting
// (Note: when using json tag "-" amino refused to serialize it...)
Created *AbsoluteTxPosition `protobuf:"bytes,5,opt,name=created,proto3" json:"created,omitempty"`
IBCPortID string `protobuf:"bytes,6,opt,name=ibc_port_id,json=ibcPortId,proto3" json:"ibc_port_id,omitempty"`
Created *AbsoluteTxPosition `protobuf:"bytes,5,opt,name=created,proto3" json:"created,omitempty"`
}
func (m *ContractInfo) Reset() { *m = ContractInfo{} }
@@ -462,76 +462,76 @@ func init() {
func init() { proto.RegisterFile("x/wasm/internal/types/types.proto", fileDescriptor_45de2b3fc8aff6aa) }
var fileDescriptor_45de2b3fc8aff6aa = []byte{
// 1094 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0xf7, 0xda, 0x8e, 0x1d, 0x4f, 0xdc, 0xd6, 0x1d, 0x52, 0x70, 0xdd, 0x6a, 0xd7, 0xd9, 0x0a,
0x94, 0x14, 0xc5, 0x26, 0x01, 0x09, 0xd4, 0x5b, 0xfc, 0x87, 0xc6, 0x94, 0xfc, 0xd1, 0xb6, 0x29,
0x0d, 0x12, 0xb2, 0x66, 0x77, 0x26, 0xf6, 0xd0, 0xf5, 0x8c, 0xb5, 0x33, 0x4e, 0x6d, 0x4e, 0x1c,
0x51, 0xb8, 0x20, 0x4e, 0x70, 0x88, 0x84, 0x04, 0x87, 0x7e, 0x01, 0xbe, 0x01, 0x87, 0x5c, 0x90,
0x2a, 0x71, 0xe1, 0x64, 0x81, 0xf3, 0x0d, 0x72, 0xcc, 0x09, 0xcd, 0xec, 0xba, 0x36, 0xb4, 0x09,
0xa1, 0xe2, 0xe2, 0x9d, 0x99, 0xf7, 0x7e, 0xbf, 0x37, 0xef, 0xf7, 0xde, 0x8c, 0x07, 0x2c, 0xf4,
0xcb, 0x4f, 0x90, 0xe8, 0x94, 0x29, 0x93, 0x24, 0x60, 0xc8, 0x2f, 0xcb, 0x41, 0x97, 0x88, 0xf0,
0xb7, 0xd4, 0x0d, 0xb8, 0xe4, 0xf0, 0x9a, 0x72, 0xc0, 0xa5, 0x7e, 0x29, 0xfc, 0xee, 0xaf, 0xb8,
0x44, 0xa2, 0x95, 0xc2, 0x7c, 0x8b, 0xb7, 0xb8, 0xf6, 0x28, 0xab, 0x51, 0xe8, 0x6c, 0xbb, 0xe0,
0xca, 0x9a, 0xe7, 0x11, 0x21, 0x1e, 0x0c, 0xba, 0x64, 0x1b, 0x05, 0xa8, 0x03, 0x1b, 0x60, 0x66,
0x1f, 0xf9, 0x3d, 0x92, 0x37, 0x8a, 0xc6, 0xe2, 0xe5, 0xd5, 0x85, 0xd2, 0x4b, 0xf9, 0x4a, 0x13,
0x58, 0x25, 0x77, 0x32, 0xb4, 0xb2, 0x03, 0xd4, 0xf1, 0xef, 0xd8, 0x1a, 0x69, 0x3b, 0x21, 0xc3,
0x9d, 0xe4, 0x77, 0x3f, 0x58, 0x86, 0xfd, 0xab, 0x01, 0xb2, 0xa1, 0x77, 0x95, 0xb3, 0x3d, 0xda,
0x82, 0x8f, 0x00, 0xe8, 0x92, 0xa0, 0x43, 0x85, 0xa0, 0x9c, 0x5d, 0x3c, 0xcc, 0xb5, 0x93, 0xa1,
0x75, 0x35, 0x0c, 0x33, 0x81, 0xdb, 0xce, 0x14, 0x17, 0xfc, 0x0c, 0xa4, 0x11, 0xc6, 0x01, 0x11,
0x22, 0x1f, 0x2f, 0x1a, 0x8b, 0xd9, 0x4a, 0xf5, 0x64, 0x68, 0x5d, 0x0e, 0x31, 0x91, 0xc1, 0x3e,
0x1d, 0x5a, 0xcb, 0x2d, 0x2a, 0xdb, 0x3d, 0xb7, 0xe4, 0xf1, 0x4e, 0xd9, 0xe3, 0xa2, 0xc3, 0x45,
0xf4, 0x59, 0x16, 0xf8, 0x71, 0x24, 0xe6, 0x9a, 0xe7, 0xad, 0x85, 0x08, 0x67, 0xcc, 0x19, 0xe5,
0xf3, 0x7d, 0x1c, 0xa4, 0xb4, 0x54, 0x02, 0x4a, 0x00, 0x3d, 0x8e, 0x49, 0xb3, 0xd7, 0xf5, 0x39,
0xc2, 0x4d, 0xa4, 0x37, 0xab, 0x33, 0x9a, 0x5b, 0xbd, 0x75, 0x6e, 0x46, 0xa1, 0x14, 0x95, 0x85,
0xa3, 0xa1, 0x15, 0x3b, 0x19, 0x5a, 0xd7, 0xc3, 0x3d, 0xbe, 0x48, 0x66, 0x3b, 0x39, 0xb5, 0xb8,
0xa3, 0xd7, 0x42, 0x28, 0xfc, 0xd6, 0x00, 0x26, 0x65, 0x42, 0x22, 0x26, 0x29, 0x92, 0xa4, 0x89,
0xc9, 0x1e, 0xea, 0xf9, 0xb2, 0x39, 0x25, 0x6a, 0xfc, 0xa2, 0xa2, 0x2e, 0x9d, 0x0c, 0xad, 0x37,
0xc3, 0xe0, 0xe7, 0x53, 0xda, 0xce, 0xcd, 0x29, 0x87, 0x5a, 0x68, 0xdf, 0x7e, 0x6e, 0xd6, 0xda,
0xc4, 0xec, 0x2f, 0xe3, 0x60, 0xb6, 0xca, 0x31, 0x69, 0xb0, 0x3d, 0x0e, 0x6f, 0x80, 0x8c, 0x4e,
0xa8, 0x8d, 0x44, 0x5b, 0x8b, 0x92, 0x75, 0x66, 0xd5, 0xc2, 0x3a, 0x12, 0x6d, 0x78, 0x0f, 0xa4,
0xbd, 0x80, 0x20, 0xc9, 0x83, 0xa8, 0x54, 0x2b, 0xaf, 0x50, 0x98, 0x88, 0x01, 0xbe, 0x0e, 0x52,
0x82, 0xf7, 0x02, 0x8f, 0xe4, 0x13, 0x45, 0x63, 0x31, 0xe3, 0x44, 0x33, 0x98, 0x07, 0x69, 0xb7,
0x47, 0x7d, 0x4c, 0x82, 0x7c, 0x52, 0x1b, 0xc6, 0x53, 0xf8, 0x08, 0xc0, 0xe9, 0x7c, 0x3d, 0x5d,
0x8e, 0xfc, 0xcc, 0xc5, 0x2b, 0x97, 0x54, 0x95, 0x73, 0xae, 0x4e, 0x91, 0x84, 0x06, 0xfb, 0xb7,
0x38, 0xc8, 0x56, 0x39, 0x93, 0x01, 0xf2, 0xa4, 0x96, 0xe1, 0x16, 0x48, 0x6b, 0x19, 0x28, 0xd6,
0x22, 0x24, 0x2b, 0x60, 0x34, 0xb4, 0x52, 0x5a, 0xa5, 0x9a, 0x93, 0x52, 0xa6, 0x06, 0xfe, 0x7f,
0xe5, 0xb8, 0x0b, 0x66, 0x10, 0xee, 0x50, 0xa6, 0xd5, 0x78, 0x25, 0xaa, 0x10, 0x0f, 0xe7, 0xc1,
0x8c, 0x8f, 0x5c, 0xe2, 0x47, 0xea, 0x85, 0x13, 0x58, 0x8d, 0xf6, 0x4a, 0x70, 0x24, 0xd8, 0xd2,
0x59, 0x82, 0xb9, 0x82, 0xfb, 0x3d, 0x49, 0x1e, 0xf4, 0xb7, 0xb9, 0xa0, 0x92, 0x72, 0xe6, 0x8c,
0x91, 0x70, 0x19, 0xcc, 0x51, 0xd7, 0x6b, 0x76, 0x79, 0x20, 0x95, 0x32, 0x29, 0x15, 0xa0, 0x72,
0x69, 0x34, 0xb4, 0x32, 0x8d, 0x4a, 0x75, 0x9b, 0x07, 0xb2, 0x51, 0x73, 0x32, 0xd4, 0xf5, 0xf4,
0x10, 0xdb, 0x5f, 0x80, 0x2b, 0x63, 0x51, 0xd7, 0xa9, 0x90, 0x3c, 0x18, 0xc0, 0x16, 0x98, 0x0f,
0xdb, 0x2b, 0x9c, 0x37, 0x09, 0x93, 0x01, 0x25, 0xea, 0xf8, 0x25, 0x16, 0xe7, 0x56, 0xcb, 0x67,
0xec, 0x69, 0xcc, 0xa2, 0xf4, 0x8f, 0x98, 0xea, 0x4c, 0x06, 0x83, 0xa8, 0xa0, 0xfa, 0x3c, 0x4f,
0xad, 0x53, 0x22, 0xec, 0xaf, 0xe3, 0x20, 0x7f, 0x16, 0x0c, 0xee, 0x80, 0x0c, 0xef, 0x92, 0x00,
0xc9, 0xc9, 0x5d, 0xf6, 0xfe, 0xc5, 0x43, 0x6f, 0x8d, 0xa1, 0xea, 0x30, 0x3a, 0x13, 0xa6, 0xe9,
0xa6, 0x89, 0x9f, 0xd9, 0x34, 0x55, 0x90, 0xee, 0x75, 0xb1, 0x2e, 0x44, 0xe2, 0x3f, 0x17, 0x22,
0x42, 0xc2, 0x12, 0x48, 0x74, 0x44, 0x4b, 0x57, 0x38, 0x5b, 0xb9, 0x79, 0x3a, 0xb4, 0xf2, 0x84,
0x79, 0x1c, 0x53, 0xd6, 0x2a, 0x7f, 0x2e, 0x38, 0x2b, 0x39, 0xe8, 0xc9, 0x06, 0x11, 0x02, 0xb5,
0x88, 0xa3, 0x1c, 0x6d, 0x07, 0xc0, 0x17, 0xe9, 0xe0, 0x02, 0xc8, 0xba, 0x3e, 0xf7, 0x1e, 0x37,
0xdb, 0x84, 0xb6, 0xda, 0x52, 0x2b, 0x91, 0x70, 0xe6, 0xf4, 0xda, 0xba, 0x5e, 0x82, 0xd7, 0xc1,
0xac, 0xec, 0x37, 0x29, 0xc3, 0xa4, 0x1f, 0xe6, 0xe4, 0xa4, 0x65, 0xbf, 0xa1, 0xa6, 0x36, 0x05,
0x33, 0x1b, 0x1c, 0x13, 0x1f, 0x7e, 0x04, 0x12, 0xf7, 0xc8, 0x20, 0xbc, 0x2c, 0x2a, 0x1f, 0x9c,
0x0e, 0xad, 0xf7, 0xa6, 0xfa, 0x56, 0x12, 0x86, 0xd5, 0x85, 0xc3, 0xe4, 0xf4, 0xd0, 0xa7, 0xae,
0x28, 0xbb, 0x03, 0x49, 0x44, 0x69, 0x9d, 0xf4, 0x2b, 0x6a, 0xe0, 0x28, 0x12, 0xd5, 0xbc, 0x0f,
0xf5, 0x1f, 0x99, 0x3e, 0x50, 0x4e, 0x38, 0xb9, 0xfd, 0xb3, 0x01, 0xc0, 0xe4, 0xfe, 0x83, 0x6f,
0x81, 0xcc, 0xce, 0x66, 0xad, 0xfe, 0x61, 0x63, 0xb3, 0x5e, 0xcb, 0xc5, 0x0a, 0x6f, 0x1c, 0x1c,
0x16, 0x5f, 0x9b, 0x98, 0x77, 0x18, 0x26, 0x7b, 0x94, 0x11, 0x0c, 0x8b, 0x20, 0xb5, 0xb9, 0x55,
0xd9, 0xaa, 0xed, 0xe6, 0x8c, 0xc2, 0xfc, 0xc1, 0x61, 0x31, 0x37, 0x71, 0xda, 0xe4, 0x2e, 0xc7,
0x03, 0xf8, 0x36, 0xc8, 0x6e, 0x6d, 0x7e, 0xbc, 0xdb, 0x5c, 0xab, 0xd5, 0x9c, 0xfa, 0xfd, 0xfb,
0xb9, 0x78, 0xe1, 0xfa, 0xc1, 0x61, 0xf1, 0xda, 0xc4, 0x6f, 0x8b, 0xf9, 0x83, 0xe8, 0x7c, 0xa9,
0xb0, 0xf5, 0x87, 0x75, 0x67, 0x57, 0x33, 0x26, 0xfe, 0x19, 0xb6, 0xbe, 0x4f, 0x82, 0x81, 0x22,
0x2d, 0xcc, 0x7e, 0xf5, 0xa3, 0x19, 0x7b, 0xfa, 0x93, 0x19, 0xbb, 0xfd, 0x8b, 0x01, 0x8a, 0xff,
0xd6, 0x40, 0xf0, 0x12, 0xc8, 0x3c, 0xdf, 0x72, 0x2e, 0x06, 0x97, 0x40, 0xb2, 0xc1, 0xa8, 0xcc,
0x19, 0x05, 0xeb, 0xe0, 0xb0, 0x78, 0xe3, 0x25, 0x70, 0x85, 0x52, 0x2e, 0xb0, 0x0c, 0xd2, 0x1b,
0xb4, 0x15, 0x20, 0x49, 0x72, 0xf1, 0x82, 0x7d, 0x70, 0x58, 0x34, 0xcf, 0xf0, 0x8e, 0xbc, 0x14,
0xe0, 0x2e, 0x61, 0x44, 0x50, 0x91, 0x4b, 0x9c, 0x0b, 0x88, 0xbc, 0x0a, 0x49, 0x95, 0x4a, 0xc5,
0x39, 0xfa, 0xd3, 0x8c, 0x3d, 0x1d, 0x99, 0xc6, 0xd1, 0xc8, 0x34, 0x9e, 0x8d, 0x4c, 0xe3, 0x8f,
0x91, 0x69, 0x7c, 0x73, 0x6c, 0xc6, 0x9e, 0x1d, 0x9b, 0xb1, 0xdf, 0x8f, 0xcd, 0xd8, 0xa7, 0xef,
0x4c, 0x55, 0xbc, 0xca, 0x45, 0xe7, 0x13, 0xf5, 0xde, 0xd1, 0xed, 0x5c, 0xee, 0x47, 0xdf, 0xbf,
0xbf, 0x7e, 0xdc, 0x94, 0x7e, 0xcb, 0xbc, 0xfb, 0x57, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8a, 0x2c,
0x44, 0x38, 0x1d, 0x09, 0x00, 0x00,
// 1096 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x56, 0x4f, 0x6f, 0x1b, 0xc5,
0x1b, 0xf6, 0xda, 0x8e, 0x9d, 0x4c, 0xfd, 0x6b, 0xdc, 0xf9, 0x25, 0xe0, 0xb8, 0x65, 0xd7, 0xd9,
0x0a, 0x94, 0x14, 0xd5, 0x26, 0x01, 0x09, 0xd4, 0x5b, 0xfc, 0x87, 0xc6, 0x2d, 0xf9, 0xa3, 0x4d,
0x53, 0x1a, 0x24, 0x64, 0x8d, 0x77, 0x27, 0xf6, 0xd0, 0xdd, 0x19, 0x6b, 0x67, 0x9c, 0xda, 0x39,
0x71, 0x44, 0xe1, 0x82, 0x38, 0x71, 0x89, 0x84, 0x44, 0x0f, 0xfd, 0x02, 0x7c, 0x03, 0x0e, 0xb9,
0x20, 0xf5, 0xc8, 0xc9, 0x82, 0x44, 0x7c, 0x81, 0x1c, 0x73, 0x42, 0x33, 0xb3, 0xc6, 0x86, 0x34,
0x21, 0x54, 0x5c, 0xbc, 0x3b, 0xef, 0x3c, 0xcf, 0xf3, 0xce, 0xfb, 0xcc, 0x3b, 0xeb, 0x01, 0xf3,
0xbd, 0xd2, 0x33, 0xc4, 0x83, 0x12, 0xa1, 0x02, 0x87, 0x14, 0xf9, 0x25, 0xd1, 0xef, 0x60, 0xae,
0x7f, 0x8b, 0x9d, 0x90, 0x09, 0x06, 0x67, 0x25, 0xc0, 0x2b, 0xf6, 0x8a, 0xfa, 0xb9, 0xb7, 0xd4,
0xc4, 0x02, 0x2d, 0xe5, 0x67, 0x5a, 0xac, 0xc5, 0x14, 0xa2, 0x24, 0xdf, 0x34, 0xd8, 0x6e, 0x82,
0xe9, 0x15, 0xd7, 0xc5, 0x9c, 0x3f, 0xea, 0x77, 0xf0, 0x26, 0x0a, 0x51, 0x00, 0xeb, 0x60, 0x62,
0x0f, 0xf9, 0x5d, 0x9c, 0x33, 0x0a, 0xc6, 0xc2, 0xf5, 0xe5, 0xf9, 0xe2, 0x2b, 0xf5, 0x8a, 0x23,
0x5a, 0x39, 0x7b, 0x3a, 0xb0, 0x32, 0x7d, 0x14, 0xf8, 0xf7, 0x6c, 0xc5, 0xb4, 0x1d, 0xad, 0x70,
0x2f, 0xf9, 0xdd, 0xf7, 0x96, 0x61, 0xff, 0x6c, 0x80, 0x8c, 0x46, 0x57, 0x18, 0xdd, 0x25, 0x2d,
0xf8, 0x04, 0x80, 0x0e, 0x0e, 0x03, 0xc2, 0x39, 0x61, 0xf4, 0xea, 0x69, 0x66, 0x4f, 0x07, 0xd6,
0x0d, 0x9d, 0x66, 0x44, 0xb7, 0x9d, 0x31, 0x2d, 0xf8, 0x39, 0x48, 0x23, 0xcf, 0x0b, 0x31, 0xe7,
0xb9, 0x78, 0xc1, 0x58, 0xc8, 0x94, 0x2b, 0xa7, 0x03, 0xeb, 0xba, 0xe6, 0x44, 0x13, 0xf6, 0xd9,
0xc0, 0xba, 0xdb, 0x22, 0xa2, 0xdd, 0x6d, 0x16, 0x5d, 0x16, 0x94, 0x5c, 0xc6, 0x03, 0xc6, 0xa3,
0xc7, 0x5d, 0xee, 0x3d, 0x8d, 0xcc, 0x5c, 0x71, 0xdd, 0x15, 0xcd, 0x70, 0x86, 0x9a, 0x51, 0x3d,
0xbf, 0xc7, 0x41, 0x4a, 0x59, 0xc5, 0xa1, 0x00, 0xd0, 0x65, 0x1e, 0x6e, 0x74, 0x3b, 0x3e, 0x43,
0x5e, 0x03, 0xa9, 0xc5, 0xaa, 0x8a, 0xae, 0x2d, 0xdf, 0xbe, 0xb4, 0x22, 0x6d, 0x45, 0x79, 0xfe,
0x68, 0x60, 0xc5, 0x4e, 0x07, 0xd6, 0x9c, 0x5e, 0xe3, 0x79, 0x31, 0xdb, 0xc9, 0xca, 0xe0, 0xb6,
0x8a, 0x69, 0x2a, 0xfc, 0xd6, 0x00, 0x26, 0xa1, 0x5c, 0x20, 0x2a, 0x08, 0x12, 0xb8, 0xe1, 0xe1,
0x5d, 0xd4, 0xf5, 0x45, 0x63, 0xcc, 0xd4, 0xf8, 0x55, 0x4d, 0x5d, 0x3c, 0x1d, 0x58, 0x6f, 0xeb,
0xe4, 0x97, 0x4b, 0xda, 0xce, 0xad, 0x31, 0x40, 0x55, 0xcf, 0x6f, 0x8e, 0xac, 0x7f, 0x00, 0x60,
0x80, 0x7a, 0x0d, 0x99, 0xa8, 0xa1, 0xca, 0xe0, 0x64, 0x1f, 0xe7, 0x12, 0x05, 0x63, 0x21, 0x59,
0x7e, 0x6b, 0x54, 0xe1, 0x79, 0x8c, 0xed, 0x4c, 0x07, 0xa8, 0xf7, 0x29, 0xe2, 0x41, 0x85, 0x79,
0x78, 0x8b, 0xec, 0xeb, 0xbe, 0x89, 0xd9, 0x5f, 0xc6, 0xc1, 0xa4, 0x0c, 0xd5, 0xe9, 0x2e, 0x83,
0x37, 0xc1, 0x94, 0x62, 0xb4, 0x11, 0x6f, 0x2b, 0x83, 0x33, 0xce, 0xa4, 0x0c, 0xac, 0x22, 0xde,
0x86, 0x0f, 0x41, 0xda, 0x0d, 0x31, 0x12, 0x2c, 0x8c, 0xb6, 0x7d, 0xe9, 0x35, 0x36, 0x39, 0x52,
0x80, 0x6f, 0x80, 0x14, 0x67, 0xdd, 0xd0, 0xd5, 0x8b, 0x9f, 0x72, 0xa2, 0x11, 0xcc, 0x81, 0x74,
0xb3, 0x4b, 0x7c, 0x0f, 0x87, 0xb9, 0xa4, 0x9a, 0x18, 0x0e, 0xe1, 0x13, 0x00, 0xc7, 0xbd, 0x73,
0xd5, 0xd6, 0xe6, 0x26, 0xae, 0xde, 0x05, 0x49, 0xd9, 0x05, 0xce, 0x8d, 0x31, 0x11, 0x3d, 0x61,
0x3f, 0x8f, 0x83, 0x4c, 0x85, 0x51, 0x11, 0x22, 0x57, 0x28, 0x1b, 0x6e, 0x83, 0xb4, 0xb2, 0x81,
0x78, 0xca, 0x84, 0x64, 0x19, 0x1c, 0x0f, 0xac, 0x94, 0x72, 0xa9, 0xea, 0xa4, 0xe4, 0x54, 0xdd,
0xfb, 0x6f, 0xed, 0xb8, 0x0f, 0x26, 0x90, 0x17, 0x10, 0xaa, 0xdc, 0x78, 0x2d, 0x29, 0xcd, 0x87,
0x33, 0x60, 0xc2, 0x47, 0x4d, 0xec, 0x47, 0xee, 0xe9, 0x01, 0xac, 0x44, 0x6b, 0xc5, 0x5e, 0x64,
0xd8, 0xe2, 0x45, 0x86, 0x35, 0x39, 0xf3, 0xbb, 0x02, 0x3f, 0xea, 0x6d, 0x32, 0x4e, 0x04, 0x61,
0xd4, 0x19, 0x32, 0xed, 0x7d, 0x30, 0x3d, 0x74, 0x69, 0x95, 0x70, 0xc1, 0xc2, 0x3e, 0x6c, 0x81,
0x19, 0xdd, 0x2f, 0x7a, 0xdc, 0xc0, 0x54, 0x84, 0x04, 0xcb, 0xb3, 0x99, 0x58, 0xb8, 0xb6, 0x5c,
0xba, 0x20, 0xc9, 0x50, 0x45, 0x1a, 0x1a, 0x29, 0xd5, 0xa8, 0x08, 0xfb, 0xd1, 0x0e, 0xa9, 0xc3,
0x3e, 0x16, 0x27, 0x98, 0xdb, 0x5f, 0xc7, 0x41, 0xee, 0x22, 0x1a, 0xdc, 0x06, 0x53, 0xac, 0x83,
0x43, 0x24, 0x46, 0x1f, 0xba, 0x0f, 0xaf, 0x9e, 0x7a, 0x63, 0x48, 0x95, 0x27, 0xd5, 0x19, 0x29,
0x8d, 0x77, 0x41, 0xfc, 0xc2, 0x2e, 0xa8, 0x80, 0x74, 0xb7, 0xe3, 0x29, 0x67, 0x13, 0xff, 0xda,
0xd9, 0x88, 0x09, 0x8b, 0x20, 0x11, 0xf0, 0x96, 0xda, 0xb2, 0x4c, 0xf9, 0xd6, 0xd9, 0xc0, 0xca,
0x61, 0xea, 0x32, 0x8f, 0xd0, 0x56, 0xe9, 0x0b, 0xce, 0x68, 0xd1, 0x41, 0xcf, 0xd6, 0x30, 0xe7,
0xa8, 0x85, 0x1d, 0x09, 0xb4, 0x1d, 0x00, 0xcf, 0xcb, 0xc1, 0x79, 0x90, 0x69, 0xfa, 0xcc, 0x7d,
0xda, 0x68, 0x63, 0xd2, 0x6a, 0x0b, 0xe5, 0x44, 0xc2, 0xb9, 0xa6, 0x62, 0xab, 0x2a, 0x04, 0xe7,
0xc0, 0xa4, 0xe8, 0x35, 0x08, 0xf5, 0x70, 0x4f, 0xd7, 0xe4, 0xa4, 0x45, 0xaf, 0x2e, 0x87, 0x36,
0x01, 0x13, 0x6b, 0xcc, 0xc3, 0x3e, 0x7c, 0x00, 0x12, 0x0f, 0x71, 0x5f, 0x9f, 0xfe, 0xf2, 0x47,
0x67, 0x03, 0xeb, 0x83, 0xb1, 0x46, 0x14, 0x98, 0x7a, 0xf2, 0x6b, 0x44, 0xc5, 0xf8, 0xab, 0x4f,
0x9a, 0xbc, 0xd4, 0xec, 0x0b, 0xcc, 0x8b, 0xab, 0xb8, 0x57, 0x96, 0x2f, 0x8e, 0x14, 0x91, 0xdd,
0xf8, 0x58, 0xfd, 0xcb, 0xa9, 0x13, 0xe2, 0xe8, 0xc1, 0x9d, 0x1f, 0x0d, 0x00, 0x46, 0x1f, 0x47,
0xf8, 0x0e, 0x98, 0xda, 0x5e, 0xaf, 0xd6, 0x3e, 0xae, 0xaf, 0xd7, 0xaa, 0xd9, 0x58, 0xfe, 0xcd,
0x83, 0xc3, 0xc2, 0xff, 0x47, 0xd3, 0xdb, 0xd4, 0xc3, 0xbb, 0x84, 0x62, 0x0f, 0x16, 0x40, 0x6a,
0x7d, 0xa3, 0xbc, 0x51, 0xdd, 0xc9, 0x1a, 0xf9, 0x99, 0x83, 0xc3, 0x42, 0x76, 0x04, 0x5a, 0x67,
0x4d, 0xe6, 0xf5, 0xe1, 0xbb, 0x20, 0xb3, 0xb1, 0xfe, 0xc9, 0x4e, 0x63, 0xa5, 0x5a, 0x75, 0x6a,
0x5b, 0x5b, 0xd9, 0x78, 0x7e, 0xee, 0xe0, 0xb0, 0x30, 0x3b, 0xc2, 0x6d, 0x50, 0xbf, 0x1f, 0x1d,
0x18, 0x99, 0xb6, 0xf6, 0xb8, 0xe6, 0xec, 0x28, 0xc5, 0xc4, 0xdf, 0xd3, 0xd6, 0xf6, 0x70, 0xd8,
0x97, 0xa2, 0xf9, 0xc9, 0xaf, 0x7e, 0x30, 0x63, 0x2f, 0x9e, 0x9b, 0xb1, 0x3b, 0x3f, 0x19, 0xa0,
0xf0, 0x4f, 0x0d, 0x04, 0xff, 0x07, 0xa6, 0xfe, 0x5c, 0x72, 0x36, 0x06, 0x17, 0x41, 0xb2, 0x4e,
0x89, 0xc8, 0x1a, 0x79, 0xeb, 0xe0, 0xb0, 0x70, 0xf3, 0x15, 0x74, 0xc9, 0x92, 0x10, 0x58, 0x02,
0xe9, 0x35, 0xd2, 0x0a, 0x91, 0xc0, 0xd9, 0x78, 0xde, 0x3e, 0x38, 0x2c, 0x98, 0x17, 0xa0, 0x23,
0x94, 0x24, 0xdc, 0xc7, 0x14, 0x73, 0xc2, 0xb3, 0x89, 0x4b, 0x09, 0x11, 0x2a, 0x9f, 0x94, 0xa5,
0x94, 0x9d, 0xa3, 0xdf, 0xcc, 0xd8, 0x8b, 0x63, 0xd3, 0x38, 0x3a, 0x36, 0x8d, 0x97, 0xc7, 0xa6,
0xf1, 0xeb, 0xb1, 0x69, 0x7c, 0x73, 0x62, 0xc6, 0x5e, 0x9e, 0x98, 0xb1, 0x5f, 0x4e, 0xcc, 0xd8,
0x67, 0xef, 0x8d, 0xed, 0x78, 0x85, 0xf1, 0x40, 0xfe, 0x6d, 0xa8, 0x1b, 0x91, 0x57, 0xea, 0x45,
0xcf, 0xbf, 0x5e, 0x8d, 0x9a, 0x29, 0x75, 0xd1, 0x79, 0xff, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff,
0x6b, 0xe9, 0x46, 0x0d, 0x3a, 0x09, 0x00, 0x00,
}
func (this *AccessTypeParam) Equal(that interface{}) bool {
@@ -610,6 +610,9 @@ func (this *Params) Equal(that interface{}) bool {
if this.InstantiateDefaultPermission != that1.InstantiateDefaultPermission {
return false
}
if this.MaxWasmCodeSize != that1.MaxWasmCodeSize {
return false
}
return true
}
func (this *CodeInfo) Equal(that interface{}) bool {
@@ -682,9 +685,6 @@ func (this *ContractInfo) Equal(that interface{}) bool {
if !this.Created.Equal(that1.Created) {
return false
}
if this.IBCPortID != that1.IBCPortID {
return false
}
return true
}
func (this *ContractHistory) Equal(that interface{}) bool {
@@ -886,6 +886,11 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if m.MaxWasmCodeSize != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.MaxWasmCodeSize))
i--
dAtA[i] = 0x18
}
if m.InstantiateDefaultPermission != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.InstantiateDefaultPermission))
i--
@@ -985,13 +990,6 @@ func (m *ContractInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.IBCPortID) > 0 {
i -= len(m.IBCPortID)
copy(dAtA[i:], m.IBCPortID)
i = encodeVarintTypes(dAtA, i, uint64(len(m.IBCPortID)))
i--
dAtA[i] = 0x32
}
if m.Created != nil {
{
size, err := m.Created.MarshalToSizedBuffer(dAtA[:i])
@@ -1242,6 +1240,9 @@ func (m *Params) Size() (n int) {
if m.InstantiateDefaultPermission != 0 {
n += 1 + sovTypes(uint64(m.InstantiateDefaultPermission))
}
if m.MaxWasmCodeSize != 0 {
n += 1 + sovTypes(uint64(m.MaxWasmCodeSize))
}
return n
}
@@ -1297,10 +1298,6 @@ func (m *ContractInfo) Size() (n int) {
l = m.Created.Size()
n += 1 + l + sovTypes(uint64(l))
}
l = len(m.IBCPortID)
if l > 0 {
n += 1 + l + sovTypes(uint64(l))
}
return n
}
@@ -1639,6 +1636,25 @@ func (m *Params) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MaxWasmCodeSize", wireType)
}
m.MaxWasmCodeSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MaxWasmCodeSize |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
@@ -2065,38 +2081,6 @@ func (m *ContractInfo) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field IBCPortID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
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 ErrInvalidLengthTypes
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.IBCPortID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])

1
x/wasm/internal/types/types.proto
View File

@@ -32,6 +32,7 @@ message Params {
option (gogoproto.goproto_stringer) = false;
AccessConfig code_upload_access = 1 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"code_upload_access\""];
AccessType instantiate_default_permission = 2 [(gogoproto.moretags) = "yaml:\"instantiate_default_permission\""];
uint64 max_wasm_code_size = 3 [(gogoproto.moretags) = "yaml:\"max_wasm_code_size\""];
}
// CodeInfo is data for the uploaded contract WASM code