Add dry run deposit query to inflow vault (#408)

* Add dry run deposit query to inflow vault contract

Add a DryRunDeposit query that calculates how many vault shares would be
minted for a given deposit amount without executing the deposit. This
allows users and frontends to preview share amounts before committing.

Closes #407

* Update changelog entry to reference PR #408

* Document that DryRunDeposit does not enforce the deposit cap

Author: p-offtermatt

.changelog/unreleased/features/407-dry-run-deposit-query.md

@@ -0,0 +1 @@
+- Add "dry run deposit" query to the inflow vault contract that calculates how many shares would be minted for a given deposit amount without executing the deposit. ([\#408](https://github.com/informalsystems/hydro/pull/408))

contracts/inflow/vault/schema/raw/query.json

@@ -269,6 +269,28 @@
         }
       },
       "additionalProperties": false
+    },
+    {
+      "description": "Simulates a deposit and returns the number of vault shares that would be minted for the given amount of the deposit token, without executing it.",
+      "type": "object",
+      "required": [
+        "dry_run_deposit"
+      ],
+      "properties": {
+        "dry_run_deposit": {
+          "type": "object",
+          "required": [
+            "amount"
+          ],
+          "properties": {
+            "amount": {
+              "$ref": "#/definitions/Uint128"
+            }
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": false
     }
   ],
   "definitions": {

contracts/inflow/vault/schema/raw/response_to_dry_run_deposit.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Uint128",
+  "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
+  "type": "string"
+}

contracts/inflow/vault/schema/vault.json

@@ -927,6 +927,28 @@
           }
         },
         "additionalProperties": false
+      },
+      {
+        "description": "Simulates a deposit and returns the number of vault shares that would be minted for the given amount of the deposit token, without executing it.",
+        "type": "object",
+        "required": [
+          "dry_run_deposit"
+        ],
+        "properties": {
+          "dry_run_deposit": {
+            "type": "object",
+            "required": [
+              "amount"
+            ],
+            "properties": {
+              "amount": {
+                "$ref": "#/definitions/Uint128"
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "additionalProperties": false
       }
     ],
     "definitions": {
@@ -1153,6 +1175,12 @@
         }
       }
     },
+    "dry_run_deposit": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "Uint128",
+      "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```",
+      "type": "string"
+    },
     "funded_withdrawal_requests": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "title": "FundedWithdrawalRequestsResponse",

contracts/inflow/vault/src/contract.rs

@@ -1770,6 +1770,9 @@ pub fn query(deps: Deps<NeutronQuery>, env: Env, msg: QueryMsg) -> StdResult<Bin
         }
         QueryMsg::ListAdapters {} => to_json_binary(&query_list_adapters(&deps)?),
         QueryMsg::AdapterInfo { name } => to_json_binary(&query_adapter_info(&deps, name)?),
+        QueryMsg::DryRunDeposit { amount } => {
+            to_json_binary(&query_dry_run_deposit(&deps, amount)?)
+        }
     }
 }
 
@@ -1817,6 +1820,32 @@ fn query_user_shares_equivalent_value(
     query_shares_equivalent_value(deps, &config, shares_balance)
 }
 
+/// Simulates a deposit and returns the number of vault shares that would be
+/// minted for the given amount of the deposit token, without executing it.
+/// Note: this does not enforce the deposit cap. It will return a share amount
+/// even if the deposit would be rejected due to the cap being reached.
+fn query_dry_run_deposit(deps: &Deps<NeutronQuery>, amount: Uint128) -> StdResult<Uint128> {
+    let config = load_config(deps.storage)?;
+    let pool_info = get_control_center_pool_info(deps, &config.control_center_contract)?;
+
+    let deposit_amount_base_tokens = convert_deposit_token_into_base_token(deps, &config, amount)?;
+
+    // In a real deposit, total_pool_value already includes the deposited tokens (they are sent
+    // before execute runs). Here no tokens have been sent, so we add the deposit amount to
+    // total_pool_value to match what calculate_number_of_shares_to_mint expects.
+    let total_pool_value_with_deposit = pool_info
+        .total_pool_value
+        .checked_add(deposit_amount_base_tokens)
+        .map_err(|e| StdError::generic_err(format!("overflow error: {e}")))?;
+
+    calculate_number_of_shares_to_mint(
+        deposit_amount_base_tokens,
+        total_pool_value_with_deposit,
+        pool_info.total_shares_issued,
+    )
+    .map_err(|e| StdError::generic_err(e.to_string()))
+}
+
 pub fn query_available_for_deployment(deps: &Deps<NeutronQuery>, env: &Env) -> StdResult<Uint128> {
     let config = load_config(deps.storage)?;
     let withdrawal_queue_info = load_withdrawal_queue_info(deps.storage)?;

contracts/inflow/vault/src/testing.rs

@@ -2125,6 +2125,110 @@ fn reporting_balance_queries_test() {
     assert_eq!(eq_value, Uint128::new(501_000));
 }
 
+#[test]
+fn dry_run_deposit_query_test() {
+    let (mut deps, mut env) = (mock_dependencies(), mock_env());
+
+    let vault_contract_addr = deps.api.addr_make(INFLOW);
+    let control_center_contract_addr = deps.api.addr_make(CONTROL_CENTER);
+    let token_info_provider_contract_addr = deps.api.addr_make(TOKEN_INFO_PROVIDER);
+    let whitelist_addr = deps.api.addr_make(WHITELIST_ADDR);
+
+    env.contract.address = vault_contract_addr.clone();
+
+    let instantiate_msg = get_default_instantiate_msg(
+        DEPOSIT_DENOM,
+        whitelist_addr.clone(),
+        control_center_contract_addr.clone(),
+        token_info_provider_contract_addr.clone(),
+    );
+
+    let info = get_message_info(&deps.api, "creator", &[]);
+    instantiate(deps.as_mut(), env.clone(), info, instantiate_msg).unwrap();
+
+    let vault_shares_denom_str: String =
+        format!("factory/{vault_contract_addr}/hydro_inflow_udatom");
+
+    set_vault_shares_denom(&mut deps, vault_shares_denom_str.clone());
+
+    // Case 1: Empty pool (no existing shares) → 1:1 ratio in base tokens
+    // With dATOM ratio of 1.2, depositing 500_000 deposit tokens = 600_000 base tokens = 600_000 shares
+    let wasm_querier = MockWasmQuerier::new(HashMap::from_iter([
+        setup_control_center_mock(
+            control_center_contract_addr.clone(),
+            DEFAULT_DEPOSIT_CAP,
+            Uint128::zero(),
+            Uint128::zero(),
+        ),
+        setup_token_info_provider_mock(
+            token_info_provider_contract_addr.clone(),
+            DEPOSIT_DENOM.to_string(),
+            DATOM_DEFAULT_RATIO,
+        ),
+    ]));
+
+    let querier_for_deps = wasm_querier.clone();
+    deps.querier
+        .update_wasm(move |q| querier_for_deps.handler(q));
+
+    let deposit_amount = Uint128::new(500_000);
+    let query_msg = QueryMsg::DryRunDeposit {
+        amount: deposit_amount,
+    };
+    let query_res = query(deps.as_ref(), env.clone(), query_msg);
+    assert!(query_res.is_ok());
+
+    let shares: Uint128 = from_json(query_res.unwrap()).unwrap();
+    // 500_000 * 1.2 ratio = 600_000 base tokens = 600_000 shares (1:1 on empty pool)
+    assert_eq!(shares, Uint128::new(600_000));
+
+    // Case 2: Pool already has 600_000 base token value and 600_000 shares.
+    // Depositing another 500_000 deposit tokens (= 600_000 base) should mint 600_000 shares
+    // since the pool ratio is 1:1.
+    update_contract_mock(
+        &mut deps,
+        &wasm_querier,
+        setup_default_control_center_mock(Uint128::new(600_000), Uint128::new(600_000)),
+    );
+
+    let query_msg = QueryMsg::DryRunDeposit {
+        amount: deposit_amount,
+    };
+    let query_res = query(deps.as_ref(), env.clone(), query_msg);
+    assert!(query_res.is_ok());
+
+    let shares: Uint128 = from_json(query_res.unwrap()).unwrap();
+    assert_eq!(shares, Uint128::new(600_000));
+
+    // Case 3: Pool value has grown (e.g. yield). Pool has 1_200_000 base value but still 600_000 shares.
+    // Depositing 500_000 deposit tokens (= 600_000 base) should mint 300_000 shares
+    // (600_000 * 600_000 / 1_200_000 = 300_000)
+    update_contract_mock(
+        &mut deps,
+        &wasm_querier,
+        setup_default_control_center_mock(Uint128::new(1_200_000), Uint128::new(600_000)),
+    );
+
+    let query_msg = QueryMsg::DryRunDeposit {
+        amount: deposit_amount,
+    };
+    let query_res = query(deps.as_ref(), env.clone(), query_msg);
+    assert!(query_res.is_ok());
+
+    let shares: Uint128 = from_json(query_res.unwrap()).unwrap();
+    assert_eq!(shares, Uint128::new(300_000));
+
+    // Case 4: Zero amount deposit should return zero shares
+    let query_msg = QueryMsg::DryRunDeposit {
+        amount: Uint128::zero(),
+    };
+    let query_res = query(deps.as_ref(), env, query_msg);
+    assert!(query_res.is_ok());
+
+    let shares: Uint128 = from_json(query_res.unwrap()).unwrap();
+    assert_eq!(shares, Uint128::zero());
+}
+
 #[test]
 fn withdrawal_with_config_update_test() {
     let (mut deps, mut env) = (mock_dependencies(), mock_env());

packages/interface/src/inflow_vault.rs

@@ -258,6 +258,13 @@ pub enum QueryMsg {
     /// Returns information about a specific adapter
     #[returns(AdapterInfoResponse)]
     AdapterInfo { name: String },
+
+    /// Simulates a deposit and returns the number of vault shares that would be
+    /// minted for the given amount of the deposit token, without executing it.
+    /// Note: this query does not enforce the deposit cap. It will return a share
+    /// amount even if the deposit would be rejected due to the cap being reached.
+    #[returns(Uint128)]
+    DryRunDeposit { amount: Uint128 },
 }
 
 #[cw_serde]

ts_types/InflowVaultBase.client.ts

@@ -57,6 +57,11 @@ export interface InflowVaultBaseReadOnlyInterface {
   }: {
     name: string;
   }) => Promise<AdapterInfoResponse>;
+  dryRunDeposit: ({
+    amount
+  }: {
+    amount: Uint128;
+  }) => Promise<Uint128>;
 }
 export class InflowVaultBaseQueryClient implements InflowVaultBaseReadOnlyInterface {
   client: CosmWasmClient;
@@ -78,6 +83,7 @@ export class InflowVaultBaseQueryClient implements InflowVaultBaseReadOnlyInterf
     this.controlCenterPoolInfo = this.controlCenterPoolInfo.bind(this);
     this.listAdapters = this.listAdapters.bind(this);
     this.adapterInfo = this.adapterInfo.bind(this);
+    this.dryRunDeposit = this.dryRunDeposit.bind(this);
   }
   config = async (): Promise<ConfigResponse> => {
     return this.client.queryContractSmart(this.contractAddress, {
@@ -200,6 +206,17 @@ export class InflowVaultBaseQueryClient implements InflowVaultBaseReadOnlyInterf
       }
     });
   };
+  dryRunDeposit = async ({
+    amount
+  }: {
+    amount: Uint128;
+  }): Promise<Uint128> => {
+    return this.client.queryContractSmart(this.contractAddress, {
+      dry_run_deposit: {
+        amount
+      }
+    });
+  };
 }
 export interface InflowVaultBaseInterface extends InflowVaultBaseReadOnlyInterface {
   contractAddress: string;

ts_types/InflowVaultBase.types.ts

@@ -163,6 +163,10 @@ export type QueryMsg = {
   adapter_info: {
     name: string;
   };
+} | {
+  dry_run_deposit: {
+    amount: Uint128;
+  };
 };
 export type Order = "ascending" | "descending";
 export type Addr = string;