Spark Program | CKAutomata: Protocol Hardening, User Onboarding and Testnet Beta

Spark Program | CKAutomata: Protocol Hardening, User Onboarding and Testnet Beta

1. Project Overview

Project name: CKAutomata

One-line summary: An eight-week improvement and beta program for CKAutomata covering protocol hardening, simpler user onboarding, and structured user testing for CKB payment automation.

Positioning: CKAutomata is an open-source, non-custodial payment-automation application built for the CKB Cell Model.

Funding requested: USD 2,000 equivalent in CKB.

Duration: Eight weeks, starting after approval.

CKAutomata supports three payment-automation services:

  1. DAO Harvest: Collect earned Nervos DAO compensation and place the user’s exact original amount into a new DAO deposit.
  2. Scheduled payments: Send a fixed amount of CKB to a chosen recipient at a future date and time.
  3. Recurring distributions: Send a fixed amount repeatedly according to an approved interval and run limit.

DAO Harvest is the main feature because it addresses a CKB-specific problem involving Nervos DAO withdrawal timing, compensation collection and re-deposit. Scheduled and recurring payments extend the same constrained-execution model to common payment use cases.

The initial contracts, services and testnet application were completed before this application. This grant does not fund that earlier work. It funds a focused next stage with three outcomes: a documented protocol-hardening pass, a clearer onboarding experience and a measured testnet beta with external users.

2. Team Profile

Applicant and developer: Hallab

I designed and built the CKAutomata contracts, transaction builders, API, indexer, executor services, external-operator tooling, wallet review flow, frontend and owner-recovery tooling. The project has received detailed public technical feedback through CKBuilders. The resulting work includes improved transaction validation, owner recovery, operator selection, external execution, real Nervos DAO script testing and versioned testnet deployments.

Project background:

3. Project Background

CKB users may need to make a payment at a future time, repeat a distribution or complete a multi-stage Nervos DAO process. Without automation, the user must remember each event, reconnect a wallet and manually submit every transaction.

A normal hosted scheduler could solve the timing problem by holding a private key, but that introduces custody and gives the service more authority than it needs. CKAutomata instead places the approved terms in CKB cells and scripts. An executor may submit an eligible transaction, but the scripts restrict the recipient, amount, timing, service payment and state transition.

DAO Harvest demonstrates the most important use case. A Nervos DAO withdrawal requires preparation followed by a later claim. A user collecting compensation and continuing with the original amount must also create another DAO deposit. CKAutomata coordinates those stages while keeping the protected original amount bound to the approved rules.

The current challenge is no longer the initial implementation. Before broader development, CKAutomata needs:

  • a focused hardening pass across the contract, transaction, wallet and executor boundaries;
  • onboarding that non-technical users can understand without reading protocol documentation; and
  • structured evidence showing whether users can complete the workflows and find them useful.

4. Solution

The funded work will improve one consistent user journey across all three services:

  1. Connect a supported CKB testnet wallet.
  2. Choose DAO Harvest, a scheduled payment or a recurring distribution.
  3. Enter the amount, recipient, timing and service-specific terms.
  4. Review the payment destination, charges, executor rules and owner recovery in plain language.
  5. Approve the setup transaction in the wallet.
  6. Follow the automation through waiting, processing and completion.
  7. Use the available cancellation, exit or recovery action when necessary.

The grant is divided into three workstreams.

A. Protocol Hardening

The hardening work will cover the deployed testnet protocol and its transaction-building boundary:

  • review the threat model for scheduled, recurring and DAO Harvest jobs;
  • test recipient, amount, timing, fee, reward, successor and owner-refund invariants;
  • extend malformed-witness, arithmetic-boundary and transaction-layout tests;
  • test wallet-added funding inputs, change, dependencies and fee limits;
  • test preferred-operator, fallback and competing-executor behavior;
  • test API, indexer and executor interruption without granting additional authority;
  • repeat owner cancellation, exit and recovery drills using public CKB data; and
  • add every reproduced defect to the automated regression suite and CI gate.

DAO Harvest will receive the deepest review because it includes Nervos DAO preparation, maturity, compensation accounting, re-deposit and owner recovery. The hardening report will clearly distinguish internal review from an independent professional security audit.

B. User Onboarding

The onboarding work will make the existing application easier to understand and operate:

  • create a short first-use path for choosing the correct automation type;
  • simplify terms used for amounts, dates, charges, executors and recovery;
  • show the complete amount the wallet will pay before approval;
  • explain each status and the next expected action in plain language;
  • improve wallet rejection, wrong-network, stale-review and service-unavailable messages;
  • improve mobile and desktop setup, review and automation-detail screens;
  • provide service-specific examples without presenting demo data as live evidence; and
  • publish a concise user guide for all three services.

C. Structured User Testing

The beta will recruit 8-12 external participants who can use a CKB testnet wallet. At least 8 completed sessions are required for the final dataset.

Each participant will:

  1. connect, disconnect and reconnect a wallet;
  2. create and track a scheduled payment;
  3. configure a recurring distribution with the correct amount, interval and run limit;
  4. review a DAO Harvest setup and explain its purpose, charges and original-amount protection;
  5. find transaction evidence and the current automation status; and
  6. locate the available owner cancellation, exit or recovery action for a selected job.

The beta uses valueless testnet CKB. No cash or token incentive is included in this grant.

Beta Targets

Metric Target
Recruited participants 8-12
Completed test sessions At least 8
Scheduled-payment task completed without direct intervention At least 80%
Recurring-payment terms configured correctly At least 80%
DAO Harvest purpose and original-amount behavior understood At least 80%
Charges and owner recovery correctly understood At least 80%
Successful transactions, excluding deliberate rejection tests At least 90%
Critical value-loss or unauthorized-recipient failures 0
Critical and high-severity beta findings Fixed and retested, or explicitly unresolved with reproduction steps

These targets are acceptance measurements, not guaranteed results. Any shortfall will be reported rather than hidden or reclassified.

Percentage targets will be calculated from completed sessions and rounded up to the next whole participant.

5. Technical Approach

CKAutomata uses CKB-native components rather than an off-chain payment ledger:

  • Contracts: Rust scripts compiled for CKB-VM validate job locks, policy rules, recipients, timing, value conservation, rewards and owner actions.
  • Schemas and builders: Molecule schemas and TypeScript builders create and inspect scheduled, recurring and DAO Harvest transactions.
  • Wallet boundary: CCC-compatible wallets approve and sign transactions; CKAutomata never receives a private key.
  • API and indexer: A Node.js API constructs unsigned transactions, while PostgreSQL and the CKB indexer provide readable automation state.
  • Executors: Hosted watchers discover eligible jobs and submit only transactions accepted by the scripts. External-operator tooling supports additional execution paths.
  • Frontend: A Next.js application provides setup, review, automation lists, details, activity and owner actions.
  • Recovery: Published manifests and recovery tooling allow owner transactions to be prepared from public CKB data without the hosted API, database, Redis or CKAutomata executors.

The application remains testnet-only during this grant. The work will not be described as a formal audit or as evidence of mainnet readiness.

6. Execution Plan

Week 1 — Baseline and Threat Review

  • Freeze the beta scope and source revision.
  • Publish the test plan, threat-model update and current known limitations.
  • Record baseline transaction, API, indexer and executor behavior.
  • Start dedicated scheduled, recurring and DAO Harvest testnet jobs.

Milestone: Published baseline report, risk register and beta task script.

Week 2 — Contract and Transaction Hardening

  • Run adversarial contract and transaction-boundary tests.
  • Test recipient, amount, timing, successor, fee, reward and refund invariants.
  • Test malformed witnesses, arithmetic boundaries and invalid transaction layouts.
  • Fix findings and add regression coverage.

Milestone: Contract and builder findings are fixed or documented with regression coverage.

Week 3 — Runtime and Recovery Hardening

  • Exercise preferred-operator, fallback and competing-executor behavior.
  • Test delayed indexing, changed wallet transactions and fee boundaries.
  • Test API, indexer and executor interruption.
  • Repeat cancellation, exit and recovery construction without hosted services.

Milestone: Hardening report with findings, fixes, residual risks and a green expanded test gate.

Week 4 — Onboarding Release

  • Improve first-use selection, setup terms, review totals, status explanations and owner-action guidance.
  • Improve wallet, network, stale-review and service-error states.
  • Test responsive desktop and mobile layouts.
  • Publish the user guide and beta release.

Milestone: Public beta release and onboarding guide covering all three services.

Week 5 — First User-Testing Round

  • Recruit 8-12 participants.
  • Run the fixed task script and questionnaire with the first participant group.
  • Record task completion, assistance required, transaction outcomes, comprehension and reported issues.
  • Triage findings by severity and publish an interim update.

Milestone: First-round anonymized results, measured task outcomes and a prioritized issue register.

Week 6 — Fix, Complete Testing and Retest

  • Fix critical, high-severity and repeated usability findings.
  • Complete the remaining participant sessions.
  • Re-run affected automated tests and repeat failed participant tasks after fixes.
  • Finalize the anonymized dataset and beta metrics.

Milestone: At least 8 completed sessions, retest results and a release-candidate beta build.

Week 7 — Operational Observation and Evidence

  • Run a seven-day observation of API, indexer and executor readiness.
  • Verify dedicated scheduled, recurring and DAO Harvest testnet jobs.
  • Publish transaction accounting, service incidents and recovery evidence.
  • Resolve any release-blocking operational finding and repeat the affected check.

Milestone: Seven-day operational record and real testnet evidence package.

Week 8 — Completion

  • Publish the final beta metrics and anonymized dataset.
  • Publish a demo video and five-minute verification guide.
  • Report actual spending, limitations and work remaining before mainnet consideration.
  • Publish a continue, revise or stop recommendation for each automation service.

Milestone: Tagged beta release and complete public evidence package.

Nervos DAO timing is controlled by the chain. If a beta Harvest position has not reached a later stage by Week 8, the report will show its exact confirmed state and continue tracking it publicly. A simulated maturity result will not be presented as a live transaction.

7. Required Funding and Breakdown

Total requested: USD 2,000, paid in CKB.

Work Amount Use
Protocol and transaction hardening $700 Threat review, adversarial and boundary tests, multi-operator and recovery drills, fixes and CI coverage
User onboarding $450 First-use flow, terminology, transaction review, status and recovery guidance, error states and responsive UI
Structured user testing $350 Participant recruitment and support, fixed test sessions, data collection, issue triage and retesting
Testnet operations and public evidence $350 Eight-week beta availability, dedicated jobs, service observation, outage drills, transaction decoding and evidence preparation
Documentation, demo and completion report $150 User guide, verification guide, video, anonymized dataset, funding report and final assessment
Total $2,000

Why More Than $1,000

This proposal combines three dependent workstreams. User testing would not be responsible without first hardening the financial and recovery paths. Hardening alone would not show whether ordinary users can understand or use the product. Onboarding changes must then be tested with people other than the developer.

The work also covers three automation services and includes CKB-contract tests, wallet transaction boundaries, executor behavior, service observation and structured external testing. A $1,000 grant could cover only part of that cycle and would leave either the technical work or the user evidence incomplete.

The request does not pay for the original CKAutomata build, previous deployments, earlier reviews, mainnet deployment, a professional audit, tester incentives or long-term operations. Actual spending and any unspent amount will be reported at completion.

The allocation places the largest share on the security-sensitive protocol work, followed by the onboarding implementation. User testing covers participant support, observation, analysis and retesting rather than incentives. Testnet operations cover keeping the beta available and observable throughout the eight-week program as well as producing reproducible transaction evidence. Documentation and reporting receive the smallest allocation.

8. Deliverables and How to Verify

Deliverable Acceptance criteria Verification without deep code review
Hardening report Threat model, findings, fixes, residual risks and explicit statement that no external audit was performed Read the report and open the linked regression tests and CI run
Expanded test gate Contract, builder, wallet, operator, cancellation and recovery cases pass from a clean checkout Run the published verification command and confirm a green result
Public beta release Scheduled, recurring and DAO Harvest setup, review, status and owner actions are usable on mobile and desktop Open the beta, connect a testnet wallet and complete the five-minute guide
Testnet evidence At least two confirmed scheduled payments, two recurring executions and one new DAO Harvest setup, with decoded accounting Open the transaction links in the CKB testnet explorer and compare them with the evidence table
Recovery evidence A documented owner cancellation or recovery construction that does not use hosted CKAutomata services Follow the recovery guide using public RPC data and inspect the unsigned transaction
User-testing report 8-12 recruited participants, at least 8 completed sessions, anonymized raw results, metrics and issue register Recalculate the reported totals from the published CSV or JSON data
Demo and completion report Video, plan-versus-actual results, funding usage, limitations and next recommendation Watch the demo and follow the evidence index

The public beta will remain available for at least 30 days after the completion report, subject to any third-party hosting limitation disclosed in that report.

9. Current State vs. Funded Work

Already Completed — Not Funded by This Grant

  • Open-source MIT-licensed repository.
  • Testnet contracts and versioned deployment manifests.
  • Public frontend, API, indexer and hosted executor services.
  • Scheduled-payment, recurring-distribution and DAO Harvest creation flows.
  • Wallet review, signing and post-wallet transaction validation.
  • Automation list, detail, activity and owner-action screens.
  • Optional operator selection and fallback execution rules.
  • External-operator hosting and registration tooling.
  • Contract, API, web, executor, fuzz and recovery tests.
  • Public technical review and remediation work.

New Work Requested from Spark

  • A time-bounded hardening pass across the three automation services.
  • New regression coverage for grant-period findings.
  • Improved first-use, review, status, error and recovery experiences.
  • A public beta guide and five-minute verification flow.
  • Structured testing with 8-12 external participants.
  • A seven-day operational observation and real transaction evidence package.
  • A public beta report, anonymized dataset, demo and completion report.

10. Out of Scope

  • CKB mainnet deployment or use of mainnet funds.
  • A formal independent security audit.
  • New automation categories beyond the three current services.
  • Changes to Nervos DAO consensus rules.
  • Claims that DAO Harvest increases Nervos DAO yield.
  • Integration into another application.
  • Tokens, reward pools, tester incentives or large-scale marketing.
  • Guaranteed operation or maintenance beyond the grant period.

11. CKB Alignment

CKAutomata depends directly on the CKB Cell Model. A Job Cell records an approved future action, while policy scripts constrain the recipient, amount, timing, state progression, executor payment and owner recovery. This allows execution to be delegated without giving the executor custody of the wallet or unrestricted control over the funds.

The three services demonstrate practical CKB use cases:

  • coordinating Nervos DAO compensation collection and re-deposit;
  • making a one-time CKB payment at a future time;
  • distributing CKB repeatedly under fixed terms; and
  • allowing selected or compatible executors to process eligible jobs under script-enforced limits.

The grant will produce reusable evidence about constrained payment automation, wallet review, external execution, owner recovery and user comprehension. The results will show which parts of CKAutomata are ready for continued development and what must be completed before any mainnet.

12. References

4 Likes