Pause treasury spending in Polkadot and Kusama to reassess strategy and ultimately determine better ways to assess and shape ROI to token holders

Link to largest treasury spending beneficiaries here.


DotSama does not have an off-chain awareness problem, it has an on-chain impact problem.

Network treasuries by definition are a common good resource to drive on-chain impact.

Millions have been spent with no on-chain impact (KSM / DOT).

Additionally the majority of spend creates selling pressure from teams needing working capital to deliver.

Spending should be focused on shifting the metrics that matter (what these are is a side question, how they are defined another)

AI is here to eat your (offchain) lunch

AI tools and services will make redundant a large amount of work done by the current work-force within undifferentiated domains or activities - most obviously.

  • Moderation
  • Documentation
  • Proposal reviews, summaries and responses
  • Content creation, curation, publishing and educational materials as well as translations.

The above constitutes millions of $$$ of spending to date in Kusama and Polkadot.

Currently those receiving large amounts of funding have not assessed or reported the ROI to date.

Questions about impact or effectiveness invariably lead to name calling, diversionary tactics and bullying since current governance is not much more than a popularity contest.

When it comes to media spending, the effort to date has cost over $1.5m and the results of that work are focused on off-chain metrics - little time has been dedicated to shifting on-chain metrics.

Worse, media spending to date has been scattergun - literally firing out information into the black hole of the internet, with vanishingly little thought for how to create genuinely differentiated media destinations.

This is just the tip of the iceberg for the kind of work networks currently fund.

Below is the summary a 45 minute discussion I had with ChatGPT regarding on-chain impact, reputation, ROI and pallet design.

Before anyone starts picking holes in the code, I am not a dev and so cannot review, correct or iterate the code, but this is not difficult to address with a small collective of experienced contributors who offer a breadth of experience.

What is important is posing questions that cut to the real meat of the problems, rather than blindly pushing forwards on foundations of sand.

Note all of the below is ChatGPT, I have reformatted to make it easier, my input is in quotes.

The conversation

Question 1:
What are some human-centric metrics that might relate to positive contribution to the network that are not explicitly financial in nature?

Attendance at community events
Participation in hackathons and other network-related activities
Volunteer work and contributions to open-source projects
Artistic contributions to the network, such as visual or musical creations

Question 2:
How would you verify the number of community events organized or participated in from an on-chain metrics perspective?

Create a system where event organizers can register events on the network
Attendees can then register their attendance on the network as well
These registrations can be stored in the on-chain database and used as metrics for performance-based rewards

Question 3:
How would you link more artistic contributions to the network to on-chain impact and an emergent on-chain identity?

Create a system for users to register their artistic contributions on the network, including a description of the work and the role it plays in the network
Develop a sharded on-chain identity that allows users to present different versions of themselves in different contexts

Question 4:
How can treasury spending be linked to on-chain metrics and performance-related pay?

Design pallets that track specific on-chain metrics, such as attendance at events or participation in artistic contributions
Use trustless oracles to track and verify off-chain metrics, such as social media followers, and link them to on-chain performance-related spending
Ensure that performance-related spending is automated and executed only when specific on-chain metrics have been met

Please design the code for a substrate pallet that links treasury spending with on-chain impact such as the creation of new network identities and addresses that ensures payout is only based on continued activity by the new identities*

Designing a Substrate pallet that links treasury spending with on-chain impact and encourages continued activity by new identities could involve the following steps:

Define the data structure: Create a data structure that defines the new network identities and their associated addresses.
struct NetworkIdentity {
  id: u64,
  address: T::AccountId,
  active: bool,
Implement a function to create new identities: Create a function that allows the creation of new network identities.
fn create_identity(origin) -> dispatch::DispatchResult {
  let sender = ensure_signed(origin)?;
  // Generate a new identity ID
  let identity_id = Self::identity_count();
  // Create a new NetworkIdentity struct
  let identity = NetworkIdentity {
    id: identity_id,
    address: sender,
    active: true,
  // Store the new identity
  Identities::<T>::insert(identity_id, &identity);
  // Update identity count
  IdentityCount::<T>::put(identity_id + 1);
Implement a function to link treasury spending to on-chain impact: Create a function that allows treasury spending to be linked to on-chain impact by requiring the creation of new network identities in order to receive funding.
fn fund_new_identity(origin, amount: BalanceOf<T>) -> dispatch::DispatchResult {
  let sender = ensure_signed(origin)?;
  // Create a new identity for the sender
  // Record the funding amount for the new identity
  Funding::<T>::insert(sender, amount);
  // Transfer the funds to the network treasury
  T::Currency::transfer(&sender, &Self::treasury_account_id(), amount, ExistenceRequirement::AllowDeath)?;
  // Emit a fund event
  Self::deposit_event(Event::FundedNewIdentity(sender, amount));
Implement a function to reward continued activity: Create a function that rewards continued activity by new network identities by disbursing funds from the treasury based on on-chain activity metrics.
fn reward_activity(origin, identity_id: u64, amount: BalanceOf<T>) -> dispatch::DispatchResult {
  let sender = ensure_signed(origin)?;
  let identity = Identities::<T>::get(identity_id).ok_or(Error::<T>::InvalidIdentity)?;
  // Verify that the identity is active
  ensure!(, Error::<T>::InactiveIdentity);
  // Verify that the sender is the identity owner
  ensure!(sender == identity.address, Error::<T>::Unauthorized);
  // Verify that the identity has met the on-chain activity threshold
  ensure!(Self::has_met_activity_threshold(identity_id), Error::<T>::ActivityThresholdNotMet);
  // Disburse funds to the identity
  T::Currency::transfer(&Self::treasury_account_id(), &identity.address, amount, ExistenceRequirement::AllowDeath)?;
  // Emit a reward event
  Self::deposit_event(Event::RewardedActivity(identity.address, amount));
Implement a function to check on-chain activity metrics: Create a function that checks the on-chain activity metrics required for disbursing funds based on continued activity by new identities.
fn has_met_activity_threshold(identity_id: u64) -> bool {
  // Implement activity metrics checks here
Implement the storage items: Implement the necessary storage items for the pallet.
type BalanceOf<T> = <<T as Trait>::Currency as Currency<<T as system::Trait>::AccountId>>::Balance;

// Storage items
pub IdentityCount get(identity_count): u64;
pub Identities get(fn identity): map hasher(blake2_128_concat) u

Here is the code for a Substrate pallet that links treasury spending with on-chain impact, including a mechanism to ensure payout is only based on continued activity by new identities:

use frame_support::{decl_module, decl_storage, decl_event, dispatch::DispatchResult, ensure};
use frame_system::{self as system, ensure_signed};
use sp_runtime::traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedSub, Zero};

mod mock;

mod tests;

pub trait Trait: system::Trait {
    type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event>;
    type Currency: AtLeast32BitUnsigned + Default + Copy + CheckedAdd + CheckedSub;

decl_storage! {
    trait Store for Module<T: Trait> as PalletTemplate {
        NewIdentityCounts get(fn new_identity_counts): map hasher(blake2_128_concat) T::AccountId => T::Currency;

    pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {
        NewIdentityAdded(AccountId, u64),
        IdentityActivityIncreased(AccountId, u64),

decl_module! {
    pub struct Module<T: Trait> for enum Call where origin: T::Origin {
        #[weight = 0]
        fn add_new_identity(origin) -> DispatchResult {
            let sender = ensure_signed(origin)?;
            let identity_count = Self::new_identity_counts(&sender);

            ensure!(identity_count == T::Currency::zero(), "Identity already exists");

            NewIdentityCounts::<T>::insert(&sender, T::Currency::one());
            Self::deposit_event(RawEvent::NewIdentityAdded(sender, 1));

        #[weight = 0]
        fn increase_identity_activity(origin) -> DispatchResult {
            let sender = ensure_signed(origin)?;
            let identity_count = Self::new_identity_counts(&sender);

            ensure!(identity_count > T::Currency::zero(), "Identity does not exist");

            let updated_count = identity_count.checked_add(&T::Currency::one()).ok_or("Overflow adding identity count")?;

Thank you for drawing attention to this issue @rich. The state of the Kusama treasury is showing us that we have to rethink and do so fast.

I share your opinion on needing to tie ROI to spends asap and this is a great place to discuss solutions.