Merge branch '0.53' into neutron

# Conflicts:
#	docs/proto/proto-docs.md

.circleci/config.yml

@@ -61,6 +61,23 @@ jobs:
  paths:
  - ".git"
 
+ tidy-go:
+ executor: golang
+ steps:
+ - checkout
+ - run:
+ name: Check go mod tidy
+ # Use --diff when available (Go 1.23)
+ # https://github.com/golang/go/issues/27005
+ command: |
+ go mod tidy
+ CHANGES_IN_REPO=$(git status --porcelain)
+ if [[ -n "$CHANGES_IN_REPO" ]]; then
+ echo "Repository is dirty. Showing 'git status' and 'git --no-pager diff' for debugging now:"
+ git status && git --no-pager diff
+ exit 1
+ fi
+
  lint:
  docker:
  - image: golangci/golangci-lint:v1.54.2
@@ -227,31 +244,17 @@ jobs:
 
  release-tagged:
  executor: golang
- environment:
- BUILD_DIR: /tmp/workspace
  steps:
- - attach_workspace:
- at: /tmp/workspace
  - checkout
- - setup_remote_docker:
- docker_layer_caching: true
- - run:
- name: Fetch static artifact
- command: docker create --name wasmd_temp "cosmwasm/wasmd:${CIRCLE_TAG}"; docker cp wasmd_temp:/usr/bin/wasmd ${BUILD_DIR}; docker rm -f wasmd_temp
- - run:
- name: gzip
- command: tar -zcvf ${BUILD_DIR}/wasmd-${CIRCLE_TAG}-linux-amd64.tar.gz -C ${BUILD_DIR} wasmd
  - gh/setup:
- token: GITHUB_CREDS
+ token: WASMD_GITHUB_RELEASES_TOKEN
  - run:
  name: Create release
  command: |
- gh release create ${CIRCLE_TAG} ${BUILD_DIR}/wasmd-${CIRCLE_TAG}-linux-amd64.tar.gz \
+ gh release create ${CIRCLE_TAG} \
  --title "$CIRCLE_TAG" \
  --draft \
- --notes "# Wasmd ${CIRCLE_TAG} Release
- See the [CHANGELOG](https://github.com/CosmWasm/wasmd/blob/${CIRCLE_TAG}/CHANGELOG.md) for details on the changes in this version.
- "
+ --notes "See the [CHANGELOG](https://github.com/CosmWasm/wasmd/blob/${CIRCLE_TAG}/CHANGELOG.md) for details on the changes in this version."
 
 workflows:
  test-suite:
@@ -275,6 +278,9 @@ workflows:
  tags:
  only:
  - /^v.*/
+ - tidy-go:
+ requires:
+ - setup-dependencies
  - lint:
  requires:
  - setup-dependencies
@@ -294,8 +300,6 @@ workflows:
  requires:
  - setup-dependencies
  - release-tagged:
- requires:
- - docker-tagged
  filters:
  tags:
  only:

.github/workflows/proto-buf-publisher.yml

@@ -17,7 +17,7 @@ jobs:
  runs-on: ubuntu-latest
  steps:
  - uses: actions/checkout@v4
- - uses: bufbuild/buf-setup-action@v1.30.1
+ - uses: bufbuild/buf-setup-action@v1.37.0
 
  # lint checks
  - uses: bufbuild/buf-lint-action@v1

Dockerfile

@@ -17,10 +17,10 @@ RUN apk add git
 WORKDIR /code
 COPY . /code/
 # See https://github.com/CosmWasm/wasmvm/releases
-ADD https://github.com/CosmWasm/wasmvm/releases/download/v2.0.0/libwasmvm_muslc.aarch64.a /lib/libwasmvm_muslc.aarch64.a
-ADD https://github.com/CosmWasm/wasmvm/releases/download/v2.0.0/libwasmvm_muslc.x86_64.a /lib/libwasmvm_muslc.x86_64.a
-RUN sha256sum /lib/libwasmvm_muslc.aarch64.a | grep 3b478b3e51d31e53ce9324a8895d2cd7278af5179b9a02ea55d8627958e42afa
-RUN sha256sum /lib/libwasmvm_muslc.x86_64.a | grep ca08bb7b73b49b483611d9755bb8455620bb8c0faf3014400908ed49bf3b19a5
+ADD https://github.com/CosmWasm/wasmvm/releases/download/v2.1.2/libwasmvm_muslc.aarch64.a /lib/libwasmvm_muslc.aarch64.a
+ADD https://github.com/CosmWasm/wasmvm/releases/download/v2.1.2/libwasmvm_muslc.x86_64.a /lib/libwasmvm_muslc.x86_64.a
+RUN sha256sum /lib/libwasmvm_muslc.aarch64.a | grep 0881c5b463e89e229b06370e9e2961aec0a5c636772d5142c68d351564464a66
+RUN sha256sum /lib/libwasmvm_muslc.x86_64.a | grep 58e1f6bfa89ee390cb9abc69a5bc126029a497fe09dd399f38a82d0d86fe95ef
 
 # force it to use static lib (from above) not standard libgo_cosmwasm.so file
 RUN LEDGER_ENABLED=false BUILD_TAGS=muslc LINK_STATICALLY=true make build

INTEGRATION.md

@@ -4,7 +4,7 @@
 
 If you want to use Wasm in your own app, here is how you can get this working
 quickly and easily. 
-First start with This [article](https://medium.com/cosmwasm/cosmwasm-for-ctos-iv-native-integrations-713140bf75fc) 
+First start with this [article](https://medium.com/cosmwasm/cosmwasm-for-ctos-iv-native-integrations-713140bf75fc) 
 in the "CosmWasm for CTOs" series that gives you a high level view. 
 Then check to make sure you fit the pre-requisites,
 then integrate the `x/wasm` module as described below, and finally, you
@@ -41,14 +41,14 @@ hardware it runs on.
 
 We currently only support Intel/AMD64 CPUs and OSX or Linux. For Linux, the standard build
 commands work for `glibc` systems (Ubuntu, Debian, CentOS, etc). If you wish to compile
-for a `muslc` based system (like alpine), you need to compile a static library wasmvm locally
+for a `muslc` based system (like Alpine), you need to compile the static library `wasmvm` locally
 and compile go with the `muslc` build tag. Or just use the [Dockerfile](./Dockerfile),
-which builds a static go binary in an alpine system.
+which builds a static go binary in an Alpine system.
 
 This limit comes from the Rust dll we use to run the wasm code, which comes 
 from [`wasmvm`](https://github.com/CosmWasm/wasmvm). There are open issues
 for adding [ARM support](https://github.com/CosmWasm/wasmvm/issues/53), and
-adding [Windows support](https://github.com/CosmWasm/wasmvm/issues/28).
+[Windows support](https://github.com/CosmWasm/wasmvm/issues/28).
 However, these issues are not high on the roadmap and unless you are championing
 them, please count on the current limits for the near future.
 
@@ -60,15 +60,15 @@ plenty that can be done there, and lots to learn.
 
 Once you are happy with it and want to use a custom Cosmos SDK app, 
 you may consider simply forking `wasmd`. *I highly advise against this*. 
-You should try one of the methods below.
+Instead you should try one of the methods below.
 
 ## Integrating wasmd
 
 ### As external module
 
 The simplest way to use `wasmd` is just to import `x/wasm` and wire it up
-in `app.go`. You now have access to the whole module and you custom modules
-running side by side. (But the CosmWasm contracts will only have access
+in `app.go`. You now have access to the whole module and your custom modules
+running side by side. (But the CosmWasm contracts will still only have access
 to `bank` and `staking`... more below on [customization](#Adding-Custom-Hooks)).
 
 The requirement here is that you have imported the standard sdk modules
@@ -133,6 +133,8 @@ to check balances.
 If you look at the unit tests in [`x/wasm/internal/keeper`](https://github.com/CosmWasm/wasmd/tree/master/x/wasm/internal/keeper),
 it should be pretty straight forward.
 
+<!-- TODO dead link above -->
+
 ### Extending the Contract Interface
 
 If you want to let the contracts access your native modules, the first
@@ -141,7 +143,7 @@ and then add them as `CosmosMsg::Custom` and `QueryRequest::Custom`
 variants. You can see an example of the [bindings for Terra](https://github.com/CosmWasm/terra-contracts/tree/master/packages/bindings).
 
 Once you have those bindings, use them to build a 
-[simple contact using much of the API](https://github.com/CosmWasm/terra-contracts/tree/master/contracts/maker).
+[simple contract using much of the API](https://github.com/CosmWasm/terra-contracts/tree/master/contracts/maker).
 Don't worry too much about the details, this should be usable, but mainly
 you will want to upload it to your chain and use for integration tests
 with your native Cosmos SDK modules. Once that is solid, then add more
@@ -153,7 +155,7 @@ the contracts (provide static data for exchange rates when your contracts
 query it). You can see an example of [mocks for Terra contracts](https://github.com/CosmWasm/terra-contracts/tree/master/packages/mocks).
 
 What these three steps provide is basically a chain-specific extension to the CosmWasm contract SDK.
-Any CosmWasm contract can import you library (bindings and mocks) and easily get started using
+Any CosmWasm contract can import your library (bindings and mocks) and easily get started using
 your custom, chain-specific extensions just as easily as using the standard CosmWasm interfaces.
 What is left is actually wiring them up in your chain so they work as desired.
 
@@ -163,25 +165,25 @@ mean that only blockchain apps that explicitly declare their support for the `XY
 (please rename XYZ to your project name) will allow the contract to be uploaded, and others
 get error messages upon upload, not while running a critical feature later on.
 You just need to add [a line like this](https://github.com/CosmWasm/terra-contracts/blob/master/packages/bindings/src/lib.rs#L13-L16)
-to your binding library to add the requirement to any contract that imports your `bindings` lib.
+to your bindings library to add the requirement to any contract that imports your `bindings` lib.
 
 ### Calling into the SDK
 
 Before I show how this works, I want to remind you, if you have copied `x/wasm`,
 please **do not make these changes to `x/wasm`**.
 
-We will add a new module, eg. `x/contracts`, that will contain custom
+We will add a new module, e.g. `x/contracts`, that will contain custom
 bindings between CosmWasm contracts and your native modules. There are two entry points
 for you to use. The first is 
 [`CustomQuerier`](https://github.com/CosmWasm/wasmd/blob/v0.8.0-rc1/x/wasm/internal/keeper/query_plugins.go#L35),
 which allows you to handle your custom queries. The second is 
-[`CustomEncoder`](https://github.com/CosmWasm/wasmd/blob/v0.8.0-rc1/x/wasm/internal/keeper/handler_plugin.go#L30)
+[`CustomEncoder`](https://github.com/CosmWasm/wasmd/blob/v0.8.0-rc1/x/wasm/internal/keeper/handler_plugin.go#L30),
 which allows you to convert the `CosmosMsg::Custom(YourMessage)` types to `[]sdk.Msg` to be dispatched.
 
 Writing stubs for these is rather simple. You can look at the `reflect_test.go` file to see this in action.
 In particular, here [we define a `CustomQuerier`](https://github.com/CosmWasm/wasmd/blob/v0.8.0-rc1/x/wasm/internal/keeper/reflect_test.go#L355-L385),
 and here [we define a `CustomHandler`](https://github.com/CosmWasm/wasmd/blob/v0.8.0-rc1/x/wasm/internal/keeper/reflect_test.go#L303-L353).
-This code is responsible to take `json.RawMessage` from the raw bytes serialized from your custom types in rust and parse it into
+This code is responsible to take `json.RawMessage` from the raw bytes serialized from your custom types in Rust and parse it into
 Go structs. Then take these go structs and properly convert them for your custom SDK modules.
 
 You can look at the implementations for the `staking` module to see how to build these for non-trivial
@@ -196,7 +198,7 @@ should properly name the JSON fields and use the `omitempty` keyword if Rust exp
 
 ### Wiring it all together
 
-Once you have writen and tested these custom callbacks for your module, you need to enable it in your application.
+Once you have written and tested these custom callbacks for your module, you need to enable it in your application.
 The first step is to write an integration test with a contract compiled with your custom SDK to ensure it works properly,
 then you need to configure this in `app.go`.
 

README.md

@@ -53,7 +53,7 @@ The following table shows
 
 | wasmd | compatible | specified |
 | ------ | ---------- | ----------------------------------------------------------------- |
-| 0.51.0 | 1.5.x | 1.5.2  |
+| 0.51.0 | 2.0.x | [2.0.0](https://github.com/CosmWasm/wasmd/blob/v0.51.0/go.mod#L6) |
 | 0.50.0 | 1.5.x | [1.5.0](https://github.com/CosmWasm/wasmd/blob/v0.50.0/go.mod#L6) |
 | 0.45.0 | 1.5.x | [1.5.0](https://github.com/CosmWasm/wasmd/blob/v0.45.0/go.mod#L6) |
 | 0.44.0 | 1.5.x | [1.5.0](https://github.com/CosmWasm/wasmd/blob/v0.44.0/go.mod#L6) |

app/app.go

@@ -12,6 +12,7 @@ import (
  tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
  dbm "github.com/cosmos/cosmos-db"
  "github.com/cosmos/gogoproto/proto"
+ ibccallbacks "github.com/cosmos/ibc-go/modules/apps/callbacks"
  "github.com/cosmos/ibc-go/modules/capability"
  capabilitykeeper "github.com/cosmos/ibc-go/modules/capability/keeper"
  capabilitytypes "github.com/cosmos/ibc-go/modules/capability/types"
@@ -30,7 +31,7 @@ import (
  ibctransferkeeper "github.com/cosmos/ibc-go/v8/modules/apps/transfer/keeper"
  ibctransfertypes "github.com/cosmos/ibc-go/v8/modules/apps/transfer/types"
  ibc "github.com/cosmos/ibc-go/v8/modules/core"
- ibcclienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types" //nolint:staticcheck
+ ibcclienttypes "github.com/cosmos/ibc-go/v8/modules/core/02-client/types"
  ibcconnectiontypes "github.com/cosmos/ibc-go/v8/modules/core/03-connection/types"
  porttypes "github.com/cosmos/ibc-go/v8/modules/core/05-port/types"
  ibcexported "github.com/cosmos/ibc-go/v8/modules/core/exported"
@@ -606,6 +607,9 @@ func NewWasmApp(
  app.MsgServiceRouter(),
  authtypes.NewModuleAddress(govtypes.ModuleName).String(),
  )
+ // set grpc router for ica host
+ app.ICAHostKeeper.WithQueryRouter(app.GRPCQueryRouter())
+
  app.ICAControllerKeeper = icacontrollerkeeper.NewKeeper(
  appCodec,
  keys[icacontrollertypes.StoreKey],
@@ -647,10 +651,10 @@ func NewWasmApp(
  wasmOpts...,
  )
 
- // Create Transfer Stack
- var transferStack porttypes.IBCModule
- transferStack = transfer.NewIBCModule(app.TransferKeeper)
- transferStack = ibcfee.NewIBCMiddleware(transferStack, app.IBCFeeKeeper)
+ // Create fee enabled wasm ibc Stack
+ var wasmStack porttypes.IBCModule
+ wasmStackIBCHandler := wasm.NewIBCHandler(app.WasmKeeper, app.IBCKeeper.ChannelKeeper, app.IBCFeeKeeper)
+ wasmStack = ibcfee.NewIBCMiddleware(wasmStackIBCHandler, app.IBCFeeKeeper)
 
  // Create Interchain Accounts Stack
  // SendPacket, since it is originating from the application to core IBC:
@@ -660,18 +664,28 @@ func NewWasmApp(
  // see https://medium.com/the-interchain-foundation/ibc-go-v6-changes-to-interchain-accounts-and-how-it-impacts-your-chain-806c185300d7
  var noAuthzModule porttypes.IBCModule
  icaControllerStack = icacontroller.NewIBCMiddleware(noAuthzModule, app.ICAControllerKeeper)
+ // app.ICAAuthModule = icaControllerStack.(ibcmock.IBCModule)
+ icaControllerStack = icacontroller.NewIBCMiddleware(icaControllerStack, app.ICAControllerKeeper)
+ icaControllerStack = ibccallbacks.NewIBCMiddleware(icaControllerStack, app.IBCFeeKeeper, wasmStackIBCHandler, wasm.DefaultMaxIBCCallbackGas)
+ icaICS4Wrapper := icaControllerStack.(porttypes.ICS4Wrapper)
  icaControllerStack = ibcfee.NewIBCMiddleware(icaControllerStack, app.IBCFeeKeeper)
+ // Since the callbacks middleware itself is an ics4wrapper, it needs to be passed to the ica controller keeper
+ app.ICAControllerKeeper.WithICS4Wrapper(icaICS4Wrapper)
 
  // RecvPacket, message that originates from core IBC and goes down to app, the flow is:
  // channel.RecvPacket -> fee.OnRecvPacket -> icaHost.OnRecvPacket
  var icaHostStack porttypes.IBCModule
  icaHostStack = icahost.NewIBCModule(app.ICAHostKeeper)
  icaHostStack = ibcfee.NewIBCMiddleware(icaHostStack, app.IBCFeeKeeper)
 
- // Create fee enabled wasm ibc Stack
- var wasmStack porttypes.IBCModule
- wasmStack = wasm.NewIBCHandler(app.WasmKeeper, app.IBCKeeper.ChannelKeeper, app.IBCFeeKeeper)
- wasmStack = ibcfee.NewIBCMiddleware(wasmStack, app.IBCFeeKeeper)
+ // Create Transfer Stack
+ var transferStack porttypes.IBCModule
+ transferStack = transfer.NewIBCModule(app.TransferKeeper)
+ transferStack = ibccallbacks.NewIBCMiddleware(transferStack, app.IBCFeeKeeper, wasmStackIBCHandler, wasm.DefaultMaxIBCCallbackGas)
+ transferICS4Wrapper := transferStack.(porttypes.ICS4Wrapper)
+ transferStack = ibcfee.NewIBCMiddleware(transferStack, app.IBCFeeKeeper)
+ // Since the callbacks middleware itself is an ics4wrapper, it needs to be passed to the ica controller keeper
+ app.TransferKeeper.WithICS4Wrapper(transferICS4Wrapper)
 
  // Create static IBC router, add app routes, then set and seal it
  ibcRouter := porttypes.NewRouter().

app/sim_test.go

@@ -135,7 +135,6 @@ func TestAppImportExport(t *testing.T) {
  ctxA := app.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
  ctxB := newApp.NewContextLegacy(true, cmtproto.Header{Height: app.LastBlockHeight()})
  _, err = newApp.InitChainer(ctxB, initReq)
-
  if err != nil {
  if strings.Contains(err.Error(), "validator set is empty after InitGenesis") {
  t.Log("Skipping simulation as all validators have been unbonded")