Fix comments

x/wasm/client/cli/gov_tx.go

@@ -129,7 +129,7 @@ func parseVerificationFlags(gzippedWasm []byte, flags *flag.FlagSet) (string, st
 		// wasm is gzipped in parseStoreCodeArgs
 		// checksum generation will be decoupled here
 		// reference https://github.com/CosmWasm/wasmvm/issues/359
-		raw, err := ioutils.UncompressWithLimit(gzippedWasm, uint64(types.MaxWasmSize))
+		raw, err := ioutils.Uncompress(gzippedWasm, int64(types.MaxWasmSize))
 		if err != nil {
 			return "", "", nil, fmt.Errorf("invalid zip: %w", err)
 		}

x/wasm/ioutils/ioutil.go

@@ -11,22 +11,8 @@ import (
 )
 
 // Uncompress expects a valid gzip source to unpack or fails. See IsGzip
-func Uncompress(gzipSrc []byte) ([]byte, error) {
-	zr, err := gzip.NewReader(bytes.NewReader(gzipSrc))
-	if err != nil {
-		return nil, err
-	}
-	zr.Multistream(false)
-	defer zr.Close()
-
-	bz, err := io.ReadAll(zr)
-	return bz, err
-}
-
-// UncompressWithLimit fails if wasm size exceeds the limit.
-// It expects a valid gzip source to unpack or fails. See IsGzip
-func UncompressWithLimit(gzipSrc []byte, limit uint64) ([]byte, error) {
-	if uint64(len(gzipSrc)) > limit {
+func Uncompress(gzipSrc []byte, limit int64) ([]byte, error) {
+	if int64(len(gzipSrc)) > limit {
 		return nil, types.ErrLimit.Wrapf("max %d bytes", limit)
 	}
 	zr, err := gzip.NewReader(bytes.NewReader(gzipSrc))
@@ -35,7 +21,7 @@ func UncompressWithLimit(gzipSrc []byte, limit uint64) ([]byte, error) {
 	}
 	zr.Multistream(false)
 	defer zr.Close()
-	bz, err := io.ReadAll(LimitReader(zr, int64(limit)))
+	bz, err := io.ReadAll(LimitReader(zr, limit))
 	if types.ErrLimit.Is(err) {
 		return nil, errorsmod.Wrapf(err, "max %d bytes", limit)
 	}

x/wasm/ioutils/ioutil_test.go

@@ -23,51 +23,6 @@ func TestUncompress(t *testing.T) {
 	wasmGzipped, err := os.ReadFile("../keeper/testdata/hackatom.wasm.gzip")
 	require.NoError(t, err)
 
-	specs := map[string]struct {
-		src       []byte
-		expError  error
-		expResult []byte
-	}{
-		"handle wasm compressed": {
-			src:       wasmGzipped,
-			expResult: wasmRaw,
-		},
-		"handle gzip identifier only": {
-			src:      gzipIdent,
-			expError: io.ErrUnexpectedEOF,
-		},
-		"handle broken gzip": {
-			src:      append(gzipIdent, byte(0x1)),
-			expError: io.ErrUnexpectedEOF,
-		},
-		"handle incomplete gzip": {
-			src:      wasmGzipped[:len(wasmGzipped)-5],
-			expError: io.ErrUnexpectedEOF,
-		},
-		"handle limit gzip output": {
-			src:       asGzip(bytes.Repeat([]byte{0x1}, 400_000)),
-			expResult: bytes.Repeat([]byte{0x1}, 400_000),
-		},
-	}
-	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)
-			if spec.expError != nil {
-				return
-			}
-			assert.Equal(t, spec.expResult, r)
-		})
-	}
-}
-
-func TestUncompressWithLimit(t *testing.T) {
-	wasmRaw, err := os.ReadFile("../keeper/testdata/hackatom.wasm")
-	require.NoError(t, err)
-
-	wasmGzipped, err := os.ReadFile("../keeper/testdata/hackatom.wasm.gzip")
-	require.NoError(t, err)
-
 	const maxSize = 400_000
 
 	specs := map[string]struct {
@@ -106,7 +61,7 @@ func TestUncompressWithLimit(t *testing.T) {
 	}
 	for msg, spec := range specs {
 		t.Run(msg, func(t *testing.T) {
-			r, err := UncompressWithLimit(spec.src, maxSize)
+			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

x/wasm/keeper/genesis_test.go

@@ -121,6 +121,8 @@ func TestGenesisExportImport(t *testing.T) {
 		return false
 	})
 
+	types.MaxWasmSize = 1
+
 	// re-import
 	var importState types.GenesisState
 	err = dstKeeper.cdc.UnmarshalJSON(exportedGenesis, &importState)
@@ -133,6 +135,12 @@ func TestGenesisExportImport(t *testing.T) {
 	srcIT := srcCtx.KVStore(wasmKeeper.storeKey).Iterator(nil, nil)
 	dstIT := dstCtx.KVStore(dstKeeper.storeKey).Iterator(nil, nil)
 
+	t.Cleanup(func() {
+		types.MaxWasmSize = 800 * 1024
+		srcIT.Close()
+		dstIT.Close()
+	})
+
 	for i := 0; srcIT.Valid(); i++ {
 		require.True(t, dstIT.Valid(), "[%s] destination DB has less elements than source. Missing: %x", wasmKeeper.storeKey.Name(), srcIT.Key())
 		require.Equal(t, srcIT.Key(), dstIT.Key(), i)
@@ -143,8 +151,6 @@ func TestGenesisExportImport(t *testing.T) {
 	if !assert.False(t, dstIT.Valid()) {
 		t.Fatalf("dest Iterator still has key :%X", dstIT.Key())
 	}
-	srcIT.Close()
-	dstIT.Close()
 }
 
 func TestGenesisInit(t *testing.T) {

x/wasm/keeper/keeper.go

@@ -170,7 +170,7 @@ func (k Keeper) create(ctx sdk.Context, creator sdk.AccAddress, wasmCode []byte,
 
 	if ioutils.IsGzip(wasmCode) {
 		ctx.GasMeter().ConsumeGas(k.gasRegister.UncompressCosts(len(wasmCode)), "Uncompress gzip bytecode")
-		wasmCode, err = ioutils.UncompressWithLimit(wasmCode, uint64(types.MaxWasmSize))
+		wasmCode, err = ioutils.Uncompress(wasmCode, int64(types.MaxWasmSize))
 		if err != nil {
 			return 0, checksum, types.ErrCreateFailed.Wrap(errorsmod.Wrap(err, "uncompress wasm archive").Error())
 		}
@@ -212,7 +212,7 @@ func (k Keeper) storeCodeInfo(ctx sdk.Context, codeID uint64, codeInfo types.Cod
 func (k Keeper) importCode(ctx sdk.Context, codeID uint64, codeInfo types.CodeInfo, wasmCode []byte) error {
 	if ioutils.IsGzip(wasmCode) {
 		var err error
-		wasmCode, err = ioutils.UncompressWithLimit(wasmCode, uint64(types.MaxWasmSize))
+		wasmCode, err = ioutils.Uncompress(wasmCode, math.MaxInt64)
 		if err != nil {
 			return types.ErrCreateFailed.Wrap(errorsmod.Wrap(err, "uncompress wasm archive").Error())
 		}

x/wasm/keeper/snapshotter.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"encoding/hex"
 	"io"
+	"math"
 
 	errorsmod "cosmossdk.io/errors"
 	"github.com/cometbft/cometbft/libs/log"
@@ -99,7 +100,7 @@ func restoreV1(_ sdk.Context, k *Keeper, compressedCode []byte) error {
 	if !ioutils.IsGzip(compressedCode) {
 		return types.ErrInvalid.Wrap("not a gzip")
 	}
-	wasmCode, err := ioutils.Uncompress(compressedCode)
+	wasmCode, err := ioutils.Uncompress(compressedCode, math.MaxInt64)
 	if err != nil {
 		return errorsmod.Wrap(types.ErrCreateFailed, err.Error())
 	}

x/wasm/keeper/snapshotter_integration_test.go

@@ -67,6 +67,11 @@ func TestSnapshotter(t *testing.T) {
 			require.NoError(t, err)
 			assert.NotNil(t, snapshot)
 
+			types.MaxWasmSize = 1
+			t.Cleanup(func() {
+				types.MaxWasmSize = 800 * 1024
+			})
+
 			// when snapshot imported into dest app instance
 			destWasmApp := app.SetupWithEmptyStore(t)
 			require.NoError(t, destWasmApp.SnapshotManager().Restore(*snapshot))