Add storage-weighted proof-of-work policy for state-creating sends

Proof-of-work today is a one-time issuance cost uncorrelated with the
permanent storage a block imposes, so minting dust is nearly free. This
prices the mass-dust vector in CPU - never a monetary fee, so the feeless
model is preserved: a state send whose destination account is not yet opened
creates new permanent ledger footprint, so it is required to carry more work
than a send to an already-existing account.

Legitimate first-contact onboarding pays the higher cost once per real new
account (rare, acceptable), while an attacker fanning dust out to fabricated
destinations pays it on every block; dodging it by pre-opening the
destinations costs an open + receive per destination, which is the
self-limiting cost the throttle imposes.

block_adds_new_account() detects the state-creating send (destination account
absent from the ledger). evaluate_storage_weighted_work() computes the
base requirement, scales it by the multiplier when the weight applies (floored
at 1.0 so it can only ever raise the bar), and reports whether the block's
work satisfies it. This is an advisory policy calculator: it does not change
consensus work validation, which would require network-wide activation.

- nano/secure/storage_weighted_work.{hpp,cpp}: detection + policy calculator
- nano/node/json_handler: "work_storage_weight" RPC (hash, multiplier)
- nano/core_test/storage_weighted_work.cpp: new-account weighting, existing-
  account exemption, and the multiplier floor

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dhyabi2

nano/core_test/CMakeLists.txt

@@ -72,6 +72,7 @@ add_executable(
   rep_weight_store.cpp
   scheduler_buckets.cpp
   state_commitment.cpp
+  storage_weighted_work.cpp
   stats.cpp
   signal_manager.cpp
   socket.cpp

nano/core_test/storage_weighted_work.cpp

@@ -0,0 +1,88 @@
+#include <nano/lib/blockbuilders.hpp>
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/lib/work.hpp>
+#include <nano/secure/common.hpp>
+#include <nano/secure/ledger.hpp>
+#include <nano/secure/ledger_set_any.hpp>
+#include <nano/secure/storage_weighted_work.hpp>
+#include <nano/test_common/ledger_context.hpp>
+
+#include <gtest/gtest.h>
+
+#include <limits>
+
+namespace
+{
+std::shared_ptr<nano::block> send_to (nano::account const & destination)
+{
+	nano::block_builder builder;
+	nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
+	return builder.state ()
+	.account (nano::dev::genesis_key.pub)
+	.previous (nano::dev::genesis->hash ())
+	.representative (nano::dev::genesis_key.pub)
+	.balance (nano::dev::constants.genesis_amount - 1)
+	.link (destination)
+	.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
+	.work (*pool.generate (nano::dev::genesis->hash ()))
+	.build ();
+}
+}
+
+// A send to a not-yet-opened account is storage-weighted: its required work is the base
+// requirement scaled by the multiplier, and at multiplier 1 it collapses to the base.
+TEST (storage_weighted_work, new_account_is_weighted)
+{
+	auto ctx = nano::test::ledger_empty ();
+	auto & ledger = ctx.ledger ();
+	nano::keypair fresh;
+	auto block = send_to (fresh.pub);
+	auto transaction = ledger.tx_begin_read ();
+
+	ASSERT_TRUE (nano::block_adds_new_account (ledger, transaction, *block));
+
+	uint64_t const base = ledger.work.threshold_base (block->work_version ());
+	auto weighted = nano::evaluate_storage_weighted_work (ledger, transaction, *block, 8.0);
+	ASSERT_TRUE (weighted.creates_new_account);
+	ASSERT_EQ (base, weighted.base_threshold);
+	ASSERT_EQ (nano::difficulty::from_multiplier (8.0, base), weighted.required_threshold);
+	ASSERT_GT (weighted.required_threshold, weighted.base_threshold);
+
+	// Multiplier 1 must not raise the requirement, and the block's own work satisfies it.
+	auto unweighted = nano::evaluate_storage_weighted_work (ledger, transaction, *block, 1.0);
+	ASSERT_EQ (base, unweighted.required_threshold);
+	ASSERT_TRUE (unweighted.satisfies);
+}
+
+// A send to an already-opened account carries no storage weight, whatever the multiplier.
+TEST (storage_weighted_work, existing_account_not_weighted)
+{
+	auto ctx = nano::test::ledger_empty ();
+	auto & ledger = ctx.ledger ();
+	// Genesis account already exists in the ledger.
+	auto block = send_to (nano::dev::genesis_key.pub);
+	auto transaction = ledger.tx_begin_read ();
+
+	ASSERT_FALSE (nano::block_adds_new_account (ledger, transaction, *block));
+
+	auto weighted = nano::evaluate_storage_weighted_work (ledger, transaction, *block, 8.0);
+	ASSERT_FALSE (weighted.creates_new_account);
+	ASSERT_EQ (weighted.base_threshold, weighted.required_threshold);
+	ASSERT_DOUBLE_EQ (1.0, weighted.weight_multiplier);
+	ASSERT_TRUE (weighted.satisfies);
+}
+
+// A multiplier below 1 can never lower the base requirement.
+TEST (storage_weighted_work, multiplier_floor)
+{
+	auto ctx = nano::test::ledger_empty ();
+	auto & ledger = ctx.ledger ();
+	nano::keypair fresh;
+	auto block = send_to (fresh.pub);
+	auto transaction = ledger.tx_begin_read ();
+
+	auto result = nano::evaluate_storage_weighted_work (ledger, transaction, *block, 0.25);
+	ASSERT_EQ (result.base_threshold, result.required_threshold);
+	ASSERT_DOUBLE_EQ (1.0, result.weight_multiplier);
+}

nano/node/json_handler.cpp

@@ -36,6 +36,7 @@
 #include <nano/secure/ledger_set_any.hpp>
 #include <nano/secure/ledger_set_cemented.hpp>
 #include <nano/secure/state_commitment.hpp>
+#include <nano/secure/storage_weighted_work.hpp>
 #include <nano/secure/transaction.hpp>
 #include <nano/store/ledger/account.hpp>
 #include <nano/store/ledger/block.hpp>
@@ -52,6 +53,7 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cmath>
 #include <vector>
 
 namespace
@@ -1810,6 +1812,53 @@ void nano::json_handler::state_pending_sweep ()
 	}));
 }
 
+void nano::json_handler::work_storage_weight ()
+{
+	// Advisory (Block 5): evaluate a block against the storage-weighted PoW requirement.
+	// A state send to a not-yet-opened account must carry `multiplier`x the base work.
+	auto hash (hash_impl ());
+	double multiplier = 8.0; // default: state-creating sends must work 8x harder
+	auto multiplier_text (request.get_optional<std::string> ("multiplier"));
+	if (!ec && multiplier_text.has_value ())
+	{
+		try
+		{
+			multiplier = std::stod (multiplier_text.value ());
+		}
+		catch (...)
+		{
+			ec = nano::error_rpc::bad_multiplier_format;
+		}
+		if (!ec && (multiplier < 1.0 || !std::isfinite (multiplier)))
+		{
+			ec = nano::error_rpc::bad_multiplier_format;
+		}
+	}
+	if (ec)
+	{
+		response_errors ();
+		return;
+	}
+	node.workers.post (create_worker_task ([hash, multiplier] (std::shared_ptr<nano::json_handler> const & rpc_l) {
+		auto transaction (rpc_l->node.ledger.tx_begin_read ());
+		auto block (rpc_l->node.ledger.any.block_get (transaction, hash));
+		if (block == nullptr)
+		{
+			rpc_l->ec = nano::error_blocks::not_found;
+			rpc_l->response_errors ();
+			return;
+		}
+		auto result (nano::evaluate_storage_weighted_work (rpc_l->node.ledger, transaction, *block, multiplier));
+		rpc_l->response_l.put ("creates_new_account", result.creates_new_account ? "true" : "false");
+		rpc_l->response_l.put ("weight_multiplier", nano::to_string (result.weight_multiplier));
+		rpc_l->response_l.put ("base_threshold", nano::to_string_hex (result.base_threshold));
+		rpc_l->response_l.put ("required_threshold", nano::to_string_hex (result.required_threshold));
+		rpc_l->response_l.put ("achieved_difficulty", nano::to_string_hex (result.achieved_difficulty));
+		rpc_l->response_l.put ("satisfies", result.satisfies ? "true" : "false");
+		rpc_l->response_errors ();
+	}));
+}
+
 void nano::json_handler::block_create ()
 {
 	std::string type (request.get<std::string> ("type"));
@@ -5818,6 +5867,7 @@ ipc_json_handler_no_arg_func_map create_ipc_json_handler_no_arg_func_map ()
 	no_arg_funcs.emplace ("state_checkpoint", &nano::json_handler::state_checkpoint);
 	no_arg_funcs.emplace ("state_retention_plan", &nano::json_handler::state_retention_plan);
 	no_arg_funcs.emplace ("state_pending_sweep", &nano::json_handler::state_pending_sweep);
+	no_arg_funcs.emplace ("work_storage_weight", &nano::json_handler::work_storage_weight);
 	no_arg_funcs.emplace ("block_create", &nano::json_handler::block_create);
 	no_arg_funcs.emplace ("block_hash", &nano::json_handler::block_hash);
 	no_arg_funcs.emplace ("bootstrap", &nano::json_handler::bootstrap);

nano/node/json_handler.hpp

@@ -65,6 +65,7 @@ class json_handler : public std::enable_shared_from_this<nano::json_handler>
 	void state_checkpoint ();
 	void state_retention_plan ();
 	void state_pending_sweep ();
+	void work_storage_weight ();
 	void block_create ();
 	void block_hash ();
 	void bootstrap ();

nano/secure/CMakeLists.txt

@@ -42,6 +42,8 @@ add_library(
   rep_weights.cpp
   state_commitment.hpp
   state_commitment.cpp
+  storage_weighted_work.hpp
+  storage_weighted_work.cpp
   transaction.hpp
   voting_policy.hpp
   voting_policy.cpp)

nano/secure/storage_weighted_work.cpp

@@ -0,0 +1,47 @@
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/constants.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/secure/ledger.hpp>
+#include <nano/secure/ledger_set_any.hpp>
+#include <nano/secure/storage_weighted_work.hpp>
+#include <nano/secure/transaction.hpp>
+
+#include <algorithm>
+
+bool nano::block_adds_new_account (nano::ledger const & ledger, nano::secure::transaction const & transaction, nano::block const & block)
+{
+	if (!block.is_send ())
+	{
+		return false;
+	}
+	// A state send carries the destination in its link; a legacy send in destination().
+	nano::account destination = block.link_field ().has_value () ? block.link_field ().value ().as_account () : block.destination ();
+	// New footprint iff the destination account is not yet opened in the ledger. A dust
+	// send to a never-opened account satisfies this on every block (the account never
+	// opens), so each such send pays the elevated cost.
+	return !ledger.any.account_exists (transaction, destination);
+}
+
+nano::storage_weighted_work_result nano::evaluate_storage_weighted_work (nano::ledger const & ledger, nano::secure::transaction const & transaction, nano::block const & block, double new_account_multiplier)
+{
+	nano::storage_weighted_work_result result;
+	// Never below 1.0: the storage weight only ever raises the requirement.
+	double const multiplier = std::max (1.0, new_account_multiplier);
+
+	result.base_threshold = ledger.work.threshold_base (block.work_version ());
+	result.achieved_difficulty = ledger.work.difficulty (block);
+	result.creates_new_account = nano::block_adds_new_account (ledger, transaction, block);
+
+	if (result.creates_new_account)
+	{
+		result.weight_multiplier = multiplier;
+		result.required_threshold = nano::difficulty::from_multiplier (multiplier, result.base_threshold);
+	}
+	else
+	{
+		result.weight_multiplier = 1.0;
+		result.required_threshold = result.base_threshold;
+	}
+	result.satisfies = result.achieved_difficulty >= result.required_threshold;
+	return result;
+}

nano/secure/storage_weighted_work.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <nano/lib/numbers.hpp>
+
+#include <cstdint>
+
+namespace nano
+{
+class block;
+class ledger;
+namespace secure
+{
+	class transaction;
+}
+
+/*
+ * Block 5 of the ledger-bloat mitigation work: the storage-weighted proof-of-work
+ * throttle. Proof-of-work today is a one-time issuance cost uncorrelated with the
+ * PERMANENT storage a block imposes, so minting dust is nearly free. This prices the
+ * mass-dust vector in CPU (never a monetary fee, so the feeless model is preserved):
+ * a state send whose destination account is not yet opened creates new permanent
+ * ledger footprint (a fresh account / receivable that may never be received), so it is
+ * required to carry more work than a send to an already-existing account.
+ *
+ * Legitimate first-contact onboarding pays the higher cost once per real new account -
+ * rare and acceptable - while an attacker fanning dust out to fabricated destinations
+ * pays it on every block. An attacker can dodge by pre-opening the destinations they
+ * control, but that itself costs an open + receive per destination, which is the
+ * self-limiting cost the throttle is meant to impose.
+ *
+ * This is an ADVISORY policy calculator: it computes the storage-weighted requirement
+ * and whether a block meets it. It does not change consensus work validation, which
+ * would require network-wide activation.
+ */
+
+// True if the block adds a brand-new account to permanent state: a send whose
+// destination account is not yet opened in the ledger.
+bool block_adds_new_account (nano::ledger const &, nano::secure::transaction const &, nano::block const &);
+
+struct storage_weighted_work_result final
+{
+	bool creates_new_account{ false }; // whether the storage weight applies
+	double weight_multiplier{ 1.0 }; // multiplier applied to the base requirement
+	uint64_t base_threshold{ 0 }; // normal work requirement for this block
+	uint64_t required_threshold{ 0 }; // storage-weighted requirement (>= base_threshold)
+	uint64_t achieved_difficulty{ 0 }; // difficulty of the block's current work
+	bool satisfies{ false }; // achieved_difficulty >= required_threshold
+};
+
+// Evaluate a block against the storage-weighted requirement. `new_account_multiplier`
+// (>= 1.0) is how much harder a state-creating send must work. Advisory / measurement.
+nano::storage_weighted_work_result evaluate_storage_weighted_work (nano::ledger const &, nano::secure::transaction const &, nano::block const &, double new_account_multiplier);
+}