Tony chen wasm test

aclmapping/bank/mappings.go

@@ -0,0 +1,82 @@
+package aclbankmapping
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkacltypes "github.com/cosmos/cosmos-sdk/types/accesscontrol"
+	aclkeeper "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper"
+	acltypes "github.com/cosmos/cosmos-sdk/x/accesscontrol/types"
+	banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+	utils "github.com/sei-protocol/sei-chain/aclmapping/utils"
+)
+
+var ErrorInvalidMsgType = fmt.Errorf("invalid message received for bank module")
+
+func GetBankDepedencyGenerator() aclkeeper.DependencyGeneratorMap {
+	dependencyGeneratorMap := make(aclkeeper.DependencyGeneratorMap)
+
+	// dex place orders
+	placeOrdersKey := acltypes.GenerateMessageKey(&banktypes.MsgSend{})
+	dependencyGeneratorMap[placeOrdersKey] = MsgSendDependencyGenerator
+
+	return dependencyGeneratorMap
+}
+
+// TODO:: we can make resource types more granular  (e.g KV_PARAM or KV_BANK_BALANCE)
+func MsgSendDependencyGenerator(keeper aclkeeper.Keeper, ctx sdk.Context, msg sdk.Msg) ([]sdkacltypes.AccessOperation, error) {
+	msgSend, ok := msg.(*banktypes.MsgSend)
+	if !ok {
+		return []sdkacltypes.AccessOperation{}, ErrorInvalidMsgType
+	}
+
+	accessOperations := []sdkacltypes.AccessOperation{
+		// MsgSend also checks if the coin denom is enabled, but the information is from the params.
+		// Changing the param would require a gov proposal, which is synchrounos by default
+
+		// Checks balance of sender
+		{
+			AccessType:         sdkacltypes.AccessType_READ,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.BANK, msgSend.FromAddress),
+		},
+		// Reduce the amount from the sender's balance
+		{
+			AccessType:         sdkacltypes.AccessType_WRITE,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.BANK, msgSend.FromAddress),
+		},
+
+		// Checks balance for receiver
+		{
+			AccessType:         sdkacltypes.AccessType_READ,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.BANK, msgSend.ToAddress),
+		},
+		{
+			AccessType:         sdkacltypes.AccessType_WRITE,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.BANK, msgSend.ToAddress),
+		},
+
+		// Tries to create the reciever's account if it doesn't exist
+		{
+			AccessType:         sdkacltypes.AccessType_READ,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.AUTH, msgSend.ToAddress),
+		},
+		{
+			AccessType:         sdkacltypes.AccessType_WRITE,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: utils.GetIdentifierTemplatePerModule(utils.AUTH, msgSend.ToAddress),
+		},
+
+		// Last Operation should always be a commit
+		{
+			ResourceType:       sdkacltypes.ResourceType_ANY,
+			AccessType:         sdkacltypes.AccessType_COMMIT,
+			IdentifierTemplate: utils.DefaultIDTemplate,
+		},
+	}
+	return accessOperations, nil
+}

aclmapping/dependency_generator.go

@@ -0,0 +1,25 @@
+package aclmapping
+
+import (
+	aclkeeper "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper"
+	aclbankmapping "github.com/sei-protocol/sei-chain/aclmapping/bank"
+	acldexmapping "github.com/sei-protocol/sei-chain/aclmapping/dex"
+	aclwasmmapping "github.com/sei-protocol/sei-chain/aclmapping/wasm"
+)
+
+type CustomDependencyGenerator struct{}
+
+func NewCustomDependencyGenerator() CustomDependencyGenerator {
+	return CustomDependencyGenerator{}
+}
+
+func (customDepGen CustomDependencyGenerator) GetCustomDependencyGenerators() aclkeeper.DependencyGeneratorMap {
+	dependencyGeneratorMap := make(aclkeeper.DependencyGeneratorMap)
+
+	dependencyGeneratorMap.Merge(acldexmapping.GetDexDependencyGenerators())
+	dependencyGeneratorMap.Merge(aclbankmapping.GetBankDepedencyGenerator())
+	wasmDependencyGenerators := aclwasmmapping.NewWasmDependencyGenerator()
+	dependencyGeneratorMap.Merge(wasmDependencyGenerators.GetWasmDependencyGenerators())
+
+	return dependencyGeneratorMap
+}

aclmapping/dex/mappings.go

@@ -0,0 +1,34 @@
+package acldexmapping
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkacltypes "github.com/cosmos/cosmos-sdk/types/accesscontrol"
+	aclkeeper "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper"
+	acltypes "github.com/cosmos/cosmos-sdk/x/accesscontrol/types"
+	dexmoduletypes "github.com/sei-protocol/sei-chain/x/dex/types"
+)
+
+var ErrPlaceOrdersGenerator = fmt.Errorf("invalid message received for type DexPlaceOrders")
+
+func GetDexDependencyGenerators() aclkeeper.DependencyGeneratorMap {
+	dependencyGeneratorMap := make(aclkeeper.DependencyGeneratorMap)
+
+	// dex place orders
+	placeOrdersKey := acltypes.GenerateMessageKey(&dexmoduletypes.MsgPlaceOrders{})
+	dependencyGeneratorMap[placeOrdersKey] = DexPlaceOrdersDependencyGenerator
+
+	return dependencyGeneratorMap
+}
+
+func DexPlaceOrdersDependencyGenerator(keeper aclkeeper.Keeper, ctx sdk.Context, msg sdk.Msg) ([]sdkacltypes.AccessOperation, error) {
+	placeOrdersMsg, ok := msg.(*dexmoduletypes.MsgPlaceOrders)
+	if !ok {
+		return []sdkacltypes.AccessOperation{}, ErrPlaceOrdersGenerator
+	}
+	// TODO: This is not final, JUST AN EXAMPLE
+	return []sdkacltypes.AccessOperation{
+		{AccessType: sdkacltypes.AccessType_WRITE, ResourceType: sdkacltypes.ResourceType_KV, IdentifierTemplate: placeOrdersMsg.ContractAddr},
+	}, nil
+}

aclmapping/utils/identifier_templates.go

@@ -0,0 +1,38 @@
+package util
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkacltypes "github.com/cosmos/cosmos-sdk/types/accesscontrol"
+)
+
+const (
+	ACCOUNT           = "acc"
+	BANK              = "bank"
+	AUTH              = "auth"
+	DefaultIDTemplate = "*"
+)
+
+func GetIdentifierTemplatePerModule(module string, identifier string) string {
+	return fmt.Sprintf("%s/%s", module, identifier)
+}
+
+func GetPrefixedIdentifierTemplatePerModule(module string, identifier string, prefix string) string {
+	return fmt.Sprintf("%s/%s/%s", module, prefix, identifier)
+}
+
+func GetOracleReadAccessOpsForValAndFeeder(feederAddr sdk.Address, valAddr sdk.Address) []sdkacltypes.AccessOperation {
+	return []sdkacltypes.AccessOperation{
+		{
+			AccessType:         sdkacltypes.AccessType_READ,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: GetIdentifierTemplatePerModule("oracle", feederAddr.String()),
+		},
+		{
+			AccessType:         sdkacltypes.AccessType_READ,
+			ResourceType:       sdkacltypes.ResourceType_KV,
+			IdentifierTemplate: GetIdentifierTemplatePerModule("oracle", valAddr.String()),
+		},
+	}
+}

aclmapping/wasm/mappings.go

@@ -0,0 +1,52 @@
+package aclwasmmapping
+
+import (
+	"fmt"
+
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkacltypes "github.com/cosmos/cosmos-sdk/types/accesscontrol"
+	aclkeeper "github.com/cosmos/cosmos-sdk/x/accesscontrol/keeper"
+	acltypes "github.com/cosmos/cosmos-sdk/x/accesscontrol/types"
+)
+
+var (
+	ErrInvalidWasmExecuteMessage        = fmt.Errorf("invalid message received for type WasmExecuteContract")
+	ErrInvalidWasmFunction              = fmt.Errorf("unable to identify wasm function")
+	ErrWasmFunctionDependenciesDisabled = fmt.Errorf("wasm function dependency mapping disabled")
+)
+
+type WasmDependencyGenerator struct{}
+
+func NewWasmDependencyGenerator() WasmDependencyGenerator {
+	return WasmDependencyGenerator{}
+}
+
+func (wasmDepGen WasmDependencyGenerator) GetWasmDependencyGenerators() aclkeeper.DependencyGeneratorMap {
+	dependencyGeneratorMap := make(aclkeeper.DependencyGeneratorMap)
+
+	// wasm execute
+	executeContractKey := acltypes.GenerateMessageKey(&wasmtypes.MsgExecuteContract{})
+	dependencyGeneratorMap[executeContractKey] = wasmDepGen.WasmExecuteContractGenerator
+
+	return dependencyGeneratorMap
+}
+
+func (wasmDepGen WasmDependencyGenerator) WasmExecuteContractGenerator(keeper aclkeeper.Keeper, ctx sdk.Context, msg sdk.Msg) ([]sdkacltypes.AccessOperation, error) {
+	executeContractMsg, ok := msg.(*wasmtypes.MsgExecuteContract)
+	if !ok {
+		return []sdkacltypes.AccessOperation{}, ErrInvalidWasmExecuteMessage
+	}
+	contractAddr, err := sdk.AccAddressFromBech32(executeContractMsg.Contract)
+	if err != nil {
+		return []sdkacltypes.AccessOperation{}, err
+	}
+	wasmDependencyMapping, err := keeper.GetWasmDependencyMapping(ctx, contractAddr)
+	if err != nil {
+		return []sdkacltypes.AccessOperation{}, err
+	}
+	if !wasmDependencyMapping.Enabled {
+		return []sdkacltypes.AccessOperation{}, ErrWasmFunctionDependenciesDisabled
+	}
+	return wasmDependencyMapping.AccessOps, nil
+}

app/abci.go

@@ -2,49 +2,53 @@ package app
 
 import (
 	"context"
+	"time"
 
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/sei-protocol/sei-chain/utils/metrics"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"go.opentelemetry.io/otel/attribute"
 )
 
-func (app *App) BeginBlock(req abci.RequestBeginBlock) (res abci.ResponseBeginBlock) {
-	ctx, topSpan := (*app.tracingInfo.Tracer).Start(context.Background(), "Block")
+func (app *App) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) (res abci.ResponseBeginBlock) {
+	tracectx, topSpan := (*app.tracingInfo.Tracer).Start(context.Background(), "Block")
 	topSpan.SetAttributes(attribute.Int64("height", req.Header.Height))
 	app.tracingInfo.BlockSpan = &topSpan
-	app.tracingInfo.TracerContext = ctx
+	app.tracingInfo.TracerContext = tracectx
 	_, beginBlockSpan := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "BeginBlock")
 	defer beginBlockSpan.End()
-	return app.BaseApp.BeginBlock(req)
+	return app.BaseApp.BeginBlock(ctx, req)
 }
 
-func (app *App) EndBlock(req abci.RequestEndBlock) (res abci.ResponseEndBlock) {
+func (app *App) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) (res abci.ResponseEndBlock) {
 	_, span := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "EndBlock")
 	defer span.End()
-	return app.BaseApp.EndBlock(req)
+	return app.BaseApp.EndBlock(ctx, req)
 }
 
-func (app *App) CheckTx(req abci.RequestCheckTx) abci.ResponseCheckTx {
+func (app *App) CheckTx(ctx context.Context, req *abci.RequestCheckTx) (*abci.ResponseCheckTx, error) {
 	_, span := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "CheckTx")
 	defer span.End()
-	return app.BaseApp.CheckTx(req)
+	return app.BaseApp.CheckTx(ctx, req)
 }
 
-func (app *App) DeliverTx(req abci.RequestDeliverTx) abci.ResponseDeliverTx {
-	ctx, span := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "DeliverTx")
+func (app *App) DeliverTx(ctx sdk.Context, req abci.RequestDeliverTx) abci.ResponseDeliverTx {
+	defer metrics.MeasureDeliverTxDuration(time.Now())
+	tracectx, span := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "DeliverTx")
 	oldCtx := app.tracingInfo.TracerContext
-	app.tracingInfo.TracerContext = ctx
+	app.tracingInfo.TracerContext = tracectx
 	defer span.End()
 	defer func() { app.tracingInfo.TracerContext = oldCtx }()
-	return app.BaseApp.DeliverTx(req)
+	return app.BaseApp.DeliverTx(ctx, req)
 }
 
-func (app *App) Commit() (res abci.ResponseCommit) {
+func (app *App) Commit(ctx context.Context) (res *abci.ResponseCommit, err error) {
 	if app.tracingInfo.BlockSpan != nil {
 		defer (*app.tracingInfo.BlockSpan).End()
 	}
 	_, span := (*app.tracingInfo.Tracer).Start(app.tracingInfo.TracerContext, "Commit")
 	defer span.End()
 	app.tracingInfo.TracerContext = context.Background()
 	app.tracingInfo.BlockSpan = nil
-	return app.BaseApp.Commit()
+	return app.BaseApp.Commit(ctx)
 }