wasm: on-demand materialize + wrappers; non-fatal pinned init

app/ante.go

@@ -57,14 +57,14 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
 		// must be first to ensure that injected txs bypass the remaining ante handlers, as they do not have gas.
 		ebifrost.NewInjectedTxDecorator(),
 
-		// Check for MsgMimir early and skip fee deduction
-		thorchain.NewMimirBypassDecorator(options.THORChainKeeper),
-
 		ante.NewSetUpContextDecorator(), // outermost AnteDecorator. SetUpContext must be called first
 
 		// replace gas meter immediately after setting up ctx
 		thorchain.NewGasDecorator(options.THORChainKeeper),
 
+		// Check for MsgMimir and bypass remaining ante after context/gas are set
+		thorchain.NewMimirBypassDecorator(options.THORChainKeeper),
+
 		wasmkeeper.NewLimitSimulationGasDecorator(options.WasmConfig.SimulationGasLimit), // after setup context to enforce limits early
 		wasmkeeper.NewCountTXDecorator(options.TXCounterStoreService),
 		wasmkeeper.NewGasRegisterDecorator(options.WasmKeeper.GetGasRegister()),

app/app.go

@@ -1,12 +1,12 @@
 package app
 
 import (
+	"os"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"path/filepath"
 	"sort"
 	"sync"
@@ -163,6 +163,7 @@ type THORChainApp struct {
 	DenomKeeper      denomkeeper.Keeper
 	msgServiceRouter *MsgServiceRouter // router for redirecting Msg service messages
 	WasmKeeper       wasmkeeper.Keeper
+	wasmDir          string
 
 	// forking services
 	forkingServices []forking.ForkingKVStoreService
@@ -178,6 +179,9 @@ type THORChainApp struct {
 	configurator        module.Configurator
 	queryServiceRouter  *QueryServiceRouter
 	once                sync.Once
+	forkGRPC   string
+	forkHeight int64
+
 }
 
 
@@ -389,9 +393,15 @@ func NewChainApp(
 			CacheSize:       cast.ToInt(appOpts.Get("fork.cache-size")),
 			GasCostPerFetch: cast.ToUint64(appOpts.Get("fork.gas-cost-per-fetch")),
 		}
+		forking.Enabled = true
+
 		logger.Info("Forking config", "height", forkingConfig.ForkHeight, "cache_enabled", forkingConfig.CacheEnabled, "cache_size", forkingConfig.CacheSize)
 
+		app.forkGRPC = forkingGRPC
+		app.forkHeight = forkingConfig.ForkHeight
+
 		if forkingConfig.TrustingPeriod == 0 {
+
 			forkingConfig.TrustingPeriod = 24 * time.Hour
 		}
 		if forkingConfig.MaxClockDrift == 0 {
@@ -491,22 +501,20 @@ func NewChainApp(
 		app.appCodec, thorchainStoreService, app.BankKeeper, app.AccountKeeper, app.UpgradeKeeper,
 	)
 
-	wasmDir := filepath.Join(homePath, "data") // "wasm" subdirectory created here
+	wasmDir := filepath.Join(homePath, "data")
+	app.wasmDir = wasmDir
 	wasmConfig, err := wasm.ReadWasmConfig(appOpts)
 	if err != nil {
 		panic(fmt.Sprintf("error while reading wasm config: %s", err))
 	}
+	fmt.Fprintf(os.Stderr, "[wasm-open] init wasmDir=%s homePath=%s forking=%v\n", wasmDir, homePath, forkingEnabled)
 
 	wasmOpts = append(wasmOpts,
-		wasmkeeper.WithQueryPlugins(
-			&wasmkeeper.QueryPlugins{
-				Grpc: wasmkeeper.AcceptListGrpcQuerier(
-					wasmAcceptedQueries,
-					app.BaseApp.GRPCQueryRouter(),
-					app.appCodec),
-			},
-		),
 		wasmkeeper.WithGasRegister(WasmGasRegister),
+		wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{
+			Stargate: wasmkeeper.AcceptListStargateQuerier(wasmAcceptedQueries, app.GRPCQueryRouter(), app.appCodec),
+			Grpc:     wasmkeeper.AcceptListGrpcQuerier(wasmAcceptedQueries, app.GRPCQueryRouter(), app.appCodec),
+		}),
 	)
 
 	// The last arguments can contain custom message handlers, and custom query handlers,
@@ -534,6 +542,7 @@ func NewChainApp(
 		authtypes.NewModuleAddress(thorchain.ModuleName).String(),
 		wasmOpts...,
 	)
+	fmt.Fprintf(os.Stderr, "[wasm-open] keeper constructed with wasmDir=%s\n", wasmDir)
 
 	app.DenomKeeper = denomkeeper.NewKeeper(
 		app.appCodec,
@@ -549,6 +558,8 @@ func NewChainApp(
 
 	mgrs := thorchain.NewManagers(app.ThorchainKeeper, app.appCodec, thorchainStoreService, app.BankKeeper, app.AccountKeeper, app.UpgradeKeeper, app.WasmKeeper)
 	app.msgServiceRouter.AddCustomRoute("cosmos.bank.v1beta1.Msg", thorchain.NewBankSendHandler(thorchain.NewSendHandler(mgrs)))
+	app.msgServiceRouter.AddCustomRoute("cosmwasm.wasm.v1.Msg", NewWasmMsgWrapper(app, &app.WasmKeeper, wasmkeeper.NewMsgServerImpl(&app.WasmKeeper)))
+	app.msgServiceRouter.AddCustomRoute("types.Msg", NewThorchainMsgWrapper(app, &app.WasmKeeper, thorchain.NewMsgServerImpl(mgrs)))
 
 	thorchainModule := thorchain.NewAppModule(mgrs, telemetryEnabled, testApp)
 
@@ -670,9 +681,9 @@ func NewChainApp(
 
 	// Uncomment if you want to set a custom migration order here.
 	// app.ModuleManager.SetOrderMigrations(custom order)
-
 	app.queryServiceRouter = NewQueryServiceRouter(app.BaseApp.GRPCQueryRouter())
 	app.queryServiceRouter.AddCustomRoute("cosmos.bank.v1beta1.Query", NewBankQueryWrapper(app.BankKeeper))
+	app.queryServiceRouter.AddCustomRoute("cosmwasm.wasm.v1.Query", NewWasmQueryWrapper(app, &app.WasmKeeper, wasmkeeper.NewGrpcQuerier(app.appCodec, wasmStoreService, &app.WasmKeeper, wasmConfig.SmartQueryGasLimit)))
 	app.configurator = module.NewConfigurator(app.appCodec, app.msgServiceRouter, app.queryServiceRouter)
 	err = app.ModuleManager.RegisterServices(app.configurator)
 	if err != nil {
@@ -781,7 +792,7 @@ func NewChainApp(
 
 		// Initialize pinned codes in wasmvm as they are not persisted there
 		if err := app.WasmKeeper.InitializePinnedCodes(ctx); err != nil {
-			panic(fmt.Sprintf("failed initialize pinned codes %s", err))
+			app.BaseApp.Logger().Error("failed initialize pinned codes", "err", err)
 		}
 	}
 
@@ -794,10 +805,6 @@ func (app *THORChainApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.Re
 	app.once.Do(func() {
 		ctx := app.NewUncachedContext(false, tmproto.Header{})
 		if _, err := app.ConsensusParamsKeeper.Params(ctx, &consensusparamtypes.QueryParamsRequest{}); err != nil {
-			// prevents panic: consensus key is nil: collections: not found: key 'no_key' of type github.com/cosmos/gogoproto/tendermint.types.ConsensusParams
-			// sdk 47:
-			// Migrate Tendermint consensus parameters from x/params module to a dedicated x/consensus module.
-			// see https://github.com/cosmos/cosmos-sdk/blob/v0.47.0/simapp/upgrades.go#L66
 			baseAppLegacySS := app.GetSubspace(baseapp.Paramspace).WithKeyTable(paramstypes.ConsensusParamsKeyTable())
 			err = baseapp.MigrateParams(sdk.UnwrapSDKContext(ctx), baseAppLegacySS, app.ConsensusParamsKeeper.ParamsStore)
 			if err != nil {
@@ -806,6 +813,14 @@ func (app *THORChainApp) FinalizeBlock(req *abci.RequestFinalizeBlock) (*abci.Re
 		}
 	})
 
+	defer func() {
+		for _, service := range app.forkingServices {
+			if e := service.EndBlock(); e != nil {
+				app.Logger().Error("failed to end block on forking service", "error", e)
+			}
+		}
+	}()
+
 	return app.BaseApp.FinalizeBlock(req)
 }
 
@@ -827,6 +842,7 @@ func (app *THORChainApp) PreBlocker(ctx sdk.Context, req *abci.RequestFinalizeBl
 	return app.ModuleManager.PreBlock(ctx)
 }
 
+
 func (a *THORChainApp) Configurator() module.Configurator {
 	return a.configurator
 }

app/msg_thorchain_wrapper.go

@@ -0,0 +1,209 @@
+package app
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"strings"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	wasmkeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
+	cwtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
+
+	thtypes "gitlab.com/thorchain/thornode/v3/x/thorchain/types"
+)
+
+type ThorchainMsgWrapper struct {
+	thtypes.UnimplementedMsgServer
+	app      *THORChainApp
+	keeper   *wasmkeeper.Keeper
+	original thtypes.MsgServer
+}
+
+func NewThorchainMsgWrapper(app *THORChainApp, k *wasmkeeper.Keeper, original thtypes.MsgServer) *ThorchainMsgWrapper {
+	return &ThorchainMsgWrapper{
+		app:      app,
+		keeper:   k,
+		original: original,
+	}
+}
+
+func (w *ThorchainMsgWrapper) withMaterialized(goCtx context.Context, codeID uint64) (context.Context, error) {
+	if codeID != 0 {
+		if err := w.app.materializeAndPinWasm(sdk.UnwrapSDKContext(goCtx), codeID); err != nil {
+			return goCtx, err
+		}
+	}
+	return goCtx, nil
+}
+
+func (w *ThorchainMsgWrapper) ensureMaterializedByAddress(ctx sdk.Context, bech32Addr string) {
+	addr, err := sdk.AccAddressFromBech32(bech32Addr)
+	if err == nil {
+		if ci := w.keeper.GetContractInfo(ctx, addr); ci != nil {
+			_ = w.app.materializeAndPinWasm(ctx, ci.CodeID)
+			return
+		}
+	}
+	target := w.app.forkGRPC
+	if strings.TrimSpace(target) == "" {
+		target = "grpc.thor.pfc.zone:443"
+	}
+	useTLS := false
+	normalized := strings.TrimSpace(target)
+	if strings.HasPrefix(normalized, "grpcs://") || strings.HasPrefix(normalized, "https://") {
+		useTLS = true
+		normalized = strings.TrimPrefix(strings.TrimPrefix(normalized, "grpcs://"), "https://")
+	} else {
+		if _, p, e := net.SplitHostPort(normalized); e == nil && p == "443" {
+			useTLS = true
+		}
+	}
+	var dialOpt grpc.DialOption
+	if useTLS {
+		dialOpt = grpc.WithTransportCredentials(credentials.NewTLS(nil))
+	} else {
+		dialOpt = grpc.WithTransportCredentials(insecure.NewCredentials())
+	}
+	conn, derr := grpc.Dial(normalized, dialOpt)
+	if derr != nil {
+		return
+	}
+	defer conn.Close()
+	wq := cwtypes.NewQueryClient(conn)
+	md := metadata.New(nil)
+	if w.app.forkHeight > 0 {
+		md.Set("x-cosmos-block-height", fmt.Sprintf("%d", w.app.forkHeight))
+	}
+	qctx := metadata.NewOutgoingContext(ctx.Context(), md)
+	resp, rerr := wq.ContractInfo(qctx, &cwtypes.QueryContractInfoRequest{Address: bech32Addr})
+	if rerr != nil && shouldRetryWithoutHeight(rerr) {
+		resp, rerr = wq.ContractInfo(ctx.Context(), &cwtypes.QueryContractInfoRequest{Address: bech32Addr})
+	}
+	if rerr != nil || resp == nil || resp.ContractInfo.CodeID == 0 {
+		return
+	}
+	_ = w.app.materializeAndPinWasm(ctx, resp.ContractInfo.CodeID)
+}
+
+
+func (w *ThorchainMsgWrapper) StoreCode(ctx context.Context, req *cwtypes.MsgStoreCode) (*cwtypes.MsgStoreCodeResponse, error) {
+	return w.original.StoreCode(ctx, req)
+}
+
+func (w *ThorchainMsgWrapper) InstantiateContract(goCtx context.Context, req *cwtypes.MsgInstantiateContract) (*cwtypes.MsgInstantiateContractResponse, error) {
+	fmt.Printf("[thorchain-msg] InstantiateContract codeID=%d admin=%s\n", req.CodeID, req.Admin)
+	if _, err := w.withMaterialized(goCtx, req.CodeID); err != nil {
+	}
+	return w.original.InstantiateContract(goCtx, req)
+}
+
+func (w *ThorchainMsgWrapper) InstantiateContract2(goCtx context.Context, req *cwtypes.MsgInstantiateContract2) (*cwtypes.MsgInstantiateContract2Response, error) {
+	fmt.Printf("[thorchain-msg] InstantiateContract2 codeID=%d admin=%s\n", req.CodeID, req.Admin)
+	if _, err := w.withMaterialized(goCtx, req.CodeID); err != nil {
+	}
+	return w.original.InstantiateContract2(goCtx, req)
+}
+
+func (w *ThorchainMsgWrapper) ExecuteContract(goCtx context.Context, req *cwtypes.MsgExecuteContract) (*cwtypes.MsgExecuteContractResponse, error) {
+	fmt.Printf("[thorchain-msg] ExecuteContract contract=%s sender=%s\n", req.Contract, req.Sender)
+	ctx := sdk.UnwrapSDKContext(goCtx)
+	w.ensureMaterializedByAddress(ctx, req.Contract)
+	fmt.Printf("[thorchain-msg] ExecuteContract dispatched contract=%s\n", req.Contract)
+	return w.original.ExecuteContract(goCtx, req)
+}
+
+func (w *ThorchainMsgWrapper) MigrateContract(goCtx context.Context, req *cwtypes.MsgMigrateContract) (*cwtypes.MsgMigrateContractResponse, error) {
+	fmt.Printf("[thorchain-msg] MigrateContract codeID=%d contract=%s\n", req.CodeID, req.Contract)
+	if _, err := w.withMaterialized(goCtx, req.CodeID); err != nil {
+	}
+	return w.original.MigrateContract(goCtx, req)
+}
+
+func (w *ThorchainMsgWrapper) SudoContract(ctx context.Context, req *cwtypes.MsgSudoContract) (*cwtypes.MsgSudoContractResponse, error) {
+	return w.original.SudoContract(ctx, req)
+}
+
+func (w *ThorchainMsgWrapper) UpdateAdmin(ctx context.Context, req *cwtypes.MsgUpdateAdmin) (*cwtypes.MsgUpdateAdminResponse, error) {
+	return w.original.UpdateAdmin(ctx, req)
+}
+
+func (w *ThorchainMsgWrapper) ClearAdmin(ctx context.Context, req *cwtypes.MsgClearAdmin) (*cwtypes.MsgClearAdminResponse, error) {
+	return w.original.ClearAdmin(ctx, req)
+}
+
+
+func (w *ThorchainMsgWrapper) Ban(ctx context.Context, msg *thtypes.MsgBan) (*thtypes.MsgEmpty, error) {
+	return w.original.Ban(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) Deposit(ctx context.Context, msg *thtypes.MsgDeposit) (*thtypes.MsgEmpty, error) {
+	return w.original.Deposit(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ErrataTx(ctx context.Context, msg *thtypes.MsgErrataTx) (*thtypes.MsgEmpty, error) {
+	return w.original.ErrataTx(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ErrataTxQuorum(ctx context.Context, msg *thtypes.MsgErrataTxQuorum) (*thtypes.MsgEmpty, error) {
+	return w.original.ErrataTxQuorum(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) Mimir(ctx context.Context, msg *thtypes.MsgMimir) (*thtypes.MsgEmpty, error) {
+	return w.original.Mimir(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ModifyLimitSwap(ctx context.Context, msg *thtypes.MsgModifyLimitSwap) (*thtypes.MsgEmpty, error) {
+	return w.original.ModifyLimitSwap(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) NetworkFee(ctx context.Context, msg *thtypes.MsgNetworkFee) (*thtypes.MsgEmpty, error) {
+	return w.original.NetworkFee(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) NetworkFeeQuorum(ctx context.Context, msg *thtypes.MsgNetworkFeeQuorum) (*thtypes.MsgEmpty, error) {
+	return w.original.NetworkFeeQuorum(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) NodePauseChain(ctx context.Context, msg *thtypes.MsgNodePauseChain) (*thtypes.MsgEmpty, error) {
+	return w.original.NodePauseChain(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ObservedTxIn(ctx context.Context, msg *thtypes.MsgObservedTxIn) (*thtypes.MsgEmpty, error) {
+	return w.original.ObservedTxIn(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ObservedTxOut(ctx context.Context, msg *thtypes.MsgObservedTxOut) (*thtypes.MsgEmpty, error) {
+	return w.original.ObservedTxOut(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ObservedTxQuorum(ctx context.Context, msg *thtypes.MsgObservedTxQuorum) (*thtypes.MsgEmpty, error) {
+	return w.original.ObservedTxQuorum(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ThorSend(ctx context.Context, msg *thtypes.MsgSend) (*thtypes.MsgEmpty, error) {
+	return w.original.ThorSend(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) SetIPAddress(ctx context.Context, msg *thtypes.MsgSetIPAddress) (*thtypes.MsgEmpty, error) {
+	return w.original.SetIPAddress(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) SetNodeKeys(ctx context.Context, msg *thtypes.MsgSetNodeKeys) (*thtypes.MsgEmpty, error) {
+	return w.original.SetNodeKeys(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) Solvency(ctx context.Context, msg *thtypes.MsgSolvency) (*thtypes.MsgEmpty, error) {
+	return w.original.Solvency(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) SolvencyQuorum(ctx context.Context, msg *thtypes.MsgSolvencyQuorum) (*thtypes.MsgEmpty, error) {
+	return w.original.SolvencyQuorum(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) TssKeysignFail(ctx context.Context, msg *thtypes.MsgTssKeysignFail) (*thtypes.MsgEmpty, error) {
+	return w.original.TssKeysignFail(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) TssPool(ctx context.Context, msg *thtypes.MsgTssPool) (*thtypes.MsgEmpty, error) {
+	return w.original.TssPool(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) SetVersion(ctx context.Context, msg *thtypes.MsgSetVersion) (*thtypes.MsgEmpty, error) {
+	return w.original.SetVersion(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ProposeUpgrade(ctx context.Context, msg *thtypes.MsgProposeUpgrade) (*thtypes.MsgEmpty, error) {
+	return w.original.ProposeUpgrade(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) ApproveUpgrade(ctx context.Context, msg *thtypes.MsgApproveUpgrade) (*thtypes.MsgEmpty, error) {
+	return w.original.ApproveUpgrade(ctx, msg)
+}
+func (w *ThorchainMsgWrapper) RejectUpgrade(ctx context.Context, msg *thtypes.MsgRejectUpgrade) (*thtypes.MsgEmpty, error) {
+	return w.original.RejectUpgrade(ctx, msg)
+}