From f9b55d269eeea8962a61e2bc176401a02e3cd29a Mon Sep 17 00:00:00 2001 From: Collin Date: Sat, 3 Feb 2024 22:34:21 -0600 Subject: [PATCH] feat:porting over add adaptor/position/oracle/price router permission structure (#246) * Restore permission structure for SP calls to add adaptor/position * Remove AddPosition changes for v2.2 Cellars * Go protos * Port the rest of the protos to SP API * Remove functions mistakenly added to SP API, force position out one off stuff * Remove unnecessary checks --- proto/steward/v4/cellar_v2.proto | 305 +- src/cellars.rs | 441 +- src/cellars/cellar_v2.rs | 108 +- src/cellars/cellar_v2_2.rs | 109 +- src/cellars/cellar_v2_5.rs | 121 +- src/gen/proto/descriptor.bin | Bin 196414 -> 208131 bytes src/gen/proto/steward.v4.rs | 341 +- .../steward_proto/cellar_v2.pb.go | 5941 +++++++++++------ 8 files changed, 5200 insertions(+), 2166 deletions(-) diff --git a/proto/steward/v4/cellar_v2.proto b/proto/steward/v4/cellar_v2.proto index 8b9abdd0..9f9cb38e 100644 --- a/proto/steward/v4/cellar_v2.proto +++ b/proto/steward/v4/cellar_v2.proto @@ -46,37 +46,38 @@ import "curve.proto"; */ message CellarV2 { // The function you wish to execute on the target cellar - oneof function { - // Represents function `addPosition(uint256 index, address position)` - AddPosition add_position = 1; + oneof function { // Represents function `callOnAdaptor(AdaptorCall[] memory data)` - CallOnAdaptor call_on_adaptor = 2; + CallOnAdaptor call_on_adaptor = 1; // Represents function `removePosition(uint256 index)` - RemovePosition remove_position = 3; + RemovePosition remove_position = 2; // Represents function `setHoldingPosition(uint32 position_id)` - SetHoldingPosition set_holding_position = 4; + SetHoldingPosition set_holding_position = 3; // Represents function `setStrategistPayoutAddress(address payout)` - SetStrategistPayoutAddress set_strategist_payout_address = 5; + SetStrategistPayoutAddress set_strategist_payout_address = 4; // Represents function `swapPositions(uint256 index1, uint256 index2)` - SwapPositions swap_positions = 6; + SwapPositions swap_positions = 5; // Represents function `setShareLockPeriod(uint256 newLock)` - SetShareLockPeriod set_share_lock_period = 7; - } + SetShareLockPeriod set_share_lock_period = 6; - /* - * Insert a trusted position to the list of positions used by the cellar at a given index. - * - * Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` - */ - message AddPosition { - // Index at which to add the position - uint32 index = 1; - // The position's ID in the cellar registry - uint32 position_id = 2; - // Data used to configure how the position behaves - bytes configuration_data = 3; - // Whether to add position in the debt array, or the credit array. - bool in_debt_array = 4; + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + + // Represents function `addPosition(uint256 index, address position)` + AddPosition add_position = 7; + // Represents function `setupAdaptor(address adaptor)` + SetupAdaptor setup_adaptor = 8; + // Represents function `initiateShutdown()` + InitiateShutdown initiate_shutdown = 9; + // Represents function `liftShutdown()` + LiftShutdown lift_shutdown = 10; + // Represents function `setPlatformFee(uint256)` + SetPlatformFee set_platform_fee = 11; + // Represents function `setStrategistPlatformCut(address)` + SetStrategistPlatformCut set_strategist_platform_cut = 12; + // Represents function `setRebalanceDeviation(uint256)` + SetRebalanceDeviation set_rebalance_deviation = 13; } /* @@ -141,6 +142,63 @@ message CellarV2 { message SetShareLockPeriod { string new_lock = 1; } + + /* + * Insert a trusted position to the list of positions used by the cellar at a given index. + * + * Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` + */ + message AddPosition { + // Index at which to add the position + uint32 index = 1; + // The position's ID in the cellar registry + uint32 position_id = 2; + // Data used to configure how the position behaves + bytes configuration_data = 3; + // Whether to add position in the debt array, or the credit array. + bool in_debt_array = 4; + } + + // Represents function `initiateShutdown()` + message InitiateShutdown { + } + + // Represents function `liftShutdown()` + message LiftShutdown { + } + + // Represents function `setPlatformFee(uint64)` + message SetPlatformFee { + // New platform fee + uint64 amount = 1; + } + + // Represents function `setStrategistPlatformCut(uint64)` + message SetStrategistPlatformCut { + // New strategist platform cut + uint64 amount = 1; + } + + /* + * Allows owner to add new adaptors for the cellar to use. + * + * Represents function `setupAdaptor(address adaptor)` + */ + message SetupAdaptor { + // Address of the adaptor + string adaptor = 1; + } + + /* + * Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + * during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + * + * Represents function `setRebalanceDeviation(uint256)` + */ + message SetRebalanceDeviation { + string new_deviation = 1; + } + } /* @@ -231,6 +289,27 @@ message CellarV2_2 { SetStrategistPayoutAddress set_strategist_payout_address = 7; // Represents function `swapPositions(uint256 index1, uint256 index2)` SwapPositions swap_positions = 8; + + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + + // Represents function `addAdaptorToCatalogue(address adaptor)` + AddAdaptorToCatalogue add_adaptor_to_catalogue = 9; + // Represents function `addPositionToCatalogue(uint32 positionId)` + AddPositionToCatalogue add_position_to_catalogue = 10; + // Represents function `setRebalanceDeviation(uint265)` + SetRebalanceDeviation set_rebalance_deviation = 11; + // Represents function `setShareLockPeriod(uint256 newLock)` + SetShareLockPeriod set_share_lock_period = 12; + // Represents function `setStrategistPlatformCut(uint64 cut)` + SetStrategistPlatformCut set_strategist_platform_cut = 13; + // Represents function `initiateShutdown()` + InitiateShutdown initiate_shutdown = 14; + // Represents function `liftShutdown()` + LiftShutdown lift_shutdown = 15; + // Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + CachePriceRouter cache_price_router = 16; } } @@ -330,6 +409,82 @@ message CellarV2_2 { message Multicall { repeated FunctionCall function_calls = 1; } + + /* + * Allows the owner to add an adaptor to the Cellar's adaptor catalogue + * + * Represents function `addAdaptorToCatalogue(address adaptor)` + */ + message AddAdaptorToCatalogue { + string adaptor = 1; + } + + /* + * Allows the owner to add a position to the Cellar's position catalogue + * + * Represents function `addPositionToCatalogue(uint32 positionId)` + */ + message AddPositionToCatalogue { + uint32 position_id = 1; + } + + /* + * Allows share lock period to be updated. + * + * Represents function `setShareLockPeriod()` + */ + message SetShareLockPeriod { + string new_lock = 1; + } + + /* + * Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + * during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + * + * Represents function `setRebalanceDeviation(uint256)` + */ + message SetRebalanceDeviation { + string new_deviation = 1; + } + + /* + * Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. + * + * Represents function `initiateShutdown()` + */ + message InitiateShutdown {} + + /* + * Allows strategist to set the platform cut for the cellar. + * + * Represents function `setStrategistPlatformCut(uint64 cut)` + */ + message SetStrategistPlatformCut { + // The new strategist platform cut + uint64 new_cut = 1; + } + + /* + * Allows the owner to restart a shut down Cellar + * + * Represents function `liftShutdown()` + */ + message LiftShutdown {} + + /* + * Updates the cellar to use the latest price router in the registry. + * + * Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + */ + message CachePriceRouter { + // Whether to check the total assets of the cellar + bool check_total_assets = 1; + // The allowable range of the cellar's total assets to deviate between old and new routers + uint32 allowable_range = 2; + // The expected price router address + string expected_price_router = 3; + } + } /* @@ -495,6 +650,25 @@ message CellarV2_5 { SetAlternativeAssetData set_alternative_asset_data = 17; // Represents function `setDropAlternativeAssetData(ERC20 _alternativeAsset)` DropAlternativeAssetData drop_alternative_asset_data = 18; + + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + + // Represents function `addAdaptorToCatalogue(address adaptor)` + AddAdaptorToCatalogue add_adaptor_to_catalogue = 19; + // Represents function `addPositionToCatalogue(uint32 positionId)` + AddPositionToCatalogue add_position_to_catalogue = 20; + // Represents function `setRebalanceDeviation(uint265)` + SetRebalanceDeviation set_rebalance_deviation = 21; + // Represents function `setStrategistPlatformCut(uint64 cut)` + SetStrategistPlatformCut set_strategist_platform_cut = 22; + // Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` + SetSharePriceOracle set_share_price_oracle = 23; + // Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` + IncreaseShareSupplyCap increase_share_supply_cap = 24; + // Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + CachePriceRouter cache_price_router = 25; } } @@ -577,16 +751,6 @@ message CellarV2_5 { string new_lock = 1; } - /* - * Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate - * during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. - * - * Represents function `setRebalanceDeviation(uint256)` - */ - message SetRebalanceDeviation { - string new_deviation = 1; - } - /* * Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. * @@ -660,6 +824,79 @@ message CellarV2_5 { // The address of the alternative asset string alternative_asset = 1; } + + /* + * Allows the owner to add an adaptor to the Cellar's adaptor catalogue + * + * Represents function `addAdaptorToCatalogue(address adaptor)` + */ + message AddAdaptorToCatalogue { + string adaptor = 1; + } + + /* + * Allows the owner to add a position to the Cellar's position catalogue + * + * Represents function `addPositionToCatalogue(uint32 positionId)` + */ + message AddPositionToCatalogue { + uint32 position_id = 1; + } + + /* + * Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + * during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + * + * Represents function `setRebalanceDeviation(uint256)` + */ + message SetRebalanceDeviation { + string new_deviation = 1; + } + + /* + * Allows strategist to set the platform cut for the cellar. + * + * Represents function `setStrategistPlatformCut(uint64 cut)` + */ + message SetStrategistPlatformCut { + // The new strategist platform cut + uint64 new_cut = 1; + } + + /* + * Allows the caller to increase the share supply cap + * + * Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` + */ + message IncreaseShareSupplyCap { + string new_cap = 1; + } + + /* + * Allows the caller to set the share price oracle contract + * + * Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` + */ + message SetSharePriceOracle { + // The oracle registry ID + string registry_id = 1; + // The oracle contract address + string share_price_oracle = 2; + } + + /* + * Updates the cellar to use the latest price router in the registry. + * + * Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + */ + message CachePriceRouter { + // Whether to check the total assets of the cellar + bool check_total_assets = 1; + // The allowable range of the cellar's total assets to deviate between old and new routers + uint32 allowable_range = 2; + // The expected price router address + string expected_price_router = 3; + } } /* diff --git a/src/cellars.rs b/src/cellars.rs index bb9f003c..ca2e40c5 100644 --- a/src/cellars.rs +++ b/src/cellars.rs @@ -1,12 +1,15 @@ use crate::{ cork::cache::{self, is_approved}, error::{Error, ErrorKind}, - utils::sp_call_error, + utils::{sp_call_error, string_to_u256}, }; use abscissa_core::tracing::info; -use ethers::abi::Address; +use ethers::prelude::*; +use lazy_static::lazy_static; use std::result::Result; +pub type CachePriceRouterArgs = (bool, u32, Option); + pub(crate) mod aave_v2_stablecoin; pub(crate) mod adaptors; pub(crate) mod cellar_v1; @@ -17,14 +20,128 @@ pub(crate) mod cellar_v2_5; // constants // addresses are normalized by removing the 0x prefix and converting to lowercase for reliable comparison -// block lists +// oracles + +pub const TURBOSWETH_ORACLE1: (U256, &str) = ( + U256([3, 0, 0, 0]), + "72249f0199eacf6230def33a31e80cf76de78f67", +); +pub const TURBOSWETH_ORACLE2: (U256, &str) = ( + U256([5, 0, 0, 0]), + "c47278b65443ce71cf47e8455bb343f2db11b70e", +); +pub const TURBOSWETH_ORACLE3: (U256, &str) = ( + U256([5, 0, 0, 0]), + "26cde3f5db92ea91c84c838e664fe42dec1b6747", +); +pub const TURBOSWETH_ORACLE4: (U256, &str) = ( + U256([5, 0, 0, 0]), + "cb265cac371970e51bec685930e1340fd919fae3", +); + +pub const ALLOWED_TURBOSWETH_PRICE_ORACLES: [(U256, &str); 4] = [ + TURBOSWETH_ORACLE1, + TURBOSWETH_ORACLE2, + TURBOSWETH_ORACLE3, + TURBOSWETH_ORACLE4, +]; + +pub const TURBOSOMM_ORACLE1: (U256, &str) = ( + U256([8, 0, 0, 0]), + "30510876b377941f23d7322845de0ca734da59e0", +); +pub const TURBOSOMM_ORACLE2: (U256, &str) = ( + U256([8, 0, 0, 0]), + "84785287f0c9c282462da7927aaed9773b32d9cb", +); + +pub const ALLOWED_TURBOSOMM_PRICE_ORACLES: [(U256, &str); 2] = + [TURBOSOMM_ORACLE1, TURBOSOMM_ORACLE2]; + +// price routers + +// since we're wrapping price router addresses in as Option, it vastly simplifies comparisons for them to be +// owned values (String) vs. a borrowed &str since we have to mutate the passed in values to normalize them. +lazy_static! { + pub static ref PRICEROUTER1: String = String::from("a1a0bc3d59e4ee5840c9530e49bdc2d1f88aaf92"); + pub static ref PRICEROUTER2: String = String::from("8e46f30b09fdfae6c97db27fecf3304f86dd88c2"); + + // mapping of cellar address to allowable arguments for a cachePriceRouter call. + // args map to params as (checkTotalAssets, allowableRange, expectedPriceRouterAddress). The third + // param is only present for 2.5 cellars so it's an Option<&str>. + pub static ref ALLOWED_CACHE_PRICE_ROUTER: [(&'static str, CachePriceRouterArgs); 4] = [ + (CELLAR_RYBTC, (true, 500, None)), + (CELLAR_RYETH, (true, 500, None)), + (CELLAR_TURBO_STETH, (false, 500, Some(PRICEROUTER1.clone()))), + (CELLAR_TURBO_STETH, (true, 500, Some(PRICEROUTER2.clone()))), + ]; +} + +// permissions + +pub const ALLOWED_V2_0_SETUP_ADAPTORS: [(&str, &str); 0] = []; +pub const ALLOWED_V2_2_CATALOGUE_ADAPTORS: [(&str, &str); 0] = []; +pub const ALLOWED_V2_5_CATALOGUE_ADAPTORS: [(&str, &str); 0] = []; + +// due to position size limits in v2.0, positions must be added and removed from the limited list +// and thus approved positions need to be allowed to be re-added, hence this large list +pub const ALLOWED_V2_0_POSITIONS: [(&str, u32); 20] = [ + (CELLAR_RYUSD, 1), + (CELLAR_RYUSD, 2), + (CELLAR_RYUSD, 3), + (CELLAR_RYUSD, 13), + (CELLAR_RYUSD, 14), + (CELLAR_RYUSD, 15), + (CELLAR_RYUSD, 16), + (CELLAR_RYUSD, 17), + (CELLAR_RYUSD, 18), + (CELLAR_RYUSD, 19), + (CELLAR_RYUSD, 20), + (CELLAR_RYUSD, 21), + (CELLAR_RYUSD, 22), + (CELLAR_RYUSD, 23), + (CELLAR_RYUSD, 24), + (CELLAR_RYUSD, 25), + (CELLAR_RYUSD, 26), + (CELLAR_RYUSD, 27), + (CELLAR_RYUSD, 28), + (CELLAR_RYUSD, 29), +]; +pub const ALLOWED_V2_2_CATALOGUE_POSITIONS: [(&str, u32); 0] = []; +pub const ALLOWED_V2_5_CATALOGUE_POSITIONS: [(&str, u32); 2] = + [(CELLAR_TURBO_EETH, 7000002), (CELLAR_TURBO_EETH, 7500002)]; pub const BLOCKED_ADAPTORS: [&str; 3] = [ ADAPTOR_UNIV3_V1, ADAPTOR_VESTING_SIMPLE_V1, ADAPTOR_COMPOUND_C_TOKEN_V1, ]; -pub const BLOCKED_POSITIONS: [u32; 9] = [4, 5, 6, 7, 8, 9, 10, 11, 12]; + +pub const BLOCKED_V2_0_POSITIONS: [u32; 9] = [4, 5, 6, 7, 8, 9, 10, 11, 12]; +pub const BLOCKED_V2_2_POSITIONS: [u32; 0] = []; +pub const BLOCKED_V2_5_POSITIONS: [u32; 0] = []; + +pub struct CellarArchPermissions { + allowed_adaptors: &'static [(&'static str, &'static str)], + allowed_positions: &'static [(&'static str, u32)], + blocked_positions: &'static [u32], +} + +pub const V2_0_PERMISSIONS: CellarArchPermissions = CellarArchPermissions { + allowed_adaptors: &ALLOWED_V2_0_SETUP_ADAPTORS, + allowed_positions: &ALLOWED_V2_0_POSITIONS, + blocked_positions: &BLOCKED_V2_0_POSITIONS, +}; +pub const V2_2_PERMISSIONS: CellarArchPermissions = CellarArchPermissions { + allowed_adaptors: &ALLOWED_V2_2_CATALOGUE_ADAPTORS, + allowed_positions: &ALLOWED_V2_2_CATALOGUE_POSITIONS, + blocked_positions: &BLOCKED_V2_2_POSITIONS, +}; +pub const V2_5_PERMISSIONS: CellarArchPermissions = CellarArchPermissions { + allowed_adaptors: &ALLOWED_V2_5_CATALOGUE_ADAPTORS, + allowed_positions: &ALLOWED_V2_5_CATALOGUE_POSITIONS, + blocked_positions: &BLOCKED_V2_5_POSITIONS, +}; // cellars @@ -36,6 +153,11 @@ pub const CELLAR_RYLINK: &str = "4068bdd217a45f8f668ef19f1e3a1f043e4c4934"; pub const CELLAR_RYSNX: &str = "cbf2250f33c4161e18d4a2fa47464520af5216b5"; pub const CELLAR_RYUNI: &str = "6a6af5393dc23d7e3db28d28ef422db7c40932b6"; pub const CELLAR_RYUSD: &str = "97e6e0a40a3d02f12d1cec30ebfbae04e37c119e"; +pub const CELLAR_TURBO_SWETH: &str = "d33dad974b938744dac81fe00ac67cb5aa13958e"; +pub const CELLAR_TURBO_GHO: &str = "0c190ded9be5f512bd72827bdad4003e9cc7975c"; +pub const CELLAR_TURBO_STETH: &str = "fd6db5011b171b05e1ea3b92f9eacaeeb055e971"; +pub const CELLAR_TURBO_SOMM: &str = "5195222f69c5821f8095ec565e71e18ab6a2298f"; +pub const CELLAR_TURBO_EETH: &str = "9a7b4980c6f0fcaa50cd5f288ad7038f434c692e"; // deprecated adaptors @@ -45,13 +167,29 @@ pub const ADAPTOR_COMPOUND_C_TOKEN_V1: &str = "26dba82495f6189dde7648ae88bead46c // adaptors +pub const ADAPTOR_AAVE_V3_A_TOKEN_V1: &str = "76cef5606c8b6ba38fe2e3c639e1659afa530b47"; +pub const ADAPTOR_AURA_ERC4626_ADAPTOR_V1: &str = "298d97494c5374e796368bcf15f0290771f6ae99"; +pub const ADAPTOR_BALANCER_POOL_V1: &str = "2750348a897059c45683d33a1742a3989454f7d6"; pub const ADAPTOR_CELLAR_V2: &str = "3b5ca5de4d808cd793d3a7b3a731d3e67e707b27"; +pub const ADAPTOR_COLLATERAL_F_TOKEN_V1: &str = "0055cf6a99eba1405d100c7dfaa88a35521a0037"; +pub const ADAPTOR_CONVEX_CURVE_ADAPTOR_V1: &str = "98c44ff447c62364e3750c5e2ef8acc38391a8b0"; +pub const ADAPTOR_CURVE_ADAPTOR_V1: &str = "94e28529f73dad189cd0bf9d83a06572d4bfb26a"; +pub const ADAPTOR_DEBT_F_TOKEN_V1: &str = "50d8f70a5da95021dab86579db4751a863c1b87c"; +pub const ADAPTOR_LEGACY_CELLAR_V1: &str = "1e22adf9e63ef8f2a3626841ddddd19683e31068"; pub const ADAPTOR_MORPHO_AAVE_V2_A_TOKEN_V1: &str = "1a4cb53edb8c65c3df6aa9d88c1ab4cf35312b73"; pub const ADAPTOR_MORPHO_AAVE_V2_DEBT_TOKEN_V1: &str = "407d5489f201013ee6a6ca20fccb05047c548138"; pub const ADAPTOR_MORPHO_AAVE_V3_A_TOKEN_COLLATERAL_V1: &str = "b46e8a03b1aafffb50f281397c57b5b87080363e"; pub const ADAPTOR_MORPHO_AAVE_V3_DEBT_TOKEN_V1: &str = "25a61f771af9a38c10ddd93c2bbab39a88926fa9"; pub const ADAPTOR_MORPHO_AAVE_V3_P2P_V1: &str = "4fe068caad05b82bf3f86e1f7d1a7b8bbf516111"; +// used by RYETH, RYBTC +pub const ADAPTOR_UNIV3_V3_DEPLOYMENT_1: &str = "92611574ec9bc13c6137917481dab7bb7b173c9b"; +// used by Turbo stETH and eETH +pub const ADAPTOR_UNIV3_V3_DEPLOYMENT_2: &str = "c74ffa211a8148949a77ec1070df7013c8d5ce92"; +pub const ADAPTOR_VESTING_SIMPLE_V1_1_DEPLOYMENT1: &str = + "3b98ba00f981342664969e609fb88280704ac479"; +pub const ADAPTOR_VESTING_SIMPLE_V1_1_DEPLOYMENT2: &str = + "8a95bbabb0039480f6dd90fe856c1e0c3d575aa1"; // utils @@ -86,6 +224,93 @@ pub fn normalize_address(address: String) -> String { // validation logic +pub fn validate_new_adaptor( + cellar_id: &str, + adaptor_id: &str, + permissions: &CellarArchPermissions, +) -> Result<(), Error> { + let adaptor_id = normalize_address(adaptor_id.to_string()); + check_blocked_adaptor(&adaptor_id)?; + + let cellar_id = normalize_address(cellar_id.to_string()); + if !permissions + .allowed_adaptors + .contains(&(&cellar_id, &adaptor_id)) + { + return Err(sp_call_error(format!( + "new adaptor {adaptor_id} not allowed to be added for cellar {cellar_id}" + ))); + } + + Ok(()) +} + +pub fn validate_new_position( + cellar_id: &str, + position: u32, + permissions: &CellarArchPermissions, +) -> Result<(), Error> { + check_blocked_position(&position, permissions)?; + + let cellar_id = normalize_address(cellar_id.to_string()); + if !permissions + .allowed_positions + .contains(&(&cellar_id, position)) + { + return Err(sp_call_error(format!( + "new position {position} not allowed to be added for cellar {cellar_id}" + ))); + } + + Ok(()) +} + +pub fn validate_oracle( + cellar_id: &str, + registry_id_in: &str, + oracle_in: &str, +) -> Result<(), Error> { + let cellar_id_normalized = normalize_address(cellar_id.to_string()); + let oracle_in = normalize_address(oracle_in.to_string()); + let registry_id_in = string_to_u256(registry_id_in.to_string())?; + if cellar_id_normalized.eq(CELLAR_TURBO_SWETH) + && ALLOWED_TURBOSWETH_PRICE_ORACLES.contains(&(registry_id_in, oracle_in.as_str())) + { + return Ok(()); + } + if cellar_id_normalized.eq(CELLAR_TURBO_SOMM) + && ALLOWED_TURBOSOMM_PRICE_ORACLES.contains(&(registry_id_in, oracle_in.as_str())) + { + return Ok(()); + } + + Err(sp_call_error("unauthorized oracle update".to_string())) +} + +pub fn validate_cache_price_router( + cellar_id: &str, + check_total_assets_value: bool, + allowable_range_value: u32, + expected_price_router: Option, +) -> Result<(), Error> { + let cellar_id_normalized = normalize_address(cellar_id.to_string()); + let expected_price_router = expected_price_router.map(normalize_address); + + if !ALLOWED_CACHE_PRICE_ROUTER + .iter() + .any(|(cellar_id, permissions)| { + cellar_id_normalized.eq(cellar_id) + && permissions.0 == check_total_assets_value + && permissions.1 >= allowable_range_value + && permissions.2 == expected_price_router + }) + { + return Err(sp_call_error("call not authorized for cellar".to_string())); + } + + Ok(()) +} + pub fn check_blocked_adaptor(adaptor_id: &str) -> Result<(), Error> { let adaptor_id = normalize_address(adaptor_id.to_string()); if BLOCKED_ADAPTORS.contains(&adaptor_id.as_str()) { @@ -95,8 +320,11 @@ pub fn check_blocked_adaptor(adaptor_id: &str) -> Result<(), Error> { Ok(()) } -pub fn check_blocked_position(position: &u32) -> Result<(), Error> { - if BLOCKED_POSITIONS.contains(position) { +pub fn check_blocked_position( + position: &u32, + permissions: &CellarArchPermissions, +) -> Result<(), Error> { + if permissions.blocked_positions.contains(position) { return Err(sp_call_error(format!("position {position} is blocked"))); } @@ -194,28 +422,35 @@ mod tests { #[test] fn test_check_blocked_position() { + let error_prefix = "SP call error: ".to_string(); + // allows unblocked position ID let unblocked_pos = 25; - assert!(check_blocked_position(&unblocked_pos).is_ok()); - - let error_prefix = "SP call error: ".to_string(); + assert!(check_blocked_position(&unblocked_pos, &V2_0_PERMISSIONS).is_ok()); + assert!(check_blocked_position(&unblocked_pos, &V2_2_PERMISSIONS).is_ok()); + assert!(check_blocked_position(&unblocked_pos, &V2_5_PERMISSIONS).is_ok()); // rejects blocked position ID - let blocked_pos = 4; - let res = check_blocked_position(&blocked_pos); - let expected_err = error_prefix.clone() + &format!("position {blocked_pos} is blocked"); + let v2_0_blocked_pos = 4; + let res = check_blocked_position(&v2_0_blocked_pos, &V2_0_PERMISSIONS); + let expected_err = + error_prefix.clone() + &format!("position {v2_0_blocked_pos} is blocked"); assert!(res.is_err()); assert_eq!(expected_err, res.unwrap_err().to_string()); + + // this position is only blocked on V2.0 + assert!(check_blocked_position(&v2_0_blocked_pos, &V2_2_PERMISSIONS).is_ok()); + assert!(check_blocked_position(&v2_0_blocked_pos, &V2_5_PERMISSIONS).is_ok()); } #[test] fn test_check_blocked_adaptor() { + let error_prefix = "SP call error: ".to_string(); + // allows unblocked adaptor ID let unblocked_adaptor = ADAPTOR_MORPHO_AAVE_V2_A_TOKEN_V1; assert!(check_blocked_adaptor(&unblocked_adaptor).is_ok()); - let error_prefix = "SP call error: ".to_string(); - // rejects blocked adaptor ID let blocked_adaptor = ADAPTOR_UNIV3_V1; let res = check_blocked_adaptor(&blocked_adaptor); @@ -223,4 +458,182 @@ mod tests { assert!(res.is_err()); assert_eq!(expected_err, res.unwrap_err().to_string()); } + + #[test] + fn test_validate_new_adaptor() { + let error_prefix = "SP call error: ".to_string(); + + // allows approved cellar/adaptor ID pairs + let (v2_0_cellar_id, v2_0_approved_adaptor_id) = (CELLAR_RYUSD, ADAPTOR_CELLAR_V2); + // assert!( + // validate_new_adaptor(v2_0_cellar_id, v2_0_approved_adaptor_id, &V2_0_PERMISSIONS) + // .is_ok() + // ); + + // rejects blocked adaptor ID + let blocked_adaptor_id = ADAPTOR_UNIV3_V1; + let res = validate_new_adaptor(v2_0_cellar_id, blocked_adaptor_id, &V2_0_PERMISSIONS); + let expected_err = + error_prefix.clone() + &format!("adaptor {blocked_adaptor_id} is blocked"); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + + // rejects unapproved cellar/adaptor ID pair + let unapproved_adaptor_id = ADAPTOR_UNIV3_V3_DEPLOYMENT_1; + let res = validate_new_adaptor(v2_0_cellar_id, unapproved_adaptor_id, &V2_0_PERMISSIONS); + let expected_err = error_prefix.clone() + + &format!( + "new adaptor {unapproved_adaptor_id} not allowed to be added for cellar {v2_0_cellar_id}" + ); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + + let unapproved_cellar = "0000000000000000000000000000000000000000"; + let res = validate_new_adaptor( + unapproved_cellar, + v2_0_approved_adaptor_id, + &V2_0_PERMISSIONS, + ); + let expected_err = error_prefix + + &format!("new adaptor {v2_0_approved_adaptor_id} not allowed to be added for cellar {unapproved_cellar}"); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + } + + #[test] + fn test_validate_new_position() { + let error_prefix = "SP call error: ".to_string(); + + // allows approved cellar/position ID pairs + let (v2_0_cellar_id, v2_0_approved_pos) = (CELLAR_RYUSD, 1); + assert!( + validate_new_position(v2_0_cellar_id, v2_0_approved_pos, &V2_0_PERMISSIONS).is_ok() + ); + + // rejects blocked position ID + let blocked_pos = 4; + let res = validate_new_position(v2_0_cellar_id, blocked_pos, &V2_0_PERMISSIONS); + let expected_err = error_prefix.clone() + &format!("position {blocked_pos} is blocked"); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + + // rejects unapproved cellar/position ID pair + let unapproved_pos = 153; + let res = validate_new_position(v2_0_cellar_id, unapproved_pos, &V2_0_PERMISSIONS); + let expected_err = error_prefix.clone() + + &format!( + "new position {unapproved_pos} not allowed to be added for cellar {v2_0_cellar_id}" + ); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + + let unapproved_cellar = "0000000000000000000000000000000000000000"; + let res = validate_new_position(unapproved_cellar, v2_0_approved_pos, &V2_0_PERMISSIONS); + let expected_err = error_prefix + + &format!( + "new position {v2_0_approved_pos} not allowed to be added for cellar {unapproved_cellar}" + ); + assert!(res.is_err()); + assert_eq!(expected_err, res.unwrap_err().to_string()); + } + + #[test] + fn test_u256_sanity() { + assert_eq!(U256([5, 0, 0, 0]), U256::from(5)); + } + + #[test] + fn test_validate_oracle() { + assert!(validate_oracle( + CELLAR_RYBTC, + &TURBOSWETH_ORACLE1.0.to_string(), + TURBOSWETH_ORACLE1.1 + ) + .is_err()); + assert!(validate_oracle( + CELLAR_RYBTC, + &TURBOSOMM_ORACLE1.0.to_string(), + TURBOSOMM_ORACLE1.1 + ) + .is_err()); + assert!(validate_oracle( + CELLAR_TURBO_SWETH, + &U256::from(6).to_string(), + TURBOSWETH_ORACLE2.1 + ) + .is_err()); + assert!(validate_oracle( + CELLAR_TURBO_SOMM, + &U256::from(6).to_string(), + TURBOSOMM_ORACLE2.1 + ) + .is_err()); + assert!(validate_oracle( + CELLAR_TURBO_SWETH, + &TURBOSWETH_ORACLE1.0.to_string(), + TURBOSWETH_ORACLE1.1 + ) + .is_ok()); + assert!(validate_oracle( + CELLAR_TURBO_SWETH, + &TURBOSWETH_ORACLE2.0.to_string(), + TURBOSWETH_ORACLE2.1 + ) + .is_ok()); + assert!(validate_oracle( + CELLAR_TURBO_SWETH, + &TURBOSWETH_ORACLE3.0.to_string(), + TURBOSWETH_ORACLE3.1 + ) + .is_ok()); + assert!(validate_oracle( + CELLAR_TURBO_SOMM, + &TURBOSOMM_ORACLE1.0.to_string(), + TURBOSOMM_ORACLE1.1 + ) + .is_ok()); + assert!(validate_oracle( + CELLAR_TURBO_SOMM, + &TURBOSOMM_ORACLE2.0.to_string(), + TURBOSOMM_ORACLE2.1 + ) + .is_ok()); + } + + #[test] + fn test_validate_cache_price_router() { + // valid + assert!(validate_cache_price_router( + CELLAR_TURBO_STETH, + true, + 400, + Some(PRICEROUTER2.clone()) + ) + .is_ok()); + assert!(validate_cache_price_router( + CELLAR_TURBO_STETH, + true, + 500, + Some(PRICEROUTER2.clone().to_uppercase()) + ) + .is_ok()); + + // invalid + assert!(validate_cache_price_router( + CELLAR_TURBO_STETH, + true, + 500, + Some("notreal".to_string()) + ) + .is_err()); + assert!(validate_cache_price_router( + CELLAR_TURBO_SWETH, + true, + 500, + Some(PRICEROUTER2.clone()) + ) + .is_err()); + assert!(validate_cache_price_router(CELLAR_RYETH, false, 500, None).is_err()); + assert!(validate_cache_price_router(CELLAR_RYBTC, true, 600, None).is_err()); + } } diff --git a/src/cellars/cellar_v2.rs b/src/cellars/cellar_v2.rs index d612ce77..4d8ebe78 100644 --- a/src/cellars/cellar_v2.rs +++ b/src/cellars/cellar_v2.rs @@ -2,35 +2,38 @@ //! //! To learn more see https://github.com/PeggyJV/cellar-contracts/blob/main/src/base/Cellar.sol use abscissa_core::tracing::{debug, info}; -use ethers::{abi::AbiEncode, contract::EthCall, types::Bytes}; -use GovernanceFunction::*; -use StrategyFunction::*; +use ethers::{ + abi::AbiEncode, + contract::EthCall, + types::{Bytes, U256}, +}; use crate::{ abi::cellar_v2::{AdaptorCall as AbiAdaptorCall, *}, cellars::adaptors, - error::Error, + error::{Error, ErrorKind}, proto::{ - adaptor_call::CallData::*, cellar_v2::Function as StrategyFunction, + adaptor_call::CallData::*, cellar_v2::Function, cellar_v2_governance::Function as GovernanceFunction, AdaptorCall, }, utils::{sp_call_error, sp_call_parse_address, string_to_u256}, }; use super::{ - check_blocked_adaptor, check_blocked_position, log_cellar_call, log_governance_cellar_call, + check_blocked_adaptor, log_cellar_call, log_governance_cellar_call, validate_new_adaptor, + validate_new_position, V2_0_PERMISSIONS, }; const CELLAR_NAME: &str = "CellarV2"; -pub fn get_encoded_call(function: StrategyFunction, cellar_id: String) -> Result, Error> { +pub fn get_encoded_call(function: Function, cellar_id: String) -> Result, Error> { get_call(function, cellar_id).map(|call| call.encode()) } -pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { +pub fn get_call(function: Function, cellar_id: String) -> Result { match function { - AddPosition(params) => { - check_blocked_position(¶ms.position_id)?; + Function::AddPosition(params) => { + validate_new_position(&cellar_id, params.position_id, &V2_0_PERMISSIONS)?; log_cellar_call(CELLAR_NAME, &AddPositionCall::function_name(), &cellar_id); let call = AddPositionCall { @@ -42,7 +45,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::CallOnAdaptor(params) => { for adaptor_call in params.data.clone() { check_blocked_adaptor(&adaptor_call.adaptor)?; } @@ -54,7 +57,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::RemovePosition(params) => { log_cellar_call( CELLAR_NAME, &RemovePositionCall::function_name(), @@ -67,7 +70,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::SetHoldingPosition(params) => { log_cellar_call( CELLAR_NAME, &SetHoldingPositionCall::function_name(), @@ -79,7 +82,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::SetStrategistPayoutAddress(params) => { log_cellar_call( CELLAR_NAME, &SetStrategistPayoutAddressCall::function_name(), @@ -91,7 +94,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::SwapPositions(params) => { log_cellar_call(CELLAR_NAME, &SwapPositionsCall::function_name(), &cellar_id); let call = SwapPositionsCall { index_1: params.index_1, @@ -101,7 +104,7 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + Function::SetShareLockPeriod(params) => { log_cellar_call( CELLAR_NAME, &SetShareLockPeriodCall::function_name(), @@ -113,6 +116,67 @@ pub fn get_call(function: StrategyFunction, cellar_id: String) -> Result { + validate_new_adaptor(&cellar_id, ¶ms.adaptor, &V2_0_PERMISSIONS)?; + log_cellar_call(CELLAR_NAME, &SetupAdaptorCall::function_name(), &cellar_id); + + let call = SetupAdaptorCall { + adaptor: sp_call_parse_address(params.adaptor)?, + }; + + Ok(CellarV2Calls::SetupAdaptor(call)) + } + Function::InitiateShutdown(_) => { + log_cellar_call( + CELLAR_NAME, + &InitiateShutdownCall::function_name(), + &cellar_id, + ); + let call = InitiateShutdownCall {}; + Ok(CellarV2Calls::InitiateShutdown(call)) + } + Function::LiftShutdown(_) => { + log_cellar_call(CELLAR_NAME, &LiftShutdownCall::function_name(), &cellar_id); + let call = LiftShutdownCall {}; + Ok(CellarV2Calls::LiftShutdown(call)) + } + Function::SetPlatformFee(params) => { + log_cellar_call( + CELLAR_NAME, + &SetPlatformFeeCall::function_name(), + &cellar_id, + ); + let call = SetPlatformFeeCall { + new_platform_fee: params.amount, + }; + Ok(CellarV2Calls::SetPlatformFee(call)) + } + Function::SetStrategistPlatformCut(params) => { + log_cellar_call( + CELLAR_NAME, + &SetStrategistPlatformCutCall::function_name(), + &cellar_id, + ); + let call = SetStrategistPlatformCutCall { cut: params.amount }; + Ok(CellarV2Calls::SetStrategistPlatformCut(call)) + } + Function::SetRebalanceDeviation(params) => { + log_cellar_call( + CELLAR_NAME, + &SetRebalanceDeviationCall::function_name(), + &cellar_id, + ); + let new_deviation = string_to_u256(params.new_deviation)?; + if new_deviation > U256::from(5000000000000000u64) { + return Err(ErrorKind::SPCallError + .context("deviation must be 0.5% or less".to_string()) + .into()); + } + + let call = SetRebalanceDeviationCall { new_deviation }; + + Ok(CellarV2Calls::SetRebalanceDeviation(call)) + } } } @@ -122,7 +186,7 @@ pub fn get_encoded_governance_call( proposal_id: u64, ) -> Result, Error> { match function { - InitiateShutdown(_) => { + GovernanceFunction::InitiateShutdown(_) => { log_governance_cellar_call( proposal_id, CELLAR_NAME, @@ -132,7 +196,7 @@ pub fn get_encoded_governance_call( let call = InitiateShutdownCall {}; Ok(CellarV2Calls::InitiateShutdown(call).encode()) } - LiftShutdown(_) => { + GovernanceFunction::LiftShutdown(_) => { log_governance_cellar_call( proposal_id, CELLAR_NAME, @@ -142,7 +206,7 @@ pub fn get_encoded_governance_call( let call = LiftShutdownCall {}; Ok(CellarV2Calls::LiftShutdown(call).encode()) } - SetPlatformFee(params) => { + GovernanceFunction::SetPlatformFee(params) => { log_governance_cellar_call( proposal_id, CELLAR_NAME, @@ -154,7 +218,7 @@ pub fn get_encoded_governance_call( }; Ok(CellarV2Calls::SetPlatformFee(call).encode()) } - SetStrategistPlatformCut(params) => { + GovernanceFunction::SetStrategistPlatformCut(params) => { log_governance_cellar_call( proposal_id, CELLAR_NAME, @@ -164,7 +228,7 @@ pub fn get_encoded_governance_call( let call = SetStrategistPlatformCutCall { cut: params.amount }; Ok(CellarV2Calls::SetStrategistPlatformCut(call).encode()) } - SetupAdaptor(params) => { + GovernanceFunction::SetupAdaptor(params) => { log_governance_cellar_call( proposal_id, CELLAR_NAME, @@ -186,7 +250,7 @@ pub fn get_encoded_governance_call( Ok(CellarV2Calls::SetupAdaptor(call).encode()) } - SetRebalanceDeviation(params) => { + GovernanceFunction::SetRebalanceDeviation(params) => { log_cellar_call( CELLAR_NAME, &SetRebalanceDeviationCall::function_name(), diff --git a/src/cellars/cellar_v2_2.rs b/src/cellars/cellar_v2_2.rs index 64f8fb42..54578f0c 100644 --- a/src/cellars/cellar_v2_2.rs +++ b/src/cellars/cellar_v2_2.rs @@ -23,6 +23,7 @@ use crate::{ use super::{ check_blocked_adaptor, check_blocked_position, log_cellar_call, log_governance_cellar_call, + validate_cache_price_router, validate_new_adaptor, validate_new_position, V2_2_PERMISSIONS, }; const CELLAR_NAME: &str = "CellarV2.2"; @@ -51,7 +52,7 @@ pub fn get_encoded_function(call: FunctionCall, cellar_id: String) -> Result { - check_blocked_position(¶ms.position_id)?; + check_blocked_position(¶ms.position_id, &V2_2_PERMISSIONS)?; log_cellar_call(CELLAR_NAME, &AddPositionCall::function_name(), &cellar_id); let call = AddPositionCall { @@ -146,6 +147,110 @@ pub fn get_encoded_function(call: FunctionCall, cellar_id: String) -> Result { + validate_cache_price_router( + &cellar_id, + params.check_total_assets, + params.allowable_range, + None, + )?; + log_cellar_call( + CELLAR_NAME, + &CachePriceRouterCall::function_name(), + &cellar_id, + ); + let call = CachePriceRouterCall { + check_total_assets: params.check_total_assets, + allowable_range: params.allowable_range as u16, + }; + + Ok(CellarV2_2Calls::CachePriceRouter(call).encode()) + } + Function::AddAdaptorToCatalogue(params) => { + validate_new_adaptor(&cellar_id, ¶ms.adaptor, &V2_2_PERMISSIONS)?; + log_cellar_call( + CELLAR_NAME, + &AddAdaptorToCatalogueCall::function_name(), + &cellar_id, + ); + let call = AddAdaptorToCatalogueCall { + adaptor: sp_call_parse_address(params.adaptor)?, + }; + + Ok(CellarV2_2Calls::AddAdaptorToCatalogue(call).encode()) + } + Function::AddPositionToCatalogue(params) => { + validate_new_position(&cellar_id, params.position_id, &V2_2_PERMISSIONS)?; + log_cellar_call( + CELLAR_NAME, + &AddPositionToCatalogueCall::function_name(), + &cellar_id, + ); + let call = AddPositionToCatalogueCall { + position_id: params.position_id, + }; + + Ok(CellarV2_2Calls::AddPositionToCatalogue(call).encode()) + } + Function::SetRebalanceDeviation(params) => { + log_cellar_call( + CELLAR_NAME, + &SetRebalanceDeviationCall::function_name(), + &cellar_id, + ); + + let new_deviation = string_to_u256(params.new_deviation)?; + if new_deviation > U256::from(5000000000000000u64) { + return Err(ErrorKind::SPCallError + .context("deviation must be 0.5% or less".to_string()) + .into()); + } + + let call = SetRebalanceDeviationCall { new_deviation }; + + Ok(CellarV2_2Calls::SetRebalanceDeviation(call).encode()) + } + Function::InitiateShutdown(_) => { + log_cellar_call( + CELLAR_NAME, + &InitiateShutdownCall::function_name(), + &cellar_id, + ); + let call = InitiateShutdownCall {}; + + Ok(CellarV2_2Calls::InitiateShutdown(call).encode()) + } + Function::SetStrategistPlatformCut(params) => { + log_cellar_call( + CELLAR_NAME, + &SetStrategistPlatformCutCall::function_name(), + &cellar_id, + ); + + let call = SetStrategistPlatformCutCall { + cut: params.new_cut, + }; + + Ok(CellarV2_2Calls::SetStrategistPlatformCut(call).encode()) + } + Function::LiftShutdown(_) => { + log_cellar_call(CELLAR_NAME, &LiftShutdownCall::function_name(), &cellar_id); + let call = LiftShutdownCall {}; + + Ok(CellarV2_2Calls::LiftShutdown(call).encode()) + } + Function::SetShareLockPeriod(params) => { + log_cellar_call( + CELLAR_NAME, + &SetShareLockPeriodCall::function_name(), + &cellar_id, + ); + let call = SetShareLockPeriodCall { + new_lock: string_to_u256(params.new_lock)?, + }; + + Ok(CellarV2_2Calls::SetShareLockPeriod(call).encode()) + } } } @@ -185,7 +290,7 @@ pub fn get_encoded_governance_call( cellar_id, ); - if let Err(err) = check_blocked_position(¶ms.position_id) { + if let Err(err) = check_blocked_position(¶ms.position_id, &V2_2_PERMISSIONS) { info!( "did not process governance call due to blocked position id {}", params.position_id diff --git a/src/cellars/cellar_v2_5.rs b/src/cellars/cellar_v2_5.rs index 89ece371..d7a48368 100644 --- a/src/cellars/cellar_v2_5.rs +++ b/src/cellars/cellar_v2_5.rs @@ -34,6 +34,8 @@ use crate::{ use super::{ check_blocked_adaptor, check_blocked_position, log_cellar_call, log_governance_cellar_call, + validate_cache_price_router, validate_new_adaptor, validate_new_position, validate_oracle, + V2_5_PERMISSIONS, }; const CELLAR_NAME: &str = "CellarV2.5"; @@ -222,6 +224,111 @@ pub fn get_encoded_function(call: FunctionCall, cellar_id: String) -> Result { + validate_oracle(&cellar_id, ¶ms.registry_id, ¶ms.share_price_oracle)?; + log_cellar_call( + CELLAR_NAME, + &SetSharePriceOracleCall::function_name(), + &cellar_id, + ); + let call = SetSharePriceOracleCall { + registry_id: string_to_u256(params.registry_id)?, + share_price_oracle: sp_call_parse_address(params.share_price_oracle)?, + }; + + Ok(CellarV2_5Calls::SetSharePriceOracle(call).encode()) + } + Function::CachePriceRouter(params) => { + validate_cache_price_router( + &cellar_id, + params.check_total_assets, + params.allowable_range, + Some(params.expected_price_router.clone()), + )?; + log_cellar_call( + CELLAR_NAME, + &CachePriceRouterCall::function_name(), + &cellar_id, + ); + let call = CachePriceRouterCall { + check_total_assets: params.check_total_assets, + allowable_range: params.allowable_range as u16, + expected_price_router: sp_call_parse_address(params.expected_price_router)?, + }; + + Ok(CellarV2_5Calls::CachePriceRouter(call).encode()) + } + Function::AddAdaptorToCatalogue(params) => { + validate_new_adaptor(&cellar_id, ¶ms.adaptor, &V2_5_PERMISSIONS)?; + log_cellar_call( + CELLAR_NAME, + &AddAdaptorToCatalogueCall::function_name(), + &cellar_id, + ); + + let call = AddAdaptorToCatalogueCall { + adaptor: sp_call_parse_address(params.adaptor)?, + }; + + Ok(CellarV2_5Calls::AddAdaptorToCatalogue(call).encode()) + } + Function::AddPositionToCatalogue(params) => { + validate_new_position(&cellar_id, params.position_id, &V2_5_PERMISSIONS)?; + log_cellar_call( + CELLAR_NAME, + &AddPositionToCatalogueCall::function_name(), + &cellar_id, + ); + + let call = AddPositionToCatalogueCall { + position_id: params.position_id, + }; + + Ok(CellarV2_5Calls::AddPositionToCatalogue(call).encode()) + } + Function::SetRebalanceDeviation(params) => { + log_cellar_call( + CELLAR_NAME, + &SetRebalanceDeviationCall::function_name(), + &cellar_id, + ); + + let new_deviation = string_to_u256(params.new_deviation)?; + if new_deviation > U256::from(5000000000000000u64) { + return Err(ErrorKind::SPCallError + .context("deviation must be 0.5% or less".to_string()) + .into()); + } + + let call = SetRebalanceDeviationCall { new_deviation }; + + Ok(CellarV2_5Calls::SetRebalanceDeviation(call).encode()) + } + Function::SetStrategistPlatformCut(params) => { + log_cellar_call( + CELLAR_NAME, + &SetStrategistPlatformCutCall::function_name(), + &cellar_id, + ); + + let call = SetStrategistPlatformCutCall { + cut: params.new_cut, + }; + + Ok(CellarV2_5Calls::SetStrategistPlatformCut(call).encode()) + } + Function::IncreaseShareSupplyCap(params) => { + log_cellar_call( + CELLAR_NAME, + &IncreaseShareSupplyCapCall::function_name(), + &cellar_id, + ); + let call = IncreaseShareSupplyCapCall { + new_share_supply_cap: string_to_u256(params.new_cap)?, + }; + + Ok(CellarV2_5Calls::IncreaseShareSupplyCap(call).encode()) + } } } @@ -379,7 +486,7 @@ pub fn get_encoded_governance_call( cellar_id, ); - if let Err(err) = check_blocked_position(¶ms.position_id) { + if let Err(err) = check_blocked_position(¶ms.position_id, &V2_5_PERMISSIONS) { info!( "did not process governance call due to blocked position id {}", params.position_id @@ -455,7 +562,8 @@ pub fn get_encoded_governance_call( Ok(CellarV2_5Calls::ToggleIgnorePause(call).encode()) } GovernanceFunction::SetSharePriceOracle(params) => { - log_cellar_call( + log_governance_cellar_call( + proposal_id, CELLAR_NAME, &SetSharePriceOracleCall::function_name(), cellar_id, @@ -468,7 +576,8 @@ pub fn get_encoded_governance_call( Ok(CellarV2_5Calls::SetSharePriceOracle(call).encode()) } GovernanceFunction::IncreaseShareSupplyCap(params) => { - log_cellar_call( + log_governance_cellar_call( + proposal_id, CELLAR_NAME, &IncreaseShareSupplyCapCall::function_name(), cellar_id, @@ -480,7 +589,8 @@ pub fn get_encoded_governance_call( Ok(CellarV2_5Calls::IncreaseShareSupplyCap(call).encode()) } GovernanceFunction::SetAutomationActions(params) => { - log_cellar_call( + log_governance_cellar_call( + proposal_id, CELLAR_NAME, &SetAutomationActionsCall::function_name(), cellar_id, @@ -495,7 +605,8 @@ pub fn get_encoded_governance_call( Ok(CellarV2_5Calls::SetAutomationActions(call).encode()) } GovernanceFunction::CachePriceRouter(params) => { - log_cellar_call( + log_governance_cellar_call( + proposal_id, CELLAR_NAME, &CachePriceRouterCall::function_name(), cellar_id, diff --git a/src/gen/proto/descriptor.bin b/src/gen/proto/descriptor.bin index afb21e4b3543d01377db5f24733a12d02ce58a31..f25826bbfd5593e522b38e5eceee8dbb499b22ed 100644 GIT binary patch delta 18416 zcmdUXdw5pGwKse1*?SK!FC@H#Bm@HCCUQ*(;gS$S0wN+Rh$w37!2nUQ2ozB2>1jhi zun0tM%|widRzU#)uR)Hrh)9LXMWmu42q5Su?ZNtl#W6um9L&-be8{4>&K;U4`z}*WLP`6;cN`{#Z&(4y~9nrF_Os`RaHv zr3Frob9s~e4(j=0YN=8OQNBa!xhp73-8P7dRAP?PLjAs&8mkuv(bcMIILOoz8XI^G z#paaI0LNF&Z-m%;CDb*M7#53{PntA-`m~voXHA|qH8W6KT2rQavzXduUKMLPvtri0 z)5n)jDxW@U+Kf!8b+tD`Xgrj%ow4eNv6SU>HmqJZQfHQ$GWm{K<7eJ=@2pAFW>3wG zHI$lrBW1T76-$NU@zbZ2&$?sUjC;o4QBjfE#7ySr2b~ViRCVbZYU{++mYXop%o0jb zzy8XJsoSolY<1~RPHU&Ba;8!X^?ET$=LS_Zl+x6H45h4kHJGX$^+O3gs>a+(oz%9W zbg(|ZjBa)5Lb|HHf*z&y@%rw=DB)7#PE|CLS_h5w_D@y#ET2n%q7>`Dk6t9;{{@qJ#VD`P6|6FTe0IZ#>Em7%O~DdF@E}t$rCHa z&zN@atcn?#sbT*Cqo{NJv2oPfsh>K6o^tAM8wCX_?|NEO-(n=~_UY5M>e%&g!miZ% zUyh-PUeXCI?3A7u^WQlkjh&FK&X0s@P-u^{33jSk8BT|cKXa(1gv-gmB7x6GmxXS6Ck>aEsN_*>q)Z4>HBcv3igxZk=akJjfLHDTw{(Xd(0*Dm$+@za~?i zdx&~f=C5~h#tyr7^r$gqV{VD%jJ>O3WN*vuX| z6YiarGkfxsDLE6+Ys!>qvnwX$OrDxko-<|gJ(FjFz{V+`IC<9nIS4*EH;kT{GyAT| zQz~LPv+k1!W2GC)^S8@~q2L)pqJ)EjNbrh@|DlkRFk=+!)d$I(LZ`Yw1|R9VvUNX>U5MRs4dJ zIw-$yzpl53euzQO$mG6`LC?sHE_M_#=o#6qN9;e@&p}+V;g(OA~0hc5qp2sMZosxT93_qtr^>zS9wE{{d=SWOT%#W0cIc zQgP@Q)wXX)LC2^8MX{s;tO#5i$_msPXkjm@o8*LtetlkHF9qdYF&D%LdSi$<$B|t4>1PE-KWvU(z#a8~|>Q zXT|zyOAZH_3F`afPJTc9jZ-y2HnVC#qwj>2w1|e<2^pEO8?7vwC#mKuX=Je(s6!4k zOp@`W1Y4WbG%KQ^VN!P6*bH_lGNqUzrl|w3(p_2Fl`e;xDe<Ew~ABpZJBErfBLd#sbHq`{I{bPrGbkHll}_07$5x zom3AR-Djt?jM|}oc4n*CueExS@G8Xu)wYuUJ&mJPC6=(K9=d>HQKdFkQrANK?SXKh zHbpNe7+8`jCnY^%V5C(}tE^ZrD~=BHRI@qM4dU>snAcDoZUv)(xC8NdEN+%Y5L`Q7 z{d^8xUxdFQKHtHrgx29@Ft9912E^w(@YFa=&;IBYhI>4S_8Xr zRYMKz##IhBPpE<2xQhKyW;MW#b&lG8KlK|N_F-?4@K{$Im%^;4K7e@uU-PgCop` zNGANXj##Hk=Tk0P5st-LC!UET#I21J{(46|r_TP}>7M}-t?L~e{|?UI)aJiAe#!v{m%;(u%9anR^0`!$f6ze= zZi<_r4%FhHgCuN8*gEJS3m0e+s6XV$E+!3kN1Vr%kU43#JKI0xAPF03J_Lsx$n)<1z!_Ys^R7c8AwI(B|MeQvxhHtx_~A};Nsb>EMUWW(71};l=3`a)09~2) zv4bRSY;aKf*g=-IBt$-T1{CT8=O9b_#~pEk4_sm5czDztjMM+j5vTa5^-X*h9x?}c z%>U96f8|3~sJ721(frHsjG>X2>@=UTw#7PqiPPam(Ty0%>2Swu2F7waJYf!;;h%BD z`TzEWr8Pejo-K4_JLmXpbyb@dkl*)QWJc#PaV|0g2F#pG9xTTd3ICst_?{0|W#XUV zkpiF9e%IhgX%?LNU8LURv+u$qrF%gAcgZ8=Am;h=NX#d5q$|{SC*E}DZb z%c)s?R<6TMdu3;rJumF@vx9G0Ny^=CJh4Ol>R}yNc(N-S%YDkS=MAr|fA>3Iw zRI((GzJ{{8MhuLuyN}91Lm+ zq38yy0Q4$S(-+g&0jmi2u+TIIfmPJyiin|m4!&n6mP%mYUC2pYGWa2&iZS5vz_5d#`lQ@{QQ z+Orvy zMsW#H6tlcd5@IvOi`0o#PKGM20)#mDF=}x|IB}Gm+#YQ?zQk;%b_Gd|C_KUFUl_Z_ zYK$ku^Ax`_t5{V%O@oqSL*dE%=%DjG<$3B{n$#4BrsrwsFnuLvw=_+N7b#w#%XzhB z3+~pM3q@d?+lppD(TkMbE2*d{6un5j`{=rndo)XkmvIWVQ0`z&Lc_}(#ll%OgNB!> zRdm3cLBq?`wR>z{xR+BBqMqV?Rq0;3FFB_aC;~ScN(vO!Q+94ra|#sIQ+|P|CiwR3 zZzr*vOf>--0^2zray0>xqvZ|^HCat)9^$}`FuQ05q;`<4CNu+Pc95+mn1K#ENmmnU z%~FyDI~$6#(Vb*V3EdmwJIR(3%s}MaMY@zIH9i6hgV;s3l+b;kWf$2}LNlOc7uiyR z8KB=LHUAYr@pa2c7QRikuG5VWf17Mwry06C2CcoyAiC&#_L0c%=3a9oS~hd9Il{|k z(uSVfQI)!qZti!&ou+OKPMCzj~Ly!4V@uzj?}UpwCty-2qAEW^O!NAFGFWZ zwzDQojSWU4DO z_uELXDXPDX^qQjjTh{yUS}$tRDp$;N8B+PhO;v8vEdg(uxh|?0vjafGEntLW1_QI4 z>)K+HTre=^xh{&kO064}>_e_t=Bjp;G*fM?Yj~2J|m>EvUjG=uqvdlsVKzYhXa2x}gT%6x9ti@TRC{4JLIoXcj(Wh@BW~Ls5d+2^adY!x%Iq(cy>x?Qmps_(YRmb+x3T$OgX6s$# zT{Ashk#BI5TiKN3V1y=2IljS7hE7wCZ(!Fk8bvOu@fTh3va2r6q4AgmC%G403rKx1+5iI*ue-K7(LG?}br;piBI76|%w1~DQ}kdfaydEfa*^Z~nzodLzt;XDQtbe`tWJ$UWi6*dw*mb4D{b0EfN^8y`LB94(-9zggC4Q zt)&Stor=DPT_ox~#&q+9f6PTqoANBZi74D0&Bu6TjDUe;)5l$v{UH@00E2{Yk4GCH z3L|6>SCKKE z;8(6iE6@{yU%5alM(E*!`iIMJVWq`fQMw5B%t0i!B&7f0;!Vtwx<4MpuGZ2BHve>G znYmgHQ3oC)FAofZ&A1Fzq1|FLAR+uu7uXDgQ7*5OBA?41+eP6iCQ^=UP+> zBxJvHEh^=58TEskM5W+iE~LOQ)i+2;|KQr{8ziKEa8Z3v)|OF1{phN_tLg5%A0vxg zK>g^p>TajX<7DletdVD2!$ujlc*^m}9w4*eI-fz{ENc zMqw8)m)I=S6Hn3Nw9O(6z%Ij6uL$v~P-RckgNav!jlF2#X>Aqiqo*l9e`{pQ+`zU* zOJZ(dTX{)1=(>Cew`0ewr90EM3&h*s>5b�`*5B{v_0>gY;;ntI_;F@<=#ef@FJd z^S0z`l&0ZEFv2;SYt-AqRw}v&=J>Y2l{ZuYx9yJBI?yo}j7SCVj@?-6JCjy8=SWU}lQz+(97@Vc*YEd*7ow)S73g)wqKq zo^6fj8{K<+j?7%ml@5&1h`G|eCz`g1dceqgB0a;TFPGmpjtFs5sMKfa?ZgpwBxf!( zup^HOowAJJf|Y~gER5l_v4g0BVA+;vs~ z=x+ogj-v{`;dsfLojY=L`$kx#Q8RQ;i!?F=!RlMVNaGC!-wKN`YCa^t6&5Si3`l+} zEW*eP?6>a)BaGK+$8lo*zTvbvHGeNG(x?TX;d=q3kwGkGK;oiM&KA0+;9|p3b6UPA zELf#GLh_>MKR`oF%s^_sBvjQF8dz|N&to`WPR^Hv#gueMNL~`X^EIZ#3?%3(k1?hG z1FAfWC22k+t2~P(X$B;#JYY$TDl-G=d7c-)I&0_(14|3FbTRcP)lHZQ+6&MBQ#{dJpcsG_u|+5E7IIWZy<&P(Pj{5-51*Cdlqrl3}~D0jTot6MP>jF ze9(&zG1rd0Z&Ew8?geUA1fBsWbsuPX(6ivAW9>B>}jFvG67~n!Lenr+oNB#Uw zryD7z;NkMbw-;t0?L6m2aIt0~sz2vhxL7lw zc|B3O9T9UZwev-0a!Qn`Y>qu&Wr^(;oL88Eulvly{v!01*l#E5Ze1CsBFw>*`# zl{O}}dln2v16$kSCBb07$lU#RL_Rfl{~gh4fC2S8cr_RbW+kw{)8h};Mh(&={JAso z3fgstq*uUzhMl}B45|u#BY(#e`#lC#XC&V7ES!o49^XEXzf>Eb7H=cjcV9FzbJ^M# zt+u&t?PI+RstT??-uJ`@9)qegehM1nc%M@iU&cYQ_QRfqRyB>0gJCZ8ngNN!o`qI5 z10z4|S!h+D81X;x#OGcTS{16S=IQZD#RL8;Y}QKW!+^uKkq78Chk0*zl)3Mpm!G;(){yPeqFZ z1~ic2d3*3=Iu*?0Z@B@!nF#pDWMA2g*~XsLd)xHHG(5(FfM(7^{ z)K>e+EntA!Y9DK;pEU#{wKcw|_4!$2#jSi3sqyWj1{!&m%C``Nrm@6ega!;wtNdhC z1Ot;&K9=}b+K+%~ANR!*zWVi>H2WufO?lk65Qkt)7SHU_1Pn$CMyTIlv}>XXfC2q$ zcmjXpl2y3P688SmhYzRb%i$r-EW)ZktC-M1*W2z;nQLpV?{bkCITHjRP-RU3UE zStIOFa9TF`s%RHoQQS(wQU!zN#|?H zD?V-oW}+Hz-fAW~*uc$OBkcxm-WpBRz|C8EqWbwkxT%QazSx1i*YNoPeAwCUTigpI zJM@ic#X!RmV1$kU0}^jUD+UH8@&>P%etr-x;OpJK_>-@3FYIc*&+Lvig~qSvAO5R<4{^6tK%jvXd0$v{EDg@y|F^jz>$!s{}6K*0qc_YD2!A>8zY z|Gh8f1`HbQzzEYJ@V#%LBal48i>l3sG!WG@C>XftCvQ(+p#MeRB1gIh3|#ara>NXD zxa2c(G(l_NAzq4xh<4qQ8ZP-3L1G3DcvWB?Jv0doRY7tU&<+h%LGp-$0S#4w zee}SM;x|E~2c`Pxk9hR>O<*5AJceE#3dG}q8uT_EJst||qldm?EDjnzdUWrjvksW% z&BGv`iv#=SVernyfqnDvcs$jCa(3g*qdKr}9^h)Wee(c`K~@L$&BNnKE)C3^$4k2@ zHGgSjjP)%I?3)LALU3t-HxGWb@R(X2gs&E51z;dSf@7X7Ktg(XV4p2O>i&4P;Ku`x zag~(;KORg{`}dHazcR2`KAIr7GO$=aNC>VB5O)i;AQqt}koj5N0W+lY6GB4e{)w99 zgK6FoJpJfV6WDhIkWf$);2q(9tpKB}4P^fY#njDtV3^MZJ^kiU8??#Sj}RasTpRT5 z7rR*t16WxV$U$N0G&moWd0X;`Z#%1kq@VfaV-@?EFRmT~D|LY!kadSC`5!w3M2YwV zEO6UcV|<^f3$pu!BsA0o0HgE+h{p)a>VO|W=Js73xr;A4t0Q+YlCnAopFTWB1J?%P znc!a&0r(JG8`wkuk`LTEb^{lKnue#rFhNH%Ah9m6cMr{gsdYh^2t2OgHV5MQfD^$Z z<2DEOUVsKxz9q2t4oyQj7@>0W^syzd_YU0y%C`hz3h=lZdNmOL8E^{d>Wq6e8oI87 zwgoo$qo*w+STU}g42?gb4MU_>f72JB0^_f{5xj(zOka2N;#`y1-u+dmlQ zA%KmrmHmM&%`^il_OpuFyuksglQm2NHiE=s+f5UNza`3Eir=z{9iqE3 zv#-a$2e}Z4e+FvX`}9iULSPdw8hFZI>nV3EGH)$kN1DxB%h%Dw!GPwkdE%URSswHI zCQzRore6KNX(-7P|0b{rS9gTuH$j+iJ$|LR6o>`*$u1IZCTIv;;%!)_HS4#UD#>p( zLkg;7a@oxrO_j8n7IJz_Rnlf!W)Qu@UCUq`%Bt%{*x{t?q%b&676MG6Q>W zzT`|>&}V)_Nme~y+6=2ZLUO)DhP@kaG}u{-C4R`OYCod8QWs0vB6bMe6mFNaTTMk{-63?$X|TlVEn=a*6!RKh;6Gj7%o+JB-rqG)T)AFvbs7 zM>{5-?@HOp{0zgC*DED*CVyps-y|WANja21YQ^t-Kc-H-Kz6dCoNjAm=aP`roy&&k zcXyxDZLQ>=P7cefjYi9vwpJ!b%bB*8N6Wt&@%j9(;?d$qo1N6Jmg9H%pY)(6McOm^ zI|H2Whyv|mDbMI<-Sy@Ozezm+}7&bTCNA6uCRqhTz_S1PDjX$9_ zd26J-RiPcyYh>G8E6pE0uaWqDwQ)Pr?vrd?yM51Zoh&;A{saLH;Sl&hJt;3MwMsY- zKPds?4%S1!d&W~z_Erz~q5><=?-<~ji-%8)NIWImm=7mFLjEa!oUcf(GZUm-dnZE@alr>>hTW{8jRLncLegHC`n)N?FKD-AT2obz0iNHp5`i z(9TM6UB6N0n46AI{9*D&*>3<~LS8SR`h| zyc5)%q9&^L5hre!i*bAOxZIlOD)$B175@=~BLy*L|AHKOtz9l4_Af~}miJ7q`gJ~j z@VwzuisgeBu5SYJFUcO)S$PKOUy|3~fLBxY03iBTq@0K!^p~>7&(GhB1k$rBnY8an?MczKa4g=u)Rw-}fVU*Zuq+uH1g~Q<5bF1tz%F3rf zeybca*2=fUEy+$JPc3=WX{NGHQ7jLI_#pMmf9tbDP$4gt3y1H%U^6wiS8>ydZ{#9wD| z6R$IYbx2vv@w$`xx4!s45;|zl`J6;P8p5ER2_@U3FqjD?+a=yh_+K*k)Cvf;lvia9 zQcv`x4(e>3)5gT^Ru~Fe_;<{_16o1L4%uZ$NJ7gFIc&J~WEL)rQvQTjqO}_F1@+7W z*~|9Lg6K|}dt*pKbf>)eR=YD><3mL$Z{VHTTD|cFb;|=8`oA?qcgY^tTG7@J-6cnl zv7&A8Rf?2@SahI0h;1-x@Y-8}HjsZ?cIY3Hkbhei6~{{T+_UjHiB#2JQd!=fC{krZ zW{+%Re(LB`He~k5p1Ia$+k|+>+U%@uUG1c+qQ7A4gBRLt3;A~&j z+)Je#omHlszfec@@M-+VkfW=UfutSAkM_`bJLuXcyI*a`-wwL=$!kYhujk;Sda2I+ zg|5y&5T(i-$Q+1LWe#KxNW9LP^=^+JZkqKD?RU-rBV6Y85Iz_!b9)FMl=X*B)7@$R E3u0TXJOBUy delta 13660 zcmZ8od3;qxmZnbCEiR7-2@euNLP*#}APFIa5JFf4K|sW%!BH7SW!lzu`KhgKFS4}F zV5D&&QV6o?k48iUL^~=Xo2>#ODk8E70RfR_1Y{hgZFRm=RrlT4|K*&j^PQ?wRcCuQ zf7+LP^T(!B9uhCpE&b%VBUE==Kk6Wp&ooJd7ft&0uP5F;uGCC;S9CY^)s!zrn>E)^ zj#*npBMfa7xh87>^*7`BuMY-LVD211!$n|z+$!2I<5HnbyK1^pG&YwHpmyf5YU*4! zb_{hEb#n)k5_N?`>6eloZ)P4IPV;G@HdkK*y#1r7S=}8YXdBfH9YedR?(`M3P1EWu zv+h4I?R26J({2iQu$M&&gxNQquBbb3Gv!fTi(gS?R@1p(i$vp8pc{Rm>&87ugGoGU z4t*jnH(ySn3^C9g-T_U&-y;&4C5cqx@`O^2s8LFmhMi}hU7Ta4JV%*k{T|V+s5ESu zNG1Xv78q|;7*P^b$4-e$ttf`d!V7Z;&2Ha1+Z4^9l425?d0BqC;2GJSBMQQ07j#Pu zvBH#++v4%;^ts3nuRux+H*TReGlZM60qpdC>r(Rb4MgjIg4ZSRM8;hv$jb=CKc{YhR~Z zTYj{B4S?#r5)YsOP~E#Mu~#sHY?M+LtIN#o`)Fsb6_$J~7bjaMdM7lG^C^xn%@2w` zB_qP-iROvMj*D3%GFrtnU`MphN%Zql7#?Xh?Wf|ZNJ3zrBO4&_369LjO(O^(jLdJB z7~~Ofila@*0V+=;5D-R(&C(KlrlXq|#xxK{;|h)S2q4Fp?;oR!2SjU-Ko}Dy(-M5L zW17WlkSu~VEOo{aDK$=AZQlHET5>ZlcU-bfqL~F3Y?kq17moxI7h!yu8Phm|@h#fM zG{nc}w~uLP8sDjN;svLPQtEnjv*~}3p7F=Po4Y=ln<%&Xi1kf0lOLwia{P^LOiY^+ zH0DlB9|mZEPsCyT!pma#CiBI^bU9@C7;Z|N05lJ#O#m9QH^BsV+v_1y>Na(UIeUn1 z@#|uf-Ii>ZsJ7UW*LAx&Q$v-e_z3Rq?dfG<2vcuQpD<`Z-wx>CT4Gx%1#p6J~FQ-l7L5m)wf(O-~g(+S` z_vE>Y%@658oM2D8@&Nd1iZE}kp)OU8B*=hiD9Er^91I-)6p@h~GhmG=qD^k1$Rl9F zG+_!~qOKMJrUl&q0k#FB0RoH*1`yoI1cY;cNSNg3G-d#=0XG~pPA6IeZUGoLo-_jp z4+$9Ymv);vrDqB?OPGUO==$775^r726gZydc8Qud`4huLPnf&jpwZd9=vo28_lE`%HcII^LOpAKe@awl&Jl3#70hSgxx%deGZmY$ zPf^gD8foT)IXJ(7#{n}}w7D=Mp>VF~S(GTV(iog4O#KEbE*I?CL4~dSR9?V5k<}q0 zAvsTU?vfZ_C1J6rMcBjKxkcoek|z*W7EPzdX3E%5gE zR$2yDv|8Ztaaa=YqWWc_>R^tNa%bE^^XUJIL>61~Ws&S;-yr6(g1?zH^QgGb-(m&U zbEv^0OzVX7V%`9s|5tmgpFze~v4 zySXuXmzII`Z{&Bmf-HQH(p!bvF6!pJMIFUtA^8NhiX{7Qwv2Ti+eFyjTflh_Fr4?W z6CkloWVDTEK*u&w!1)d-nEib`ITDGc2`mV6-xpyD=t>bkxt&6NECPGp6t?2Gv{NKn zCVKHWZ}CH6)-9mYq7S1>W`h9O{*u`k01}sspE2BeO6?LRZy{Cn+9kpk4w;=l*r~jT z#1eOjb_Mo@5MQi4LY)+x+zlK68ngGXtutW+ki5`OMfjy?VmE0ynDVJ;o}IYLP2sif z6UlBrO9Bhbs6~{l0N*(z2-+jrCvrMPNY+E`6UcNpn)3`G9}vkRpA-K0K2i(I#!~~o zOA5sQt~IHgVq^FJRTVp$T9CmNc+F%V9O+zZl+ zXbglCqI-|Tetx>dZt1L0|1_Is(Z}ZCbMV<``685Ad>dEJ3C=gWnS$l8&AI4NLDJrm za{`%;+cFpcKPQmtRC;k}|3+})*&DY*aJB>5KTFH76Ofcd2pp2X;ea~WBj9#?D>(72 z?9T!mlD`$mIwJwTCEp69ooNOTz7@zjFZT$b&zpZfMx)HE=P4{d9|d%V;|p>=3h0)> zvswQ#XC8Qlsigiyrsy+TG?^r;n@YIf?0G=)i<(BrJe_*bxKUta#tarD<<83=Y5k3@4aPGp&5OUo-~tRz#-KTUP@oP z2J5zG5@(}5_>goZI55*pN*mg_@R^i8D(Avy5{}Bf1iP_W#A)d$v-%JzTqp1VGmCrz zWEoidEbPsp=ZO>TGE=ykl6`Qq zB6JL5_VY2i%kQ3N^xs+Z#wq<0sh5ef?ca`jDYjB$zD{ci*`B)_pm73VMA%>edoB53 zPZA8Qd@UgsPqx@$O0OfenK;${V`?2=RnD+UhK#+QIKwU~TOUJ$56Jbg;lTjpdNzEK zm&Ak(#F=$**@lLa?A$jrl;r2TfhC=P3OS?RL@uM|CGhjz6kjMXfUqgPP+$OI6PxPy zb~{ZF`bljk(|j#GFlj3#xx(P>G~w-Rqp+7Z6==LXFrt?S243DaYLOq$fU<4Wu1Cy( zvTamcV)Jf1yAP?+yOQ(nu`NHOu&oW&lH=+wQYXm#;gsl|0~#>92&wmIEYZHc-4yoc zhDDC4KSez&z=LWqUB>8M-)?GGZUeh}d%LM$rEOZ+m$!$)0l9-s`$wt0nXrYr^s!ku zxb3_MTY3)_R74~ezK8l(*_;(#D5dsNI%nNO9n9D_DNzDmv;wyCUh+9B1R%eckh5N5 zw*YECHSAneaMd7j@9jXY*UH{Nn9*+8SCx+N|$1`P3IAKZ7%oU$r!h3WoC-mH`E4qDN{O zP;rJI>3pXGDZqE6{s|SE>8WwwQL=-5V-oQZ;O8SpYH5Ij5rMlD;C$rj>s0?CEV zBU1fEa$V3(T=j@do5jA$nbKDTnCT*7jPBm#OzA5EI|Jx5B`ShPoLO+6Yo!@`l&0rP z$@jQcqL_Qw4I&oJmujI5avzv2@>`lSr|GsFX(Q2miHfQhoD@jjcR&YkxgCrSSfuTU?re;r9>VOL13dVN*_CU0_Ol=#1QO?UX(s|%85J$ z7%xhkd4vIfw5lNnKXfo$BZWcP9j%f+kFX3ttYV0V+#V6e>ZE!N_Py7I`lUi%$q%m8 zwUVD%olNF?bvCfQD&aHSu0cZ`7?C;`;a-)^TE;V=?p2xHIQm~LwawHfx*Yb&9a%xH0(qGZhM(aPr#?rP+*c%M4eh*~yT8TcS+k zsusD}HrZ%S;Hp}_!P}&-Y83~y?NWUpT~!Mj!`r1VYHhZ*Lxx>*J0kzQ>+VVSOuFOV zdkQBO-ecZhKyA#R9i)pe?p&@*-F8UtazSDhJESjmZ8^PDa+Za?=F4=T41_sL{2cc>}`MJwSr2Chr`Sd10zlfLq`4B+gOhY(&Bv}FM5p!78;GjONtCD)+i z%Ih1NgM)Xy^tGp*2+4Yh+H;iO26P>f$$sfyOnR4tjCaA2{D>?lOK*!~`4QQ-!q%6J zh-iLPCVQJDXGG8R$#PT&*F_dP3pht*eo-2SBl}U=tJJphc?M$pahdGlT61Q~N0eU% z+IbW^4us>fO>C7A2*+i&?zR`fGZ5TQNb})GbXCQPhUQ~ea-yO6IKZEf!!NOg7fU8m z>ZDAL_ALn8CbMkp0({qrunZubl)e*T89+KIFBz4%*qgIyN}ZC)AudDtVHXwk0oftF z>!tuWB|BEd3;>*x0|zJO36GFWsjuMYKBoC)U&&<0^vongzmlD*V+KUOl7lZwT<0a5 zA*Vn@+D#M6&u{>YZelY?o{^mg#SBQEkrxef4G6^zi1SiSQ~aaX-qd-1k=%U106*aG zrENa=w*nR}+xL+Rv~z&}eH73v1Nh%_K;s?+Gce%?$vuevWj{2OWY_aU6vymDNdCYv zh`l~D@LGS8+O_LKBI2g`@#Ptx}sECZ51N#Ao|2I#4Zf9x7*&Ky9~VXE@c$PPk$ zs`A0lGVF9HwoM0QiYfiDQjaKZIxM~AVddKm7+{msDBo_dG~O{7uIRB0T$>u@+YOch zZ8gfb8!Q9bYE;y2KzK{(CzLXZf9`rA^@Q?`1q`sZT4fsx{s3GaRjYhDVCMk8R{4y= zGJs#Jd}o0fm@r4BI}6D^b7Es)(2k~!0S3h9C>Vn)am5XVg-R_^T#4VETBv*tjsafX zVwJAJm04Mj8fJ04HW!x`E1#-Z5r8jda4y6Zet*=@DfPVKLj3OQKw~k_Dc`gJ$tspB zUyfTE*AEPr3|R&wmMdS5TLv^NSH2uqaLjs*Qm-m5$M45)a`5$Q_&m8L$0#dUtL(2{ z=7S@oDr~(UD{#GpwaO=oRsssvDqoy411oq%*`K`_A}o8Qp*WlOm4@PM-d9+hD|8me zC9hLlp^q!8iw_2TNY=%-6bwk#vF$jsR}xw128EvgXItoo2_P|j1D_7(fFOBi8aO{UI*Y40?c1t+ijPs&uub_C-_p|%obp~}7QaRl+kn8>UWIVL zJqab7rgXhhM-=xY?zsarhU=B@On~Ht9ag?GVQD;4Frr6_33#N3mG4a08Gtyfd}qQk zu+qZ{oeA4lQ!<&-Un=zvWgc5evnGOuz?bn&O|s6D%D2}rY#k*Skuku4#L4(3fB_XJ z`6k%*nv%^@`fH{BSN*KL_J?cOfq$)ha}Bdt(>dh}1WUv0U__cQ0TSopR|f_(o#UJH zM{B?4DgC`tKPXdhg6_YzIc9&ae9ft3bH@Kyyc5vC2P47<0}}s=cLE0R|HV5w#o4@) z87cixpdJa#*%Nd;I|I`n3J}crw|fk-g6V;2afC58&2a z+LggiVn$%DK1r8Ug21|FG?eGJHY3RB?n51BKz>Gm2Erv?Gu~QFVD_J+p;Z~S7gp0y zp5bc(pUty=esMJc641Z8ePzN^2kObdT>B4NoSlj3PXq|HZeN+auUfmWUj0B|b+s`% z7?@rg?+y&0*YfW8M`x~QgGTeT{n5EK`@#8vZ-51yYcB}YOMz>EfyVHHz&F6GlUx-1 ztN{idZaA2({p8BsMS*XCfrRQsfp35XyzeE!&l+HzP3E_xOTcvvFwC)&d;<(55S9eK z0cL-=e>V8{2AC?t0M>z#XdSHT*}%8KFbb4s1GK@ogB38fG(ZPy7z8<`UK;p57Dxy# z4SXL9q@9XB7B`gwPNtXP*VXUn*3xBxZ(e~5nPq`*CxL{_GQJJ{tPIX)c@UQ7cAw23 zRUH>Huea@ff$925f$e@R4}3ofBmkBN=qEj30kFUoPutVIVR#JM)!6+Sr^fuViC$NDeqz zUKN<@|4F|oUd5NhDQ5S)D#-60k&syxpy060uYmL8H32uj{$M75Pr7tXY$tZTYhpWb zg1jb(I$!}8fv*K>UEn%kpfUZmz{dfQeD7ap18~Y|X_yua=P)b-60Zk7hFS(xydJ<| z*bZ30Iq2p0!*^ld?mB`aIwc z)chw`Nj>>c;JZ*5Wc+%*#qK~rLjf4kPF!AAANZWnN*Kg1_uoYFk%Qk zqQhx}U&A86ILsF341_V@ZI3j>;6fD)*A}u9fN>=7xu<0S;s`_B&ler(p*k6uSwj9c z=VX9>(=+Ub1J3Er2I~J{=Ewc-P`yY#oH`pM3+;Cgn87AE7nt`*b}KsnXXxSU z0-KTj5MN@Ok^LCI6VTWn7?Dj~M)qTT?qER0k9_X0Iu*#srfc$%}2t1*E8xJI(O0DKLUZrWkek5(}IYFVHpf=4ju{vonA&NBd?TGjJv6YSZKm z>e1hlK$zPQfmO`aJ_WEdfG}4h1-KPK8W(R7fAVW4gz}cuB8_i%yWmFJ+qOij)~5P# zkypj;7%V`8m$2^G-Mb~aX(}QCyF_PY+uva{2l!{TI<5mV`9kX6)*{#_|ExwwaG2GB zl`YkX@`oQ6m1b2FnJ5A2zRSX;wWICb4_qJtzf>c>^9M+_#8{^BZP%dgG=N3jr(s}q z^vmIGFVmgeXI-w+Sf&wO`PV7UVR^X@FXApyCv&JfJ`G!#fO_ycd3pA5%XR1Kh_n)e zhu9x(G)LzZymEZeRct2D7Kut{BK|B41JNEhT(8jSJ#e^Q!F%BE(=_{zmAnUhpVrCT z*;IBY0vWBJ^QD#X`Z-Xq)87bzc^@{E?$cu8! zenq3HGteqV^;Df9h*J5=|A^IAtbNfWsY8{_Vug&;m4?AsQN{q-hFER)QqEq6UX`SvASv(1lb-H?x z{q#-~8d&Q!e%?D=z3k;%O7xal)gIb#}}-Vc_2d; zl!7eqbGg3RpbK4Iq^UVXH|X*TwEy^sGVp7+4kzV~FiU#kXWPf-imv{4X5iXjD3aqU zW|Jt}<|&bKZ!Hr*7>u^UWy2Po?|!7zlnJ0Mx}+3M zL|#vel={04$MBbe`R0S`MdR6zP0@2osfGPT7~=rLgbVyKS^(_ty4#3|1lZs8s7w8k zrc&x1ZAx0mk)`kGFgo`XWZuy|#(0?&WZu!2Ux_X|FQ6rgd>!6|Z=xHM z#W=-q_H2Oc)K%3Uq&2=K^dMDcdrMqHkdbI>h<+H0wub13Eb2UT z4n9lJVHJDmPUb)RP_`M^N+wFdi(Fg|QQE0O7FiKGN@@00@WmrI&eI7vcj29S-HI zo^MuHP|94tNM!g+Ux-t~XcQw0f%JJCBMX7_xkdw@|LI0kdwi;(P0t)Ty6{+h((NI0 SEI#S>kU6I7p30H8w)%f+lVrO9 diff --git a/src/gen/proto/steward.v4.rs b/src/gen/proto/steward.v4.rs index 9269501c..6cbb2eca 100644 --- a/src/gen/proto/steward.v4.rs +++ b/src/gen/proto/steward.v4.rs @@ -3382,30 +3382,14 @@ pub struct AaveV3DebtTokenAdaptorV1FlashLoanCalls { #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] pub struct CellarV2 { /// The function you wish to execute on the target cellar - #[prost(oneof = "cellar_v2::Function", tags = "1, 2, 3, 4, 5, 6, 7")] + #[prost( + oneof = "cellar_v2::Function", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13" + )] pub function: ::core::option::Option, } /// Nested message and enum types in `CellarV2`. pub mod cellar_v2 { - /// - /// Insert a trusted position to the list of positions used by the cellar at a given index. - /// - /// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` - #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] - pub struct AddPosition { - /// Index at which to add the position - #[prost(uint32, tag = "1")] - pub index: u32, - /// The position's ID in the cellar registry - #[prost(uint32, tag = "2")] - pub position_id: u32, - /// Data used to configure how the position behaves - #[prost(bytes = "vec", tag = "3")] - pub configuration_data: ::prost::alloc::vec::Vec, - /// Whether to add position in the debt array, or the credit array. - #[prost(bool, tag = "4")] - pub in_debt_array: bool, - } /// /// Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. /// @@ -3472,30 +3456,110 @@ pub mod cellar_v2 { #[prost(string, tag = "1")] pub new_lock: ::prost::alloc::string::String, } + /// + /// Insert a trusted position to the list of positions used by the cellar at a given index. + /// + /// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct AddPosition { + /// Index at which to add the position + #[prost(uint32, tag = "1")] + pub index: u32, + /// The position's ID in the cellar registry + #[prost(uint32, tag = "2")] + pub position_id: u32, + /// Data used to configure how the position behaves + #[prost(bytes = "vec", tag = "3")] + pub configuration_data: ::prost::alloc::vec::Vec, + /// Whether to add position in the debt array, or the credit array. + #[prost(bool, tag = "4")] + pub in_debt_array: bool, + } + /// Represents function `initiateShutdown()` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct InitiateShutdown {} + /// Represents function `liftShutdown()` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct LiftShutdown {} + /// Represents function `setPlatformFee(uint64)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetPlatformFee { + /// New platform fee + #[prost(uint64, tag = "1")] + pub amount: u64, + } + /// Represents function `setStrategistPlatformCut(uint64)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetStrategistPlatformCut { + /// New strategist platform cut + #[prost(uint64, tag = "1")] + pub amount: u64, + } + /// + /// Allows owner to add new adaptors for the cellar to use. + /// + /// Represents function `setupAdaptor(address adaptor)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetupAdaptor { + /// Address of the adaptor + #[prost(string, tag = "1")] + pub adaptor: ::prost::alloc::string::String, + } + /// + /// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + /// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + /// + /// Represents function `setRebalanceDeviation(uint256)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetRebalanceDeviation { + #[prost(string, tag = "1")] + pub new_deviation: ::prost::alloc::string::String, + } /// The function you wish to execute on the target cellar #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Oneof)] pub enum Function { - /// Represents function `addPosition(uint256 index, address position)` - #[prost(message, tag = "1")] - AddPosition(AddPosition), /// Represents function `callOnAdaptor(AdaptorCall[] memory data)` - #[prost(message, tag = "2")] + #[prost(message, tag = "1")] CallOnAdaptor(CallOnAdaptor), /// Represents function `removePosition(uint256 index)` - #[prost(message, tag = "3")] + #[prost(message, tag = "2")] RemovePosition(RemovePosition), /// Represents function `setHoldingPosition(uint32 position_id)` - #[prost(message, tag = "4")] + #[prost(message, tag = "3")] SetHoldingPosition(SetHoldingPosition), /// Represents function `setStrategistPayoutAddress(address payout)` - #[prost(message, tag = "5")] + #[prost(message, tag = "4")] SetStrategistPayoutAddress(SetStrategistPayoutAddress), /// Represents function `swapPositions(uint256 index1, uint256 index2)` - #[prost(message, tag = "6")] + #[prost(message, tag = "5")] SwapPositions(SwapPositions), /// Represents function `setShareLockPeriod(uint256 newLock)` - #[prost(message, tag = "7")] + #[prost(message, tag = "6")] SetShareLockPeriod(SetShareLockPeriod), + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + /// Represents function `addPosition(uint256 index, address position)` + #[prost(message, tag = "7")] + AddPosition(AddPosition), + /// Represents function `setupAdaptor(address adaptor)` + #[prost(message, tag = "8")] + SetupAdaptor(SetupAdaptor), + /// Represents function `initiateShutdown()` + #[prost(message, tag = "9")] + InitiateShutdown(InitiateShutdown), + /// Represents function `liftShutdown()` + #[prost(message, tag = "10")] + LiftShutdown(LiftShutdown), + /// Represents function `setPlatformFee(uint256)` + #[prost(message, tag = "11")] + SetPlatformFee(SetPlatformFee), + /// Represents function `setStrategistPlatformCut(address)` + #[prost(message, tag = "12")] + SetStrategistPlatformCut(SetStrategistPlatformCut), + /// Represents function `setRebalanceDeviation(uint256)` + #[prost(message, tag = "13")] + SetRebalanceDeviation(SetRebalanceDeviation), } } /// @@ -3581,7 +3645,10 @@ pub mod cellar_v2_2 { /// The function you wish to execute on the target cellar #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] pub struct FunctionCall { - #[prost(oneof = "function_call::Function", tags = "1, 2, 3, 4, 5, 6, 7, 8")] + #[prost( + oneof = "function_call::Function", + tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16" + )] pub function: ::core::option::Option, } /// Nested message and enum types in `FunctionCall`. @@ -3612,6 +3679,33 @@ pub mod cellar_v2_2 { /// Represents function `swapPositions(uint256 index1, uint256 index2)` #[prost(message, tag = "8")] SwapPositions(super::SwapPositions), + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + /// Represents function `addAdaptorToCatalogue(address adaptor)` + #[prost(message, tag = "9")] + AddAdaptorToCatalogue(super::AddAdaptorToCatalogue), + /// Represents function `addPositionToCatalogue(uint32 positionId)` + #[prost(message, tag = "10")] + AddPositionToCatalogue(super::AddPositionToCatalogue), + /// Represents function `setRebalanceDeviation(uint265)` + #[prost(message, tag = "11")] + SetRebalanceDeviation(super::SetRebalanceDeviation), + /// Represents function `setShareLockPeriod(uint256 newLock)` + #[prost(message, tag = "12")] + SetShareLockPeriod(super::SetShareLockPeriod), + /// Represents function `setStrategistPlatformCut(uint64 cut)` + #[prost(message, tag = "13")] + SetStrategistPlatformCut(super::SetStrategistPlatformCut), + /// Represents function `initiateShutdown()` + #[prost(message, tag = "14")] + InitiateShutdown(super::InitiateShutdown), + /// Represents function `liftShutdown()` + #[prost(message, tag = "15")] + LiftShutdown(super::LiftShutdown), + /// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + #[prost(message, tag = "16")] + CachePriceRouter(super::CachePriceRouter), } } /// @@ -3717,6 +3811,81 @@ pub mod cellar_v2_2 { #[prost(message, repeated, tag = "1")] pub function_calls: ::prost::alloc::vec::Vec, } + /// + /// Allows the owner to add an adaptor to the Cellar's adaptor catalogue + /// + /// Represents function `addAdaptorToCatalogue(address adaptor)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct AddAdaptorToCatalogue { + #[prost(string, tag = "1")] + pub adaptor: ::prost::alloc::string::String, + } + /// + /// Allows the owner to add a position to the Cellar's position catalogue + /// + /// Represents function `addPositionToCatalogue(uint32 positionId)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct AddPositionToCatalogue { + #[prost(uint32, tag = "1")] + pub position_id: u32, + } + /// + /// Allows share lock period to be updated. + /// + /// Represents function `setShareLockPeriod()` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetShareLockPeriod { + #[prost(string, tag = "1")] + pub new_lock: ::prost::alloc::string::String, + } + /// + /// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + /// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + /// + /// Represents function `setRebalanceDeviation(uint256)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetRebalanceDeviation { + #[prost(string, tag = "1")] + pub new_deviation: ::prost::alloc::string::String, + } + /// + /// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. + /// + /// Represents function `initiateShutdown()` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct InitiateShutdown {} + /// + /// Allows strategist to set the platform cut for the cellar. + /// + /// Represents function `setStrategistPlatformCut(uint64 cut)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetStrategistPlatformCut { + /// The new strategist platform cut + #[prost(uint64, tag = "1")] + pub new_cut: u64, + } + /// + /// Allows the owner to restart a shut down Cellar + /// + /// Represents function `liftShutdown()` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct LiftShutdown {} + /// + /// Updates the cellar to use the latest price router in the registry. + /// + /// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct CachePriceRouter { + /// Whether to check the total assets of the cellar + #[prost(bool, tag = "1")] + pub check_total_assets: bool, + /// The allowable range of the cellar's total assets to deviate between old and new routers + #[prost(uint32, tag = "2")] + pub allowable_range: u32, + /// The expected price router address + #[prost(string, tag = "3")] + pub expected_price_router: ::prost::alloc::string::String, + } #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Oneof)] pub enum CallType { /// Represents a single function call @@ -3884,7 +4053,7 @@ pub mod cellar_v2_5 { pub struct FunctionCall { #[prost( oneof = "function_call::Function", - tags = "1, 2, 3, 4, 5, 6, 8, 9, 11, 14, 15, 16, 17, 18" + tags = "1, 2, 3, 4, 5, 6, 8, 9, 11, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25" )] pub function: ::core::option::Option, } @@ -3934,6 +4103,30 @@ pub mod cellar_v2_5 { /// Represents function `setDropAlternativeAssetData(ERC20 _alternativeAsset)` #[prost(message, tag = "18")] DropAlternativeAssetData(super::DropAlternativeAssetData), + // TEMPORARY + // These are governance functions, but will be allowed in a limited capacity for SPs while + // the new governance model is still in early adoption for emergencies. + /// Represents function `addAdaptorToCatalogue(address adaptor)` + #[prost(message, tag = "19")] + AddAdaptorToCatalogue(super::AddAdaptorToCatalogue), + /// Represents function `addPositionToCatalogue(uint32 positionId)` + #[prost(message, tag = "20")] + AddPositionToCatalogue(super::AddPositionToCatalogue), + /// Represents function `setRebalanceDeviation(uint265)` + #[prost(message, tag = "21")] + SetRebalanceDeviation(super::SetRebalanceDeviation), + /// Represents function `setStrategistPlatformCut(uint64 cut)` + #[prost(message, tag = "22")] + SetStrategistPlatformCut(super::SetStrategistPlatformCut), + /// Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` + #[prost(message, tag = "23")] + SetSharePriceOracle(super::SetSharePriceOracle), + /// Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` + #[prost(message, tag = "24")] + IncreaseShareSupplyCap(super::IncreaseShareSupplyCap), + /// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + #[prost(message, tag = "25")] + CachePriceRouter(super::CachePriceRouter), } } /// @@ -4022,16 +4215,6 @@ pub mod cellar_v2_5 { pub new_lock: ::prost::alloc::string::String, } /// - /// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate - /// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. - /// - /// Represents function `setRebalanceDeviation(uint256)` - #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] - pub struct SetRebalanceDeviation { - #[prost(string, tag = "1")] - pub new_deviation: ::prost::alloc::string::String, - } - /// /// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. /// /// Represents function `initiateShutdown()` @@ -4105,6 +4288,82 @@ pub mod cellar_v2_5 { #[prost(string, tag = "1")] pub alternative_asset: ::prost::alloc::string::String, } + /// + /// Allows the owner to add an adaptor to the Cellar's adaptor catalogue + /// + /// Represents function `addAdaptorToCatalogue(address adaptor)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct AddAdaptorToCatalogue { + #[prost(string, tag = "1")] + pub adaptor: ::prost::alloc::string::String, + } + /// + /// Allows the owner to add a position to the Cellar's position catalogue + /// + /// Represents function `addPositionToCatalogue(uint32 positionId)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct AddPositionToCatalogue { + #[prost(uint32, tag = "1")] + pub position_id: u32, + } + /// + /// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate + /// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. + /// + /// Represents function `setRebalanceDeviation(uint256)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetRebalanceDeviation { + #[prost(string, tag = "1")] + pub new_deviation: ::prost::alloc::string::String, + } + /// + /// Allows strategist to set the platform cut for the cellar. + /// + /// Represents function `setStrategistPlatformCut(uint64 cut)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetStrategistPlatformCut { + /// The new strategist platform cut + #[prost(uint64, tag = "1")] + pub new_cut: u64, + } + /// + /// Allows the caller to increase the share supply cap + /// + /// Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct IncreaseShareSupplyCap { + #[prost(string, tag = "1")] + pub new_cap: ::prost::alloc::string::String, + } + /// + /// Allows the caller to set the share price oracle contract + /// + /// Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct SetSharePriceOracle { + /// The oracle registry ID + #[prost(string, tag = "1")] + pub registry_id: ::prost::alloc::string::String, + /// The oracle contract address + #[prost(string, tag = "2")] + pub share_price_oracle: ::prost::alloc::string::String, + } + /// + /// Updates the cellar to use the latest price router in the registry. + /// + /// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Message)] + pub struct CachePriceRouter { + /// Whether to check the total assets of the cellar + #[prost(bool, tag = "1")] + pub check_total_assets: bool, + /// The allowable range of the cellar's total assets to deviate between old and new routers + #[prost(uint32, tag = "2")] + pub allowable_range: u32, + /// The expected price router address + #[prost(string, tag = "3")] + pub expected_price_router: ::prost::alloc::string::String, + } #[derive(serde::Deserialize, serde::Serialize, Clone, PartialEq, ::prost::Oneof)] pub enum CallType { /// Represents a single function call diff --git a/steward_proto_go/steward_proto/cellar_v2.pb.go b/steward_proto_go/steward_proto/cellar_v2.pb.go index 1f23cd2b..0f0be4fe 100644 --- a/steward_proto_go/steward_proto/cellar_v2.pb.go +++ b/steward_proto_go/steward_proto/cellar_v2.pb.go @@ -35,13 +35,19 @@ type CellarV2 struct { // The function you wish to execute on the target cellar // // Types that are assignable to Function: - // *CellarV2_AddPosition_ // *CellarV2_CallOnAdaptor_ // *CellarV2_RemovePosition_ // *CellarV2_SetHoldingPosition_ // *CellarV2_SetStrategistPayoutAddress_ // *CellarV2_SwapPositions_ // *CellarV2_SetShareLockPeriod_ + // *CellarV2_AddPosition_ + // *CellarV2_SetupAdaptor_ + // *CellarV2_InitiateShutdown_ + // *CellarV2_LiftShutdown_ + // *CellarV2_SetPlatformFee_ + // *CellarV2_SetStrategistPlatformCut_ + // *CellarV2_SetRebalanceDeviation_ Function isCellarV2_Function `protobuf_oneof:"function"` } @@ -84,13 +90,6 @@ func (m *CellarV2) GetFunction() isCellarV2_Function { return nil } -func (x *CellarV2) GetAddPosition() *CellarV2_AddPosition { - if x, ok := x.GetFunction().(*CellarV2_AddPosition_); ok { - return x.AddPosition - } - return nil -} - func (x *CellarV2) GetCallOnAdaptor() *CellarV2_CallOnAdaptor { if x, ok := x.GetFunction().(*CellarV2_CallOnAdaptor_); ok { return x.CallOnAdaptor @@ -133,46 +132,123 @@ func (x *CellarV2) GetSetShareLockPeriod() *CellarV2_SetShareLockPeriod { return nil } -type isCellarV2_Function interface { - isCellarV2_Function() +func (x *CellarV2) GetAddPosition() *CellarV2_AddPosition { + if x, ok := x.GetFunction().(*CellarV2_AddPosition_); ok { + return x.AddPosition + } + return nil } -type CellarV2_AddPosition_ struct { - // Represents function `addPosition(uint256 index, address position)` - AddPosition *CellarV2_AddPosition `protobuf:"bytes,1,opt,name=add_position,json=addPosition,proto3,oneof"` +func (x *CellarV2) GetSetupAdaptor() *CellarV2_SetupAdaptor { + if x, ok := x.GetFunction().(*CellarV2_SetupAdaptor_); ok { + return x.SetupAdaptor + } + return nil +} + +func (x *CellarV2) GetInitiateShutdown() *CellarV2_InitiateShutdown { + if x, ok := x.GetFunction().(*CellarV2_InitiateShutdown_); ok { + return x.InitiateShutdown + } + return nil +} + +func (x *CellarV2) GetLiftShutdown() *CellarV2_LiftShutdown { + if x, ok := x.GetFunction().(*CellarV2_LiftShutdown_); ok { + return x.LiftShutdown + } + return nil +} + +func (x *CellarV2) GetSetPlatformFee() *CellarV2_SetPlatformFee { + if x, ok := x.GetFunction().(*CellarV2_SetPlatformFee_); ok { + return x.SetPlatformFee + } + return nil +} + +func (x *CellarV2) GetSetStrategistPlatformCut() *CellarV2_SetStrategistPlatformCut { + if x, ok := x.GetFunction().(*CellarV2_SetStrategistPlatformCut_); ok { + return x.SetStrategistPlatformCut + } + return nil +} + +func (x *CellarV2) GetSetRebalanceDeviation() *CellarV2_SetRebalanceDeviation { + if x, ok := x.GetFunction().(*CellarV2_SetRebalanceDeviation_); ok { + return x.SetRebalanceDeviation + } + return nil +} + +type isCellarV2_Function interface { + isCellarV2_Function() } type CellarV2_CallOnAdaptor_ struct { // Represents function `callOnAdaptor(AdaptorCall[] memory data)` - CallOnAdaptor *CellarV2_CallOnAdaptor `protobuf:"bytes,2,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` + CallOnAdaptor *CellarV2_CallOnAdaptor `protobuf:"bytes,1,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` } type CellarV2_RemovePosition_ struct { // Represents function `removePosition(uint256 index)` - RemovePosition *CellarV2_RemovePosition `protobuf:"bytes,3,opt,name=remove_position,json=removePosition,proto3,oneof"` + RemovePosition *CellarV2_RemovePosition `protobuf:"bytes,2,opt,name=remove_position,json=removePosition,proto3,oneof"` } type CellarV2_SetHoldingPosition_ struct { // Represents function `setHoldingPosition(uint32 position_id)` - SetHoldingPosition *CellarV2_SetHoldingPosition `protobuf:"bytes,4,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` + SetHoldingPosition *CellarV2_SetHoldingPosition `protobuf:"bytes,3,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` } type CellarV2_SetStrategistPayoutAddress_ struct { // Represents function `setStrategistPayoutAddress(address payout)` - SetStrategistPayoutAddress *CellarV2_SetStrategistPayoutAddress `protobuf:"bytes,5,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` + SetStrategistPayoutAddress *CellarV2_SetStrategistPayoutAddress `protobuf:"bytes,4,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` } type CellarV2_SwapPositions_ struct { // Represents function `swapPositions(uint256 index1, uint256 index2)` - SwapPositions *CellarV2_SwapPositions `protobuf:"bytes,6,opt,name=swap_positions,json=swapPositions,proto3,oneof"` + SwapPositions *CellarV2_SwapPositions `protobuf:"bytes,5,opt,name=swap_positions,json=swapPositions,proto3,oneof"` } type CellarV2_SetShareLockPeriod_ struct { // Represents function `setShareLockPeriod(uint256 newLock)` - SetShareLockPeriod *CellarV2_SetShareLockPeriod `protobuf:"bytes,7,opt,name=set_share_lock_period,json=setShareLockPeriod,proto3,oneof"` + SetShareLockPeriod *CellarV2_SetShareLockPeriod `protobuf:"bytes,6,opt,name=set_share_lock_period,json=setShareLockPeriod,proto3,oneof"` } -func (*CellarV2_AddPosition_) isCellarV2_Function() {} +type CellarV2_AddPosition_ struct { + // Represents function `addPosition(uint256 index, address position)` + AddPosition *CellarV2_AddPosition `protobuf:"bytes,7,opt,name=add_position,json=addPosition,proto3,oneof"` +} + +type CellarV2_SetupAdaptor_ struct { + // Represents function `setupAdaptor(address adaptor)` + SetupAdaptor *CellarV2_SetupAdaptor `protobuf:"bytes,8,opt,name=setup_adaptor,json=setupAdaptor,proto3,oneof"` +} + +type CellarV2_InitiateShutdown_ struct { + // Represents function `initiateShutdown()` + InitiateShutdown *CellarV2_InitiateShutdown `protobuf:"bytes,9,opt,name=initiate_shutdown,json=initiateShutdown,proto3,oneof"` +} + +type CellarV2_LiftShutdown_ struct { + // Represents function `liftShutdown()` + LiftShutdown *CellarV2_LiftShutdown `protobuf:"bytes,10,opt,name=lift_shutdown,json=liftShutdown,proto3,oneof"` +} + +type CellarV2_SetPlatformFee_ struct { + // Represents function `setPlatformFee(uint256)` + SetPlatformFee *CellarV2_SetPlatformFee `protobuf:"bytes,11,opt,name=set_platform_fee,json=setPlatformFee,proto3,oneof"` +} + +type CellarV2_SetStrategistPlatformCut_ struct { + // Represents function `setStrategistPlatformCut(address)` + SetStrategistPlatformCut *CellarV2_SetStrategistPlatformCut `protobuf:"bytes,12,opt,name=set_strategist_platform_cut,json=setStrategistPlatformCut,proto3,oneof"` +} + +type CellarV2_SetRebalanceDeviation_ struct { + // Represents function `setRebalanceDeviation(uint256)` + SetRebalanceDeviation *CellarV2_SetRebalanceDeviation `protobuf:"bytes,13,opt,name=set_rebalance_deviation,json=setRebalanceDeviation,proto3,oneof"` +} func (*CellarV2_CallOnAdaptor_) isCellarV2_Function() {} @@ -186,6 +262,20 @@ func (*CellarV2_SwapPositions_) isCellarV2_Function() {} func (*CellarV2_SetShareLockPeriod_) isCellarV2_Function() {} +func (*CellarV2_AddPosition_) isCellarV2_Function() {} + +func (*CellarV2_SetupAdaptor_) isCellarV2_Function() {} + +func (*CellarV2_InitiateShutdown_) isCellarV2_Function() {} + +func (*CellarV2_LiftShutdown_) isCellarV2_Function() {} + +func (*CellarV2_SetPlatformFee_) isCellarV2_Function() {} + +func (*CellarV2_SetStrategistPlatformCut_) isCellarV2_Function() {} + +func (*CellarV2_SetRebalanceDeviation_) isCellarV2_Function() {} + // // Represent a function call initiated through a governance proposal type CellarV2Governance struct { @@ -1467,85 +1557,6 @@ func (*AdaptorCall_MorphoBlueDebtV1Calls) isAdaptorCall_CallData() {} func (*AdaptorCall_MorphoBlueSupplyV1Calls) isAdaptorCall_CallData() {} -// -// Insert a trusted position to the list of positions used by the cellar at a given index. -// -// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` -type CellarV2_AddPosition struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - // Index at which to add the position - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - // The position's ID in the cellar registry - PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - // Data used to configure how the position behaves - ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` - // Whether to add position in the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` -} - -func (x *CellarV2_AddPosition) Reset() { - *x = CellarV2_AddPosition{} - if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[7] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CellarV2_AddPosition) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CellarV2_AddPosition) ProtoMessage() {} - -func (x *CellarV2_AddPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[7] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CellarV2_AddPosition.ProtoReflect.Descriptor instead. -func (*CellarV2_AddPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 0} -} - -func (x *CellarV2_AddPosition) GetIndex() uint32 { - if x != nil { - return x.Index - } - return 0 -} - -func (x *CellarV2_AddPosition) GetPositionId() uint32 { - if x != nil { - return x.PositionId - } - return 0 -} - -func (x *CellarV2_AddPosition) GetConfigurationData() []byte { - if x != nil { - return x.ConfigurationData - } - return nil -} - -func (x *CellarV2_AddPosition) GetInDebtArray() bool { - if x != nil { - return x.InDebtArray - } - return false -} - // // Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. // @@ -1561,7 +1572,7 @@ type CellarV2_CallOnAdaptor struct { func (x *CellarV2_CallOnAdaptor) Reset() { *x = CellarV2_CallOnAdaptor{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[8] + mi := &file_cellar_v2_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1574,7 +1585,7 @@ func (x *CellarV2_CallOnAdaptor) String() string { func (*CellarV2_CallOnAdaptor) ProtoMessage() {} func (x *CellarV2_CallOnAdaptor) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[8] + mi := &file_cellar_v2_proto_msgTypes[7] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1587,7 +1598,7 @@ func (x *CellarV2_CallOnAdaptor) ProtoReflect() protoreflect.Message { // Deprecated: Use CellarV2_CallOnAdaptor.ProtoReflect.Descriptor instead. func (*CellarV2_CallOnAdaptor) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 1} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 0} } func (x *CellarV2_CallOnAdaptor) GetData() []*AdaptorCall { @@ -1615,7 +1626,7 @@ type CellarV2_RemovePosition struct { func (x *CellarV2_RemovePosition) Reset() { *x = CellarV2_RemovePosition{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[9] + mi := &file_cellar_v2_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1628,7 +1639,7 @@ func (x *CellarV2_RemovePosition) String() string { func (*CellarV2_RemovePosition) ProtoMessage() {} func (x *CellarV2_RemovePosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[9] + mi := &file_cellar_v2_proto_msgTypes[8] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1641,7 +1652,7 @@ func (x *CellarV2_RemovePosition) ProtoReflect() protoreflect.Message { // Deprecated: Use CellarV2_RemovePosition.ProtoReflect.Descriptor instead. func (*CellarV2_RemovePosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 2} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 1} } func (x *CellarV2_RemovePosition) GetIndex() uint32 { @@ -1674,7 +1685,7 @@ type CellarV2_SetHoldingPosition struct { func (x *CellarV2_SetHoldingPosition) Reset() { *x = CellarV2_SetHoldingPosition{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[10] + mi := &file_cellar_v2_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1687,7 +1698,7 @@ func (x *CellarV2_SetHoldingPosition) String() string { func (*CellarV2_SetHoldingPosition) ProtoMessage() {} func (x *CellarV2_SetHoldingPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[10] + mi := &file_cellar_v2_proto_msgTypes[9] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1700,7 +1711,7 @@ func (x *CellarV2_SetHoldingPosition) ProtoReflect() protoreflect.Message { // Deprecated: Use CellarV2_SetHoldingPosition.ProtoReflect.Descriptor instead. func (*CellarV2_SetHoldingPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 3} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 2} } func (x *CellarV2_SetHoldingPosition) GetPositionId() uint32 { @@ -1725,7 +1736,7 @@ type CellarV2_SetStrategistPayoutAddress struct { func (x *CellarV2_SetStrategistPayoutAddress) Reset() { *x = CellarV2_SetStrategistPayoutAddress{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[11] + mi := &file_cellar_v2_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1738,7 +1749,7 @@ func (x *CellarV2_SetStrategistPayoutAddress) String() string { func (*CellarV2_SetStrategistPayoutAddress) ProtoMessage() {} func (x *CellarV2_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[11] + mi := &file_cellar_v2_proto_msgTypes[10] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1751,7 +1762,7 @@ func (x *CellarV2_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Messag // Deprecated: Use CellarV2_SetStrategistPayoutAddress.ProtoReflect.Descriptor instead. func (*CellarV2_SetStrategistPayoutAddress) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 4} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 3} } func (x *CellarV2_SetStrategistPayoutAddress) GetPayout() string { @@ -1781,7 +1792,7 @@ type CellarV2_SwapPositions struct { func (x *CellarV2_SwapPositions) Reset() { *x = CellarV2_SwapPositions{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[12] + mi := &file_cellar_v2_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1794,7 +1805,7 @@ func (x *CellarV2_SwapPositions) String() string { func (*CellarV2_SwapPositions) ProtoMessage() {} func (x *CellarV2_SwapPositions) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[12] + mi := &file_cellar_v2_proto_msgTypes[11] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1807,7 +1818,7 @@ func (x *CellarV2_SwapPositions) ProtoReflect() protoreflect.Message { // Deprecated: Use CellarV2_SwapPositions.ProtoReflect.Descriptor instead. func (*CellarV2_SwapPositions) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 5} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 4} } func (x *CellarV2_SwapPositions) GetIndex_1() uint32 { @@ -1846,7 +1857,7 @@ type CellarV2_SetShareLockPeriod struct { func (x *CellarV2_SetShareLockPeriod) Reset() { *x = CellarV2_SetShareLockPeriod{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[13] + mi := &file_cellar_v2_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1859,7 +1870,7 @@ func (x *CellarV2_SetShareLockPeriod) String() string { func (*CellarV2_SetShareLockPeriod) ProtoMessage() {} func (x *CellarV2_SetShareLockPeriod) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[13] + mi := &file_cellar_v2_proto_msgTypes[12] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1872,7 +1883,7 @@ func (x *CellarV2_SetShareLockPeriod) ProtoReflect() protoreflect.Message { // Deprecated: Use CellarV2_SetShareLockPeriod.ProtoReflect.Descriptor instead. func (*CellarV2_SetShareLockPeriod) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{0, 6} + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 5} } func (x *CellarV2_SetShareLockPeriod) GetNewLock() string { @@ -1882,30 +1893,42 @@ func (x *CellarV2_SetShareLockPeriod) GetNewLock() string { return "" } -// Represents function `initiateShutdown()` -type CellarV2Governance_InitiateShutdown struct { +// +// Insert a trusted position to the list of positions used by the cellar at a given index. +// +// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` +type CellarV2_AddPosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + // Index at which to add the position + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // The position's ID in the cellar registry + PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // Data used to configure how the position behaves + ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` + // Whether to add position in the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2Governance_InitiateShutdown) Reset() { - *x = CellarV2Governance_InitiateShutdown{} +func (x *CellarV2_AddPosition) Reset() { + *x = CellarV2_AddPosition{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[14] + mi := &file_cellar_v2_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2Governance_InitiateShutdown) String() string { +func (x *CellarV2_AddPosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2Governance_InitiateShutdown) ProtoMessage() {} +func (*CellarV2_AddPosition) ProtoMessage() {} -func (x *CellarV2Governance_InitiateShutdown) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[14] +func (x *CellarV2_AddPosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[13] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1916,34 +1939,101 @@ func (x *CellarV2Governance_InitiateShutdown) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_InitiateShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_InitiateShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 0} -} - -// Represents function `liftShutdown()` -type CellarV2Governance_LiftShutdown struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields +// Deprecated: Use CellarV2_AddPosition.ProtoReflect.Descriptor instead. +func (*CellarV2_AddPosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 6} } -func (x *CellarV2Governance_LiftShutdown) Reset() { - *x = CellarV2Governance_LiftShutdown{} - if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[15] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *CellarV2_AddPosition) GetIndex() uint32 { + if x != nil { + return x.Index } + return 0 } -func (x *CellarV2Governance_LiftShutdown) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *CellarV2_AddPosition) GetPositionId() uint32 { + if x != nil { + return x.PositionId + } + return 0 } -func (*CellarV2Governance_LiftShutdown) ProtoMessage() {} +func (x *CellarV2_AddPosition) GetConfigurationData() []byte { + if x != nil { + return x.ConfigurationData + } + return nil +} -func (x *CellarV2Governance_LiftShutdown) ProtoReflect() protoreflect.Message { +func (x *CellarV2_AddPosition) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false +} + +// Represents function `initiateShutdown()` +type CellarV2_InitiateShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_InitiateShutdown) Reset() { + *x = CellarV2_InitiateShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_InitiateShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_InitiateShutdown) ProtoMessage() {} + +func (x *CellarV2_InitiateShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_InitiateShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_InitiateShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 7} +} + +// Represents function `liftShutdown()` +type CellarV2_LiftShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_LiftShutdown) Reset() { + *x = CellarV2_LiftShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_LiftShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_LiftShutdown) ProtoMessage() {} + +func (x *CellarV2_LiftShutdown) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[15] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1955,13 +2045,13 @@ func (x *CellarV2Governance_LiftShutdown) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_LiftShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_LiftShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 1} +// Deprecated: Use CellarV2_LiftShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_LiftShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 8} } // Represents function `setPlatformFee(uint64)` -type CellarV2Governance_SetPlatformFee struct { +type CellarV2_SetPlatformFee struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -1970,8 +2060,8 @@ type CellarV2Governance_SetPlatformFee struct { Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` } -func (x *CellarV2Governance_SetPlatformFee) Reset() { - *x = CellarV2Governance_SetPlatformFee{} +func (x *CellarV2_SetPlatformFee) Reset() { + *x = CellarV2_SetPlatformFee{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1979,13 +2069,13 @@ func (x *CellarV2Governance_SetPlatformFee) Reset() { } } -func (x *CellarV2Governance_SetPlatformFee) String() string { +func (x *CellarV2_SetPlatformFee) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2Governance_SetPlatformFee) ProtoMessage() {} +func (*CellarV2_SetPlatformFee) ProtoMessage() {} -func (x *CellarV2Governance_SetPlatformFee) ProtoReflect() protoreflect.Message { +func (x *CellarV2_SetPlatformFee) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[16] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -1997,12 +2087,12 @@ func (x *CellarV2Governance_SetPlatformFee) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_SetPlatformFee.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_SetPlatformFee) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 2} +// Deprecated: Use CellarV2_SetPlatformFee.ProtoReflect.Descriptor instead. +func (*CellarV2_SetPlatformFee) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 9} } -func (x *CellarV2Governance_SetPlatformFee) GetAmount() uint64 { +func (x *CellarV2_SetPlatformFee) GetAmount() uint64 { if x != nil { return x.Amount } @@ -2010,7 +2100,7 @@ func (x *CellarV2Governance_SetPlatformFee) GetAmount() uint64 { } // Represents function `setStrategistPlatformCut(uint64)` -type CellarV2Governance_SetStrategistPlatformCut struct { +type CellarV2_SetStrategistPlatformCut struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -2019,8 +2109,8 @@ type CellarV2Governance_SetStrategistPlatformCut struct { Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` } -func (x *CellarV2Governance_SetStrategistPlatformCut) Reset() { - *x = CellarV2Governance_SetStrategistPlatformCut{} +func (x *CellarV2_SetStrategistPlatformCut) Reset() { + *x = CellarV2_SetStrategistPlatformCut{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2028,13 +2118,13 @@ func (x *CellarV2Governance_SetStrategistPlatformCut) Reset() { } } -func (x *CellarV2Governance_SetStrategistPlatformCut) String() string { +func (x *CellarV2_SetStrategistPlatformCut) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2Governance_SetStrategistPlatformCut) ProtoMessage() {} +func (*CellarV2_SetStrategistPlatformCut) ProtoMessage() {} -func (x *CellarV2Governance_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { +func (x *CellarV2_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[17] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2046,12 +2136,12 @@ func (x *CellarV2Governance_SetStrategistPlatformCut) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 3} +// Deprecated: Use CellarV2_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. +func (*CellarV2_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 10} } -func (x *CellarV2Governance_SetStrategistPlatformCut) GetAmount() uint64 { +func (x *CellarV2_SetStrategistPlatformCut) GetAmount() uint64 { if x != nil { return x.Amount } @@ -2062,7 +2152,7 @@ func (x *CellarV2Governance_SetStrategistPlatformCut) GetAmount() uint64 { // Allows owner to add new adaptors for the cellar to use. // // Represents function `setupAdaptor(address adaptor)` -type CellarV2Governance_SetupAdaptor struct { +type CellarV2_SetupAdaptor struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -2071,8 +2161,8 @@ type CellarV2Governance_SetupAdaptor struct { Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2Governance_SetupAdaptor) Reset() { - *x = CellarV2Governance_SetupAdaptor{} +func (x *CellarV2_SetupAdaptor) Reset() { + *x = CellarV2_SetupAdaptor{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2080,13 +2170,13 @@ func (x *CellarV2Governance_SetupAdaptor) Reset() { } } -func (x *CellarV2Governance_SetupAdaptor) String() string { +func (x *CellarV2_SetupAdaptor) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2Governance_SetupAdaptor) ProtoMessage() {} +func (*CellarV2_SetupAdaptor) ProtoMessage() {} -func (x *CellarV2Governance_SetupAdaptor) ProtoReflect() protoreflect.Message { +func (x *CellarV2_SetupAdaptor) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[18] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2098,12 +2188,12 @@ func (x *CellarV2Governance_SetupAdaptor) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_SetupAdaptor.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_SetupAdaptor) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 4} +// Deprecated: Use CellarV2_SetupAdaptor.ProtoReflect.Descriptor instead. +func (*CellarV2_SetupAdaptor) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 11} } -func (x *CellarV2Governance_SetupAdaptor) GetAdaptor() string { +func (x *CellarV2_SetupAdaptor) GetAdaptor() string { if x != nil { return x.Adaptor } @@ -2115,7 +2205,7 @@ func (x *CellarV2Governance_SetupAdaptor) GetAdaptor() string { // during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. // // Represents function `setRebalanceDeviation(uint256)` -type CellarV2Governance_SetRebalanceDeviation struct { +type CellarV2_SetRebalanceDeviation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -2123,8 +2213,8 @@ type CellarV2Governance_SetRebalanceDeviation struct { NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` } -func (x *CellarV2Governance_SetRebalanceDeviation) Reset() { - *x = CellarV2Governance_SetRebalanceDeviation{} +func (x *CellarV2_SetRebalanceDeviation) Reset() { + *x = CellarV2_SetRebalanceDeviation{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2132,13 +2222,13 @@ func (x *CellarV2Governance_SetRebalanceDeviation) Reset() { } } -func (x *CellarV2Governance_SetRebalanceDeviation) String() string { +func (x *CellarV2_SetRebalanceDeviation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2Governance_SetRebalanceDeviation) ProtoMessage() {} +func (*CellarV2_SetRebalanceDeviation) ProtoMessage() {} -func (x *CellarV2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { +func (x *CellarV2_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[19] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2150,38 +2240,27 @@ func (x *CellarV2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.M return mi.MessageOf(x) } -// Deprecated: Use CellarV2Governance_SetRebalanceDeviation.ProtoReflect.Descriptor instead. -func (*CellarV2Governance_SetRebalanceDeviation) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{1, 5} +// Deprecated: Use CellarV2_SetRebalanceDeviation.ProtoReflect.Descriptor instead. +func (*CellarV2_SetRebalanceDeviation) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{0, 12} } -func (x *CellarV2Governance_SetRebalanceDeviation) GetNewDeviation() string { +func (x *CellarV2_SetRebalanceDeviation) GetNewDeviation() string { if x != nil { return x.NewDeviation } return "" } -// The function you wish to execute on the target cellar -type CellarV2_2_FunctionCall struct { +// Represents function `initiateShutdown()` +type CellarV2Governance_InitiateShutdown struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - - // Types that are assignable to Function: - // *CellarV2_2_FunctionCall_AddPosition - // *CellarV2_2_FunctionCall_CallOnAdaptor - // *CellarV2_2_FunctionCall_RemovePosition - // *CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue - // *CellarV2_2_FunctionCall_RemovePositionFromCatalogue - // *CellarV2_2_FunctionCall_SetHoldingPosition - // *CellarV2_2_FunctionCall_SetStrategistPayoutAddress - // *CellarV2_2_FunctionCall_SwapPositions - Function isCellarV2_2_FunctionCall_Function `protobuf_oneof:"function"` } -func (x *CellarV2_2_FunctionCall) Reset() { - *x = CellarV2_2_FunctionCall{} +func (x *CellarV2Governance_InitiateShutdown) Reset() { + *x = CellarV2Governance_InitiateShutdown{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2189,13 +2268,13 @@ func (x *CellarV2_2_FunctionCall) Reset() { } } -func (x *CellarV2_2_FunctionCall) String() string { +func (x *CellarV2Governance_InitiateShutdown) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_FunctionCall) ProtoMessage() {} +func (*CellarV2Governance_InitiateShutdown) ProtoMessage() {} -func (x *CellarV2_2_FunctionCall) ProtoReflect() protoreflect.Message { +func (x *CellarV2Governance_InitiateShutdown) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[20] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2207,170 +2286,126 @@ func (x *CellarV2_2_FunctionCall) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_FunctionCall.ProtoReflect.Descriptor instead. -func (*CellarV2_2_FunctionCall) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 0} +// Deprecated: Use CellarV2Governance_InitiateShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_InitiateShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 0} } -func (m *CellarV2_2_FunctionCall) GetFunction() isCellarV2_2_FunctionCall_Function { - if m != nil { - return m.Function - } - return nil +// Represents function `liftShutdown()` +type CellarV2Governance_LiftShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields } -func (x *CellarV2_2_FunctionCall) GetAddPosition() *CellarV2_2_AddPosition { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_AddPosition); ok { - return x.AddPosition +func (x *CellarV2Governance_LiftShutdown) Reset() { + *x = CellarV2Governance_LiftShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return nil } -func (x *CellarV2_2_FunctionCall) GetCallOnAdaptor() *CellarV2_2_CallOnAdaptor { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_CallOnAdaptor); ok { - return x.CallOnAdaptor - } - return nil +func (x *CellarV2Governance_LiftShutdown) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *CellarV2_2_FunctionCall) GetRemovePosition() *CellarV2_2_RemovePosition { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemovePosition); ok { - return x.RemovePosition - } - return nil -} +func (*CellarV2Governance_LiftShutdown) ProtoMessage() {} -func (x *CellarV2_2_FunctionCall) GetRemoveAdaptorFromCatalogue() *CellarV2_2_RemoveAdaptorFromCatalogue { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue); ok { - return x.RemoveAdaptorFromCatalogue +func (x *CellarV2Governance_LiftShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil + return mi.MessageOf(x) } -func (x *CellarV2_2_FunctionCall) GetRemovePositionFromCatalogue() *CellarV2_2_RemovePositionFromCatalogue { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemovePositionFromCatalogue); ok { - return x.RemovePositionFromCatalogue - } - return nil +// Deprecated: Use CellarV2Governance_LiftShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_LiftShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 1} } -func (x *CellarV2_2_FunctionCall) GetSetHoldingPosition() *CellarV2_2_SetHoldingPosition { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetHoldingPosition); ok { - return x.SetHoldingPosition - } - return nil -} +// Represents function `setPlatformFee(uint64)` +type CellarV2Governance_SetPlatformFee struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields -func (x *CellarV2_2_FunctionCall) GetSetStrategistPayoutAddress() *CellarV2_2_SetStrategistPayoutAddress { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetStrategistPayoutAddress); ok { - return x.SetStrategistPayoutAddress - } - return nil + // New platform fee + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` } -func (x *CellarV2_2_FunctionCall) GetSwapPositions() *CellarV2_2_SwapPositions { - if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SwapPositions); ok { - return x.SwapPositions +func (x *CellarV2Governance_SetPlatformFee) Reset() { + *x = CellarV2Governance_SetPlatformFee{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return nil } -type isCellarV2_2_FunctionCall_Function interface { - isCellarV2_2_FunctionCall_Function() +func (x *CellarV2Governance_SetPlatformFee) String() string { + return protoimpl.X.MessageStringOf(x) } -type CellarV2_2_FunctionCall_AddPosition struct { - // Represents function `addPosition(uint256 index, address position)` - AddPosition *CellarV2_2_AddPosition `protobuf:"bytes,1,opt,name=add_position,json=addPosition,proto3,oneof"` -} +func (*CellarV2Governance_SetPlatformFee) ProtoMessage() {} -type CellarV2_2_FunctionCall_CallOnAdaptor struct { - // Represents function `callOnAdaptor(AdaptorCall[] memory data)` - CallOnAdaptor *CellarV2_2_CallOnAdaptor `protobuf:"bytes,2,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` +func (x *CellarV2Governance_SetPlatformFee) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) } -type CellarV2_2_FunctionCall_RemovePosition struct { - // Represents function `removePosition(uint256 index, bool inDebtArray)` - RemovePosition *CellarV2_2_RemovePosition `protobuf:"bytes,3,opt,name=remove_position,json=removePosition,proto3,oneof"` +// Deprecated: Use CellarV2Governance_SetPlatformFee.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_SetPlatformFee) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 2} } -type CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue struct { - // Represents function `removeAdaptorFromCatalogue(address adaptor)` - RemoveAdaptorFromCatalogue *CellarV2_2_RemoveAdaptorFromCatalogue `protobuf:"bytes,4,opt,name=remove_adaptor_from_catalogue,json=removeAdaptorFromCatalogue,proto3,oneof"` +func (x *CellarV2Governance_SetPlatformFee) GetAmount() uint64 { + if x != nil { + return x.Amount + } + return 0 } -type CellarV2_2_FunctionCall_RemovePositionFromCatalogue struct { - // Represents function `removePositionFromCatalogue(uint32 positionId)` - RemovePositionFromCatalogue *CellarV2_2_RemovePositionFromCatalogue `protobuf:"bytes,5,opt,name=remove_position_from_catalogue,json=removePositionFromCatalogue,proto3,oneof"` -} - -type CellarV2_2_FunctionCall_SetHoldingPosition struct { - // Represents function `setHoldingPosition(uint32 position_id)` - SetHoldingPosition *CellarV2_2_SetHoldingPosition `protobuf:"bytes,6,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` -} - -type CellarV2_2_FunctionCall_SetStrategistPayoutAddress struct { - // Represents function `setStrategistPayoutAddress(address payout)` - SetStrategistPayoutAddress *CellarV2_2_SetStrategistPayoutAddress `protobuf:"bytes,7,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` -} - -type CellarV2_2_FunctionCall_SwapPositions struct { - // Represents function `swapPositions(uint256 index1, uint256 index2)` - SwapPositions *CellarV2_2_SwapPositions `protobuf:"bytes,8,opt,name=swap_positions,json=swapPositions,proto3,oneof"` -} - -func (*CellarV2_2_FunctionCall_AddPosition) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_CallOnAdaptor) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_RemovePosition) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_RemovePositionFromCatalogue) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_SetHoldingPosition) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_SetStrategistPayoutAddress) isCellarV2_2_FunctionCall_Function() {} - -func (*CellarV2_2_FunctionCall_SwapPositions) isCellarV2_2_FunctionCall_Function() {} - -// -// Insert a trusted position to the list of positions used by the cellar at a given index. -// -// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` -type CellarV2_2_AddPosition struct { +// Represents function `setStrategistPlatformCut(uint64)` +type CellarV2Governance_SetStrategistPlatformCut struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Index at which to add the position - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - // The position's ID in the cellar registry - PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - // Data used to configure how the position behaves - ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` - // Whether to add position in the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + // New strategist platform cut + Amount uint64 `protobuf:"varint,1,opt,name=amount,proto3" json:"amount,omitempty"` } -func (x *CellarV2_2_AddPosition) Reset() { - *x = CellarV2_2_AddPosition{} +func (x *CellarV2Governance_SetStrategistPlatformCut) Reset() { + *x = CellarV2Governance_SetStrategistPlatformCut{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[21] + mi := &file_cellar_v2_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_AddPosition) String() string { +func (x *CellarV2Governance_SetStrategistPlatformCut) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_AddPosition) ProtoMessage() {} +func (*CellarV2Governance_SetStrategistPlatformCut) ProtoMessage() {} -func (x *CellarV2_2_AddPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[21] +func (x *CellarV2Governance_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[23] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2381,68 +2416,48 @@ func (x *CellarV2_2_AddPosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_AddPosition.ProtoReflect.Descriptor instead. -func (*CellarV2_2_AddPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 1} -} - -func (x *CellarV2_2_AddPosition) GetIndex() uint32 { - if x != nil { - return x.Index - } - return 0 +// Deprecated: Use CellarV2Governance_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 3} } -func (x *CellarV2_2_AddPosition) GetPositionId() uint32 { +func (x *CellarV2Governance_SetStrategistPlatformCut) GetAmount() uint64 { if x != nil { - return x.PositionId + return x.Amount } return 0 } -func (x *CellarV2_2_AddPosition) GetConfigurationData() []byte { - if x != nil { - return x.ConfigurationData - } - return nil -} - -func (x *CellarV2_2_AddPosition) GetInDebtArray() bool { - if x != nil { - return x.InDebtArray - } - return false -} - // -// Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. +// Allows owner to add new adaptors for the cellar to use. // -// Represents function `callOnAdaptor(AdaptorCall[] memory data)` -type CellarV2_2_CallOnAdaptor struct { +// Represents function `setupAdaptor(address adaptor)` +type CellarV2Governance_SetupAdaptor struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Data []*AdaptorCall `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` + // Address of the adaptor + Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2_2_CallOnAdaptor) Reset() { - *x = CellarV2_2_CallOnAdaptor{} +func (x *CellarV2Governance_SetupAdaptor) Reset() { + *x = CellarV2Governance_SetupAdaptor{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[22] + mi := &file_cellar_v2_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_CallOnAdaptor) String() string { +func (x *CellarV2Governance_SetupAdaptor) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_CallOnAdaptor) ProtoMessage() {} +func (*CellarV2Governance_SetupAdaptor) ProtoMessage() {} -func (x *CellarV2_2_CallOnAdaptor) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[22] +func (x *CellarV2Governance_SetupAdaptor) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2453,50 +2468,48 @@ func (x *CellarV2_2_CallOnAdaptor) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_CallOnAdaptor.ProtoReflect.Descriptor instead. -func (*CellarV2_2_CallOnAdaptor) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 2} +// Deprecated: Use CellarV2Governance_SetupAdaptor.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_SetupAdaptor) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 4} } -func (x *CellarV2_2_CallOnAdaptor) GetData() []*AdaptorCall { +func (x *CellarV2Governance_SetupAdaptor) GetAdaptor() string { if x != nil { - return x.Data + return x.Adaptor } - return nil + return "" } // -// Remove the position at a given index from the list of positions used by the cellar. +// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate +// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. // -// Represents function `removePosition(uint32 index, bool inDebtArray)` -type CellarV2_2_RemovePosition struct { +// Represents function `setRebalanceDeviation(uint256)` +type CellarV2Governance_SetRebalanceDeviation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Index at which to remove the position - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - // Whether to remove position from the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,2,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` } -func (x *CellarV2_2_RemovePosition) Reset() { - *x = CellarV2_2_RemovePosition{} +func (x *CellarV2Governance_SetRebalanceDeviation) Reset() { + *x = CellarV2Governance_SetRebalanceDeviation{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[23] + mi := &file_cellar_v2_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_RemovePosition) String() string { +func (x *CellarV2Governance_SetRebalanceDeviation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_RemovePosition) ProtoMessage() {} +func (*CellarV2Governance_SetRebalanceDeviation) ProtoMessage() {} -func (x *CellarV2_2_RemovePosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[23] +func (x *CellarV2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2507,54 +2520,61 @@ func (x *CellarV2_2_RemovePosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_RemovePosition.ProtoReflect.Descriptor instead. -func (*CellarV2_2_RemovePosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 3} -} - -func (x *CellarV2_2_RemovePosition) GetIndex() uint32 { - if x != nil { - return x.Index - } - return 0 +// Deprecated: Use CellarV2Governance_SetRebalanceDeviation.ProtoReflect.Descriptor instead. +func (*CellarV2Governance_SetRebalanceDeviation) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{1, 5} } -func (x *CellarV2_2_RemovePosition) GetInDebtArray() bool { +func (x *CellarV2Governance_SetRebalanceDeviation) GetNewDeviation() string { if x != nil { - return x.InDebtArray + return x.NewDeviation } - return false + return "" } -// -// Allows callers to remove adaptors from this cellar's catalogue -// -// Represents function `removeAdaptorFromCatalogue(address adaptor)` -type CellarV2_2_RemoveAdaptorFromCatalogue struct { +// The function you wish to execute on the target cellar +type CellarV2_2_FunctionCall struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` + // Types that are assignable to Function: + // *CellarV2_2_FunctionCall_AddPosition + // *CellarV2_2_FunctionCall_CallOnAdaptor + // *CellarV2_2_FunctionCall_RemovePosition + // *CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue + // *CellarV2_2_FunctionCall_RemovePositionFromCatalogue + // *CellarV2_2_FunctionCall_SetHoldingPosition + // *CellarV2_2_FunctionCall_SetStrategistPayoutAddress + // *CellarV2_2_FunctionCall_SwapPositions + // *CellarV2_2_FunctionCall_AddAdaptorToCatalogue + // *CellarV2_2_FunctionCall_AddPositionToCatalogue + // *CellarV2_2_FunctionCall_SetRebalanceDeviation + // *CellarV2_2_FunctionCall_SetShareLockPeriod + // *CellarV2_2_FunctionCall_SetStrategistPlatformCut + // *CellarV2_2_FunctionCall_InitiateShutdown + // *CellarV2_2_FunctionCall_LiftShutdown + // *CellarV2_2_FunctionCall_CachePriceRouter + Function isCellarV2_2_FunctionCall_Function `protobuf_oneof:"function"` } -func (x *CellarV2_2_RemoveAdaptorFromCatalogue) Reset() { - *x = CellarV2_2_RemoveAdaptorFromCatalogue{} +func (x *CellarV2_2_FunctionCall) Reset() { + *x = CellarV2_2_FunctionCall{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[24] + mi := &file_cellar_v2_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_RemoveAdaptorFromCatalogue) String() string { +func (x *CellarV2_2_FunctionCall) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_RemoveAdaptorFromCatalogue) ProtoMessage() {} +func (*CellarV2_2_FunctionCall) ProtoMessage() {} -func (x *CellarV2_2_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[24] +func (x *CellarV2_2_FunctionCall) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2565,99 +2585,282 @@ func (x *CellarV2_2_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_RemoveAdaptorFromCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_2_RemoveAdaptorFromCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 4} +// Deprecated: Use CellarV2_2_FunctionCall.ProtoReflect.Descriptor instead. +func (*CellarV2_2_FunctionCall) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 0} } -func (x *CellarV2_2_RemoveAdaptorFromCatalogue) GetAdaptor() string { - if x != nil { - return x.Adaptor +func (m *CellarV2_2_FunctionCall) GetFunction() isCellarV2_2_FunctionCall_Function { + if m != nil { + return m.Function } - return "" + return nil } -// -// Allows caller to remove positions from this cellar's catalogue -// -// Represents function `removePositionFromCatalogue(uint32 positionId)` -type CellarV2_2_RemovePositionFromCatalogue struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +func (x *CellarV2_2_FunctionCall) GetAddPosition() *CellarV2_2_AddPosition { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_AddPosition); ok { + return x.AddPosition + } + return nil } -func (x *CellarV2_2_RemovePositionFromCatalogue) Reset() { - *x = CellarV2_2_RemovePositionFromCatalogue{} - if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[25] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) +func (x *CellarV2_2_FunctionCall) GetCallOnAdaptor() *CellarV2_2_CallOnAdaptor { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_CallOnAdaptor); ok { + return x.CallOnAdaptor } + return nil } -func (x *CellarV2_2_RemovePositionFromCatalogue) String() string { - return protoimpl.X.MessageStringOf(x) +func (x *CellarV2_2_FunctionCall) GetRemovePosition() *CellarV2_2_RemovePosition { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemovePosition); ok { + return x.RemovePosition + } + return nil } -func (*CellarV2_2_RemovePositionFromCatalogue) ProtoMessage() {} - -func (x *CellarV2_2_RemovePositionFromCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[25] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms +func (x *CellarV2_2_FunctionCall) GetRemoveAdaptorFromCatalogue() *CellarV2_2_RemoveAdaptorFromCatalogue { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue); ok { + return x.RemoveAdaptorFromCatalogue } - return mi.MessageOf(x) + return nil } -// Deprecated: Use CellarV2_2_RemovePositionFromCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_2_RemovePositionFromCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 5} +func (x *CellarV2_2_FunctionCall) GetRemovePositionFromCatalogue() *CellarV2_2_RemovePositionFromCatalogue { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_RemovePositionFromCatalogue); ok { + return x.RemovePositionFromCatalogue + } + return nil } -func (x *CellarV2_2_RemovePositionFromCatalogue) GetPositionId() uint32 { - if x != nil { - return x.PositionId +func (x *CellarV2_2_FunctionCall) GetSetHoldingPosition() *CellarV2_2_SetHoldingPosition { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetHoldingPosition); ok { + return x.SetHoldingPosition } - return 0 + return nil +} + +func (x *CellarV2_2_FunctionCall) GetSetStrategistPayoutAddress() *CellarV2_2_SetStrategistPayoutAddress { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetStrategistPayoutAddress); ok { + return x.SetStrategistPayoutAddress + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetSwapPositions() *CellarV2_2_SwapPositions { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SwapPositions); ok { + return x.SwapPositions + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetAddAdaptorToCatalogue() *CellarV2_2_AddAdaptorToCatalogue { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_AddAdaptorToCatalogue); ok { + return x.AddAdaptorToCatalogue + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetAddPositionToCatalogue() *CellarV2_2_AddPositionToCatalogue { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_AddPositionToCatalogue); ok { + return x.AddPositionToCatalogue + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetSetRebalanceDeviation() *CellarV2_2_SetRebalanceDeviation { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetRebalanceDeviation); ok { + return x.SetRebalanceDeviation + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetSetShareLockPeriod() *CellarV2_2_SetShareLockPeriod { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetShareLockPeriod); ok { + return x.SetShareLockPeriod + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetSetStrategistPlatformCut() *CellarV2_2_SetStrategistPlatformCut { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_SetStrategistPlatformCut); ok { + return x.SetStrategistPlatformCut + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetInitiateShutdown() *CellarV2_2_InitiateShutdown { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_InitiateShutdown); ok { + return x.InitiateShutdown + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetLiftShutdown() *CellarV2_2_LiftShutdown { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_LiftShutdown); ok { + return x.LiftShutdown + } + return nil +} + +func (x *CellarV2_2_FunctionCall) GetCachePriceRouter() *CellarV2_2_CachePriceRouter { + if x, ok := x.GetFunction().(*CellarV2_2_FunctionCall_CachePriceRouter); ok { + return x.CachePriceRouter + } + return nil +} + +type isCellarV2_2_FunctionCall_Function interface { + isCellarV2_2_FunctionCall_Function() +} + +type CellarV2_2_FunctionCall_AddPosition struct { + // Represents function `addPosition(uint256 index, address position)` + AddPosition *CellarV2_2_AddPosition `protobuf:"bytes,1,opt,name=add_position,json=addPosition,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_CallOnAdaptor struct { + // Represents function `callOnAdaptor(AdaptorCall[] memory data)` + CallOnAdaptor *CellarV2_2_CallOnAdaptor `protobuf:"bytes,2,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_RemovePosition struct { + // Represents function `removePosition(uint256 index, bool inDebtArray)` + RemovePosition *CellarV2_2_RemovePosition `protobuf:"bytes,3,opt,name=remove_position,json=removePosition,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue struct { + // Represents function `removeAdaptorFromCatalogue(address adaptor)` + RemoveAdaptorFromCatalogue *CellarV2_2_RemoveAdaptorFromCatalogue `protobuf:"bytes,4,opt,name=remove_adaptor_from_catalogue,json=removeAdaptorFromCatalogue,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_RemovePositionFromCatalogue struct { + // Represents function `removePositionFromCatalogue(uint32 positionId)` + RemovePositionFromCatalogue *CellarV2_2_RemovePositionFromCatalogue `protobuf:"bytes,5,opt,name=remove_position_from_catalogue,json=removePositionFromCatalogue,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SetHoldingPosition struct { + // Represents function `setHoldingPosition(uint32 position_id)` + SetHoldingPosition *CellarV2_2_SetHoldingPosition `protobuf:"bytes,6,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SetStrategistPayoutAddress struct { + // Represents function `setStrategistPayoutAddress(address payout)` + SetStrategistPayoutAddress *CellarV2_2_SetStrategistPayoutAddress `protobuf:"bytes,7,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SwapPositions struct { + // Represents function `swapPositions(uint256 index1, uint256 index2)` + SwapPositions *CellarV2_2_SwapPositions `protobuf:"bytes,8,opt,name=swap_positions,json=swapPositions,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_AddAdaptorToCatalogue struct { + // Represents function `addAdaptorToCatalogue(address adaptor)` + AddAdaptorToCatalogue *CellarV2_2_AddAdaptorToCatalogue `protobuf:"bytes,9,opt,name=add_adaptor_to_catalogue,json=addAdaptorToCatalogue,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_AddPositionToCatalogue struct { + // Represents function `addPositionToCatalogue(uint32 positionId)` + AddPositionToCatalogue *CellarV2_2_AddPositionToCatalogue `protobuf:"bytes,10,opt,name=add_position_to_catalogue,json=addPositionToCatalogue,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SetRebalanceDeviation struct { + // Represents function `setRebalanceDeviation(uint265)` + SetRebalanceDeviation *CellarV2_2_SetRebalanceDeviation `protobuf:"bytes,11,opt,name=set_rebalance_deviation,json=setRebalanceDeviation,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SetShareLockPeriod struct { + // Represents function `setShareLockPeriod(uint256 newLock)` + SetShareLockPeriod *CellarV2_2_SetShareLockPeriod `protobuf:"bytes,12,opt,name=set_share_lock_period,json=setShareLockPeriod,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_SetStrategistPlatformCut struct { + // Represents function `setStrategistPlatformCut(uint64 cut)` + SetStrategistPlatformCut *CellarV2_2_SetStrategistPlatformCut `protobuf:"bytes,13,opt,name=set_strategist_platform_cut,json=setStrategistPlatformCut,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_InitiateShutdown struct { + // Represents function `initiateShutdown()` + InitiateShutdown *CellarV2_2_InitiateShutdown `protobuf:"bytes,14,opt,name=initiate_shutdown,json=initiateShutdown,proto3,oneof"` +} + +type CellarV2_2_FunctionCall_LiftShutdown struct { + // Represents function `liftShutdown()` + LiftShutdown *CellarV2_2_LiftShutdown `protobuf:"bytes,15,opt,name=lift_shutdown,json=liftShutdown,proto3,oneof"` } +type CellarV2_2_FunctionCall_CachePriceRouter struct { + // Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + CachePriceRouter *CellarV2_2_CachePriceRouter `protobuf:"bytes,16,opt,name=cache_price_router,json=cachePriceRouter,proto3,oneof"` +} + +func (*CellarV2_2_FunctionCall_AddPosition) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_CallOnAdaptor) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_RemovePosition) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_RemoveAdaptorFromCatalogue) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_RemovePositionFromCatalogue) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SetHoldingPosition) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SetStrategistPayoutAddress) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SwapPositions) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_AddAdaptorToCatalogue) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_AddPositionToCatalogue) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SetRebalanceDeviation) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SetShareLockPeriod) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_SetStrategistPlatformCut) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_InitiateShutdown) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_LiftShutdown) isCellarV2_2_FunctionCall_Function() {} + +func (*CellarV2_2_FunctionCall_CachePriceRouter) isCellarV2_2_FunctionCall_Function() {} + // -// Set the holding position used of the cellar. +// Insert a trusted position to the list of positions used by the cellar at a given index. // -// Represents function `setHoldingIndex(uint8 index)` -type CellarV2_2_SetHoldingPosition struct { +// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` +type CellarV2_2_AddPosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // ID (index) of the new holding position to use - PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // Index at which to add the position + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // The position's ID in the cellar registry + PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // Data used to configure how the position behaves + ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` + // Whether to add position in the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_2_SetHoldingPosition) Reset() { - *x = CellarV2_2_SetHoldingPosition{} +func (x *CellarV2_2_AddPosition) Reset() { + *x = CellarV2_2_AddPosition{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[26] + mi := &file_cellar_v2_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_SetHoldingPosition) String() string { +func (x *CellarV2_2_AddPosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_SetHoldingPosition) ProtoMessage() {} +func (*CellarV2_2_AddPosition) ProtoMessage() {} -func (x *CellarV2_2_SetHoldingPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[26] +func (x *CellarV2_2_AddPosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2668,47 +2871,68 @@ func (x *CellarV2_2_SetHoldingPosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_SetHoldingPosition.ProtoReflect.Descriptor instead. -func (*CellarV2_2_SetHoldingPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 6} +// Deprecated: Use CellarV2_2_AddPosition.ProtoReflect.Descriptor instead. +func (*CellarV2_2_AddPosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 1} } -func (x *CellarV2_2_SetHoldingPosition) GetPositionId() uint32 { +func (x *CellarV2_2_AddPosition) GetIndex() uint32 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *CellarV2_2_AddPosition) GetPositionId() uint32 { if x != nil { return x.PositionId } return 0 } +func (x *CellarV2_2_AddPosition) GetConfigurationData() []byte { + if x != nil { + return x.ConfigurationData + } + return nil +} + +func (x *CellarV2_2_AddPosition) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false +} + // -// Sets the Strategists payout address. +// Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. // -// Represents function `setStrategistPayoutAddress(address payout)` -type CellarV2_2_SetStrategistPayoutAddress struct { +// Represents function `callOnAdaptor(AdaptorCall[] memory data)` +type CellarV2_2_CallOnAdaptor struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Payout string `protobuf:"bytes,1,opt,name=payout,proto3" json:"payout,omitempty"` + Data []*AdaptorCall `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` } -func (x *CellarV2_2_SetStrategistPayoutAddress) Reset() { - *x = CellarV2_2_SetStrategistPayoutAddress{} +func (x *CellarV2_2_CallOnAdaptor) Reset() { + *x = CellarV2_2_CallOnAdaptor{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[27] + mi := &file_cellar_v2_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_SetStrategistPayoutAddress) String() string { +func (x *CellarV2_2_CallOnAdaptor) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_SetStrategistPayoutAddress) ProtoMessage() {} +func (*CellarV2_2_CallOnAdaptor) ProtoMessage() {} -func (x *CellarV2_2_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[27] +func (x *CellarV2_2_CallOnAdaptor) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2719,52 +2943,50 @@ func (x *CellarV2_2_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_SetStrategistPayoutAddress.ProtoReflect.Descriptor instead. -func (*CellarV2_2_SetStrategistPayoutAddress) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 7} +// Deprecated: Use CellarV2_2_CallOnAdaptor.ProtoReflect.Descriptor instead. +func (*CellarV2_2_CallOnAdaptor) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 2} } -func (x *CellarV2_2_SetStrategistPayoutAddress) GetPayout() string { +func (x *CellarV2_2_CallOnAdaptor) GetData() []*AdaptorCall { if x != nil { - return x.Payout + return x.Data } - return "" + return nil } // -// Swap the positions at two given indeces. +// Remove the position at a given index from the list of positions used by the cellar. // -// Represents function `swapPositions(uint32 index1, uint32 index2)` -type CellarV2_2_SwapPositions struct { +// Represents function `removePosition(uint32 index, bool inDebtArray)` +type CellarV2_2_RemovePosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Index of the first position - Index_1 uint32 `protobuf:"varint,1,opt,name=index_1,json=index1,proto3" json:"index_1,omitempty"` - // Index of the second position - Index_2 uint32 `protobuf:"varint,2,opt,name=index_2,json=index2,proto3" json:"index_2,omitempty"` - // Whether to switch positions in the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + // Index at which to remove the position + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // Whether to remove position from the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,2,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_2_SwapPositions) Reset() { - *x = CellarV2_2_SwapPositions{} +func (x *CellarV2_2_RemovePosition) Reset() { + *x = CellarV2_2_RemovePosition{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[28] + mi := &file_cellar_v2_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2_SwapPositions) String() string { +func (x *CellarV2_2_RemovePosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2_SwapPositions) ProtoMessage() {} +func (*CellarV2_2_RemovePosition) ProtoMessage() {} -func (x *CellarV2_2_SwapPositions) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[28] +func (x *CellarV2_2_RemovePosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2775,26 +2997,19 @@ func (x *CellarV2_2_SwapPositions) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2_SwapPositions.ProtoReflect.Descriptor instead. -func (*CellarV2_2_SwapPositions) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 8} -} - -func (x *CellarV2_2_SwapPositions) GetIndex_1() uint32 { - if x != nil { - return x.Index_1 - } - return 0 +// Deprecated: Use CellarV2_2_RemovePosition.ProtoReflect.Descriptor instead. +func (*CellarV2_2_RemovePosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 3} } -func (x *CellarV2_2_SwapPositions) GetIndex_2() uint32 { +func (x *CellarV2_2_RemovePosition) GetIndex() uint32 { if x != nil { - return x.Index_2 + return x.Index } return 0 } -func (x *CellarV2_2_SwapPositions) GetInDebtArray() bool { +func (x *CellarV2_2_RemovePosition) GetInDebtArray() bool { if x != nil { return x.InDebtArray } @@ -2802,61 +3017,10 @@ func (x *CellarV2_2_SwapPositions) GetInDebtArray() bool { } // -// Allows caller to call multiple functions in a single TX. -// -// Represents function `multicall(bytes[] data)` -type CellarV2_2_Multicall struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache - unknownFields protoimpl.UnknownFields - - FunctionCalls []*CellarV2_2_FunctionCall `protobuf:"bytes,1,rep,name=function_calls,json=functionCalls,proto3" json:"function_calls,omitempty"` -} - -func (x *CellarV2_2_Multicall) Reset() { - *x = CellarV2_2_Multicall{} - if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) - } -} - -func (x *CellarV2_2_Multicall) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*CellarV2_2_Multicall) ProtoMessage() {} - -func (x *CellarV2_2_Multicall) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[29] - if protoimpl.UnsafeEnabled && x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use CellarV2_2_Multicall.ProtoReflect.Descriptor instead. -func (*CellarV2_2_Multicall) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{2, 9} -} - -func (x *CellarV2_2_Multicall) GetFunctionCalls() []*CellarV2_2_FunctionCall { - if x != nil { - return x.FunctionCalls - } - return nil -} - -// -// Allows the owner to add an adaptor to the Cellar's adaptor catalogue +// Allows callers to remove adaptors from this cellar's catalogue // -// Represents function `addAdaptorToCatalogue(address adaptor)` -type CellarV2_2Governance_AddAdaptorToCatalogue struct { +// Represents function `removeAdaptorFromCatalogue(address adaptor)` +type CellarV2_2_RemoveAdaptorFromCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -2864,8 +3028,8 @@ type CellarV2_2Governance_AddAdaptorToCatalogue struct { Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2_2Governance_AddAdaptorToCatalogue) Reset() { - *x = CellarV2_2Governance_AddAdaptorToCatalogue{} +func (x *CellarV2_2_RemoveAdaptorFromCatalogue) Reset() { + *x = CellarV2_2_RemoveAdaptorFromCatalogue{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2873,13 +3037,13 @@ func (x *CellarV2_2Governance_AddAdaptorToCatalogue) Reset() { } } -func (x *CellarV2_2Governance_AddAdaptorToCatalogue) String() string { +func (x *CellarV2_2_RemoveAdaptorFromCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_AddAdaptorToCatalogue) ProtoMessage() {} +func (*CellarV2_2_RemoveAdaptorFromCatalogue) ProtoMessage() {} -func (x *CellarV2_2Governance_AddAdaptorToCatalogue) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2891,12 +3055,12 @@ func (x *CellarV2_2Governance_AddAdaptorToCatalogue) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_AddAdaptorToCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_AddAdaptorToCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 0} +// Deprecated: Use CellarV2_2_RemoveAdaptorFromCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2_RemoveAdaptorFromCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 4} } -func (x *CellarV2_2Governance_AddAdaptorToCatalogue) GetAdaptor() string { +func (x *CellarV2_2_RemoveAdaptorFromCatalogue) GetAdaptor() string { if x != nil { return x.Adaptor } @@ -2904,10 +3068,10 @@ func (x *CellarV2_2Governance_AddAdaptorToCatalogue) GetAdaptor() string { } // -// Allows the owner to add a position to the Cellar's position catalogue +// Allows caller to remove positions from this cellar's catalogue // -// Represents function `addPositionToCatalogue(uint32 positionId)` -type CellarV2_2Governance_AddPositionToCatalogue struct { +// Represents function `removePositionFromCatalogue(uint32 positionId)` +type CellarV2_2_RemovePositionFromCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -2915,8 +3079,8 @@ type CellarV2_2Governance_AddPositionToCatalogue struct { PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (x *CellarV2_2Governance_AddPositionToCatalogue) Reset() { - *x = CellarV2_2Governance_AddPositionToCatalogue{} +func (x *CellarV2_2_RemovePositionFromCatalogue) Reset() { + *x = CellarV2_2_RemovePositionFromCatalogue{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2924,13 +3088,13 @@ func (x *CellarV2_2Governance_AddPositionToCatalogue) Reset() { } } -func (x *CellarV2_2Governance_AddPositionToCatalogue) String() string { +func (x *CellarV2_2_RemovePositionFromCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_AddPositionToCatalogue) ProtoMessage() {} +func (*CellarV2_2_RemovePositionFromCatalogue) ProtoMessage() {} -func (x *CellarV2_2Governance_AddPositionToCatalogue) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_RemovePositionFromCatalogue) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2942,12 +3106,12 @@ func (x *CellarV2_2Governance_AddPositionToCatalogue) ProtoReflect() protoreflec return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_AddPositionToCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_AddPositionToCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 1} +// Deprecated: Use CellarV2_2_RemovePositionFromCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2_RemovePositionFromCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 5} } -func (x *CellarV2_2Governance_AddPositionToCatalogue) GetPositionId() uint32 { +func (x *CellarV2_2_RemovePositionFromCatalogue) GetPositionId() uint32 { if x != nil { return x.PositionId } @@ -2955,19 +3119,20 @@ func (x *CellarV2_2Governance_AddPositionToCatalogue) GetPositionId() uint32 { } // -// Allows share lock period to be updated. +// Set the holding position used of the cellar. // -// Represents function `setShareLockPeriod()` -type CellarV2_2Governance_SetShareLockPeriod struct { +// Represents function `setHoldingIndex(uint8 index)` +type CellarV2_2_SetHoldingPosition struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - NewLock string `protobuf:"bytes,1,opt,name=new_lock,json=newLock,proto3" json:"new_lock,omitempty"` + // ID (index) of the new holding position to use + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (x *CellarV2_2Governance_SetShareLockPeriod) Reset() { - *x = CellarV2_2Governance_SetShareLockPeriod{} +func (x *CellarV2_2_SetHoldingPosition) Reset() { + *x = CellarV2_2_SetHoldingPosition{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2975,13 +3140,13 @@ func (x *CellarV2_2Governance_SetShareLockPeriod) Reset() { } } -func (x *CellarV2_2Governance_SetShareLockPeriod) String() string { +func (x *CellarV2_2_SetHoldingPosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_SetShareLockPeriod) ProtoMessage() {} +func (*CellarV2_2_SetHoldingPosition) ProtoMessage() {} -func (x *CellarV2_2Governance_SetShareLockPeriod) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_SetHoldingPosition) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2993,33 +3158,32 @@ func (x *CellarV2_2Governance_SetShareLockPeriod) ProtoReflect() protoreflect.Me return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_SetShareLockPeriod.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_SetShareLockPeriod) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 2} +// Deprecated: Use CellarV2_2_SetHoldingPosition.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SetHoldingPosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 6} } -func (x *CellarV2_2Governance_SetShareLockPeriod) GetNewLock() string { +func (x *CellarV2_2_SetHoldingPosition) GetPositionId() uint32 { if x != nil { - return x.NewLock + return x.PositionId } - return "" + return 0 } // -// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate -// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. +// Sets the Strategists payout address. // -// Represents function `setRebalanceDeviation(uint256)` -type CellarV2_2Governance_SetRebalanceDeviation struct { +// Represents function `setStrategistPayoutAddress(address payout)` +type CellarV2_2_SetStrategistPayoutAddress struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` + Payout string `protobuf:"bytes,1,opt,name=payout,proto3" json:"payout,omitempty"` } -func (x *CellarV2_2Governance_SetRebalanceDeviation) Reset() { - *x = CellarV2_2Governance_SetRebalanceDeviation{} +func (x *CellarV2_2_SetStrategistPayoutAddress) Reset() { + *x = CellarV2_2_SetStrategistPayoutAddress{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3027,13 +3191,13 @@ func (x *CellarV2_2Governance_SetRebalanceDeviation) Reset() { } } -func (x *CellarV2_2Governance_SetRebalanceDeviation) String() string { +func (x *CellarV2_2_SetStrategistPayoutAddress) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_SetRebalanceDeviation) ProtoMessage() {} +func (*CellarV2_2_SetStrategistPayoutAddress) ProtoMessage() {} -func (x *CellarV2_2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3045,30 +3209,37 @@ func (x *CellarV2_2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_SetRebalanceDeviation.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_SetRebalanceDeviation) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 3} +// Deprecated: Use CellarV2_2_SetStrategistPayoutAddress.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SetStrategistPayoutAddress) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 7} } -func (x *CellarV2_2Governance_SetRebalanceDeviation) GetNewDeviation() string { +func (x *CellarV2_2_SetStrategistPayoutAddress) GetPayout() string { if x != nil { - return x.NewDeviation + return x.Payout } return "" } // -// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. +// Swap the positions at two given indeces. // -// Represents function `initiateShutdown()` -type CellarV2_2Governance_InitiateShutdown struct { +// Represents function `swapPositions(uint32 index1, uint32 index2)` +type CellarV2_2_SwapPositions struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + // Index of the first position + Index_1 uint32 `protobuf:"varint,1,opt,name=index_1,json=index1,proto3" json:"index_1,omitempty"` + // Index of the second position + Index_2 uint32 `protobuf:"varint,2,opt,name=index_2,json=index2,proto3" json:"index_2,omitempty"` + // Whether to switch positions in the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_2Governance_InitiateShutdown) Reset() { - *x = CellarV2_2Governance_InitiateShutdown{} +func (x *CellarV2_2_SwapPositions) Reset() { + *x = CellarV2_2_SwapPositions{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3076,13 +3247,13 @@ func (x *CellarV2_2Governance_InitiateShutdown) Reset() { } } -func (x *CellarV2_2Governance_InitiateShutdown) String() string { +func (x *CellarV2_2_SwapPositions) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_InitiateShutdown) ProtoMessage() {} +func (*CellarV2_2_SwapPositions) ProtoMessage() {} -func (x *CellarV2_2Governance_InitiateShutdown) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_SwapPositions) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3094,26 +3265,46 @@ func (x *CellarV2_2Governance_InitiateShutdown) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_InitiateShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_InitiateShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 4} +// Deprecated: Use CellarV2_2_SwapPositions.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SwapPositions) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 8} } -// -// Allows strategist to set the platform cut for the cellar. -// -// Represents function `setStrategistPlatformCut(uint64 cut)` -type CellarV2_2Governance_SetStrategistPlatformCut struct { - state protoimpl.MessageState - sizeCache protoimpl.SizeCache +func (x *CellarV2_2_SwapPositions) GetIndex_1() uint32 { + if x != nil { + return x.Index_1 + } + return 0 +} + +func (x *CellarV2_2_SwapPositions) GetIndex_2() uint32 { + if x != nil { + return x.Index_2 + } + return 0 +} + +func (x *CellarV2_2_SwapPositions) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false +} + +// +// Allows caller to call multiple functions in a single TX. +// +// Represents function `multicall(bytes[] data)` +type CellarV2_2_Multicall struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // The new strategist platform cut - NewCut uint64 `protobuf:"varint,1,opt,name=new_cut,json=newCut,proto3" json:"new_cut,omitempty"` + FunctionCalls []*CellarV2_2_FunctionCall `protobuf:"bytes,1,rep,name=function_calls,json=functionCalls,proto3" json:"function_calls,omitempty"` } -func (x *CellarV2_2Governance_SetStrategistPlatformCut) Reset() { - *x = CellarV2_2Governance_SetStrategistPlatformCut{} +func (x *CellarV2_2_Multicall) Reset() { + *x = CellarV2_2_Multicall{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3121,13 +3312,13 @@ func (x *CellarV2_2Governance_SetStrategistPlatformCut) Reset() { } } -func (x *CellarV2_2Governance_SetStrategistPlatformCut) String() string { +func (x *CellarV2_2_Multicall) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_SetStrategistPlatformCut) ProtoMessage() {} +func (*CellarV2_2_Multicall) ProtoMessage() {} -func (x *CellarV2_2Governance_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_Multicall) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3139,30 +3330,32 @@ func (x *CellarV2_2Governance_SetStrategistPlatformCut) ProtoReflect() protorefl return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 5} +// Deprecated: Use CellarV2_2_Multicall.ProtoReflect.Descriptor instead. +func (*CellarV2_2_Multicall) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 9} } -func (x *CellarV2_2Governance_SetStrategistPlatformCut) GetNewCut() uint64 { +func (x *CellarV2_2_Multicall) GetFunctionCalls() []*CellarV2_2_FunctionCall { if x != nil { - return x.NewCut + return x.FunctionCalls } - return 0 + return nil } // -// Allows the owner to restart a shut down Cellar +// Allows the owner to add an adaptor to the Cellar's adaptor catalogue // -// Represents function `liftShutdown()` -type CellarV2_2Governance_LiftShutdown struct { +// Represents function `addAdaptorToCatalogue(address adaptor)` +type CellarV2_2_AddAdaptorToCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2_2Governance_LiftShutdown) Reset() { - *x = CellarV2_2Governance_LiftShutdown{} +func (x *CellarV2_2_AddAdaptorToCatalogue) Reset() { + *x = CellarV2_2_AddAdaptorToCatalogue{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3170,13 +3363,13 @@ func (x *CellarV2_2Governance_LiftShutdown) Reset() { } } -func (x *CellarV2_2Governance_LiftShutdown) String() string { +func (x *CellarV2_2_AddAdaptorToCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_LiftShutdown) ProtoMessage() {} +func (*CellarV2_2_AddAdaptorToCatalogue) ProtoMessage() {} -func (x *CellarV2_2Governance_LiftShutdown) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_AddAdaptorToCatalogue) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3188,27 +3381,32 @@ func (x *CellarV2_2Governance_LiftShutdown) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_LiftShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_LiftShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 6} +// Deprecated: Use CellarV2_2_AddAdaptorToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2_AddAdaptorToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 10} +} + +func (x *CellarV2_2_AddAdaptorToCatalogue) GetAdaptor() string { + if x != nil { + return x.Adaptor + } + return "" } // -// Allows caller to force a position out of the cellar +// Allows the owner to add a position to the Cellar's position catalogue // -// Represents function `forcePositionOut(uint32 index, uint32 positionId, bool inDebtArray)` -type CellarV2_2Governance_ForcePositionOut struct { +// Represents function `addPositionToCatalogue(uint32 positionId)` +type CellarV2_2_AddPositionToCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (x *CellarV2_2Governance_ForcePositionOut) Reset() { - *x = CellarV2_2Governance_ForcePositionOut{} +func (x *CellarV2_2_AddPositionToCatalogue) Reset() { + *x = CellarV2_2_AddPositionToCatalogue{} if protoimpl.UnsafeEnabled { mi := &file_cellar_v2_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3216,13 +3414,13 @@ func (x *CellarV2_2Governance_ForcePositionOut) Reset() { } } -func (x *CellarV2_2Governance_ForcePositionOut) String() string { +func (x *CellarV2_2_AddPositionToCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_ForcePositionOut) ProtoMessage() {} +func (*CellarV2_2_AddPositionToCatalogue) ProtoMessage() {} -func (x *CellarV2_2Governance_ForcePositionOut) ProtoReflect() protoreflect.Message { +func (x *CellarV2_2_AddPositionToCatalogue) ProtoReflect() protoreflect.Message { mi := &file_cellar_v2_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3234,61 +3432,99 @@ func (x *CellarV2_2Governance_ForcePositionOut) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_ForcePositionOut.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_ForcePositionOut) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 7} +// Deprecated: Use CellarV2_2_AddPositionToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2_AddPositionToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 11} } -func (x *CellarV2_2Governance_ForcePositionOut) GetIndex() uint32 { +func (x *CellarV2_2_AddPositionToCatalogue) GetPositionId() uint32 { if x != nil { - return x.Index + return x.PositionId } return 0 } -func (x *CellarV2_2Governance_ForcePositionOut) GetPositionId() uint32 { - if x != nil { - return x.PositionId +// +// Allows share lock period to be updated. +// +// Represents function `setShareLockPeriod()` +type CellarV2_2_SetShareLockPeriod struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NewLock string `protobuf:"bytes,1,opt,name=new_lock,json=newLock,proto3" json:"new_lock,omitempty"` +} + +func (x *CellarV2_2_SetShareLockPeriod) Reset() { + *x = CellarV2_2_SetShareLockPeriod{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[38] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return 0 } -func (x *CellarV2_2Governance_ForcePositionOut) GetInDebtArray() bool { +func (x *CellarV2_2_SetShareLockPeriod) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2_SetShareLockPeriod) ProtoMessage() {} + +func (x *CellarV2_2_SetShareLockPeriod) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[38] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2_SetShareLockPeriod.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SetShareLockPeriod) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 12} +} + +func (x *CellarV2_2_SetShareLockPeriod) GetNewLock() string { if x != nil { - return x.InDebtArray + return x.NewLock } - return false + return "" } // -// Allows caller to toggle the ignorePause flag on the cellar +// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate +// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. // -// Represents function `toggleIgnorePause(bool ignore)` -type CellarV2_2Governance_ToggleIgnorePause struct { +// Represents function `setRebalanceDeviation(uint256)` +type CellarV2_2_SetRebalanceDeviation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Ignore bool `protobuf:"varint,1,opt,name=ignore,proto3" json:"ignore,omitempty"` + NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` } -func (x *CellarV2_2Governance_ToggleIgnorePause) Reset() { - *x = CellarV2_2Governance_ToggleIgnorePause{} +func (x *CellarV2_2_SetRebalanceDeviation) Reset() { + *x = CellarV2_2_SetRebalanceDeviation{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[38] + mi := &file_cellar_v2_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2Governance_ToggleIgnorePause) String() string { +func (x *CellarV2_2_SetRebalanceDeviation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_ToggleIgnorePause) ProtoMessage() {} +func (*CellarV2_2_SetRebalanceDeviation) ProtoMessage() {} -func (x *CellarV2_2Governance_ToggleIgnorePause) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[38] +func (x *CellarV2_2_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3299,52 +3535,1157 @@ func (x *CellarV2_2Governance_ToggleIgnorePause) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_ToggleIgnorePause.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_ToggleIgnorePause) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 8} +// Deprecated: Use CellarV2_2_SetRebalanceDeviation.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SetRebalanceDeviation) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 13} } -func (x *CellarV2_2Governance_ToggleIgnorePause) GetIgnore() bool { +func (x *CellarV2_2_SetRebalanceDeviation) GetNewDeviation() string { if x != nil { - return x.Ignore + return x.NewDeviation } - return false + return "" } // -// Updates the cellar to use the latest price router in the registry. +// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. // -// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` -type CellarV2_2Governance_CachePriceRouter struct { +// Represents function `initiateShutdown()` +type CellarV2_2_InitiateShutdown struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields +} - // Whether to check the total assets of the cellar - CheckTotalAssets bool `protobuf:"varint,1,opt,name=check_total_assets,json=checkTotalAssets,proto3" json:"check_total_assets,omitempty"` - // The allowable range of the cellar's total assets to deviate between old and new routers - AllowableRange uint32 `protobuf:"varint,2,opt,name=allowable_range,json=allowableRange,proto3" json:"allowable_range,omitempty"` - // The expected price router address - ExpectedPriceRouter string `protobuf:"bytes,3,opt,name=expected_price_router,json=expectedPriceRouter,proto3" json:"expected_price_router,omitempty"` +func (x *CellarV2_2_InitiateShutdown) Reset() { + *x = CellarV2_2_InitiateShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } } -func (x *CellarV2_2Governance_CachePriceRouter) Reset() { - *x = CellarV2_2Governance_CachePriceRouter{} +func (x *CellarV2_2_InitiateShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2_InitiateShutdown) ProtoMessage() {} + +func (x *CellarV2_2_InitiateShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[40] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2_InitiateShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_2_InitiateShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 14} +} + +// +// Allows strategist to set the platform cut for the cellar. +// +// Represents function `setStrategistPlatformCut(uint64 cut)` +type CellarV2_2_SetStrategistPlatformCut struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The new strategist platform cut + NewCut uint64 `protobuf:"varint,1,opt,name=new_cut,json=newCut,proto3" json:"new_cut,omitempty"` +} + +func (x *CellarV2_2_SetStrategistPlatformCut) Reset() { + *x = CellarV2_2_SetStrategistPlatformCut{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[39] + mi := &file_cellar_v2_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_2Governance_CachePriceRouter) String() string { +func (x *CellarV2_2_SetStrategistPlatformCut) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2_SetStrategistPlatformCut) ProtoMessage() {} + +func (x *CellarV2_2_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[41] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. +func (*CellarV2_2_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 15} +} + +func (x *CellarV2_2_SetStrategistPlatformCut) GetNewCut() uint64 { + if x != nil { + return x.NewCut + } + return 0 +} + +// +// Allows the owner to restart a shut down Cellar +// +// Represents function `liftShutdown()` +type CellarV2_2_LiftShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_2_LiftShutdown) Reset() { + *x = CellarV2_2_LiftShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[42] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2_LiftShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2_LiftShutdown) ProtoMessage() {} + +func (x *CellarV2_2_LiftShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[42] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2_LiftShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_2_LiftShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 16} +} + +// +// Updates the cellar to use the latest price router in the registry. +// +// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` +type CellarV2_2_CachePriceRouter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Whether to check the total assets of the cellar + CheckTotalAssets bool `protobuf:"varint,1,opt,name=check_total_assets,json=checkTotalAssets,proto3" json:"check_total_assets,omitempty"` + // The allowable range of the cellar's total assets to deviate between old and new routers + AllowableRange uint32 `protobuf:"varint,2,opt,name=allowable_range,json=allowableRange,proto3" json:"allowable_range,omitempty"` + // The expected price router address + ExpectedPriceRouter string `protobuf:"bytes,3,opt,name=expected_price_router,json=expectedPriceRouter,proto3" json:"expected_price_router,omitempty"` +} + +func (x *CellarV2_2_CachePriceRouter) Reset() { + *x = CellarV2_2_CachePriceRouter{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[43] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2_CachePriceRouter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2_CachePriceRouter) ProtoMessage() {} + +func (x *CellarV2_2_CachePriceRouter) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[43] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2_CachePriceRouter.ProtoReflect.Descriptor instead. +func (*CellarV2_2_CachePriceRouter) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{2, 17} +} + +func (x *CellarV2_2_CachePriceRouter) GetCheckTotalAssets() bool { + if x != nil { + return x.CheckTotalAssets + } + return false +} + +func (x *CellarV2_2_CachePriceRouter) GetAllowableRange() uint32 { + if x != nil { + return x.AllowableRange + } + return 0 +} + +func (x *CellarV2_2_CachePriceRouter) GetExpectedPriceRouter() string { + if x != nil { + return x.ExpectedPriceRouter + } + return "" +} + +// +// Allows the owner to add an adaptor to the Cellar's adaptor catalogue +// +// Represents function `addAdaptorToCatalogue(address adaptor)` +type CellarV2_2Governance_AddAdaptorToCatalogue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` +} + +func (x *CellarV2_2Governance_AddAdaptorToCatalogue) Reset() { + *x = CellarV2_2Governance_AddAdaptorToCatalogue{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[44] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_AddAdaptorToCatalogue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_AddAdaptorToCatalogue) ProtoMessage() {} + +func (x *CellarV2_2Governance_AddAdaptorToCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[44] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_AddAdaptorToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_AddAdaptorToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 0} +} + +func (x *CellarV2_2Governance_AddAdaptorToCatalogue) GetAdaptor() string { + if x != nil { + return x.Adaptor + } + return "" +} + +// +// Allows the owner to add a position to the Cellar's position catalogue +// +// Represents function `addPositionToCatalogue(uint32 positionId)` +type CellarV2_2Governance_AddPositionToCatalogue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` +} + +func (x *CellarV2_2Governance_AddPositionToCatalogue) Reset() { + *x = CellarV2_2Governance_AddPositionToCatalogue{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[45] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_AddPositionToCatalogue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_AddPositionToCatalogue) ProtoMessage() {} + +func (x *CellarV2_2Governance_AddPositionToCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[45] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_AddPositionToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_AddPositionToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 1} +} + +func (x *CellarV2_2Governance_AddPositionToCatalogue) GetPositionId() uint32 { + if x != nil { + return x.PositionId + } + return 0 +} + +// +// Allows share lock period to be updated. +// +// Represents function `setShareLockPeriod()` +type CellarV2_2Governance_SetShareLockPeriod struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NewLock string `protobuf:"bytes,1,opt,name=new_lock,json=newLock,proto3" json:"new_lock,omitempty"` +} + +func (x *CellarV2_2Governance_SetShareLockPeriod) Reset() { + *x = CellarV2_2Governance_SetShareLockPeriod{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[46] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_SetShareLockPeriod) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_SetShareLockPeriod) ProtoMessage() {} + +func (x *CellarV2_2Governance_SetShareLockPeriod) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[46] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_SetShareLockPeriod.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_SetShareLockPeriod) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 2} +} + +func (x *CellarV2_2Governance_SetShareLockPeriod) GetNewLock() string { + if x != nil { + return x.NewLock + } + return "" +} + +// +// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate +// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. +// +// Represents function `setRebalanceDeviation(uint256)` +type CellarV2_2Governance_SetRebalanceDeviation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` +} + +func (x *CellarV2_2Governance_SetRebalanceDeviation) Reset() { + *x = CellarV2_2Governance_SetRebalanceDeviation{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[47] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_SetRebalanceDeviation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_SetRebalanceDeviation) ProtoMessage() {} + +func (x *CellarV2_2Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[47] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_SetRebalanceDeviation.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_SetRebalanceDeviation) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 3} +} + +func (x *CellarV2_2Governance_SetRebalanceDeviation) GetNewDeviation() string { + if x != nil { + return x.NewDeviation + } + return "" +} + +// +// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. +// +// Represents function `initiateShutdown()` +type CellarV2_2Governance_InitiateShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_2Governance_InitiateShutdown) Reset() { + *x = CellarV2_2Governance_InitiateShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[48] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_InitiateShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_InitiateShutdown) ProtoMessage() {} + +func (x *CellarV2_2Governance_InitiateShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[48] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_InitiateShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_InitiateShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 4} +} + +// +// Allows strategist to set the platform cut for the cellar. +// +// Represents function `setStrategistPlatformCut(uint64 cut)` +type CellarV2_2Governance_SetStrategistPlatformCut struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The new strategist platform cut + NewCut uint64 `protobuf:"varint,1,opt,name=new_cut,json=newCut,proto3" json:"new_cut,omitempty"` +} + +func (x *CellarV2_2Governance_SetStrategistPlatformCut) Reset() { + *x = CellarV2_2Governance_SetStrategistPlatformCut{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[49] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_SetStrategistPlatformCut) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_SetStrategistPlatformCut) ProtoMessage() {} + +func (x *CellarV2_2Governance_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[49] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 5} +} + +func (x *CellarV2_2Governance_SetStrategistPlatformCut) GetNewCut() uint64 { + if x != nil { + return x.NewCut + } + return 0 +} + +// +// Allows the owner to restart a shut down Cellar +// +// Represents function `liftShutdown()` +type CellarV2_2Governance_LiftShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_2Governance_LiftShutdown) Reset() { + *x = CellarV2_2Governance_LiftShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[50] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_LiftShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_LiftShutdown) ProtoMessage() {} + +func (x *CellarV2_2Governance_LiftShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[50] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_LiftShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_LiftShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 6} +} + +// +// Allows caller to force a position out of the cellar +// +// Represents function `forcePositionOut(uint32 index, uint32 positionId, bool inDebtArray)` +type CellarV2_2Governance_ForcePositionOut struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` +} + +func (x *CellarV2_2Governance_ForcePositionOut) Reset() { + *x = CellarV2_2Governance_ForcePositionOut{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[51] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_ForcePositionOut) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_ForcePositionOut) ProtoMessage() {} + +func (x *CellarV2_2Governance_ForcePositionOut) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[51] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_ForcePositionOut.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_ForcePositionOut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 7} +} + +func (x *CellarV2_2Governance_ForcePositionOut) GetIndex() uint32 { + if x != nil { + return x.Index + } + return 0 +} + +func (x *CellarV2_2Governance_ForcePositionOut) GetPositionId() uint32 { + if x != nil { + return x.PositionId + } + return 0 +} + +func (x *CellarV2_2Governance_ForcePositionOut) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false +} + +// +// Allows caller to toggle the ignorePause flag on the cellar +// +// Represents function `toggleIgnorePause(bool ignore)` +type CellarV2_2Governance_ToggleIgnorePause struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ignore bool `protobuf:"varint,1,opt,name=ignore,proto3" json:"ignore,omitempty"` +} + +func (x *CellarV2_2Governance_ToggleIgnorePause) Reset() { + *x = CellarV2_2Governance_ToggleIgnorePause{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[52] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_ToggleIgnorePause) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_ToggleIgnorePause) ProtoMessage() {} + +func (x *CellarV2_2Governance_ToggleIgnorePause) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[52] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_ToggleIgnorePause.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_ToggleIgnorePause) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 8} +} + +func (x *CellarV2_2Governance_ToggleIgnorePause) GetIgnore() bool { + if x != nil { + return x.Ignore + } + return false +} + +// +// Updates the cellar to use the latest price router in the registry. +// +// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` +type CellarV2_2Governance_CachePriceRouter struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Whether to check the total assets of the cellar + CheckTotalAssets bool `protobuf:"varint,1,opt,name=check_total_assets,json=checkTotalAssets,proto3" json:"check_total_assets,omitempty"` + // The allowable range of the cellar's total assets to deviate between old and new routers + AllowableRange uint32 `protobuf:"varint,2,opt,name=allowable_range,json=allowableRange,proto3" json:"allowable_range,omitempty"` + // The expected price router address + ExpectedPriceRouter string `protobuf:"bytes,3,opt,name=expected_price_router,json=expectedPriceRouter,proto3" json:"expected_price_router,omitempty"` +} + +func (x *CellarV2_2Governance_CachePriceRouter) Reset() { + *x = CellarV2_2Governance_CachePriceRouter{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[53] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_2Governance_CachePriceRouter) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_2Governance_CachePriceRouter) ProtoMessage() {} + +func (x *CellarV2_2Governance_CachePriceRouter) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[53] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_2Governance_CachePriceRouter.ProtoReflect.Descriptor instead. +func (*CellarV2_2Governance_CachePriceRouter) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{3, 9} +} + +func (x *CellarV2_2Governance_CachePriceRouter) GetCheckTotalAssets() bool { + if x != nil { + return x.CheckTotalAssets + } + return false +} + +func (x *CellarV2_2Governance_CachePriceRouter) GetAllowableRange() uint32 { + if x != nil { + return x.AllowableRange + } + return 0 +} + +func (x *CellarV2_2Governance_CachePriceRouter) GetExpectedPriceRouter() string { + if x != nil { + return x.ExpectedPriceRouter + } + return "" +} + +// The function you wish to execute on the target cellar +type CellarV2_5_FunctionCall struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Function: + // *CellarV2_5_FunctionCall_AddPosition + // *CellarV2_5_FunctionCall_CallOnAdaptor + // *CellarV2_5_FunctionCall_RemovePosition + // *CellarV2_5_FunctionCall_SetHoldingPosition + // *CellarV2_5_FunctionCall_SetStrategistPayoutAddress + // *CellarV2_5_FunctionCall_SwapPositions + // *CellarV2_5_FunctionCall_SetShareLockPeriod + // *CellarV2_5_FunctionCall_InitiateShutdown + // *CellarV2_5_FunctionCall_LiftShutdown + // *CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue + // *CellarV2_5_FunctionCall_RemovePositionFromCatalogue + // *CellarV2_5_FunctionCall_DecreaseShareSupplyCap + // *CellarV2_5_FunctionCall_SetAlternativeAssetData + // *CellarV2_5_FunctionCall_DropAlternativeAssetData + // *CellarV2_5_FunctionCall_AddAdaptorToCatalogue + // *CellarV2_5_FunctionCall_AddPositionToCatalogue + // *CellarV2_5_FunctionCall_SetRebalanceDeviation + // *CellarV2_5_FunctionCall_SetStrategistPlatformCut + // *CellarV2_5_FunctionCall_SetSharePriceOracle + // *CellarV2_5_FunctionCall_IncreaseShareSupplyCap + // *CellarV2_5_FunctionCall_CachePriceRouter + Function isCellarV2_5_FunctionCall_Function `protobuf_oneof:"function"` +} + +func (x *CellarV2_5_FunctionCall) Reset() { + *x = CellarV2_5_FunctionCall{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[54] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_5_FunctionCall) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_5_FunctionCall) ProtoMessage() {} + +func (x *CellarV2_5_FunctionCall) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[54] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_5_FunctionCall.ProtoReflect.Descriptor instead. +func (*CellarV2_5_FunctionCall) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 0} +} + +func (m *CellarV2_5_FunctionCall) GetFunction() isCellarV2_5_FunctionCall_Function { + if m != nil { + return m.Function + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetAddPosition() *CellarV2_5_AddPosition { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_AddPosition); ok { + return x.AddPosition + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetCallOnAdaptor() *CellarV2_5_CallOnAdaptor { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_CallOnAdaptor); ok { + return x.CallOnAdaptor + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetRemovePosition() *CellarV2_5_RemovePosition { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemovePosition); ok { + return x.RemovePosition + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetHoldingPosition() *CellarV2_5_SetHoldingPosition { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetHoldingPosition); ok { + return x.SetHoldingPosition + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetStrategistPayoutAddress() *CellarV2_5_SetStrategistPayoutAddress { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetStrategistPayoutAddress); ok { + return x.SetStrategistPayoutAddress + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSwapPositions() *CellarV2_5_SwapPositions { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SwapPositions); ok { + return x.SwapPositions + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetShareLockPeriod() *CellarV2_5_SetShareLockPeriod { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetShareLockPeriod); ok { + return x.SetShareLockPeriod + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetInitiateShutdown() *CellarV2_5_InitiateShutdown { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_InitiateShutdown); ok { + return x.InitiateShutdown + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetLiftShutdown() *CellarV2_5_LiftShutdown { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_LiftShutdown); ok { + return x.LiftShutdown + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetRemoveAdaptorFromCatalogue() *CellarV2_5_RemoveAdaptorFromCatalogue { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue); ok { + return x.RemoveAdaptorFromCatalogue + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetRemovePositionFromCatalogue() *CellarV2_5_RemovePositionFromCatalogue { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemovePositionFromCatalogue); ok { + return x.RemovePositionFromCatalogue + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetDecreaseShareSupplyCap() *CellarV2_5_DecreaseShareSupplyCap { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_DecreaseShareSupplyCap); ok { + return x.DecreaseShareSupplyCap + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetAlternativeAssetData() *CellarV2_5_SetAlternativeAssetData { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetAlternativeAssetData); ok { + return x.SetAlternativeAssetData + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetDropAlternativeAssetData() *CellarV2_5_DropAlternativeAssetData { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_DropAlternativeAssetData); ok { + return x.DropAlternativeAssetData + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetAddAdaptorToCatalogue() *CellarV2_5_AddAdaptorToCatalogue { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_AddAdaptorToCatalogue); ok { + return x.AddAdaptorToCatalogue + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetAddPositionToCatalogue() *CellarV2_5_AddPositionToCatalogue { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_AddPositionToCatalogue); ok { + return x.AddPositionToCatalogue + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetRebalanceDeviation() *CellarV2_5_SetRebalanceDeviation { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetRebalanceDeviation); ok { + return x.SetRebalanceDeviation + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetStrategistPlatformCut() *CellarV2_5_SetStrategistPlatformCut { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetStrategistPlatformCut); ok { + return x.SetStrategistPlatformCut + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetSetSharePriceOracle() *CellarV2_5_SetSharePriceOracle { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetSharePriceOracle); ok { + return x.SetSharePriceOracle + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetIncreaseShareSupplyCap() *CellarV2_5_IncreaseShareSupplyCap { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_IncreaseShareSupplyCap); ok { + return x.IncreaseShareSupplyCap + } + return nil +} + +func (x *CellarV2_5_FunctionCall) GetCachePriceRouter() *CellarV2_5_CachePriceRouter { + if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_CachePriceRouter); ok { + return x.CachePriceRouter + } + return nil +} + +type isCellarV2_5_FunctionCall_Function interface { + isCellarV2_5_FunctionCall_Function() +} + +type CellarV2_5_FunctionCall_AddPosition struct { + // Represents function `addPosition(uint256 index, address position)` + AddPosition *CellarV2_5_AddPosition `protobuf:"bytes,1,opt,name=add_position,json=addPosition,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_CallOnAdaptor struct { + // Represents function `callOnAdaptor(AdaptorCall[] memory data)` + CallOnAdaptor *CellarV2_5_CallOnAdaptor `protobuf:"bytes,2,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_RemovePosition struct { + // Represents function `removePosition(uint256 index)` + RemovePosition *CellarV2_5_RemovePosition `protobuf:"bytes,3,opt,name=remove_position,json=removePosition,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetHoldingPosition struct { + // Represents function `setHoldingPosition(uint32 position_id)` + SetHoldingPosition *CellarV2_5_SetHoldingPosition `protobuf:"bytes,4,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetStrategistPayoutAddress struct { + // Represents function `setStrategistPayoutAddress(address payout)` + SetStrategistPayoutAddress *CellarV2_5_SetStrategistPayoutAddress `protobuf:"bytes,5,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SwapPositions struct { + // Represents function `swapPositions(uint256 index1, uint256 index2)` + SwapPositions *CellarV2_5_SwapPositions `protobuf:"bytes,6,opt,name=swap_positions,json=swapPositions,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetShareLockPeriod struct { + // Represents function `setShareLockPeriod(uint256 newLock)` + SetShareLockPeriod *CellarV2_5_SetShareLockPeriod `protobuf:"bytes,8,opt,name=set_share_lock_period,json=setShareLockPeriod,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_InitiateShutdown struct { + // Represents function `initiateShutdown()` + InitiateShutdown *CellarV2_5_InitiateShutdown `protobuf:"bytes,9,opt,name=initiate_shutdown,json=initiateShutdown,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_LiftShutdown struct { + // Represents function `liftShutdown()` + LiftShutdown *CellarV2_5_LiftShutdown `protobuf:"bytes,11,opt,name=lift_shutdown,json=liftShutdown,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue struct { + // Represents function `removeAdaptorFromCatalogue(address adaptor)` + RemoveAdaptorFromCatalogue *CellarV2_5_RemoveAdaptorFromCatalogue `protobuf:"bytes,14,opt,name=remove_adaptor_from_catalogue,json=removeAdaptorFromCatalogue,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_RemovePositionFromCatalogue struct { + // Represents function `removePositionFromCatalogue(uint32 positionId)` + RemovePositionFromCatalogue *CellarV2_5_RemovePositionFromCatalogue `protobuf:"bytes,15,opt,name=remove_position_from_catalogue,json=removePositionFromCatalogue,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_DecreaseShareSupplyCap struct { + // Represents function `decreaseShareSupplyCap(uint192) + DecreaseShareSupplyCap *CellarV2_5_DecreaseShareSupplyCap `protobuf:"bytes,16,opt,name=decrease_share_supply_cap,json=decreaseShareSupplyCap,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetAlternativeAssetData struct { + // Represents function `setAlternativeAssetData(ERC20 _alternativeAsset, uint32 _alternativeHoldingPosition, uint32 _alternativeAssetFee)` + SetAlternativeAssetData *CellarV2_5_SetAlternativeAssetData `protobuf:"bytes,17,opt,name=set_alternative_asset_data,json=setAlternativeAssetData,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_DropAlternativeAssetData struct { + // Represents function `setDropAlternativeAssetData(ERC20 _alternativeAsset)` + DropAlternativeAssetData *CellarV2_5_DropAlternativeAssetData `protobuf:"bytes,18,opt,name=drop_alternative_asset_data,json=dropAlternativeAssetData,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_AddAdaptorToCatalogue struct { + // Represents function `addAdaptorToCatalogue(address adaptor)` + AddAdaptorToCatalogue *CellarV2_5_AddAdaptorToCatalogue `protobuf:"bytes,19,opt,name=add_adaptor_to_catalogue,json=addAdaptorToCatalogue,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_AddPositionToCatalogue struct { + // Represents function `addPositionToCatalogue(uint32 positionId)` + AddPositionToCatalogue *CellarV2_5_AddPositionToCatalogue `protobuf:"bytes,20,opt,name=add_position_to_catalogue,json=addPositionToCatalogue,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetRebalanceDeviation struct { + // Represents function `setRebalanceDeviation(uint265)` + SetRebalanceDeviation *CellarV2_5_SetRebalanceDeviation `protobuf:"bytes,21,opt,name=set_rebalance_deviation,json=setRebalanceDeviation,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetStrategistPlatformCut struct { + // Represents function `setStrategistPlatformCut(uint64 cut)` + SetStrategistPlatformCut *CellarV2_5_SetStrategistPlatformCut `protobuf:"bytes,22,opt,name=set_strategist_platform_cut,json=setStrategistPlatformCut,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_SetSharePriceOracle struct { + // Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` + SetSharePriceOracle *CellarV2_5_SetSharePriceOracle `protobuf:"bytes,23,opt,name=set_share_price_oracle,json=setSharePriceOracle,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_IncreaseShareSupplyCap struct { + // Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` + IncreaseShareSupplyCap *CellarV2_5_IncreaseShareSupplyCap `protobuf:"bytes,24,opt,name=increase_share_supply_cap,json=increaseShareSupplyCap,proto3,oneof"` +} + +type CellarV2_5_FunctionCall_CachePriceRouter struct { + // Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` + CachePriceRouter *CellarV2_5_CachePriceRouter `protobuf:"bytes,25,opt,name=cache_price_router,json=cachePriceRouter,proto3,oneof"` +} + +func (*CellarV2_5_FunctionCall_AddPosition) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_CallOnAdaptor) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_RemovePosition) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetHoldingPosition) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetStrategistPayoutAddress) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SwapPositions) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetShareLockPeriod) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_InitiateShutdown) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_LiftShutdown) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_RemovePositionFromCatalogue) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_DecreaseShareSupplyCap) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetAlternativeAssetData) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_DropAlternativeAssetData) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_AddAdaptorToCatalogue) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_AddPositionToCatalogue) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetRebalanceDeviation) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetStrategistPlatformCut) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_SetSharePriceOracle) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_IncreaseShareSupplyCap) isCellarV2_5_FunctionCall_Function() {} + +func (*CellarV2_5_FunctionCall_CachePriceRouter) isCellarV2_5_FunctionCall_Function() {} + +// +// Insert a trusted position to the list of positions used by the cellar at a given index. +// +// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` +type CellarV2_5_AddPosition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Index at which to add the position + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // The position's ID in the cellar registry + PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // Data used to configure how the position behaves + ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` + // Whether to add position in the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` +} + +func (x *CellarV2_5_AddPosition) Reset() { + *x = CellarV2_5_AddPosition{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[55] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_5_AddPosition) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_2Governance_CachePriceRouter) ProtoMessage() {} +func (*CellarV2_5_AddPosition) ProtoMessage() {} -func (x *CellarV2_2Governance_CachePriceRouter) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[39] +func (x *CellarV2_5_AddPosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3355,73 +4696,68 @@ func (x *CellarV2_2Governance_CachePriceRouter) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_2Governance_CachePriceRouter.ProtoReflect.Descriptor instead. -func (*CellarV2_2Governance_CachePriceRouter) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{3, 9} +// Deprecated: Use CellarV2_5_AddPosition.ProtoReflect.Descriptor instead. +func (*CellarV2_5_AddPosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 1} } -func (x *CellarV2_2Governance_CachePriceRouter) GetCheckTotalAssets() bool { +func (x *CellarV2_5_AddPosition) GetIndex() uint32 { if x != nil { - return x.CheckTotalAssets + return x.Index } - return false + return 0 } -func (x *CellarV2_2Governance_CachePriceRouter) GetAllowableRange() uint32 { +func (x *CellarV2_5_AddPosition) GetPositionId() uint32 { if x != nil { - return x.AllowableRange + return x.PositionId } return 0 } -func (x *CellarV2_2Governance_CachePriceRouter) GetExpectedPriceRouter() string { +func (x *CellarV2_5_AddPosition) GetConfigurationData() []byte { if x != nil { - return x.ExpectedPriceRouter + return x.ConfigurationData } - return "" + return nil } -// The function you wish to execute on the target cellar -type CellarV2_5_FunctionCall struct { +func (x *CellarV2_5_AddPosition) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false +} + +// +// Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. +// +// Represents function `callOnAdaptor(AdaptorCall[] memory data)` +type CellarV2_5_CallOnAdaptor struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Types that are assignable to Function: - // *CellarV2_5_FunctionCall_AddPosition - // *CellarV2_5_FunctionCall_CallOnAdaptor - // *CellarV2_5_FunctionCall_RemovePosition - // *CellarV2_5_FunctionCall_SetHoldingPosition - // *CellarV2_5_FunctionCall_SetStrategistPayoutAddress - // *CellarV2_5_FunctionCall_SwapPositions - // *CellarV2_5_FunctionCall_SetShareLockPeriod - // *CellarV2_5_FunctionCall_InitiateShutdown - // *CellarV2_5_FunctionCall_LiftShutdown - // *CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue - // *CellarV2_5_FunctionCall_RemovePositionFromCatalogue - // *CellarV2_5_FunctionCall_DecreaseShareSupplyCap - // *CellarV2_5_FunctionCall_SetAlternativeAssetData - // *CellarV2_5_FunctionCall_DropAlternativeAssetData - Function isCellarV2_5_FunctionCall_Function `protobuf_oneof:"function"` + Data []*AdaptorCall `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` } -func (x *CellarV2_5_FunctionCall) Reset() { - *x = CellarV2_5_FunctionCall{} +func (x *CellarV2_5_CallOnAdaptor) Reset() { + *x = CellarV2_5_CallOnAdaptor{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[40] + mi := &file_cellar_v2_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_FunctionCall) String() string { +func (x *CellarV2_5_CallOnAdaptor) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_FunctionCall) ProtoMessage() {} +func (*CellarV2_5_CallOnAdaptor) ProtoMessage() {} -func (x *CellarV2_5_FunctionCall) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[40] +func (x *CellarV2_5_CallOnAdaptor) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3432,254 +4768,216 @@ func (x *CellarV2_5_FunctionCall) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_FunctionCall.ProtoReflect.Descriptor instead. -func (*CellarV2_5_FunctionCall) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 0} -} - -func (m *CellarV2_5_FunctionCall) GetFunction() isCellarV2_5_FunctionCall_Function { - if m != nil { - return m.Function - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetAddPosition() *CellarV2_5_AddPosition { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_AddPosition); ok { - return x.AddPosition - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetCallOnAdaptor() *CellarV2_5_CallOnAdaptor { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_CallOnAdaptor); ok { - return x.CallOnAdaptor - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetRemovePosition() *CellarV2_5_RemovePosition { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemovePosition); ok { - return x.RemovePosition - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetSetHoldingPosition() *CellarV2_5_SetHoldingPosition { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetHoldingPosition); ok { - return x.SetHoldingPosition - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetSetStrategistPayoutAddress() *CellarV2_5_SetStrategistPayoutAddress { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetStrategistPayoutAddress); ok { - return x.SetStrategistPayoutAddress - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetSwapPositions() *CellarV2_5_SwapPositions { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SwapPositions); ok { - return x.SwapPositions - } - return nil -} - -func (x *CellarV2_5_FunctionCall) GetSetShareLockPeriod() *CellarV2_5_SetShareLockPeriod { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetShareLockPeriod); ok { - return x.SetShareLockPeriod - } - return nil +// Deprecated: Use CellarV2_5_CallOnAdaptor.ProtoReflect.Descriptor instead. +func (*CellarV2_5_CallOnAdaptor) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 2} } -func (x *CellarV2_5_FunctionCall) GetInitiateShutdown() *CellarV2_5_InitiateShutdown { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_InitiateShutdown); ok { - return x.InitiateShutdown +func (x *CellarV2_5_CallOnAdaptor) GetData() []*AdaptorCall { + if x != nil { + return x.Data } return nil } -func (x *CellarV2_5_FunctionCall) GetLiftShutdown() *CellarV2_5_LiftShutdown { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_LiftShutdown); ok { - return x.LiftShutdown - } - return nil -} +// +// Remove the position at a given index from the list of positions used by the cellar. +// +// Represents function `removePosition(uint32 index, bool inDebtArray)` +type CellarV2_5_RemovePosition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields -func (x *CellarV2_5_FunctionCall) GetRemoveAdaptorFromCatalogue() *CellarV2_5_RemoveAdaptorFromCatalogue { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue); ok { - return x.RemoveAdaptorFromCatalogue - } - return nil + // Index at which to remove the position + Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` + // Whether to remove position from the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,2,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_5_FunctionCall) GetRemovePositionFromCatalogue() *CellarV2_5_RemovePositionFromCatalogue { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_RemovePositionFromCatalogue); ok { - return x.RemovePositionFromCatalogue +func (x *CellarV2_5_RemovePosition) Reset() { + *x = CellarV2_5_RemovePosition{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) } - return nil } -func (x *CellarV2_5_FunctionCall) GetDecreaseShareSupplyCap() *CellarV2_5_DecreaseShareSupplyCap { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_DecreaseShareSupplyCap); ok { - return x.DecreaseShareSupplyCap - } - return nil +func (x *CellarV2_5_RemovePosition) String() string { + return protoimpl.X.MessageStringOf(x) } -func (x *CellarV2_5_FunctionCall) GetSetAlternativeAssetData() *CellarV2_5_SetAlternativeAssetData { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_SetAlternativeAssetData); ok { - return x.SetAlternativeAssetData - } - return nil -} +func (*CellarV2_5_RemovePosition) ProtoMessage() {} -func (x *CellarV2_5_FunctionCall) GetDropAlternativeAssetData() *CellarV2_5_DropAlternativeAssetData { - if x, ok := x.GetFunction().(*CellarV2_5_FunctionCall_DropAlternativeAssetData); ok { - return x.DropAlternativeAssetData +func (x *CellarV2_5_RemovePosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[57] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - return nil -} - -type isCellarV2_5_FunctionCall_Function interface { - isCellarV2_5_FunctionCall_Function() -} - -type CellarV2_5_FunctionCall_AddPosition struct { - // Represents function `addPosition(uint256 index, address position)` - AddPosition *CellarV2_5_AddPosition `protobuf:"bytes,1,opt,name=add_position,json=addPosition,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_CallOnAdaptor struct { - // Represents function `callOnAdaptor(AdaptorCall[] memory data)` - CallOnAdaptor *CellarV2_5_CallOnAdaptor `protobuf:"bytes,2,opt,name=call_on_adaptor,json=callOnAdaptor,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_RemovePosition struct { - // Represents function `removePosition(uint256 index)` - RemovePosition *CellarV2_5_RemovePosition `protobuf:"bytes,3,opt,name=remove_position,json=removePosition,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_SetHoldingPosition struct { - // Represents function `setHoldingPosition(uint32 position_id)` - SetHoldingPosition *CellarV2_5_SetHoldingPosition `protobuf:"bytes,4,opt,name=set_holding_position,json=setHoldingPosition,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_SetStrategistPayoutAddress struct { - // Represents function `setStrategistPayoutAddress(address payout)` - SetStrategistPayoutAddress *CellarV2_5_SetStrategistPayoutAddress `protobuf:"bytes,5,opt,name=set_strategist_payout_address,json=setStrategistPayoutAddress,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_SwapPositions struct { - // Represents function `swapPositions(uint256 index1, uint256 index2)` - SwapPositions *CellarV2_5_SwapPositions `protobuf:"bytes,6,opt,name=swap_positions,json=swapPositions,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_SetShareLockPeriod struct { - // Represents function `setShareLockPeriod(uint256 newLock)` - SetShareLockPeriod *CellarV2_5_SetShareLockPeriod `protobuf:"bytes,8,opt,name=set_share_lock_period,json=setShareLockPeriod,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_InitiateShutdown struct { - // Represents function `initiateShutdown()` - InitiateShutdown *CellarV2_5_InitiateShutdown `protobuf:"bytes,9,opt,name=initiate_shutdown,json=initiateShutdown,proto3,oneof"` -} - -type CellarV2_5_FunctionCall_LiftShutdown struct { - // Represents function `liftShutdown()` - LiftShutdown *CellarV2_5_LiftShutdown `protobuf:"bytes,11,opt,name=lift_shutdown,json=liftShutdown,proto3,oneof"` + return mi.MessageOf(x) } -type CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue struct { - // Represents function `removeAdaptorFromCatalogue(address adaptor)` - RemoveAdaptorFromCatalogue *CellarV2_5_RemoveAdaptorFromCatalogue `protobuf:"bytes,14,opt,name=remove_adaptor_from_catalogue,json=removeAdaptorFromCatalogue,proto3,oneof"` +// Deprecated: Use CellarV2_5_RemovePosition.ProtoReflect.Descriptor instead. +func (*CellarV2_5_RemovePosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 3} } -type CellarV2_5_FunctionCall_RemovePositionFromCatalogue struct { - // Represents function `removePositionFromCatalogue(uint32 positionId)` - RemovePositionFromCatalogue *CellarV2_5_RemovePositionFromCatalogue `protobuf:"bytes,15,opt,name=remove_position_from_catalogue,json=removePositionFromCatalogue,proto3,oneof"` +func (x *CellarV2_5_RemovePosition) GetIndex() uint32 { + if x != nil { + return x.Index + } + return 0 } -type CellarV2_5_FunctionCall_DecreaseShareSupplyCap struct { - // Represents function `decreaseShareSupplyCap(uint192) - DecreaseShareSupplyCap *CellarV2_5_DecreaseShareSupplyCap `protobuf:"bytes,16,opt,name=decrease_share_supply_cap,json=decreaseShareSupplyCap,proto3,oneof"` +func (x *CellarV2_5_RemovePosition) GetInDebtArray() bool { + if x != nil { + return x.InDebtArray + } + return false } -type CellarV2_5_FunctionCall_SetAlternativeAssetData struct { - // Represents function `setAlternativeAssetData(ERC20 _alternativeAsset, uint32 _alternativeHoldingPosition, uint32 _alternativeAssetFee)` - SetAlternativeAssetData *CellarV2_5_SetAlternativeAssetData `protobuf:"bytes,17,opt,name=set_alternative_asset_data,json=setAlternativeAssetData,proto3,oneof"` -} +// +// Set the holding position used of the cellar. +// +// Represents function `setHoldingIndex(uint8 index)` +type CellarV2_5_SetHoldingPosition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields -type CellarV2_5_FunctionCall_DropAlternativeAssetData struct { - // Represents function `setDropAlternativeAssetData(ERC20 _alternativeAsset)` - DropAlternativeAssetData *CellarV2_5_DropAlternativeAssetData `protobuf:"bytes,18,opt,name=drop_alternative_asset_data,json=dropAlternativeAssetData,proto3,oneof"` + // ID (index) of the new holding position to use + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (*CellarV2_5_FunctionCall_AddPosition) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetHoldingPosition) Reset() { + *x = CellarV2_5_SetHoldingPosition{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} -func (*CellarV2_5_FunctionCall_CallOnAdaptor) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetHoldingPosition) String() string { + return protoimpl.X.MessageStringOf(x) +} -func (*CellarV2_5_FunctionCall_RemovePosition) isCellarV2_5_FunctionCall_Function() {} +func (*CellarV2_5_SetHoldingPosition) ProtoMessage() {} -func (*CellarV2_5_FunctionCall_SetHoldingPosition) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetHoldingPosition) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[58] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} -func (*CellarV2_5_FunctionCall_SetStrategistPayoutAddress) isCellarV2_5_FunctionCall_Function() {} +// Deprecated: Use CellarV2_5_SetHoldingPosition.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetHoldingPosition) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 4} +} -func (*CellarV2_5_FunctionCall_SwapPositions) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetHoldingPosition) GetPositionId() uint32 { + if x != nil { + return x.PositionId + } + return 0 +} -func (*CellarV2_5_FunctionCall_SetShareLockPeriod) isCellarV2_5_FunctionCall_Function() {} +// +// Sets the Strategists payout address. +// +// Represents function `setStrategistPayoutAddress(address payout)` +type CellarV2_5_SetStrategistPayoutAddress struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields -func (*CellarV2_5_FunctionCall_InitiateShutdown) isCellarV2_5_FunctionCall_Function() {} + Payout string `protobuf:"bytes,1,opt,name=payout,proto3" json:"payout,omitempty"` +} -func (*CellarV2_5_FunctionCall_LiftShutdown) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetStrategistPayoutAddress) Reset() { + *x = CellarV2_5_SetStrategistPayoutAddress{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} -func (*CellarV2_5_FunctionCall_RemoveAdaptorFromCatalogue) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetStrategistPayoutAddress) String() string { + return protoimpl.X.MessageStringOf(x) +} -func (*CellarV2_5_FunctionCall_RemovePositionFromCatalogue) isCellarV2_5_FunctionCall_Function() {} +func (*CellarV2_5_SetStrategistPayoutAddress) ProtoMessage() {} -func (*CellarV2_5_FunctionCall_DecreaseShareSupplyCap) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[59] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} -func (*CellarV2_5_FunctionCall_SetAlternativeAssetData) isCellarV2_5_FunctionCall_Function() {} +// Deprecated: Use CellarV2_5_SetStrategistPayoutAddress.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetStrategistPayoutAddress) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 5} +} -func (*CellarV2_5_FunctionCall_DropAlternativeAssetData) isCellarV2_5_FunctionCall_Function() {} +func (x *CellarV2_5_SetStrategistPayoutAddress) GetPayout() string { + if x != nil { + return x.Payout + } + return "" +} // -// Insert a trusted position to the list of positions used by the cellar at a given index. +// Swap the positions at two given indeces. // -// Represents function `addPosition(uint32 index, uint32 positionId, bytes configurationData, bool inDebtArray)` -type CellarV2_5_AddPosition struct { +// Represents function `swapPositions(uint32 index1, uint32 index2)` +type CellarV2_5_SwapPositions struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Index at which to add the position - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - // The position's ID in the cellar registry - PositionId uint32 `protobuf:"varint,2,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` - // Data used to configure how the position behaves - ConfigurationData []byte `protobuf:"bytes,3,opt,name=configuration_data,json=configurationData,proto3" json:"configuration_data,omitempty"` - // Whether to add position in the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,4,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + // Index of the first position + Index_1 uint32 `protobuf:"varint,1,opt,name=index_1,json=index1,proto3" json:"index_1,omitempty"` + // Index of the second position + Index_2 uint32 `protobuf:"varint,2,opt,name=index_2,json=index2,proto3" json:"index_2,omitempty"` + // Whether to switch positions in the debt array, or the credit array. + InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_5_AddPosition) Reset() { - *x = CellarV2_5_AddPosition{} +func (x *CellarV2_5_SwapPositions) Reset() { + *x = CellarV2_5_SwapPositions{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[41] + mi := &file_cellar_v2_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_AddPosition) String() string { +func (x *CellarV2_5_SwapPositions) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_AddPosition) ProtoMessage() {} +func (*CellarV2_5_SwapPositions) ProtoMessage() {} -func (x *CellarV2_5_AddPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[41] +func (x *CellarV2_5_SwapPositions) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3690,33 +4988,26 @@ func (x *CellarV2_5_AddPosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_AddPosition.ProtoReflect.Descriptor instead. -func (*CellarV2_5_AddPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 1} +// Deprecated: Use CellarV2_5_SwapPositions.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SwapPositions) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 6} } -func (x *CellarV2_5_AddPosition) GetIndex() uint32 { +func (x *CellarV2_5_SwapPositions) GetIndex_1() uint32 { if x != nil { - return x.Index + return x.Index_1 } return 0 } -func (x *CellarV2_5_AddPosition) GetPositionId() uint32 { +func (x *CellarV2_5_SwapPositions) GetIndex_2() uint32 { if x != nil { - return x.PositionId + return x.Index_2 } return 0 } -func (x *CellarV2_5_AddPosition) GetConfigurationData() []byte { - if x != nil { - return x.ConfigurationData - } - return nil -} - -func (x *CellarV2_5_AddPosition) GetInDebtArray() bool { +func (x *CellarV2_5_SwapPositions) GetInDebtArray() bool { if x != nil { return x.InDebtArray } @@ -3724,34 +5015,34 @@ func (x *CellarV2_5_AddPosition) GetInDebtArray() bool { } // -// Allows strategists to manage their Cellar using arbitrary logic calls to adaptors. +// Allows share lock period to be updated. // -// Represents function `callOnAdaptor(AdaptorCall[] memory data)` -type CellarV2_5_CallOnAdaptor struct { +// Represents function `setShareLockPeriod()` +type CellarV2_5_SetShareLockPeriod struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Data []*AdaptorCall `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"` + NewLock string `protobuf:"bytes,1,opt,name=new_lock,json=newLock,proto3" json:"new_lock,omitempty"` } -func (x *CellarV2_5_CallOnAdaptor) Reset() { - *x = CellarV2_5_CallOnAdaptor{} +func (x *CellarV2_5_SetShareLockPeriod) Reset() { + *x = CellarV2_5_SetShareLockPeriod{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[42] + mi := &file_cellar_v2_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_CallOnAdaptor) String() string { +func (x *CellarV2_5_SetShareLockPeriod) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_CallOnAdaptor) ProtoMessage() {} +func (*CellarV2_5_SetShareLockPeriod) ProtoMessage() {} -func (x *CellarV2_5_CallOnAdaptor) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[42] +func (x *CellarV2_5_SetShareLockPeriod) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3762,50 +5053,87 @@ func (x *CellarV2_5_CallOnAdaptor) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_CallOnAdaptor.ProtoReflect.Descriptor instead. -func (*CellarV2_5_CallOnAdaptor) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 2} +// Deprecated: Use CellarV2_5_SetShareLockPeriod.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetShareLockPeriod) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 7} } -func (x *CellarV2_5_CallOnAdaptor) GetData() []*AdaptorCall { +func (x *CellarV2_5_SetShareLockPeriod) GetNewLock() string { if x != nil { - return x.Data + return x.NewLock } - return nil + return "" +} + +// +// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. +// +// Represents function `initiateShutdown()` +type CellarV2_5_InitiateShutdown struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *CellarV2_5_InitiateShutdown) Reset() { + *x = CellarV2_5_InitiateShutdown{} + if protoimpl.UnsafeEnabled { + mi := &file_cellar_v2_proto_msgTypes[62] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *CellarV2_5_InitiateShutdown) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CellarV2_5_InitiateShutdown) ProtoMessage() {} + +func (x *CellarV2_5_InitiateShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[62] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CellarV2_5_InitiateShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_5_InitiateShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 8} } // -// Remove the position at a given index from the list of positions used by the cellar. +// Allows the owner to restart a shut down Cellar // -// Represents function `removePosition(uint32 index, bool inDebtArray)` -type CellarV2_5_RemovePosition struct { +// Represents function `liftShutdown()` +type CellarV2_5_LiftShutdown struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - - // Index at which to remove the position - Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` - // Whether to remove position from the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,2,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` } -func (x *CellarV2_5_RemovePosition) Reset() { - *x = CellarV2_5_RemovePosition{} +func (x *CellarV2_5_LiftShutdown) Reset() { + *x = CellarV2_5_LiftShutdown{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[43] + mi := &file_cellar_v2_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_RemovePosition) String() string { +func (x *CellarV2_5_LiftShutdown) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_RemovePosition) ProtoMessage() {} +func (*CellarV2_5_LiftShutdown) ProtoMessage() {} -func (x *CellarV2_5_RemovePosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[43] +func (x *CellarV2_5_LiftShutdown) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3816,55 +5144,40 @@ func (x *CellarV2_5_RemovePosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_RemovePosition.ProtoReflect.Descriptor instead. -func (*CellarV2_5_RemovePosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 3} -} - -func (x *CellarV2_5_RemovePosition) GetIndex() uint32 { - if x != nil { - return x.Index - } - return 0 -} - -func (x *CellarV2_5_RemovePosition) GetInDebtArray() bool { - if x != nil { - return x.InDebtArray - } - return false +// Deprecated: Use CellarV2_5_LiftShutdown.ProtoReflect.Descriptor instead. +func (*CellarV2_5_LiftShutdown) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 9} } // -// Set the holding position used of the cellar. +// Allows caller to call multiple functions in a single TX. // -// Represents function `setHoldingIndex(uint8 index)` -type CellarV2_5_SetHoldingPosition struct { +// Represents function `multicall(bytes[] data)` +type CellarV2_5_Multicall struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // ID (index) of the new holding position to use - PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + FunctionCalls []*CellarV2_5_FunctionCall `protobuf:"bytes,1,rep,name=function_calls,json=functionCalls,proto3" json:"function_calls,omitempty"` } -func (x *CellarV2_5_SetHoldingPosition) Reset() { - *x = CellarV2_5_SetHoldingPosition{} +func (x *CellarV2_5_Multicall) Reset() { + *x = CellarV2_5_Multicall{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[44] + mi := &file_cellar_v2_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SetHoldingPosition) String() string { +func (x *CellarV2_5_Multicall) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SetHoldingPosition) ProtoMessage() {} +func (*CellarV2_5_Multicall) ProtoMessage() {} -func (x *CellarV2_5_SetHoldingPosition) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[44] +func (x *CellarV2_5_Multicall) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3875,47 +5188,47 @@ func (x *CellarV2_5_SetHoldingPosition) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SetHoldingPosition.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SetHoldingPosition) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 4} +// Deprecated: Use CellarV2_5_Multicall.ProtoReflect.Descriptor instead. +func (*CellarV2_5_Multicall) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 10} } -func (x *CellarV2_5_SetHoldingPosition) GetPositionId() uint32 { +func (x *CellarV2_5_Multicall) GetFunctionCalls() []*CellarV2_5_FunctionCall { if x != nil { - return x.PositionId + return x.FunctionCalls } - return 0 + return nil } // -// Sets the Strategists payout address. +// Allows callers to remove adaptors from this cellar's catalogue // -// Represents function `setStrategistPayoutAddress(address payout)` -type CellarV2_5_SetStrategistPayoutAddress struct { +// Represents function `removeAdaptorFromCatalogue(address adaptor)` +type CellarV2_5_RemoveAdaptorFromCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Payout string `protobuf:"bytes,1,opt,name=payout,proto3" json:"payout,omitempty"` + Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2_5_SetStrategistPayoutAddress) Reset() { - *x = CellarV2_5_SetStrategistPayoutAddress{} +func (x *CellarV2_5_RemoveAdaptorFromCatalogue) Reset() { + *x = CellarV2_5_RemoveAdaptorFromCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[45] + mi := &file_cellar_v2_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SetStrategistPayoutAddress) String() string { +func (x *CellarV2_5_RemoveAdaptorFromCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SetStrategistPayoutAddress) ProtoMessage() {} +func (*CellarV2_5_RemoveAdaptorFromCatalogue) ProtoMessage() {} -func (x *CellarV2_5_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[45] +func (x *CellarV2_5_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3926,52 +5239,47 @@ func (x *CellarV2_5_SetStrategistPayoutAddress) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SetStrategistPayoutAddress.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SetStrategistPayoutAddress) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 5} +// Deprecated: Use CellarV2_5_RemoveAdaptorFromCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_5_RemoveAdaptorFromCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 11} } -func (x *CellarV2_5_SetStrategistPayoutAddress) GetPayout() string { +func (x *CellarV2_5_RemoveAdaptorFromCatalogue) GetAdaptor() string { if x != nil { - return x.Payout + return x.Adaptor } return "" } // -// Swap the positions at two given indeces. +// Allows caller to remove positions from this cellar's catalogue // -// Represents function `swapPositions(uint32 index1, uint32 index2)` -type CellarV2_5_SwapPositions struct { +// Represents function `removePositionFromCatalogue(uint32 positionId)` +type CellarV2_5_RemovePositionFromCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Index of the first position - Index_1 uint32 `protobuf:"varint,1,opt,name=index_1,json=index1,proto3" json:"index_1,omitempty"` - // Index of the second position - Index_2 uint32 `protobuf:"varint,2,opt,name=index_2,json=index2,proto3" json:"index_2,omitempty"` - // Whether to switch positions in the debt array, or the credit array. - InDebtArray bool `protobuf:"varint,3,opt,name=in_debt_array,json=inDebtArray,proto3" json:"in_debt_array,omitempty"` + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (x *CellarV2_5_SwapPositions) Reset() { - *x = CellarV2_5_SwapPositions{} +func (x *CellarV2_5_RemovePositionFromCatalogue) Reset() { + *x = CellarV2_5_RemovePositionFromCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[46] + mi := &file_cellar_v2_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SwapPositions) String() string { +func (x *CellarV2_5_RemovePositionFromCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SwapPositions) ProtoMessage() {} +func (*CellarV2_5_RemovePositionFromCatalogue) ProtoMessage() {} -func (x *CellarV2_5_SwapPositions) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[46] +func (x *CellarV2_5_RemovePositionFromCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3982,61 +5290,47 @@ func (x *CellarV2_5_SwapPositions) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SwapPositions.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SwapPositions) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 6} -} - -func (x *CellarV2_5_SwapPositions) GetIndex_1() uint32 { - if x != nil { - return x.Index_1 - } - return 0 +// Deprecated: Use CellarV2_5_RemovePositionFromCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_5_RemovePositionFromCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 12} } -func (x *CellarV2_5_SwapPositions) GetIndex_2() uint32 { +func (x *CellarV2_5_RemovePositionFromCatalogue) GetPositionId() uint32 { if x != nil { - return x.Index_2 + return x.PositionId } return 0 } -func (x *CellarV2_5_SwapPositions) GetInDebtArray() bool { - if x != nil { - return x.InDebtArray - } - return false -} - // -// Allows share lock period to be updated. +// Allows strategist to decrease the share supply cap // -// Represents function `setShareLockPeriod()` -type CellarV2_5_SetShareLockPeriod struct { +// Represents function `decreaseShareSupplyCap(uint192)` +type CellarV2_5_DecreaseShareSupplyCap struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - NewLock string `protobuf:"bytes,1,opt,name=new_lock,json=newLock,proto3" json:"new_lock,omitempty"` + NewCap string `protobuf:"bytes,1,opt,name=new_cap,json=newCap,proto3" json:"new_cap,omitempty"` } -func (x *CellarV2_5_SetShareLockPeriod) Reset() { - *x = CellarV2_5_SetShareLockPeriod{} +func (x *CellarV2_5_DecreaseShareSupplyCap) Reset() { + *x = CellarV2_5_DecreaseShareSupplyCap{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[47] + mi := &file_cellar_v2_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SetShareLockPeriod) String() string { +func (x *CellarV2_5_DecreaseShareSupplyCap) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SetShareLockPeriod) ProtoMessage() {} +func (*CellarV2_5_DecreaseShareSupplyCap) ProtoMessage() {} -func (x *CellarV2_5_SetShareLockPeriod) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[47] +func (x *CellarV2_5_DecreaseShareSupplyCap) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4047,48 +5341,52 @@ func (x *CellarV2_5_SetShareLockPeriod) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SetShareLockPeriod.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SetShareLockPeriod) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 7} +// Deprecated: Use CellarV2_5_DecreaseShareSupplyCap.ProtoReflect.Descriptor instead. +func (*CellarV2_5_DecreaseShareSupplyCap) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 13} } -func (x *CellarV2_5_SetShareLockPeriod) GetNewLock() string { +func (x *CellarV2_5_DecreaseShareSupplyCap) GetNewCap() string { if x != nil { - return x.NewLock + return x.NewCap } return "" } // -// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate -// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. +// Allows the strategist to add, or update an existing alternative asset deposit. // -// Represents function `setRebalanceDeviation(uint256)` -type CellarV2_5_SetRebalanceDeviation struct { +// Represents function `setAlternativeAssetData(ERC20 _alternativeAsset, uint32 _alternativeHoldingPosition, uint32 _alternativeAssetFee)` +type CellarV2_5_SetAlternativeAssetData struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` + // The address of the alternative asset + AlternativeAsset string `protobuf:"bytes,1,opt,name=alternative_asset,json=alternativeAsset,proto3" json:"alternative_asset,omitempty"` + // The holding position to direct alternative asset deposits to + AlternativeHoldingPosition uint32 `protobuf:"varint,2,opt,name=alternative_holding_position,json=alternativeHoldingPosition,proto3" json:"alternative_holding_position,omitempty"` + // The fee to charge for depositing this alternative asset + AlternativeAssetFee uint32 `protobuf:"varint,3,opt,name=alternative_asset_fee,json=alternativeAssetFee,proto3" json:"alternative_asset_fee,omitempty"` } -func (x *CellarV2_5_SetRebalanceDeviation) Reset() { - *x = CellarV2_5_SetRebalanceDeviation{} +func (x *CellarV2_5_SetAlternativeAssetData) Reset() { + *x = CellarV2_5_SetAlternativeAssetData{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[48] + mi := &file_cellar_v2_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SetRebalanceDeviation) String() string { +func (x *CellarV2_5_SetAlternativeAssetData) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SetRebalanceDeviation) ProtoMessage() {} +func (*CellarV2_5_SetAlternativeAssetData) ProtoMessage() {} -func (x *CellarV2_5_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[48] +func (x *CellarV2_5_SetAlternativeAssetData) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4099,45 +5397,62 @@ func (x *CellarV2_5_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SetRebalanceDeviation.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SetRebalanceDeviation) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 8} +// Deprecated: Use CellarV2_5_SetAlternativeAssetData.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetAlternativeAssetData) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 14} } -func (x *CellarV2_5_SetRebalanceDeviation) GetNewDeviation() string { +func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeAsset() string { if x != nil { - return x.NewDeviation + return x.AlternativeAsset } return "" } +func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeHoldingPosition() uint32 { + if x != nil { + return x.AlternativeHoldingPosition + } + return 0 +} + +func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeAssetFee() uint32 { + if x != nil { + return x.AlternativeAssetFee + } + return 0 +} + // -// Shutdown the cellar. Used in an emergency or if the cellar has been deprecated. +// Allows the strategist to stop an alternative asset from being deposited. // -// Represents function `initiateShutdown()` -type CellarV2_5_InitiateShutdown struct { +// Represents function `dropAlternativeAssetData(ERC20 _alternativeAsset)` +type CellarV2_5_DropAlternativeAssetData struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + // The address of the alternative asset + AlternativeAsset string `protobuf:"bytes,1,opt,name=alternative_asset,json=alternativeAsset,proto3" json:"alternative_asset,omitempty"` } -func (x *CellarV2_5_InitiateShutdown) Reset() { - *x = CellarV2_5_InitiateShutdown{} +func (x *CellarV2_5_DropAlternativeAssetData) Reset() { + *x = CellarV2_5_DropAlternativeAssetData{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[49] + mi := &file_cellar_v2_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_InitiateShutdown) String() string { +func (x *CellarV2_5_DropAlternativeAssetData) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_InitiateShutdown) ProtoMessage() {} +func (*CellarV2_5_DropAlternativeAssetData) ProtoMessage() {} -func (x *CellarV2_5_InitiateShutdown) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[49] +func (x *CellarV2_5_DropAlternativeAssetData) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4148,38 +5463,47 @@ func (x *CellarV2_5_InitiateShutdown) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_InitiateShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2_5_InitiateShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 9} +// Deprecated: Use CellarV2_5_DropAlternativeAssetData.ProtoReflect.Descriptor instead. +func (*CellarV2_5_DropAlternativeAssetData) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 15} +} + +func (x *CellarV2_5_DropAlternativeAssetData) GetAlternativeAsset() string { + if x != nil { + return x.AlternativeAsset + } + return "" } // -// Allows the owner to restart a shut down Cellar +// Allows the owner to add an adaptor to the Cellar's adaptor catalogue // -// Represents function `liftShutdown()` -type CellarV2_5_LiftShutdown struct { +// Represents function `addAdaptorToCatalogue(address adaptor)` +type CellarV2_5_AddAdaptorToCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields + + Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` } -func (x *CellarV2_5_LiftShutdown) Reset() { - *x = CellarV2_5_LiftShutdown{} +func (x *CellarV2_5_AddAdaptorToCatalogue) Reset() { + *x = CellarV2_5_AddAdaptorToCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[50] + mi := &file_cellar_v2_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_LiftShutdown) String() string { +func (x *CellarV2_5_AddAdaptorToCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_LiftShutdown) ProtoMessage() {} +func (*CellarV2_5_AddAdaptorToCatalogue) ProtoMessage() {} -func (x *CellarV2_5_LiftShutdown) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[50] +func (x *CellarV2_5_AddAdaptorToCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4190,40 +5514,47 @@ func (x *CellarV2_5_LiftShutdown) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_LiftShutdown.ProtoReflect.Descriptor instead. -func (*CellarV2_5_LiftShutdown) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 10} +// Deprecated: Use CellarV2_5_AddAdaptorToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_5_AddAdaptorToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 16} +} + +func (x *CellarV2_5_AddAdaptorToCatalogue) GetAdaptor() string { + if x != nil { + return x.Adaptor + } + return "" } // -// Allows caller to call multiple functions in a single TX. +// Allows the owner to add a position to the Cellar's position catalogue // -// Represents function `multicall(bytes[] data)` -type CellarV2_5_Multicall struct { +// Represents function `addPositionToCatalogue(uint32 positionId)` +type CellarV2_5_AddPositionToCatalogue struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - FunctionCalls []*CellarV2_5_FunctionCall `protobuf:"bytes,1,rep,name=function_calls,json=functionCalls,proto3" json:"function_calls,omitempty"` + PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` } -func (x *CellarV2_5_Multicall) Reset() { - *x = CellarV2_5_Multicall{} +func (x *CellarV2_5_AddPositionToCatalogue) Reset() { + *x = CellarV2_5_AddPositionToCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[51] + mi := &file_cellar_v2_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_Multicall) String() string { +func (x *CellarV2_5_AddPositionToCatalogue) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_Multicall) ProtoMessage() {} +func (*CellarV2_5_AddPositionToCatalogue) ProtoMessage() {} -func (x *CellarV2_5_Multicall) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[51] +func (x *CellarV2_5_AddPositionToCatalogue) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4234,47 +5565,48 @@ func (x *CellarV2_5_Multicall) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_Multicall.ProtoReflect.Descriptor instead. -func (*CellarV2_5_Multicall) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 11} +// Deprecated: Use CellarV2_5_AddPositionToCatalogue.ProtoReflect.Descriptor instead. +func (*CellarV2_5_AddPositionToCatalogue) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 17} } -func (x *CellarV2_5_Multicall) GetFunctionCalls() []*CellarV2_5_FunctionCall { +func (x *CellarV2_5_AddPositionToCatalogue) GetPositionId() uint32 { if x != nil { - return x.FunctionCalls + return x.PositionId } - return nil + return 0 } // -// Allows callers to remove adaptors from this cellar's catalogue +// Changes the cellar's allowed rebalance deviation, which is the percent the total assets of a cellar may deviate +// during a `callOnAdaptor`(rebalance) call. The maximum allowed deviation is 100000000000000000 (0.1e18), or 10%. // -// Represents function `removeAdaptorFromCatalogue(address adaptor)` -type CellarV2_5_RemoveAdaptorFromCatalogue struct { +// Represents function `setRebalanceDeviation(uint256)` +type CellarV2_5_SetRebalanceDeviation struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - Adaptor string `protobuf:"bytes,1,opt,name=adaptor,proto3" json:"adaptor,omitempty"` + NewDeviation string `protobuf:"bytes,1,opt,name=new_deviation,json=newDeviation,proto3" json:"new_deviation,omitempty"` } -func (x *CellarV2_5_RemoveAdaptorFromCatalogue) Reset() { - *x = CellarV2_5_RemoveAdaptorFromCatalogue{} +func (x *CellarV2_5_SetRebalanceDeviation) Reset() { + *x = CellarV2_5_SetRebalanceDeviation{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[52] + mi := &file_cellar_v2_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_RemoveAdaptorFromCatalogue) String() string { +func (x *CellarV2_5_SetRebalanceDeviation) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_RemoveAdaptorFromCatalogue) ProtoMessage() {} +func (*CellarV2_5_SetRebalanceDeviation) ProtoMessage() {} -func (x *CellarV2_5_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[52] +func (x *CellarV2_5_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4285,47 +5617,48 @@ func (x *CellarV2_5_RemoveAdaptorFromCatalogue) ProtoReflect() protoreflect.Mess return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_RemoveAdaptorFromCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_5_RemoveAdaptorFromCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 12} +// Deprecated: Use CellarV2_5_SetRebalanceDeviation.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetRebalanceDeviation) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 18} } -func (x *CellarV2_5_RemoveAdaptorFromCatalogue) GetAdaptor() string { +func (x *CellarV2_5_SetRebalanceDeviation) GetNewDeviation() string { if x != nil { - return x.Adaptor + return x.NewDeviation } return "" } // -// Allows caller to remove positions from this cellar's catalogue +// Allows strategist to set the platform cut for the cellar. // -// Represents function `removePositionFromCatalogue(uint32 positionId)` -type CellarV2_5_RemovePositionFromCatalogue struct { +// Represents function `setStrategistPlatformCut(uint64 cut)` +type CellarV2_5_SetStrategistPlatformCut struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - PositionId uint32 `protobuf:"varint,1,opt,name=position_id,json=positionId,proto3" json:"position_id,omitempty"` + // The new strategist platform cut + NewCut uint64 `protobuf:"varint,1,opt,name=new_cut,json=newCut,proto3" json:"new_cut,omitempty"` } -func (x *CellarV2_5_RemovePositionFromCatalogue) Reset() { - *x = CellarV2_5_RemovePositionFromCatalogue{} +func (x *CellarV2_5_SetStrategistPlatformCut) Reset() { + *x = CellarV2_5_SetStrategistPlatformCut{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[53] + mi := &file_cellar_v2_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_RemovePositionFromCatalogue) String() string { +func (x *CellarV2_5_SetStrategistPlatformCut) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_RemovePositionFromCatalogue) ProtoMessage() {} +func (*CellarV2_5_SetStrategistPlatformCut) ProtoMessage() {} -func (x *CellarV2_5_RemovePositionFromCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[53] +func (x *CellarV2_5_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4336,23 +5669,23 @@ func (x *CellarV2_5_RemovePositionFromCatalogue) ProtoReflect() protoreflect.Mes return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_RemovePositionFromCatalogue.ProtoReflect.Descriptor instead. -func (*CellarV2_5_RemovePositionFromCatalogue) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 13} +// Deprecated: Use CellarV2_5_SetStrategistPlatformCut.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetStrategistPlatformCut) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 19} } -func (x *CellarV2_5_RemovePositionFromCatalogue) GetPositionId() uint32 { +func (x *CellarV2_5_SetStrategistPlatformCut) GetNewCut() uint64 { if x != nil { - return x.PositionId + return x.NewCut } return 0 } // -// Allows strategist to decrease the share supply cap +// Allows the caller to increase the share supply cap // -// Represents function `decreaseShareSupplyCap(uint192)` -type CellarV2_5_DecreaseShareSupplyCap struct { +// Represents function `increaseShareSupplyCap(uint192 _newShareSupplyCap)` +type CellarV2_5_IncreaseShareSupplyCap struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields @@ -4360,23 +5693,23 @@ type CellarV2_5_DecreaseShareSupplyCap struct { NewCap string `protobuf:"bytes,1,opt,name=new_cap,json=newCap,proto3" json:"new_cap,omitempty"` } -func (x *CellarV2_5_DecreaseShareSupplyCap) Reset() { - *x = CellarV2_5_DecreaseShareSupplyCap{} +func (x *CellarV2_5_IncreaseShareSupplyCap) Reset() { + *x = CellarV2_5_IncreaseShareSupplyCap{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[54] + mi := &file_cellar_v2_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_DecreaseShareSupplyCap) String() string { +func (x *CellarV2_5_IncreaseShareSupplyCap) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_DecreaseShareSupplyCap) ProtoMessage() {} +func (*CellarV2_5_IncreaseShareSupplyCap) ProtoMessage() {} -func (x *CellarV2_5_DecreaseShareSupplyCap) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[54] +func (x *CellarV2_5_IncreaseShareSupplyCap) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4387,12 +5720,12 @@ func (x *CellarV2_5_DecreaseShareSupplyCap) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_DecreaseShareSupplyCap.ProtoReflect.Descriptor instead. -func (*CellarV2_5_DecreaseShareSupplyCap) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 14} +// Deprecated: Use CellarV2_5_IncreaseShareSupplyCap.ProtoReflect.Descriptor instead. +func (*CellarV2_5_IncreaseShareSupplyCap) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 20} } -func (x *CellarV2_5_DecreaseShareSupplyCap) GetNewCap() string { +func (x *CellarV2_5_IncreaseShareSupplyCap) GetNewCap() string { if x != nil { return x.NewCap } @@ -4400,39 +5733,37 @@ func (x *CellarV2_5_DecreaseShareSupplyCap) GetNewCap() string { } // -// Allows the strategist to add, or update an existing alternative asset deposit. +// Allows the caller to set the share price oracle contract // -// Represents function `setAlternativeAssetData(ERC20 _alternativeAsset, uint32 _alternativeHoldingPosition, uint32 _alternativeAssetFee)` -type CellarV2_5_SetAlternativeAssetData struct { +// Represents function `setSharePriceOracle(uint256 _registryId, ERC4626SharePriceOracle _sharePriceOracle)` +type CellarV2_5_SetSharePriceOracle struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // The address of the alternative asset - AlternativeAsset string `protobuf:"bytes,1,opt,name=alternative_asset,json=alternativeAsset,proto3" json:"alternative_asset,omitempty"` - // The holding position to direct alternative asset deposits to - AlternativeHoldingPosition uint32 `protobuf:"varint,2,opt,name=alternative_holding_position,json=alternativeHoldingPosition,proto3" json:"alternative_holding_position,omitempty"` - // The fee to charge for depositing this alternative asset - AlternativeAssetFee uint32 `protobuf:"varint,3,opt,name=alternative_asset_fee,json=alternativeAssetFee,proto3" json:"alternative_asset_fee,omitempty"` + // The oracle registry ID + RegistryId string `protobuf:"bytes,1,opt,name=registry_id,json=registryId,proto3" json:"registry_id,omitempty"` + // The oracle contract address + SharePriceOracle string `protobuf:"bytes,2,opt,name=share_price_oracle,json=sharePriceOracle,proto3" json:"share_price_oracle,omitempty"` } -func (x *CellarV2_5_SetAlternativeAssetData) Reset() { - *x = CellarV2_5_SetAlternativeAssetData{} +func (x *CellarV2_5_SetSharePriceOracle) Reset() { + *x = CellarV2_5_SetSharePriceOracle{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[55] + mi := &file_cellar_v2_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_SetAlternativeAssetData) String() string { +func (x *CellarV2_5_SetSharePriceOracle) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_SetAlternativeAssetData) ProtoMessage() {} +func (*CellarV2_5_SetSharePriceOracle) ProtoMessage() {} -func (x *CellarV2_5_SetAlternativeAssetData) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[55] +func (x *CellarV2_5_SetSharePriceOracle) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4443,62 +5774,59 @@ func (x *CellarV2_5_SetAlternativeAssetData) ProtoReflect() protoreflect.Message return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_SetAlternativeAssetData.ProtoReflect.Descriptor instead. -func (*CellarV2_5_SetAlternativeAssetData) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 15} +// Deprecated: Use CellarV2_5_SetSharePriceOracle.ProtoReflect.Descriptor instead. +func (*CellarV2_5_SetSharePriceOracle) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 21} } -func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeAsset() string { +func (x *CellarV2_5_SetSharePriceOracle) GetRegistryId() string { if x != nil { - return x.AlternativeAsset + return x.RegistryId } return "" } -func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeHoldingPosition() uint32 { - if x != nil { - return x.AlternativeHoldingPosition - } - return 0 -} - -func (x *CellarV2_5_SetAlternativeAssetData) GetAlternativeAssetFee() uint32 { +func (x *CellarV2_5_SetSharePriceOracle) GetSharePriceOracle() string { if x != nil { - return x.AlternativeAssetFee + return x.SharePriceOracle } - return 0 + return "" } // -// Allows the strategist to stop an alternative asset from being deposited. +// Updates the cellar to use the latest price router in the registry. // -// Represents function `dropAlternativeAssetData(ERC20 _alternativeAsset)` -type CellarV2_5_DropAlternativeAssetData struct { +// Represents function `cachePriceRouter(bool checkTotalAssets, uint16 allowableRange, address expectedPriceRouter)` +type CellarV2_5_CachePriceRouter struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // The address of the alternative asset - AlternativeAsset string `protobuf:"bytes,1,opt,name=alternative_asset,json=alternativeAsset,proto3" json:"alternative_asset,omitempty"` + // Whether to check the total assets of the cellar + CheckTotalAssets bool `protobuf:"varint,1,opt,name=check_total_assets,json=checkTotalAssets,proto3" json:"check_total_assets,omitempty"` + // The allowable range of the cellar's total assets to deviate between old and new routers + AllowableRange uint32 `protobuf:"varint,2,opt,name=allowable_range,json=allowableRange,proto3" json:"allowable_range,omitempty"` + // The expected price router address + ExpectedPriceRouter string `protobuf:"bytes,3,opt,name=expected_price_router,json=expectedPriceRouter,proto3" json:"expected_price_router,omitempty"` } -func (x *CellarV2_5_DropAlternativeAssetData) Reset() { - *x = CellarV2_5_DropAlternativeAssetData{} +func (x *CellarV2_5_CachePriceRouter) Reset() { + *x = CellarV2_5_CachePriceRouter{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[56] + mi := &file_cellar_v2_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } } -func (x *CellarV2_5_DropAlternativeAssetData) String() string { +func (x *CellarV2_5_CachePriceRouter) String() string { return protoimpl.X.MessageStringOf(x) } -func (*CellarV2_5_DropAlternativeAssetData) ProtoMessage() {} +func (*CellarV2_5_CachePriceRouter) ProtoMessage() {} -func (x *CellarV2_5_DropAlternativeAssetData) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[56] +func (x *CellarV2_5_CachePriceRouter) ProtoReflect() protoreflect.Message { + mi := &file_cellar_v2_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4509,14 +5837,28 @@ func (x *CellarV2_5_DropAlternativeAssetData) ProtoReflect() protoreflect.Messag return mi.MessageOf(x) } -// Deprecated: Use CellarV2_5_DropAlternativeAssetData.ProtoReflect.Descriptor instead. -func (*CellarV2_5_DropAlternativeAssetData) Descriptor() ([]byte, []int) { - return file_cellar_v2_proto_rawDescGZIP(), []int{4, 16} +// Deprecated: Use CellarV2_5_CachePriceRouter.ProtoReflect.Descriptor instead. +func (*CellarV2_5_CachePriceRouter) Descriptor() ([]byte, []int) { + return file_cellar_v2_proto_rawDescGZIP(), []int{4, 22} } -func (x *CellarV2_5_DropAlternativeAssetData) GetAlternativeAsset() string { +func (x *CellarV2_5_CachePriceRouter) GetCheckTotalAssets() bool { if x != nil { - return x.AlternativeAsset + return x.CheckTotalAssets + } + return false +} + +func (x *CellarV2_5_CachePriceRouter) GetAllowableRange() uint32 { + if x != nil { + return x.AllowableRange + } + return 0 +} + +func (x *CellarV2_5_CachePriceRouter) GetExpectedPriceRouter() string { + if x != nil { + return x.ExpectedPriceRouter } return "" } @@ -4536,7 +5878,7 @@ type CellarV2_5Governance_AddAdaptorToCatalogue struct { func (x *CellarV2_5Governance_AddAdaptorToCatalogue) Reset() { *x = CellarV2_5Governance_AddAdaptorToCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[57] + mi := &file_cellar_v2_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4549,7 +5891,7 @@ func (x *CellarV2_5Governance_AddAdaptorToCatalogue) String() string { func (*CellarV2_5Governance_AddAdaptorToCatalogue) ProtoMessage() {} func (x *CellarV2_5Governance_AddAdaptorToCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[57] + mi := &file_cellar_v2_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4587,7 +5929,7 @@ type CellarV2_5Governance_AddPositionToCatalogue struct { func (x *CellarV2_5Governance_AddPositionToCatalogue) Reset() { *x = CellarV2_5Governance_AddPositionToCatalogue{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[58] + mi := &file_cellar_v2_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4600,7 +5942,7 @@ func (x *CellarV2_5Governance_AddPositionToCatalogue) String() string { func (*CellarV2_5Governance_AddPositionToCatalogue) ProtoMessage() {} func (x *CellarV2_5Governance_AddPositionToCatalogue) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[58] + mi := &file_cellar_v2_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4639,7 +5981,7 @@ type CellarV2_5Governance_SetRebalanceDeviation struct { func (x *CellarV2_5Governance_SetRebalanceDeviation) Reset() { *x = CellarV2_5Governance_SetRebalanceDeviation{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[59] + mi := &file_cellar_v2_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4652,7 +5994,7 @@ func (x *CellarV2_5Governance_SetRebalanceDeviation) String() string { func (*CellarV2_5Governance_SetRebalanceDeviation) ProtoMessage() {} func (x *CellarV2_5Governance_SetRebalanceDeviation) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[59] + mi := &file_cellar_v2_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4691,7 +6033,7 @@ type CellarV2_5Governance_SetStrategistPlatformCut struct { func (x *CellarV2_5Governance_SetStrategistPlatformCut) Reset() { *x = CellarV2_5Governance_SetStrategistPlatformCut{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[60] + mi := &file_cellar_v2_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4704,7 +6046,7 @@ func (x *CellarV2_5Governance_SetStrategistPlatformCut) String() string { func (*CellarV2_5Governance_SetStrategistPlatformCut) ProtoMessage() {} func (x *CellarV2_5Governance_SetStrategistPlatformCut) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[60] + mi := &file_cellar_v2_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4744,7 +6086,7 @@ type CellarV2_5Governance_ForcePositionOut struct { func (x *CellarV2_5Governance_ForcePositionOut) Reset() { *x = CellarV2_5Governance_ForcePositionOut{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[61] + mi := &file_cellar_v2_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4757,7 +6099,7 @@ func (x *CellarV2_5Governance_ForcePositionOut) String() string { func (*CellarV2_5Governance_ForcePositionOut) ProtoMessage() {} func (x *CellarV2_5Governance_ForcePositionOut) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[61] + mi := &file_cellar_v2_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4807,7 +6149,7 @@ type CellarV2_5Governance_ToggleIgnorePause struct { func (x *CellarV2_5Governance_ToggleIgnorePause) Reset() { *x = CellarV2_5Governance_ToggleIgnorePause{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[62] + mi := &file_cellar_v2_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4820,7 +6162,7 @@ func (x *CellarV2_5Governance_ToggleIgnorePause) String() string { func (*CellarV2_5Governance_ToggleIgnorePause) ProtoMessage() {} func (x *CellarV2_5Governance_ToggleIgnorePause) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[62] + mi := &file_cellar_v2_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4854,7 +6196,7 @@ type CellarV2_5Governance_SetAutomationActions struct { func (x *CellarV2_5Governance_SetAutomationActions) Reset() { *x = CellarV2_5Governance_SetAutomationActions{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[63] + mi := &file_cellar_v2_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4867,7 +6209,7 @@ func (x *CellarV2_5Governance_SetAutomationActions) String() string { func (*CellarV2_5Governance_SetAutomationActions) ProtoMessage() {} func (x *CellarV2_5Governance_SetAutomationActions) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[63] + mi := &file_cellar_v2_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4912,7 +6254,7 @@ type CellarV2_5Governance_IncreaseShareSupplyCap struct { func (x *CellarV2_5Governance_IncreaseShareSupplyCap) Reset() { *x = CellarV2_5Governance_IncreaseShareSupplyCap{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[64] + mi := &file_cellar_v2_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4925,7 +6267,7 @@ func (x *CellarV2_5Governance_IncreaseShareSupplyCap) String() string { func (*CellarV2_5Governance_IncreaseShareSupplyCap) ProtoMessage() {} func (x *CellarV2_5Governance_IncreaseShareSupplyCap) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[64] + mi := &file_cellar_v2_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4966,7 +6308,7 @@ type CellarV2_5Governance_SetSharePriceOracle struct { func (x *CellarV2_5Governance_SetSharePriceOracle) Reset() { *x = CellarV2_5Governance_SetSharePriceOracle{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[65] + mi := &file_cellar_v2_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4979,7 +6321,7 @@ func (x *CellarV2_5Governance_SetSharePriceOracle) String() string { func (*CellarV2_5Governance_SetSharePriceOracle) ProtoMessage() {} func (x *CellarV2_5Governance_SetSharePriceOracle) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[65] + mi := &file_cellar_v2_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5029,7 +6371,7 @@ type CellarV2_5Governance_CachePriceRouter struct { func (x *CellarV2_5Governance_CachePriceRouter) Reset() { *x = CellarV2_5Governance_CachePriceRouter{} if protoimpl.UnsafeEnabled { - mi := &file_cellar_v2_proto_msgTypes[66] + mi := &file_cellar_v2_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5042,7 +6384,7 @@ func (x *CellarV2_5Governance_CachePriceRouter) String() string { func (*CellarV2_5Governance_CachePriceRouter) ProtoMessage() {} func (x *CellarV2_5Governance_CachePriceRouter) ProtoReflect() protoreflect.Message { - mi := &file_cellar_v2_proto_msgTypes[66] + mi := &file_cellar_v2_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5132,46 +6474,104 @@ var file_cellar_v2_proto_rawDesc = []byte{ 0x72, 0x61, 0x5f, 0x65, 0x72, 0x63, 0x34, 0x36, 0x32, 0x36, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x12, 0x63, 0x6f, 0x6e, 0x76, 0x65, 0x78, 0x5f, 0x63, 0x75, 0x72, 0x76, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x0b, 0x63, 0x75, 0x72, 0x76, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x22, 0xa2, 0x09, 0x0a, 0x08, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x12, 0x45, - 0x0a, 0x0c, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, - 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4c, 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x6f, 0x6e, - 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, - 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x6f, 0x72, 0x12, 0x4e, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, - 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, - 0x56, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x12, 0x5b, 0x0a, 0x14, 0x73, 0x65, 0x74, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x69, - 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, - 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, - 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, - 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x12, 0x74, 0x0a, 0x1d, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, - 0x73, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, - 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, - 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, - 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, - 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, - 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4b, 0x0a, 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x73, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x5c, 0x0a, 0x15, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, - 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, - 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, - 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, 0x73, - 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, - 0x64, 0x1a, 0x97, 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6f, 0x22, 0x9d, 0x0f, 0x0a, 0x08, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x12, 0x4c, + 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x43, 0x61, + 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, + 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x4e, 0x0a, 0x0f, + 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, + 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5b, 0x0a, 0x14, + 0x73, 0x65, 0x74, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, + 0x2e, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, + 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x74, 0x0a, 0x1d, 0x73, 0x65, 0x74, + 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6f, + 0x75, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, + 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x48, 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, + 0x4b, 0x0a, 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x77, + 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x73, + 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5c, 0x0a, 0x15, + 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, + 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, + 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, + 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x45, 0x0a, 0x0c, 0x61, 0x64, + 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x20, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, + 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x48, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x75, 0x70, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, + 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, + 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0c, 0x73, + 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x54, 0x0a, 0x11, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x49, 0x6e, 0x69, + 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, + 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, + 0x6e, 0x12, 0x48, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, + 0x77, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, + 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x4c, + 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6c, + 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x4f, 0x0a, 0x10, 0x73, + 0x65, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x66, 0x65, 0x65, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x50, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, + 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x12, 0x6e, 0x0a, 0x1b, + 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, + 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, + 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, + 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x64, 0x0a, 0x17, + 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, + 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, + 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, + 0x72, 0x56, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, + 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x74, + 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x1a, 0x3c, 0x0a, 0x0d, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, + 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, + 0x1a, 0x4a, 0x0a, 0x0e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, + 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x35, 0x0a, 0x12, + 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x64, 0x1a, 0x34, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x1a, 0x65, 0x0a, 0x0d, 0x53, 0x77, 0x61, + 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x31, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x32, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x32, 0x12, 0x22, 0x0a, 0x0d, + 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x1a, 0x2f, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, + 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, + 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, + 0x6b, 0x1a, 0x97, 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, @@ -5180,289 +6580,249 @@ var file_cellar_v2_proto_rawDesc = []byte{ 0x20, 0x01, 0x28, 0x0c, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, - 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x3c, 0x0a, 0x0d, 0x43, - 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x04, - 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x65, - 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x43, - 0x61, 0x6c, 0x6c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x4a, 0x0a, 0x0e, 0x52, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, - 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, - 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x35, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, - 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, - 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x34, 0x0a, 0x1a, - 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, - 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, - 0x79, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x79, 0x6f, - 0x75, 0x74, 0x1a, 0x65, 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x31, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x31, 0x12, 0x17, 0x0a, 0x07, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x32, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, - 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, - 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x2f, 0x0a, 0x12, 0x53, 0x65, 0x74, - 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, - 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x6b, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, - 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xd7, 0x06, 0x0a, 0x12, 0x43, 0x65, 0x6c, 0x6c, 0x61, - 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x5e, 0x0a, - 0x11, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, - 0x77, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, + 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x12, 0x0a, 0x10, 0x49, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, + 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, + 0x28, 0x0a, 0x0e, 0x53, 0x65, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, + 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x32, 0x0a, 0x18, 0x53, 0x65, 0x74, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x28, 0x0a, + 0x0c, 0x53, 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, + 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, + 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x22, 0xd7, 0x06, 0x0a, 0x12, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, + 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x5e, 0x0a, 0x11, 0x69, 0x6e, 0x69, 0x74, + 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, + 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, + 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, + 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x52, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, + 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2b, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, + 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x0c, + 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x59, 0x0a, 0x10, + 0x73, 0x65, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x66, 0x65, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x46, 0x65, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, 0x74, 0x50, 0x6c, 0x61, 0x74, + 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x12, 0x78, 0x0a, 0x1b, 0x73, 0x65, 0x74, 0x5f, 0x73, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, + 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, + 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, + 0x72, 0x6d, 0x43, 0x75, 0x74, 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, + 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, + 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x75, 0x70, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, - 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, - 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, - 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x52, 0x0a, - 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, - 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, - 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, - 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, - 0x6e, 0x12, 0x59, 0x0a, 0x10, 0x73, 0x65, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, + 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x6e, 0x0a, 0x17, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x15, + 0x73, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x12, 0x0a, 0x10, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, + 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, + 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x28, 0x0a, 0x0e, 0x53, 0x65, 0x74, + 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x61, + 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, + 0x75, 0x6e, 0x74, 0x1a, 0x32, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, + 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x28, 0x0a, 0x0c, 0x53, 0x65, 0x74, 0x75, 0x70, + 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, + 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, + 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x42, + 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xf3, 0x16, 0x0a, 0x0a, + 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x12, 0x4a, 0x0a, 0x0d, 0x66, 0x75, + 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, + 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x40, 0x0a, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x63, + 0x61, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x74, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, + 0x32, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x09, 0x6d, + 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x1a, 0xaa, 0x0c, 0x0a, 0x0c, 0x46, 0x75, 0x6e, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x47, 0x0a, 0x0c, 0x61, 0x64, 0x64, + 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x6f, 0x6e, 0x5f, 0x61, 0x64, + 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, - 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x50, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x48, 0x00, 0x52, 0x0e, 0x73, 0x65, - 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, 0x12, 0x78, 0x0a, 0x1b, - 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x37, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, - 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, - 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, - 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, - 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, - 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x52, 0x0a, 0x0d, 0x73, 0x65, 0x74, 0x75, 0x70, 0x5f, - 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, - 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, - 0x72, 0x56, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, - 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x65, - 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x6e, 0x0a, 0x17, 0x73, 0x65, - 0x74, 0x5f, 0x72, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x73, 0x74, + 0x32, 0x5f, 0x32, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x12, 0x50, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, - 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x52, + 0x32, 0x5f, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x61, + 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, + 0x32, 0x5f, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, + 0x52, 0x1a, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, + 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x79, 0x0a, 0x1e, + 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x52, 0x65, 0x6d, + 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x1b, 0x72, 0x65, 0x6d, 0x6f, + 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, + 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x5d, 0x0a, 0x14, 0x73, 0x65, 0x74, 0x5f, 0x68, + 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x65, + 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, + 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x5f, + 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, + 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, + 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, + 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, + 0x48, 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4d, + 0x0a, 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, + 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0d, + 0x73, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x67, 0x0a, + 0x18, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x6f, 0x5f, + 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2c, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, + 0x15, 0x61, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, + 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x6a, 0x0a, 0x19, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, + 0x67, 0x75, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, + 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, + 0x32, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x16, 0x61, 0x64, 0x64, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, + 0x75, 0x65, 0x12, 0x66, 0x0a, 0x17, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, - 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x12, 0x0a, 0x10, 0x49, 0x6e, - 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x0e, - 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x28, - 0x0a, 0x0e, 0x53, 0x65, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x46, 0x65, 0x65, - 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x32, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, - 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, - 0x6d, 0x43, 0x75, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x61, 0x6d, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x28, 0x0a, 0x0c, - 0x53, 0x65, 0x74, 0x75, 0x70, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, - 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, - 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0x91, 0x0d, 0x0a, 0x0a, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x12, - 0x4a, 0x0a, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, - 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x46, - 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0c, 0x66, - 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x40, 0x0a, 0x09, 0x6d, - 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, - 0x48, 0x00, 0x52, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x1a, 0x9e, 0x06, - 0x0a, 0x0c, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x47, - 0x0a, 0x0c, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, - 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x41, 0x64, 0x64, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, - 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, - 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x50, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x25, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, - 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x72, 0x65, 0x6d, - 0x6f, 0x76, 0x65, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x66, 0x72, 0x6f, 0x6d, - 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, - 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, - 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x1a, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, - 0x65, 0x12, 0x79, 0x0a, 0x1e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, - 0x67, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x74, 0x65, 0x77, + 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5e, 0x0a, 0x15, 0x73, 0x65, + 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, 0x65, 0x72, + 0x69, 0x6f, 0x64, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, - 0x32, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, - 0x1b, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, - 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x5d, 0x0a, 0x14, - 0x73, 0x65, 0x74, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x65, - 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, - 0x5f, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, - 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x73, - 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x61, - 0x79, 0x6f, 0x75, 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, - 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, - 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, - 0x64, 0x72, 0x65, 0x73, 0x73, 0x48, 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, - 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, - 0x65, 0x73, 0x73, 0x12, 0x4d, 0x0a, 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, + 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, + 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, + 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x70, 0x0a, 0x1b, 0x73, 0x65, + 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x6c, 0x61, + 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, + 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, + 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x56, 0x0a, 0x11, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, + 0x6e, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, + 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, + 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x4a, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, + 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, - 0x32, 0x5f, 0x32, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x48, 0x00, 0x52, 0x0d, 0x73, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x97, - 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, - 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, - 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x0c, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, - 0x44, 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, - 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, - 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x3c, 0x0a, 0x0d, 0x43, 0x61, 0x6c, 0x6c, - 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x04, 0x64, 0x61, 0x74, - 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x43, 0x61, 0x6c, 0x6c, - 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x4a, 0x0a, 0x0e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, - 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, - 0x61, 0x79, 0x1a, 0x36, 0x0a, 0x1a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, - 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, - 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x3e, 0x0a, 0x1b, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, - 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x35, 0x0a, 0x12, 0x53, 0x65, - 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x32, 0x5f, 0x32, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x48, 0x00, 0x52, 0x0c, 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x12, 0x57, 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, + 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x63, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, + 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x97, 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2d, 0x0a, 0x12, + 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, + 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x69, + 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, + 0x3c, 0x0a, 0x0d, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, + 0x12, 0x2b, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, + 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x6f, 0x72, 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x4a, 0x0a, + 0x0e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, + 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, + 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x36, 0x0a, 0x1a, 0x52, 0x65, 0x6d, + 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, + 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x1a, 0x3e, 0x0a, 0x1b, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x64, 0x1a, 0x34, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, - 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, - 0x16, 0x0a, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x1a, 0x65, 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, - 0x31, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x32, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, - 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x57, - 0x0a, 0x09, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x12, 0x4a, 0x0a, 0x0e, 0x66, - 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, - 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, - 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x2e, 0x46, 0x75, 0x6e, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x42, 0x0b, 0x0a, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x5f, - 0x74, 0x79, 0x70, 0x65, 0x22, 0xb9, 0x0d, 0x0a, 0x14, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, - 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x71, 0x0a, - 0x18, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x6f, 0x5f, - 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x36, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, - 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, - 0x65, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, - 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x15, 0x61, 0x64, 0x64, 0x41, 0x64, - 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, - 0x12, 0x74, 0x0a, 0x19, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, - 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, - 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x16, - 0x61, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, - 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x70, 0x0a, 0x17, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, - 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, - 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, - 0x00, 0x52, 0x15, 0x73, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, - 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x68, 0x0a, 0x15, 0x73, 0x65, 0x74, 0x5f, - 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, - 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, - 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, - 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, - 0x73, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, - 0x6f, 0x64, 0x12, 0x7a, 0x0a, 0x1b, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, - 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, - 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, - 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, - 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, - 0x75, 0x74, 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, - 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x60, - 0x0a, 0x11, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, - 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, - 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x69, 0x74, - 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x10, - 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, - 0x12, 0x54, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, - 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, - 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, - 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, - 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x61, 0x0a, 0x12, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x5f, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, - 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, - 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x48, 0x00, 0x52, 0x10, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x12, 0x64, 0x0a, 0x13, 0x74, 0x6f, 0x67, - 0x67, 0x6c, 0x65, 0x5f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x70, 0x61, 0x75, 0x73, 0x65, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, - 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, - 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x54, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x49, - 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x48, 0x00, 0x52, 0x11, 0x74, 0x6f, - 0x67, 0x67, 0x6c, 0x65, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x12, - 0x61, 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x72, - 0x6f, 0x75, 0x74, 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, - 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, - 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x61, - 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x48, 0x00, - 0x52, 0x10, 0x63, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, - 0x65, 0x72, 0x1a, 0x31, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, - 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, - 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, - 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x39, 0x0a, 0x16, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, - 0x1a, 0x2f, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, - 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, - 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, - 0x6b, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, - 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, - 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, - 0x12, 0x0a, 0x10, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x1a, 0x33, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, - 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, - 0x17, 0x0a, 0x07, 0x6e, 0x65, 0x77, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x06, 0x6e, 0x65, 0x77, 0x43, 0x75, 0x74, 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, - 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x6d, 0x0a, 0x10, 0x46, 0x6f, 0x72, 0x63, - 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x12, 0x14, 0x0a, 0x05, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, - 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x64, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, - 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, - 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x2b, 0x0a, 0x11, 0x54, 0x6f, 0x67, 0x67, 0x6c, - 0x65, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, - 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x67, - 0x6e, 0x6f, 0x72, 0x65, 0x1a, 0x9d, 0x01, 0x0a, 0x10, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, + 0x64, 0x1a, 0x35, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x34, 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x1a, 0x65, + 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x31, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x32, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, + 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, + 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x57, 0x0a, 0x09, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, + 0x6c, 0x6c, 0x12, 0x4a, 0x0a, 0x0e, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, + 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, + 0x5f, 0x32, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x52, + 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x1a, 0x31, + 0x0a, 0x15, 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, + 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x1a, 0x39, 0x0a, 0x16, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, + 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x2f, 0x0a, 0x12, + 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, + 0x6f, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x6b, 0x1a, 0x3c, 0x0a, + 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, + 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, + 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, + 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x12, 0x0a, 0x10, 0x49, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, + 0x33, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, + 0x65, 0x77, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x65, + 0x77, 0x43, 0x75, 0x74, 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, + 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x9d, 0x01, 0x0a, 0x10, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x6f, 0x74, 0x61, @@ -5472,178 +6832,361 @@ var file_cellar_v2_proto_rawDesc = []byte{ 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, - 0x75, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x22, 0xb0, 0x15, 0x0a, 0x0a, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x12, - 0x4a, 0x0a, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, - 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x46, - 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0c, 0x66, - 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x40, 0x0a, 0x09, 0x6d, - 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, - 0x48, 0x00, 0x52, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x1a, 0xef, 0x0a, - 0x0a, 0x0c, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x47, - 0x0a, 0x0c, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, - 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x41, 0x64, 0x64, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, - 0x6f, 0x6e, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, - 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, - 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, - 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x50, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x25, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, - 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5d, 0x0a, 0x14, 0x73, 0x65, 0x74, - 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, - 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, - 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x73, 0x65, 0x74, 0x5f, - 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, - 0x74, 0x5f, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, - 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, - 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x48, 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, - 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x12, 0x4d, 0x0a, 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, - 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, - 0x2e, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, - 0x52, 0x0d, 0x73, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, - 0x5e, 0x0a, 0x15, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, - 0x6b, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, + 0x75, 0x74, 0x65, 0x72, 0x42, 0x0b, 0x0a, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x79, 0x70, + 0x65, 0x22, 0xb9, 0x0d, 0x0a, 0x14, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, + 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x18, 0x61, 0x64, + 0x64, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x61, 0x74, + 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, + 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x41, + 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, + 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x15, 0x61, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x74, 0x0a, + 0x19, 0x61, 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, + 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x37, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, + 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, + 0x63, 0x65, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, + 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x16, 0x61, 0x64, 0x64, + 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, + 0x67, 0x75, 0x65, 0x12, 0x70, 0x0a, 0x17, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x15, + 0x73, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x68, 0x0a, 0x15, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, + 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, - 0x56, 0x0a, 0x11, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, - 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, - 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, - 0x5f, 0x35, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, - 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x4a, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, - 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, - 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, - 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, + 0x7a, 0x0a, 0x1b, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x5f, 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x48, + 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x60, 0x0a, 0x11, 0x69, + 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, + 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, + 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, + 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x54, 0x0a, + 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, + 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x48, 0x00, 0x52, 0x0c, 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, - 0x6f, 0x77, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x61, 0x64, - 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, - 0x6f, 0x67, 0x75, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, - 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, - 0x5f, 0x35, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, - 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, - 0x1a, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, - 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x79, 0x0a, 0x1e, 0x72, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, - 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x0f, 0x20, + 0x6f, 0x77, 0x6e, 0x12, 0x61, 0x0a, 0x12, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x5f, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6f, 0x75, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, + 0x65, 0x2e, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4f, + 0x75, 0x74, 0x48, 0x00, 0x52, 0x10, 0x66, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x12, 0x64, 0x0a, 0x13, 0x74, 0x6f, 0x67, 0x67, 0x6c, 0x65, + 0x5f, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x5f, 0x70, 0x61, 0x75, 0x73, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, - 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x52, 0x65, 0x6d, 0x6f, - 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, - 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x1b, 0x72, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, - 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x6a, 0x0a, 0x19, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, - 0x73, 0x65, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x5f, - 0x63, 0x61, 0x70, 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, - 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, - 0x35, 0x2e, 0x44, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, - 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x61, 0x70, 0x48, 0x00, 0x52, 0x16, 0x64, 0x65, 0x63, 0x72, - 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, - 0x61, 0x70, 0x12, 0x6d, 0x0a, 0x1a, 0x73, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, - 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, - 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, - 0x65, 0x74, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, - 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x17, 0x73, 0x65, 0x74, 0x41, 0x6c, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x12, 0x70, 0x0a, 0x1b, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, - 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, 0x47, 0x6f, 0x76, 0x65, 0x72, + 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x54, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x49, 0x67, 0x6e, 0x6f, + 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x48, 0x00, 0x52, 0x11, 0x74, 0x6f, 0x67, 0x67, 0x6c, + 0x65, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x12, + 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x6f, 0x75, 0x74, + 0x65, 0x72, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, + 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x32, + 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x63, + 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x1a, + 0x31, 0x0a, 0x15, 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, + 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x1a, 0x39, 0x0a, 0x16, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x2f, 0x0a, + 0x12, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, + 0x69, 0x6f, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x6b, 0x1a, 0x3c, + 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, + 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, + 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x12, 0x0a, 0x10, + 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x1a, 0x33, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, 0x17, 0x0a, 0x07, + 0x6e, 0x65, 0x77, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, + 0x65, 0x77, 0x43, 0x75, 0x74, 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, + 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x6d, 0x0a, 0x10, 0x46, 0x6f, 0x72, 0x63, 0x65, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x75, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, + 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, + 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, + 0x72, 0x72, 0x61, 0x79, 0x1a, 0x2b, 0x0a, 0x11, 0x54, 0x6f, 0x67, 0x67, 0x6c, 0x65, 0x49, 0x67, + 0x6e, 0x6f, 0x72, 0x65, 0x50, 0x61, 0x75, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x69, 0x67, 0x6e, + 0x6f, 0x72, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x67, 0x6e, 0x6f, 0x72, + 0x65, 0x1a, 0x9d, 0x01, 0x0a, 0x10, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, + 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x12, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x5f, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x73, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x41, 0x73, + 0x73, 0x65, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x62, 0x6c, + 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0e, 0x61, + 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x32, 0x0a, + 0x15, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, + 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x65, 0x78, + 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, + 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0xe3, 0x1e, + 0x0a, 0x0a, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x12, 0x4a, 0x0a, 0x0d, + 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x46, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, 0x0c, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x40, 0x0a, 0x09, 0x6d, 0x75, 0x6c, 0x74, + 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x73, 0x74, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, + 0x32, 0x5f, 0x35, 0x2e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x48, 0x00, 0x52, + 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x1a, 0xc6, 0x10, 0x0a, 0x0c, 0x46, + 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x12, 0x47, 0x0a, 0x0c, 0x61, + 0x64, 0x64, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x22, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, + 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, 0x61, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x0f, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x6f, 0x6e, 0x5f, + 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, + 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, + 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, + 0x74, 0x6f, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x63, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, + 0x70, 0x74, 0x6f, 0x72, 0x12, 0x50, 0x0a, 0x0f, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, + 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, + 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x5d, 0x0a, 0x14, 0x73, 0x65, 0x74, 0x5f, 0x68, 0x6f, + 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, + 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, + 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x48, + 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x76, 0x0a, 0x1d, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, + 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x5f, 0x61, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, + 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, + 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x48, + 0x00, 0x52, 0x1a, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, + 0x50, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x4d, 0x0a, + 0x0e, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x77, + 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x73, + 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x5e, 0x0a, 0x15, + 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x70, + 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x73, 0x74, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, + 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, + 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x48, 0x00, 0x52, 0x12, 0x73, 0x65, 0x74, 0x53, 0x68, 0x61, + 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x56, 0x0a, 0x11, + 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, + 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, + 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x48, 0x00, 0x52, 0x10, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, + 0x64, 0x6f, 0x77, 0x6e, 0x12, 0x4a, 0x0a, 0x0d, 0x6c, 0x69, 0x66, 0x74, 0x5f, 0x73, 0x68, 0x75, + 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, + 0x32, 0x5f, 0x35, 0x2e, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x48, 0x00, 0x52, 0x0c, 0x6c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x12, 0x76, 0x0a, 0x1d, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x5f, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, + 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, + 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, + 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, + 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x1a, 0x72, 0x65, + 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, + 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x79, 0x0a, 0x1e, 0x72, 0x65, 0x6d, 0x6f, + 0x76, 0x65, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x66, 0x72, 0x6f, 0x6d, + 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x32, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, + 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, + 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x1b, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, + 0x67, 0x75, 0x65, 0x12, 0x6a, 0x0a, 0x19, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x5f, + 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x63, 0x61, 0x70, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x44, - 0x72, 0x6f, 0x70, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, - 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x18, 0x64, 0x72, 0x6f, 0x70, 0x41, + 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, + 0x6c, 0x79, 0x43, 0x61, 0x70, 0x48, 0x00, 0x52, 0x16, 0x64, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, + 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x61, 0x70, 0x12, + 0x6d, 0x0a, 0x1a, 0x73, 0x65, 0x74, 0x5f, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x11, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2e, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, - 0x61, 0x74, 0x61, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x1a, - 0x97, 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, - 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0c, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, - 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, - 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x3c, 0x0a, 0x0d, 0x43, 0x61, 0x6c, - 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x2b, 0x0a, 0x04, 0x64, 0x61, - 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, - 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x43, 0x61, 0x6c, - 0x6c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x4a, 0x0a, 0x0e, 0x52, 0x65, 0x6d, 0x6f, 0x76, - 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, - 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, - 0x72, 0x61, 0x79, 0x1a, 0x35, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, - 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, + 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x17, 0x73, 0x65, 0x74, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x70, + 0x0a, 0x1b, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x12, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, + 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x44, 0x72, 0x6f, 0x70, + 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x44, 0x61, 0x74, 0x61, 0x48, 0x00, 0x52, 0x18, 0x64, 0x72, 0x6f, 0x70, 0x41, 0x6c, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, + 0x12, 0x67, 0x0a, 0x18, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, + 0x74, 0x6f, 0x5f, 0x63, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x13, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, + 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x41, 0x64, 0x64, 0x41, 0x64, + 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, + 0x48, 0x00, 0x52, 0x15, 0x61, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, + 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x6a, 0x0a, 0x19, 0x61, 0x64, 0x64, + 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x6f, 0x5f, 0x63, 0x61, 0x74, + 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, + 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x48, 0x00, 0x52, 0x16, 0x61, + 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x66, 0x0a, 0x17, 0x73, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x62, + 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2c, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, + 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, + 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x15, 0x73, 0x65, 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x70, 0x0a, + 0x1b, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x5f, + 0x70, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x5f, 0x63, 0x75, 0x74, 0x18, 0x16, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, + 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x74, + 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, + 0x43, 0x75, 0x74, 0x48, 0x00, 0x52, 0x18, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x43, 0x75, 0x74, 0x12, + 0x61, 0x0a, 0x16, 0x73, 0x65, 0x74, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x65, 0x5f, 0x70, 0x72, 0x69, + 0x63, 0x65, 0x5f, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x2a, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, + 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, + 0x50, 0x72, 0x69, 0x63, 0x65, 0x4f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x48, 0x00, 0x52, 0x13, 0x73, + 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x4f, 0x72, 0x61, 0x63, + 0x6c, 0x65, 0x12, 0x6a, 0x0a, 0x19, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x5f, 0x73, + 0x68, 0x61, 0x72, 0x65, 0x5f, 0x73, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x5f, 0x63, 0x61, 0x70, 0x18, + 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x49, 0x6e, + 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, + 0x79, 0x43, 0x61, 0x70, 0x48, 0x00, 0x52, 0x16, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, + 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x61, 0x70, 0x12, 0x57, + 0x0a, 0x12, 0x63, 0x61, 0x63, 0x68, 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x73, 0x74, 0x65, + 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, + 0x5f, 0x35, 0x2e, 0x43, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, + 0x74, 0x65, 0x72, 0x48, 0x00, 0x52, 0x10, 0x63, 0x61, 0x63, 0x68, 0x65, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x42, 0x0a, 0x0a, 0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x1a, 0x97, 0x01, 0x0a, 0x0b, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x2d, 0x0a, 0x12, 0x63, 0x6f, + 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x64, 0x61, 0x74, 0x61, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x11, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, + 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x3c, 0x0a, + 0x0d, 0x43, 0x61, 0x6c, 0x6c, 0x4f, 0x6e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x2b, + 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x73, + 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x1a, 0x4a, 0x0a, 0x0e, 0x52, + 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x14, 0x0a, + 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, + 0x72, 0x72, 0x61, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, + 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x35, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x48, 0x6f, + 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, + 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x34, + 0x0a, 0x1a, 0x53, 0x65, 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, + 0x61, 0x79, 0x6f, 0x75, 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, + 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, + 0x79, 0x6f, 0x75, 0x74, 0x1a, 0x65, 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x31, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x31, 0x12, 0x17, + 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x32, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, + 0x62, 0x74, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, + 0x69, 0x6e, 0x44, 0x65, 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x2f, 0x0a, 0x12, 0x53, + 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, + 0x64, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x6b, 0x1a, 0x12, 0x0a, 0x10, + 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, + 0x1a, 0x57, 0x0a, 0x09, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x12, 0x4a, 0x0a, + 0x0e, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, + 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, + 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x46, 0x75, + 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x0d, 0x66, 0x75, 0x6e, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, 0x6c, 0x6c, 0x73, 0x1a, 0x36, 0x0a, 0x1a, 0x52, 0x65, 0x6d, + 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, + 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, + 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, + 0x72, 0x1a, 0x3e, 0x0a, 0x1b, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, + 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x64, 0x1a, 0x31, 0x0a, 0x16, 0x44, 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, + 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, 0x6c, 0x79, 0x43, 0x61, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x6e, + 0x65, 0x77, 0x5f, 0x63, 0x61, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x65, + 0x77, 0x43, 0x61, 0x70, 0x1a, 0xbc, 0x01, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x41, 0x6c, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, + 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, + 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, 0x6c, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x40, 0x0a, + 0x1c, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x68, 0x6f, 0x6c, + 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0d, 0x52, 0x1a, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x32, 0x0a, 0x15, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, + 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, + 0x46, 0x65, 0x65, 0x1a, 0x47, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x41, 0x6c, 0x74, 0x65, 0x72, + 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, + 0x2b, 0x0a, 0x11, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, + 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, 0x6c, 0x74, 0x65, + 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x1a, 0x31, 0x0a, 0x15, + 0x41, 0x64, 0x64, 0x41, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x43, 0x61, 0x74, 0x61, + 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, + 0x39, 0x0a, 0x16, 0x41, 0x64, 0x64, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, + 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, - 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x34, 0x0a, 0x1a, 0x53, 0x65, - 0x74, 0x53, 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x61, 0x79, 0x6f, 0x75, - 0x74, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x70, 0x61, 0x79, 0x6f, - 0x75, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x70, 0x61, 0x79, 0x6f, 0x75, 0x74, - 0x1a, 0x65, 0x0a, 0x0d, 0x53, 0x77, 0x61, 0x70, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x31, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x31, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x6e, - 0x64, 0x65, 0x78, 0x5f, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x06, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x32, 0x12, 0x22, 0x0a, 0x0d, 0x69, 0x6e, 0x5f, 0x64, 0x65, 0x62, 0x74, 0x5f, 0x61, - 0x72, 0x72, 0x61, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x69, 0x6e, 0x44, 0x65, - 0x62, 0x74, 0x41, 0x72, 0x72, 0x61, 0x79, 0x1a, 0x2f, 0x0a, 0x12, 0x53, 0x65, 0x74, 0x53, 0x68, - 0x61, 0x72, 0x65, 0x4c, 0x6f, 0x63, 0x6b, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x19, 0x0a, - 0x08, 0x6e, 0x65, 0x77, 0x5f, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x07, 0x6e, 0x65, 0x77, 0x4c, 0x6f, 0x63, 0x6b, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, 0x74, 0x52, - 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, 0x65, 0x76, - 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x12, 0x0a, 0x10, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, - 0x74, 0x65, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x0e, 0x0a, 0x0c, 0x4c, 0x69, - 0x66, 0x74, 0x53, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x1a, 0x57, 0x0a, 0x09, 0x4d, 0x75, - 0x6c, 0x74, 0x69, 0x63, 0x61, 0x6c, 0x6c, 0x12, 0x4a, 0x0a, 0x0e, 0x66, 0x75, 0x6e, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x63, 0x61, 0x6c, 0x6c, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x23, 0x2e, 0x73, 0x74, 0x65, 0x77, 0x61, 0x72, 0x64, 0x2e, 0x76, 0x34, 0x2e, 0x43, 0x65, 0x6c, - 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x2e, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x43, 0x61, 0x6c, 0x6c, 0x52, 0x0d, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x61, - 0x6c, 0x6c, 0x73, 0x1a, 0x36, 0x0a, 0x1a, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x41, 0x64, 0x61, - 0x70, 0x74, 0x6f, 0x72, 0x46, 0x72, 0x6f, 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, - 0x65, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x1a, 0x3e, 0x0a, 0x1b, 0x52, - 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, - 0x6d, 0x43, 0x61, 0x74, 0x61, 0x6c, 0x6f, 0x67, 0x75, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x70, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, - 0x0a, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x31, 0x0a, 0x16, 0x44, - 0x65, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, 0x70, 0x70, - 0x6c, 0x79, 0x43, 0x61, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x65, 0x77, 0x5f, 0x63, 0x61, 0x70, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x65, 0x77, 0x43, 0x61, 0x70, 0x1a, 0xbc, - 0x01, 0x0a, 0x17, 0x53, 0x65, 0x74, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, - 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x6c, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, - 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x12, 0x40, 0x0a, 0x1c, 0x61, 0x6c, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x68, 0x6f, 0x6c, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x70, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x1a, 0x61, - 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x48, 0x6f, 0x6c, 0x64, 0x69, 0x6e, - 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x15, 0x61, 0x6c, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x5f, 0x66, - 0x65, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x74, 0x69, 0x76, 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x46, 0x65, 0x65, 0x1a, 0x47, 0x0a, - 0x18, 0x44, 0x72, 0x6f, 0x70, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, - 0x41, 0x73, 0x73, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2b, 0x0a, 0x11, 0x61, 0x6c, 0x74, - 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, - 0x65, 0x41, 0x73, 0x73, 0x65, 0x74, 0x42, 0x0b, 0x0a, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x74, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x1a, 0x3c, 0x0a, 0x15, 0x53, 0x65, + 0x74, 0x52, 0x65, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x44, 0x65, 0x76, 0x69, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x77, 0x5f, 0x64, 0x65, 0x76, 0x69, 0x61, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6e, 0x65, 0x77, 0x44, + 0x65, 0x76, 0x69, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x33, 0x0a, 0x18, 0x53, 0x65, 0x74, 0x53, + 0x74, 0x72, 0x61, 0x74, 0x65, 0x67, 0x69, 0x73, 0x74, 0x50, 0x6c, 0x61, 0x74, 0x66, 0x6f, 0x72, + 0x6d, 0x43, 0x75, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x65, 0x77, 0x5f, 0x63, 0x75, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x6e, 0x65, 0x77, 0x43, 0x75, 0x74, 0x1a, 0x31, 0x0a, + 0x16, 0x49, 0x6e, 0x63, 0x72, 0x65, 0x61, 0x73, 0x65, 0x53, 0x68, 0x61, 0x72, 0x65, 0x53, 0x75, + 0x70, 0x70, 0x6c, 0x79, 0x43, 0x61, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x65, 0x77, 0x5f, 0x63, + 0x61, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x65, 0x77, 0x43, 0x61, 0x70, + 0x1a, 0x64, 0x0a, 0x13, 0x53, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x65, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x4f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x67, 0x69, 0x73, + 0x74, 0x72, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x72, 0x65, + 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x49, 0x64, 0x12, 0x2c, 0x0a, 0x12, 0x73, 0x68, 0x61, 0x72, + 0x65, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x5f, 0x6f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x73, 0x68, 0x61, 0x72, 0x65, 0x50, 0x72, 0x69, 0x63, 0x65, + 0x4f, 0x72, 0x61, 0x63, 0x6c, 0x65, 0x1a, 0x9d, 0x01, 0x0a, 0x10, 0x43, 0x61, 0x63, 0x68, 0x65, + 0x50, 0x72, 0x69, 0x63, 0x65, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x12, 0x2c, 0x0a, 0x12, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x5f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x61, 0x73, 0x73, 0x65, 0x74, + 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x54, 0x6f, + 0x74, 0x61, 0x6c, 0x41, 0x73, 0x73, 0x65, 0x74, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0d, 0x52, 0x0e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x61, 0x62, 0x6c, 0x65, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x5f, 0x70, + 0x72, 0x69, 0x63, 0x65, 0x5f, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x13, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x72, 0x69, 0x63, 0x65, + 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x42, 0x0b, 0x0a, 0x09, 0x63, 0x61, 0x6c, 0x6c, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x22, 0x8e, 0x0f, 0x0a, 0x14, 0x43, 0x65, 0x6c, 0x6c, 0x61, 0x72, 0x56, 0x32, 0x5f, 0x35, 0x47, 0x6f, 0x76, 0x65, 0x72, 0x6e, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x71, 0x0a, 0x18, 0x61, 0x64, 0x64, 0x5f, 0x61, 0x64, 0x61, 0x70, 0x74, 0x6f, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x63, @@ -5998,7 +7541,7 @@ func file_cellar_v2_proto_rawDescGZIP() []byte { return file_cellar_v2_proto_rawDescData } -var file_cellar_v2_proto_msgTypes = make([]protoimpl.MessageInfo, 67) +var file_cellar_v2_proto_msgTypes = make([]protoimpl.MessageInfo, 87) var file_cellar_v2_proto_goTypes = []interface{}{ (*CellarV2)(nil), // 0: steward.v4.CellarV2 (*CellarV2Governance)(nil), // 1: steward.v4.CellarV2Governance @@ -6007,203 +7550,244 @@ var file_cellar_v2_proto_goTypes = []interface{}{ (*CellarV2_5)(nil), // 4: steward.v4.CellarV2_5 (*CellarV2_5Governance)(nil), // 5: steward.v4.CellarV2_5Governance (*AdaptorCall)(nil), // 6: steward.v4.AdaptorCall - (*CellarV2_AddPosition)(nil), // 7: steward.v4.CellarV2.AddPosition - (*CellarV2_CallOnAdaptor)(nil), // 8: steward.v4.CellarV2.CallOnAdaptor - (*CellarV2_RemovePosition)(nil), // 9: steward.v4.CellarV2.RemovePosition - (*CellarV2_SetHoldingPosition)(nil), // 10: steward.v4.CellarV2.SetHoldingPosition - (*CellarV2_SetStrategistPayoutAddress)(nil), // 11: steward.v4.CellarV2.SetStrategistPayoutAddress - (*CellarV2_SwapPositions)(nil), // 12: steward.v4.CellarV2.SwapPositions - (*CellarV2_SetShareLockPeriod)(nil), // 13: steward.v4.CellarV2.SetShareLockPeriod - (*CellarV2Governance_InitiateShutdown)(nil), // 14: steward.v4.CellarV2Governance.InitiateShutdown - (*CellarV2Governance_LiftShutdown)(nil), // 15: steward.v4.CellarV2Governance.LiftShutdown - (*CellarV2Governance_SetPlatformFee)(nil), // 16: steward.v4.CellarV2Governance.SetPlatformFee - (*CellarV2Governance_SetStrategistPlatformCut)(nil), // 17: steward.v4.CellarV2Governance.SetStrategistPlatformCut - (*CellarV2Governance_SetupAdaptor)(nil), // 18: steward.v4.CellarV2Governance.SetupAdaptor - (*CellarV2Governance_SetRebalanceDeviation)(nil), // 19: steward.v4.CellarV2Governance.SetRebalanceDeviation - (*CellarV2_2_FunctionCall)(nil), // 20: steward.v4.CellarV2_2.FunctionCall - (*CellarV2_2_AddPosition)(nil), // 21: steward.v4.CellarV2_2.AddPosition - (*CellarV2_2_CallOnAdaptor)(nil), // 22: steward.v4.CellarV2_2.CallOnAdaptor - (*CellarV2_2_RemovePosition)(nil), // 23: steward.v4.CellarV2_2.RemovePosition - (*CellarV2_2_RemoveAdaptorFromCatalogue)(nil), // 24: steward.v4.CellarV2_2.RemoveAdaptorFromCatalogue - (*CellarV2_2_RemovePositionFromCatalogue)(nil), // 25: steward.v4.CellarV2_2.RemovePositionFromCatalogue - (*CellarV2_2_SetHoldingPosition)(nil), // 26: steward.v4.CellarV2_2.SetHoldingPosition - (*CellarV2_2_SetStrategistPayoutAddress)(nil), // 27: steward.v4.CellarV2_2.SetStrategistPayoutAddress - (*CellarV2_2_SwapPositions)(nil), // 28: steward.v4.CellarV2_2.SwapPositions - (*CellarV2_2_Multicall)(nil), // 29: steward.v4.CellarV2_2.Multicall - (*CellarV2_2Governance_AddAdaptorToCatalogue)(nil), // 30: steward.v4.CellarV2_2Governance.AddAdaptorToCatalogue - (*CellarV2_2Governance_AddPositionToCatalogue)(nil), // 31: steward.v4.CellarV2_2Governance.AddPositionToCatalogue - (*CellarV2_2Governance_SetShareLockPeriod)(nil), // 32: steward.v4.CellarV2_2Governance.SetShareLockPeriod - (*CellarV2_2Governance_SetRebalanceDeviation)(nil), // 33: steward.v4.CellarV2_2Governance.SetRebalanceDeviation - (*CellarV2_2Governance_InitiateShutdown)(nil), // 34: steward.v4.CellarV2_2Governance.InitiateShutdown - (*CellarV2_2Governance_SetStrategistPlatformCut)(nil), // 35: steward.v4.CellarV2_2Governance.SetStrategistPlatformCut - (*CellarV2_2Governance_LiftShutdown)(nil), // 36: steward.v4.CellarV2_2Governance.LiftShutdown - (*CellarV2_2Governance_ForcePositionOut)(nil), // 37: steward.v4.CellarV2_2Governance.ForcePositionOut - (*CellarV2_2Governance_ToggleIgnorePause)(nil), // 38: steward.v4.CellarV2_2Governance.ToggleIgnorePause - (*CellarV2_2Governance_CachePriceRouter)(nil), // 39: steward.v4.CellarV2_2Governance.CachePriceRouter - (*CellarV2_5_FunctionCall)(nil), // 40: steward.v4.CellarV2_5.FunctionCall - (*CellarV2_5_AddPosition)(nil), // 41: steward.v4.CellarV2_5.AddPosition - (*CellarV2_5_CallOnAdaptor)(nil), // 42: steward.v4.CellarV2_5.CallOnAdaptor - (*CellarV2_5_RemovePosition)(nil), // 43: steward.v4.CellarV2_5.RemovePosition - (*CellarV2_5_SetHoldingPosition)(nil), // 44: steward.v4.CellarV2_5.SetHoldingPosition - (*CellarV2_5_SetStrategistPayoutAddress)(nil), // 45: steward.v4.CellarV2_5.SetStrategistPayoutAddress - (*CellarV2_5_SwapPositions)(nil), // 46: steward.v4.CellarV2_5.SwapPositions - (*CellarV2_5_SetShareLockPeriod)(nil), // 47: steward.v4.CellarV2_5.SetShareLockPeriod - (*CellarV2_5_SetRebalanceDeviation)(nil), // 48: steward.v4.CellarV2_5.SetRebalanceDeviation - (*CellarV2_5_InitiateShutdown)(nil), // 49: steward.v4.CellarV2_5.InitiateShutdown - (*CellarV2_5_LiftShutdown)(nil), // 50: steward.v4.CellarV2_5.LiftShutdown - (*CellarV2_5_Multicall)(nil), // 51: steward.v4.CellarV2_5.Multicall - (*CellarV2_5_RemoveAdaptorFromCatalogue)(nil), // 52: steward.v4.CellarV2_5.RemoveAdaptorFromCatalogue - (*CellarV2_5_RemovePositionFromCatalogue)(nil), // 53: steward.v4.CellarV2_5.RemovePositionFromCatalogue - (*CellarV2_5_DecreaseShareSupplyCap)(nil), // 54: steward.v4.CellarV2_5.DecreaseShareSupplyCap - (*CellarV2_5_SetAlternativeAssetData)(nil), // 55: steward.v4.CellarV2_5.SetAlternativeAssetData - (*CellarV2_5_DropAlternativeAssetData)(nil), // 56: steward.v4.CellarV2_5.DropAlternativeAssetData - (*CellarV2_5Governance_AddAdaptorToCatalogue)(nil), // 57: steward.v4.CellarV2_5Governance.AddAdaptorToCatalogue - (*CellarV2_5Governance_AddPositionToCatalogue)(nil), // 58: steward.v4.CellarV2_5Governance.AddPositionToCatalogue - (*CellarV2_5Governance_SetRebalanceDeviation)(nil), // 59: steward.v4.CellarV2_5Governance.SetRebalanceDeviation - (*CellarV2_5Governance_SetStrategistPlatformCut)(nil), // 60: steward.v4.CellarV2_5Governance.SetStrategistPlatformCut - (*CellarV2_5Governance_ForcePositionOut)(nil), // 61: steward.v4.CellarV2_5Governance.ForcePositionOut - (*CellarV2_5Governance_ToggleIgnorePause)(nil), // 62: steward.v4.CellarV2_5Governance.ToggleIgnorePause - (*CellarV2_5Governance_SetAutomationActions)(nil), // 63: steward.v4.CellarV2_5Governance.SetAutomationActions - (*CellarV2_5Governance_IncreaseShareSupplyCap)(nil), // 64: steward.v4.CellarV2_5Governance.IncreaseShareSupplyCap - (*CellarV2_5Governance_SetSharePriceOracle)(nil), // 65: steward.v4.CellarV2_5Governance.SetSharePriceOracle - (*CellarV2_5Governance_CachePriceRouter)(nil), // 66: steward.v4.CellarV2_5Governance.CachePriceRouter - (*AaveATokenAdaptorV1Calls)(nil), // 67: steward.v4.AaveATokenAdaptorV1Calls - (*AaveDebtTokenAdaptorV1Calls)(nil), // 68: steward.v4.AaveDebtTokenAdaptorV1Calls - (*CompoundCTokenAdaptorV2Calls)(nil), // 69: steward.v4.CompoundCTokenAdaptorV2Calls - (*AaveATokenAdaptorV2Calls)(nil), // 70: steward.v4.AaveATokenAdaptorV2Calls - (*AaveDebtTokenAdaptorV2Calls)(nil), // 71: steward.v4.AaveDebtTokenAdaptorV2Calls - (*AaveV3ATokenAdaptorV1Calls)(nil), // 72: steward.v4.AaveV3ATokenAdaptorV1Calls - (*AaveV3DebtTokenAdaptorV1Calls)(nil), // 73: steward.v4.AaveV3DebtTokenAdaptorV1Calls - (*OneInchAdaptorV1Calls)(nil), // 74: steward.v4.OneInchAdaptorV1Calls - (*FeesAndReservesAdaptorV1Calls)(nil), // 75: steward.v4.FeesAndReservesAdaptorV1Calls - (*ZeroXAdaptorV1Calls)(nil), // 76: steward.v4.ZeroXAdaptorV1Calls - (*SwapWithUniswapAdaptorV1Calls)(nil), // 77: steward.v4.SwapWithUniswapAdaptorV1Calls - (*VestingSimpleAdaptorV2Calls)(nil), // 78: steward.v4.VestingSimpleAdaptorV2Calls - (*CellarAdaptorV1Calls)(nil), // 79: steward.v4.CellarAdaptorV1Calls - (*UniswapV3AdaptorV2Calls)(nil), // 80: steward.v4.UniswapV3AdaptorV2Calls - (*AaveV2EnableAssetAsCollateralAdaptorV1Calls)(nil), // 81: steward.v4.AaveV2EnableAssetAsCollateralAdaptorV1Calls - (*FTokenAdaptorV1Calls)(nil), // 82: steward.v4.FTokenAdaptorV1Calls - (*MorphoAaveV2ATokenAdaptorV1Calls)(nil), // 83: steward.v4.MorphoAaveV2ATokenAdaptorV1Calls - (*MorphoAaveV2DebtTokenAdaptorV1Calls)(nil), // 84: steward.v4.MorphoAaveV2DebtTokenAdaptorV1Calls - (*MorphoAaveV3ATokenCollateralAdaptorV1Calls)(nil), // 85: steward.v4.MorphoAaveV3ATokenCollateralAdaptorV1Calls - (*MorphoAaveV3ATokenP2PAdaptorV1Calls)(nil), // 86: steward.v4.MorphoAaveV3ATokenP2PAdaptorV1Calls - (*MorphoAaveV3DebtTokenAdaptorV1Calls)(nil), // 87: steward.v4.MorphoAaveV3DebtTokenAdaptorV1Calls - (*BalancerPoolAdaptorV1Calls)(nil), // 88: steward.v4.BalancerPoolAdaptorV1Calls - (*LegacyCellarAdaptorV1Calls)(nil), // 89: steward.v4.LegacyCellarAdaptorV1Calls - (*DebtFTokenAdaptorV1Calls)(nil), // 90: steward.v4.DebtFTokenAdaptorV1Calls - (*CollateralFTokenAdaptorV1Calls)(nil), // 91: steward.v4.CollateralFTokenAdaptorV1Calls - (*AaveV3DebtTokenAdaptorV1FlashLoanCalls)(nil), // 92: steward.v4.AaveV3DebtTokenAdaptorV1FlashLoanCalls - (*BalancerPoolAdaptorV1FlashLoanCalls)(nil), // 93: steward.v4.BalancerPoolAdaptorV1FlashLoanCalls - (*ConvexCurveAdaptorV1Calls)(nil), // 94: steward.v4.ConvexCurveAdaptorV1Calls - (*CurveAdaptorV1Calls)(nil), // 95: steward.v4.CurveAdaptorV1Calls - (*AuraERC4626AdaptorV1Calls)(nil), // 96: steward.v4.AuraERC4626AdaptorV1Calls - (*MorphoBlueCollateralAdaptorV1Calls)(nil), // 97: steward.v4.MorphoBlueCollateralAdaptorV1Calls - (*MorphoBlueDebtAdaptorV1Calls)(nil), // 98: steward.v4.MorphoBlueDebtAdaptorV1Calls - (*MorphoBlueSupplyAdaptorV1Calls)(nil), // 99: steward.v4.MorphoBlueSupplyAdaptorV1Calls + (*CellarV2_CallOnAdaptor)(nil), // 7: steward.v4.CellarV2.CallOnAdaptor + (*CellarV2_RemovePosition)(nil), // 8: steward.v4.CellarV2.RemovePosition + (*CellarV2_SetHoldingPosition)(nil), // 9: steward.v4.CellarV2.SetHoldingPosition + (*CellarV2_SetStrategistPayoutAddress)(nil), // 10: steward.v4.CellarV2.SetStrategistPayoutAddress + (*CellarV2_SwapPositions)(nil), // 11: steward.v4.CellarV2.SwapPositions + (*CellarV2_SetShareLockPeriod)(nil), // 12: steward.v4.CellarV2.SetShareLockPeriod + (*CellarV2_AddPosition)(nil), // 13: steward.v4.CellarV2.AddPosition + (*CellarV2_InitiateShutdown)(nil), // 14: steward.v4.CellarV2.InitiateShutdown + (*CellarV2_LiftShutdown)(nil), // 15: steward.v4.CellarV2.LiftShutdown + (*CellarV2_SetPlatformFee)(nil), // 16: steward.v4.CellarV2.SetPlatformFee + (*CellarV2_SetStrategistPlatformCut)(nil), // 17: steward.v4.CellarV2.SetStrategistPlatformCut + (*CellarV2_SetupAdaptor)(nil), // 18: steward.v4.CellarV2.SetupAdaptor + (*CellarV2_SetRebalanceDeviation)(nil), // 19: steward.v4.CellarV2.SetRebalanceDeviation + (*CellarV2Governance_InitiateShutdown)(nil), // 20: steward.v4.CellarV2Governance.InitiateShutdown + (*CellarV2Governance_LiftShutdown)(nil), // 21: steward.v4.CellarV2Governance.LiftShutdown + (*CellarV2Governance_SetPlatformFee)(nil), // 22: steward.v4.CellarV2Governance.SetPlatformFee + (*CellarV2Governance_SetStrategistPlatformCut)(nil), // 23: steward.v4.CellarV2Governance.SetStrategistPlatformCut + (*CellarV2Governance_SetupAdaptor)(nil), // 24: steward.v4.CellarV2Governance.SetupAdaptor + (*CellarV2Governance_SetRebalanceDeviation)(nil), // 25: steward.v4.CellarV2Governance.SetRebalanceDeviation + (*CellarV2_2_FunctionCall)(nil), // 26: steward.v4.CellarV2_2.FunctionCall + (*CellarV2_2_AddPosition)(nil), // 27: steward.v4.CellarV2_2.AddPosition + (*CellarV2_2_CallOnAdaptor)(nil), // 28: steward.v4.CellarV2_2.CallOnAdaptor + (*CellarV2_2_RemovePosition)(nil), // 29: steward.v4.CellarV2_2.RemovePosition + (*CellarV2_2_RemoveAdaptorFromCatalogue)(nil), // 30: steward.v4.CellarV2_2.RemoveAdaptorFromCatalogue + (*CellarV2_2_RemovePositionFromCatalogue)(nil), // 31: steward.v4.CellarV2_2.RemovePositionFromCatalogue + (*CellarV2_2_SetHoldingPosition)(nil), // 32: steward.v4.CellarV2_2.SetHoldingPosition + (*CellarV2_2_SetStrategistPayoutAddress)(nil), // 33: steward.v4.CellarV2_2.SetStrategistPayoutAddress + (*CellarV2_2_SwapPositions)(nil), // 34: steward.v4.CellarV2_2.SwapPositions + (*CellarV2_2_Multicall)(nil), // 35: steward.v4.CellarV2_2.Multicall + (*CellarV2_2_AddAdaptorToCatalogue)(nil), // 36: steward.v4.CellarV2_2.AddAdaptorToCatalogue + (*CellarV2_2_AddPositionToCatalogue)(nil), // 37: steward.v4.CellarV2_2.AddPositionToCatalogue + (*CellarV2_2_SetShareLockPeriod)(nil), // 38: steward.v4.CellarV2_2.SetShareLockPeriod + (*CellarV2_2_SetRebalanceDeviation)(nil), // 39: steward.v4.CellarV2_2.SetRebalanceDeviation + (*CellarV2_2_InitiateShutdown)(nil), // 40: steward.v4.CellarV2_2.InitiateShutdown + (*CellarV2_2_SetStrategistPlatformCut)(nil), // 41: steward.v4.CellarV2_2.SetStrategistPlatformCut + (*CellarV2_2_LiftShutdown)(nil), // 42: steward.v4.CellarV2_2.LiftShutdown + (*CellarV2_2_CachePriceRouter)(nil), // 43: steward.v4.CellarV2_2.CachePriceRouter + (*CellarV2_2Governance_AddAdaptorToCatalogue)(nil), // 44: steward.v4.CellarV2_2Governance.AddAdaptorToCatalogue + (*CellarV2_2Governance_AddPositionToCatalogue)(nil), // 45: steward.v4.CellarV2_2Governance.AddPositionToCatalogue + (*CellarV2_2Governance_SetShareLockPeriod)(nil), // 46: steward.v4.CellarV2_2Governance.SetShareLockPeriod + (*CellarV2_2Governance_SetRebalanceDeviation)(nil), // 47: steward.v4.CellarV2_2Governance.SetRebalanceDeviation + (*CellarV2_2Governance_InitiateShutdown)(nil), // 48: steward.v4.CellarV2_2Governance.InitiateShutdown + (*CellarV2_2Governance_SetStrategistPlatformCut)(nil), // 49: steward.v4.CellarV2_2Governance.SetStrategistPlatformCut + (*CellarV2_2Governance_LiftShutdown)(nil), // 50: steward.v4.CellarV2_2Governance.LiftShutdown + (*CellarV2_2Governance_ForcePositionOut)(nil), // 51: steward.v4.CellarV2_2Governance.ForcePositionOut + (*CellarV2_2Governance_ToggleIgnorePause)(nil), // 52: steward.v4.CellarV2_2Governance.ToggleIgnorePause + (*CellarV2_2Governance_CachePriceRouter)(nil), // 53: steward.v4.CellarV2_2Governance.CachePriceRouter + (*CellarV2_5_FunctionCall)(nil), // 54: steward.v4.CellarV2_5.FunctionCall + (*CellarV2_5_AddPosition)(nil), // 55: steward.v4.CellarV2_5.AddPosition + (*CellarV2_5_CallOnAdaptor)(nil), // 56: steward.v4.CellarV2_5.CallOnAdaptor + (*CellarV2_5_RemovePosition)(nil), // 57: steward.v4.CellarV2_5.RemovePosition + (*CellarV2_5_SetHoldingPosition)(nil), // 58: steward.v4.CellarV2_5.SetHoldingPosition + (*CellarV2_5_SetStrategistPayoutAddress)(nil), // 59: steward.v4.CellarV2_5.SetStrategistPayoutAddress + (*CellarV2_5_SwapPositions)(nil), // 60: steward.v4.CellarV2_5.SwapPositions + (*CellarV2_5_SetShareLockPeriod)(nil), // 61: steward.v4.CellarV2_5.SetShareLockPeriod + (*CellarV2_5_InitiateShutdown)(nil), // 62: steward.v4.CellarV2_5.InitiateShutdown + (*CellarV2_5_LiftShutdown)(nil), // 63: steward.v4.CellarV2_5.LiftShutdown + (*CellarV2_5_Multicall)(nil), // 64: steward.v4.CellarV2_5.Multicall + (*CellarV2_5_RemoveAdaptorFromCatalogue)(nil), // 65: steward.v4.CellarV2_5.RemoveAdaptorFromCatalogue + (*CellarV2_5_RemovePositionFromCatalogue)(nil), // 66: steward.v4.CellarV2_5.RemovePositionFromCatalogue + (*CellarV2_5_DecreaseShareSupplyCap)(nil), // 67: steward.v4.CellarV2_5.DecreaseShareSupplyCap + (*CellarV2_5_SetAlternativeAssetData)(nil), // 68: steward.v4.CellarV2_5.SetAlternativeAssetData + (*CellarV2_5_DropAlternativeAssetData)(nil), // 69: steward.v4.CellarV2_5.DropAlternativeAssetData + (*CellarV2_5_AddAdaptorToCatalogue)(nil), // 70: steward.v4.CellarV2_5.AddAdaptorToCatalogue + (*CellarV2_5_AddPositionToCatalogue)(nil), // 71: steward.v4.CellarV2_5.AddPositionToCatalogue + (*CellarV2_5_SetRebalanceDeviation)(nil), // 72: steward.v4.CellarV2_5.SetRebalanceDeviation + (*CellarV2_5_SetStrategistPlatformCut)(nil), // 73: steward.v4.CellarV2_5.SetStrategistPlatformCut + (*CellarV2_5_IncreaseShareSupplyCap)(nil), // 74: steward.v4.CellarV2_5.IncreaseShareSupplyCap + (*CellarV2_5_SetSharePriceOracle)(nil), // 75: steward.v4.CellarV2_5.SetSharePriceOracle + (*CellarV2_5_CachePriceRouter)(nil), // 76: steward.v4.CellarV2_5.CachePriceRouter + (*CellarV2_5Governance_AddAdaptorToCatalogue)(nil), // 77: steward.v4.CellarV2_5Governance.AddAdaptorToCatalogue + (*CellarV2_5Governance_AddPositionToCatalogue)(nil), // 78: steward.v4.CellarV2_5Governance.AddPositionToCatalogue + (*CellarV2_5Governance_SetRebalanceDeviation)(nil), // 79: steward.v4.CellarV2_5Governance.SetRebalanceDeviation + (*CellarV2_5Governance_SetStrategistPlatformCut)(nil), // 80: steward.v4.CellarV2_5Governance.SetStrategistPlatformCut + (*CellarV2_5Governance_ForcePositionOut)(nil), // 81: steward.v4.CellarV2_5Governance.ForcePositionOut + (*CellarV2_5Governance_ToggleIgnorePause)(nil), // 82: steward.v4.CellarV2_5Governance.ToggleIgnorePause + (*CellarV2_5Governance_SetAutomationActions)(nil), // 83: steward.v4.CellarV2_5Governance.SetAutomationActions + (*CellarV2_5Governance_IncreaseShareSupplyCap)(nil), // 84: steward.v4.CellarV2_5Governance.IncreaseShareSupplyCap + (*CellarV2_5Governance_SetSharePriceOracle)(nil), // 85: steward.v4.CellarV2_5Governance.SetSharePriceOracle + (*CellarV2_5Governance_CachePriceRouter)(nil), // 86: steward.v4.CellarV2_5Governance.CachePriceRouter + (*AaveATokenAdaptorV1Calls)(nil), // 87: steward.v4.AaveATokenAdaptorV1Calls + (*AaveDebtTokenAdaptorV1Calls)(nil), // 88: steward.v4.AaveDebtTokenAdaptorV1Calls + (*CompoundCTokenAdaptorV2Calls)(nil), // 89: steward.v4.CompoundCTokenAdaptorV2Calls + (*AaveATokenAdaptorV2Calls)(nil), // 90: steward.v4.AaveATokenAdaptorV2Calls + (*AaveDebtTokenAdaptorV2Calls)(nil), // 91: steward.v4.AaveDebtTokenAdaptorV2Calls + (*AaveV3ATokenAdaptorV1Calls)(nil), // 92: steward.v4.AaveV3ATokenAdaptorV1Calls + (*AaveV3DebtTokenAdaptorV1Calls)(nil), // 93: steward.v4.AaveV3DebtTokenAdaptorV1Calls + (*OneInchAdaptorV1Calls)(nil), // 94: steward.v4.OneInchAdaptorV1Calls + (*FeesAndReservesAdaptorV1Calls)(nil), // 95: steward.v4.FeesAndReservesAdaptorV1Calls + (*ZeroXAdaptorV1Calls)(nil), // 96: steward.v4.ZeroXAdaptorV1Calls + (*SwapWithUniswapAdaptorV1Calls)(nil), // 97: steward.v4.SwapWithUniswapAdaptorV1Calls + (*VestingSimpleAdaptorV2Calls)(nil), // 98: steward.v4.VestingSimpleAdaptorV2Calls + (*CellarAdaptorV1Calls)(nil), // 99: steward.v4.CellarAdaptorV1Calls + (*UniswapV3AdaptorV2Calls)(nil), // 100: steward.v4.UniswapV3AdaptorV2Calls + (*AaveV2EnableAssetAsCollateralAdaptorV1Calls)(nil), // 101: steward.v4.AaveV2EnableAssetAsCollateralAdaptorV1Calls + (*FTokenAdaptorV1Calls)(nil), // 102: steward.v4.FTokenAdaptorV1Calls + (*MorphoAaveV2ATokenAdaptorV1Calls)(nil), // 103: steward.v4.MorphoAaveV2ATokenAdaptorV1Calls + (*MorphoAaveV2DebtTokenAdaptorV1Calls)(nil), // 104: steward.v4.MorphoAaveV2DebtTokenAdaptorV1Calls + (*MorphoAaveV3ATokenCollateralAdaptorV1Calls)(nil), // 105: steward.v4.MorphoAaveV3ATokenCollateralAdaptorV1Calls + (*MorphoAaveV3ATokenP2PAdaptorV1Calls)(nil), // 106: steward.v4.MorphoAaveV3ATokenP2PAdaptorV1Calls + (*MorphoAaveV3DebtTokenAdaptorV1Calls)(nil), // 107: steward.v4.MorphoAaveV3DebtTokenAdaptorV1Calls + (*BalancerPoolAdaptorV1Calls)(nil), // 108: steward.v4.BalancerPoolAdaptorV1Calls + (*LegacyCellarAdaptorV1Calls)(nil), // 109: steward.v4.LegacyCellarAdaptorV1Calls + (*DebtFTokenAdaptorV1Calls)(nil), // 110: steward.v4.DebtFTokenAdaptorV1Calls + (*CollateralFTokenAdaptorV1Calls)(nil), // 111: steward.v4.CollateralFTokenAdaptorV1Calls + (*AaveV3DebtTokenAdaptorV1FlashLoanCalls)(nil), // 112: steward.v4.AaveV3DebtTokenAdaptorV1FlashLoanCalls + (*BalancerPoolAdaptorV1FlashLoanCalls)(nil), // 113: steward.v4.BalancerPoolAdaptorV1FlashLoanCalls + (*ConvexCurveAdaptorV1Calls)(nil), // 114: steward.v4.ConvexCurveAdaptorV1Calls + (*CurveAdaptorV1Calls)(nil), // 115: steward.v4.CurveAdaptorV1Calls + (*AuraERC4626AdaptorV1Calls)(nil), // 116: steward.v4.AuraERC4626AdaptorV1Calls + (*MorphoBlueCollateralAdaptorV1Calls)(nil), // 117: steward.v4.MorphoBlueCollateralAdaptorV1Calls + (*MorphoBlueDebtAdaptorV1Calls)(nil), // 118: steward.v4.MorphoBlueDebtAdaptorV1Calls + (*MorphoBlueSupplyAdaptorV1Calls)(nil), // 119: steward.v4.MorphoBlueSupplyAdaptorV1Calls } var file_cellar_v2_proto_depIdxs = []int32{ - 7, // 0: steward.v4.CellarV2.add_position:type_name -> steward.v4.CellarV2.AddPosition - 8, // 1: steward.v4.CellarV2.call_on_adaptor:type_name -> steward.v4.CellarV2.CallOnAdaptor - 9, // 2: steward.v4.CellarV2.remove_position:type_name -> steward.v4.CellarV2.RemovePosition - 10, // 3: steward.v4.CellarV2.set_holding_position:type_name -> steward.v4.CellarV2.SetHoldingPosition - 11, // 4: steward.v4.CellarV2.set_strategist_payout_address:type_name -> steward.v4.CellarV2.SetStrategistPayoutAddress - 12, // 5: steward.v4.CellarV2.swap_positions:type_name -> steward.v4.CellarV2.SwapPositions - 13, // 6: steward.v4.CellarV2.set_share_lock_period:type_name -> steward.v4.CellarV2.SetShareLockPeriod - 14, // 7: steward.v4.CellarV2Governance.initiate_shutdown:type_name -> steward.v4.CellarV2Governance.InitiateShutdown - 15, // 8: steward.v4.CellarV2Governance.lift_shutdown:type_name -> steward.v4.CellarV2Governance.LiftShutdown - 16, // 9: steward.v4.CellarV2Governance.set_platform_fee:type_name -> steward.v4.CellarV2Governance.SetPlatformFee - 17, // 10: steward.v4.CellarV2Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2Governance.SetStrategistPlatformCut - 18, // 11: steward.v4.CellarV2Governance.setup_adaptor:type_name -> steward.v4.CellarV2Governance.SetupAdaptor - 19, // 12: steward.v4.CellarV2Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2Governance.SetRebalanceDeviation - 20, // 13: steward.v4.CellarV2_2.function_call:type_name -> steward.v4.CellarV2_2.FunctionCall - 29, // 14: steward.v4.CellarV2_2.multicall:type_name -> steward.v4.CellarV2_2.Multicall - 30, // 15: steward.v4.CellarV2_2Governance.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_2Governance.AddAdaptorToCatalogue - 31, // 16: steward.v4.CellarV2_2Governance.add_position_to_catalogue:type_name -> steward.v4.CellarV2_2Governance.AddPositionToCatalogue - 33, // 17: steward.v4.CellarV2_2Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2_2Governance.SetRebalanceDeviation - 32, // 18: steward.v4.CellarV2_2Governance.set_share_lock_period:type_name -> steward.v4.CellarV2_2Governance.SetShareLockPeriod - 35, // 19: steward.v4.CellarV2_2Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_2Governance.SetStrategistPlatformCut - 34, // 20: steward.v4.CellarV2_2Governance.initiate_shutdown:type_name -> steward.v4.CellarV2_2Governance.InitiateShutdown - 36, // 21: steward.v4.CellarV2_2Governance.lift_shutdown:type_name -> steward.v4.CellarV2_2Governance.LiftShutdown - 37, // 22: steward.v4.CellarV2_2Governance.force_position_out:type_name -> steward.v4.CellarV2_2Governance.ForcePositionOut - 38, // 23: steward.v4.CellarV2_2Governance.toggle_ignore_pause:type_name -> steward.v4.CellarV2_2Governance.ToggleIgnorePause - 39, // 24: steward.v4.CellarV2_2Governance.cache_price_router:type_name -> steward.v4.CellarV2_2Governance.CachePriceRouter - 40, // 25: steward.v4.CellarV2_5.function_call:type_name -> steward.v4.CellarV2_5.FunctionCall - 51, // 26: steward.v4.CellarV2_5.multicall:type_name -> steward.v4.CellarV2_5.Multicall - 57, // 27: steward.v4.CellarV2_5Governance.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_5Governance.AddAdaptorToCatalogue - 58, // 28: steward.v4.CellarV2_5Governance.add_position_to_catalogue:type_name -> steward.v4.CellarV2_5Governance.AddPositionToCatalogue - 59, // 29: steward.v4.CellarV2_5Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2_5Governance.SetRebalanceDeviation - 60, // 30: steward.v4.CellarV2_5Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_5Governance.SetStrategistPlatformCut - 61, // 31: steward.v4.CellarV2_5Governance.force_position_out:type_name -> steward.v4.CellarV2_5Governance.ForcePositionOut - 62, // 32: steward.v4.CellarV2_5Governance.toggle_ignore_pause:type_name -> steward.v4.CellarV2_5Governance.ToggleIgnorePause - 65, // 33: steward.v4.CellarV2_5Governance.set_share_price_oracle:type_name -> steward.v4.CellarV2_5Governance.SetSharePriceOracle - 64, // 34: steward.v4.CellarV2_5Governance.increase_share_supply_cap:type_name -> steward.v4.CellarV2_5Governance.IncreaseShareSupplyCap - 63, // 35: steward.v4.CellarV2_5Governance.set_automation_actions:type_name -> steward.v4.CellarV2_5Governance.SetAutomationActions - 66, // 36: steward.v4.CellarV2_5Governance.cache_price_router:type_name -> steward.v4.CellarV2_5Governance.CachePriceRouter - 67, // 37: steward.v4.AdaptorCall.aave_a_token_v1_calls:type_name -> steward.v4.AaveATokenAdaptorV1Calls - 68, // 38: steward.v4.AdaptorCall.aave_debt_token_v1_calls:type_name -> steward.v4.AaveDebtTokenAdaptorV1Calls - 69, // 39: steward.v4.AdaptorCall.compound_c_token_v2_calls:type_name -> steward.v4.CompoundCTokenAdaptorV2Calls - 70, // 40: steward.v4.AdaptorCall.aave_a_token_v2_calls:type_name -> steward.v4.AaveATokenAdaptorV2Calls - 71, // 41: steward.v4.AdaptorCall.aave_debt_token_v2_calls:type_name -> steward.v4.AaveDebtTokenAdaptorV2Calls - 72, // 42: steward.v4.AdaptorCall.aave_v3_a_token_v1_calls:type_name -> steward.v4.AaveV3ATokenAdaptorV1Calls - 73, // 43: steward.v4.AdaptorCall.aave_v3_debt_token_v1_calls:type_name -> steward.v4.AaveV3DebtTokenAdaptorV1Calls - 74, // 44: steward.v4.AdaptorCall.one_inch_v1_calls:type_name -> steward.v4.OneInchAdaptorV1Calls - 75, // 45: steward.v4.AdaptorCall.fees_and_reserves_v1_calls:type_name -> steward.v4.FeesAndReservesAdaptorV1Calls - 76, // 46: steward.v4.AdaptorCall.zero_x_v1_calls:type_name -> steward.v4.ZeroXAdaptorV1Calls - 77, // 47: steward.v4.AdaptorCall.swap_with_uniswap_v1_calls:type_name -> steward.v4.SwapWithUniswapAdaptorV1Calls - 78, // 48: steward.v4.AdaptorCall.vesting_simple_v2_calls:type_name -> steward.v4.VestingSimpleAdaptorV2Calls - 79, // 49: steward.v4.AdaptorCall.cellar_v1_calls:type_name -> steward.v4.CellarAdaptorV1Calls - 80, // 50: steward.v4.AdaptorCall.uniswap_v3_v2_calls:type_name -> steward.v4.UniswapV3AdaptorV2Calls - 81, // 51: steward.v4.AdaptorCall.aave_v2_enable_asset_as_collateral_v1_calls:type_name -> steward.v4.AaveV2EnableAssetAsCollateralAdaptorV1Calls - 82, // 52: steward.v4.AdaptorCall.f_token_v1_calls:type_name -> steward.v4.FTokenAdaptorV1Calls - 83, // 53: steward.v4.AdaptorCall.morpho_aave_v2_a_token_v1_calls:type_name -> steward.v4.MorphoAaveV2ATokenAdaptorV1Calls - 84, // 54: steward.v4.AdaptorCall.morpho_aave_v2_debt_token_v1_calls:type_name -> steward.v4.MorphoAaveV2DebtTokenAdaptorV1Calls - 85, // 55: steward.v4.AdaptorCall.morpho_aave_v3_a_token_collateral_v1_calls:type_name -> steward.v4.MorphoAaveV3ATokenCollateralAdaptorV1Calls - 86, // 56: steward.v4.AdaptorCall.morpho_aave_v3_a_token_p2p_v1_calls:type_name -> steward.v4.MorphoAaveV3ATokenP2PAdaptorV1Calls - 87, // 57: steward.v4.AdaptorCall.morpho_aave_v3_debt_token_v1_calls:type_name -> steward.v4.MorphoAaveV3DebtTokenAdaptorV1Calls - 88, // 58: steward.v4.AdaptorCall.balancer_pool_v1_calls:type_name -> steward.v4.BalancerPoolAdaptorV1Calls - 89, // 59: steward.v4.AdaptorCall.legacy_cellar_v1_calls:type_name -> steward.v4.LegacyCellarAdaptorV1Calls - 90, // 60: steward.v4.AdaptorCall.debt_f_token_v1_calls:type_name -> steward.v4.DebtFTokenAdaptorV1Calls - 91, // 61: steward.v4.AdaptorCall.collateral_f_token_v1_calls:type_name -> steward.v4.CollateralFTokenAdaptorV1Calls - 92, // 62: steward.v4.AdaptorCall.aave_v3_debt_token_v1_flash_loan_calls:type_name -> steward.v4.AaveV3DebtTokenAdaptorV1FlashLoanCalls - 93, // 63: steward.v4.AdaptorCall.balancer_pool_v1_flash_loan_calls:type_name -> steward.v4.BalancerPoolAdaptorV1FlashLoanCalls - 94, // 64: steward.v4.AdaptorCall.convex_curve_v1_calls:type_name -> steward.v4.ConvexCurveAdaptorV1Calls - 95, // 65: steward.v4.AdaptorCall.curve_v1_calls:type_name -> steward.v4.CurveAdaptorV1Calls - 96, // 66: steward.v4.AdaptorCall.aura_erc4626_v1_calls:type_name -> steward.v4.AuraERC4626AdaptorV1Calls - 97, // 67: steward.v4.AdaptorCall.morpho_blue_collateral_v1_calls:type_name -> steward.v4.MorphoBlueCollateralAdaptorV1Calls - 98, // 68: steward.v4.AdaptorCall.morpho_blue_debt_v1_calls:type_name -> steward.v4.MorphoBlueDebtAdaptorV1Calls - 99, // 69: steward.v4.AdaptorCall.morpho_blue_supply_v1_calls:type_name -> steward.v4.MorphoBlueSupplyAdaptorV1Calls - 6, // 70: steward.v4.CellarV2.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall - 21, // 71: steward.v4.CellarV2_2.FunctionCall.add_position:type_name -> steward.v4.CellarV2_2.AddPosition - 22, // 72: steward.v4.CellarV2_2.FunctionCall.call_on_adaptor:type_name -> steward.v4.CellarV2_2.CallOnAdaptor - 23, // 73: steward.v4.CellarV2_2.FunctionCall.remove_position:type_name -> steward.v4.CellarV2_2.RemovePosition - 24, // 74: steward.v4.CellarV2_2.FunctionCall.remove_adaptor_from_catalogue:type_name -> steward.v4.CellarV2_2.RemoveAdaptorFromCatalogue - 25, // 75: steward.v4.CellarV2_2.FunctionCall.remove_position_from_catalogue:type_name -> steward.v4.CellarV2_2.RemovePositionFromCatalogue - 26, // 76: steward.v4.CellarV2_2.FunctionCall.set_holding_position:type_name -> steward.v4.CellarV2_2.SetHoldingPosition - 27, // 77: steward.v4.CellarV2_2.FunctionCall.set_strategist_payout_address:type_name -> steward.v4.CellarV2_2.SetStrategistPayoutAddress - 28, // 78: steward.v4.CellarV2_2.FunctionCall.swap_positions:type_name -> steward.v4.CellarV2_2.SwapPositions - 6, // 79: steward.v4.CellarV2_2.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall - 20, // 80: steward.v4.CellarV2_2.Multicall.function_calls:type_name -> steward.v4.CellarV2_2.FunctionCall - 41, // 81: steward.v4.CellarV2_5.FunctionCall.add_position:type_name -> steward.v4.CellarV2_5.AddPosition - 42, // 82: steward.v4.CellarV2_5.FunctionCall.call_on_adaptor:type_name -> steward.v4.CellarV2_5.CallOnAdaptor - 43, // 83: steward.v4.CellarV2_5.FunctionCall.remove_position:type_name -> steward.v4.CellarV2_5.RemovePosition - 44, // 84: steward.v4.CellarV2_5.FunctionCall.set_holding_position:type_name -> steward.v4.CellarV2_5.SetHoldingPosition - 45, // 85: steward.v4.CellarV2_5.FunctionCall.set_strategist_payout_address:type_name -> steward.v4.CellarV2_5.SetStrategistPayoutAddress - 46, // 86: steward.v4.CellarV2_5.FunctionCall.swap_positions:type_name -> steward.v4.CellarV2_5.SwapPositions - 47, // 87: steward.v4.CellarV2_5.FunctionCall.set_share_lock_period:type_name -> steward.v4.CellarV2_5.SetShareLockPeriod - 49, // 88: steward.v4.CellarV2_5.FunctionCall.initiate_shutdown:type_name -> steward.v4.CellarV2_5.InitiateShutdown - 50, // 89: steward.v4.CellarV2_5.FunctionCall.lift_shutdown:type_name -> steward.v4.CellarV2_5.LiftShutdown - 52, // 90: steward.v4.CellarV2_5.FunctionCall.remove_adaptor_from_catalogue:type_name -> steward.v4.CellarV2_5.RemoveAdaptorFromCatalogue - 53, // 91: steward.v4.CellarV2_5.FunctionCall.remove_position_from_catalogue:type_name -> steward.v4.CellarV2_5.RemovePositionFromCatalogue - 54, // 92: steward.v4.CellarV2_5.FunctionCall.decrease_share_supply_cap:type_name -> steward.v4.CellarV2_5.DecreaseShareSupplyCap - 55, // 93: steward.v4.CellarV2_5.FunctionCall.set_alternative_asset_data:type_name -> steward.v4.CellarV2_5.SetAlternativeAssetData - 56, // 94: steward.v4.CellarV2_5.FunctionCall.drop_alternative_asset_data:type_name -> steward.v4.CellarV2_5.DropAlternativeAssetData - 6, // 95: steward.v4.CellarV2_5.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall - 40, // 96: steward.v4.CellarV2_5.Multicall.function_calls:type_name -> steward.v4.CellarV2_5.FunctionCall - 97, // [97:97] is the sub-list for method output_type - 97, // [97:97] is the sub-list for method input_type - 97, // [97:97] is the sub-list for extension type_name - 97, // [97:97] is the sub-list for extension extendee - 0, // [0:97] is the sub-list for field type_name + 7, // 0: steward.v4.CellarV2.call_on_adaptor:type_name -> steward.v4.CellarV2.CallOnAdaptor + 8, // 1: steward.v4.CellarV2.remove_position:type_name -> steward.v4.CellarV2.RemovePosition + 9, // 2: steward.v4.CellarV2.set_holding_position:type_name -> steward.v4.CellarV2.SetHoldingPosition + 10, // 3: steward.v4.CellarV2.set_strategist_payout_address:type_name -> steward.v4.CellarV2.SetStrategistPayoutAddress + 11, // 4: steward.v4.CellarV2.swap_positions:type_name -> steward.v4.CellarV2.SwapPositions + 12, // 5: steward.v4.CellarV2.set_share_lock_period:type_name -> steward.v4.CellarV2.SetShareLockPeriod + 13, // 6: steward.v4.CellarV2.add_position:type_name -> steward.v4.CellarV2.AddPosition + 18, // 7: steward.v4.CellarV2.setup_adaptor:type_name -> steward.v4.CellarV2.SetupAdaptor + 14, // 8: steward.v4.CellarV2.initiate_shutdown:type_name -> steward.v4.CellarV2.InitiateShutdown + 15, // 9: steward.v4.CellarV2.lift_shutdown:type_name -> steward.v4.CellarV2.LiftShutdown + 16, // 10: steward.v4.CellarV2.set_platform_fee:type_name -> steward.v4.CellarV2.SetPlatformFee + 17, // 11: steward.v4.CellarV2.set_strategist_platform_cut:type_name -> steward.v4.CellarV2.SetStrategistPlatformCut + 19, // 12: steward.v4.CellarV2.set_rebalance_deviation:type_name -> steward.v4.CellarV2.SetRebalanceDeviation + 20, // 13: steward.v4.CellarV2Governance.initiate_shutdown:type_name -> steward.v4.CellarV2Governance.InitiateShutdown + 21, // 14: steward.v4.CellarV2Governance.lift_shutdown:type_name -> steward.v4.CellarV2Governance.LiftShutdown + 22, // 15: steward.v4.CellarV2Governance.set_platform_fee:type_name -> steward.v4.CellarV2Governance.SetPlatformFee + 23, // 16: steward.v4.CellarV2Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2Governance.SetStrategistPlatformCut + 24, // 17: steward.v4.CellarV2Governance.setup_adaptor:type_name -> steward.v4.CellarV2Governance.SetupAdaptor + 25, // 18: steward.v4.CellarV2Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2Governance.SetRebalanceDeviation + 26, // 19: steward.v4.CellarV2_2.function_call:type_name -> steward.v4.CellarV2_2.FunctionCall + 35, // 20: steward.v4.CellarV2_2.multicall:type_name -> steward.v4.CellarV2_2.Multicall + 44, // 21: steward.v4.CellarV2_2Governance.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_2Governance.AddAdaptorToCatalogue + 45, // 22: steward.v4.CellarV2_2Governance.add_position_to_catalogue:type_name -> steward.v4.CellarV2_2Governance.AddPositionToCatalogue + 47, // 23: steward.v4.CellarV2_2Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2_2Governance.SetRebalanceDeviation + 46, // 24: steward.v4.CellarV2_2Governance.set_share_lock_period:type_name -> steward.v4.CellarV2_2Governance.SetShareLockPeriod + 49, // 25: steward.v4.CellarV2_2Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_2Governance.SetStrategistPlatformCut + 48, // 26: steward.v4.CellarV2_2Governance.initiate_shutdown:type_name -> steward.v4.CellarV2_2Governance.InitiateShutdown + 50, // 27: steward.v4.CellarV2_2Governance.lift_shutdown:type_name -> steward.v4.CellarV2_2Governance.LiftShutdown + 51, // 28: steward.v4.CellarV2_2Governance.force_position_out:type_name -> steward.v4.CellarV2_2Governance.ForcePositionOut + 52, // 29: steward.v4.CellarV2_2Governance.toggle_ignore_pause:type_name -> steward.v4.CellarV2_2Governance.ToggleIgnorePause + 53, // 30: steward.v4.CellarV2_2Governance.cache_price_router:type_name -> steward.v4.CellarV2_2Governance.CachePriceRouter + 54, // 31: steward.v4.CellarV2_5.function_call:type_name -> steward.v4.CellarV2_5.FunctionCall + 64, // 32: steward.v4.CellarV2_5.multicall:type_name -> steward.v4.CellarV2_5.Multicall + 77, // 33: steward.v4.CellarV2_5Governance.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_5Governance.AddAdaptorToCatalogue + 78, // 34: steward.v4.CellarV2_5Governance.add_position_to_catalogue:type_name -> steward.v4.CellarV2_5Governance.AddPositionToCatalogue + 79, // 35: steward.v4.CellarV2_5Governance.set_rebalance_deviation:type_name -> steward.v4.CellarV2_5Governance.SetRebalanceDeviation + 80, // 36: steward.v4.CellarV2_5Governance.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_5Governance.SetStrategistPlatformCut + 81, // 37: steward.v4.CellarV2_5Governance.force_position_out:type_name -> steward.v4.CellarV2_5Governance.ForcePositionOut + 82, // 38: steward.v4.CellarV2_5Governance.toggle_ignore_pause:type_name -> steward.v4.CellarV2_5Governance.ToggleIgnorePause + 85, // 39: steward.v4.CellarV2_5Governance.set_share_price_oracle:type_name -> steward.v4.CellarV2_5Governance.SetSharePriceOracle + 84, // 40: steward.v4.CellarV2_5Governance.increase_share_supply_cap:type_name -> steward.v4.CellarV2_5Governance.IncreaseShareSupplyCap + 83, // 41: steward.v4.CellarV2_5Governance.set_automation_actions:type_name -> steward.v4.CellarV2_5Governance.SetAutomationActions + 86, // 42: steward.v4.CellarV2_5Governance.cache_price_router:type_name -> steward.v4.CellarV2_5Governance.CachePriceRouter + 87, // 43: steward.v4.AdaptorCall.aave_a_token_v1_calls:type_name -> steward.v4.AaveATokenAdaptorV1Calls + 88, // 44: steward.v4.AdaptorCall.aave_debt_token_v1_calls:type_name -> steward.v4.AaveDebtTokenAdaptorV1Calls + 89, // 45: steward.v4.AdaptorCall.compound_c_token_v2_calls:type_name -> steward.v4.CompoundCTokenAdaptorV2Calls + 90, // 46: steward.v4.AdaptorCall.aave_a_token_v2_calls:type_name -> steward.v4.AaveATokenAdaptorV2Calls + 91, // 47: steward.v4.AdaptorCall.aave_debt_token_v2_calls:type_name -> steward.v4.AaveDebtTokenAdaptorV2Calls + 92, // 48: steward.v4.AdaptorCall.aave_v3_a_token_v1_calls:type_name -> steward.v4.AaveV3ATokenAdaptorV1Calls + 93, // 49: steward.v4.AdaptorCall.aave_v3_debt_token_v1_calls:type_name -> steward.v4.AaveV3DebtTokenAdaptorV1Calls + 94, // 50: steward.v4.AdaptorCall.one_inch_v1_calls:type_name -> steward.v4.OneInchAdaptorV1Calls + 95, // 51: steward.v4.AdaptorCall.fees_and_reserves_v1_calls:type_name -> steward.v4.FeesAndReservesAdaptorV1Calls + 96, // 52: steward.v4.AdaptorCall.zero_x_v1_calls:type_name -> steward.v4.ZeroXAdaptorV1Calls + 97, // 53: steward.v4.AdaptorCall.swap_with_uniswap_v1_calls:type_name -> steward.v4.SwapWithUniswapAdaptorV1Calls + 98, // 54: steward.v4.AdaptorCall.vesting_simple_v2_calls:type_name -> steward.v4.VestingSimpleAdaptorV2Calls + 99, // 55: steward.v4.AdaptorCall.cellar_v1_calls:type_name -> steward.v4.CellarAdaptorV1Calls + 100, // 56: steward.v4.AdaptorCall.uniswap_v3_v2_calls:type_name -> steward.v4.UniswapV3AdaptorV2Calls + 101, // 57: steward.v4.AdaptorCall.aave_v2_enable_asset_as_collateral_v1_calls:type_name -> steward.v4.AaveV2EnableAssetAsCollateralAdaptorV1Calls + 102, // 58: steward.v4.AdaptorCall.f_token_v1_calls:type_name -> steward.v4.FTokenAdaptorV1Calls + 103, // 59: steward.v4.AdaptorCall.morpho_aave_v2_a_token_v1_calls:type_name -> steward.v4.MorphoAaveV2ATokenAdaptorV1Calls + 104, // 60: steward.v4.AdaptorCall.morpho_aave_v2_debt_token_v1_calls:type_name -> steward.v4.MorphoAaveV2DebtTokenAdaptorV1Calls + 105, // 61: steward.v4.AdaptorCall.morpho_aave_v3_a_token_collateral_v1_calls:type_name -> steward.v4.MorphoAaveV3ATokenCollateralAdaptorV1Calls + 106, // 62: steward.v4.AdaptorCall.morpho_aave_v3_a_token_p2p_v1_calls:type_name -> steward.v4.MorphoAaveV3ATokenP2PAdaptorV1Calls + 107, // 63: steward.v4.AdaptorCall.morpho_aave_v3_debt_token_v1_calls:type_name -> steward.v4.MorphoAaveV3DebtTokenAdaptorV1Calls + 108, // 64: steward.v4.AdaptorCall.balancer_pool_v1_calls:type_name -> steward.v4.BalancerPoolAdaptorV1Calls + 109, // 65: steward.v4.AdaptorCall.legacy_cellar_v1_calls:type_name -> steward.v4.LegacyCellarAdaptorV1Calls + 110, // 66: steward.v4.AdaptorCall.debt_f_token_v1_calls:type_name -> steward.v4.DebtFTokenAdaptorV1Calls + 111, // 67: steward.v4.AdaptorCall.collateral_f_token_v1_calls:type_name -> steward.v4.CollateralFTokenAdaptorV1Calls + 112, // 68: steward.v4.AdaptorCall.aave_v3_debt_token_v1_flash_loan_calls:type_name -> steward.v4.AaveV3DebtTokenAdaptorV1FlashLoanCalls + 113, // 69: steward.v4.AdaptorCall.balancer_pool_v1_flash_loan_calls:type_name -> steward.v4.BalancerPoolAdaptorV1FlashLoanCalls + 114, // 70: steward.v4.AdaptorCall.convex_curve_v1_calls:type_name -> steward.v4.ConvexCurveAdaptorV1Calls + 115, // 71: steward.v4.AdaptorCall.curve_v1_calls:type_name -> steward.v4.CurveAdaptorV1Calls + 116, // 72: steward.v4.AdaptorCall.aura_erc4626_v1_calls:type_name -> steward.v4.AuraERC4626AdaptorV1Calls + 117, // 73: steward.v4.AdaptorCall.morpho_blue_collateral_v1_calls:type_name -> steward.v4.MorphoBlueCollateralAdaptorV1Calls + 118, // 74: steward.v4.AdaptorCall.morpho_blue_debt_v1_calls:type_name -> steward.v4.MorphoBlueDebtAdaptorV1Calls + 119, // 75: steward.v4.AdaptorCall.morpho_blue_supply_v1_calls:type_name -> steward.v4.MorphoBlueSupplyAdaptorV1Calls + 6, // 76: steward.v4.CellarV2.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall + 27, // 77: steward.v4.CellarV2_2.FunctionCall.add_position:type_name -> steward.v4.CellarV2_2.AddPosition + 28, // 78: steward.v4.CellarV2_2.FunctionCall.call_on_adaptor:type_name -> steward.v4.CellarV2_2.CallOnAdaptor + 29, // 79: steward.v4.CellarV2_2.FunctionCall.remove_position:type_name -> steward.v4.CellarV2_2.RemovePosition + 30, // 80: steward.v4.CellarV2_2.FunctionCall.remove_adaptor_from_catalogue:type_name -> steward.v4.CellarV2_2.RemoveAdaptorFromCatalogue + 31, // 81: steward.v4.CellarV2_2.FunctionCall.remove_position_from_catalogue:type_name -> steward.v4.CellarV2_2.RemovePositionFromCatalogue + 32, // 82: steward.v4.CellarV2_2.FunctionCall.set_holding_position:type_name -> steward.v4.CellarV2_2.SetHoldingPosition + 33, // 83: steward.v4.CellarV2_2.FunctionCall.set_strategist_payout_address:type_name -> steward.v4.CellarV2_2.SetStrategistPayoutAddress + 34, // 84: steward.v4.CellarV2_2.FunctionCall.swap_positions:type_name -> steward.v4.CellarV2_2.SwapPositions + 36, // 85: steward.v4.CellarV2_2.FunctionCall.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_2.AddAdaptorToCatalogue + 37, // 86: steward.v4.CellarV2_2.FunctionCall.add_position_to_catalogue:type_name -> steward.v4.CellarV2_2.AddPositionToCatalogue + 39, // 87: steward.v4.CellarV2_2.FunctionCall.set_rebalance_deviation:type_name -> steward.v4.CellarV2_2.SetRebalanceDeviation + 38, // 88: steward.v4.CellarV2_2.FunctionCall.set_share_lock_period:type_name -> steward.v4.CellarV2_2.SetShareLockPeriod + 41, // 89: steward.v4.CellarV2_2.FunctionCall.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_2.SetStrategistPlatformCut + 40, // 90: steward.v4.CellarV2_2.FunctionCall.initiate_shutdown:type_name -> steward.v4.CellarV2_2.InitiateShutdown + 42, // 91: steward.v4.CellarV2_2.FunctionCall.lift_shutdown:type_name -> steward.v4.CellarV2_2.LiftShutdown + 43, // 92: steward.v4.CellarV2_2.FunctionCall.cache_price_router:type_name -> steward.v4.CellarV2_2.CachePriceRouter + 6, // 93: steward.v4.CellarV2_2.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall + 26, // 94: steward.v4.CellarV2_2.Multicall.function_calls:type_name -> steward.v4.CellarV2_2.FunctionCall + 55, // 95: steward.v4.CellarV2_5.FunctionCall.add_position:type_name -> steward.v4.CellarV2_5.AddPosition + 56, // 96: steward.v4.CellarV2_5.FunctionCall.call_on_adaptor:type_name -> steward.v4.CellarV2_5.CallOnAdaptor + 57, // 97: steward.v4.CellarV2_5.FunctionCall.remove_position:type_name -> steward.v4.CellarV2_5.RemovePosition + 58, // 98: steward.v4.CellarV2_5.FunctionCall.set_holding_position:type_name -> steward.v4.CellarV2_5.SetHoldingPosition + 59, // 99: steward.v4.CellarV2_5.FunctionCall.set_strategist_payout_address:type_name -> steward.v4.CellarV2_5.SetStrategistPayoutAddress + 60, // 100: steward.v4.CellarV2_5.FunctionCall.swap_positions:type_name -> steward.v4.CellarV2_5.SwapPositions + 61, // 101: steward.v4.CellarV2_5.FunctionCall.set_share_lock_period:type_name -> steward.v4.CellarV2_5.SetShareLockPeriod + 62, // 102: steward.v4.CellarV2_5.FunctionCall.initiate_shutdown:type_name -> steward.v4.CellarV2_5.InitiateShutdown + 63, // 103: steward.v4.CellarV2_5.FunctionCall.lift_shutdown:type_name -> steward.v4.CellarV2_5.LiftShutdown + 65, // 104: steward.v4.CellarV2_5.FunctionCall.remove_adaptor_from_catalogue:type_name -> steward.v4.CellarV2_5.RemoveAdaptorFromCatalogue + 66, // 105: steward.v4.CellarV2_5.FunctionCall.remove_position_from_catalogue:type_name -> steward.v4.CellarV2_5.RemovePositionFromCatalogue + 67, // 106: steward.v4.CellarV2_5.FunctionCall.decrease_share_supply_cap:type_name -> steward.v4.CellarV2_5.DecreaseShareSupplyCap + 68, // 107: steward.v4.CellarV2_5.FunctionCall.set_alternative_asset_data:type_name -> steward.v4.CellarV2_5.SetAlternativeAssetData + 69, // 108: steward.v4.CellarV2_5.FunctionCall.drop_alternative_asset_data:type_name -> steward.v4.CellarV2_5.DropAlternativeAssetData + 70, // 109: steward.v4.CellarV2_5.FunctionCall.add_adaptor_to_catalogue:type_name -> steward.v4.CellarV2_5.AddAdaptorToCatalogue + 71, // 110: steward.v4.CellarV2_5.FunctionCall.add_position_to_catalogue:type_name -> steward.v4.CellarV2_5.AddPositionToCatalogue + 72, // 111: steward.v4.CellarV2_5.FunctionCall.set_rebalance_deviation:type_name -> steward.v4.CellarV2_5.SetRebalanceDeviation + 73, // 112: steward.v4.CellarV2_5.FunctionCall.set_strategist_platform_cut:type_name -> steward.v4.CellarV2_5.SetStrategistPlatformCut + 75, // 113: steward.v4.CellarV2_5.FunctionCall.set_share_price_oracle:type_name -> steward.v4.CellarV2_5.SetSharePriceOracle + 74, // 114: steward.v4.CellarV2_5.FunctionCall.increase_share_supply_cap:type_name -> steward.v4.CellarV2_5.IncreaseShareSupplyCap + 76, // 115: steward.v4.CellarV2_5.FunctionCall.cache_price_router:type_name -> steward.v4.CellarV2_5.CachePriceRouter + 6, // 116: steward.v4.CellarV2_5.CallOnAdaptor.data:type_name -> steward.v4.AdaptorCall + 54, // 117: steward.v4.CellarV2_5.Multicall.function_calls:type_name -> steward.v4.CellarV2_5.FunctionCall + 118, // [118:118] is the sub-list for method output_type + 118, // [118:118] is the sub-list for method input_type + 118, // [118:118] is the sub-list for extension type_name + 118, // [118:118] is the sub-list for extension extendee + 0, // [0:118] is the sub-list for field type_name } func init() { file_cellar_v2_proto_init() } @@ -6255,8 +7839,164 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance); i { + file_cellar_v2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2Governance); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5Governance); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*AdaptorCall); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_CallOnAdaptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_RemovePosition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetHoldingPosition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetStrategistPayoutAddress); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SwapPositions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetShareLockPeriod); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_AddPosition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_InitiateShutdown); i { case 0: return &v.state case 1: @@ -6267,8 +8007,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2); i { + file_cellar_v2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_LiftShutdown); i { case 0: return &v.state case 1: @@ -6279,8 +8019,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2Governance); i { + file_cellar_v2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetPlatformFee); i { case 0: return &v.state case 1: @@ -6291,8 +8031,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5); i { + file_cellar_v2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetStrategistPlatformCut); i { case 0: return &v.state case 1: @@ -6303,8 +8043,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5Governance); i { + file_cellar_v2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetupAdaptor); i { case 0: return &v.state case 1: @@ -6315,8 +8055,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*AdaptorCall); i { + file_cellar_v2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_SetRebalanceDeviation); i { case 0: return &v.state case 1: @@ -6327,8 +8067,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_AddPosition); i { + file_cellar_v2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_InitiateShutdown); i { case 0: return &v.state case 1: @@ -6339,8 +8079,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_CallOnAdaptor); i { + file_cellar_v2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_LiftShutdown); i { case 0: return &v.state case 1: @@ -6351,8 +8091,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_RemovePosition); i { + file_cellar_v2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_SetPlatformFee); i { case 0: return &v.state case 1: @@ -6363,8 +8103,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_SetHoldingPosition); i { + file_cellar_v2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_SetStrategistPlatformCut); i { case 0: return &v.state case 1: @@ -6375,8 +8115,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_SetStrategistPayoutAddress); i { + file_cellar_v2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_SetupAdaptor); i { case 0: return &v.state case 1: @@ -6387,8 +8127,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_SwapPositions); i { + file_cellar_v2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2Governance_SetRebalanceDeviation); i { case 0: return &v.state case 1: @@ -6399,8 +8139,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_SetShareLockPeriod); i { + file_cellar_v2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_FunctionCall); i { case 0: return &v.state case 1: @@ -6411,8 +8151,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_InitiateShutdown); i { + file_cellar_v2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_AddPosition); i { case 0: return &v.state case 1: @@ -6423,8 +8163,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_LiftShutdown); i { + file_cellar_v2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_CallOnAdaptor); i { case 0: return &v.state case 1: @@ -6435,8 +8175,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_SetPlatformFee); i { + file_cellar_v2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_RemovePosition); i { case 0: return &v.state case 1: @@ -6447,8 +8187,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_SetStrategistPlatformCut); i { + file_cellar_v2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_RemoveAdaptorFromCatalogue); i { case 0: return &v.state case 1: @@ -6459,8 +8199,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_SetupAdaptor); i { + file_cellar_v2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_RemovePositionFromCatalogue); i { case 0: return &v.state case 1: @@ -6471,8 +8211,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2Governance_SetRebalanceDeviation); i { + file_cellar_v2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SetHoldingPosition); i { case 0: return &v.state case 1: @@ -6483,8 +8223,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_FunctionCall); i { + file_cellar_v2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SetStrategistPayoutAddress); i { case 0: return &v.state case 1: @@ -6495,8 +8235,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_AddPosition); i { + file_cellar_v2_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SwapPositions); i { case 0: return &v.state case 1: @@ -6507,8 +8247,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_CallOnAdaptor); i { + file_cellar_v2_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_Multicall); i { case 0: return &v.state case 1: @@ -6519,8 +8259,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_RemovePosition); i { + file_cellar_v2_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_AddAdaptorToCatalogue); i { case 0: return &v.state case 1: @@ -6531,8 +8271,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_RemoveAdaptorFromCatalogue); i { + file_cellar_v2_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_AddPositionToCatalogue); i { case 0: return &v.state case 1: @@ -6543,8 +8283,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_RemovePositionFromCatalogue); i { + file_cellar_v2_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SetShareLockPeriod); i { case 0: return &v.state case 1: @@ -6555,8 +8295,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_SetHoldingPosition); i { + file_cellar_v2_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SetRebalanceDeviation); i { case 0: return &v.state case 1: @@ -6567,8 +8307,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_SetStrategistPayoutAddress); i { + file_cellar_v2_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_InitiateShutdown); i { case 0: return &v.state case 1: @@ -6579,8 +8319,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_SwapPositions); i { + file_cellar_v2_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_SetStrategistPlatformCut); i { case 0: return &v.state case 1: @@ -6591,8 +8331,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_2_Multicall); i { + file_cellar_v2_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_LiftShutdown); i { case 0: return &v.state case 1: @@ -6603,7 +8343,19 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_2_CachePriceRouter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_AddAdaptorToCatalogue); i { case 0: return &v.state @@ -6615,7 +8367,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_AddPositionToCatalogue); i { case 0: return &v.state @@ -6627,7 +8379,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_SetShareLockPeriod); i { case 0: return &v.state @@ -6639,7 +8391,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_SetRebalanceDeviation); i { case 0: return &v.state @@ -6651,7 +8403,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_InitiateShutdown); i { case 0: return &v.state @@ -6663,7 +8415,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_SetStrategistPlatformCut); i { case 0: return &v.state @@ -6675,7 +8427,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_LiftShutdown); i { case 0: return &v.state @@ -6687,7 +8439,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_ForcePositionOut); i { case 0: return &v.state @@ -6699,7 +8451,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_ToggleIgnorePause); i { case 0: return &v.state @@ -6711,7 +8463,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_2Governance_CachePriceRouter); i { case 0: return &v.state @@ -6723,7 +8475,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_FunctionCall); i { case 0: return &v.state @@ -6735,7 +8487,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_AddPosition); i { case 0: return &v.state @@ -6747,7 +8499,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_CallOnAdaptor); i { case 0: return &v.state @@ -6759,7 +8511,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_RemovePosition); i { case 0: return &v.state @@ -6771,7 +8523,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_SetHoldingPosition); i { case 0: return &v.state @@ -6783,7 +8535,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_SetStrategistPayoutAddress); i { case 0: return &v.state @@ -6795,7 +8547,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_SwapPositions); i { case 0: return &v.state @@ -6807,7 +8559,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5_SetShareLockPeriod); i { case 0: return &v.state @@ -6819,8 +8571,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_SetRebalanceDeviation); i { + file_cellar_v2_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_InitiateShutdown); i { case 0: return &v.state case 1: @@ -6831,8 +8583,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_InitiateShutdown); i { + file_cellar_v2_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_LiftShutdown); i { case 0: return &v.state case 1: @@ -6843,8 +8595,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_LiftShutdown); i { + file_cellar_v2_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_Multicall); i { case 0: return &v.state case 1: @@ -6855,8 +8607,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_Multicall); i { + file_cellar_v2_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_RemoveAdaptorFromCatalogue); i { case 0: return &v.state case 1: @@ -6867,8 +8619,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_RemoveAdaptorFromCatalogue); i { + file_cellar_v2_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_RemovePositionFromCatalogue); i { case 0: return &v.state case 1: @@ -6879,8 +8631,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_RemovePositionFromCatalogue); i { + file_cellar_v2_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_DecreaseShareSupplyCap); i { case 0: return &v.state case 1: @@ -6891,8 +8643,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_DecreaseShareSupplyCap); i { + file_cellar_v2_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_SetAlternativeAssetData); i { case 0: return &v.state case 1: @@ -6903,8 +8655,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_SetAlternativeAssetData); i { + file_cellar_v2_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_DropAlternativeAssetData); i { case 0: return &v.state case 1: @@ -6915,8 +8667,8 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CellarV2_5_DropAlternativeAssetData); i { + file_cellar_v2_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_AddAdaptorToCatalogue); i { case 0: return &v.state case 1: @@ -6927,7 +8679,79 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_AddPositionToCatalogue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_SetRebalanceDeviation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_SetStrategistPlatformCut); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_IncreaseShareSupplyCap); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_SetSharePriceOracle); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*CellarV2_5_CachePriceRouter); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_cellar_v2_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_AddAdaptorToCatalogue); i { case 0: return &v.state @@ -6939,7 +8763,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_AddPositionToCatalogue); i { case 0: return &v.state @@ -6951,7 +8775,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_SetRebalanceDeviation); i { case 0: return &v.state @@ -6963,7 +8787,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_SetStrategistPlatformCut); i { case 0: return &v.state @@ -6975,7 +8799,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_ForcePositionOut); i { case 0: return &v.state @@ -6987,7 +8811,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_ToggleIgnorePause); i { case 0: return &v.state @@ -6999,7 +8823,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_SetAutomationActions); i { case 0: return &v.state @@ -7011,7 +8835,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_IncreaseShareSupplyCap); i { case 0: return &v.state @@ -7023,7 +8847,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_SetSharePriceOracle); i { case 0: return &v.state @@ -7035,7 +8859,7 @@ func file_cellar_v2_proto_init() { return nil } } - file_cellar_v2_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { + file_cellar_v2_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*CellarV2_5Governance_CachePriceRouter); i { case 0: return &v.state @@ -7049,13 +8873,19 @@ func file_cellar_v2_proto_init() { } } file_cellar_v2_proto_msgTypes[0].OneofWrappers = []interface{}{ - (*CellarV2_AddPosition_)(nil), (*CellarV2_CallOnAdaptor_)(nil), (*CellarV2_RemovePosition_)(nil), (*CellarV2_SetHoldingPosition_)(nil), (*CellarV2_SetStrategistPayoutAddress_)(nil), (*CellarV2_SwapPositions_)(nil), (*CellarV2_SetShareLockPeriod_)(nil), + (*CellarV2_AddPosition_)(nil), + (*CellarV2_SetupAdaptor_)(nil), + (*CellarV2_InitiateShutdown_)(nil), + (*CellarV2_LiftShutdown_)(nil), + (*CellarV2_SetPlatformFee_)(nil), + (*CellarV2_SetStrategistPlatformCut_)(nil), + (*CellarV2_SetRebalanceDeviation_)(nil), } file_cellar_v2_proto_msgTypes[1].OneofWrappers = []interface{}{ (*CellarV2Governance_InitiateShutdown_)(nil), @@ -7132,7 +8962,7 @@ func file_cellar_v2_proto_init() { (*AdaptorCall_MorphoBlueDebtV1Calls)(nil), (*AdaptorCall_MorphoBlueSupplyV1Calls)(nil), } - file_cellar_v2_proto_msgTypes[20].OneofWrappers = []interface{}{ + file_cellar_v2_proto_msgTypes[26].OneofWrappers = []interface{}{ (*CellarV2_2_FunctionCall_AddPosition)(nil), (*CellarV2_2_FunctionCall_CallOnAdaptor)(nil), (*CellarV2_2_FunctionCall_RemovePosition)(nil), @@ -7141,8 +8971,16 @@ func file_cellar_v2_proto_init() { (*CellarV2_2_FunctionCall_SetHoldingPosition)(nil), (*CellarV2_2_FunctionCall_SetStrategistPayoutAddress)(nil), (*CellarV2_2_FunctionCall_SwapPositions)(nil), - } - file_cellar_v2_proto_msgTypes[40].OneofWrappers = []interface{}{ + (*CellarV2_2_FunctionCall_AddAdaptorToCatalogue)(nil), + (*CellarV2_2_FunctionCall_AddPositionToCatalogue)(nil), + (*CellarV2_2_FunctionCall_SetRebalanceDeviation)(nil), + (*CellarV2_2_FunctionCall_SetShareLockPeriod)(nil), + (*CellarV2_2_FunctionCall_SetStrategistPlatformCut)(nil), + (*CellarV2_2_FunctionCall_InitiateShutdown)(nil), + (*CellarV2_2_FunctionCall_LiftShutdown)(nil), + (*CellarV2_2_FunctionCall_CachePriceRouter)(nil), + } + file_cellar_v2_proto_msgTypes[54].OneofWrappers = []interface{}{ (*CellarV2_5_FunctionCall_AddPosition)(nil), (*CellarV2_5_FunctionCall_CallOnAdaptor)(nil), (*CellarV2_5_FunctionCall_RemovePosition)(nil), @@ -7157,6 +8995,13 @@ func file_cellar_v2_proto_init() { (*CellarV2_5_FunctionCall_DecreaseShareSupplyCap)(nil), (*CellarV2_5_FunctionCall_SetAlternativeAssetData)(nil), (*CellarV2_5_FunctionCall_DropAlternativeAssetData)(nil), + (*CellarV2_5_FunctionCall_AddAdaptorToCatalogue)(nil), + (*CellarV2_5_FunctionCall_AddPositionToCatalogue)(nil), + (*CellarV2_5_FunctionCall_SetRebalanceDeviation)(nil), + (*CellarV2_5_FunctionCall_SetStrategistPlatformCut)(nil), + (*CellarV2_5_FunctionCall_SetSharePriceOracle)(nil), + (*CellarV2_5_FunctionCall_IncreaseShareSupplyCap)(nil), + (*CellarV2_5_FunctionCall_CachePriceRouter)(nil), } type x struct{} out := protoimpl.TypeBuilder{ @@ -7164,7 +9009,7 @@ func file_cellar_v2_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_cellar_v2_proto_rawDesc, NumEnums: 0, - NumMessages: 67, + NumMessages: 87, NumExtensions: 0, NumServices: 0, },