Continue funding for ReactiveDOT & related developments

1d 14hrs ago

Confirming

Content

AI Summary

Building upon #812, #948, #1334, and #1477, this proposal requests funding for the continuation of ReactiveDOT, along with its related projects: DOTConsole and DOTConnect.

Project goals

ReactiveDOT is a library designed to:

Simplify development: Provide a set of intuitive front-end functions and utilities to facilitate Substrate chain interactions, making development accessible for developers of all skill levels.
Enhance developer experience: Reduce boilerplate code and complexity involved in integrating DApps with Substrate chains, allowing developers to focus on building robust applications.
Promote adoption: Lower the entry barrier for developers through improved tooling and familiar patterns, encouraging the adoption of Polkadot.

Previously completed goals

Ink! contract support

As of now, ReactiveDOT provides what is arguably the best-in-class front-end API for smart contracts in any ecosystem.

Announcement: https://x.com/TienNguyenK/status/1930861744391623006
Pull request: https://github.com/tien/reactive-dot/pull/632
Documentation: https://reactivedot.dev/react/guides/smart-contract

Incremental loading

Improves perceived latency for large multi-queries by enabling partial results to stream in incrementally.

Pull request: https://github.com/tien/reactive-dot/pull/727
Documentation: https://reactivedot.dev/react/guides/incremental-loading

≥ 90% test coverage

Maintained high test coverage across the codebase.

Coverage: https://app.codecov.io/gh/tien/reactive-dot

Miscellaneous contributions

Beyond my own projects, I contribute to various efforts in the Polkadot ecosystem whenever possible. You can see my recent activity here:
https://github.com/tien?tab=overview

In-progress

Query composition

Most of the current research has focused on enabling stable cached Promises within render logic to leverage native React 19 support for use.

The goal is to allow developers to compose logic on top of these cached Promises.

Research findings so far:

Creating stable Promises outside the React render cycle is too memory-expensive, as a new cache entry is required for every permutation of hook arguments.
Creating stable cache entries within the render cycle is potentially feasible, but very complex. The cache must remain stable across multiple suspense cycles while also being weakly held (not strongly referenced), allowing it to be garbage collected.

Further research will be conducted to determine whether this direction remains viable or if a different approach should be pursued.

Planned works

Solidity-based contract support

In anticipation of the upcoming Polkadot Hub launch with PalletRevive, similar support for Ink! contracts will be extended to Solidity contracts that expose ABIs. The goal is to maintain a unified developer experience and API regardless of contract implementation.

Granular cache manipulation

As usage around smart contract grows, many interactions will become pull-based (as opposed to reactive storage push-based). As such, manual cache control becomes essential.

Proposed API:

const loader = useQueryLoader();

// Eagerly load queries into cache
loader.loadQuery((query) => query.runtimeApi(/* ... */));

// Refresh active queries
loader.refresh((query) => query.runtimeApi(/* ... */));

/**
 * Mark queries as invalid:
 * - New data will be fetched on the next render
 * - If there's no active query, the cache will be removed
 */
loader.invalidate((query) => query.runtimeApi(/* ... */));

Additional filtering-based lookup will also be supported:

const queryLoader = useQueryLoader();

// Invalidate all queries, akin to a garbage collection cycle
loader.invalidate.all();

// Invalidate all balance-related caches
loader.refresh.all((entry) => entry.pallet === "Balances");

// Especially useful for smart contracts
loader.refresh.all(
  (entry) =>
    entry.instruction === "contract-read" &&
    entry.address === SOME_CONTRACT_ADDRESS,
);

Auto-refresh/refetch for contract queries

Since all interactions are cached and serialized, ReactiveDOT can track all contract reads and provide configurable auto-refresh behavior:

import { contracts } from "@polkadot-api/descriptors";

const psp22 = defineContract({
  descriptor: contracts.psp22,
  // Refresh strategy can be:
  autoRefresh: {
    // After each mutation
    postMutation: true,
    // After every `x` blocks
    everyBlockCount: 5,
    // Potentially more advance strategies
    inResponseToEvent: (event) => {
      /* TBD */
    },
  },
});

Incremental loading for single query

Much like incremental loading for multi-queries, an escape hatch could be provided for single-query scenarios. While ReactiveDOT remains committed to a suspense-first design, careful consideration will be given as to whether and how this feature should be implemented.

Continued improvements to DOTConnect & DOTConsole

Further enhancements will be guided by community feedback or requirements identified to support the ongoing testing and development of ReactiveDOT.

Funding request

Period: July 2025 – October 2025
Duration: 4 months (89 workdays / 712 hours)
Hourly rate: 125 USDC
Total requested: 89,000 USDC

Edited

Request

89,000USDC

Status

Decision28d

Confirmation

Attempts

Tally

64.2%Aye

35.8%Nay

Aye

≈32.8MDOT

Nay

≈18.27MDOT

0.0%
0.0%
Threshold
0.0%

Support

0.46%

≈7.33MDOT

Issuance

≈1.58BDOT

Votes

Nested

Flattened

Actions

Or do delegation here, check wiki.

Call

Metadata

Timeline4

Votes Bubble

Statistics

Comments

15wb...zWSp

Progress seems solid. Could you please mention some of the challenges you may have encountered during implementation and how you were able to resolve them?

12mP...Eyoh

PolkaWorld votes NAY

Until a clear compensation framework is established for the Treasury, PolkaWorld will reject any proposal with an hourly rate exceeding $100.

Additionally, this proposal lacks budget transparency and provides insufficient information about the team behind it.

Read all feedback here.

1y2q...bmxR

✅ Why Vote YES
• High Developer Impact: ReactiveDOT simplifies dApp development on Substrate chains using modern React APIs. Ink! smart contract support is already live; Solidity support is coming.
• Modern Frontend Design: Features include incremental loading, cache-aware queries, suspense-first architecture, and auto-refreshable contract reads.
• Trusted Contributor: Tien is an established builder with deep contributions to the Polkadot ecosystem and >90% test coverage across the codebase.
• Low Overhead: Solo developer requesting 125 USDC/hour for full-time work over 4 months (712 hours total). Efficient, clear scope.
• Supports Upcoming Polkadot Hub: New Solidity compatibility (via PalletRevive) is being integrated—ensuring unified UX for both Ink! and Solidity contracts.

⸻

❌ Why Vote NO
• Solo Development Risk: Project continuity, responsiveness, and scalability may be at risk due to single-developer dependence.
• Limited User Adoption Metrics: While technically impressive, there is little data shared on actual dApp adoption or user metrics.
• PolkadotJS/SDK Already Exists: Some may argue ReactiveDOT overlaps with existing dev tooling like polkadot.js or useInk, raising questions of differentiation.
• Highly Technical Scope: Features like granular cache invalidation or React Suspense hooks may benefit advanced devs more than casual builders.

⸻

📌 Conclusion
ReactiveDOT aims to make Polkadot dApp development easier, faster, and more scalable—especially ahead of the Polkadot Hub era. If adopted, this funding will maintain momentum on one of the most advanced frontend SDKs in the ecosystem.

13zn...P5ju

Dear Proposer,

Thank you for your proposal. Our first vote on this proposal is AYE.

The Medium Spender track requires 50% quorum (at least 5 aye votes) and simple majority of non-abstain votes according to our voting policy v0.2, and any referendum in which the majority of members vote abstain receives an abstain vote. This proposal has received six aye and two nay votes from ten available members. Below is a summary of our members' comments:

In the referendum, a majority expressed support for the initiative, highlighting its potential to advance developer resources and improve experiences in building decentralized applications. Some voters acknowledged the project's merits but raised concerns about its cost, questioning the justification for the significant funding request. While there was enthusiasm for the initiative's progress and the emergence of alternative solutions, a few voters remained skeptical about the clarity of its benefits and the necessity of the proposed budget, suggesting a need for further review.

The full discussion can be found in our internal voting.

Please feel free to contact us through the links below for further discussion.

Kind regards,
Permanence DAO
Decentralized Voices Cohort IV Delegate

📅 Book Office Hours
💬 Public Telegram
🌐️ Web
🐦 Twitter
🗳️ Delegate

15ro...ZjMK

This proposal deserves unequivocal support.

@tien has consistently delivered high-quality tools that are both practical and increasingly more appreciated across the ecosystem. Beyond the technical contributions, Tien actively engages with the community and provides insightful feedback upstream: improving not just their own work, but the broader developer experience as well.

Having such a talented builder in the Polkadot ecosystem is a huge asset. Supporting this proposal is a clear win for everyone involved.

14Pi...VXZa

OG Tracker Rating 2/3

Clear display of deliverables✅

Solidity-based contract support
Granular cache manipulation
Auto-refresh/refetch for contract queries
Incremental loading for single query
Continued improvements to DOTConnect & DOTConsole

Clear display of a valid direct point of contact ❌

Not provided.
@tien Could you share a valid point of contact in case someone needs to reach out?

Clear display of proposal’s duration✅

The duration of this proposal is 4 months.

OGT Rating aims to help voters make better informed decisions and direct proposers towards certain common-good practices. We are providing feedback based on 3 simple yet crucial criteria which we believe should be included in every OpenGov referenda.

13dV...6afh

TruthDAO votes NAY.

In accordance with the TruthDAO Manifesto, we reject any proposal requesting over $100 without a detailed budget breakdown.

You can view our full feedback here.

📖Truth DAO Governance Statement

💭 Contact: Email, Telegram

🗳️ Delegate

1Thi...vvjg

This proposal is a clear AYE for me. Tien is an asset to the Polkadot eco at many levels. I've been a user of the dot-connect library for years now, it's unmatched, it's always kept up to date and enhanced, and if you ever have a question or an issue, you get an answer in no time. Similarly, the reactive-do project and dot-console interface has been pushing boundaries and proven very useful.