Remove simulator autofarm support.

Author: greimela

crates/chia-sdk-bindings/src/full_node_simulator.rs

@@ -74,15 +74,6 @@ impl FullNodeSimulator {
         Ok(())
     }
 
-    pub fn get_autofarm(&self) -> Result<bool> {
-        Ok(self.0.lock().unwrap().get_autofarm())
-    }
-
-    pub fn set_autofarm(&self, autofarm: bool) -> Result<()> {
-        self.0.lock().unwrap().set_autofarm(autofarm);
-        Ok(())
-    }
-
     pub fn get_blockchain_state(&self) -> Result<BlockchainStateResponse> {
         Ok(self.0.lock().unwrap().get_blockchain_state())
     }

crates/chia-sdk-test/src/full_node_simulator.rs

@@ -56,7 +56,6 @@ pub struct FullNodeSimulator {
     coin_spends: IndexMap<Bytes32, CoinSpend>,
     coin_hints: IndexMap<Bytes32, Bytes32>,
     mempool: IndexMap<Bytes32, ValidatedBundle>,
-    autofarm: bool,
     farming_puzzle_hash: Bytes32,
     master_secret_key: SecretKey,
     prefarm_puzzle_hash: Bytes32,
@@ -254,7 +253,6 @@ impl FullNodeSimulator {
             coin_spends: IndexMap::new(),
             coin_hints: IndexMap::new(),
             mempool: IndexMap::new(),
-            autofarm: true,
             farming_puzzle_hash: prefarm_puzzle_hash,
             master_secret_key: root_secret_key,
             prefarm_puzzle_hash,
@@ -309,14 +307,6 @@ impl FullNodeSimulator {
         self.farming_puzzle_hash = puzzle_hash;
     }
 
-    pub fn get_autofarm(&self) -> bool {
-        self.autofarm
-    }
-
-    pub fn set_autofarm(&mut self, autofarm: bool) {
-        self.autofarm = autofarm;
-    }
-
     pub fn get_blockchain_state(&self) -> BlockchainStateResponse {
         let peak = self
             .blocks
@@ -595,9 +585,6 @@ impl FullNodeSimulator {
         loop {
             let tx_id = spend_bundle.name();
             if self.mempool.contains_key(&tx_id) {
-                if self.autofarm {
-                    self.farm_block(1);
-                }
                 return push_tx_success();
             }
 
@@ -621,10 +608,6 @@ impl FullNodeSimulator {
 
             match self.insert_mempool_item(tx_id, validated.clone()) {
                 Ok(()) => {
-                    if self.autofarm {
-                        self.farm_block(1);
-                    }
-
                     return push_tx_success();
                 }
                 Err(SimulatorError::Validation(ErrorCode::MempoolConflict))
@@ -952,15 +935,24 @@ mod tests {
     }
 
     #[test]
-    fn push_tx_autofarms_by_default() -> anyhow::Result<()> {
+    fn push_tx_waits_for_manual_farming() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let coin = sim.new_coin(puzzle_hash, 100);
         let spend_bundle = spend_to_child(coin, puzzle_reveal, puzzle_hash, 99)?;
 
-        assert!(sim.get_autofarm());
         let response = sim.push_tx(spend_bundle);
         assert!(response.success);
+        assert_eq!(
+            sim.get_blockchain_state()
+                .blockchain_state
+                .unwrap()
+                .mempool_size,
+            1
+        );
+        assert_eq!(sim.height(), 1);
+
+        sim.farm_block(1);
         assert_eq!(
             sim.get_blockchain_state()
                 .blockchain_state
@@ -990,7 +982,6 @@ mod tests {
     #[test]
     fn farm_block_includes_mempool_and_emits_event() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let coin = sim.new_coin(puzzle_hash, 100);
         let child = Coin::new(coin.coin_id(), puzzle_hash, 99);
@@ -1061,7 +1052,6 @@ mod tests {
     #[test]
     fn push_tx_accepts_ephemeral_spends_in_same_bundle() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let parent = sim.new_coin(puzzle_hash, 100);
         let child = Coin::new(parent.coin_id(), puzzle_hash, 99);
@@ -1105,40 +1095,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn autofarm_can_be_turned_off_and_on() -> anyhow::Result<()> {
-        let mut sim = FullNodeSimulator::new();
-        let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
-        let coin = sim.new_coin(puzzle_hash, 100);
-        let spend_bundle = spend_to_child(coin, puzzle_reveal, puzzle_hash, 99)?;
-
-        sim.set_autofarm(false);
-        assert!(!sim.get_autofarm());
-        assert!(sim.push_tx(spend_bundle.clone()).success);
-        assert_eq!(
-            sim.get_blockchain_state()
-                .blockchain_state
-                .unwrap()
-                .mempool_size,
-            1
-        );
-        assert_eq!(sim.height(), 1);
-
-        sim.set_autofarm(true);
-        assert!(sim.get_autofarm());
-        assert!(sim.push_tx(spend_bundle).success);
-        assert_eq!(sim.height(), 2);
-        assert_eq!(
-            sim.get_blockchain_state()
-                .blockchain_state
-                .unwrap()
-                .mempool_size,
-            0
-        );
-
-        Ok(())
-    }
-
     #[test]
     fn revert_removes_farmed_reward() {
         let mut sim = FullNodeSimulator::new();

crates/chia-sdk-test/src/full_node_simulator/fast_forward.rs

@@ -363,6 +363,7 @@ mod tests {
 
         let response = sim.push_tx(stale_bundle);
         assert!(response.success, "{response:?}");
+        sim.farm_block(1);
 
         let child_record = sim
             .get_coin_record_by_name(child_coin.coin_id())

crates/chia-sdk-test/src/full_node_simulator/mempool.rs

@@ -106,7 +106,6 @@ mod tests {
     #[test]
     fn push_tx_rejects_mempool_conflict() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let coin = sim.new_coin(puzzle_hash, 100);
         let first = spend_to_child(coin, puzzle_reveal.clone(), puzzle_hash, 98)?;
@@ -134,7 +133,6 @@ mod tests {
     #[test]
     fn push_tx_replaces_mempool_conflict_with_higher_fee_superset() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let coin = sim.new_coin(puzzle_hash, 100);
         let first = spend_to_child(coin, puzzle_reveal.clone(), puzzle_hash, 99)?;
@@ -169,7 +167,6 @@ mod tests {
     #[test]
     fn push_tx_does_not_replace_conflict_that_is_not_a_superset() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let coin_a = sim.new_coin(puzzle_hash, 100);
         let coin_b = sim.new_coin(puzzle_hash, 100);
@@ -206,7 +203,6 @@ mod tests {
     #[test]
     fn push_tx_allows_dedup_compatible_mempool_overlap() -> anyhow::Result<()> {
         let mut sim = FullNodeSimulator::new();
-        sim.set_autofarm(false);
         let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
         let shared_coin = sim.new_coin(puzzle_hash, 100);
         let extra_coin = sim.new_coin(puzzle_hash, 100);

crates/chia-sdk-test/src/full_node_simulator_http/handlers.rs

@@ -14,9 +14,9 @@ use super::{
         GetAggsigAdditionalDataResponse, HeaderHashRequest, HeightRequest, HintRequest,
         HintsRequest, InsertCoinRequest, NameRequest, NamesRequest, NewCoinRequest,
         ParentIdsRequest, PushTxRequest, PuzzleAndSolutionRequest, PuzzleHashRequest,
-        PuzzleHashesRequest, ReorgBlocksRequest, RevertBlocksRequest, SetAutofarmRequest,
-        SetFarmingPhRequest, SimEventsResponse, SimFarmBlockResponse, SimNewCoinResponse,
-        SimRevertBlocksResponse, SimSuccessResponse, TxIdRequest,
+        PuzzleHashesRequest, ReorgBlocksRequest, RevertBlocksRequest, SetFarmingPhRequest,
+        SimEventsResponse, SimFarmBlockResponse, SimNewCoinResponse, SimRevertBlocksResponse,
+        SimSuccessResponse, TxIdRequest,
     },
 };
 
@@ -78,7 +78,6 @@ pub(super) fn router(simulator: SharedSimulator) -> Router {
         .route("/sim/reorg_blocks", post(sim_reorg_blocks))
         .route("/sim/new_coin", post(sim_new_coin))
         .route("/sim/insert_coin", post(sim_insert_coin))
-        .route("/sim/set_autofarm", post(sim_set_autofarm))
         .route("/sim/set_farming_ph", post(sim_set_farming_ph))
         .route("/sim/drain_events", post(sim_drain_events))
         .with_state(simulator)
@@ -382,14 +381,6 @@ async fn sim_insert_coin(
     Json(SimSuccessResponse { success: true })
 }
 
-async fn sim_set_autofarm(
-    State(simulator): State<SharedSimulator>,
-    Json(request): Json<SetAutofarmRequest>,
-) -> Json<SimSuccessResponse> {
-    simulator.lock().unwrap().set_autofarm(request.autofarm);
-    Json(SimSuccessResponse { success: true })
-}
-
 async fn sim_set_farming_ph(
     State(simulator): State<SharedSimulator>,
     Json(request): Json<SetFarmingPhRequest>,

crates/chia-sdk-test/src/full_node_simulator_http/tests.rs

@@ -14,10 +14,7 @@ use crate::{
 use super::{
     push_tx::push_tx_response_body,
     server::FullNodeSimulatorServer,
-    types::{
-        GetAggsigAdditionalDataResponse, SimFarmBlockResponse, SimNewCoinResponse,
-        SimSuccessResponse,
-    },
+    types::{GetAggsigAdditionalDataResponse, SimFarmBlockResponse, SimNewCoinResponse},
 };
 
 #[tokio::test]
@@ -48,15 +45,6 @@ async fn rpc_client_can_drive_http_simulator() -> anyhow::Result<()> {
     assert_eq!(additional_data.len(), 64);
     assert!(!additional_data.starts_with("0x"));
 
-    let response = http
-        .post(format!("{}/sim/set_autofarm", server.url()))
-        .json(&serde_json::json!({ "autofarm": false }))
-        .send()
-        .await?
-        .json::<SimSuccessResponse>()
-        .await?;
-    assert!(response.success);
-
     let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
     let new_coin = http
         .post(format!("{}/sim/new_coin", server.url()))
@@ -212,10 +200,6 @@ async fn get_coin_records_by_puzzle_hashes_uses_exclusive_end_height() -> anyhow
     let server = FullNodeSimulatorServer::new().await?;
     let client = CoinsetClient::new(server.url());
     let http = reqwest::Client::new();
-    http.post(format!("{}/sim/set_autofarm", server.url()))
-        .json(&serde_json::json!({ "autofarm": false }))
-        .send()
-        .await?;
 
     let (parent_puzzle_hash, parent_puzzle_reveal) = to_puzzle(1)?;
     let (child_puzzle_hash, _) = to_puzzle(2)?;
@@ -273,10 +257,6 @@ async fn get_coin_records_by_puzzle_hashes_passes_through_include_spent_coins()
     let server = FullNodeSimulatorServer::new().await?;
     let client = CoinsetClient::new(server.url());
     let http = reqwest::Client::new();
-    http.post(format!("{}/sim/set_autofarm", server.url()))
-        .json(&serde_json::json!({ "autofarm": false }))
-        .send()
-        .await?;
 
     let (historical_puzzle_hash, historical_puzzle_reveal) = to_puzzle(1)?;
     let parent = http
@@ -473,10 +453,6 @@ async fn unsupported_endpoints_and_cursor_policy_are_explicit() -> anyhow::Resul
 async fn push_tx_returns_pending_for_mempool_conflict() -> anyhow::Result<()> {
     let server = FullNodeSimulatorServer::new().await?;
     let http = reqwest::Client::new();
-    http.post(format!("{}/sim/set_autofarm", server.url()))
-        .json(&serde_json::json!({ "autofarm": false }))
-        .send()
-        .await?;
 
     let (puzzle_hash, puzzle_reveal) = to_puzzle(1)?;
     let coin = http

crates/chia-sdk-test/src/full_node_simulator_http/types.rs

@@ -147,11 +147,6 @@ pub(super) struct InsertCoinRequest {
     pub(super) coin: Coin,
 }
 
-#[derive(Debug, Deserialize)]
-pub(super) struct SetAutofarmRequest {
-    pub(super) autofarm: bool,
-}
-
 #[derive(Debug, Deserialize)]
 pub(super) struct SetFarmingPhRequest {
     pub(super) puzzle_hash: Bytes32,

napi/__test__/full_node_simulator.spec.ts

@@ -75,15 +75,29 @@ test("full node simulator includes farmed rewards in block records", (t) => {
   t.false(rewardRecord!.spent);
 });
 
-test("full node simulator autofarm defaults on and can be toggled", (t) => {
+test("full node simulator push tx waits for manual farming", (t) => {
   const sim = new FullNodeSimulator();
-  t.true(sim.getAutofarm());
+  const clvm = new Clvm();
+  const puzzle = clvm.parse("1");
+  const puzzleHash = puzzle.treeHash();
+  const coin = sim.newCoin(puzzleHash, 100n);
+
+  const spendBundle = new SpendBundle(
+    [
+      new CoinSpend(
+        coin,
+        puzzle.serialize(),
+        clvm.parse(`((51 0x${Buffer.from(puzzleHash).toString("hex")} 99))`).serialize()
+      ),
+    ],
+    Signature.infinity()
+  );
 
-  sim.setAutofarm(false);
-  t.false(sim.getAutofarm());
+  t.true(sim.pushTx(spendBundle).success);
+  t.is(sim.getBlockchainState().blockchainState?.mempoolSize, 1);
 
-  sim.setAutofarm(true);
-  t.true(sim.getAutofarm());
+  sim.farmBlock(1);
+  t.is(sim.getBlockchainState().blockchainState?.mempoolSize, 0);
 });
 
 test("full node simulator can serve rpc over http", async (t) => {
@@ -99,7 +113,6 @@ test("full node simulator can serve rpc over http", async (t) => {
     const clvm = new Clvm();
     const puzzle = clvm.parse("1");
     const puzzleHash = puzzle.treeHash();
-    sim.setAutofarm(false);
     const coin = sim.newCoin(puzzleHash, 100n);
 
     const spendBundle = new SpendBundle(

napi/index.d.ts

@@ -1220,8 +1220,6 @@ export declare class FullNodeSimulator {
   getMasterSecretKey(): SecretKey
   getPrefarmPuzzleHash(): Buffer
   setFarmingPh(puzzleHash: Uint8Array): void
-  getAutofarm(): boolean
-  setAutofarm(autofarm: boolean): void
   getBlockchainState(): BlockchainStateResponse
   getNetworkInfo(): GetNetworkInfoResponse
   getAggsigAdditionalData(): Buffer

napi/src/lib.rs

@@ -336,17 +336,6 @@ impl FullNodeSimulator {
         Ok(())
     }
 
-    #[napi]
-    pub fn get_autofarm(&self) -> Result<bool> {
-        Ok(self.inner.get_autofarm()?)
-    }
-
-    #[napi]
-    pub fn set_autofarm(&mut self, autofarm: bool) -> Result<()> {
-        self.inner.set_autofarm(autofarm)?;
-        Ok(())
-    }
-
     #[napi]
     pub fn get_blockchain_state(&self, env: Env) -> Result<BlockchainStateResponse> {
         Ok(FromRust::from_rust(