LIVEPublicAPI accessHosted by@OpticFeeds

DeFi Governance Forums | Tracking

Sources: - gov.optimism.io - forum.dfinity.org - gov.near.org - forum.aptosfoundation.org - gov.ethenafoundation.com - forums.sui.io - forum.cosmos.network - dao.rocketpool.net - forum.thegraph.com - forum.fantom.network - forum.fluxfinance.com - gov.frax.finance - forum.safe.global - governance.aave.com - gov.gmx.io - gov.curve.fi - forum.flow.com - forum.arbitrum.foundation - www.comp.xyz - discuss.ens.domains - forum.gnosis.io - gov.indexcoop.com - research.lido.fi - forum.sky.money - forum.pyth.network - dao.rocketpool.net - community.starknet.io - dydx.forum - gov.uniswap.org - forum.xinfin.org - forum.celestia.org - forum.mantle.xyz - forum.stacks.org - forum.polkadot.network - www.jupresear.ch - https://forum.bt.io/ - forum.algorand.org - forum.sandboxdao.com - forum.eigenlayer.xyz - governance.zetachain.com - community.iotex.io - forum.reserve.org - forum.livepeer.org - community.trustwallet.com - forum.0xprotocol.org - forum.astar.network - govern.iota.org - gov.blur.foundation - forum.zknation.io - community.axelar.network - forums.minaprotocol.com - forum.wormhole.com - forum.tezosagora.org - forum.apecoin.com - govforum.kaia.io - agora.multiversx.com - forum.threshold.network - forum.nexusmutual.io - driftgov.discourse.group - forum.sia.tech - gov.ribbon.finance - forum.mwc.mw - governance.ether.fi - forum.swellnetwork.io - forum.jito.network - forum.holo.host - forum.celo.org - forum.dymension.xyz - ceg.vote - community.creditcoin.org

DeFi-Gov+In packageDelayed 10 s for guests27

Connect your agent

Follow https://synoptic.com/p/streams/tracking-or-defi-governance-forums/SKILL.md to connect DeFi Governance Forums | Tracking from Synoptic

Data stream

This is a delayed preview. Log in to follow the stream and see new posts in real time.

talk.nervos.org: C-KZG-4844 on CKB-VM & Blob tree<br /> Port c-kzg-4844 to CKB-VM; see EIP-4844 for more details. We also introduce a blob tree built on c-kzg-4844. We already have SMT, but SMT proofs are quite large, especially when proving multiple elements at once. So we propose a new solution: the blob tree. At its core, it is a two-level path tree built on c-kzg-4844 with Shplonk. It commits to as many as 16,777,216 (4096×4096) elements in a tree of just two levels. Whether you query one element or many, the proof reduces to a single KZG verification call. github.com GitHub - XuJiandong/c-kzg-4844: A minimal implementation of the Polynomial... port-riscv A minimal implementation of the Polynomial Commitments API for EIP-4844 and EIP-7594, written in C. - XuJiandong/c-kzg-4844 Link

talk.nervos.org: Spark Program | CapKey: Spend-Capped Sub-Key Covenants for Browser dApps and AI Agents<br /> Project Name: CapKey Applicant: Terry Jn. ( TeeYml on GitHub) Funding Requested: $720 (paid in CKB, payout address provided upon approval) Duration: 5 Weeks License: MIT Contact: Nervos Talk direct message Ecosystem Alignment: AI Machine Payments, Browser Self-Custody Sessions (BSS) Applicant Profile Terry Jn. ( TeeYml on GitHub) is an independent full-stack and web3 engineer with experience building smart contracts, transaction serialization pipelines and developer tooling across UTXO and account-based ecosystems. GitHub: https://github.com/TeeYml Repository: https://github.com/TeeYml/capkey 1. Executive Summary CapKey is an on-chain covenant vault protocol and client SDK for Nervos CKB that lets wallet holders delegate strictly bounded spending power to temporary sub-keys. In modern Web3 applications and autonomous agent pipelines, key management faces a sharp tradeoff between user friction and catastrophic key exposure. In browser dApps, requiring a wallet popup for every 5 CKB micro-action creates unbearable user fatigue in games, streaming payments and social tipping. Conversely, handing an unconstrained hot private key to an AI agent or browser local storage exposes the entire wallet balance to theft from a single prompt injection or malicious dependency. CapKey solves this natively at the CKB consensus level. By locking funds into a capkey-lock Vault Cell, the master account owner defines non-bypassable constraints: Per-Transaction Cap: A hard ceiling on how much can be spent in any individual transaction. Cumulative Allowance: An exact step-down budget across the lifetime of the sub-key. Single-Successor Rule: Exactly one vault Cell in and one out, so a spend cannot split or merge vaults to dodge the caps. Sequence Counter: Each delegate spend raises last_sequence by one, giving verifiers an ordered history. Owner Recovery: The owner can sweep or rotate the vault at any block. Because CKB utilizes the UTXO Cell Model, these rules are enforced directly by recursive script covenants on the transaction outputs without requiring the heavy smart-contract account abstraction layers (ERC-4337) or centralized relayer infrastructure needed on account-based chains. 2. Motivation & Ecosystem Need The Nervos Opportunity Map for AI, Machine Payments and Fiber in 2026 ( AI, machine payments, and Fiber in 2026: an opportunity map for CKB and Fiber developers ) designates Browser Self-Custody Sessions (BSS) as a high-priority track under “Validate Next” , highlighting two critical emerging use cases: Enabling browser users to conduct repetitive on-chain interactions without signing continuous wallet popups. Providing autonomous AI agents with scoped, bounded on-chain balances so they can pay for inference, data or tooling without access to the operator’s master treasury. Why Existing Approaches Fall Short Approach Architecture Failure Mode Frequent Master Signing Cold wallet signs every micro-action Severe popup fatigue; breaks gameplay and real-time interaction flows Hot Key In Local Storage / .env Unconstrained private key in app environment Full balance exposed; one XSS exploit or prompt injection drains all funds Off-Chain Policy Linters (e.g. CellGuard ) Off-chain client checks transaction JSON Stolen hot key bypasses the linter and broadcasts directly to CKB RPC nodes Centralized Database Balances Custodial server tracks user credits Defeats self-custody; requires user trust and creates regulatory counterparty risk EVM Account Abstraction (ERC-4337) Smart-contract wallet with session keys Extreme complexity; requires user-ops, bundlers, paymasters and high gas overhead CapKey provides a native CKB answer: a lightweight, recursive covenant lock script where every sub-key spend is validated directly by CKB-VM nodes. 3. Protocol Architecture & Invariants CapKey operates via a hierarchical key model: the Cold Master Key retains unconstrained ownership, while the Hot Delegate Key holds covenant-restricted spending permissions. Vault Transition Flow Input vault Cell (500 CKB, allowance 250, max_per_tx 100, seq 0) + input locked by delegate_lock_hash (its lock checks the signature) | v Output 0: successor vault Cell (420 CKB, allowance 170, max_per_tx 100, seq 1) Output 1: recipient Cell (79.99 CKB) 80 CKB left the vault: 79.99 to the recipient and 0.01 as fee Binary Cell Layout ( CK01 ) Lock Script Arguments ( args ) (64 bytes) owner_lock_hash (32 bytes): lock hash of the owner wallet. delegate_lock_hash (32 bytes): lock hash of the delegate key. Any CKB lock can fill this role. Cell Data (28 bytes) magic (4 bytes): ASCII identifier CK01 . max_per_tx (8 bytes, u64 LE): maximum shannons that may leave the vault in one transaction. remaining_allowance (8 bytes, u64 LE): cumulative shannons the delegate may still spend. last_sequence (8 bytes, u64 LE): counter raised by one on each delegate spend. Design choice: the delegate’s own lock checks the signature The delegate path requires an input in the same transaction locked by delegate_lock_hash . That lock verifies the signature over the whole transaction, so capkey-lock contains no signature code. This keeps the script at 27 KB and lets the delegate be secp256k1, a WebAuthn lock such as JoyID or any other lock already on CKB. Consensus Rules Owner path: an input locked by owner_lock_hash is present. The script accepts. Delegate path: an input locked by delegate_lock_hash is present and all of these hold: One vault Cell is consumed and exactly one is created. Output 0 carries the same capkey-lock script and no type script. spent = input.capacity - output[0].capacity is above zero. It covers the recipient payment and the miner fee. spent <= max_per_tx . spent <= remaining_allowance . Output 0 data keeps max_per_tx , lowers remaining_allowance by exactly spent and raises last_sequence by one. Known limits CKB has no upper bound on when a transaction may be committed so a lock cannot enforce “valid until time T”. CapKey does not claim expiry. The allowance bounds the loss and the owner can sweep at any time. Caps apply to capacity only. xUDT and Spore assets are out of scope. The recipient is not restricted. 4. Current State & Proof of Execution The core lock already exists and is public, written in Rust and tested in the real CKB-VM: Script: contracts/capkey-lock , ckb-std 1.1, no_std , 27,712 bytes. Tests: 12 ckb-testtool tests. Each rejection test asserts the exact script error code. Measured: 38,085 cycles for a delegate spend and 22,648 for an owner sweep, with an always-success delegate lock in the harness. Reproduce: make test Existing vs Funded Scope Component Status Today Funded Scope in Grant capkey-lock script Done, 12 tests passing Hardening, review fixes and testnet deployment Tests with a real signature lock Always-success locks only Tests against the secp256k1 lock and a WebAuthn lock, with real cycle numbers @capkey/sdk None Transaction builders for create, delegate spend, chained spends and owner sweep capkey CLI None issue , pay and verify against CKB RPC Web app None Public testnet app with a non-extractable WebCrypto delegate key Independent verifier None Standalone checker that validates a vault transition from RPC data alone 5. Milestone Roadmap & Deliverables The funded work runs for 5 weeks in four milestones. Milestone 1: Real signature locks and testnet deployment (Week 1) Add tests where the delegate is the secp256k1 sighash lock and where it is a WebAuthn (P-256) lock. Publish the cycle cost of each. Add the cases missing from the current suite: a delegate input present but spending a different vault, two vaults in one transaction and u64 boundary values. Deploy capkey-lock to CKB testnet and publish the code hash and deployment transaction. Deliverable: tag v0.2.0 . Milestone 2: TypeScript SDK and CLI (Weeks 2-3) @capkey/sdk on CCC with builders for vault creation, delegate spend, chained unconfirmed spends (up to 3) and owner sweep. capkey issue and capkey pay working against testnet. Deliverable: published npm package and CLI. Milestone 3: Public web app (Week 4) Connect a testnet wallet, fund a vault and issue a delegate key. The delegate key is a WebCrypto key with extractable: false stored in IndexedDB, so page scripts can sign but cannot export it. A demo store spends from the vault with no wallet popups and shows remaining_allowance falling. A “Simulate Rogue Drain” button submits an over-cap transaction and shows the node’s script error. Deliverable: live URL. Milestone 4: Verifier, guide and video (Week 5) capkey verify <tx_hash> rebuilds the input state, outputs and caps from CKB RPC and prints pass or fail. Integration guide for dApps and AI agent frameworks. Short walkthrough video. Deliverable: verifier, guide, video and a closing report. 6. How to Verify Every milestone includes self-contained reproduction commands requiring no subjective review: Native Script Verification: git clone https://github.com/TeeYml/capkey.git cd capkey make test Every adversarial case fails inside the CKB script with its expected error code while valid transitions succeed. Public Web Experience: Navigate to the hosted testnet web app. Connect JoyID or MetaMask, deposit 500 CKB and issue a 100 CKB sub-key with a 25 CKB per-tx limit. Click “Purchase Item (10 CKB)” three times: payments confirm on testnet with zero wallet popups. Click “Simulate Rogue Drain (150 CKB)”: transaction is rejected by CKB RPC. Click “Revoke & Sweep”: master key reclaims all remaining vault funds to the cold wallet. Independent RPC Verification: npx capkey verify <tx_hash> --rpc https://testnet.ckbapp.dev/ Outputs parsed input vault parameters, deducted payment, fee breakdown, successor vault allowance and validation status. On-Chain Explorer Verification: Inspect published transaction hashes on pudge.explorer.nervos.org proving live deployment, delegate spends and master revocations. 7. Budget Breakdown The requested funding is $720 , paid in CKB. Calculated bottom-up at $15/hour across 48 hours . The lock script and its first test suite are already written and are not billed. Milestone / Deliverable Hours Cost (USD) Milestone 1: Real signature lock tests, extra cases and testnet deployment 10 $150 Milestone 2: @capkey/sdk builders, chained spends and CLI 16 $240 Milestone 3: Public web app with WebCrypto delegate and attack simulator 14 $210 Milestone 4: Independent verifier, guide and video 8 $120 Total 48 $720 Disbursement will follow the committee’s standard milestone schedule. Payout address will be provided upon approval when requested. 8. Post-Grant Maintenance Plan Following the completion of the 5-week grant scope, I commit to: 6 months of active maintenance for the @capkey/sdk repository. Responding to community issues and pull requests on GitHub within 48 hours. Ensuring ongoing compatibility with updates to CCC, ckb-std and CKB node releases. Providing technical guidance to any ecosystem dApp or AI agent team seeking to integrate CapKey sub-keys. Link

talk.nervos.org: Spark Program | CKB Script Bench: How Well Do AI Models Write CKB Scripts?<br /> 1. Project Overview Project name: CKB Script Bench One-sentence summary: An open, re-runnable test set of 24 CKB on-chain script tasks that measures whether AI-written lock and type scripts compile against the current ckb-std and hold up against malicious transactions, and whether CKB’s official AI resources fix the failures. A pilot on 3 tasks already found that the main failure is outdated or invented API use, not unsafe logic. Project type: open-source benchmark (task set + hidden security tests + runner) and a public report, run in ckb-testtool / ckb-debugger. No chain deployment needed. Funding requested: $980, paid in CKB Duration: 6 weeks CKB Script Bench is a measurement, not another AI assistant. It does not build a chatbot, a scaffold or an MCP server. It tests the ones that already exist and publishes where AI-written CKB scripts break. 2. Team Profile Shobiye Abdulazeem (solo), backend / smart-contract engineer, Lagos, Nigeria]. I built Stellar tags, Human-readable payment tags for the Stellar network. Send to alice*stellartags instead of a 56-character G... address. Has shipped on Stellar/Soroban. Anything that breaks in ckb-testtool, ckb-debugger or the official docs gets written up and filed upstream. GitHub: github.com/Abdulazeem-code · Repo: github.com/Abdulazeem-code/ckb-script-bench · Contact: Nervos Talk DM 3. Project Background Why I want to build this. AI written ckb script was good, But it doesn’t seem safe for the developer and whatever product is being worked on And also Not all its code compile against the current ckb-std. The gap this targets. CKB now officially recommends AI agents for script work. The docs publish llms.txt and llms-full.txt , list a community MCP server (CKB AI) and an agent skill (CKB Dev Skills), and ship a starter prompt to “Write, Test, and Deploy a CKB Script”. Nobody has published numbers on whether the scripts these agents write are safe . An AI-written CKB script can fail in two ways. It may not compile against the current ckb-std, because the model learned an older API or invents methods. Or it compiles but is too permissive: a lock that ignores the script group, a token that doesn’t check overflow, or a timelock that reads since wrongly. The second is the expensive failure, so every task carries attack tests. The pilot below found the first is the common one today, and it is the one the official AI resources should fix. Existing work, and what this reuses. Existing What it covers How this project relates ckb-ai-bench Whether the CKB AI MCP server improves a coding agent; 7 tasks verified by direct CKB RPC on devnet/testnet; no published run yet Complementary. It measures tool help on chain operations; this measures script correctness under attack. The CKB AI MCP condition is left out here so the two do not test the same thing. Tasks and tests are published openly, so ckb-ai-bench or anyone else can reuse them Official AI resources (AGENTS.md in ckb-script-templates, llms-full.txt, CKB Dev Skills) What agents should read and how they should work These are the conditions being tested, used unmodified ckb-testtool + ckb-debugger Running scripts against crafted transactions The test engine. No new runtime is built Nervos Brain (Spark, completed) Answering developer questions Different question: answers vs. code that holds up What is new: compile checks against the current ckb-std plus hidden attack tests, run on agent-written scripts from a developer-style brief, with each official AI resource switched on and off, published so anyone can re-check every number. Pilot evidence (already done, not funded). Three tasks were built and given to ChatGPT and Gemini in fresh chats, with no follow-up messages. Each answer was compiled unedited and run against the task’s positive and attack tests. Run Model Task Prompt Result 01 ChatGPT A01 hash-preimage lock full spec Correct: 3/3 valid, 6/6 attacks rejected 01 Gemini A02 absolute timelock full spec Correct: 3/3, 7/7 01 ChatGPT (free) A01 hash-preimage lock brief Correct: 3/3, 6/6 01 Gemini Pro A02 absolute timelock brief Correct: 3/3, 7/7 01 ChatGPT (free) B01 simple token brief Compile error: calls Script::hash() , which doesn’t exist. Correct after a minimal fix 01 Gemini Pro B01 simple token brief Compile error: SysError match written for an older ckb-std. Correct after a one-line fix 02 ChatGPT (free) B01 simple token brief + AGENTS.md Correct: 4/4, 7/7 02 Gemini Pro B01 simple token brief + AGENTS.md Compile error: the same SysError match. Correct after the same fix None of the 8 answers was unsafe; every failure was API knowledge. 3 of the 4 answers to the Tier B brief failed to compile against ckb-std 1.1. Adding the official AGENTS.md fixed one of the two: it steered ChatGPT to real high_level functions, but it says nothing about what changed between ckb-std versions, so Gemini repeated its mistake. This is one answer per model per condition: a signal, not a measurement. Prompts, unedited answers, compiler output and results are in the repo ( run 01 , run 02 ). The funded run repeats every cell with more tasks, models and runs. 4. Solution What anyone gets (from week 5): Clone the repo and run one command. It re-runs every hidden test against the published agent outputs, with no API keys needed. Open the results page: pass rates per task, per model, per condition, and every unsafe script with the attack that broke it. Optionally plug in your own model or agent setup and score it on the same 24 tasks. The task set (24 tasks, Rust + ckb-std, as the official agent instructions recommend): Tier Tasks Examples A. Lock scripts 6 (2 built) hash-preimage lock, owner lock by lock hash, absolute and relative timelocks via since , 2-of-3 multisig-lite B. Type scripts 9 (1 built) counter that only increments, simple token (output sum ≤ input sum unless owner mints), immutable data cell, one-time-unique cell (Type ID style) C. Combined 9 escrow with refund after deadline, vault that must keep capacity, lock + type pairing, script reading cell deps Each task has a plain-English spec (what an agent sees), 2–4 positive tests and 4–8 hidden attack tests (what it never sees). The attacks are the common CKB mistakes: extra inputs in the same script group, unchecked args length, outputs created without the type script, wrong since flags, sums checked on one side only. Each task also has a brief : the interface only (args, cell data and witness format), the way a developer would ask. Scored runs use the brief, because in the pilot the full spec turned the safety rules into a checklist that every model followed. The set leans toward Tiers B and C because every Tier A answer in the pilot was correct; Tier A stays as a floor. Conditions, each with the same prompt and the same three models (chosen at kickoff: two leading closed models and one open-weight model): C0 bare model, no CKB context C1 + AGENTS.md from ckb-script-templates (the pilot’s condition) C2 + official llms-full.txt C3 + CKB Dev Skills agent skill The MCP server condition is left to ckb-ai-bench so the two projects do not overlap. Pre-registered hypotheses. Posted on this thread before week 1. Anyone may propose an extra attack test, and I commit to adding it before the scored run. # Hypothesis Pass if If it fails, the report publishes H1 Bare models often write CKB scripts that don’t compile against the current ckb-std In C0, ≥ 30% of first attempts on Tier B and C tasks fail to compile The real first-try compile rate, and the API errors behind each failure H2 Bare models rarely write unsafe scripts In C0, < 10% of scripts that pass all positive tests fail an attack test Every unsafe script with the attack that broke it H3 Official AI context cuts compile failures The best of C1–C3 cuts first-try compile failures by ≥ 15 points vs C0 Per-resource deltas, including tasks where context made it worse H4 A one-page “ckb-std 1.x changes and common mistakes” note, written from scored-run failures, fixes the top errors On 6 held-out tasks, adding the note to C1 raises first-try compile by ≥ 10 points The note anyway, marked as not shown to help What this does not claim. 24 tasks and three models are a sample, not a ranking of AI vendors. The report states run counts and variance and makes no claim beyond them. 5. Technical Architecture Task layout (as already in the repo): tasks/<id>/spec.md (full spec), tasks/<id>/brief.md (what the model sees in scored runs), contracts/<name>/ (reference solution, from ckb-script-templates) and tests/src/<name>.rs (positive p* and attack a* tests). The 3 pilot tasks are public. Attack tests for the other 21 stay in a private branch until the scored run is frozen, then are published. Runner (extends the working scripts/render_prompt.sh and scripts/run_candidate.sh ): Builds the prompt: spec + template + the condition’s context (none / AGENTS.md / llms-full.txt / CKB Dev Skills). Calls the model once, then allows up to 3 repair turns that show only compiler errors. No web access, no test results shown. This keeps runs cheap and comparable. Builds the script to RISC-V in a throwaway copy of the repo inside a pinned Docker image, then runs positive and attack tests with ckb-testtool, which executes through the CKB-VM the same way ckb-debugger does. Writes one JSON line per run: task, model, condition, run number, compiled yes/no, positives passed, attacks passed, cycles used, tokens, cost, and the generated source. Scoring: Compiles first try → the unedited answer builds without errors Compiles after repair → builds within 3 repair turns that show only compiler errors Happy-path pass → all positive tests pass Full pass → all positive and all attack tests pass Unsafe → happy-path pass but ≥ 1 attack accepted Run size: 24 tasks × 4 conditions × 3 models × 2 runs = 576 runs, plus 36 runs for H4 (6 held-out tasks × 3 models × 2 runs). Each run is about 10–20k tokens. Two runs per cell, instead of three, keeps the added AGENTS.md condition inside the same API budget. H4 hold-out: 6 of the 21 private tasks are frozen as held-out before the scored run. The note is written only from failures on the other 15, then tested on the 6. Verification without API keys: all generated sources are committed. make verify rebuilds every script and re-runs every test from the committed sources, and make report rebuilds every number in the report from the JSON logs. Hard parts, which are the point of the test: Fair attack tests: each one follows from a rule the brief states (“only the owner can mint” covers the overflow and owner-on-output attacks), and the full spec spells it out. Telling API errors from logic errors: every answer is scored unedited, then again after compile-only repair turns, so a script that fails to compile still gets a safety verdict. Model outputs vary run to run; two runs per cell and published variance handle this. Cycle limits: a script that is correct but exceeds a sane cycle budget is reported separately, not counted as safe. Out of scope: mainnet or testnet deployment, building a new AI assistant or MCP server, fine-tuning models, C and JS scripts (possible follow-up). 6. Weekly Execution Plan Week Focus Concrete output 0 (before start) Post hypotheses and the 24 task titles on this thread Hypotheses and task titles posted and locked 1 Automated runner (model API calls, 4 conditions, repair turns), pinned Docker image, scoring; the remaining 4 Tier A tasks make verify passes on reference solutions for all 6 Tier A tasks and B01; tag v0.1 2 The remaining 17 Tier B and C tasks; reference solution and broken copies for every task All 24 reference solutions pass every test and every broken copy is caught; community attack-test proposals merged 3 Automated pilot run (1 model, C0, 1 run) to find unfair tests; freeze the 6 hold-out tasks Pilot results posted on this thread; any test changed is listed with the reason; attack tests frozen by commit hash 4 Scored run: 576 runs; write the note from the 15 non-held-out private tasks; 36 H4 runs Raw JSON logs and all generated sources committed 5 Results page and report draft; publish attack tests Results page live; report draft posted for comments 6 Final report, CKB script mistakes note, upstream issues Report and note published; issues filed for any docs or tool gaps found; closing post on this thread 7. Funding Requirements: $980 in CKB Bottom-up at $15/hour, 54 hours, plus model API costs. Item Hours Cost (USD) Runner, pinned Docker image, scoring, make verify / make report 10 150 Tier A: 4 remaining lock-script tasks (2 already built, not funded), reference solutions, positive + attack tests 4 60 Tiers B and C: 17 remaining tasks (1 already built, not funded), reference solutions, positive + attack tests 22 330 Pilot run and fixing unfair tests 4 60 Scored run supervision and the mistakes note 5 75 Results page and report 7 105 Upstream issues and closing post 2 30 Model API usage, ~610 runs at 10–20k tokens each (estimate; invoices published, any unused amount reported) – 170 Total 54 980 20% at launch ($196). The remaining 80% ($784) on completion against the deliverables in section 8. Fund usage is disclosed at completion against this table. 8. Deliverables and Verification None of these checks needs a code review or an API key. Deliverable How to verify Task set (24 tasks) Clone the repo, run make verify-reference : every reference solution passes every positive and attack test Attack tests are real Run make verify-broken : each task ships 1–2 deliberately wrong solutions, and the attack tests catch every one Scored results Run make verify : rebuilds all ~610 committed agent-written scripts and re-runs every test; results match the published logs Report numbers (H1–H4) Run make report on the published JSON logs; diff against the published report Tests were frozen before scoring The attack-test commit hash posted on this thread in week 3 predates the scored-run logs Results page Open the link from this thread: filter by task, model and condition; each unsafe script links to its source and the attack that broke it CKB script mistakes note One page in the repo; H4 result shows whether it helped on the 6 held-out tasks Upstream notes UPSTREAM.md lists each docs or tooling gap found, each linked to an issue in the relevant repo 9. Current State vs. Funded Scope Already exists (not funded): a public repo, ckb-script-bench , with 3 finished tasks (A01 hash-preimage lock, A02 absolute timelock, B01 simple token). Each has a full spec, a brief, a reference solution, and positive and attack tests: 30 tests, all passing. Every attack test was checked against a deliberately broken copy of the reference with the bug it targets, and all 12 broken copies are caught by exactly that test. Scripts render the prompts and score any model’s answer (CORRECT / WORKS BUT UNSAFE / BROKEN / COMPILE ERROR). Two pilot runs produced 8 model answers (section 3). Funded by this grant: the remaining 21 tasks and tests, the automated runner (model API calls, repair turns) and Docker image, the automated pilot and scored runs, results page, report, the ckb-std changes note, upstream issues. Explicitly out of scope: deployment to any network, a new AI assistant or MCP server, model fine-tuning, C or JS scripts, ranking AI vendors. 10. CKB Ecosystem Alignment AI-assisted developer onboarding , one of Spark’s three stated directions, approached as measurement: it tests the AI resources CKB already recommends instead of building another one. Problem before solution: the pilot already tested the original idea. Unsafe scripts didn’t appear in 8 answers; compile failures against the current ckb-std did, in 3 of 4 Tier B answers. The hypotheses follow that evidence, and H2 says plainly that unsafe scripts may be rare. Anyone can verify it: every number rebuilds from committed sources and logs with one command and no API keys. Reuses before building: ckb-testtool, ckb-debugger, ckb-script-templates, the official llms-full.txt and CKB Dev Skills, all unmodified; tasks published openly for reuse by ckb-ai-bench or anyone else. Useful after the grant: DevRel and tool authors (CKB AI, CKB Dev Skills, docs) can re-run the bench after each change to see whether scripts compile and hold up better. The pilot already found one gap to report: AGENTS.md says nothing about what changed in ckb-std 1.x. Honest limit: a sample of 24 tasks, three models and Rust only. It shows where agents fail on CKB, not which AI is best. Risks and Mitigations Risk Mitigation Overlap with ckb-ai-bench Scope split stated up front: they cover MCP help on chain operations, this covers script safety, and the MCP condition is left out here. Tasks published openly for reuse Attack tests are unfair or too strict Every attack maps to a sentence in the spec; week-3 pilot finds unfair tests; changes listed publicly before tests are frozen Tasks leak into future model training The 3 pilot tasks are public and reported separately; attack tests for the other 21 stay private until the scored run is frozen; 6 held-out tasks; the runner accepts new task versions API costs exceed estimate Repair turns capped at 3; run count fixed in advance; if short, drop the open-weight model’s second run first and say so in the report Models update mid-run Exact model versions and dates recorded per run; whole scored run done inside week 4 Result is “agents are already fine” A valid result, and the pilot already points that way for safety. The report publishes it with the evidence; the compile measurements (H1, H3, H4) stand either way Sources CKB official AI resources ckb-script-templates (source of AGENTS.md) ckb-ai-bench (sonami-tech) Spark Program Q2 2026: What the Ecosystem Is Building ckb-script-bench repo : pilot run 01 , run 02 Link

talk.nervos.org: CKB Pulse today: a new look, lessons from real fixes, and CKB inside your tools<br /> CKB Pulse started six weeks ago as one page that shows who is building on CKB, live . It has grown into something larger: a place where the work of every CKB builder is seen, credited, and turned into lessons the next builder can use. This post is what it does today. VIDEO: https://x.com/LusoCryptoLabs/status/2123541495776940150 CKB Pulse CKB Pulse Pulse shows the public work of the CKB ecosystem as it happens, from GitHub: projects, people and updates in one place. In short Live. Every push, pull request, review, issue and release in the CKB projects on GitHub, as it happens. In the 30 days to 19 November: 5,514 updates by 213 people in 209 projects, not counting our own. Bots and AI agents are left out. A new look. The whole site was redesigned, in dark and light, with a first page that says what it is. Lessons from real fixes. 198 lessons so far, drawn from the public commits of 47 CKB projects. Each one is checked against the commit it came from and links to it. Credit where the work was done. Every project has a card with who works on it and what CKB learned from it. Maintainers can confirm the lessons from their own project. Inside your tools. An MCP server for AI agents, a check of your code against the lessons, and a GitHub Action that brings the lessons to your pull requests. Free and open source (MIT), in English, 中文 and Português, on a phone or a computer. A new look The site was redesigned from top to bottom: straight corners, strong type, one red signal, and the name of who makes it under the title. The reading pages follow your device in dark or light, and you can switch. First-time visitors land on a page that says what Pulse is before the live view opens. The address changed too: pulse.lusocryptolabs.com . Old links keep working. What the ecosystem learned, kept for the next builder Most of what builders learn on CKB stays in a commit message, or in nobody’s notes. Someone finds out that an absolute epoch since needs its flag, or that completeFeeBy adds a change output where they expected an output to shrink, fixes it, and moves on. The next builder hits the same wall. Pulse reads the public commits of the projects it follows and keeps what they teach as short lessons: the rule, why it matters, the code before and after when the commit shows it, and the commit itself. A lesson is released only after it is checked against that commit and against the project’s code as it is today. A lesson that stops being true comes down. Browse and learn: https://pulse.lusocryptolabs.com/learned , by topic and by level, with a start page, a glossary and a review mode. Credit: every lesson names the project and links the commit. Every project card lists “What CKB learned from this project”. Confirmed by maintainers: if you own a project, wrote the commit, or are a public member of its organisation, you can confirm or correct its lessons from the lesson page, one by one or all at once. A confirmed lesson shows your name. The first 21 are confirmed, all from our own repositories. Yours are next, if you want them to be. Open data: all of it as JSON, under CC BY 4.0: https://pulse.lusocryptolabs.com/learned.json The lessons come to you Reading a list of lessons is one way. Having them arrive while you work is better. In your AI agent Pulse is an MCP server. One line in Claude Code (other MCP clients take the same address): claude mcp add --transport http ckb-pulse https://pulse.lusocryptolabs.com/mcp Your agent can then ask who works on what, search the lessons, and check your code against them ( check_code ): it returns the lessons about the functions, RPC methods and constants your code uses, and flags code that repeats a known mistake. It gives hints to read, not proof. Nothing is run and the code is not stored. To have your agent do this by itself, paste the short rule from https://pulse.lusocryptolabs.com/use#rule into your project’s AGENTS.md or CLAUDE.md . On every pull request A GitHub Action comments on each pull request with the lessons that apply to the lines that changed, repeated mistakes first. Copy one file into .github/workflows/ : https://github.com/LusoCryptoLabs/ckb-pulse-action No key and no account. Only the changed lines are sent, and they are not stored. Who builds on what Which CKB libraries do projects really use? Pulse reads the dependency files of every project it follows. The list is made by use: a library appears when several builders use it, and leaves by itself when nobody builds on it any more. Today: CCC in 124 projects, ckb-std in 89, ckb-testtool in 77, Molecule in 36, and nine more. If you maintain a library, this is your reach, updated twice a day: https://pulse.lusocryptolabs.com/impact Also there Digests for the day, the week and the month: the busiest projects and people, and what shipped. https://pulse.lusocryptolabs.com/digest?p=week Follow projects and people on your device, and share what they ship. A badge for your README, and a feed. An API for everything on the page: https://pulse.lusocryptolabs.com/use Limits GitHub only. On-chain activity, private repositories and work outside GitHub do not show. Projects are found automatically, by the CKB libraries they use and by how they describe themselves. A check today found about 60 active projects Pulse was missing, and most are followed now. Some are surely still missing: suggest yours on the page. A lesson comes from one project’s commit unless it says otherwise. Read the source before you rely on one. If you want your project or your account out of Pulse, open an issue and it is done: https://github.com/LusoCryptoLabs/ckb-pulse/issues Questions for you What should Pulse answer that it does not today? If you maintain a project with lessons on Pulse: are they right? Your confirmation, or your correction, makes them worth more to everyone. Would you put the action on your repository? What would stop you? What would you use most? Following projects and people live The daily, weekly and monthly digests The lessons from real fixes Pulse inside my AI agent (MCP) The lessons on my pull requests (GitHub Action) 0 voters Source: https://github.com/LusoCryptoLabs/ckb-pulse Corrections are welcome. Link

forum.pyth.network: [Pythian Council Election #6] Borys - Pyth Network<br /> Candidate Information Full Name: Borys Current Role: Chiron at Pyth Network Discord / 5th Price Feed Council Member Protocol / Organization: Pyth Network Location (Continent): Europe (Kyiv, Ukraine) X (Twitter) handle: @CryptohooperB Discord handle: bbb21024654 GitHub handle: N/A Solana Wallet Address: H29R8L5XaGVjDTSq1KxSvNWSF2DZSPHAUm1Y7CMN3H6B Ethereum Wallet Address: 0xe202c44E38d2ADa26A425b4FCdc0E95117678BA7 Signing-key Custody: Ledger Flex hardware wallet for both Solana and Ethereum keys Motivations to participate in the Pythian Council Proven Council Reliability: Two seats in this election opened up because incumbents fell below the one-third voting threshold. Having served on the 5th Price Feed Council and as a Pyth Chiron since April 2025, I have already demonstrated consistent multisig discipline and uninterrupted daily engagement. I bring that exact operational track record to the 7-of-9 Pythian Multisig to guarantee 100% participation in reviewing and signing Operational PIPs. Operational Coverage in the European Time Zone: Timely execution of oracle upgrades, cross-chain verification changes, Express Relay adjustments, and Strategic Reserve actions requires active signers across global time zones. Operating from Europe (EET/UTC+2), I provide consistent daytime and evening coverage to prevent multisig bottlenecks. Protecting Protocol Integrity and Community Alignment: The Pythian Council executes critical decisions around protocol fees, Entropy parameters, and publisher onboarding objections on the Pyth Data Marketplace. Having dedicated my entire Web3 journey exclusively to Pyth since June 2024, I am motivated to safeguard the technical standards of our infrastructure while ensuring complex operational updates remain transparent to long-term stakers. Relevant Experience 5th Price Feed Council Member: Elected member of the 5th Price Feed Council, actively participating in multisig operations, proposal reviews, and protocol governance execution using a dedicated Ledger Flex hardware setup. Long-Term Ecosystem Track Record: Active Pyth community member since June 2024 and serving as a Pyth Network Chiron since April 2025. Pyth is my sole focus in Web3, giving me deep historical context on the protocol’s evolution. Active Governance and Staking Participant: Long-term PYTH staker, OIS participant, and consistent on-chain voter on Realms. I regularly monitor governance proposals, operational PIPs, and tokenomic mechanics including the Strategic Reserve and fee structures. Deep Familiarity with Pyth Infrastructure: My daily work involves tracking and breaking down core technical updates across the ecosystem, including pull-oracle architecture, RWA price feeds, Express Relay, Entropy, and Pyth Pro institutional integrations. Proven Operational Discipline: Managing council duties alongside structured weekly community operations and multi-platform media workflows has demonstrated my ability to verify technical instructions accurately and execute routine commitments without failure. Ecosystem Alignment: Pythenians NFT holder and active contributor to community onboarding and education in Discord. Link

forum.cosmos.network: Hub Weekly Update #25: November 19, 2026<br /> This is the twenty-fifth Hub Weekly Thursday recap, straight from the Hub Unit team, as promised in the From Chaos to Stability to Growth post. Every Thursday, we will call out significant Cosmos Hub updates on the forum, with a short companion thread on X, recapping announcements, live events like validator or community calls, and ecosystem updates! For more info, see the linked posts, and contact me or @RoboMcGobo on Telegram to submit news for the weekly. Robo is back next week! This week: Gaia v29.1.0 is live, dYdX moves its USDC to Injective, the latest USDC figures, and Skip:Go maintenance day on November 23. Gaia v29.1.0 : Proposal 1061 passed, and the upgrade executed on November 18 at block 33,935,300 dYdX moves its USDC to Injective : v9.9 applied on November 17, deposits now route through Injective, and user balances are unchanged USDC migration : 55.65M USDC.n remaining on Noble as of Thursday, down from 84.56M on November 11 Skip:Go maintenance : about three hours of downtime on November 23 from 02:00 UTC, with no code changes needed from integrators. The team continues to work on the Tokenomics update for the last week of November , as promised, to begin the public review and proposal process through then and the end of the year. Gaia v29.1.0 Is Live: Proposal 1061 Passed, and the Upgrade Executed on November 18 at Block 33,935,300 Proposal 1061 passed. Voting ended on November 17 at 11:57 UTC with 155,557,950.13 ATOM voting yes, 1,134.77 ATOM abstaining, 231.81 ATOM voting no, and no veto votes. The upgrade executed on November 18 at block 33,935,300 , at 12:37 UTC, and the Hub has been producing blocks on v29.1.0 since. What it fixed: the v29 upgrade removed the legacy params module, which broke decoding of older parameter-change proposals, so governance queries and state export failed on those entries (reads only; voting and execution were never affected). v29.1.0 restores decoding of those proposals, updates wasmd to v0.60.10 and wasmvm to v2.3.6, and ran on the testnet from November 3. The release is on the Gaia repository , the upgrade post is on the forum , and the background is in last week’s update . Thank you to all validators for helping with the update! How you can help: Validators still on the old binary: switch to v29.1.0 now, verified against the release signing keys . A node on v29.0.x stops at block 33,935,300 and does not sync past it. Node operators running a public RPC, REST or gRPC endpoint: make sure it is on v29.1.0 too, so the wallets, explorers and indexers pointed at it get the restored governance queries. dYdX Moves Its USDC to Injective: v9.9 Applied on November 17, Deposits Now Route Through Injective, and Balances Are Unchanged dYdX Proposal 400 , the v9.9 software upgrade, passed with voting ending on November 16, and the upgrade applied on November 17 at height 114,220,000. It adds a Canonical USDC module that tracks whether each unit of USDC on dYdX Chain is backed by USDC on Noble or by USDC on Injective, and moves that backing to Injective over time. What changed for dYdX users since the upgrade: Deposits route through Injective. Deposits sent from Noble, including CCTP transfers routed through Noble, are rejected and refunded to the sending address. Withdrawals to Injective arrive as USDC on Injective. Noble withdrawals stay open as a temporary route until dYdX governance closes them. Balances, positions and collateral are unchanged , and the USDC denom on dYdX Chain stays the same. The dYdX post on the migration has the full detail, including the safeguards (per-block backing checks, rate limits and automatic pauses), and the Hub’s post from November 13 has the short version. Why it matters for the migration as a whole: as of November 11, dYdX held about 69.3M USDC.n, around 82 percent of what remained on Noble. The backing shifts gradually rather than in one transaction: deposits through Injective add Injective backing, and a designated operator moves the Noble-backed portion over in rounds, within Circle’s rate limits. As of Thursday morning, the Noble escrow for dYdX’s channel holds 41.81M USDC.n, down about 27.5M in the week, and 24.31M USDC.inj is now on dYdX Chain. Thank you to the dYdX team for this massive effort, and for all teams coordinating with the Ecosystem team, Injective, and Circle, to facilitate the transition. This will greatly accelerate te migration! USDC Migration: 55.65M USDC.n Remaining on Noble as of Thursday, November 19, Down from 84.56M a Week Earlier On-chain supply as of Thursday, November 19, with the change since Wednesday, November 11, the date of last week’s figures: USDC.inj on Injective: 36.94M , up from 11.70M USDC.n remaining on Noble: 55.65M , down from 84.56M. The Noble escrow for dYdX’s channel holds 41.81M of it, or about 75 percent of what remains, down from about 69.3M Outside dYdX, 6.37M remains on Osmosis, down from about 6.8M, and the Hub’s balance is 0.42M, unchanged The drop on Noble tracks dYdX’s migration almost one for one, and the rise on Injective is the same USDC arriving on the other side. For everyone else, the balances left are small and spread across chains and wallets, and the tooling to move them is live today. Circle’s dates for Noble USDC: January 12, 2027: Circle pauses the Noble USDC contract and takes a snapshot of balances. January 13, 2027: Noble USDC is no longer accessible through Circle Mint or CCTP. From that point, redemption is manual. Two ways to migrate today: Skip:Go: the Noble to Injective route moves USDC.n to USDC.inj in one flow. The migration guide walks through it step by step, including the manual path. Osmosis transmuter: pool 3497 swaps USDC.n for USDC.inj 1:1 with no fee. How you can help: Holding USDC.n in a wallet? Migrate now, using either route above. Running a contract, a multisig or a treasury that holds USDC.n? Plan the migration this month, and reach out to @RoboMcGobo on Telegram if you need a hand. Running a chain that wants USDC.inj listed in Skip:Go? Keep IBC relayers running to Injective and open a PR on the chain registry . Skip:Go Maintenance on November 23: About Three Hours of Downtime from 02:00 UTC, and No Code Changes Needed Afterwards Skip:Go is moving to new infrastructure on Monday, November 23, starting at 02:00 UTC, with an expected duration of about three hours. During the window, all public prod.skip.money and skip.build endpoints return a 503, which covers the Skip Go API and go.skip.build. What to expect: Transfers submitted before the window keep processing on the current system until they complete. Data is backed up and moved , and the service reopens after final checks. No code changes are needed from integrators. After the migration, everything works as before, and the user experience stays the same. Some users may see 503s for a few more minutes afterwards, depending on their network, and the schedule may change. How you can help: Running an app on Skip:Go? Avoid scheduling releases or batch transfers in the window, and treat a 503 during it as the maintenance, not a failure to retry. Moving USDC.n that morning? Submit before 02:00 UTC, or wait until the service reopens. That’s all for this week That’s all for this week - thanks to everyone engaging across the forum, validator channels, and Telegram. Looking forward to next week’s update! Please let us know if you like the Weekly format, and what else you’d like to hear from us. Follow the Hub on X for updates Join the next monthly validator call: Wednesday, December 9, 9:00 AM ET, three weeks before the Q4 delegation snapshot on December 31 Join the next community call on X: Wednesday, November 25. Register for the community calendar here Link

forum.tezosagora.org: Upcoming changes in the development process of our teams working on software for the Tezos L1 blockchain and Etherlink<br /> This is a joint post from Nomadic Labs, Trilitech and Functori. TL;DR: AI agents have made finding and exploiting software vulnerabilities faster and cheaper than ever, across the whole software industry, not just blockchains. The same tools have also opened up new ways to check for bugs and defend against attacks, and we have leaned into this heavily. Over 2026, we have used AI to build a continuous audit process for our work on the Tezos L1 protocol and Etherlink, which has found and fixed several issues before they became a problem. But the rapid growth in the use of AI agents also raises the risk that public development branches and discussions may expose security flaws before fixes are deployed. To reduce that risk, as part of a broader strategy to evolve our engineering processes, we are moving our day-to-day development on Tezos L1 and Etherlink from their current upstream location to a private repository starting December 2, 2026 . Released source code will remain publicly available under the MIT license, and we are committed to improving the quality of any tools and documentation that we create to help enable anyone to submit protocol proposals through Tezos governance. 2026 has marked a turning point in how software gets built, for us and the rest of the industry. A few core engineers at Nomadic Labs, Trilitech and Functori had already been experimenting with tools like Claude Code and Codex during 2025. They had seen how transformative they could be with the right approach, and witnessed the rapid progress of the frontier models. Over the Christmas holidays, experimentation spread across our teams and by the time we returned to work in January, AI agents were no longer niche. Like everyone else, we had to figure out what that shift meant in practice . These tools have changed not only how we write code, but also how we review it, test it, and find bugs in it. One thing became very clear: their impact goes well beyond producing new software, and cybersecurity is the clearest example. The adversarial model has changed dramatically in 2026. LLMs and agentic tools have lowered the expertise required to find new 0-days , with close to no prior knowledge of the system being targeted. The whole software industry is feeling it. Mozilla reported around 20–30 security fixes per month for Firefox throughout 2025, rising to 423 in April 2026 . Starting July 2026, Cisco introduced twice-monthly security disclosure windows, seven-day advance notifications, and planned quarterly hardening updates for major network operating systems . Google’s Threat Intelligence Group recently published an article in which they outlined how adversaries are leveraging multi-agent systems and LLM-driven pipelines to automate labor-intensive phases of vulnerability analysis, chaining capabilities together to reduce the window between patch disclosure and weaponized exploitation. Similar examples keep piling up and there is even a term for describing this turbulent era: the Vulnpocalypse . The Tezos ecosystem is no exception. Over the course of 2026: S ix security upgrades were proposed and voted on by bakers on the Tezos L1 blockchain to address an ever-growing number of vulnerabilities. Most of these issues were threats to the liveness of the chain, but a few of them could have also put user funds at risk. We shipped four releases of the Octez node to address flaws that put the health of the Tezos L1 network at risk. As a consequence, we have had to invest significantly more engineering effort in addressing known (often still undisclosed) issues and proactively looking for new ones, to protect the chains and user assets. This shift in engineering focus is real, and it is here to stay. The Tezos bug bounty program , administered by the Tezos Foundation remains a valued source of community input on critical bugs. Yet models keep getting better. Safeguards implemented by frontier labs may not prevent every misuse. And new code keeps being written, bringing with it the possibility of new, increasingly subtle bugs with unexpected impact. As security work grows, our engineers already spend more of their time working in private, preparing fixes that cannot safely be disclosed before they are deployed. The August 2026 Cosmos EVM incident illustrates why coordinating publication with deployment matters: according to Cosmos Labs’ post-mortem , a public pull request described the vulnerability and its exploitation path less than twelve hours before the first known attack. Six networks were ultimately exploited, even though patched releases were already available. In addition, routine development can reveal sensitive information: a public branch fixing a seemingly harmless bug, or a discussion about the security of a future feature, can give an attacker a hint on a flaw in software already running on the network. Today, separating public development from private security work relies on every engineer recognising those implications before sharing a change or asking a question. That is why we have decided to move day-to-day development to a private git repository starting December 2, 2026. Concretely, this means core engineers at TriliTech, Nomadic Labs and Functori working on Tezos L1 and Etherlink will push, propose and discuss their changes in a private Gitlab repository. We will set up automated mirroring of the master branch, meaning that our changes will be made available as soon as they are approved and merged. This change will give us more control over when sensitive changes become public. The software we develop will remain open source under the MIT license. We are committed to improving our documentation and tooling so that anyone can participate fully in Tezos ecosystem governance, including reviewing our changes and submitting protocol proposals. We also continue to welcome external contributions through the public monorepo. Any security vulnerabilities discovered by the broader technical community should also continue to be submitted via the Tezos Foundation’s established bug bounty process. For almost a decade, the Tezos ecosystem has adapted to meet new realities. Security has been at the core of its design from the start, and systems built to last must be able to respond to threats their designers could not have anticipated. That now applies to how we develop it, too. The tools reshaping software security are not going away, and neither is our commitment to openness in what we ship. The Tezos L1 network and Etherlink are open source projects governed by the community. This change is about timing, not openness: it lets us fix problems before they are exposed, while ensuring these networks remain open source, auditable and governed by the community. Adaptability is a security quality, and it is one that has always characterised the Tezos protocol and its ecosystem. For our part, we will keep sharing what we learn as the industry adapts, and we welcome feedback from bakers, builders and contributors along the way. Link

gov.optimism.io: Security Council: Lead Election<br /> As outlined in the Security Council Charter , it is time to elect the Optimism Security Council Lead. The elected Lead will serve a 24 month term following the elcection. There is no limit to the number of terms a Lead may serve. Under the updated Security Council Charter, the Lead’s role has expanded. In addition to coordinating Council operations, the Lead is now responsible for recruiting and nominating the Security Council members, who are then confirmed by the Token House through a veto vote. Candidates should read the Lead Responsibilities section below before nominating. This thread explains the process. Candidates should not nominate themselves here - each candidate creates their own self-nomination thread , as described below. Lead Responsibilities The Council Lead coordinates the ongoing operations of the key holding Council participants. As stated in the Charter, the Lead is elected by the Token House and appoints the key holding participants, subject to confirmation veto by the Token House. The Lead’s role is procedural, communicative, and includes recruiting and nominating key holders. The Lead has no ability to directly influence the substantive signing decisions of key holders, and the Lead is not a key holder. The Lead is responsible for supporting the implementation and operationalization of the Council’s procedures, including by: Alerting key holders of upcoming protocol upgrade or role permissioning proposals going through Governance; Managing required timelines; Monitoring compliance with the procedures; Onboarding new Council participants; Recruiting and nominating key holding participants, and nominating replacements when seats become vacant; and Scheduling, setting agendas, and hosting Council meetings and facilitating discussions; Communicating with external stakeholders, including Optimism Governance, as to Council operations. Appointing key holders. The Lead nominates key holders by applying the Security Council Member Selection Criteria . In doing so, the Lead must: Conduct outreach to a pool of candidates broad enough to satisfy the composition requirements, keep a record of candidates considered, and provide a public method for anyone to apply; Interview each promising candidate and assess them against the candidate criteria; Submit each candidate for Foundation KYC/KYB screening before the nomination is posted; Decline to nominate any candidate whose seating would breach the composition requirements, who is associated with the Lead, or with whom the Lead has an undisclosed conflict; Publish an overall summary of the proposed cohort and the selection process used, including the number of applications and interviews. The composition requirements are: fewer participants residing in any one country than the quorum required for multisig action; at least 50% of participants not part of the Optimism Core Development teams; and no more than one participant associated with any one entity. Each Council Appointment proposal has a one-week review period followed by a one-week veto period. A vetoed nominee is not seated, and the Lead nominates a replacement. Budget: The Lead proposes Security Council operating budgets every 12 months, with the opportunity for a re-adjustment proposal after 6 months. The Council operates a dedicated budget multisig managed by the Lead, from which Council compensation is paid. Recipients must complete KYC/KYB before payment. Accountability: Like all Security Council participants, the Lead is subject to removal via the Representative Removal proposal type outlined in the Operating Manual . If the Lead is removed, a new Lead election is held. Eligibility Considerations The Lead may be an individual or an entity, and current and former Council participants may self-nominate. All nominees should be evaluated against the following criteria: Reputation: Known, trusted individuals or entities that have demonstrated consistent alignment with the Optimistic Vision. Technical competency: Baseline proficiency with the OP Stack and an understanding of the Council’s signing and key management procedures, sufficient to support the key holders. Alignment: No conflicts of interest that will regularly impact the ability to make impartial decisions in the role, such as affiliations with direct Optimism competitors or a proven history of exploiting projects or self-dealing. The Lead may not nominate candidates associated with the Lead and must disclose any conflicts. Recruiting and vetting capability: Ability to run a credible outreach and interview process to identify qualified, independent and geographically distributed key holders, and to document that process publicly. Ability to participate: The willingness and ability to actively fulfill the Lead responsibilities, including coordination around upgrade timelines and an on-call aspect during emergencies. Nominees should state the time they expect to commit. The Lead applies the composition requirements in the Member Selection Criteria when nominating key holders, and nominees should be comfortable being held to them. Compensation Because of the increased scope of the Security Council Lead role, the Foundation recommends adjusting the Security Council budget to reflect this added responsibility and workload. The Foundation recommends that the Lead receive at least 1.5x the compensation that key-holding Security Council members receive. Nomination Process Step 1: Create your self-nomination thread. Anyone meeting the eligibility criteria may self-nominate by creating a new thread in the Elections category with the title: Security Council Lead Self-Nomination: [Your name or entity] Use the template below. Please keep answers concise while conveying all relevant information. Self-nominations must be posted by Wednesday, November 25th at 19:00 GMT. Security Council Lead Self-Nomination Template Does this nomination represent an individual or an organization? Candidate country of residence (or, if an entity, incorporation and principal place of business): Have you previously served on Optimism’s Security Council? In what role? Relevant experience, including any non-Optimism experience you believe is relevant to this role: Technical background, including your GitHub handle: Experience relevant to the Lead responsibilities (coordination, operations, security procedures, communication, recruiting and vetting): Your approach to recruiting, interviewing, and nominating key holders, including how you would satisfy the Member Selection Criteria and the composition requirements: Expected time commitment and availability, including how you would handle on-call and emergency situations: Any potential conflicts of interest, including any relationships with potential key holders: Link to your delegate commitment or other public profile (optional): Your plans for the Security Council operating budget and your compensation (optional): Step 2: Collect four delegate approvals. For a nomination to move to a vote, four of the Top 100 delegates must give explicit approval on the nomination thread by Thursday, November 26th at 19:00 GMT. Delegates may not approve their own nomination. Delegates can signal approval by pasting the following comment: “I am an Optimism delegate [link to your delegate profile] with sufficient voting power and I believe this proposal is ready to move to a vote.” A delegate approval is not an endorsement. It simply signals that the delegate believes the nomination is ready to move to a vote. Nominees are encouraged to engage with delegate questions on their thread and to summarize any feedback they incorporate. Step 3: Vote. Nominations that receive four approvals by the deadline will appear on the ballot. The Foundation will post the final list of valid nominees in this thread. Voting The election will run from Thursday, November 26th to Wednesday, December 2nd at vote.optimism.io . It uses approval voting for a single seat: each delegate may cast their full voting power for as many nominees as they choose, and the nominee with the most votes is elected, provided the election meets quorum. Quorum is 30% of the active votable OP supply, as defined in the Operating Manual. After the Election Before joining the Council, the elected Lead must pass the Foundation’s eligibility screening. This process may include KYC/AML and sanctions screening and a requirement to sign a standard contract, implemented at the Foundation’s discretion. If an elected candidate declines the role or fails the screen, the next qualified runner-up to pass the screening will be offered the position. If there is no eligible Lead nominee, the Foundation may appoint one or take other administrative steps as necessary. Once seated, the Lead begins nominating key holding participants through Council Appointment proposals, as described above. Link

forum.pyth.network: [Pythian Council Election #6] Skyz — Pyth Network<br /> Name: SkyZ Solana wallet address: Eosu1qUYtAh2mBqvpjfRExTYumQoSNG3njLXDHjCssAj Ethereum wallet address: 0x58a2224bF105b4FAA0445F6297E78De89D88b9e2 Twitter: @ SkyZ_DIGITALIA Discord: djony0815 Current role & ecosystem: Chiron, VdM Continent: Europe Signing-key Custody: Tangem hardware wallet for both keys Motivation to participate in the Pythian Council: Joined Pyth community back in da days, when Pythenians were minting. Joined the Pyth Discord and snap my life changed. Would of never thought that community that lives on web 3 can do that to a human. I literally left everything i did back then in dug deep into what Pyth actually is and was stunned over and over what this will actually bring to the world of finance on chain /off chain, everywhere! From that moment my brains operate differently and i embrace only purple stuff and educating myself daily and try to cope with all the partnerships Pyth is bringing in… FIRE TEAM! I just want to dig even deeper and learn, expand knowledge and share this to other people; they need to know how big Pyth actually is and how importaint role is playin atm and how big role it will it play in the near / distance future! My approach is clear - Pyth is religion and my path is to preach it worldwide. I am involved in all Pyth fields like forum, staking, pythentity, pythenians, … So adding Council will evolve my brain even further and im always 100% in it to bring it. I basically live in the Pyth Temple and community is near me everyday so the voice of it will be heared and as a long time staker i will lead in guide new people to join and contribute to the eco via DAO. Relevant Experience: In my track record i went throu many roles but my current ones are Chiron & Community Jannie. That reveals my obsession and devotion to Pyth eco. Im Daily involved in the community and actively helping members to grow and expand their horizons. Basically live in the Pyth DC everyday for few years now and i just cant start/ end a day without checking Pyth Discord. As a Pyth staker and DAO voter i always check out why, when and for what are the Eco updates, new integrations, partnerships,… i just love to learn this and my brain is forever hungry for more so they can later on share this and try to help others to understand how big things really are. TY Link

talk.nervos.org: Spark Program | CKB script regression fixtures: reproducible tests for review findings<br /> Applicant: it44 · GitHub: agentcontrolmap/ckb-script-fixtures (public repo; links will follow in a reply once the forum allows them) · Contact: replies in this thread Funding requested: $600 USD equivalent, paid in USDI · Duration: 4 weeks · License: MIT 1. What this is Open-source test fixtures (Rust, ckb-testtool, runnable with cargo test ) that turn review findings about CKB scripts into executable, reproducible checks: a “naive” version that accepts the bad transaction and a “hardened” version that rejects it, so a maintainer sees the issue and the fix in one run. Not a scanner, not an audit, not a new security framework. 2. Existing work (not requested for funding) Escrow review, five points (group inputs, refund/release race, fee burn on permissionless refund, minimum-capacity remainder, terms not validated at creation): my post #2 in the “Spark Program | CKB Escrow Security Test Kit” topic (topic 11150). Public repo agentcontrolmap/ckb-script-fixtures with the first fixtures already in place (seven scenarios on a toy escrow lock, naive vs hardened; the README lists what they do NOT show). CI passes on a clean checkout: workflow run #3 in the repo’s Actions tab. Price-feed question (upper bound on the update timestamp): my post #3 in the “Asset Price Oracle on Nervos Network” topic (topic 10800). The maintainer’s reply (post #5 ) agrees the scenario is valid for the deployed price_feed_type and says an on-chain bound is worth investigating. 3. Deliverables (4 weeks) M1 (week 1): minimum-capacity remainder fixture on a local dev chain, plus CI on the repo as it stands. Acceptance: clean checkout, cargo test passes, README says what each fixture shows and does NOT show. M2 (week 2): fixture for the feed-timestamp scenario against a local copy of the logic, only if public source allows a standalone reproduction; otherwise publish why and the exact missing input. M3 (week 3): the same method on ONE further public CKB script with its owner’s consent; negative results published too. M4 (week 4): final report: planned vs done, limitations, owner feedback if given. 4. Budget M1 remaining work $100 · M2 $200 · M3 $200 · M4 report $100. Total $600. The fixtures already published are not charged. No recurring costs. 5. Verification Everything is reproducible from a clean checkout; every claim in the report is tagged as run, read-only, or unverified. Weekly updates in this thread. 6. Risks Owners may not engage (then published as independent work, disclosed); fixtures show the behaviour of the code given, not an audit or guarantee; scope limited to the listed scripts. A negative result is still reported. Link

talk.nervos.org: CKB Mixer(混币器)——Tornado Cash on CKb<br /> 过去一段时间用AI做了一个小项目,现在整条链路已经在 CKB 公共测试网上跑通了,发出来给有兴趣的人看。 一句话: 用 Groth16 + Poseidon Merkle 树在 CKB 上实现了「存款 → 零知识证明 → 匿名取款」,所有验证逻辑写在真实的 CKB-VM 脚本里,能上链、能取钱;另外做了一个存款意向 + 聚合者的 v2,以及一个浏览器里就能用的网页 demo。 代码: https://github.com/tianlitao/ckb-mixer 线上 demo(仅测试网): https://ckb-mixer.nervosscan.com/ 为什么这件事在 CKB 上值得单独做一遍 Tornado Cash 在 EVM 上靠合约存储「这张 commitment 已经用过了」,CKB 的 cell 模型没有便宜的链上 map。但反过来,CKB 给了两个在 EVM 上不可能的结构性好处: 链上不需要存 Merkle 树。 池子 cell 里只有 1,640 字节状态:30 个历史根、20 层 frontier、nullifier 集合的根。树由脚本按 frontier 增量维护,存款时约 20 次 Poseidon。 取款交易不需要任何签名。 收款地址和手续费被电路绑进证明,交易只有 1 个输入(池子 cell)、2 个输出。没有中继者也能上链,也没人能把收款人换成自己——这一点在 EVM 上必须靠 relayer 合约配合才成立。 代价也很 CKB: 所有池子共用一个 cell,任何存款/取款都得花它 。Tornado 的每笔交易独立、可并行;这里是个单点。这正是 v2 要解决的问题(通过聚合器和意图cell)。 一、它怎么工作 一个池子就是一个 cell: 部分 内容 type 池子脚本,args = 面额 ‖ 验证密钥 cell 的 data hash ‖ 池子 lock 的 code hash / hash type lock 池子 lock,逻辑是「这个 cell 必须带池子 type script」—— 没有私钥 ,谁也没法把池子锁死 data 1,640 字节池子状态: next_index ‖ root_pos ‖ 30 个历史根 ‖ 20 层 frontier ‖ nullifier 集合根 存款 :commitment 写在 witness 里,脚本用 frontier 把它追加进 depth-20 的 Poseidon 树,并要求输出 cell 的 data 逐字节等于新状态、capacity 恰好 输入 + 面额 。一笔交易只记录一个新根,所以证明在之后 30 笔存款交易内都有效。 取款 :脚本依次检查根在历史里 → 收款 cell 必须是池子之后的那个输出、无 type 无 data、capacity 恰好 面额 − fee → 把 nullifierHash 插进 256 层稀疏 Merkle 树(要求「插入前」的根等于当前集合根)→ 用链上的验证密钥 cell 验证 Groth16。 电路 (5,322 约束,4 个公开输入): commitment = Poseidon(nullifier, secret) , nullifierHash = Poseidon(nullifier, index) 。 nullifier 绑定了叶子下标 ,所以同一个 commitment 存两次会有两个不同的 nullifierHash、两笔都能取——链上没有「commitment 已用」表也能防重复花。 nullifier 集合 用自研的 256 层 SMT:每层一次 blake2b,证明是 32 字节 bitmap + 非空兄弟。取款时约 1.96M cycles。 二、一次取款要多少 cycles 默认构建(opt-level 3),本地 ckb-testtool ,多次运行波动 < 0.2%: 阶段 cycles 占比 Groth16 验证 约 67.4M 97% nullifier 集合(256 层 blake2b) 约 1.96M 2.8% VM 启动 + 加载 276 KB 脚本 70,722 0.1% 读状态 / 收款检查 / 输出比对 约 86k 0.1% 合计 约 69.4M–69.5M 单块上限的 2% 存款约 8.4M(0.24%),其中 8.25M 是 20 次 Poseidon。批量存款每多一笔约 +0.4M。 编译档位的取舍 很值得一说。 opt-level = z 把二进制缩小 2.3 倍,但 cycles 反而多 47%: 变体 pool-type 体积 部署锁仓 存款 ×1 取款 default(opt 3) 276,640 B 27.7 万 CKB 8.40M 69.4M size(opt z) 121,400 B 12.1 万 CKB 11.26M 102.3M bext(opt 3 + 位扩展指令) 269,936 B 27.0 万 CKB 8.31M 68.6M 1 字节占 1 CKB,部署一次所有池子共用;但 size 档每笔取款要多花约 3300 万 cycles,并且越过节点默认的 max_tx_verify_cycles = 70M (默认档的 69.4M 也只比它低不到 1%,电路一改就可能越界)。 三、测试网上实测 2026-11-17 与 11-18 在 ckb_testnet (公共节点 testnet.ckb.dev )上跑了两轮。上链的是 size 构建 (水龙头每个地址只给 30 万 CKB,default 构建光部署就要 29.7 万): 项目 结果 部署(验证密钥 + 两个脚本) 141,614 字节,14.1 万 CKB 永久锁定 建池 面额 100 CKB,池子 cell 永久占 1,819 CKB v1 跑完 5 笔存款 / 5 笔取款,取款约 1.025 亿 cycles ,12–23 秒出块 超过 70M 能不能上链 能。 五笔 1.025 亿的取款交给公共节点后都正常打包 链上 vs 本地 cycles 相差 0.2%–0.5% 同块连发 一笔存款 + 两笔取款首尾相接(每笔花前一笔尚未上链的输出), 三笔进了同一个块 对抗性 dry-run 重放、改收款人、抬 fee、少付、直接花池子、付一份钱存两个 commitment……6 种全部被拒,退出码符合预期 链上历史还能完整重放:工具每次运行都从建池交易沿池子 cell 的血缘读回全部交易,用同一个 mixer-core 重新执行,得到的 1,640 字节状态和 capacity 与链上 cell 逐字节一致 ,否则不往下做。 四、v2:把存款人的签名和池子 cell 解耦 v1 最大的现实问题是:存款人的 sighash 签名覆盖了「花的是哪一个池子 cell」,前面插进一笔交易,这笔存款就得重签。v2 做了三处改动: 改动 解决什么 存款意向 cell :用户把「面额 + 小费」锁进一个带 commitment 的 cell,不碰池子 存款不再和任何人抢 cell,签一次名就结束 批量 action :一笔池子交易处理任意多个意向 + 任意多笔取款 一次花池子 cell 办完很多人的事 池子 Type ID 意向 cell 必须能唯一指名「哪个池子」 取款本来就没有签名,证明只绑定 root、收款人、fee——所以一笔取款天然就是一条链下消息,谁拿到都能装进自己构造的交易里。于是多了一个 不需要许可、不需要押金 的角色:聚合者。它收集链上意向和链下取款消息,拼成批次,赚小费和 fee;偷不了钱、改不了收款人,最坏只是不干活。 flowchart LR A[用户 A 签名] --> IA[意向 cell A] B[用户 B 签名] --> IB[意向 cell B] C[用户 C:链下取款消息] --> AG D[用户 D:链下取款消息] --> AG IA --> AG[聚合者拼批次] IB --> AG AG --> P[池子 cell 新状态] AG --> RC[收款 cell C] AG --> RD[收款 cell D] v2 同样在测试网上跑过(2026-11-18,55 笔存款、55 笔取款,size 构建): 批次 链上 cycles 占块上限 出块 8 笔取款 8.23 亿 23.5% 15 s 16 笔取款 16.42 亿 46.9% 24 s 20 笔取款 20.54 亿 58.7% 14 s 大交易和小交易一样在十几到二十几秒内出块;本地测得上限是 50 笔(默认构建)/ 34 笔(size),受限于资金,链上只试到 20 笔。 手续费按 权重 收,不按字节: max(字节数, cycles × 597,000 / 3.5G) 。20 笔取款的交易只有 13.6 KB,权重约 350 KB,按 5,000 shannons/KB 付 0.0175 CKB——聚合者从 20 笔里收 0.2 CKB,依然划算。 撤回受共识保护 :意向建好立刻撤回,节点回 Immature ;过了 6 个块同一笔交易上链。 两个聚合者抢同一批意向 (真的发出去):先到的批次手续费 13,315 shannons,对手出 13,315、15,978 都被拒( expect it to >= 17309 ),出 18,641 后被接受并上链,先到的被标 RBFRejected 。规则与节点源码一致。 五、网页 demo 在 v2 之上做了一个纯静态页面 + 一个 Cloudflare Worker 聚合者: 页面: https://ckb-mixer.nervosscan.com/ (中 / 英双语) 用 CCC 官方的 <ccc-connector> 连钱包;存款签一次名就留下「回执」; 取款证明在浏览器里生成(约 1 秒) ,消息交给聚合者,或者点「自己发送(保底)」(不需要签名、不需要事先有 CKB)。 页面和聚合者都从建池交易起重放池子全部交易,与链上 cell 逐字节比对;票据的两张随机数只存在浏览器 localStorage 里。 聚合者每分钟一次 cron,把等着的意向和收到的取款拼成批次; GET /info 能看到它的地址和参数。 截至 2026-11-19:池子 2,250 CKB,61 笔存款、59 笔取款、2 笔未取 ,重放结果与链上 cell 一致。线上 cron 已经真的打包过带取款的批次。 Link

talk.nervos.org: [DIS] CKB Productathon: Ship on CKB (Kisumu, Kenya)<br /> Lead and community links FidelCoder – Blockchain Educator & Developer FidelCoder is a distinguished blockchain expert and community leader in Africa, renowned for designing scalable decentralized systems. As an educator, he excels at demystifying complex blockchain concepts, guiding learners through building protocols and decentralized applications (DApps) with clarity and precision. His hands-on approach and deep technical knowledge make him a pivotal force in equipping participants with the skills to innovate on CKB Productathon, amplifying the program’s technical impact. X: https://x.com/GriffinOduol LinkedIn: https://www.linkedin.com/in/griffins-oduol-a138b11b4/ GitHub: https://github.com/FidelCoder Umojaverse X: https://x.com/Umojaverse Website: umojaverse.xyz LinkedIn: https://www.linkedin.com/company/umojaversepeeps/posts/?viewAsMember=true Instagram: https://www.instagram.com/umojaversepeeps/ Summary Umojaverse is an Africa-focused builder community that brings blockchain, web3 and general tech together from the grassroots and across borders, so people learn and build products of real value. Through campus tours, ideathons, workshops and hackerhouses, it takes people from first curiosity to working prototypes. The CKB Productathon is a competitive programme in Kenya that turns builders into teams with live products on CKB mainnet. It runs in two parts. The first is virtual: expert-led training on CKB technology and on building a startup, while teams ship and gather real users. The second is a two-day physical hackerhouse on the shore of Lake Victoria, where teams that have gone live build, demo and pitch for prizes. Teams with a working product and teams with a new idea and a credible execution plan can both apply, and the aim is the same: products that ship, win user validation and keep growing. Ask: $10,925 for the full programme, from planning to follow-up. Timeline (tentative): planning in December 2026, programme from January to early February 2027, follow-up support until mid-March 2027. Teams: up to 15 teams of three at the hackerhouse. The rule: only teams live on CKB mainnet can enter the hackerhouse, and to win a prize a team must show on-chain activity from at least 5 beta users. Why this is needed, why Umojaverse, why now Why it is needed. Kenya has talented builders and no shortage of events, but too few of them ship products that real users depend on. Workshops and ideathons tend to end at the idea or the demo, and the hard part that follows has little support: deploying to mainnet, finding the first users and keeping the product running. Three gaps hold builders back. There is no structured path from a first contract to a mainnet product. Mentors who have shipped and found users are scarce and hard to reach outside the big cities. And builders work alone, without a room of peers building beside them to share fixes, pressure and momentum. CKB makes this gap worth closing. Its cell model, RISC-V based virtual machine and flexible scripts let builders create their own product logic, not just move tokens, but that flexibility is hard to learn alone. Guided, hands-on training turns it into an advantage, and every product that goes live on mainnet with real users is lasting proof of adoption for the ecosystem. Making live mainnet use the measure of success changes the incentive: builders are rewarded for shipping and getting users, not for attending. Why Umojaverse. Umojaverse is a builder community, not a one-off event organiser, and this programme is the next step of work we already do. We take builders from first curiosity to working prototypes through campus tours, ideathons, workshops and hackerhouses, in person across Kenya and, through the Pulse East Africa HackFest, in five African countries. That gives this programme five things it needs: Reach. An established builder community and presence across Kenya and wider Africa, so the open call draws serious applicants. Proven delivery. Experience running multi-day, in-person hackerhouses and multi-country events, from venues and logistics to mentors, judging and content. Teaching depth. A lead organiser who is a blockchain educator and developer, backed by a network of seasoned builders to teach, mentor and judge. A CKB footing. We are already introducing Kenyan builders to CKB, and we know the questions they ask and where they get stuck. Follow-through. We stay with builders after the event, through follow-up support and public recordings that keep teaching long after the programme ends. This means we can run the programme end to end: recruit the teams, teach them, bring them together, showcase them and keep supporting them. Why now. Three things line up. First, the tools are ready: builder tooling such as CCC and OffCKB makes it practical to go from a first script to a mainnet deployment inside a short programme. Second, builder attention in Kenya is warm and will cool without a concrete next step. Recent CKB activity needs a destination with a deadline, prizes and a place to build. Third, the calendar works: planning in December and a January start use the weeks after the holidays, and teams that ship to mainnet by early February get months of real use to prove adoption before mid-year. A month of follow-up support then turns a weekend of building into traction. Previous work Umojaverse has run builder programmes across Kenya, from first workshops to hackerhouses. Five pieces of work matter most for this proposal. Campus builder programme. Visited five Kenyan universities and reached 503 developers. They produced 104 project ideas, and 23 submissions reached the hackerhouse. It showed us that the drop-off after ideas is the real problem, which this programme targets. Pulse East Africa HackFest. Held in Kenya, Ethiopia, Rwanda, South Africa and Uganda, with at least 90 participants in each country. CKB Builders Workshop, Kisumu (16 October 2026). 70 RSVPs, 37 attendees and about 11 builders with laptops ready to build. Anything and Everything CKB X Space (14 November 2026). A public session with CKB builders and community members, where the community’s interest in building on CKB showed. Community. Ongoing builder community across Kenya and wider Africa through Umojaverse’s X account, events and campus presence. What these taught us. Attendance does not predict shipping, so the programme rewards on-chain proof of use. People who build together ship more, so the programme includes a physical hackerhouse. Builders also need practical guidance on getting users, so half of the sessions teach startup building. Proof of work. Photos from these events and the HackFest, Google Drive: https://drive.google.com/drive/folders/1HVpd353eCFPX03cG4GNJ7vjgIAd_5eds?usp=sharing and https://drive.google.com/drive/folders/1p_EuYRvLQ3Tv2KaML4FUilUVn3t1Hm9S CKB Builders Workshop: https://talk.nervos.org/t/ckb-builders-workshop-in-kisumu-37-people-showed-up-ready-to-learn-and-build/11012 Anything & Everything CKB, space announcement: https://talk.nervos.org/t/anything-everything-ckb-join-our-upcoming-x-space/11091 Anything & Everything CKB, X Space recording: https://x.com/Umojaverse/status/2121649307493265551?a=JoiiD3lF_6fF0H2ZhPU&s=20 More X posts and validation material: [links, to be added] Programme format and execution flow The programme has two parts: a virtual phase, where teams learn and ship to mainnet, and a two-day physical hackerhouse for the teams that make it. The timeline below is tentative and may shift as planning firms up. Plan, open call and selection (December 2026). Curriculum, instructors, venue and partners are confirmed. The open call (14 to 27 December) takes live products and strong plans, and selected teams are announced on Monday 4 January. Virtual phase (9 to 26 January). Starts five days after acceptance. Eight sessions, two a day over four days across three weeks: Saturday 9, Tuesday 12, Tuesday 19 and Tuesday 26 January. Up to 30 teams ship to mainnet. Mainnet submission (27 to 28 January). Two extra days to deploy to mainnet and submit. Beta testers are not required yet. Review and acceptance (29 to 31 January). Two days of review, then hackerhouse teams are announced on Sunday 31 January. Preparation and travel (1 to 5 February). Four days to gather beta users and prepare, with travel on Friday 5 February. Hackerhouse by Lake Victoria (Saturday 6 to Sunday 7 February). Up to 15 teams, with pitches and prizes. Follow-up month (8 February to 12 March). Mentor support, a 30-day live check and a closing showcase. Final report (by Wednesday 24 March). The programme has three gates: Selection: a live product or a strong execution plan. Mainnet gate (28 January): the product is deployed on CKB mainnet to enter the hackerhouse. Prize gate (7 February): on-chain activity from at least 5 beta users, shown at the demos. Winners are named, and the 30-day check follows. Applications, selection and the mainnet gate Who can apply. Teams of up to three builders based in Kenya. The programme does not target existing products only. Live products and new ideas are both accepted, provided a new idea comes with a credible plan to execute. The aim for every team is a product that ships, earns user validation and grows into real adoption. How applications are scored. Up to 30 teams are admitted to the virtual phase. Applications are scored on execution evidence (30), CKB integration (25), user and problem (20), team (15) and reuse and impact (10). A live product with early users scores well on execution evidence, and a new idea needs a clear build plan and a team able to carry it out. The mainnet gate and prize rule. To enter the hackerhouse, a team must have deployed its product to CKB mainnet and submitted it by Thursday 28 January. Beta testers are not required at that point. To win a prize, a team must prove on-chain activity from at least 5 distinct beta users who actually use the product, not team members testing themselves. The organisers verify this with transaction links and tester confirmation. If more than 15 teams qualify, places go by application score and the strength of the live product. Virtual sessions Eight sessions run two a day over four days. The four startup sessions, on how to build and grow a startup, run from 12:00 to 14:00 EAT, and the four technical CKB sessions run in the evening from 18:00 EAT. Instructors are seasoned builders who have shipped products. Saturday 9 January. Startup session, 12:00 to 14:00: from idea to a validated problem. Technical session, evening: CKB fundamentals, covering cells, scripts and the CKB-VM. Tuesday 12 January. Startup session, 12:00 to 14:00: finding and recruiting your first beta testers. Technical session, evening: building with CCC and OffCKB. Tuesday 19 January. Startup session, 12:00 to 14:00: metrics, feedback and iteration. Technical session, evening: deploying to mainnet, wallets and user experience. Tuesday 26 January. Startup session, 12:00 to 14:00: pitching and demo preparation. Technical session, evening: security and advanced patterns. Weekly mentor office hours support teams between sessions. Every virtual session is recorded and added to the Umojaverse YouTube channel as a CKB learning resource, and the sessions held during the physical phase are added too. Hackerhouse, judging and prizes Up to 15 teams of three gather at a hackerhouse on the shore of Lake Victoria for two days. Day 1, Saturday 6 February. Arrival, kickoff and a full day of building, with mentor rounds and an evening checkpoint. Day 2, Sunday 7 February. Final polish, demos and pitches, judging, results and prizes. Judging. A panel of at least three judges drawn from experienced builders, the CKB ecosystem and startup practitioners. Teams are scored on live product and real use (30), CKB integration (25), user and problem (20), pitch and team (15) and reuse and impact (10). Prizes. Four awards totalling $4,000: first place $1,500, second $1,000, third $800 and fourth $700. Only teams with on-chain activity from at least 5 beta users are eligible. Prizes are paid in full once the hackerhouse results are verified. Team videos. Every team at the hackerhouse gets a neat 3-minute video: 1.5 minutes of short pitch or explainer from the team, then 1.5 minutes showing the product flow, edited into one. The videos are published on X, YouTube and TikTok to win distribution, and show both the founders and the product. We expect about 15 videos. Follow-up month From 8 February to 12 March, hackerhouse builders get continued support to keep shipping: Weekly clinics for product, technical and user-growth questions. A mentor session with experienced builders. Introductions to funders and ecosystem programmes. A 30-day live check on Tuesday 9 March to confirm products are still live and in use. A closing X Space on Friday 12 March where teams showcase their progress. Budget and payment The programme costs $10,925: $4,000 for prizes and $6,925 for operations, set out below. Prizes: $4,000 Instructors (8 sessions at $100): $800 Hackerhouse mentors and judges: $500 Meals and refreshments: $1,200 Travel support for hackerhouse teams: $700 Accommodation for the two hackerhouse days: $1,500 Lake-shore house hire, power, internet and audio-visual equipment: $200 Organising and coordination: $700 Follow-up support: $400 Media and promotion: $525 Photographer and videographer for the two days: $400 Distribution and promotion on X, YouTube and TikTok: $125 Branding and merchandise: $400 Total: $10925 Instructor and mentor fees reward the expertise that moves teams to mainnet, and travel support and shared accommodation make sure cost does not keep strong teams away, and the team videos give every founder and product lasting distribution. Progress is posted on Nervos Talk after each milestone: planning and open call, virtual phase complete, hackerhouse results, and the final report. Success metrics Success is measured by live products, not attendance: 30 or more applications. 20 to 30 teams admitted to the virtual phase. 10 to 15 teams deployed on mainnet and admitted to the hackerhouse. 50 to 75 beta users with verified on-chain activity across teams. 10 to 15 teams demoing at the hackerhouse. At least 80% of hackerhouse products still live at the 30-day check. All eight virtual sessions and the hackerhouse sessions published on YouTube. Builder write-ups and a final report. 15 team videos published on X, YouTube and TikTok. Team and asks Umojaverse is the host ( @Umojaverse ), with FidelCoder as lead organiser. The hackerhouse is held at a hackerhouse on the shore of Lake Victoria, and instructors are seasoned builders recruited for the programme. We ask the CKB ecosystem for more than funding. Each of these makes the programme stronger: Funding. $10,925 to run the full programme, as set out in the budget. Technical instructors. At least two CKB engineers or developer-relations team members to teach or co-teach the technical sessions. A named technical contact. One person who answers builders’ questions during the virtual phase and the hackerhouse. Judges. Two judges from the CKB ecosystem for the hackerhouse panel. Introductions. Warm introductions for winning teams to ecosystem programmes, funders and partners. Amplification. Sharing the open call and the session recordings through ecosystem channels, so the learning resources reach more builders. Link

talk.nervos.org: DAO提案公平性疑问?<br /> 假设,我有50个账户,其中一些账户买了一些金额的ckb,锁定后具备投票资格,那么是否可以发起一个提案,用其中一些账户点赞,再投票,然后盗取DAO资金?,如果50个账户是我的50个朋友呢?或者其他可能性。,那么是不是DAO可以被以这样的方式随意推动提案成功并盗取资金? Link

forum.gnosis.io: Zodiac Reality Module on the legacy Safe: Invalid or No?<br /> On 17 November a proposal that does not exist on Snapshot was submitted to the Reality module of GnosisDAO’s legacy Safe . The id in the question is gnosis-dao-old-treasury-full-sweep-i3081 , and Snapshot has no proposal with that id . Open the question on Reality.eth What happened (UTC) 17 Nov 07:01: the asker answered Yes with 100 GNO ( transaction ). 17 Nov 07:54: another wallet answered Invalid with 200 GNO ( transaction ). 18 Nov 13:32: I answered No with 400 GNO ( transaction ). It becomes final on 20 Nov 13:32 unless someone answers with 800 GNO. Why the answer is No The daorequirements record on gnosis.eth points to the GnosisDAO Proposal Acceptance Criteria . They list seven conditions for Yes and one case for Invalid. They say all other cases resolve to No. A proposal that was never on Snapshot is one of the other cases. Step by step, with every source linked: https://why-the-answer-is-no.pages.dev/ Two things for the DAO to fix Questions from this module have no working arbitrator, so the largest bond decides, whatever the criteria say. The minimum bond is 100 GNO and every answer doubles it. Correcting a wrong answer costs 400, then 800, then 1,600 GNO. With Kleros named as arbitrator and a lower minimum bond, anyone could ask jurors to rule for a court fee, and a bigger bond would no longer decide. If the bond is raised If someone answers Invalid with 800 GNO, the first No at 1,600 GNO earns 23.75% in 48 hours if it stands. A Reality.eth bond can be lost in full. Disclosure: I hold the 400 GNO No answer and gain 292.5 GNO if it stands. Link

talk.nervos.org: RFC draft: Lock Proof, proving control of a CKB lock<br /> We would like feedback on an RFC draft before opening it in nervosnetwork/rfcs. It came up in the review of ckb-devrel/ccc#641. What it does. A site asks a wallet to prove it controls a lock. The wallet signs a transaction that can never be committed: one input at an out point no transaction can create, one output under the lock holding the site’s message. The site rebuilds that transaction, resolves the input itself and runs the lock in CKB-VM. If the lock accepts, the key controls the lock. It is BIP-322 adapted to CKB. Why. A verifier for one signature scheme cannot check a passkey lock, a multisig, an Omnilock in a foreign chain’s mode or a smart account. Running the lock checks all of them with one verifier, and every wallet can sign it with the code it already has. What is tested. 17 signed proofs, replayed by the reference test suite: secp256k1, JoyID main key and sub key (signed in the JoyID app), multisig, anyone-can-pay, Omnilock (Dogecoin, Ethereum, Bitcoin modes), PW-lock, Nostr, the quantum-resistant lock, a smart-account lock. Four of them on mainnet. Questions for you. Standards Track or Informational? Is there a lock you use that this would not cover? The draft lists what it does not cover (relative time locks, locks that need two inputs, locks that do not sign the transaction hash). Wallet authors: would you show a proof as a sign-in request, as the draft suggests? Reference implementation: GitHub - LusoCryptoLabs/ckb-ward: Ward: lock proof for CKB. Prove control of any CKB lock with a proof transaction that can never land on chain. · GitHub (npm ckb-ward ) Draft: Lock Proof, Proving Control of a CKB Lock Category: Standards Track. Status: Proposal. Abstract This RFC defines a way to prove, off chain, that the holder of a key controls a CKB lock script, for any lock that signs the transaction hash. The prover signs a transaction that can never be committed: its only input points at an out point no transaction can create, and its only output, under the claimed lock, holds a message written by the party that asks. The verifier rebuilds that transaction from the lock and the message, resolves the input itself, and runs the lock in CKB-VM. If the lock accepts, the key controls the lock. Nothing moves on chain. It follows BIP-322 (generic signed message format for Bitcoin) and serves the purpose EIP-1271 serves for Ethereum contract accounts. Motivation A service sometimes needs to know that the person behind one of its accounts controls a CKB lock. A governance site, for example, counts the Nervos DAO deposits under a lock as that account’s voting weight. On CKB a lock is a program. A verifier that checks one signature scheme (secp256k1 with a known message prefix) cannot check a passkey lock, a multisig, an Omnilock in a foreign chain’s mode or a smart-account lock. Each new lock would need new verifier code and new wallet code, and locks that have no message signing at all could never be counted. Every wallet can already sign a transaction that spends a cell under its lock. If the proof is such a transaction, every wallet can produce one with the code it has, and one verifier, which runs the lock as the node would, handles every lock. Specification The key words “MUST”, “MUST NOT”, “SHOULD”, “SHOULD NOT” and “MAY” are to be interpreted as described in RFC 2119. Terms ckbhash : BLAKE2b-256 with personalization ckb-default-hash . lock hash : ckbhash of the molecule-serialized Script . prover : the holder of the key, and their wallet. platform : the service that asks for the proof, issues the message and runs the verifier. binding : a platform’s record that links a lock to one of its accounts. Message The platform writes the message. It is UTF-8, lines separated by a single LF (0x0a), no trailing LF, at most 1024 bytes, exactly six lines: {domain} wants you to prove control of a CKB lock. Account: {account} Lock hash: {lock hash} Chain: {chain} Issued at: {issued at} Nonce: {nonce} Field Format domain host name of the platform, optional :port ; letters, digits, . and - account 1 to 256 printable ASCII characters (0x20 to 0x7e), no space at either end lock hash 0x and 64 lowercase hex digits: the lock hash of the claimed lock chain 0x and 64 lowercase hex digits: the genesis block hash of the chain issued at RFC 3339 in UTC with Z , optional fraction of a second nonce 1 to 128 characters from A-Z a-z 0-9 . _ ~ - , at least 64 random bits Mainnet genesis: 0x92b197aa1fba0f63633922c61c92375c9c074a93e85963554f5499fe1450d0e5 . Testnet genesis: 0x10639e0895502b5688a6be8cf69460d76541bfa4821629d86d62ba0aae3f9606 . Proof transaction TAG = "CKB lock proof v1\n" (18 bytes, ASCII, ends with LF) P = ckbhash(TAG || lock hash || message) (lock hash as 32 raw bytes, message as UTF-8) n = byte length of the message s = occupied size of the claimed lock (32 of code hash, 1 of hash type, its args) Field Value version 0 cell_deps what the lock needs, chosen by the wallet header_deps what a header-reading lock needs, chosen by the wallet, usually none inputs exactly one: previous_output = { tx_hash: P, index: 0xffffffff } , since = 0 or a value the wallet sets to satisfy a matured absolute time lock outputs exactly one: lock = the claimed lock, capacity = (8 + s + n) * 10^8 shannons, no type outputs_data exactly one: the message bytes witnesses exactly one: what the lock needs, as the wallet writes it The verifier resolves the input to the cell { capacity: 0xffffffffffffffff, lock: the claimed lock, type: none, data: empty } . The prover never supplies it. A wallet signs the proof as it would any transaction spending a cell under the lock. A wallet that receives the transaction without the input cell MUST rebuild it from the transaction: capacity u64::MAX, the lock of the only output, no type, empty data. It MUST NOT look the input up on chain, since it does not exist. Verification Input: the claimed lock L, the message M, the signed transaction T, and the platform’s expectation E: the exact message it issued for this nonce, its domain, the account, the nonce, the chain’s genesis hash from its own configuration, and an age window. A node error means “could not verify”, not “refused”. Steps 1 to 7 read nothing from the chain. Refuse when any field of E is missing. Parse M. Refuse when it is not the six lines above. Refuse unless M equals E’s message byte for byte. Refuse unless the lock hash line equals the lock hash of L. Refuse when L is a lock an administrator can open (see Security considerations). Refuse unless the domain, account, nonce and chain lines equal E’s, now - issued at is within E’s window, and issued at is at most 60 seconds ahead of now . Refuse unless T has exactly one witness and is within the limits below. Build the transaction of the previous section from (L, M), copy T’s cell deps, header deps and the input’s since into it, and refuse unless its transaction hash equals T’s. Mark the nonce used. Refuse when it was already used. Refuse unless the node’s genesis hash equals E’s chain. Read every cell dep of T from the node as a live cell. Count the cells each dep group lists, from its data, and refuse when all groups together list more than 32, before reading any member; then read each member as a live cell. Refuse when any cell is not live. Read each header dep from the node; refuse when one is unknown. Run the lock script group of input 0 in CKB-VM with T, the resolved input, deps and headers, under a cycle limit. Refuse unless it exits 0. Probe for exclusive control. Run the lock again on (a) T with its witness replaced by an empty one, and (b) the transaction built from M with a fresh random nonce, with T’s cell deps and T’s witness. Refuse when either exits 0. Accept. Return the out points read in step 10. The VM SHOULD be the node’s own script verifier under the chain’s consensus at the current epoch, so that the VM version, syscalls and hash_type resolution match what the node does for a real spend. Node RPCs such as test_tx_pool_accept cannot do this check: they refuse the transaction before any script runs, because the input does not exist. Limits Limit Value cell deps listed 16, no out point twice cells listed by all dep groups together 32, counted from the groups’ data before any member is read header deps 8 transaction size in a block 597,000 bytes (the consensus block limit) witness 65,536 bytes; a verifier MAY raise it for a lock with larger signatures message 1,024 bytes each chain read a timeout each lock run a cycle limit Platform requirements A verifier only says that a lock accepted one transaction. A platform that counts anything from a binding MUST also: Write the message itself, store the exact text per nonce, and compare byte for byte. It MUST NOT rebuild the message from the proof. Issue each nonce for one account and one lock hash, and mark it used with a compare-and-set no later than the first chain read. Take the genesis hash from its configuration, never from the message or the node. Keep at most one active binding per lock hash. Moving a binding to another account notifies the previous one, and the moved binding counts only after a cooldown. When counting weight, read it at one snapshot block for every account, and count a binding only if it was made before that block and every cell dep its proof used was still live at that block. For the Nervos DAO, count deposits only (data of 8 zero bytes), found by the exact lock script. Wallet behaviour A wallet SHOULD recognise a proof: a transaction equal to the proof transaction for one of its locks and the message in its only output, cell deps, header deps, since and witness aside. It SHOULD then show a sign-in request rather than a transfer: the domain next to the origin of the site that asks, with a warning when they differ, the account and the chain. It SHOULD NOT show the input’s capacity as an amount: nothing leaves the account. Rationale Index 0xffffffff. No transaction can have 2^32 - 1 outputs within the block size limit, so the out point cannot exist and the signed proof can never be committed. P commits to the tag, the lock and the message. Another lock or another message gives another transaction, so a signature cannot be moved between them. The tag keeps P apart from any real transaction hash, and names the bytes being signed: a change to those bytes gets a new tag. Input capacity u64::MAX. Some locks let a key move only a limited amount per transaction. At u64::MAX such a key sees the whole account leave and cannot prove the lock; a key with no limit can. The transaction hash covers out points, not the cells they resolve to, so this value is not part of the signed bytes for locks that sign the transaction hash. Output under the claimed lock. Output locks never run. The output names the lock, so a wallet with several locks reads from the transaction which one is asked to sign, and a signer that gets the transaction without the input cell can rebuild it. The lock is part of the signed bytes, so a transaction whose output lock differs from the lock P commits to is a proof for no lock. Output capacity (8 + s + n) CKB. The occupied capacity of that output. CCC 1.19 and later raises an output to its occupied capacity while building, so fixing this value makes every implementation build the same bytes. The verifier builds the transaction. If it accepted any transaction with input 0 under L, a prover could add inputs or outputs that open L without the key: an owner-lock style lock accepts when another input carries a given lock hash, and anyone-can-pay accepts without a signature when an output under the same lock receives more than the input. With one input at u64::MAX and one output holding less, anyone-can-pay still asks for the signature. Message shape. The first line follows EIP-4361 (Sign-In with Ethereum), so it reads the same way to users who have seen that. The account is ASCII only, so it cannot carry line breaks, direction overrides or look-alike letters into the text a wallet shows. Rejected: a real input that cannot be spent yet An earlier draft let wallets that only sign real inputs use a live cell of the lock with since set to a block far in the future. It was dropped: such a since satisfies time locks that have not matured, the outflow is only a fee so a key with a per-transaction limit can prove the whole account, the real input may carry a type script that opens the lock another way, and the message is only visible as a hash. Security considerations Cell deps come from the chain as live cells, never from the prover. A lock’s code and settings can live in deps. A forged settings cell that lists the attacker’s key would make some locks accept. The input is a constant of the verifier , never a cell the prover names. No exclusive control, no proof. A lock that accepts an empty witness opens for anyone. A lock that accepts the same witness on another message (a password or hash-preimage lock) lets anyone who has seen one proof make another. The two probes of step 12 refuse both kinds. A lock written to tell a probe from a real proof could still pass them. No lock an administrator can open. An Omnilock with the administrator flag (args byte 21, bit 0) is also opened by any identity on an admin list the administrator controls. The verifier refuses such locks, for the owner’s proofs too. Read the VM’s result, not text the script printed. A debugger that prints script logs on the same stream as its result can be fooled by a script that prints a result line. Replay: Replay Stopped by the same proof, same platform nonce used once a proof made for another platform domain another account on the same platform account, and the stored message another lock the stored message, and P testnet on mainnet, or the reverse chain line, against the platform’s configuration and the node an old proof issued at window the proof sent to the chain its input does not exist A proof shows control at verification time. A key can be shared later, and for locks whose code is upgradable or whose settings live in cells, the keys that control a lock can change. Requirement 5 ties a binding to the cells its proof used. Not covered: relative time locks, and time-dependent conditions in general: the input is fabricated, and the lock sees the since the wallet sets, not the chain’s time; locks whose signature does not cover the transaction hash; locks that need more than one input or one witness; locks that read the input’s capacity and could overflow on u64::MAX; type scripts, which are never run. Backwards compatibility An earlier form of this proof put the output under the lock { code_hash: 0x00 * 32, hash_type: "data", args: 0x } with capacity (41 + n) CKB and the tag CKB lock proof v0\n . It is a different transaction, a signature for one form does not open the other, and verifiers following this RFC refuse it at step 7. Reference implementation and test vectors ckb-ward ( GitHub - LusoCryptoLabs/ckb-ward: Ward: lock proof for CKB. Prove control of any CKB lock with a proof transaction that can never land on chain. · GitHub , npm ckb-ward ) implements the message, the transaction, the verifier, and three runners: one built from the node’s own script crates, one on ckb-debugger, and one on ckb-vm-js in a browser. It carries 17 signed proofs, each replayed by its tests with the expected exit codes for the proof and for controls: secp256k1 (testnet and mainnet), JoyID main key (testnet and mainnet, signed in the JoyID app), JoyID sub key, a 2-of-3 multisig, anyone-can-pay, Omnilock in Dogecoin, Ethereum and Bitcoin modes, PW-lock (testnet and mainnet), the Nostr lock, the quantum-resistant lock with an SLH-DSA key (testnet and mainnet), and a smart-account lock in two configurations. The full byte-exact vectors are in its docs/SPEC.md . CCC’s signer JSON-RPC rebuilds the input cell as described above, so a wallet connected through it can sign a proof for any of its locks. The change (ckb-devrel/ccc#641) is merged into CCC’s development branch and not yet in a release. Link

forum.tezosagora.org: Announcing Etherlink 8.0 (Horus): a new Etherlink kernel upgrade proposal<br /> This is a joint post from Nomadic Labs, TriliTech, and Functori. A new Etherlink kernel upgrade proposal, Etherlink 8.0 (Horus) , has just been submitted to Etherlink’s Slow governance mechanism. Where Etherlink 7.0 (Ganesha) opened Etherlink to a second interface, Etherlink 8.0 focuses on making the two-interface chain safer and more predictable for the people already using it: Recoverable EVM aliases : the EVM alias of every tz1, tz2 and tz3 account is now derived as the CREATE2 address of a smart-account contract deployed through the Safe singleton factory ( 0x914d7Fec6aaC8cd542e72Bca78B30650d45643d7 ). The alias is therefore the same on every EVM chain supported by Safe, and can be computed from the Tezos address alone. Funds sent to it on the wrong network by mistake can be recovered by the account owner, by signing a human-readable message with their Tezos key (Ledger included). On Etherlink itself, only the address value changes: NAC calls behave exactly as before. PLEASE NOTE: This is a breaking change for users, as they will no longer have access to their old aliases. There are currently no significant funds associated with any of these aliases. On-demand alias materialization : users and dApps can materialize aliases on both interfaces without first making a cross-interface call: through the RuntimeGateway precompile at 0xff00000000000000000000000000000000000007 on the EVM interface, and through the %materialize_alias entrypoint of the enshrined gateway contract KT18oDJJKXMKhfE1bSuAPGp92pYcwVDiqsPw on the Michelson interface. Michelson gas refunds : unused gas provided in a Michelson operation is now reimbursed to the sender, as it already is on the EVM interface. Tezos L1-compatible errors : error reporting on the Michelson interface now follows the formats used on Tezos L1, so indexers, wallets and SDKs that already parse L1 errors through the octez-node compatible RPCs can display Etherlink failures without special handling. REVM upgrade : the EVM interface moves to the latest version of REVM, the Rust EVM implementation at the heart of Etherlink’s execution, paving the way for compatibility with the upcoming Glamsterdam upgrade. Please see the full announcement for further details: https://medium.com/@etherlink/announcing-horus-an-8th-upgrade-proposal-for-etherlink-mainnet-4f36da2c479f Builders: the new alias derivation is a breaking change for dApps and wallets that store, display or compute EVM aliases of Tezos accounts. Existing aliases are not migrated: aliases derived with the old formula keep forwarding tez to their Tezos account, but they are no longer that account’s alias. Please recompute aliases with the new formula, for instance using the latest release of octez.js, and test your integration on the Tezos X Previewnet , which already runs a release candidate of Etherlink 8.0. See the Etherlink 8.0 preview for details, and reach out in this thread if you need help adapting your integration. Node operators: Etherlink 8.0 requires Octez EVM node version 0.69 (or higher), which will be released shortly. Please upgrade your infrastructure before activation to avoid regressions and feature breakage.If the governance vote is successful, the upgrade will be triggered to activate Etherlink 8.0 on 30 November. Thank you for your continued support for Etherlink. CTA: Please upvote Etherlink 8.0 The kernel upgrade proposal ( 0x0098890c787a228c5c170059915e99af5d991e9d37505148f3ddf1e66186ec84eb ) has already been injected in the current proposal period. Proposal period vote: slow governance period 63, spanning between L1 levels #15 ,873,889 (November 18 21:49 UTC) and #15 ,941,088 (November 23 13:49 UTC). Promotion period vote: slow governance period 64, spanning between L1 levels #15 ,941,089 (November 23 13:49 UTC) and #16 ,008,288 (November 28 05:49 UTC). For the proposal to move to the Promotion period, it must gather support from at least 1% of the total voting power . The Promotion period then requires a 5% quorum and a 75% “yea” supermajority . How to vote Bakers can cast their votes in a few clicks with Etherlink’s governance explorer UI , or using TezGov . We provide further voting instructions to vote with Octez CLI below. Don’t hesitate to reach out if you need our help to make sure you can cast your votes in time. Proposal Period (slow governance period 63) You can upvote the Etherlink 8.0 kernel upgrade proposal using the following Octez CLI command: octez-client call KT1AXRU3wLc87WNhLhVGrgqDGubLACUMUgPb from <baking_key or voting_key> \ --entrypoint "upvote_proposal" \ --arg "0x0098890c787a228c5c170059915e99af5d991e9d37505148f3ddf1e66186ec84eb" \ --burn-cap 0.11 Promotion Period (slow governance period 64) If the Proposal period is successful, you can vote for the Etherlink 8.0 kernel upgrade proposal using the following Octez CLI command: octez-client call KT1AXRU3wLc87WNhLhVGrgqDGubLACUMUgPb from <baking_key or voting_key> \ --entrypoint "vote" --arg '"yea"' \ --burn-cap 0.11 See this documentation entry for further instructions on how to participate in Etherlink’s governance, and don’t hesitate to reach out if you need our assistance to cast your votes. Reproducing the kernel root hash Etherlink upgrades are identified by the root hash of the binary resulting from the compilation of the Etherlink kernel crate to WASM. The Etherlink 8.0 kernel root hash is 0x0098890c787a228c5c170059915e99af5d991e9d37505148f3ddf1e66186ec84eb , built from commit 30d6f6e14ebb5d4ce8ca0fa8089775dcba3a87c2 of the Octez repository. This hash is fully reproducible: rather than trusting the proposers, anyone can rebuild the kernel from source and check that they obtain the same root hash as the one submitted on-chain. The build runs inside a Docker container to make it reproducible, so Docker is the only prerequisite. git clone https://gitlab.com/tezos/tezos cd tezos git checkout 30d6f6e14ebb5d4ce8ca0fa8089775dcba3a87c2 ./etherlink/scripts/build-wasm.sh cat etherlink/kernels-0098890c787a228c5c170059915e99af5d991e9d37505148f3ddf1e66186ec84eb/root_hash The output should match the root hash of the proposal: ROOT_HASH: 0098890c787a228c5c170059915e99af5d991e9d37505148f3ddf1e66186ec84eb Once you have checked the hash, you can safely ignore and delete the contents of the _evm_installer_preimages/ directory. For a comprehensive list of changes compared to the kernel currently deployed on mainnet, and links to the code changes, refer to the kernel’s changelog: https://gitlab.com/tezos/tezos/-/blob/master/etherlink/CHANGES_KERNEL.md Link

forum.celo.org: Introducing Altana: the agent-first wallet for agentic finance, now live on Celo mainnet<br /> Hi Celo community, Altana is live on Celo mainnet and Celo Sepolia as of today. We build for sovereign agentic finance: your agent gets its own key, bounded by rules the chain enforces, while the keys stay with the person who owns the wallet. This is our introduction here, so some context on what we do, and why Celo. The problem we started from Giving an agent money today means picking between two bad options. You hand it a private key and hope the prompt holds, or you park funds with a custodial agent platform and trust a dashboard. Neither option is legible to the protocol on the other side of the transaction: a DEX, a merchant contract or a paid API has no way to know what the agent calling it is actually allowed to do. What Altana is You keep custody of your wallet and grant an agent a session key carrying its own policy: a spend cap per token, per rolling period an allowlist of contracts, methods, or both an expiry The policy is enforced onchain. A session that passes its cap or calls a contract outside its allowlist reverts during validation, so the limits hold whether or not the agent’s code behaves. Revoking is one transaction, effective wherever the key is registered. Every grant is recorded in the Keystore, a public onchain registry. Any app, protocol or counterparty can read what an agent is permitted to do before executing, with a plain eth_call and no integration with us. Only you hold your keys. No server holds them, and no server holds a share of them. What is specific to Celo The Celo build is tuned for stablecoins: Agents can pay gas in USDC or USD₮. Fund an agent in dollars and it covers its own execution out of the same balance it spends from. Rates are read live from Celo’s fee currency allowlist. The Keystore is deployed on Celo itself, so grants and revocations batch into the same transaction as the agent’s own calls rather than needing a separate cross-chain step. Payments per request. A session key can pay for x402 resources inside its cap, settled in stablecoins through Celo’s own x402 facilitator, and your own service can charge per request the same way. Onchain identity. Register your agent with ERC-8004, the identity standard Celo has adopted, at 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 , so it can be discovered and scoped at the same time. On Celo Sepolia the relay also accepts Mento’s USDm, EURm and KESm as fee tokens, so you can test local currency flows end to end. Ideas you can get started with Payroll and contractor agents paying in USDC under a rolling weekly cap DeFi agents that swap and rebalance LP positions on allowlisted pools, capped per day Any x402 API the agent pays for per request, inside that same cap Treasury agents scoped to a single pool contract, revocable the moment you change your mind Multi-agent setups: several agents on one wallet, each with its own session, revoked independently Where it stands today Live on Celo mainnet and Celo Sepolia Keystore contracts are audited SDK is Apache 2.0, with no account, no API key and no hosted backend. Agentic activity across chains is growing at a rate of 41% WoW. Celo opened today, and every key is public in the explorer. TypeScript SDK plus an MCP server, so you can drive the same primitives from Claude, Cursor or any MCP client. Try it on Celo Sepolia npm install @altananetwork/sdk viem import { createClient, CELO_SEPOLIA, signerFromPrivateKey } from "@altananetwork/sdk"; const client = createClient({ chains: [CELO_SEPOLIA] }); const admin = signerFromPrivateKey(process.env.PRIVATE_KEY as `0x${string}`); const wallet = await client.createWallet({ signer: admin }); const session = await client.grantSession({ wallet, signer: admin, permissions: { calls: [{ to: "0xYourPoolOrRouter..." }], spend: [{ limit: 50n * 10n ** 6n, // 50 USDC, 6 decimals on Celo period: "day", token: "0x01C5C0122039549AD1493B8220cABEdD739BC44E", // USDC on Celo Sepolia }], }, expiry: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60, }); Fund the wallet with test CELO from the Celo Faucet, then switch CELO_SEPOLIA to CELO for mainnet with the same code. Links Announcement post: https://www.altana.network/blog/altana-is-live-on-celo Launch thread on X: https://x.com/AltanaNetwork/status/2123130172555534356 Docs: https://docs.altana.network Keystore Explorer: https://explorer.altana.network What we are looking for Feedback from people building agents on Celo, and specifically: which stablecoin flows in your market need scoped spending the most, and what would make the permission model easier to integrate into wallets and agent kits already running here. Excited to be part of the Celo fam, The Altana team Link

talk.nervos.org: Spark Program | CKB ClearSign: verify before you sign<br /> 1. Project CKB ClearSign: a TypeScript library + CCC signer wrapper that independently verifies a transaction’s inputs and explains it in plain language before the user signs. Repo: github.com/RaceeyXo/ckb-clearsign (MIT) 2. Applicant RaceeyXo: software engineer (full-stack Web3, AI engineering). GitHub: RaceeyXo . 3. Problem A CKB transaction only references its inputs by out point (txHash:index). The capacity, lock, type and data of those cells come from an indexer/RPC, and CCC trusts that answer. A lying, compromised or MITM’d RPC can make a wallet show “fee 0.0001 CKB” while the user actually signs something very different. As discussed in the October DevRel AMA, CCC deliberately trusts its indexer, and this check belongs in the wallet. Related work: CellGuard (CKBuilder projects #48 ) inspects transactions against policies but resolves inputs via RPC. Pocket Node decodes transactions in-wallet. CKB Contract Flow only decodes committed transactions. ClearSign is complementary: it proves input cell data by re-hashing origin transactions and ships as a CCC signer wrapper that tools like these can sit on. 4. Solution (v0.1 already built and working) verifyInputs: fetches each input’s origin tx, re-hashes it locally (blake2b) and rejects any mismatch. RPC-supplied cell data is never trusted. explainTransaction: per-address CKB sent/received, xUDT movements, mint/burn, fee, and a list of type scripts it can’t explain (flagged, not guessed). ClearSignSigner: wraps any ccc.Signer (verify → explain → user confirm → sign) and checks the signed tx hash equals the confirmed one. Honest guarantees: two separate flags. inputDataVerified = true; chainStateVerified = false in v0.1. It explains asset movements, not contract outcomes. 5. Proof it works Tested on Windows and Linux: 39 offline tests on 5 recorded testnet transactions (2 xUDT), plus a live public-testnet check. Lying-RPC demo: Plain CCC + lying RPC accepts a forged input (288 CKB reported as 10,288 CKB). ClearSign + honest RPC: verified and explained. ClearSign + lying RPC: blocked with ORIGIN_TX_HASH_MISMATCH before the user is asked anything. dApp pre-fills forged cell data: blocked with PREFILLED_CELL_OUTPUT_MISMATCH . Reproduce: git clone github.com/RaceeyXo/ckb-clearsign npm install npm test npm run demo -- --offline (Screenshots of the demo and test runs will be added once my forum account can post images.) 6. Why a signer wrapper A library used only by the dApp protects users from honest dApps. A malicious dApp just skips it. Real protection is in the signer/wallet, so ClearSign ships as a drop-in CCC signer wrapper, and this grant funds a pilot in a real wallet. 7. Scope & to-do (6 weeks) Wk 1: Harden v0.1 (edge cases, cross-platform scripts, browser build), publish to npm. Wk 2: Docs + integration guide for wallet developers. Wk 3–4: Pilot integration in one CKB wallet (PR or fork + write-up). Wk 5: “Trusted node” mode (verifyClient) + prototype chain-state check, documented with its limits. Wk 6: Completion report on Nervos Talk: results, wallet feedback, next steps. Out of scope: Spore/iCKB/DAO decoding, contract simulation. 8. Budget: $1,000 Development & testing (wks 1, 3–5): $750 Docs & integration guide (wk 2): $150 Completion report & community support (wk 6): $100 9. Milestones M1 (wk 2): npm package v0.2 + docs M2 (wk 4): working wallet pilot M3 (wk 6): chain-state prototype + final report Link

forum.celo.org: State of Stablecoins on Celo: MGP-19 Follow-Up<br /> Hi Celo community, MGP-19 has passed, and issuance of Mento stable assets now sits under Celo Governance. Below is what has been done based on your votes, what changes from here, and where we’re taking the stablecoin economy on Celo together. 1. MGP-19 is done MGP-19 ( original proposal ) passed in Mento Governance on September 8, 2026, following a positive proxy vote in Celo Governance ( CGP 253 ). In short: Issuance is back under Celo Governance. Onchain authority now sits with Celo Governance. That covers all 15 Mento stable assets, the Broker, BiPoolManager and Reserve contracts, the V3 reserve issuance contracts, the CDP branches (GBPm, CHFm, JPYm), and the oracle and circuit-breaker layer. The AP Reserve Foundation is confirmed as steward of the Mento Reserve’s assets and revenue. Under the standing principles, the reserve principal is never spent, the stablecoins stay overcollateralized, and part of the reserve earns yield. Only that yield funds protocol operations: oracles, monitoring, audits, entity costs, incident response and reserve administration. The Foundation will publish reports on reserve composition, yield, distributions and coverage ratio. Only Celo Governance can change these principles. CELO has gone back to the Community Fund. The Reserve’s original 120M CELO was already returned to the community in CGP 79 . Now 90% of the remaining CELO, 33.94M CELO, has also moved to the Community Fund: Celo Transaction Hash: 0xece87a0b22... | CeloScan . The other 10% stays in the Reserve as an asset of last resort, staked as stCELO and removed from active rebalancing. Mento Labs does not issue, own, govern or back the Mento stable assets, and does not hold or control the Reserve. Mento Labs GmbH is an independent company that provides defined technical services to the AP Reserve Foundation as an external contractor, under the 24-month agreement approved in MGP-19. Mento Labs receives a fixed fee and has no claim on the Reserve or its yield. What this means: the full value of Mento-issued stablecoins accrues to the Celo ecosystem and is governed by the Celo community. The Reserve remains overcollateralized, as it has been throughout its nearly six years of operation, and all but a 10% last-resort buffer of the Reserve’s CELO is back in the Community Fund. 2. A simpler structure with lower costs With the reserve and its governance back under Celo Governance, we no longer need several separate legal entities: The Mento Liquidity Foundation and the Mento Protocol Foundation will be wound down. Their remaining responsibilities move to the AP Reserve Foundation. That leaves a single steward, fully accountable to Celo Governance, with less overhead, so more of the Reserve’s yield goes to operations instead of administration. On the MENTO token , a launch isn’t planned for the near term. The broader market and the industry’s shift away from launching new tokens make this an inopportune moment, and despite extensive engagement with exchanges, the level of support needed for a strong launch isn’t there yet. We’ll revisit should conditions change. The Mento Labs team under a services agreement with Celo Core Co. will continue providing operational support for the Reserve , which includes rebalancing, running the oracle, and maintaining the circuit-breaker stack. Mento Labs will keep building onchain FX infrastructure on Celo and the other chains where it is live. It aims to improve on-chain liquidity and price finding by leveraging the infrastructure it developed over the recent years and that it is currently building out further. A new Global Head of Stablecoins role (filled by me, former Mento Labs CEO & cLabs Chief Economist), further focuses on making Celo the leading stablecoin network globally. The chain for every payment, every stablecoin, every currency, every transfer. We want to bring all stablecoins on Celo and strengthen the ones that are already live on Celo. 3. Where the Mento stablecoins fit The Mento stable assets remain a public good. How we use them depends on the market: Where no local-currency stablecoin is live yet, Mento stablecoins fill a real gap, giving people and businesses onchain access to their own currency. We’ll keep supporting the local communities. Where a strong, compliant local stablecoin already exists (or even several), we’ll work with every team rather than compete. That means we help with the best infrastructure for stablecoins, deep liquidity, good FX routing and integrations around the issuer, so Celo becomes the best home for every currency and every stablecoin. Issuers are best placed to build their own stablecoins. We’ve seen global issuers (e.g. Tether, Circle) and local ones (e.g. IDRX, cNGN) do this best when they focus on their own markets. Our job is to bring all of them live on Celo and provide them with the best infrastructure to scale. The goal is to cover as many currencies as possible, with the best available liquid assets in each market. 4. State of stablecoins on Celo Celo has become one of the most widely used chains for stablecoins, and the leading blockchain for stablecoin payments globally: Built for the world from day one: phone-number-based addressing, gas fees payable in stablecoins, and low, predictable costs. 33+ local-currency stablecoins live on the network. The #1 distribution network for Tether USD₮ by weekly active users, accounting for about 28% of cross-chain USD₮ transfers (Tether, July 2026). Fast-growing newer stablecoins, including local-currency assets like IDRX and cNGN, and USA₮, Tether’s US-regulated dollar stablecoin, which chose Celo as its first network after Ethereum. They grow alongside native USD₮, USDC, the Mento stables and others. 5. Payments for AI agents We expect agents to become a major source of stablecoin payment volume, and Celo is positioning for that: UseBuy.ai , launched by Celo Core Co., is a marketplace where agents on Celo can pay for 700+ services on their own, in USD₮, USA₮ and USDC. x402: Celo is a member of the x402 Foundation and supports x402 natively, including its own facilitator, so agent payments over plain HTTP are easy to add ( docs ). 6. What’s next The first AP Reserve Foundation report under this governance. Wind-down of the Mento Liquidity Foundation and the Mento Protocol Foundation. We’ll post an update when it’s complete. Continued work with local stablecoin issuers and ecosystem affiliates, such as Stabila Foundation, to grow liquidity, FX pairs and distribution on Celo. Thank you to everyone who took part in the discussion and the vote, and to the Mento Labs team for making the transition smooth. Questions and feedback are always welcome, either as DM or below. Markus Link

talk.nervos.org: [DIS] KeyMe — CKB's PSBT: Open Air-Gapped Signing and the First DIY Hardware<br /> If you have used a Bitcoin hardware wallet, the flow is familiar. A watch-only app builds a transaction. It hands it to a small device as a QR code or a file. The device shows the amount and the destination. You approve. The signed transaction goes back to the app, which broadcasts it. The machine that holds the key never talks to the internet. Bitcoin calls that container a PSBT (Partially Signed Bitcoin Transaction). The devices have names you may know: Coldcard, SeedSigner, Specter DIY. They do not share one design. They share one rule: the key lives on a device that cannot reach the network, and the device shows you what you are signing. CKB has the same need and no open equivalent. CKB transactions are not Bitcoin transactions. They carry cells, lock and type scripts, DAO state, xUDT amounts and multisig. A Bitcoin device cannot read them. In 2020, a grant added a Ledger app for CKB; it is a closed device. There is still no open, radio-less CKB signer that a community can inspect, build and improve. KeyMe is the CKB version. PSCT is the container, CKB’s equivalent of PSBT. KeyMe is the signer, a small, radio-less device that reads the PSCT, checks every byte, shows the transaction, and signs only after you approve. The first hardware is built on a Pico 2: a small board with a screen, a QR scanner, no radio, and no operating system. It is not a clone of a Bitcoin device; it is the shape that fits CKB. The one-minute version PSCT — a Partially Signed CKB Transaction — is a file with three parts: the transaction, a proof for every coin it spends, and the block headers the scripts need. The device checks that each proof hashes to the coin it claims, decodes the previous output, checks the script against its registry, and shows the amount, destination, fee and change. It signs only after you confirm. It never trusts the coordinator’s summary, an address label, or a script it does not know. The idea is not new In 2020, a CKB grant added a Ledger app for CKB ( Nervos Talk ). It proved the demand; it is a closed device. In May 2021, Xuejie Xiao ( @xxuejie ), a CKB core developer, posted “RFC Draft: CKB Offline Transaction Signing Scheme” ( Nervos Talk ). It separated transaction assembly from signing, defined the data the signer needs, described the review step, and ended with this: As a side project, I do plan to build a Raspberry Pi Pico powered, air gapped offline transaction signing app. With a Cortex-M0+ chip and 264 KB RAM, the Pico should be more than enough to power such an offline signing design. It stayed a draft. The Pico build never shipped. In September 2022, @doitian opened “CKB Open Transaction” to describe a partial CKB transaction that multiple parties can build over time ( GitHub discussion ). The hardware wallet is the final signer in its example: One party works on an open transaction, changes it, and hands it to the next participant. For example, the indexer collects input cells for a user; the dApp creates the unsigned transaction based on the inputs; and the hardware wallet finally signs the transaction. The discussion cites Bitcoin’s PSBT as prior work. The project produced an alpha demo and an RFC; the RFC was closed without merging, and the project closed in 2024. No open hardware signer shipped. The 2021 draft planned the offline signer. The 2022 project planned the partial transaction format. Both named the hardware wallet. Neither shipped an open device. KeyMe picks up the signing half: PSCT v0 is the signed container, and the Pico 2, the current Pico, is the device. KeyMe keeps the 2021 goal and changes what building it taught us: canonical CBOR instead of a molecule envelope; hash-bound proofs instead of full input transactions; per-script-group signatures; a registry that refuses unknown scripts; finalize-or-throw. We did not carry the draft’s Lua signing path. A signer that executes arbitrary scripts is not a signer we can verify. The 2021 draft is the ancestor; PSCT v0 is the working version. Grant requested: $9,500, in five payments of $1,900. ETA: 3.5 months from approval. What you get: three assembled units (two for independent testers), open firmware, open hardware, and documentation. What is already built KeyMe’s software is not a paper design. It is the oracle the hardware will be tested against. Layer Status PSCT v0 Frozen. Canonical CBOR, molecule, hash-bound input proofs, witness templates. Verifier 42 hostile tests. Refuses unknown locks and types; never guesses. Coordinator + signer CLI. Builds, binds, displays, refuses, signs, finalizes. Second implementation Rust. Byte-identical tx_hash and full_tx_hash ; 3/3 conformance vectors. Testnet Transfer at block 23,084,406. 2-of-3 payout at block 23,086,201. Devnet DAO deposit → prepare → withdraw; xUDT mint → transfer. Reproducible with the demo scripts. Hardware Board selected: Pico 2 (RP2350). Build starts with this grant. The testnet transfer is 0xbb10d0b6…1a85 ; the 2-of-3 spend is 0x0ea1b375…535f . The DAO and xUDT runs are devnet, not public chain; the scripts are in the repository. In total: 68 tests, plus the Rust conformance run. The repository is https://github.com/WuodOdhis/keyme ; the spec is spec/psct-v0.md . What this grant delivers Three assembled units. Two go to independent testers; one stays with the project for demos. A fourth parts set is the spare. Firmware v0.1.0 for the RP2350: PSCT parsing, proof binding, script registry, DAO/xUDT display, secp256k1 signing, QR in/out, PIN and encrypted seed, signed boot. A host QR page. A static page that turns a PSCT into animated QR and scans the signed frames with a phone camera. No server, no keys. Open hardware. Carrier board, schematic, BOM, 3D-printable case. Documentation. Build guide, flashing, test report, demo video, threat model. Licences. MIT/Apache-2.0 for code, CERN-OHL-S-2.0 for hardware, CC-BY-4.0 for docs. How it works The coordinator proposes; the device verifies. The device trusts only three things: the canonical PSCT bytes, proofs that hash to the inputs they claim, and its own account and script registry. If a lock or type is unknown, it refuses. If the CBOR is non-canonical, it refuses. If the proof, network or header is wrong, it refuses. There is no “proceed anyway” button. The device has no operating system, no shell and no network stack. The firmware is the only code. The RP2350 boots from signed flash; the seed is BIP39, encrypted at rest with a PIN and the ATECC608B key, and decrypted only while signing. USB is power-only while signing; QR is the data path. v0.1 has no third-party audit and no lab-grade physical security; that is a v0.2 conversation. Demo A short concept animation shows the flow: the coordinator builds the PSCT, the frames cross the air gap, the device audits the input proofs and change lock, and a malware-swapped change output is refused. It is a simulation, not the protocol; the QR grid is illustrative, and the real verifier is the test suite. The automatic refusal is the change-output check; the destination remains a human check. Click the still to open the interactive demo. Normal flow Tamper: a swapped change output is refused Hardware The units are off-the-shelf modules on a carrier board. No custom injection mold, no custom silicon. Why these parts: Pico 2 (RP2350): no radio, 520KB RAM, 150MHz, Rust, secure boot, $6. No OS, instant boot, and it is in stock. GM65: decodes QR inside the module over UART. No camera pipeline, no DSP, no large framebuffer. 2.8-inch TFT: review screen and animated QR. ATECC608B: stores the key that encrypts the seed at rest. It does not sign secp256k1; the RP2350 does. I am not claiming a secure enclave in v0.1. microSD: signed firmware updates and a backup. It is not the running OS. LiPo + charger: signing does not need a cable. No ESP32: radio. No phone: radio and a large attack surface. No Pi SBC (Zero, 3, 4, 5): a full OS and radio. The Pico 2 is a microcontroller: no OS, no radio, instant boot. BOM for four units (three plus a spare): Part Qty Cost RP2350 Pico 2 4 $24 2.8-inch TFT 4 $72 GM65 QR scanner 4 $120 ATECC608B 4 $20 microSD 4 $16 LiPo + charger 4 $40 Buttons, headers, wire 4 $40 Carrier PCB (5 pcs) 1 $40 3D-printed case 4 $40 Tools/consumables 1 $100 Shipping to testers 1 $50 Total $562 One unit is about $100 in parts (v2 should be significantly cheaper once we have the hardware supply chain right). The build guide is the point: anyone can make one. Milestones 3.5 months, five payments of $1,900: the first at approval, then one after each milestone. Each milestone payment follows a public report and the committee’s check. # Week Work Acceptance Kickoff (M0) 1 Order hardware; publish repo and licences; firmware skeleton; PSCT parser, sighash, secp256k1; signed boot The device signs the three conformance vectors; host verifier accepts; BOM and block diagram published M1 3 Scanner input; review UI; PIN and encrypted seed; host QR page Scan unsigned PSCT, review, sign, return signed PSCT, finalize a testnet transfer; video M2 6 Three units on carrier board; case; battery; testers Each unit signs a testnet transfer; two units shipped; build guide draft M3 10 Hostile tests; DAO and xUDT paths; firmware v0.1.0 20+ adversarial tests pass on device; signed image verified; test report M4 14 Docs, BOM, schematics, STL, flashing, video; independent build A third party builds a unit and signs a testnet transaction; final report The first payment is released at approval and funds the hardware order. The kickoff report at week 1 is reviewed before the M1 payment. The minimum viable outcome is one working unit plus open firmware and docs. If something has to give, the cut order is spare unit → custom carrier board → ATECC. The firmware and docs are never cut. Budget Category Amount What it covers Development $7,638 Firmware, host QR page, carrier board design, tests. About 400 hours over 14 weeks at a community rate. Hardware $562 Four units, PCB, case, tools, shipping. The BOM above, at cost. Documentation $600 Build guide, photos, demo video, test report, Chinese translation. Independent review $700 Firmware review by an embedded developer. Total $9,500 If hardware costs more (tax, a part price change), I absorb it or drop the spare unit. The software is donated; the hardware is at cost. Payments are in CKB at the payment-date rate, as recent grants are. Path to sustainability The grant pays for the open design and the first three units; it does not fund inventory. After v0.1, the same design can be sold as an assembled, tested unit to people who do not want to source parts, print a case, or flash firmware. DIY: the BOM and build guide stay open; anyone can build at parts cost. Assembled: a tested reference unit with signed firmware, case, battery and a starter QR workflow, priced at the BOM plus assembly, testing and support, with a small margin. Support: flashing, replacement parts and setup help, priced separately. The margin from assembled units funds the next batch and the v0.2 revision: a custom PCB, a secure element and an independent audit. The design stays open; the paid product is assembly and support, not a closed lock-in. The exact price is set after the v0.1 BOM is final. This grant is not a promise of a company or a retail product. It proves the design and the first units; the assembled path is how the work can continue without a new grant for every unit. What this is not Not a production wallet, not certified, not an audited vault. No custody of mainnet funds, no mobile app, no custom injection mold, no retail packaging. No third-party audit in this grant. That is v0.2: a custom PCB, a secure element, an audit, and a small batch. Risks Risk Mitigation The bare-metal firmware is more work than a Linux app Reuse the existing Rust PSCT code and vectors; v0.1 supports secp, multisig, DAO and xUDT; explicit cut order. The 3.5-month schedule is tight The Rust PSCT code and conformance vectors already exist; hardware is ordered at kickoff; the cut order protects the core; progress notes at each milestone. 520KB is tight with the display and QR 1-bit or partial display refresh; stream QR frames; prove the budget in M0. The scanner cannot read animated QR reliably Test in M1; slow frames, high error correction; SD-card fallback. Seed storage is weaker than a production wallet ATECC608B plus PIN; documented limits; v0.2 secure element. Signed boot is misconfigured Test the signed image in M0; document provisioning; bricking is recoverable over USB. Parts are delayed Pico 2 is current and in stock; order four at kickoff; Pico 1 is a fallback with less RAM. Physical attacks v0.1 is a reference; testnet first; v0.2 audit. Why me I am WuodOdhis. I hold a BSc in Electrical Engineering. I am well versed in the hardware side of this build — board-level design, power, displays, scanners and embedded debugging — and my software and blockchain work covers the PSCT verifier, transaction semantics and the signed bytes. Together they give me an end-to-end understanding of the device, from the carrier board and power path to the signature. The public CKB work below is the base this proposal builds on. Work What it is Evidence KeyMe PSCT v0, verifier, coordinator, offline signer, Rust conformance; 68 tests; testnet and devnet runs repo CKBuilders CKB Dev Log from the CKBuilders program: cell model, xUDT, JoyID, Spore, Rust scripts, weekly reports, capstone repo Reflections of a CKBuilder Three merged Nervos Education Hub articles on the cell model, builder semantics and RGB++/Bitcoin interoperability Part 1 , Parts 2–3 CellScript swap builder Deterministic CKB transaction builder for CellScript amm_pool contracts (local devnet) repo Fiber LSP Prototype receive-first liquidity service on the Fiber Network repo CKB Agent Lock Web2-to-Web3 claim flow with a custom RISC-V lock on CKB-VM repo ForecastCKB CKB pilot for auditable AI benchmark records; commit-reveal and independent verification repo I wrote the PSCT spec, the verifier, the coordinator, the signer and the tests. The device firmware will be a port of the same rules against the same vectors. The 2021 draft stopped at the design; this is the implementation. Full public record: docs/08-prior-work.md . Links Pico 2: https://www.raspberrypi.com/products/raspberry-pi-pico-2/ 2022 Open Transaction: nervosnetwork/ckb#3607 Open Transaction RFC (closed unmerged): nervosnetwork/rfcs#406 Open Transaction project issue (closed 2024): nervosnetwork/ckb#3608 2021 draft: https://talk.nervos.org/t/rfc-draft-ckb-offline-transaction-signing-scheme/5794 2020 Ledger grant: https://talk.nervos.org/t/4349 Repository: https://github.com/WuodOdhis/keyme Prior work: https://github.com/WuodOdhis/keyme/blob/main/docs/08-prior-work.md PSCT spec: https://github.com/WuodOdhis/keyme/blob/main/spec/psct-v0.md Stage 2 record: https://github.com/WuodOdhis/keyme/blob/main/docs/04-stage2.md Threat model: https://github.com/WuodOdhis/keyme/blob/main/docs/05-threat-model.md Testnet transfer: https://explorer.nervos.org/transaction/0xbb10d0b6fb9ad72f6618f29020a1f065e73b4435f5ce24515afcbcb5c50a1a85 Testnet 2-of-3: https://explorer.nervos.org/transaction/0x0ea1b3755a6a9610d266a791f2adb0b8c484e6fa1fe203ccfccffedfddbd535f Link

talk.nervos.org: Spark Program | Will On-Chain: Tamper-Evident, Private Digital Wills on CKB<br /> Applicant: Fizan (GitHub: Fizan324926) Requested grant: $1,000 USD (equivalent in CKB at the official approval price snapshot) Duration: 4 weeks Disbursement: 20% (200)onapproval,80%(800) on completion and reproducible verification License: MIT OR Apache-2.0 Making will accessible, transparent, and verifiable through CKB technology 1. Summary Will On-Chain is an open-source testnet app for sealing, updating and releasing a digital last will, using CKB as a tamper-evident, versioned registry. The will is encrypted in the browser and the key is split among chosen guardians, so the chain, the app and the developer cannot read it. The chain holds the ciphertext (or its hash), a timestamp, a version number, and an inactivity timer that lets a named executor signal a claim if the owner stops checking in. This is a technical MVP for a tamper-evident vault. It does not provide legal validity, and it does not claim the chain can verify a death. The scripts are unaudited and for testnet only. 2. Problem Wills held on paper, with a lawyer, or in cloud storage can be lost, backdated, disputed or locked behind an account. Families often can’t tell whether a will exists or which version is current. Crypto holders have an extra problem: heirs may not know assets exist, and secrets can’t go into a plaintext will. 3. Why CKB Natural versioning. Updating a will spends the old cell and creates a new one with a higher version. The chain history is the revision history. Timelocks without keepers. CKB’s since field lets a lock script enforce “owner can act anytime, executor only after a period of inactivity” with no oracle, keeper or admin key. Capacity returns to the owner. Storing the cell costs a refundable deposit, not a fee. Fixed, verifiable logic. The lock script is deployed by data hash and built reproducibly, so anyone can verify and redeploy it. Related Spark work: CRT explores general revocable timelocks and Tranfr targets fund recovery. Will On-Chain is an end-to-end document workflow (encryption, key shares, versioning, executor view) built on similar primitives. 4. How it works Create. The owner uploads or writes a will. The browser encrypts it with AES-256-GCM and computes a SHA-256 digest. Split the key. The key is split with Shamir secret sharing (e.g. 2-of-3) into shares exported as files or QR codes for guardians. Shares never touch the chain. Seal. The app creates a will cell holding: version, document hash, timestamp, executor lock hash, inactivity period, and either the ciphertext or the hash plus a storage pointer for larger files. Check in. The owner spends and recreates the cell at any time, which resets the timer. Updating works the same way with a higher version. Revoking spends the cell without recreating it. Claim. If the inactivity period passes with no check-in, the executor can spend the cell through the timelocked path, creating a public, timestamped on-chain claim. Release. Guardians see the on-chain claim and, per the owner’s instructions, hand their shares to the beneficiaries, who recombine them in the app to decrypt and verify the hash. The inactivity period has no protocol default. It is set at creation by the will’s key holders, and the app simply enforces whatever they choose. What is and isn’t private Phase Hidden Visible on-chain Sealed Will contents, key shares Document hash, version, timestamp, addresses, inactivity period, cell size After a claim Will contents (until shares are combined) The claim and its timestamp After release Nothing, for those who hold enough shares Same as above; decryption happens off-chain Revoked Contents stay encrypted That a will existed and was revoked Trust model: nothing on-chain can verify death, and the chain does not hold the decryption key. The timelock gives a public, owner-vetoable claim signal, and the guardians’ shares are the real access control. If the ciphertext is stored on-chain, it stays public forever, so its secrecy rests entirely on the encryption and the share holders. 5. Scope In scope (testnet MVP) A small Rust lock script (ckb-std) with two paths: owner (update, check-in, revoke) and executor (after since maturity), with tests covering premature claim, unauthorized spend, check-in resetting the timer, and stale version spend Browser module: AES-256-GCM encryption, SHA-256 hashing, Shamir split/combine, share export/import (file and QR) Web app using CCC with standard CKB wallets: owner dashboard (create, update, check in, revoke) and executor/beneficiary view (check maturity, claim, recombine shares, decrypt, verify hash) Testnet deployment with tx hashes and reproducible build instructions Short spec, threat model, privacy and legal disclaimer, demo video, feedback from 3 to 5 testers Stretch (only if ahead of schedule): optional witness signatures over the document hash, and a hash-only mode with an IPFS pointer. 6. Timeline Week Work 1 Repo setup; cell data layout; lock script (owner and executor paths); ckb-testtool suite; testnet deploy 2 Browser encryption, hashing, Shamir split/combine, share export/import; create, update, check-in and revoke transactions via CCC 3 Owner dashboard and executor/beneficiary view; full create → check-in → claim → decrypt flow on testnet 4 Tester feedback and fixes; spec, threat model, disclaimer, README; demo video; final report with tx hashes 7. Budget | Item | Amount | |—|—| | Lock script and tests (Week 1) | $250 | | Crypto module and CCC transactions (Week 2) | $250 | | Web app (Week 3) | $300 | | Testing, docs, demo, report (Week 4) | $200 | | Total | $1,000 | Requested in CKB at the official approval snapshot rate. No other funding has been received for this work. I’ll post a short update on this thread weekly and publish fund usage at completion. 8. Risks and limitations Not audited. Delivery includes a self-review and a clear “unaudited, testnet only” notice. An audit is recommended before any mainnet use and is not funded here. Key-share loss: documented in the threat model; the app warns users and supports re-splitting on update. False or malicious claims: the owner’s check-in resets the timer, and the key holders choose the inactivity period. Public metadata: addresses, timing and cell size are visible on-chain even while the will is encrypted. The docs describe mitigations. Scope: if the web app runs long, the executor view takes priority over polish, and stretch items are dropped first. 9. How to verify Public repo with the script, browser module, web app and demo, under the stated license Reproducible script build, published code hash and deployment tx Test suite runnable with a single documented command Testnet tx hashes for create, check-in, update, revoke, and claim Recorded end-to-end lifecycle, spec, threat model and deploy guide 10. Maintenance, ecosystem value and next steps I commit to bug-fix and compatibility updates for 12 months after delivery, with a published contact for security reports. The project gives CKB a relatable, non-crypto use case and reusable pieces: a timelocked two-path lock, versioned encrypted documents, and a browser Shamir module. If the MVP works, a follow-up Community Fund DAO proposal could cover an audit, mainnet, m-of-n attestors, asset distribution and Fiber integration. Link

forum.pyth.network: [Pythian Council Election #6] [Agarwal] — Pyth Network<br /> Gm, everyone i’m putting myself forward for the 6th Pythian Council. Candidate Information Name: Agarwal Current Role / Organization: Chiron & Community Jannie at Pyth Network Location Asia X: Agarwalfeeds Discord: agarwalfeeds GitHub: Agarwal Solana Wallet: J2jisiC4fVC6nUyACRj9EN71DrH3mV8dmiptRb1RQQrP Ethereum Wallet: 0xd60348E8145960cb981A79E19aDc42A788b509eb Signing-key Custody: Safepal hardware wallet for both keys Motivation to participate in the Pythian Council: Being part of Pyth has given me the opportunity to learn, contribute and grow alongside an amazing community. I’ve always tried to stay involved, take initiative and help wherever I can. I’d love to bring that same approach to the Pythian Council by bringing my full availability, consistency and attention to detail in every decision. Relevant Experience: My track record as a Pyth Chiron & Community Jannie reflects my consistency & dedication . Through daily moderation, content creation and active involvement in Discord, i’ve never gone a single day without engaging with the Pyth community. I make sure to follow through on my responsibilities without interruption . Background in data analysis and data science, with an analytical approach to understanding information, paying attention to details and solving problems. Actively follow Pyth’s ecosystem updates, integrations and developments, with a genuine interest in understanding what we’re building and where we’re heading. Long-term PYTH staker and active Pyth governance voter. Link

www.comp.xyz: [Gauntlet] Mantle USDe Comet: Closing Remaining Positions<br /> Simple Summary Gauntlet began deprecating the Mantle USDe Comet earlier this year by setting supply caps and Borrow Collateral Factors to 0. Since most surplus reserves were withdrawn, utilization has climbed to around 250%. The largest supplier still cannot withdraw because there is no liquidity in the comet. To fully wind the market down, Gauntlet and Woof recommend the changes below. Together, they make every remaining borrow position eligible for absorption. Recommendations Asset Parameter Current Recommended WETH Liquidation Collateral Factor 87% 0.5% mETH Liquidation Collateral Factor 85% 0.5% FBTC Liquidation Collateral Factor 83% 0.5% Borrow Collateral Factors are already 0% for all three assets and stay there. Liquidation factors and the storefront price factor stay the same. Open Borrow Positions by Debt to Collateral A position can be absorbed once its debt to collateral ratio is higher than the Liquidation Collateral Factor. The table below groups all open borrow positions by that ratio. The Liquidation Collateral Factor needs to sit below the lowest bucket for every position to become liquidatable. Debt to Collateral Accounts Debt (USDe) Collateral (USD) Cumulative Accounts Cumulative Debt (USDe) 15% to 20% 1 1,040 5,935 1 1,040 20% to 30% 1 506 1,978 2 1,545 30% to 40% 3 54,674 138,765 5 56,220 40% to 50% 2 108 265 7 56,328 50% to 60% 2 1,899 3,596 9 58,227 > 60% 1 150 231 10 58,377 Total 10 58,377 150,770 Debt excludes accrued interest. Collateral is valued at $1,783 per WETH, $1,978 per mETH and $64,010 per FBTC as of November 18, 2026. Most of the debt is in one position: one account holds about $52.9K of debt (91% of the total) against about 75 WETH, at roughly 40% debt to collateral. The rest is small: the other nine accounts hold about $5.4K of debt between them. The low end sets the floor: the lowest position sits at 17.5%. Any Liquidation Collateral Factor below that clears today’s book. Rationale The cause is market structure, not collateral risk. Utilization above 100% means borrowers owe more than suppliers have deposited. Interest keeps compounding into the borrow index, and if it overflows the market stops working. Clearing the remaining borrows brings utilization to near zero and stops that growth. Open borrows: 10 accounts still have open borrows, totaling around $58K USDe excluding accrued interest. They are backed by about 78.4 WETH, 4.7 mETH and 0.026 FBTC. Why 0.5%: it sits well below the lowest bucket in the table above. It also matches the Scroll USDC Comet wind down. It leaves room for price moves, since higher ETH and BTC prices push ratios down. And it catches accounts whose only remaining debt is accrued interest, which does not show up in the table. What borrowers keep: when a position is absorbed, the borrower keeps the remaining equity (collateral value × liquidation factor, minus debt) as a USDe supply balance they can withdraw. For the largest position, that is about $71K at current prices. Next Steps Borrowers should repay before execution to avoid the liquidation penalty. Collateral-only accounts should withdraw. After execution, positions will be absorbed and the seized collateral sold through buyCollateral . We welcome community feedback. Link

forum.safefoundation.org: Safenet Aegis Rewards Distribution — Period 2<br /> Summary Safenet Aegis rewards for period X (October 27, 2026 – November 10, 2026, UTC) were distributed on November 18, 2026 following the permissionless Reality.eth approval process under SEP-56. Details Reward period: October 27, 2026 – November 10, 2026 (UTC) Methodology: SEP-56 / Safenet rewards documentation Distribution package and Merkle proofs: ipfs://bafybeia3dwqf2lrsslbx72jagyokkvctnxvhcrgeikdh3dyub5hcszakdi Reality.eth question: reality.eth Execution transaction: Ethereum Transaction Hash: 0x931946f94d... | Etherscan Distribution contract: Safenet Aegis Rewards | Address: 0xe5139Fc0...6757120f2 | Etherscan Claiming Eligible recipients can claim directly from the distributor contract or via 3rd-party UI such as https://safenetstake.eth.limo/ or https://safenet-staking.bzz.limo/ . Once each biweekly rewards period concludes, anyone can initiate the permissionless rewards distribution process as outlined in SEP-56. Link

talk.nervos.org: Spark Program | CKAutomata: Protocol Hardening, User Onboarding and Testnet Beta<br /> 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: DAO Harvest: Collect earned Nervos DAO compensation and place the user’s exact original amount into a new DAO deposit. Scheduled payments: Send a fixed amount of CKB to a chosen recipient at a future date and time. 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 GitHub: Hallab7 Email: ibrahimhabeebolawale@gmail.com Discord: hallab. Telegram: just_hallab Repository: Hallab7/ckb-automata 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: CKAutomata introduction on Nervos Talk CKBuilder review request and technical feedback 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: Connect a supported CKB testnet wallet. Choose DAO Harvest, a scheduled payment or a recurring distribution. Enter the amount, recipient, timing and service-specific terms. Review the payment destination, charges, executor rules and owner recovery in plain language. Approve the setup transaction in the wallet. Follow the automation through waiting, processing and completion. 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: connect, disconnect and reconnect a wallet; create and track a scheduled payment; configure a recurring distribution with the correct amount, interval and run limit; review a DAO Harvest setup and explain its purpose, charges and original-amount protection; find transaction evidence and the current automation status; and 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 CKAutomata source CKAutomata testnet application CKAutomata introduction CKBuilder review Link

forum.thegraph.com: Self curation is allowed now, so here's an indexer's guide to it<br /> The games have begun, as promised. At 02:31 UTC today a fresh wallet put 300k GRT of signal on uniswap-v4-base-3. It burned 3k and moved ~2.4% of all indexing rewards onto one deployment with three indexers on it: https://arbiscan.io/tx/0xaf61fc98f9eb0dd7a222a1141725a3668e71f87923bb6ccabba21f155383568d @mindstyle_p-ops is right that the burn is nothing next to that. At 3% a sole indexer earns it back in about 12 hours. The 3% was also meant to execute last night. The Curation contract still says 1%. Since its allowed now, I wrote up how any indexer can do the same and what it pays: https://www.lodestar-dashboard.com/blog/self-curation-is-allowed-an-indexers-guide Is the Council planning anything beyond the tax before everyone piles in? Link

talk.nervos.org: [DIS] Fiber Claim Cell: Async Receive and On-Chain Claims for Fiber LSPs<br /> Following up on my earlier reply in the Fiber LSP discussion , I’m excited to share Fiber Claim Cell ! Since then, I’ve narrowed the project from a full LSP service to an on-chain claim module for existing LSPs and wallets. The focus is receiving a Fiber payment without a usable channel, with the recipient coming online later to claim it on CKB within a defined claim window. I’d love feedback from the Fiber team and LSP operators on how this could complement the hosted LSP work already under way. Summary This proposal adds an on-chain claim option for receivers with no usable Fiber channel, without the LSP taking custody of the receiver’s funds. Optional stablecoin support also covers receivers with no CKB. The LSP funds a claim cell on CKB. Its claim path pays the designated receiver; the intended flow then uses the revealed preimage to settle the payer’s held payment. Amount verification and claim-timing safeguards are part of the funded work. The current prototype does not yet establish that the receiver can safely claim the correct amount in every case. Public LSPs are already under way. Fiber’s own hosted LSP support is in review. Cellula’s proposal for a public mainnet LSP, built on it, passed a Community Fund DAO vote on 16 November 2026. Both deliver a payment over a channel the receiver already has. This work adds the path for a receiver who has none, and is meant to plug into those LSPs, not to run another one. The mechanism already works. A draft specification, the L1 lock script, and a reference implementation of the module an LSP runs are public, and the full flow has run on three real Fiber nodes and the CKB testnet. Receivers are meant to need no new wallet. A web page asks the wallet they already have for one signed message and does the rest itself, so that only an LSP has to switch the module on. So far this has run in a browser test with a raw key. No real wallet has been connected yet, and recovery on a second device works only for wallets whose signatures are deterministic, which leaves out passkey wallets. Which wallets work is established in package C. The proposed core budget is USD 26,500 , covering packages A, C, E and F. Packages B and D are optional; including both brings the current estimate to USD 35,500 . The final package list, auditor’s quote and CKB request will be confirmed before voting. The full set of packages is estimated to take about four and a half months. An advance of 10% is paid on approval and counted against package A. Further payments follow acceptance; package F is reimbursed at actual cost up to its ceiling. Where this fits To receive a payment on Fiber, a user must be reachable and must already have a channel with enough inbound liquidity. Two efforts address this, and the second is built on the first: Cellula runs Fiber’s LSP branch plus its own fixes. Fiber hosted LSP Cellula public LSP This proposal Who Fiber core team: design , PR #1623 LusoCryptoLabs: DAO proposal , scale test Akane-CN/fiber-claim-cell Status Pull request open. The design calls itself an integrated prototype, not production ready Vote passed on 16 November 2026. Running on testnet Reference implementation working on testnet Model One public node hosts many wallets. Each wallet keeps a private channel with it and signs on its own device The same model, operated as a public service A lock script and a module that an LSP adds Where the channel comes from The wallet funds its side. Liquidity policy is listed as an open question The approved proposal includes LSP-funded channels of 299 CKB for the first 1,000 wallets Not addressed. Left to the LSP Receiver offline, has a channel The LSP keeps the payer’s payment pending and delivers when the wallet wakes: 24 hours by default, 7 days at most, then it fails the payment back Inherits this. Its tests state that the payee must be awake to sign Overlaps. See below Receiver has no channel Not supported. Delivery requires a registered wallet with a private channel Not described Claim cell on L1 Payment larger than the channel can receive Not addressed Not addressed. A 299 CKB channel cannot receive more than that Claim cell on L1 Payment delivered on L1 No. Funds are credited only by a channel update No Yes, this is the mechanism Stablecoins, receiver with no CKB Not designed. The only asset rule is that amount and asset match Stablecoins not named in the proposal Script-level support verified on testnet. The LSP fronts the cell capacity This table is built from the documents linked in it, read on 17 November 2026. Either team may have plans that those documents do not show. What the table shows: The offline case is already handled. Fiber’s hosted delivery holds a payment for a sleeping wallet, which is what this project’s path A does. Path A exists in the reference implementation and is not developed further here. An on-chain fallback is the gap this proposal targets. The public designs reviewed here do not describe an on-chain claim fallback for these cases. These are a receiver with no channel, a payment above the receiver’s inbound capacity, and a stablecoin payment to a receiver with no CKB. The claim cell is a natural fallback for hosted delivery. Where the hosted LSP would fail a payment back because there is no channel, no capacity, or no time left in the buffer window, it can open a claim cell instead. That is the integration proposed in package D. What already exists Everything below is public at Akane-CN/fiber-claim-cell and can be reproduced from the repository. Item Status RFC 0001 : async receive Draft. Timing rules checked against the Fiber source at commit 21c4dfb async-claim-lock L1 script Implemented in Rust, 17 KB. 33 script-level tests pass in the CKB-VM verifier. The build is reproducible and checked against the deployed code hash Lock script on testnet Deployed . 25 on-chain checks pass for CKB and xUDT, including 15 transactions the node had to reject and did LSP-side module Reference implementation: registration, hold invoices, per-payment state machine, exposure cap, HTTP interface, and a refund watcher that holds no key. CKB payments only. It is a module for an LSP to run, not an LSP End-to-end run 27 checks pass on three Fiber v0.10.1 nodes built from source, on CKB testnet Watchtower recovery after an LSP outage One run at real timings: recovery succeeded and 9 of 10 checks pass. The failed check concerned force-close timing; the payer still showed the payment as in flight. See Risks for the full timeline, including the brief LSP restart. Internal review One adversarial review each of the script and of the LSP-side and page code. Every finding and what was done about it is in review-notes.md . It is not a substitute for the audit in package E A receive web app is also working. It turns an existing wallet into a receiver without changing the wallet: the page derives the payment secrets from one signed message, checks each claim cell against the chain, and submits the claim, which needs no signature. In a browser test on testnet, a wallet with no CKB and no Fiber node collected 248.75 CKB with no action beyond opening the page, and a second device with empty browser storage recovered the same pay link and history from the wallet alone. 11 checks pass. The test signs with a raw key; connecting a real wallet through the CCC connector is built in but has not been exercised. Recovery on another device relies on the wallet producing the same signature for the same message. Wallets that sign with passkeys do not, so for them the receiving identity lives only in the browser that created it. The end-to-end run used an ordinary Fiber node as the payer, with no knowledge of this protocol: Scenario Result on testnet Receiver wakes up and is paid over its channel Payer paid 100 CKB, receiver got 99.9 CKB, payer got the receiver’s preimage. About 10 seconds end to end Receiver offline, claims later on L1 A wallet that had never held CKB claimed 298.7 CKB with no signature. The LSP read the preimage from the chain and the payer’s payment then succeeded Nobody claims The LSP refunded after expiry. The payer’s payment failed cleanly and its channel balance returned to its original value LSP crashes while sending a claim cell, restarts, then is down when the cell expires The restarted LSP sent the same transaction again and only one claim cell existed. While the LSP was down, a watcher holding no key refunded the expired cell. The LSP came back, read the refund from the chain, and returned the payer’s money Reading the Fiber source also turned up two places where the public RPC documentation disagrees with the code, and one rule it does not state. The minimum final expiry delta is 160 minutes, not the documented 16 hours. cancel_invoice works on a held payment, not only on an open invoice as documented. And a hold invoice has no hold timeout of its own, which the documentation does not say either way: the 120-second hold timeout in the code applies only to multi-part payments whose preimage is already known. The RFC is written against the code. What this work has not yet shown: The refund and crash scenarios shortened the claim cell’s expiry to 90 and 150 seconds. Only the watchtower run used real, hours-long timings, and it ran once. A refund at real timings has not been tested. xUDT was verified at the script level only, not end to end. In the watchtower path, an upstream peer that does not force-close and a preimage that reaches the watchtower late have not been run. No real wallet has been connected to the receive page. The receiver cannot yet check the amount it is paid against what the payer sent. See Risks. The lock script has not been audited. How it works The payer pays an invoice whose hash was set by the receiver. The LSP holds the payment and sends the receiver a wake-up push. Path A, receiver online in time. The LSP forwards the payment with the same hash. The receiver settles, and the preimage goes to the LSP. Path B, receiver not online or has no channel. The LSP locks the amount in a claim cell on L1. The receiver claims later, and the preimage goes on chain. In the intended flow, the LSP uses the revealed preimage to settle upstream, completing the payer’s payment. If the claim cell is never claimed, the LSP refunds it and cancels the invoice, and the payer gets its money back. Both paths use a receiver-controlled payment hash. The LSP settles upstream with the revealed preimage; that preimage alone does not prove the correct amount has reached the receiver. Safe use also depends on amount verification, confirmations and the claim cutoff described under Risks. The funded work completes and validates these checks, with client claim logic included in the audit scope. Async receive (RFC 0001, working today). The receiver registers a pool of payment hashes with the LSP. The LSP issues hold invoices from that pool and holds an incoming payment without settling it. Path A. The receiver wakes up and hands the LSP an invoice for the same hash. The LSP pays it over their channel, learns the preimage when the receiver settles, and settles upstream. Path B. If the receiver does not show up, or has no channel, the LSP locks the amount in a claim cell on L1. The cell’s lock checks no signature. It only constrains outputs: a claim with the preimage can pay only the receiver, and a refund, which becomes valid at expiry, can pay only the LSP. Expiry does not close the claim path: from then until one of the two confirms, both are valid and they race. The receiver’s safety therefore also rests on client-side checks, described under Risks. The receiver claims later with a single L1 transaction and needs no CKB to do it, because the fee comes out of the cell. Refund. If nobody claims, the LSP refunds the cell and cancels the invoice, and the payer’s payment fails with nothing lost. Under HTLCs the payer’s payment stays pending until the receiver reveals the preimage, for at most the invoice’s final expiry delta, which Fiber caps at 14 days. This is a limit of the design, stated in the RFC. Receiving stablecoins with zero CKB. A UDT cell needs 142 CKB of capacity that a new user does not have. On path B the LSP fronts that capacity and deducts its value from the payment at a quoted rate. The script-level version of this already passes on testnet. Scope The scope is the on-chain claim capability, made safe enough for an LSP operator to switch on. Everything is released under the MIT licence. Core scope (packages A, C, E and F): The async-claim-lock script: reproducible build, audit, mainnet deployment. RFC 0001, revised for the timing and liveness rules found in testing. The LSP-side module that holds a payment, opens and refunds claim cells, and settles upstream, with the safeguards an operator needs: refund watchers, an exposure cap, crash recovery. A client library that carries the receiver’s safety checks, so wallets do not reimplement them. Optional extensions: B. Stablecoins: payments end to end, including capacity fronting for receivers with no CKB. D. Hosted LSP integration: the claim path takes over where a hosted delivery cannot complete. Dropped from the earlier draft, because others are already building them: Holding a payment for an offline wallet that has a channel. Fiber’s hosted delivery does this, with a 24-hour default window. A specification and implementation for giving wallets inbound channels. Fiber’s LSP support and Cellula’s LSP cover this. A public reference LSP on mainnet. Cellula has an approved proposal covering public LSP operation and channel liquidity. Liquidity capital of any kind. Work packages and budget Engineering deliverables are fixed-price. Package E includes an estimated audit fee, which is confirmed before voting. Package F is reimbursed at actual cost up to its ceiling. Accepted engineering packages are paid less any advance already credited to them. Delivery overruns are not added to the approved engineering prices. The core request is currently USD 26,500 for A, C, E and F. Packages B and D are optional. The final request is set before voting from the selected packages and the confirmed audit quote. Package What is delivered Budget, USD In the core A. Hardening RFC 0001 revised, including a rule that lets the receiver check the amount, implemented in the module. Tests at real timings, including the point where the node returns a held payment. Recovery from an LSP outage while claim cells are live. Refund watcher, preimage relay and exposure cap taken from the working prototypes to production. Signed receiver authentication, a real database 6,500 Yes B. Stablecoins xUDT payments end to end on testnet, with capacity fronting and its pricing 4,500 No C. Client library TypeScript library on CCC: hash pool, claim cell verification, confirmation and expiry rules, on-chain claim. The receive web app, which works with existing wallets through one signed message, taken from working prototype to release and tested with real wallets 6,000 Yes D. LSP integration The claim path as the fallback inside Fiber’s hosted LSP: when a delivery would fail for lack of a channel, capacity or time, a claim cell is opened instead. Built on Fiber’s LSP support once it is released 4,500 No E. Audit and mainnet Third-party audit of the lock script, of the client library’s claim logic, and of how the web app derives and stores its secrets. Fixes. Mainnet deployment with the code hash published 11,500 Yes F. Running costs Test infrastructure, mainnet deployment capacity, buffer for audit rework. A ceiling, not a fixed price: paid at actual cost 2,500 Yes Proposed core A, C, E, F 26,500 With both optional packages A, B, C, D, E, F 35,500 Before voting, two things can change the requested budget: Audit fee. USD 10,000 of package E’s price is the auditor’s fee. It is an estimate until a firm quotes for the script and the client logic together, and the price of E moves with the quote. Any saving is returned. Packages B and D. B depends on which stablecoin LSP operators want first. D depends on an operator agreeing to integrate and on Fiber’s LSP support being released; without both it is left out and not charged. All packages together take about four and a half months. For scale, among Community Fund DAO proposals: Cellula’s public LSP was approved at USD 22,258 plus up to USD 1,664 contingency. Pocket Node asked for USD 15,000 for one developer over four months. Three months of maintenance after the last package are included at no extra cost. Payment terms Payments follow the Community Fund DAO rules. The proposed schedule is below; the applicable rules will be confirmed with the DAO stewards before voting. Amount. The rules have budgets requested in CKB. The prices in this post are in USD. The voting post states the request as a CKB amount, converted from the final USD total at the CKB price on the day it is posted, and shows both figures. Quorum. Three times that CKB amount, as the rules require. Stages. The budget is over USD 10,000, so it is paid in stages. 10% of the final total is paid on approval, inside the rule’s limit of 20% and USD 10,000. That advance is not extra money: it is counted against package A, and the rest of A’s price is paid when A is accepted. Every other selected engineering package is paid in full when it is accepted. Package F is settled last, at actual cost up to its ceiling, and what is not spent is not claimed. Final amount. The request is fixed before the voting post, from the packages finally included and the auditor’s quote, and does not change after the vote. Reporting. At each stage, a public report of what was delivered and what was spent, as the rules require. Disbursement. By the DAO’s funds management committee under its default rules. Risks Risk How it is handled Fiber’s LSP support or Cellula’s LSP ends up covering the same cases The comparison under “Where this fits” is drawn from both teams’ public documents, and both are asked to correct it in this thread. Any package they already cover is dropped. The on-chain claim is built as a module they can adopt, not a competing service Claim and refund race after expiry. The script lets a claim through after expiry until the refund confirms, so a receiver who reveals the preimage too late can lose it to a refund that lands first The receiver’s client must stop claiming a fixed margin before expiry, and must wait for confirmations on the claim cell before revealing anything. These checks live in the client library, wallets use the library instead of reimplementing them, and the library’s claim logic is inside the audit scope alongside the script The LSP is offline when a claim lands. The node returns the incoming payment about 161 minutes before that payment expires. An LSP that is down between a claim and that point pays the receiver and collects nothing. A payer and a receiver acting together, or one person playing both, can time a claim to an outage and take the full amount Four layers. (1) The gap is sized to the operator’s recovery time: at least 24 hours, not the 4 hours used in testing, which leaves about 21 hours to come back and settle. (2) The refund needs no signature, so independent watchers submit it the moment the cell expires. (3) A watcher separate from the node reads the preimage from L1 and hands it to Fiber’s watchtower, so the payment can still be collected on chain after a force close. Fiber’s source shows this works only if the upstream peer force-closes, the preimage reaches the watchtower in time, and the LSP runs the watchtower itself. This was run once on testnet with real nodes and real timings. The LSP node was down when the claim landed, came back for about a minute to settle a second payment, and was then stopped for good with this one unsettled. The payer’s node force-closed at minute 266, and the watchtower collected the 200 CKB 82 minutes later, 62 minutes before the payment expired. 9 of 10 checks pass: the force-close timing check failed by one minute, after the test machine restarted and took the payer’s node down for up to 20 minutes. The payer’s node still showed the payment as in flight when the run ended. One run on one channel is not enough. The cases where the upstream peer does not force-close or the preimage arrives late, and the payer’s final state, are tested in package A. (4) The value in live claim cells is capped per receiver and overall, which bounds the worst case The receive page does not work with a given wallet. It has been tested only with a raw key, and recovery on a second device needs deterministic signatures, which passkey wallets do not give Compatibility is not promised in general. Package C is accepted only when two different existing wallets have each collected a payment unchanged, and the release lists the wallets tested and those that cannot recover on a second device The receiver cannot check the amount. The page learns what the payer paid from the LSP, so an LSP could open a smaller claim cell, let the receiver claim it, and settle the full amount upstream Open in the RFC today. The revision in package A has to close it, for example by having the receiver fix the amount for each hash or the payer carry it to the receiver, and the client library then enforces the rule The audit finds a serious flaw No mainnet deployment until every high finding is fixed. The script is under 500 lines with no signature verification. Package F holds a buffer for rework Held payments tie up liquidity along the route Invoices cap how long a payment may be held. Multi-part payments are disabled because Fiber can settle them partially when held. Designs based on PTLCs that remove the hold are out of scope Fiber’s RPC and LSP interfaces are still changing Fiber calls sit behind one client module, each release pins a Fiber version, and package D starts only after Fiber’s LSP support is released An operator enabling this needs capital locked in claim cells The exposure cap sets how much. This proposal asks for no capital; an operator funds its own No LSP operator adopts it Adoption is reported at each milestone but is not an acceptance criterion, because it is not ours to deliver. Package D is charged only if an operator commits CKB price moves The request is made in CKB, as the DAO rules require, converted from the USD total on the day of the voting post Acceptance and targets Acceptance criteria are things the team can deliver on its own, and each can be checked by anyone. Results that depend on other people are listed separately as targets: they are reported, but a milestone does not wait on them. Package Accepted when A. Hardening The revised RFC 0001 is published and open for review, with a rule for how the receiver checks the amount. A public test report shows the flow at real timings, the behaviour at the point where the node returns a held payment, and recovery from an LSP outage with claim cells live. Watchtower settlement has worked once; the report covers what that run did not: an upstream peer that does not force-close, a preimage that arrives late, a refund at real timings, and the payer’s final state B. Stablecoins A wallet holding no CKB receives a stablecoin payment through a claim cell on testnet, and the transactions are public C. Client library The library is on npm. Its tests show it refusing each unsafe claim: wrong cell, too few confirmations, too close to expiry. The receive web app collects a payment on testnet with at least two different existing wallets, with no change to either wallet. The release lists the wallets tested and those that cannot recover on a second device D. LSP integration The module runs inside the partner’s LSP on testnet, and a payment to a receiver with no channel completes through it E. Audit and mainnet The audit report, covering the script, the client claim logic and the web app’s secret handling, is public. Every high and medium finding is fixed. The script is on mainnet and its code hash matches the audited build. One payment to a wallet with no CKB and no channel completes on mainnet through our own instance, with the exposure capped F. Running costs Not a deliverable. Settled against receipts published with the final report, up to the ceiling. Unspent money is not claimed Targets, not criteria: At least one LSP operator, other than our own instance, switches the claim path on on mainnet. The intent is that no wallet has to change for this; which wallets that holds for is reported from package C. At least one Fiber core developer reviews RFC 0001. What we commit to is submitting it in a reviewable form and answering every comment in public. A second party runs the module from the documentation without our help. Sources Akane-CN/fiber-claim-cell : RFC 0001, the lock script, the LSP-side module, and the testnet reports. Fiber PR #1623, LSP support : the core team’s LSP work, open at the time of writing. [DIS] Cellula on Fiber and its vote result : the approved public LSP proposal, its budget and its payment terms. CKB Community Fund DAO Rules and Process : the rules in force. Fiber: Protocol-Complete, Network-Tested – 2026 Outlook : liquidity as a 2026 focus. Fiber source at commit 21c4dfb : hold invoice behaviour and expiry constants. async-claim-lock, refund and payout checks : the script rules described under Risks. Fiber issue #1625, multi-tenant hosted LSP design : the hosted model, delivery buffering, trust assumptions and non-goals. Cellula LSP scale test : architecture and the requirement that the payee be awake to sign. Link

forum.cosmos.network: Disabling tokenization on staked ATOM: what the lock stops and what it doesn't<br /> Several posts here since 7 November describe the same thing happening to staked ATOM. The delegation gets tokenized with MsgTokenizeShares and the share tokens go to another address in the same transaction, often with the reward withdraw address changed too, and none of it waits 21 days. The clearest public example is the 7 November “lsm recovery batch” (D2283D7E…). It has 27 messages from six delegators in one block, including 10 tokenizations and 6 withdraw address changes. That one went to Web3Auth’s published recovery address. An attacker with the same keys could have sent the same transaction. This came up here in July 2025 too, and the advice then was to disable tokenization on your address. In the wallet vacuum thread I wrote that with tokenizing disabled, someone holding your key can only start a 21-day unbond or the 21-day wait to turn it back on. That’s true for the stake itself. It misses the rewards, and it misses that you can cancel their re-enable, so I read x/liquid in Gaia v29.0.1 (unchanged in v29.1.0) to see what the lock really covers. The lock MsgDisableTokenizeShares puts a lock on your address, so it covers every delegation from it. TokenizeShares checks that lock before anything else and refuses while it’s on ( msg_server.go L79-L86 ). Outside its own two messages and the status query, that’s the only place Gaia reads it, so everything else about the delegation works as before, unbonding included. It costs one transaction fee. MsgEnableTokenizeShares doesn’t unlock anything right away. It queues the unlock for the block time plus the unbonding period ( liquid_stake.go L349-L366 ), which is 1,814,400 seconds on the Hub today, so 21 days, and until then the status reads LOCK_EXPIRING with the date. If you send disable again during that window, the pending unlock is taken out of the queue and you’re fully locked again ( msg_server.go L430-L478 ). So an enable you didn’t send gives you 21 days to see it and cancel it, and whoever sent it has to start over. What it leaves open MsgSetWithdrawAddress is in x/distribution and never looks at the lock. Someone with your key can point your rewards at their own address and claim what has built up right away. The 7 November batch changed it on all six accounts, and one of the 10 November reports here asks about it too. If you get control back, check it and set it again. Undelegating still works for whoever has the key. It takes 21 days, and the delegator can cancel an unbonding with MsgCancelUnbondingDelegation , but whoever holds the key can do the same, and when it completes the ATOM lands at the same address. The lock doesn’t make a leaked key safe. It makes sure nothing leaves in one block, and the slow paths show on chain while they run. On the other hand, the 7 November batch worked as a recovery only because those six accounts could still tokenize. With the lock on, a recovery team holding the key waits 21 days like anyone else. Checking yours gaiad q liquid tokenize-share-lock-info <address> or /gaia/liquid/v1beta1/tokenize_share_lock_info/<address> on any Hub REST endpoint. You get TOKENIZE_SHARE_LOCK_STATUS_LOCKED , _UNLOCKED or _LOCK_EXPIRING with an expiration_time . A LOCK_EXPIRING you didn’t start means send disable now. Turning it on is gaiad tx liquid disable-tokenize-shares --from <key> , or any wallet that can sign that message. A wallet that already lists delegations could show this status next to them with one query, and flag an enable or a withdraw address change the user didn’t send. Link

talk.nervos.org: Spark Program | SkillPass Care — Transferable Warranty Pilot for Second-Hand Products on CKB<br /> Applicant: Dang Ba Ty ( @Dangbaty2004 ) GitHub: tydeptrai21042004 Discord: tyforwork Email: dangbaty.work@gmail.com Funding requested: $500 USD, payable in equivalent CKB Estimated duration: 4 weeks Project category: CKB dApp / Product MVP / Early User Validation Target network: CKB Pudge Testnet Project links: SkillPass protocol: https://github.com/tydeptrai21042004/ckb-skill SkillPass Care application: https://github.com/tydeptrai21042004/SkillPass-Care SkillPass demo: https://ckb-skill.vercel.app/ SkillPass Care demo: https://skill-pass-care-api.vercel.app/ CKBuilder technical review: https://github.com/Nervos-Community-Catalyst/CKBuilder-projects/issues/37 Existing real Testnet evidence: https://github.com/tydeptrai21042004/ckb-skill/actions/runs/39808161770 1. Project Overview SkillPass Care is a CKB-based application for transferable product-service coverage, initially focusing on refurbished and second-hand electronic devices. The problem is straightforward: when a product is resold, any remaining warranty or service entitlement may be difficult for the next owner to verify or use, particularly if different service providers maintain separate customer records. SkillPass Care explores a different approach. A service entitlement is represented by a transferable Capability Cell on CKB, while the application maintains the coverage plan, remaining service units, and service history. When Alice transfers the entitlement to Bob, authorized providers can verify Bob’s current ownership from CKB without relying on a shared entitlement-owner database. An existing SkillPass Testnet experiment has already demonstrated issuance, transfer, and ownership verification. The proposed Spark project will turn this technical foundation into a usable warranty pilot and test whether the workflow provides practical value to users and service providers. The objective is to deliver and evaluate one complete product-service lifecycle, not to develop a new general-purpose protocol. The funded work will focus on a limited warranty workflow, real Testnet ownership integration, user-facing improvements, and initial external validation. 2. Team Profile I am Dang Ba Ty, an independent developer contributing to the Nervos CKB ecosystem. My work has focused on CKB Cell-based applications, transaction construction, verification, and developer-facing tools. I developed the underlying SkillPass protocol and the SkillPass Care reference application. Both are publicly available, with ongoing technical discussion through the CKBuilder program. SkillPass has received CKBuilder mentorship support, including the assignment of @zhangsoledad for technical review. Relevant development experience includes: Rust and ckb-std for CKB Type Scripts. TypeScript, Node.js, and React for applications and verification tooling. CCC and wallet integration for CKB transactions. PostgreSQL for persistent application state. GitHub Actions for reproducible testing and public technical evidence. I will be responsible for implementation, Testnet validation, documentation, user-testing coordination, and reporting. External reviewers and pilot participants will be invited to evaluate the results; their participation is not assumed or presented as confirmed. 3. Project Background Consider a customer who purchases a refurbished smartphone with three remaining service units. The customer, Alice, uses one diagnostic service at Provider A. She then sells the phone to Bob. Bob wants to use the two remaining service units at Provider B. In a conventional provider-specific warranty system, this process may require manual ownership updates, account migration, or coordination between providers. A warranty recorded only against Alice’s original customer account may not automatically follow a transferable entitlement. SkillPass Care investigates whether CKB can provide a shared ownership reference without requiring each provider to maintain synchronized ownership records. The proposed workflow is: Alice receives a service entitlement containing three coverage units. Provider A verifies Alice and records one service, leaving two units. Alice transfers the Capability Cell to Bob through a CKB transaction. After the transfer is confirmed, Alice is no longer authorized to use the entitlement. Provider B independently verifies Bob and processes another service. The remaining balance becomes one unit, with both service events preserved. This scenario provides a concrete way to test the usefulness of portable service rights. The project does not assume that customers or businesses already demand blockchain-based warranties. Establishing whether the workflow is understandable, useful, and preferable to simpler alternatives is part of the proposed validation. 4. Proposed Solution SkillPass Care will provide a small, end-to-end warranty application covering issuance, service usage, ownership transfer, and continued service eligibility. The pilot will use one representative refurbished-electronics coverage plan, with a fixed service-unit allowance and two provider configurations. 4.1 Customer experience A customer will be able to: View an assigned service entitlement and its remaining coverage. Connect a supported CKB wallet to verify entitlement ownership. Transfer the entitlement to another wallet. Review service history and remaining service units. Present the entitlement to a provider for verification. The application will explain the difference between pending, confirmed, rejected, and unavailable verification results. 4.2 Provider experience A participating provider will be able to: Check the current entitlement holder against CKB. Review the applicable coverage plan and remaining service units. Record a permitted service event. Reject requests from the previous owner after a confirmed transfer. Detect duplicate service submissions and prevent repeated consumption. Provider verification will use the current live Capability Cell and the application’s coverage rules. 4.3 Pilot scope The initial pilot will focus on one complete scenario rather than supporting an open-ended warranty marketplace. The acceptance scenario is: Step Expected result Alice receives coverage 3 units Provider A completes diagnostic 2 units Alice transfers entitlement to Bob CKB ownership changes Alice requests another service DENY Bob requests service at Provider B ALLOW Provider B completes service 1 unit Service history is inspected Both provider events retained The application will support English-language instructions and expose sufficient information for participants to understand the process without inspecting smart-contract code. The pilot will not claim that ownership of a digital service entitlement independently proves ownership or possession of the associated physical device. Product identity and eligibility remain subject to issuer and provider verification. 5. Technical Approach SkillPass Care uses two distinct layers. 5.1 CKB ownership layer The existing SkillPass protocol represents a service entitlement through a Capability Cell. The live Cell’s lock identifies the current authorized holder, while the Capability Type Script constrains entitlement transitions. The application will use the existing canonical SkillPass verification interfaces to establish current ownership. Provider decisions must account for: The recognized Type Script deployment. The current live Capability Cell. The entitlement identity and applicable policy. The claimant’s wallet authorization. Transaction confirmation and chain-state freshness. Unavailable or contradictory verification evidence. An unavailable RPC response must not be interpreted as successful authorization. 5.2 Application layer SkillPass Care maintains product-specific state separately from CKB ownership. This includes the coverage plan, remaining service units, service-event history, provider authorization, and issuer suspension or revocation. The existing implementation uses TypeScript, React, Node.js, and PostgreSQL. The funded work will connect the application to the real SkillPass Testnet ownership path, improve the customer/provider workflow, and exercise the complete lifecycle through the hosted application. The pilot will reuse the existing Capability contract, ownership interfaces, and Care domain model. It will not introduce another blockchain protocol or a replacement for CCC. 5.3 Service integrity The pilot will test that: A previous owner cannot consume coverage after a confirmed transfer. The same service request cannot consume coverage twice. Concurrent service requests cannot consume more units than remain available. Provider authorization is bound to the specific entitlement and requested service. Missing chain evidence leaves the operation unapproved. Ownership transfer preserves the associated coverage history. A configurable confirmation policy will be documented. No fixed confirmation depth will be presented as an absolute finality guarantee. The project will remain on CKB Pudge Testnet. It is not intended to provide production-grade insurance, a legally enforceable warranty, or custody of real customer funds. 6. Execution Plan and Milestones Total duration: 4 weeks M1 — Real Testnet Ownership Integration Week 1 Connect SkillPass Care to the existing canonical SkillPass ownership-verification path. Tasks: Pin the supported Capability deployment and protocol version. Integrate real Testnet entitlement lookup and authorization. Connect the Care runtime to canonical SkillPass ownership evidence. Verify current-owner and previous-owner behavior. Establish reproducible integration tests. Deliverable: A working Care application that can distinguish valid, stale, and unavailable ownership using CKB Testnet evidence. Acceptance criteria: The application verifies an existing real Capability ownership state and rejects unsupported or stale ownership rather than falling back to simulated authorization. M2 — Transferable Warranty Product MVP Week 2 Complete the user-facing warranty lifecycle. Tasks: Connect the existing coverage-plan workflow to real ownership verification. Support the Alice-to-Bob wallet transfer scenario. Preserve coverage units and service history across transfer. Complete Provider A and Provider B service workflows. Improve customer-facing transaction and authorization status reporting. Deliverable: A public Testnet-oriented application demonstrating the full transfer-and-service workflow. Acceptance criteria: The documented scenario produces 3 → 2 → transfer → 1 coverage units, with Alice rejected and Bob authorized after the confirmed transfer. M3 — Reliability and Pilot Preparation Week 3 Prepare the product for controlled external evaluation. Tasks: Test duplicate requests and concurrent service consumption. Test stale ownership, incompatible entitlements, and temporary RPC failures. Validate restart-safe Care records using PostgreSQL. Run two separately configured provider instances or processes. Prepare a short user guide and a repeatable pilot script. Deliverable: A tested pilot release with documented failure scenarios and a guided walkthrough. Acceptance criteria: Automated tests pass for the principal authorization, transfer, quota, and failure-handling scenarios. Any unresolved failure is documented rather than silently treated as success. M4 — Early User Validation and Final Evidence Week 4 Conduct an initial product evaluation and publish the results. Tasks: Invite potential refurbished-electronics sellers, repair providers, and individual users to test the workflow. Target at least three external participant sessions, including feedback from at least one potential service provider. Record whether participants can understand ownership transfer, remaining coverage, and service eligibility. Collect usability concerns and assess whether simpler non-blockchain alternatives would meet their needs. Publish the final Testnet evidence package, reproduction instructions, and summary report. Deliverable: Public pilot report, reproducible technical evidence, and updated application documentation. Acceptance criteria: Completed outreach and testing are reported with actual participation counts, observed issues, and findings. If the recruitment target is not reached, the report will document the shortfall and the evidence actually obtained. No external provider participation is claimed before it occurs. 7. Required Funding and Funding Breakdown Total requested: $500 USD equivalent in CKB. The funding supports incremental development and early product validation over four weeks. Work package Funding Canonical CKB ownership integration and verification $175 Transferable warranty MVP and provider workflows $150 External pilot preparation and user testing $100 Reproducible evidence, documentation, and final report $75 Total $500 The requested amount is intended to cover a limited validation phase, not the complete historical development cost of SkillPass or SkillPass Care. Existing contract code, earlier Testnet transactions, application components, and prior testing will be reused without requesting retrospective funding. The project will use public Testnet infrastructure and existing open-source tooling wherever feasible. I will publish milestone updates and a final summary of fund allocation and completed work. 8. Deliverables and How to Verify 8.1 Expected deliverables Deliverable Format Verification Real ownership integration Open-source code Valid and stale ownership tests Warranty MVP Hosted application Complete Alice → Bob lifecycle Provider workflows Source code and test reports Provider A/B verification and service usage Safety regression coverage Automated CI tests Failure and duplicate-request tests Testnet evidence JSON, transaction hashes, logs Independent public-chain inspection Early user evaluation Public report Actual participation and feedback summary Final documentation Markdown and walkthrough Clean-checkout verification 8.2 Independent verification A reviewer should be able to inspect the result without trusting screenshots or developer assertions alone. The final evidence package will include: The exact source revision used for testing. Capability Type Script deployment identity and code hash. Testnet issuance and transfer transaction hashes. Input and successor OutPoints. Relevant transaction confirmation evidence. Provider authorization decisions before and after transfer. Care service-event records and remaining-unit transitions. Automated test results. The pilot report and reproduction instructions. The reviewer can follow these steps: Open the public SkillPass Care application and follow the guided scenario. Inspect the published CKB transaction hashes and confirm the ownership transition. Check that the previous entitlement OutPoint is spent and the successor Cell corresponds to the new holder. Verify that the post-transfer authorization evidence rejects Alice and accepts Bob. Inspect the Care service-event report to confirm that two services were recorded and one coverage unit remains. Review the published CI results for duplicate requests, stale ownership, and unavailable RPC data. For source-level reproduction, the existing repository provides: npm install --no-audit --no-fund npm run check npm run verify:care The final release will document any additional configuration and verification commands needed for the integrated Testnet workflow. Read-only review of published evidence will not require a funded wallet. Repeating the complete live transaction workflow will require a CKB Testnet wallet, Testnet CKB, and RPC connectivity. Successful completion means a reviewer can verify both the ownership transfer on CKB and the corresponding service-coverage continuity in SkillPass Care. The project will not substitute synthetic transactions for the required final Testnet evidence. 9. Current State vs. Funded Work 9.1 Work already completed The existing SkillPass project includes: A Capability Cell model for transferable service entitlements. A CKB Type Script and associated contract tests. Issuance and ownership-transfer logic. Current-owner and stale-owner verification. Wallet connectivity and a hosted interface. A previously completed real CKB Pudge Testnet lifecycle. A successful GitHub Actions run is publicly available: github.com Add files via upload Real CKB Testnet — Deploy + Lifecycle #6 The previously published Testnet evidence includes: Contract deployment 0xb340d171bb9cc0e25e580c406bf2379d8753cddfb38920eade177c896e12a39d Capability issuance 0xbeab784808e46377466605f79be2ea3a0fdeef16e83532d18f735c927025aa25 Alice → Bob transfer 0x223ba748f9bb09c4951e8b0db92f119d1bd046a80d62ece3e33e488d00aafc53 The CKBuilder update reports successful ownership checks by two provider configurations before and after the transfer, including 16 on-chain verification checks. This is existing protocol evidence, not a completed end-to-end SkillPass Care product pilot. SkillPass Care already includes: Product-service coverage plans. Remaining-unit accounting. Service-event history. Provider-specific workflow rules. A PostgreSQL-backed application state model. A canonical ownership integration interface. In-memory and persistence-based tests. A hosted product demonstration. These components are already implemented and are not being submitted as new funded deliverables. 9.2 New work requested from Spark The requested grant is limited to: Completing and validating the real canonical Testnet ownership integration within SkillPass Care. Demonstrating the complete warranty workflow with real ownership transfer and persistent Care state. Improving the customer/provider experience sufficiently for controlled external testing. Running an initial product evaluation with potential users and service providers. Publishing a reproducible technical and usability evidence package. The distinction is intentional: the existing SkillPass lifecycle establishes that ownership transfer works; the funded pilot will examine whether that capability produces a usable warranty application. 9.3 Scope exclusions The four-week pilot does not include: Mainnet deployment or handling real customer funds. A new CKB Type Script protocol. A warranty marketplace or payment-processing system. Fiber or x402 integration. DID, reputation, or credential infrastructure. Verification of physical-product possession or legal title. Claims of independent legal or smart-contract security certification. These exclusions keep the project focused on one measurable product experiment. 10. CKB Alignment and Ecosystem Value SkillPass Care uses CKB’s Cell model as the ownership foundation for portable service entitlements. Its main CKB-specific properties are: Transferable entitlement ownership A Capability Cell can move between wallet-controlled locks through a CKB transaction. The application derives the current holder from canonical chain state rather than relying on a manually synchronized owner field. Independent provider authorization Different providers can verify the same entitlement identity and its current owner without sharing an entitlement-owner database. Each provider can still maintain its own service policies. Separation of ownership and application state CKB records the transferable entitlement, while SkillPass Care manages service quotas, history, and provider operations. This avoids putting every repair or diagnostic event on-chain. Wallet-based control Customers can use supported CKB wallet mechanisms to control entitlement transfers and prove authorization without giving a warranty provider custody of their private keys. The experiment aims to determine whether this design is useful for a tangible consumer-facing scenario: transferring remaining service coverage when a second-hand product changes hands. A successful pilot would provide an open-source example of how a CKB-native service right can support an application used by more than one provider. An unsuccessful or inconclusive pilot would also provide useful evidence about adoption barriers, wallet friction, operational complexity, or cases where an ordinary database-backed solution is more practical. 11. Risks, Evaluation, and Reporting Risk Mitigation Real ownership integration is incomplete Use the existing deployment-pinned SkillPass interfaces and keep unresolved verification fail-closed Chain or RPC data is unavailable Report an inconclusive state instead of authorizing service Duplicate or concurrent requests consume excess coverage Apply idempotency and transactional quota checks Pilot participants are difficult to recruit Begin outreach early and publish actual responses, including unsuccessful outreach Users find wallet-based warranties too complicated Measure completion difficulties and compare with simpler alternatives Project scope exceeds four weeks Keep one product scenario, one coverage plan, and two provider configurations Progress will be reported at the end of each milestone through the repository and Nervos Talk. The final report will distinguish completed functionality, verified on-chain evidence, external feedback, and any unmet objectives. 12. Expected Outcome At the end of the four-week Spark pilot, SkillPass Care should provide: A usable CKB Testnet warranty application demonstrating ownership transfer between two customers. A complete service lifecycle preserving remaining coverage across that transfer. Provider workflows that verify the current entitlement holder and reject stale authorization. Public, reproducible evidence connecting CKB ownership changes with application service records. Initial feedback establishing whether the product concept is useful and what would be required for a larger pilot. The requested $500 will support this focused product-validation milestone, not another general-purpose infrastructure layer. If the pilot establishes meaningful developer or provider interest, a larger deployment or commercial integration can be considered separately. The immediate goal is more modest: demonstrate one complete application, allow others to verify it, and learn whether transferable warranty coverage is a useful CKB product. Thank you to the Spark Program Committee and CKBuilder mentors for reviewing the project and supporting its technical development. I welcome feedback on the proposed scope, acceptance criteria, and whether this focused product pilot is appropriate for Spark funding. Link

forum.pyth.network: [Pythian Council Election #6] Kirito - Pyth Network<br /> Name of Candidate : Kirito Role: Chiron at PythNetwork and Aristophane (Content Creator) Location: North Africa Twitter handle : @KiritoDotSol Discord handle : @kirito.sol Github handle : kiritoDotSol Solana : 8k3GAqACXrZDTUeHKkwPXA1tvRyVeRm5nz3kBp5W6xdN Eth : 0x293c97E36A8391B071CF7e6Ed1E6332DeAa50CFd Signing-key custody: Safepal hardware wallet for both keys Motivations to Participate in the Community Council : Pyth becomes more than just a project to me, it’s a space where I create, share, and connect with people as a Chiron & Aristophane. What motivates me is being able to contribute to how the community grows and feels. I see Pyth not just as important infrastructure in Web3, but as a community built by its people. Through my work in illustration, graphic design, and videos, I try to make Pyth more engaging and easier to connect with. I’d like to be part of the Council to keep pushing that forward and help create a space where people feel comfortable contributing and being part of something real. Relevant Experience : I have over 7 years of experience in web development, working on different real-world projects. I also have a Master’s degree in Management of Information Systems, which helps me understand the technical side behind what we’re building. On Pyth, I contribute as aristophane by creating visual content, such as illustrations, designs, and videos that help represent the ecosystem in my own style. I’ve been active in Web3 for a while now, and I really believe in what Pyth is building long term. Link