Skip to content

Commit

Permalink
remove MsgStoreCompat and fix wasm bindings
Browse files Browse the repository at this point in the history
  • Loading branch information
trevormil committed Feb 10, 2024
1 parent 892593c commit a2f4e79
Show file tree
Hide file tree
Showing 17 changed files with 387 additions and 945 deletions.
4 changes: 2 additions & 2 deletions app/app.go
Original file line number Diff line number Diff line change
Expand Up @@ -654,8 +654,8 @@ func New(

// Create static IBC router, add transfer route, then set and seal it
ibcRouter := ibcporttypes.NewRouter()
ibcRouter.AddRoute(icahosttypes.SubModuleName, icaHostIBCModule).
AddRoute(ibctransfertypes.ModuleName, transferIBCModule)
ibcRouter.AddRoute(icahosttypes.SubModuleName, icaHostIBCModule)
ibcRouter.AddRoute(ibctransfertypes.ModuleName, transferIBCModule)
ibcRouter.AddRoute(badgesmoduletypes.ModuleName, badgesIBCModule)
ibcRouter.AddRoute(wasmtypes.ModuleName, wasmStack)
ibcRouter.AddRoute(protocolsmoduletypes.ModuleName, protocolsIBCModule)
Expand Down
32 changes: 8 additions & 24 deletions app/wasm_custom_bindings.go
Original file line number Diff line number Diff line change
Expand Up @@ -3,48 +3,32 @@ package app
import (
"github.com/CosmWasm/wasmd/x/wasm"
wasmKeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
badgeCustomBindings "github.com/bitbadges/bitbadgeschain/x/badges/custom-bindings"
badgeKeeper "github.com/bitbadges/bitbadgeschain/x/badges/keeper"

protocolCustomBindings "github.com/bitbadges/bitbadgeschain/x/protocols/custom-bindings"
protocolKeeper "github.com/bitbadges/bitbadgeschain/x/protocols/keeper"

customBindings "github.com/bitbadges/bitbadgeschain/custom-bindings"
)

func GetCustomMsgEncodersOptions() []wasmKeeper.Option {
badgeEncodingOptions := wasmKeeper.WithMessageEncoders(badgeMsgEncoders())
protocolEncodingOptions := wasmKeeper.WithMessageEncoders(protocolMsgEncoders())
return []wasm.Option{badgeEncodingOptions, protocolEncodingOptions}
return []wasm.Option{badgeEncodingOptions}
}

func GetCustomMsgQueryOptions(keeper badgeKeeper.Keeper, keeper2 protocolKeeper.Keeper) []wasmKeeper.Option {
badgeQueryOptions := wasmKeeper.WithQueryPlugins(badgeQueryPlugins(keeper))
protocolQueryOptions := wasmKeeper.WithQueryPlugins(protocolQueryPlugins(keeper2))
return []wasm.Option{badgeQueryOptions, protocolQueryOptions}
badgeQueryOptions := wasmKeeper.WithQueryPlugins(badgeQueryPlugins(keeper ,keeper2))
return []wasm.Option{badgeQueryOptions}
}

func badgeMsgEncoders() *wasmKeeper.MessageEncoders {
return &wasmKeeper.MessageEncoders{
Custom: badgeCustomBindings.EncodeBadgeMessage(),
Custom: customBindings.EncodeBitBadgesModuleMessage(),
}
}

// badgeQueryPlugins needs to be registered in test setup to handle custom query callbacks
func badgeQueryPlugins(keeper badgeKeeper.Keeper) *wasmKeeper.QueryPlugins {
func badgeQueryPlugins(bk badgeKeeper.Keeper, pk protocolKeeper.Keeper) *wasmKeeper.QueryPlugins {
return &wasmKeeper.QueryPlugins{
Custom: badgeCustomBindings.PerformCustomBadgeQuery(keeper),
Custom: customBindings.PerformCustomBitBadgesModuleQuery(bk, pk),
}
}


func protocolMsgEncoders() *wasmKeeper.MessageEncoders {
return &wasmKeeper.MessageEncoders{
Custom: protocolCustomBindings.EncodeProtocolMessage(),
}
}

// protocolQueryPlugins needs to be registered in test setup to handle custom query callbacks
func protocolQueryPlugins(keeper protocolKeeper.Keeper) *wasmKeeper.QueryPlugins {
return &wasmKeeper.QueryPlugins{
Custom: protocolCustomBindings.PerformCustomProtocolQuery(keeper),
}
}
144 changes: 144 additions & 0 deletions custom-bindings/custom_query.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,144 @@
package custom_bindings

import (
"encoding/json"

sdkerrors "cosmossdk.io/errors"
wasmKeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
"github.com/CosmWasm/wasmd/x/wasm/types"
badgeKeeper "github.com/bitbadges/bitbadgeschain/x/badges/keeper"
badgeTypes "github.com/bitbadges/bitbadgeschain/x/badges/types"

protocolKeeper "github.com/bitbadges/bitbadgeschain/x/protocols/keeper"
protocolTypes "github.com/bitbadges/bitbadgeschain/x/protocols/types"

sdk "github.com/cosmos/cosmos-sdk/types"
)

func PerformCustomBitBadgesModuleQuery(bk badgeKeeper.Keeper, pk protocolKeeper.Keeper) wasmKeeper.CustomQuerier {
return func(ctx sdk.Context, request json.RawMessage) ([]byte, error) {
isBadgeModuleQuery := false
var custom badgeCustomQuery
err := json.Unmarshal(request, &custom)
if err == nil {
isBadgeModuleQuery = true
}

if isBadgeModuleQuery {
switch {
case custom.QueryCollection != nil:
res, err := bk.GetCollection(ctx, custom.QueryCollection)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetCollectionResponse{Collection: res.Collection})
case custom.QueryBalance != nil:
res, err := bk.GetBalance(ctx, custom.QueryBalance)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetBalanceResponse{Balance: res.Balance})

case custom.QueryAddressList != nil:
res, err := bk.GetAddressList(ctx, custom.QueryAddressList)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetAddressListResponse{List: res.List})
case custom.QueryApprovalTracker != nil:
res, err := bk.GetApprovalTracker(ctx, custom.QueryApprovalTracker)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetApprovalTrackerResponse{Tracker: res.Tracker})
case custom.QueryGetChallengeTracker != nil:
res, err := bk.GetChallengeTracker(ctx, custom.QueryGetChallengeTracker)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetChallengeTrackerResponse{NumUsed: res.NumUsed})
}
} else {
var custom protocolCustomQuery
err := json.Unmarshal(request, &custom)
if err != nil {
return nil, sdkerrors.Wrap(err, err.Error())
}

switch {
case custom.QueryGetProtocol != nil:
res, err := pk.GetProtocol(ctx, custom.QueryGetProtocol)
if err != nil {
return nil, err
}
return json.Marshal(protocolTypes.QueryGetProtocolResponse{Protocol: res.Protocol})
case custom.QueryGetCollectionIdForProtocol != nil:
res, err := pk.GetCollectionIdForProtocol(ctx, custom.QueryGetCollectionIdForProtocol)
if err != nil {
return nil, err
}
return json.Marshal(protocolTypes.QueryGetCollectionIdForProtocolResponse{CollectionId: res.CollectionId})
}
}

return nil, sdkerrors.Wrap(types.ErrInvalidMsg, "Unknown Custom query variant")
}
}
// WASM handler for contracts calling into the badges module
func PerformCustomBadgeQuery(keeper badgeKeeper.Keeper) wasmKeeper.CustomQuerier {
return func(ctx sdk.Context, request json.RawMessage) ([]byte, error) {
var custom badgeCustomQuery
err := json.Unmarshal(request, &custom)
if err != nil {
return nil, sdkerrors.Wrap(err, err.Error())
}

switch {
case custom.QueryCollection != nil:
res, err := keeper.GetCollection(ctx, custom.QueryCollection)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetCollectionResponse{Collection: res.Collection})
case custom.QueryBalance != nil:
res, err := keeper.GetBalance(ctx, custom.QueryBalance)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetBalanceResponse{Balance: res.Balance})

case custom.QueryAddressList != nil:
res, err := keeper.GetAddressList(ctx, custom.QueryAddressList)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetAddressListResponse{List: res.List})
case custom.QueryApprovalTracker != nil:
res, err := keeper.GetApprovalTracker(ctx, custom.QueryApprovalTracker)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetApprovalTrackerResponse{Tracker: res.Tracker})
case custom.QueryGetChallengeTracker != nil:
res, err := keeper.GetChallengeTracker(ctx, custom.QueryGetChallengeTracker)
if err != nil {
return nil, err
}
return json.Marshal(badgeTypes.QueryGetChallengeTrackerResponse{NumUsed: res.NumUsed})
}
return nil, sdkerrors.Wrap(types.ErrInvalidMsg, "Unknown Custom query variant")
}
}

type badgeCustomQuery struct {
QueryCollection *badgeTypes.QueryGetCollectionRequest `json:"queryCollection,omitempty"`
QueryBalance *badgeTypes.QueryGetBalanceRequest `json:"queryBalance,omitempty"`
QueryAddressList *badgeTypes.QueryGetAddressListRequest `json:"queryAddressList,omitempty"`
QueryApprovalTracker *badgeTypes.QueryGetApprovalTrackerRequest `json:"queryApprovalTracker,omitempty"`
QueryGetChallengeTracker *badgeTypes.QueryGetChallengeTrackerRequest `json:"queryGetChallengeTracker,omitempty"`
}

type protocolCustomQuery struct {
QueryGetProtocol *protocolTypes.QueryGetProtocolRequest `json:"queryGetProtocol,omitempty"`
QueryGetCollectionIdForProtocol *protocolTypes.QueryGetCollectionIdForProtocolRequest `json:"queryGetCollectionIdForProtocol,omitempty"`
}
98 changes: 98 additions & 0 deletions custom-bindings/custom_tx.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,98 @@
package custom_bindings

import (
"bytes"
"encoding/json"

sdkerrors "cosmossdk.io/errors"
wasmKeeper "github.com/CosmWasm/wasmd/x/wasm/keeper"
"github.com/CosmWasm/wasmd/x/wasm/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/gogo/protobuf/jsonpb"

protocolTypes "github.com/bitbadges/bitbadgeschain/x/protocols/types"
badgeTypes "github.com/bitbadges/bitbadgeschain/x/badges/types"
)

func EncodeBitBadgesModuleMessage() wasmKeeper.CustomEncoder {
return func(sender sdk.AccAddress, msg json.RawMessage) ([]sdk.Msg, error) {
// Convert message and route to corresponding handler
jsonData, err := msg.MarshalJSON()
if err != nil {
return nil, sdkerrors.Wrap(err, err.Error())
}

reader := bytes.NewReader(jsonData)

isBadgeModuleMsg := false
var badgeCustomMsg badgeTypes.BadgeCustomMsgType
err = jsonpb.Unmarshal(reader, &badgeCustomMsg)
if err == nil {
isBadgeModuleMsg = true
}

if isBadgeModuleMsg {
reader = bytes.NewReader(jsonData)
var badgeCustomMsg badgeTypes.BadgeCustomMsgType
err = jsonpb.Unmarshal(reader, &badgeCustomMsg)
if err != nil {
return nil, sdkerrors.Wrap(err, err.Error())
}

switch {
case badgeCustomMsg.UniversalUpdateCollectionMsg != nil:
badgeCustomMsg.UniversalUpdateCollectionMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.UniversalUpdateCollectionMsg}, nil
case badgeCustomMsg.CreateCollectionMsg != nil:
badgeCustomMsg.CreateCollectionMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.CreateCollectionMsg}, nil
case badgeCustomMsg.CreateAddressListsMsg != nil:
badgeCustomMsg.CreateAddressListsMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.CreateAddressListsMsg}, nil
case badgeCustomMsg.UpdateCollectionMsg != nil:
badgeCustomMsg.UpdateCollectionMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.UpdateCollectionMsg}, nil
case badgeCustomMsg.DeleteCollectionMsg != nil:
badgeCustomMsg.DeleteCollectionMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.DeleteCollectionMsg}, nil
case badgeCustomMsg.TransferBadgesMsg != nil:
badgeCustomMsg.TransferBadgesMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.TransferBadgesMsg}, nil
case badgeCustomMsg.UpdateUserApprovalsMsg != nil:
badgeCustomMsg.UpdateUserApprovalsMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.UpdateUserApprovalsMsg}, nil
default:
return nil, sdkerrors.Wrapf(types.ErrInvalidMsg, "Unknown custom badge message variant %s", badgeCustomMsg)
}
} else {
reader = bytes.NewReader(jsonData)
var badgeCustomMsg protocolTypes.ProtocolCustomMsgType
err = jsonpb.Unmarshal(reader, &badgeCustomMsg)
if err != nil {
return nil, sdkerrors.Wrap(err, err.Error())
}
switch {
case badgeCustomMsg.CreateProtocolMsg != nil:
badgeCustomMsg.CreateProtocolMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.CreateProtocolMsg}, nil
case badgeCustomMsg.UpdateProtocolMsg != nil:
badgeCustomMsg.UpdateProtocolMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.UpdateProtocolMsg}, nil
case badgeCustomMsg.DeleteProtocolMsg != nil:
badgeCustomMsg.DeleteProtocolMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.DeleteProtocolMsg}, nil
case badgeCustomMsg.SetCollectionForProtocolMsg != nil:
badgeCustomMsg.SetCollectionForProtocolMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.SetCollectionForProtocolMsg}, nil
case badgeCustomMsg.UnsetCollectionForProtocolMsg != nil:
badgeCustomMsg.UnsetCollectionForProtocolMsg.Creator = sender.String()
return []sdk.Msg{badgeCustomMsg.UnsetCollectionForProtocolMsg}, nil
default:
return nil, sdkerrors.Wrapf(types.ErrInvalidMsg, "Unknown custom badge message variant %s", badgeCustomMsg)
}
}

}
}


Loading

0 comments on commit a2f4e79

Please sign in to comment.