feat: taker fee share

CHANGELOG.md

@@ -49,6 +49,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * [#8375](https://github.com/osmosis-labs/osmosis/pull/8375) Enforce sub-authenticator to be greater than 1
 * [#8509](https://github.com/osmosis-labs/osmosis/pull/8509) Change LiquidityNetInDirection return type to sdk math
 * [#8535](https://github.com/osmosis-labs/osmosis/pull/8535) Prevent Setting Invalid Before Send Hook
+* [#8310](https://github.com/osmosis-labs/osmosis/pull/8310) Taker fee share
 * [#8494](https://github.com/osmosis-labs/osmosis/pull/8494) Add additional events in x/lockup, x/superfluid, x/concentratedliquidity
 
 ### State Compatible

app/apptesting/cosmwasmpool.go

@@ -23,6 +23,7 @@ const (
 	DefaultTransmuterDenomANormFactor = 1
 	DefaultTransmuterDenomB           = "gravusdc"
 	DefaultTransmuterDenomBNormFactor = 100
+	DefaultTransmuterDenomC           = "nbtc"
 	DefaultAlloyedSubDenom            = "allusdc"
 	DefaultAlloyedDenomNormFactor     = 1000
 
@@ -37,6 +38,14 @@ const (
 	osmosisRepoTransmuterPath = "x/cosmwasmpool/bytecode"
 )
 
+type InstantiateMsg struct {
+	PoolAssetConfigs                []AssetConfig `json:"pool_asset_configs"`
+	AlloyedAssetSubdenom            string        `json:"alloyed_asset_subdenom"`
+	AlloyedAssetNormalizationFactor string        `json:"alloyed_asset_normalization_factor"`
+	Admin                           string        `json:"admin"`
+	Moderator                       string        `json:"moderator"`
+}
+
 type AssetConfig struct {
 	Denom               string       `json:"denom"`
 	NormalizationFactor osmomath.Int `json:"normalization_factor"`
@@ -70,17 +79,48 @@ func (s *KeeperTestHelper) PrepareCustomTransmuterPool(owner sdk.AccAddress, den
 // Gives flexibility for the helper to be reused outside of the Osmosis repository by providing custom
 // project name and bytecode path.
 func (s *KeeperTestHelper) PrepareCustomTransmuterPoolCustomProject(owner sdk.AccAddress, denoms []string, projectName, byteCodePath string) cosmwasmpooltypes.CosmWasmExtension {
+	return s.PrepareTransmuterPool(owner, denoms, nil, projectName, byteCodePath, TransmuterContractName, s.GetTransmuterInstantiateMsgBytes)
+}
+
+// PrepareCustomTransmuterPoolV3 sets up a transmuter pool with the custom parameters for version 3 of the transmuter contract (alloyed assets).
+// It initializes the pool with the provided ratio for the given denoms, using a default normalization factor of "1" for each denom.
+func (s *KeeperTestHelper) PrepareCustomTransmuterPoolV3(owner sdk.AccAddress, denoms []string, ratio []uint16) cosmwasmpooltypes.CosmWasmExtension {
+	normalizationFactors := make([]string, len(denoms))
+	for i := range normalizationFactors {
+		normalizationFactors[i] = "1"
+	}
+	return s.PrepareCustomTransmuterPoolV3WithNormalization(owner, denoms, normalizationFactors, ratio)
+}
+
+// PrepareCustomTransmuterPoolV3WithNormalization sets up a transmuter pool with the custom parameters for version 3 of the transmuter contract (alloyed assets).
+// It initializes the pool with the provided ratio for the given denoms and their respective normalization factors.
+func (s *KeeperTestHelper) PrepareCustomTransmuterPoolV3WithNormalization(owner sdk.AccAddress, denoms []string, normalizationFactors []string, ratio []uint16) cosmwasmpooltypes.CosmWasmExtension {
+	pool := s.PrepareTransmuterPool(owner, denoms, normalizationFactors, osmosisRepository, osmosisRepoTransmuterPath, TransmuterV3ContractName, s.GetTransmuterInstantiateMsgBytesV3)
+	s.AddRatioFundsToTransmuterPool(s.TestAccs[0], denoms, ratio, pool.GetId())
+	pool, err := s.App.CosmwasmPoolKeeper.GetPoolById(s.Ctx, pool.GetId())
+	s.Require().NoError(err)
+	return pool
+}
+
+// PrepareTransmuterPool sets up a transmuter pool with the custom parameters and optional normalization factors.
+func (s *KeeperTestHelper) PrepareTransmuterPool(owner sdk.AccAddress, denoms []string, normalizationFactors []string, projectName, byteCodePath, contractName string, getInstantiateMsgBytes func([]string, []string, sdk.AccAddress) []byte) cosmwasmpooltypes.CosmWasmExtension {
 	// Mint some assets to the account.
 	s.FundAcc(s.TestAccs[0], DefaultAcctFunds)
 
+	// Set the supply of the denoms, since the contract fails if the denom doesn't exist on chain.
+	for _, denom := range denoms {
+		err := s.App.BankKeeper.Supply.Set(s.Ctx, denom, osmomath.NewInt(100000000000000))
+		s.Require().NoError(err)
+	}
+
 	// Upload contract code and get the code id.
-	codeId := s.StoreCosmWasmPoolContractCodeCustomProject(TransmuterContractName, projectName, byteCodePath)
+	codeId := s.StoreCosmWasmPoolContractCodeCustomProject(contractName, projectName, byteCodePath)
 
 	// Add code id to the whitelist.
 	s.App.CosmwasmPoolKeeper.WhitelistCodeId(s.Ctx, codeId)
 
 	// Generate instantiate message bytes.
-	instantiateMsgBz := s.GetTransmuterInstantiateMsgBytes(denoms)
+	instantiateMsgBz := getInstantiateMsgBytes(denoms, normalizationFactors, owner)
 
 	// Generate msg create pool.
 	validCWPoolMsg := model.NewMsgCreateCosmWasmPool(codeId, owner, instantiateMsgBz)
@@ -96,15 +136,51 @@ func (s *KeeperTestHelper) PrepareCustomTransmuterPoolCustomProject(owner sdk.Ac
 	return pool
 }
 
+// AddRatioFundsToTransmuterPool adds funds to a transmuter pool based on the provided ratio of denoms.
+// The number of tokens minted is equal to 1000000000 times the ratio.
+// (i.e. if the ratio is 2,3,5, then the number of tokens minted for each denom will be 2000000000, 3000000000, 5000000000)
+//
+// Parameters:
+// - owner: The account address that will own the funds.
+// - denoms: A list of denominations to be added to the pool.
+// - ratioOfDenoms: A list of ratios corresponding to each denom. Must be the same length as denoms.
+// - poolId: The ID of the pool to which the funds will be added.
+//
+// Panics if the length of denoms and ratioOfDenoms are not equal.
+func (s *KeeperTestHelper) AddRatioFundsToTransmuterPool(owner sdk.AccAddress, denoms []string, ratioOfDenoms []uint16, poolId uint64) {
+	if ratioOfDenoms == nil {
+		return
+	}
+
+	if len(denoms) != len(ratioOfDenoms) {
+		panic("denoms and ratioOfDenoms must be of equal length")
+	}
+
+	var poolCoins sdk.Coins
+	for i, denom := range denoms {
+		// 1000000000 is chosen randomly, we just want a set of coins that is equal to the ratio,
+		// but not so small that test cases won't have enough tokens to work with.
+		amount := osmomath.NewInt(int64(ratioOfDenoms[i])).Mul(osmomath.NewInt(1000000000))
+		if amount.IsZero() {
+			continue
+		}
+		poolCoins = append(poolCoins, sdk.NewCoin(denom, amount))
+	}
+
+	// Add funds to the pool
+	s.FundAcc(owner, poolCoins)
+	s.JoinTransmuterPool(s.TestAccs[0], poolId, poolCoins)
+}
+
 // GetDefaultTransmuterInstantiateMsgBytes returns the default instantiate message for the transmuter contract
 // with DefaultTransmuterDenomA and DefaultTransmuterDenomB as the pool asset denoms.
 func (s *KeeperTestHelper) GetDefaultTransmuterInstantiateMsgBytes() []byte {
-	return s.GetTransmuterInstantiateMsgBytes([]string{DefaultTransmuterDenomA, DefaultTransmuterDenomB})
+	return s.GetTransmuterInstantiateMsgBytes([]string{DefaultTransmuterDenomA, DefaultTransmuterDenomB}, nil, sdk.AccAddress{})
 }
 
 // GetTransmuterInstantiateMsgBytes returns the instantiate message for the transmuter contract with the
 // given pool asset denoms.
-func (s *KeeperTestHelper) GetTransmuterInstantiateMsgBytes(poolAssetDenoms []string) []byte {
+func (s *KeeperTestHelper) GetTransmuterInstantiateMsgBytes(poolAssetDenoms []string, normalizationFactors []string, owner sdk.AccAddress) []byte {
 	instantiateMsg := msg.InstantiateMsg{
 		PoolAssetDenoms: poolAssetDenoms,
 	}
@@ -115,6 +191,34 @@ func (s *KeeperTestHelper) GetTransmuterInstantiateMsgBytes(poolAssetDenoms []st
 	return instantiateMsgBz
 }
 
+// GetTransmuterInstantiateMsgBytesV3 returns the instantiate message for the transmuter contract with the
+// given pool asset denoms and their respective normalization factors.
+func (s *KeeperTestHelper) GetTransmuterInstantiateMsgBytesV3(poolAssetDenoms []string, normalizationFactors []string, owner sdk.AccAddress) []byte {
+	var assetConfigs []AssetConfig
+	for i, denom := range poolAssetDenoms {
+		normalizationFactor, ok := osmomath.NewIntFromString(normalizationFactors[i])
+		s.Require().True(ok)
+
+		assetConfigs = append(assetConfigs, AssetConfig{
+			Denom:               denom,
+			NormalizationFactor: normalizationFactor,
+		})
+	}
+
+	instantiateMsg := InstantiateMsg{
+		PoolAssetConfigs:                assetConfigs,
+		AlloyedAssetSubdenom:            DefaultAlloyedSubDenom,
+		AlloyedAssetNormalizationFactor: "1",
+		Admin:                           owner.String(),
+		Moderator:                       owner.String(),
+	}
+
+	instantiateMsgBz, err := json.Marshal(instantiateMsg)
+	s.Require().NoError(err)
+
+	return instantiateMsgBz
+}
+
 // StoreCosmWasmPoolContractCode stores the cosmwasm pool contract code in the wasm keeper and returns the code id.
 // contractName is the name of the contract file in the x/cosmwasmpool/bytecode directory without the .wasm extension.
 func (s *KeeperTestHelper) StoreCosmWasmPoolContractCode(contractName string) uint64 {

app/apptesting/test_suite.go

@@ -81,6 +81,7 @@ type SupportedPoolAndGaugeInfo struct {
 	BalancerPoolID     uint64
 	StableSwapPoolID   uint64
 	CosmWasmPoolID     uint64
+	AlloyedPoolID      uint64
 
 	ConcentratedGaugeID uint64
 	BalancerGaugeID     uint64
@@ -184,12 +185,16 @@ func (s *KeeperTestHelper) PrepareAllSupportedPoolsCustomProject(projectName, tr
 		stableswapPoolID   = s.PrepareBasicStableswapPool()
 		cosmWasmPool       = s.PrepareCustomTransmuterPoolCustomProject(s.TestAccs[0], []string{DefaultTransmuterDenomA, DefaultTransmuterDenomB}, projectName, transmuterPath)
 		cosmWasmPoolID     = cosmWasmPool.GetId()
+		alloyedPool        = s.PrepareCustomTransmuterPoolV3(s.TestAccs[0], []string{DefaultTransmuterDenomA, DefaultTransmuterDenomB}, []uint16{1, 1})
+		alloyedPoolID      = alloyedPool.GetId()
 	)
+
 	return SupportedPoolAndGaugeInfo{
 		ConcentratedPoolID: concentratedPoolID,
 		BalancerPoolID:     balancerPoolID,
 		StableSwapPoolID:   stableswapPoolID,
 		CosmWasmPoolID:     cosmWasmPoolID,
+		AlloyedPoolID:      alloyedPoolID,
 
 		// Define expected gauge IDs:
 

app/keepers/keepers.go

@@ -445,6 +445,7 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 		appKeepers.DistrKeeper,
 		appKeepers.StakingKeeper,
 		appKeepers.ProtoRevKeeper,
+		appKeepers.WasmKeeper,
 	)
 	appKeepers.PoolManagerKeeper.SetStakingKeeper(appKeepers.StakingKeeper)
 	appKeepers.GAMMKeeper.SetPoolManager(appKeepers.PoolManagerKeeper)
@@ -598,6 +599,7 @@ func (appKeepers *AppKeepers) InitNormalKeepers(
 	)
 	appKeepers.WasmKeeper = &wasmKeeper
 	appKeepers.CosmwasmPoolKeeper.SetWasmKeeper(appKeepers.WasmKeeper)
+	appKeepers.PoolManagerKeeper.SetWasmKeeper(appKeepers.WasmKeeper)
 
 	// Pass the contract keeper to all the structs (generally ICS4Wrappers for ibc middlewares) that need it
 	appKeepers.ContractKeeper = wasmkeeper.NewDefaultPermissionKeeper(appKeepers.WasmKeeper)

app/upgrades/v24/upgrades_test.go

@@ -225,9 +225,9 @@ func (s *UpgradeTestSuite) TestUpgrade() {
 	// TWAP records indexed by pool ID should be untouched.
 	twapRecords, err = s.App.TwapKeeper.GetAllHistoricalPoolIndexedTWAPsForPoolId(s.Ctx, twapRecord1.PoolId)
 	s.Require().NoError(err)
-	s.Require().Len(twapRecords, 6)
-	s.Require().Equal(twapRecord1, twapRecords[4])
-	s.Require().Equal(twapRecord2, twapRecords[5])
+	s.Require().Len(twapRecords, 8)
+	s.Require().Equal(twapRecord1, twapRecords[6])
+	s.Require().Equal(twapRecord2, twapRecords[7])
 
 	// PROTOREV Tests
 	//

ingest/common/domain/keepers.go

@@ -71,7 +71,7 @@ type PoolManagerKeeper interface {
 		tokenIn sdk.Coin,
 		tokenOutDenom string,
 		tokenOutMinAmount osmomath.Int,
-	) (tokenOutAmount osmomath.Int, err error)
+	) (tokenOutAmount osmomath.Int, takerFeeTotal sdk.Coin, err error)
 
 	RouteGetPoolDenoms(
 		ctx sdk.Context,

proto/osmosis/cosmwasmpool/v1beta1/model/v3/pool_query_msg.proto

@@ -0,0 +1,38 @@
+syntax = "proto3";
+package osmosis.cosmwasmpool.v1beta1.model.v3;
+
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v25/x/cosmwasmpool/cosmwasm/msg/v3";
+
+// ===================== ShareDenomResponse
+message ShareDenomResponse {
+  // share_denom is the share denomination.
+  string share_denom = 1;
+}
+
+// ===================== TotalPoolLiquidityResponse
+message TotalPoolLiquidityResponse {
+  // total_pool_liquidity is the total liquidity in the pool denominated in
+  // coins.
+  repeated cosmos.base.v1beta1.Coin total_pool_liquidity = 1 [
+    (gogoproto.nullable) = false,
+    (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+  ];
+}
+
+// ===================== AssetConfig
+message AssetConfig {
+  // denom is the asset denomination.
+  string denom = 1;
+
+  // normalization_factor is the normalization factor for the asset.
+  string normalization_factor = 2;
+}
+
+// ===================== ListAssetConfigsResponse
+message ListAssetConfigsResponse {
+  // asset_configs is the list of asset configurations.
+  repeated AssetConfig asset_configs = 1 [ (gogoproto.nullable) = false ];
+}