LIVEPublicAPI accessHosted by@OpticFeeds

DeFi Governance Forums

Feed: gov-forums-topic-post 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-GovFreeDelayed 10 s for guests49

Connect your agent

Follow https://synoptic.com/p/streams/defi-governance-forums-96zcg/SKILL.md to connect DeFi Governance Forums 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: Sigsheet: one file for signing CKB multisig transactions across ckb-cli, Neuron and CCC apps (first spec draft, feedback wanted)<br /> Hi everyone, We’ve published the first draft of Sigsheet , an open file format for signing a CKB multisig transaction. Each signer uses the wallet they already have: ckb-cli, Neuron, or an app built on CCC. We’d like your feedback before we write the implementations. The problem A CKB multisig transaction is usually signed by several people, often with different tools. Today two things get in the way. Partial signatures don’t travel between tools. ckb-cli, Neuron, CCC and ckb-sdk each hold a partly signed multisig transaction in a different way. The incompatibility between ckb-cli’s tx file and Neuron was reported in 2024 ( ckb-cli#584 , neuron#3048 ). In our tests with ckb-cli 2.0.0, Neuron 0.204.1 and CCC 1.23.1, none of the three read another’s partial signatures: they were dropped on import, lost silently, or the file couldn’t be read at all ( the measurements ). So in practice, one person collects everyone’s signatures and assembles the transaction. Fiber’s 0.7.0 mainnet script upgrade this month, for example, gathered four of its five signatures from pull request comments ( fiber-scripts#34 ). A signature doesn’t cover the input cells. The multisig lock signs the transaction hash and the witnesses, and the transaction hash covers each input’s out point, not the cell it points to. A signer who can’t see the input cells can’t check the amounts they are signing. What Sigsheet is One canonical JSON file per transaction. It carries: the transaction, with a witness template for each lock group to be signed; the previous transaction of every input, so a reader checks every input cell offline, by hash; the block headers and inclusion proofs a Nervos DAO withdrawal needs; the multisig configs; every signature so far, keyed by lock group and signer. How it’s used: Signers pass the file along, or each one shares a copy and anyone merges them. Any order gives the same bytes. Whoever holds a ready file finalizes it into a standard transaction. It works with the multisig locks and addresses already on chain: the genesis, 2024 and v2 deployments. There’s no new on-chain script. The goal One file that every signer’s tool reads and writes: ckb-cli and Neuron directly, and apps built on CCC through a separate package. Signatures then move between tools with no bridge in the middle, and nobody has to collect and forward them. What’s published All of this is in github.com/ILE-Labs/Sigsheet , linked at commits 4588a55 on main and e4896d3 on research so every comment refers to a known version: The specification, first draft . It covers: the file and its canonical form; 31 reader checks, all run offline; the message rule of each lock; merge, ready and finalize, including a rule for the signature sets the genesis multisig binary rejects; what a signer is shown; creating and sending; security considerations. Every rule links to its evidence. Test vectors : 24 cases, 18 attacks and 2 mainnet transactions, rebuilt byte for byte by one command. An independent check: every message is recomputed with CCC’s and ckb-cli’s own code; every signature is recovered; every final transaction runs through the deployed lock binaries under ckb-debugger. The checks run on Linux, macOS and Windows. The design record and its benchmarks , on the repository’s research branch: every decision, with its evidence; the paths considered, and why each was dropped; the experiments. What we’ve learned since publishing On ckb-devrel/ccc#646 , CCC’s maintainer closed the request: CCC currently has no plans to include Sigsheet, and further progress is welcome here on Nervos Talk. So we’re building it as a separate package on @ckb-ccc/core as published, with no change to CCC. The thread also asked why a new format is needed at all; the first question below answers it. We’ve also shared it with ckb-cli’s and Neuron’s maintainers ( ckb-cli#694 , neuron#3518 ). Two questions we’ve already been asked Why not keep the partial signatures in the transaction itself? We tested that as our path D, and two design-stage measurements on Fiber’s 0.7.0 upgrade (a 3-of-5 multisig whose members sent five signatures) moved us off it. A witness with M slots can’t keep the signatures beyond M, and merging the five copies inside the witness in all 120 orders gave 60 different results ( X3a, section 1 ). Sigsheet keeps every signature by lock group and signer: its merge gave the same result in 2,000 of 2,000 trials ( X3a, section 2 ), and finalizes to the standard transaction ( why path D was dropped ). Why not a hosted multisig wallet? A hosted wallet removes the exchange when every member uses it. Sigsheet is for groups whose members sign with different tools, such as ckb-cli and Neuron, on any of the three multisig deployments. A service like that could also read and write the same file. What’s next: the roadmap to v1.0 v0.1 : the specification after this feedback; a TypeScript library on CCC, the reference implementation; ckb-cli commands, in Rust; Neuron support through Offline Sign; a demo on testnet with all three tools. v0.2 : a readable summary for signers; a ckb-cli command that writes the file and that summary in one step; an optional relay that carries one signature at a time, about 367 bytes at design stage, instead of the whole file; Neuron’s own Sigsheet screens; Omnilock’s multisig mode; support in more tools. v1.0 : a stable specification with a conformance suite any implementation can run, proposed as a CKB RFC. None of this depends on any project including the changes: the TypeScript library will work with CCC as published; the ckb-cli and Neuron changes will be available as builds from the repository. At design stage, each wallet’s change was small: 381 code lines in ckb-cli, 229 in CCC and 137 in Neuron; each wallet’s own tests gave the same results before and after ( X6 ); on a local devnet, ckb-cli, CCC and Neuron signed one shared file in seven flows, all committed ( X5 ). The feedback we’re looking for If you sign multisig transactions today, for a treasury, a team wallet or script deployments: which tools do your members sign with, and which transactions? We’ll make sure the first implementations cover them, and once they exist we’d like to run one of yours through Sigsheet with you, on testnet. Wallet and SDK maintainers: what would your signing flow need from the format? Security reviewers: the reader checks (§5); the signature rules (§7); the attacks considered (§13). CoBuild and CKB IDL: the boundary in Annexes A and B. @quake , @phroi : Fiber’s 0.7.0 upgrade, which you both took part in, gathered its five signatures from the deploy file and four pull request comments. It’s the case we most want to get right. A whole Sigsheet file for that upgrade is about 733 KB at design stage, far more than a signature in a comment. So v0.2 adds a ckb-cli command that writes the file in one step, and a relay message of one signature, about 367 bytes. Your view on how signatures should travel in that flow would help most. @doitian : the request-signature step you planned for ckb-cli deploy ( ckb-cli#603 ) is the job we want Sigsheet’s file to do, and your view on what it needs would help too. @RetricSu , @rink1969 : you’ve signed multisig transactions with ckb-cli and Neuron and run into their limits ( ckb-cli#658 , neuron#3260 ), and we’d value your view of the draft. Every change the feedback leads to will be listed in the repository with specification v0.1, and linked from this thread. Thanks for reading. We’ll answer every comment here. — ILE Labs Link

talk.nervos.org: Unlinked for CKB: Tor-Routed RPC and Browser Privacy Extension<br /> Funding requested: $1,000 Project duration: 6 weeks Category: Developer Tools / Privacy Target ecosystem: Nervos CKB License: Open source Applicant: Owais (GitHub: owaisdotcom) · Full Stack Software Engineer 1. Project Overview Unlinked for CKB is an open-source browser extension prototype designed to improve privacy when interacting with Nervos CKB decentralized applications. It adapts the anon-rpc architecture and browser-based Tor client (tor-js, based on Arti compiled to WebAssembly) to the CKB ecosystem. The goal is to let users route supported CKB RPC requests through Tor directly from their browser, without requiring them to install or operate a separate native Tor daemon. The extension will investigate running the privacy worker in a sandboxed browser environment and integrating it with CKB RPC endpoints to provide Tor-routed blockchain access. The prototype will implement two complementary features: Tor-Routed CKB RPC: A browser-compatible transport that routes supported CKB RPC requests through the Tor network, reducing the ability of RPC endpoints to associate requests with a user’s direct IP address. Wallet Privacy Inspector: A browser-based inspection tool that detects CKB addresses and recognizable wallet-related information in outgoing requests and shows users which external domains receive that information. The project will focus on building a functional prototype rather than a production-ready privacy service. It will adapt existing technologies, develop the CKB-specific integration, test both features in real browser environments, and publish the resulting software with documentation and demonstrations. The goal is to give CKB developers and users an early, usable example of browser-level privacy tooling, while providing a foundation for further development in the Nervos ecosystem. 2. Problem Statement When users interact with CKB dApps, information can be exposed through both network connections and application-generated browser requests. Network-level exposure When a browser communicates directly with a CKB RPC provider, that provider can observe the connecting IP address. Changing RPC providers does not necessarily prevent this exposure. Tor offers a way to route network connections through multiple relays, making it harder for the destination endpoint to associate requests with the user’s direct IP address. However, browser networking restrictions make a browser-native implementation challenging. Wallet information disclosure A dApp may transmit CKB addresses or other recognizable wallet information to external services through browser requests. These services can include analytics providers, application APIs and other third-party endpoints. Users generally have little visibility into which domains receive this information. Unlinked aims to address these two problems through a browser extension that provides experimental private RPC access and local inspection of outgoing wallet-related information. 3. Why Nervos CKB? CKB’s Cell model and Lock Script architecture provide recognizable structures that can be used when inspecting wallet-related information. CKB addresses encode information about locking scripts and their arguments. This gives the privacy inspector a practical starting point for detecting CKB-related identifiers in outgoing requests. The prototype will investigate how to recognize these structures without accessing private keys or uploading users’ browsing data. CKB also has an ecosystem of wallets, dApps and RPC-based applications that provides a relevant environment for developing and testing browser privacy tooling. The project complements existing CKB infrastructure. A Light Client can independently verify blockchain data, while Tor addresses network-level IP exposure. These are different capabilities, and the prototype focuses on exploring the latter alongside wallet information inspection. 4. Proposed Prototype Unlinked for CKB will consist of a browser extension with two main experimental features. 4.1 Tor-Routed CKB RPC The first feature will prototype browser-compatible access to CKB RPC endpoints through Tor. The intended request path is: Browser extension → Tor-compatible transport → Tor network → CKB RPC endpoint The prototype will investigate existing browser-compatible Tor technologies, including Arti-based WebAssembly approaches where practical. Initial development will focus on: Establishing a browser-compatible Tor transport. Connecting to a configurable CKB RPC endpoint. Routing a defined set of CKB JSON-RPC requests through Tor. Displaying connection and routing status in the extension. Handling connection failures without silently falling back to a direct connection. The objective is to demonstrate that a browser extension can make supported CKB RPC requests without exposing the user’s direct IP address to the destination endpoint. The initial prototype will use existing Tor technologies rather than attempt to implement the Tor protocol from scratch. If an external gateway or relay is required, its role and operational dependencies will be documented. 4.2 Wallet Privacy Inspector The second feature will prototype local inspection of outgoing browser requests to identify CKB wallet-related information. The initial version will inspect Fetch and XMLHttpRequest traffic. It will attempt to detect: CKB addresses. Recognizable Lock Script arguments. Other identifiable CKB wallet-related values. External domains receiving detected information. The extension will display findings in a per-site privacy report. For example, when a dApp sends a user’s CKB address to an external analytics endpoint, the extension will identify the destination domain and show the detected information. The inspector will operate locally in the browser. It will not upload inspected request contents to a central service. The initial prototype will focus on Fetch and XMLHttpRequest. WebSocket and other traffic types may be explored later, but will not be required for the first version. 5. Prototype Architecture Browser extension The main interface will provide connection controls, privacy inspection and per-site reports. Tor transport A browser-compatible Tor transport will be integrated for supported CKB RPC requests. The implementation will evaluate available WebAssembly and browser networking approaches. CKB RPC integration The extension will connect to a configurable CKB RPC endpoint and support a defined subset of JSON-RPC methods. Request inspection The inspector will analyze observable Fetch and XMLHttpRequest requests for recognizable CKB wallet information and associate findings with destination domains. Local privacy reporting Inspection results will be presented locally, without sending browsing or wallet information to a central analytics service. 6. Development Deliverables The project will produce: Browser extension prototype: An installable, open-source extension containing the initial privacy features. Tor-Routed RPC prototype: A working browser-based experiment for routing supported CKB RPC requests through Tor, subject to transport feasibility. Wallet Privacy Inspector: A working prototype that detects CKB addresses and recognizable wallet information in outgoing requests. Per-site privacy report: An interface displaying detected wallet information and destination domains. CKB dApp test environment: A controlled test dApp demonstrating wallet information disclosure and inspection. Existing dApp compatibility tests: Tests against at least two existing CKB applications, documenting supported behavior and observed results. Source code and documentation: Public repository, setup instructions, technical notes and a demonstration video. 7. Six-Week Development Plan Week 1 — Extension Foundation and Tor Setup Set up the browser extension project. Investigate browser-compatible Tor transport options. Evaluate Arti-based WebAssembly approaches. Configure a CKB RPC test environment. Define the initial RPC methods to support. Milestone: Extension foundation and initial Tor transport experiment. Week 2 — Tor-Routed RPC Prototype Implement the initial browser-compatible transport. Attempt to connect to a CKB RPC endpoint through Tor. Add connection status and error handling. Test routing behavior and prevent silent direct-connection fallback. Milestone: Initial Tor-routed CKB RPC prototype, or documented technical limitations and an alternative implementation approach. Week 3 — Wallet Privacy Inspector Implement Fetch and XMLHttpRequest inspection. Add CKB address detection. Investigate recognizable Lock Script argument detection. Identify destination domains. Build the initial privacy report interface. Milestone: Functional wallet information inspection prototype. Week 4 — CKB dApp Integration and Testing Build a controlled CKB test dApp. Test the inspector against controlled wallet-information disclosures. Integrate at least two existing CKB dApps into the testing process. Record observed requests and findings. Improve detection and reporting. Milestone: Working inspection demonstration and initial compatibility results. Week 5 — Prototype Integration Integrate the working components into the browser extension. Test supported CKB RPC requests. Verify Tor routing behavior where implemented. Improve the extension interface. Address compatibility and performance issues. Milestone: Integrated Unlinked for CKB prototype. Week 6 — Final Testing and Release Complete functional tests. Fix remaining issues. Publish the source code. Write setup and developer documentation. Publish the CKB dApp testing results. Record a demonstration video. Milestone: Public prototype release. 8. Success Metrics and Verification The project will be evaluated through working software and reproducible demonstrations. Tor-Routed RPC Demonstrate a supported CKB RPC request routed through Tor in a real browser, if technically feasible. Verify that the destination endpoint observes the Tor exit IP rather than the user’s direct IP. Display routing status in the extension. Demonstrate that the extension does not silently fall back to a direct connection. Wallet Privacy Inspector Detect CKB addresses in controlled outgoing requests. Identify destination domains. Display detected information in a per-site report. Demonstrate local inspection without uploading request contents. CKB Application Testing Test at least two existing CKB dApps. Document observed wallet-information disclosures and negative findings. Publish reproducible test cases. Open-Source Release Publish the extension source code. Provide installation and setup instructions. Publish a demonstration and technical documentation. The project will clearly distinguish implemented functionality from experimental or unsupported features. 9. Risks and Mitigations Browser-compatible Tor transport Browser networking restrictions may make direct Tor integration difficult. Mitigation: Use existing browser-compatible Tor technologies, limit the initial implementation to supported RPC requests and document transport limitations. Incomplete request inspection Some wallet information may be encoded or transmitted through unsupported traffic types. Mitigation: Focus the initial prototype on observable Fetch and XMLHttpRequest requests and document unsupported mechanisms. False positives and missed disclosures Not every detected string necessarily represents a privacy leak, and transformed data may not be recognizable. Mitigation: Validate detections against controlled test cases and distinguish confirmed findings from potential disclosures. 10. Funding Request Total requested: $1,000 The funding will support six weeks of prototype development, integration and testing. The budget covers: Browser extension development. Tor transport integration and experimentation. CKB RPC integration. Wallet Privacy Inspector development. User interface and reporting. CKB dApp testing. Documentation, open-source publication and demonstration. The resulting software and technical documentation will be publicly available to the Nervos ecosystem. 11. Expected Ecosystem Impact Unlinked for CKB will introduce an experimental browser privacy tool for the Nervos ecosystem. For users, it aims to provide greater visibility into wallet-related information transmitted by dApps and demonstrate an alternative way to access supported CKB RPC endpoints. For developers, it will provide a practical example of browser-based wallet information inspection and a test environment for evaluating application privacy. For the wider ecosystem, it will contribute: An open-source browser extension prototype. Experimental Tor integration for CKB RPC access. A reusable wallet privacy inspection component. Testing results from existing CKB applications. Documentation that can support further development of CKB privacy tooling. 12. Final Outcome The final outcome will be an open-source Unlinked for CKB browser extension prototype demonstrating two complementary privacy features: experimental Tor-routed access to supported CKB RPC endpoints and local inspection of wallet-related information transmitted by dApps. The project prioritizes functional software, reproducible demonstrations and practical developer deliverables. The six-week grant will fund the development and testing needed to turn these ideas into a working prototype and establish a foundation for future improvements to extension browser privacy in the Nervos ecosystem. Link

forum.tezosagora.org: Call for Testers: Taquito v25.2.0-rc0 & @ecadlabs/beacon-sdk v4.9.0-ecad-rc.0 (Lifecycle & Type-Safety Overhaul, Faster Pairing, No More Half-Open Stalls, 7 Locales + RTL, Accessibility, and Tezos X)<br /> We are preparing the stable release of Taquito v25.2.0 (paired with @ecadlabs/beacon-sdk v4.9.0 ) and are inviting dApp developers, wallet teams, and community members to test the release candidates @taquito/*@25.2.0-rc0 (published on the npm next dist-tag across all @taquito/* packages) and @ecadlabs/beacon-*@4.9.0-ecad-rc.0 (published on the npm beta dist-tag). Project status. Taquito and @ecadlabs/beacon-* are unfunded projects maintained by ECAD Labs. Releases continue on a best-effort basis; protocol-tracking and critical security and reliability releases remain a priority. Beacon connects a Tezos dApp to your wallet. In Taquito 25.2.0 and Beacon 4.9.0, the connection layer has undergone a major lifecycle, transport, and type-safety refactor: it gets a pairing QR onto the screen sooner, eliminates multi-minute half-open Matrix /sync stalls when waking a device or switching tabs, gives users time to unlock their phone and review a request without premature dApp timeouts, and tells the dApp when the wallet has received a request. Wallet prompts follow the browser language automatically across seven built-in locales (with RTL layout and WCAG keyboard accessibility), and dApps can display which wallet will receive the next request. You can try the new wallet UX, language/theme switching, large-payload timing, and protocol inspector live right now on the Shadownet test dApp: Beacon UI, i18n & Theme Playground: https://shadownet.dapp.taquito.io/tests/beacon-ui Large Payload Timing Harness (1 to 256 KiB): https://shadownet.dapp.taquito.io/tests/large-payload Live Shadownet Test dApp (with Beacon Inspector in the header): https://shadownet.dapp.taquito.io/ Next Wallet API & Accessibility Guide: https://taquito.io/docs/next/wallet_API/ Reference Vue Wallet Store Integration: https://github.com/ecadlabs/taquito-test-dapp-vue/blob/af706d7/src/stores/createWalletStore.ts GitHub Release Candidates: Taquito v25.2.0-rc0 · Beacon v4.9.0-ecad-rc.0 Try the RC in your dApp Faster QR pairing, recovery after a tab wakes up, and faster large-message encoding come with the upgrade. If you use a coding assistant, open it in your dApp repository and paste either prompt. The short version gets you running. The extended version also puts the new wallet APIs to work in your existing UI. Pre-prepared quick upgrade prompt for your agent Upgrade this Tezos dApp to the Taquito 25.2.0-rc0 release candidate using its existing package manager. Pin the Taquito packages we already use that ship this RC, update the lockfile, and verify the resolved versions. If we use @taquito/beacon-wallet , it already brings in Beacon 4.9.0-ecad-rc.0 . Align any direct @ecadlabs/beacon-* dependencies we already use with that version. Check our connect and signing flows for short app-side timeouts that can report failure while the wallet is still waiting for approval. Where we ask users to check their wallet, show its name from getWalletInfo() when available. Run our existing checks and give me a short Shadownet checklist for pairing, rejecting a request, and approving one after switching tabs. Extended prompt for wallet UX, recovery, and testing Upgrade this Tezos dApp to Taquito 25.2.0-rc0 and apply the changes below wherever they improve a flow we already have. Start by locating our package manifests, wallet setup, account state, and the screens users see while signing. Use our existing framework, package manager, and UI conventions. Dependencies and wallet setup. Pin our direct Taquito packages that ship 25.2.0-rc0 , refresh the lockfile, and check the resolved versions. @taquito/beacon-wallet supplies the matching Beacon packages. Align any direct @ecadlabs/beacon-* dependencies we use to 4.9.0-ecad-rc.0 . If we offer WalletConnect, verify that pairing uses our own Reown project ID and works from our dApp’s origin. Preserve other wallet providers and network settings. Show users where to look. Use getWalletInfo() to name the active wallet in our confirmation UI, for example “Check Kukai to confirm.” Fall back to “Check your wallet” when metadata is missing. Refresh the label after restoring a session or switching accounts, and clear it on disconnect. Subscribe once per wallet lifecycle and release listeners on teardown so reconnecting produces one notification per event. Make pending requests understandable. Review our timers and retry buttons. Beacon gives permissions a 60-second default and lets signing and operation requests stay pending. Where we show progress, distinguish “Request sent,” “Wallet received your request” on ACKNOWLEDGE_RECEIVED ( if (ack.correlated) ), and the actual approval or rejection. Some wallets may respond without a separate acknowledgement. If our product requires a local deadline, handle LATE_RESPONSE_RECEIVED and surface any returned operation hash so users can check the result before retrying. Give users a recovery path. Use isBeaconError() and the typed error fields to distinguish a user declining, an unreachable wallet, and a rejected operation. Preserve useful RPC error details ( err.data on TransactionInvalidBeaconError , filtered with isTezosRpcError ). If Beacon deactivates an invalid saved account, clear stale connected UI and offer Reconnect. If we already have a support or debug view, use getConnectionInfo() and getPendingRequests() there to help explain a stalled request. Fit the chooser to our app. Keep browser language detection as the default. If our app already has a language or theme preference, apply it when creating the wallet and sync subsequent changes with setLocale() and setColorMode() . Check Arabic RTL, keyboard-only pairing, Escape, and focus returning to Connect. Verify the user journey. Run our typecheck, build, and relevant tests. Give me a short real-wallet Shadownet checklist covering fresh pairing, a restored session, rejection followed by retry, and approval after leaving the tab long enough to unlock a phone. If our app sends large contract parameters, include one representative payload. Report what passed, what still needs a person with a wallet, and which files changed. If you try the RC, we would like to hear which wallet and browser you used, which flow you tested, and what happened. For a stalled request, one particularly helpful detail is the last step you saw: request sent, wallet acknowledged, or response received. 1. Eliminating Half-Open /sync Stalls, Faster Pairing, and 375x Faster Large Payload Serialization No more 4-to-5-minute half-open Matrix /sync stalls ( beacon-sdk#204 , #207 ): Previously, waking a laptop or phone from sleep, backgrounding a browser tab, or having a proxy/NAT silently drop an idle HTTP/2 or HTTP/3 stream could leave Matrix /sync long-polling hung for 4 to 5 minutes until OS TCP keepalive eviction, freezing incoming signing prompts or responses even while outbound sends succeeded. Beacon now enforces a client-side /sync fetch timeout and immediately refreshes when a tab regains focus, becomes visible, or comes back online. First-relay Matrix pairing ( beacon-sdk#265 ): Beacon starts pairing as soon as the first healthy Matrix relay responds rather than blocking on a slow or stalled peer relay. In a controlled Chromium test with one healthy relay and one stalled relay, the median time from clicking Connect to seeing a usable QR fell from 10.31 seconds to 0.55 seconds (and with two healthy relays, from 0.81 to 0.55 seconds , across three fresh browser contexts per condition). The chooser also shows progress while it prepares the QR. 375x faster large Base58Check message serialization ( beacon-sdk#257 ): Large contract parameters used to leave the browser busy converting a wallet message for seconds at a time. In Chrome, encoding an operation containing a 128 KiB Micheline string fell from 31.5 seconds to 84 milliseconds , and decoding fell from 18.9 seconds to 28 milliseconds (measuring serialization alone; wire format stays 100% compatible with existing wallets). You can test 1 to 256 KiB sign and operation payloads against your own wallet at https://shadownet.dapp.taquito.io/tests/large-payload . 2. Seven Built-In Languages (with RTL Layout) and WCAG Keyboard Accessibility 7 built-in locales with browser auto-detection and runtime switching ( beacon-sdk#246 , #253 , #256 ): Human-reviewed ( status: 'human-reviewed' ): English ( en ) , German ( de ) , and Polish ( pl ) (thank you to David Kaminski ( @dvkam ) for contributing the reviewed Polish translation and refining the German terminology). AI-generated drafts open for native-speaker review ( status: 'ai-draft' ): French ( fr ) , Spanish ( es ) , Japanese ( ja ) , and Arabic ( ar , with automatic right-to-left dir="rtl" layout) . Beacon detects the browser language automatically, and dApps can switch languages or light/dark themes at runtime ( wallet.setLocale('ar') , wallet.setColorMode(ColorMode.DARK) ). Play with the live language and theme switcher at https://shadownet.dapp.taquito.io/tests/beacon-ui . Help Beacon sound natural in your language: If you would phrase a prompt differently, tell us which language you used, the wording you saw, and what you would say instead, or edit a translation directly on GitHub: TRANSLATIONS.md . New languages are welcome too. WCAG / WAI-ARIA keyboard navigation and focus management ( beacon-sdk#247 ): The chooser supports light and dark themes, role="dialog" , aria-modal="true" , Tab / Shift+Tab focus trapping, Escape -to-close, focus restoration, visible keyboard focus outlines, screen-reader live announcements, and prefers-reduced-motion . See the keyboard demo and wallet API examples . 3. Major Lifecycle Refactor, Type-Safety Debt Paydown, and Non-Expiring Requests Deep lifecycle ownership & strict TypeScript 6 / ESLint 10 overhaul: Over 230 source files across Beacon were refactored to unify request correlation, pairing ownership, multi-tab leader/follower routing, and storage lifecycles so cancelled pairings, disconnects, and tab switches settle callers cleanly and cannot overwrite a newer session. Legacy Transport<any> and untyped callback, storage, and logger boundaries were replaced with strict TypeScript 6 types, discriminated PermissionResponseInput and StoredAccountInfo unions, typechecked test and tooling suites ( beacon-sdk#249 , #270 ), and ESLint 10 gates across both Beacon and Taquito. Non-expiring signing and operation requests by default ( beacon-sdk#126 ): If it takes a minute to unlock your phone and review an operation, the dApp used to be able to report a timeout while the approval was still on your screen. Signing and operation requests now stay pending by default (permission requests still default to 60 seconds). DApps that choose their own deadline ( requestTimeoutMs ) can listen for BeaconEvent.LATE_RESPONSE_RECEIVED and use the transaction hash to tell the user what happened. See which wallet is connected ( await wallet.getWalletInfo() ): DApps can call await wallet.getWalletInfo() on a Taquito BeaconWallet to read { name, icon, deeplink, type } for the active wallet without opening a pairing prompt. 4. Typed BeaconError Subclasses, Connection Observability, and the Beacon Inspector 12 typed BeaconError subclasses & isBeaconError() ( beacon-sdk#174 , #179 , #245 ): Request methods reject with concrete BeaconError subclasses ( AbortedBeaconError , TransactionInvalidBeaconError preserving RPC error .data alongside isTezosRpcError() , PeerUnreachableBeaconError , etc.) carrying errorType , errorOrigin ( 'wallet' | 'local' ), title , and description , plus typed WalletConnect pairing failure reasons ( 'origin-not-allowed' , 'relay-unreachable' , 'timeout' , 'initialization-unavailable' ). Connection health and pending-request inspection ( beacon-sdk#176 , #206 ): DApps can call await wallet.getConnectionInfo() ( health: 'ok' | 'degraded' ), wallet.getPendingRequests() , wallet.subscribeToMessages() , and subscribe to TRANSPORT_STATUS_CHANGED , WAITING_FOR_WALLET_ACK , and INVALID_ACCOUNT_DEACTIVATED . Pass uiOptions: { enableToasts: false } to suppress built-in progress toasts. Did the wallet receive my request? (Beacon Inspector): The Beacon Inspector in the Vue test dApp puts outgoing requests, wallet acknowledgements, responses, and transport changes on one timeline. Follow the request ID to see whether the wallet acknowledged the request and where any wait occurred, or export the trace for debugging: https://shadownet.dapp.taquito.io/ 5. Elsewhere in Taquito 25.2 (Plus Today’s v25.1.2 / v25.1.3 Security Rollup) Detached signing, Smart Rollups in the Wallet API, and tz5 wallet permissions: Wallets can prepare manager operations for detached signing ( #3480 ), dApps can originate Smart Rollups (including private rollup whitelists, #3486 ) and submit rollup messages and batches through the Wallet API ( #3483 ), and Beacon permission responses now accept tz5 ( mdpk ) ML-DSA-44 accounts ( beacon-sdk#271 ). Paginated big-map reads & two-step block polling: Applications can page through finite big-map values in a single RPC request ( #3485 , #3523 ). Block polling checks the head hash before fetching the full block, reducing repeated RPC work ( #3482 ). BLS ( tz4 ), BIP39 helpers, and Sapling: Aggregate-key BLS proof-of-possession signing ( #3484 , #3492 ), BLS shell RPC endpoints ( #3474 ), BLpk packing in michel-codec ( #3540 ), English BIP39 mnemonic key derivation without a signer ( #3479 ), opt-in randomized Sapling output ordering ( #3499 ), and custom Sapling boundData construction ( #3533 ). Tezos X ( @taquito/tezosx ): The optional, experimental @taquito/tezosx package prepares unsigned Michelson-to-EVM and EVM-to-Michelson calls for compatible Tezos X kernels ( #3531 ), alongside Tezos X synthetic operation hash derivation in @taquito/utils ( #3529 ). TZIP-16 verification, RPC resilience, and browser-native bytes: TZIP-16 metadata reads now verify SHA-256 digests with IPFS gateway fallback ( #3506 ). HTTP requests keep timeouts active across body reads ( #3502 ) and retry transient 502 / 503 / 504 gateway errors ( #3500 ) as well as native Firefox/WebKit network failures ( #3461 ). Browser paths no longer rely on unguarded global Buffer polyfills ( #3512 , #3547 ). Security and encoding hardening (also shipped on stable latest today in v25.1.2 and v25.1.3 ): @taquito/sapling ( GHSA-6r9w-cxjj-5776 ): SaplingTransactionBuilder now samples a fresh commitment trapdoor ( rcm ) for every deposit, payment, and payback output and a fresh spend randomizer for every input ( #3587 , #3588 , GHSA-6r9w-cxjj-5776 ). @taquito/local-forging ( GHSA-9wjf-4grc-2g2h ): LocalForger.parse() now slices bounded sub-buffers matching the declared 4-byte length prefix when decoding smart_rollup_originate whitelist fields, governance proposals , and BLS signature_v1 proofs, and rejects unknown public key hash tags or truncated inputs ( #3581 , #3582 , #3583 , GHSA-9wjf-4grc-2g2h ). @taquito/signer : Preserves leading zero bytes when exporting 32-byte ECDSA keys and copies caller byte buffers before signing ( #3584 ). David Kaminski ( @dvkam ) contributed across Beacon, rollups, signing, and conformance tests. Thank you to Rahul Saxena ( @saxenism ) of Bluethroat Labs ( GHSA-6r9w-cxjj-5776 ) and byfor ( @byfor8 ) ( GHSA-9wjf-4grc-2g2h ) for their responsible security disclosures, to Martin at Tezos Domains for feedback on metadata verification and wallet timeouts, and to Klas Harrysson at Kukai for the encoder regression report. Cumulative Taquito changes and credits . Link

forum.monero.space: Best Class Help Service?<br /> Many university students face intense pressure when multiple major assignments are due during the exact same week. When the academic stress becomes too heavy to handle alone, saying ‘ I want to pay someone to take my online class for me’ is a highly practical solution. Also, when we take your class, we utilize secure residential VPN services to manage your login safely while adding to our thousands of successfully completed assignments. You can protect your peace of mind while our experts manage your course portal efficiently. Link

forum.monero.space: Which is the best class help service In USA<br /> With deadlines, exams, and personal commitments all competing for your attention, University life can become difficult. This is why many students turn to Takemyonlineclass for academic support that fits around their schedule and helps them manage coursework more effectively. It could be weekly discussions, assignments, quizzes, or total course management; our experts can ease the pressure while maintaining quality. We make sure to submit work on time, maintain privacy, and provide reliable support for students to keep a stable academic position even with busy schedules. Link

forum.gnosis.io: GIP-[XXX]: Blockscout SLA and Hosting Renewal (January 2027 - December 2027)<br /> GIP-Draft: Blockscout SLA and Hosting Renewal (January 2027 - December 2027) In Favour Against 0 voters GIP: [XXX] title: Should GnosisDAO support an annual renewal for Blockscout SLA and hosting: January 2027 - December 2027 author: Andrew Gross (andrew.gross@blockscout.com) status: Draft type: Funding created: 2026-11-20 replaces (*optional): GIP-144 duration:1 year (January 2027 - December 2027) funding:$106,800 Category Service Agreements - [ type ] Executive Summary Blockscout proposes a one-year renewal of its SLA and hosting services for Gnosis to continue providing the ecosystem’s open block explorer, API and developer infrastructure. In 2026 we delivered everything committed in GIP-144, including the Universal Bridge Indexer for the Gnosis bridge, while explorer usage continued to grow. Most notably, Gnosis was able to cancel their previous Etherscan support contract, saving the project hundreds of thousands of dollars per year in operational costs without sacrificing data availability or explorer features. Gnosis requires reliable blockchain infrastructure that supports developers, validators, and users on the chain. A dedicated, customizable explorer provides transaction transparency, contract verification tools, a robust API and user onboarding features. Due to database optimizations and other ongoing storage savings we are able to lower our ask by ~7% from the 2025 proposal. 2026 Delivery Recap: Universal Bridge Indexer Blockscout completed the Universal Bridge Indexer for the Gnosis bridge, the main feature committed in the 2026 proposal. Cross-chain activity is central to how people use Gnosis, and the Universal Bridge Indexer brings that into the Gnosis explorer itself. The Universal Bridge Indexer is a standalone, open-source service, part of Blockscout’s Rust microservices suite, that indexes and aggregates interoperability data across multiple blockchains. It runs alongside the main Blockscout indexer rather than inside it, so bridge indexing scales and is maintained independently of the explorer’s core pipeline. It is tightly integrated into the Blockscout UI and API endpoints. Delivered: Standalone bridge indexer service for the Gnosis bridge, covering cross-chain token transfers and messages Cross-chain transactions page in the explorer UI Cross-chain transaction detail views for both successful and failed transfers API endpoints exposing bridge transfer and message data Bridges supported: AMB/Omnibridge and xDai Bridge Networks covered: Ethereum mainnet to Gnosis and Gnosis to Ethereum mainnet Indexed volume to date: 92,307 cross-chain transactions on gnosisscan.io as of November 20, 2026. Cross-chain transactions list page ( https://gnosisscan.io/txs?tab=txs_cross_chain ) live in production Successful cross-chain transaction details page. Ecosystem Benefits and 2027 Roadmap Blockscout’s continued support enables: Accessibility for all network participants 14,050+ verified MyAccount users on the explorer Contract verification rates up 188% to 534,600 from 185,600 a year ago due to our multichain ETH bytecode DB. Advanced tooling for developers, including TheGraph integration and essential DApps in the Dapp marketplace A comprehensive Blockscout API that gives developers and teams building on Gnosis reliable access to onchain data and metadata Improved user onboarding through name services, DEX tracking, and the Universal Bridge Indexer now live on the Gnosis explorer Infrastructure that supports the Gnosis vision for decentralized, low-risk and user-friendly blockchain applications Joint work with the Circles team to onboard users and promote Circles to our large, multi-chain audience Cross-chain continuity across ecosystems. Blockscout is the official explorer for the OP ecosystem, Robinhood and Arc, providing a consistent user and developer experience across the greater Ethereum landscape. 2027 plans: In addition to our regular updates and optimizations, we will work with the Gnosis team as a launch partner to scope and support the EEZ transition. Blockscout infra is currently supporting the EEZ devnet at https://rollupx.eez.dev/explorer Continuity across the fork: ensuring a smooth explorer transition with no redeployment or migration required of users or integrators. Faster blocks and new finality: block time moves from 5 seconds to 2 seconds, and finality moves from consensus-based finality to soft confirmation in seconds with hard finality once the proof lands on Ethereum. The explorer will need to present both states clearly. Validator set retirement: consensus-layer and validator-related views will be reviewed and updated as the validator set retires. Settlement and proof visibility: blocks settle to Ethereum with data published to blobs, starting with an interim proving setup before moving to real-time ZK proofs. Blockscout already supports batch, settlement and proof views for other rollups and will scope the equivalent for EEZ. Route-based fees: fees will be priced by route (instance only, instance to Ethereum, Ethereum to instance), still paid in xDai, and should be shown clearly per transaction. Synchronous cross-chain calls: extend the universal bridge indexer architecture to support EEZ functionality. Service Description Blockscout provides comprehensive block explorer and infrastructure services for Gnosis mainnet and Chiado testnet, serving as the ecosystem’s primary interface for blockchain data, contract interaction, and network analytics. Key aspects Enterprise-Grade Infrastructure: 99.9% uptime with redundant hosting architecture Advanced Contract Verification: industry-leading tooling supporting Solidity, Vyper, and multi-part verification Integrated DApp Ecosystem: essential tools including Swap, Revoke, Multisend, Dapp Marketplace, and DEX tracker Cross-Chain Visibility: Universal Bridge Indexer for Gnosis bridge transfers and messages Developer-Focused Features: comprehensive API access and real-time data feeds User Experience Innovations: name service integration (.GNO and .ETH names), Gas.zip integration, and intuitive UI/UX Service Scope Mainnet explorer hosting and maintenance ( gnosisscan.io ) Real-time and historical indexing for transactions, blocks, tokens, and smart contracts Chiado testnet explorer hosting and maintenance Bridge indexer hosting and maintenance 24/7 monitoring and incident response Regular feature updates and security patches API infrastructure with rate-limited public access Contract verification and interaction Integration support for ecosystem projects Continuity of explorer service through the EEZ transition Service delivery Infrastructure Layer: hosting services with load balancing and automatic failover Indexing Layer: real-time blockchain data processing with sub-second latency Application Layer: user-facing explorer with responsive design and mobile optimization API Layer: JSON RPC and RESTful endpoints with comprehensive documentation Support Layer: technical support via dedicated channels and community forums Support Technical Support: direct communication channel for ecosystem partners and core developers Incident Response: 24/7 monitoring with fast response time for critical issues Community Support: documentation, FAQ resources, and Blockscout community forum monitoring Integration Assistance: technical consultation for projects integrating with Blockscout on Gnosis Pricing and payment We propose a renewal of our 12-month engagement beginning January 1, 2027 and continuing through December 31, 2027. Pricing reflects a decrease of about 7% over 2026 rates. Despite higher hardware costs this year, our DB optimizations in the major v12 release allowed us to save substantial storage space. Mainnet storage and costs are up slightly, but we are able to host Chiado much more efficiently, and have reduced the ask accordingly. Pricing structure: Gnosis Mainnet explorer and archive node: $6,900/month for hosting, services and maintenance, for a total 12-month cost of $82,800 Chiado Testnet explorer and archive node: $2,000/month for hosting, services and maintenance, for a total 12-month cost of $24,000 Bridge indexer hosting and maintenance is included in the mainnet price All-in annual cost: $106,800 Amount is requested up front for the year. Payment can be made to Blockscout’s SAFE [0x242ba6d68FfEb4a098B591B32d370F973FF882B7] on Ethereum mainnet with USDC or USDT by January 15, 2027. In the event that the DAO governance process is still ongoing at the end of the year, we will continue to maintain the explorer until it is resolved. Service Terms and Exit Strategy Contract Duration: January 1, 2027 - December 31, 2027 (12 months) Renewal Terms: This agreement may be renewed for subsequent annual periods via the governance process, with pricing subject to review based on usage growth and market conditions. Termination Conditions: GnosisDAO may terminate this agreement under the following circumstances: Non-Performance or Cause: if Blockscout fails to maintain 95% uptime over any 90-day period (excluding scheduled maintenance) Convenience: termination with 90 days’ written notice If service is terminated, the pro-rated amount will be returned to the GnosisDAO within 1 month of termination completion. Team/ Organization Eva Zhang is Blockscout’s CEO with Igor Barinov as the project founder. Victor Baranov has served as Head Architect since the project’s inception. They lead the team of developers, most of whom worked previously on the xDai chain and remain committed to the long term growth and success of Gnosis. Conclusion Blockscout’s partnership with GnosisDAO has demonstrated substantial value. We are committed to continuous innovation and support services for Gnosis. Renewing this SLA ensures a full-featured Gnosis explorer continues to provide needed open-source tooling and onchain transparency. We look forward to continuing our partnership with GnosisDAO and supporting the Gnosis mandate to provide accessible, decentralized blockchain infrastructure to everyone. Gnosis Snapshot Phase 2 Proposals: Please ignore this section, and leave as is. It is used for Phase 3 proposals. Phase 3 Proposals: Add a link to the corresponding Gnosis Snapshot poll you’ve created. Link

talk.nervos.org: Spark Program | MoniMkt: CKB Lending Validation Toolkit and Product Field Test<br /> 1. Project Overview Project name: MoniMkt One-line summary: A reusable CKB lending validation toolkit, field-tested with real users against the MoniMkt testnet product. Positioning: The primary deliverable is a standalone, reusable validation toolkit for cell-based lending markets on CKB. MoniMkt is the first reference fixture and field test, not the product being funded. This directly follows the committee’s suggestion to focus on a testing suite or validation tool without broader market operations. MoniMkt is the CKB equivalent of what Compound built for Ethereum: a pooled lending market where users supply, borrow, repay, and withdraw against collateral. The difference is that MoniMkt uses CKB cells directly. Market state, positions, vaults, and the oracle are cells, and the rules are enforced by CKB scripts. The market and frontend already work on testnet. What is missing is a reusable way to validate lending behavior across CKB lending products, and real product evidence from users who are not the builder. This proposal delivers both, with the toolkit as the core and MoniMkt as the first field test. 2. Committee Alignment This proposal is structured around the committee’s feedback: The core deliverable is a standalone validation toolkit , not a market operations package. MoniMkt is one reference fixture and field test, not the product being funded. The work is testing and validation only . There is no security hardening , no oracle operations, no mainnet work, no custody work, and no ongoing hosted beta. The entire scope is one toolkit plus one bounded field test. The product field test exists to prove the toolkit is useful in practice, not to turn Spark into an operations funder. 3. Team Profile Applicant / core developer: North Bear, full-stack and Rust, protocol and smart-contract development. GitHub: GitHub - NOrththebear/MoniMkt · GitHub Email: capc55005@gmail.com Discord: northbears I built the MoniMkt contracts, testnet deployment, frontend, and oracle keeper. I also built Bees Network, a CKB observation-layer MVP deployed on Pudge testnet, including its cell-based registry, epoch accounting, and desktop client. 4. Product Background CKB has strong custody and settlement primitives, but most users still meet CKB applications through wallets, forms, and transaction prompts that assume technical knowledge. A working contract is not the same as a usable product. MoniMkt currently supports: CKB wallet connection and account initialization. Live reads of market and position cells. RUSD supply and withdraw. CKB collateral supply and withdraw. RUSD borrow and repay. Transaction lifecycle feedback. Dashboard and activity views. A multi-source CKB/USD oracle. The product has been exercised end to end on testnet. What we do not have is: A reusable validation harness that other CKB lending teams can use. Evidence from users who are not the builder. A clear answer to which product surfaces help or block real users. 5. What We Are Building A. Core deliverable: CKB lending validation toolkit A standalone, open-source toolkit for validating cell-based lending markets. CLI and scenario format A command-line runner that executes a lending scenario file. A small scenario format for actors, actions, expected results, and failure cases. Deterministic fixtures for market state, RUSD cells, CKB vaults, accounts, positions, and oracle cells. One-command clean run against a local devnet or ckb-testtool . Adapters ckb-testtool adapter for script-level and transaction-level validation. Local devnet adapter for end-to-end flows with real wallets and RPC. A fixture builder that can target a new CKB lending market without rewriting the runner. Scenario coverage Supply and withdraw base asset. Supply and withdraw collateral. Borrow and repay. Interest accrual and index updates. Liquidation, absorb, and discounted collateral purchase. Pause and approval behavior where supported. Stale oracle, insufficient collateral, wrong witness, malformed cell data, wrong action, and capacity failures. Token conservation and vault capacity checks. Assertions and reports Assertions on output cells, cell data, lock and type errors, token deltas, vault deltas, nonce changes, and transaction outcomes. Deterministic pass or fail results. JSON and HTML reports with scenario names, expected outcomes, actual outcomes, and transaction hashes. CI templates so a project can run the suite on every push. Documentation A short integration guide for another CKB lending project. A scenario authoring guide. A “verify in five minutes” guide. The MoniMkt fixture as a worked example. B. MoniMkt field test MoniMkt is the first reference fixture and the first real product test. A fixed four-week validation round with 15 to 20 external CKB users. Structured tasks covering connection, initialization, supply, borrow, repay, withdraw, and recovery from expected failures. Wallet coverage across the CCC-supported wallets used by the product. Short surveys, observed task completion, and follow-up interviews. A weekly issue review during the test. This is not a hosted beta operation. It is a bounded field test that produces evidence for the toolkit and for the product. C. Product surface work needed for a fair test The current frontend works, but it is still a builder’s interface. Before asking users to test the product, it needs a focused product surface pass: A single frontend state model for wallet, account, market data, position, and transaction status. A consistent transaction lifecycle: preparing, confirm in wallet, confirming, confirmed, rejected, and retry guidance. Clearer wallet onboarding and recovery for JoyID, OKX Wallet, UTXO Global, and Khie. Simpler supply, withdraw, borrow, and repay forms with validation and plain-language errors. A dashboard that leads with the user’s position and next action. Mobile layout, typography, and accessibility improvements. This is not a feature expansion. It is the minimum product surface required to run a fair test and to demonstrate the toolkit against a real product. D. Product fixes and report Fix the highest-severity usability issues found during the field test. Re-test the fixed flows with a subset of users. Publish a prioritized product roadmap based on evidence. Publish the toolkit’s scenario coverage, reports, and integration guide. No contract changes. The MoniMkt market scripts and state model remain unchanged. 6. What This Proposal Does Not Fund This is not a request for Spark to fund: Smart contract development. Security hardening or an external audit. Oracle operations or keeper maintenance. Mainnet deployment or custody work. Hosted beta operations or ongoing support. Tester incentives. A token, a reward pool, or liquidity incentives. The existing testnet infrastructure is sufficient. The grant covers the toolkit, the field test, and the minimum product surface needed for that test. 7. Execution Plan: 6 Weeks Start on acceptance. The four-week field test begins after a two-week build phase. Week 1: Toolkit foundation Define the scenario format, CLI, fixtures, and assertion model. Build the ckb-testtool adapter and the first MoniMkt scenarios. Define the product test plan and hypotheses. Milestone: a clean local run of the first scenario set. Week 2: Toolkit coverage and beta build Add devnet adapter, failure scenarios, JSON and HTML reports, CI template, and integration docs. Finish the product surface pass, onboarding, transaction states, and beta build. Prepare the test scripts and wallet matrix. Milestone: public beta build and a documented toolkit that runs the MoniMkt fixture. Weeks 3 to 6: Four-week field test Run 15 to 20 testers through the structured tasks. Track task completion, wallet-specific issues, transaction outcomes, time to first supply, and qualitative feedback. Triage weekly, fix the highest-severity product issues, and re-test the fixes. Use the field test to refine the toolkit’s scenarios and reports. Milestone: all testers have attempted the core flows; toolkit and product findings are recorded and prioritized. Week 6 close-out Publish the validation report, toolkit documentation, scenario pack, before-and-after product notes, a demo video, and the completion report. Milestone: public toolkit release and product validation report. 8. Required Funding and Breakdown Requested: USD 1,500, payable in CKB. Why $1,500: This is one validation project with two coupled outputs. The reusable toolkit is the primary deliverable, and the four-week field test proves it against a real CKB lending product. A $1,000 budget would underfund either the toolkit or the field test. Item Amount Use Validation toolkit $600 CLI, scenario format, fixtures, ckb-testtool and devnet adapters, assertions, reports, CI, docs Product surface for the field test $450 State model, transaction lifecycle, onboarding, forms, dashboard, mobile, accessibility Field test design and facilitation $300 Test plan, task scripts, 15 to 20 testers, scheduling, interviews, weekly triage Report, demo, and completion package $150 Analysis, public report, demo video, docs Total $1,500 9. Deliverables and How to Verify Deliverables Open-source CKB lending validation toolkit with CLI, scenario format, fixtures, adapters, assertions, and reports. A documented scenario pack with positive and negative lending cases. MoniMkt reference fixture and a five-minute integration guide. CI template and example report. Public beta build with the new product surface and transaction states. Product validation report with 15 to 20 testers, wallet coverage, task completion, transaction results, and verbatim feedback. Prioritized product roadmap. Demo video and completion report. How to verify without code review Run the toolkit’s published command against the MoniMkt fixture and inspect the pass/fail report. Open the example JSON and HTML reports and confirm expected versus actual outcomes. Read the scenario authoring and integration guides. Open the public beta URL, connect a CKB wallet, and complete the core lending flow. Compare the before-and-after product screenshots and notes. Read the product validation report and check the measured results. Open the provided testnet explorer links for the flows exercised during validation. Watch the demo video. 10. Success Metrics Toolkit metrics Metric Target Documented scenarios At least 15 Positive and negative cases At least 8 positive, 7 negative One-command clean run Works on a clean checkout Deterministic reports Same result on repeated runs External integration guide One other CKB lending project can follow it without author help CI template Passes on a sample repository Product field-test metrics Metric Target External testers 15 to 20 Testers completing one full cycle At least 12 Wallet connection success At least 90% per tested wallet Transaction success excluding deliberate failure tests At least 95% Median time to first supply Under 5 minutes Testers who can explain the next action from the dashboard At least 80% Structured feedback responses At least 12 Critical usability blockers after fixes 0 The report will publish actual results, including misses and unresolved issues. 11. Current State vs Funded Work Already built and live on testnet MoniMkt market with RUSD base asset and CKB collateral. 13 RISC-V scripts deployed with Type ID. Working supply, withdraw, borrow, repay, collateral, absorb, and discounted collateral flows. Static CKB frontend with CCC wallet connection and direct cell reads. Multi-source CKB/USD oracle keeper. 112 automated tests across contracts and integration scenarios. Funded by this grant Reusable validation toolkit and scenario pack. MoniMkt field test with 15 to 20 users. Product surface and frontend state work required for the test. Product fixes, re-test, and a prioritized roadmap. Public report, demo, and completion package. Not claimed: this grant does not improve the protocol security model, oracle operations, mainnet readiness, or custody guarantees. Those remain separate work. 12. Risks and Limits Toolkit scope. The toolkit must stay focused on lending scenarios and avoid becoming a general-purpose chain indexer or simulator. Fixture assumptions. MoniMkt is the first fixture. The integration guide will state what another lending project must adapt. Product surface only. This grant will not fix contract-level or oracle-level risks. Wallet variance. CCC-supported wallets can behave differently. The field test records issues per wallet. Small sample. 15 to 20 testers provide directional product evidence, not statistical proof. Testnet conditions. Testnet CKB has no real value, and testers may need guidance on collateral amounts at current CKB prices. No ongoing operations. The field test is a four-week window inside a six-week project, not a permanent hosted service. 13. CKB Alignment MoniMkt is a native CKB product. The frontend reads live cells directly, uses CKB wallet signatures, and displays transaction outcomes from the cell model. It does not depend on an off-chain ledger or an account-based contract. The validation toolkit is CKB-native as well. It exercises cell transitions, type and lock scripts, token conservation, vault capacity, and transaction-level failure behavior. It gives CKB lending teams a reusable way to validate their own markets rather than rebuilding test infrastructure from scratch. 14. Closing The committee asked for a standalone testing suite or validation tool. This proposal makes that the core deliverable and uses MoniMkt as the first real fixture and field test. The output is a reusable CKB lending validation toolkit, a documented scenario pack, a public product validation report, and a clear next-step roadmap. It does not fund market operations, security hardening, oracle maintenance, mainnet work, or an indefinite beta. Link

forum.tezosagora.org: Keeping Etherlink Secure - Ganesha 7.3 Security Disclosures<br /> The Etherlink Ganesha 7.3 kernel upgrade proposal was successfully activated on block 57,776,852 on November 12th. As outlined here , it was an undisclosed kernel proposal mitigating a set of potential liveness vulnerabilities in the Etherlink kernel. The release addresses a family of issues where malformed or adversarial transactions could risk disrupting block production, or where execution costs were not aligned with the work or memory a transaction triggered. Some of these issues were reported through the bug bounty program and others were found through continued internal auditing and testing. We’d like to thank the external security researchers who help us keep Etherlink secure, as well as the bakers who voted in support of our security upgrade proposal. Issues Addressed The common theme is denial-of-service resistance and liveness. This is important to address in the kernel, as the delayed inbox can force transactions to be included: a transaction that should be cheaply rejected as invalid must never be able to abort block production or stop the chain. The release also continues the work begun in Etherlink 7.2 of ensuring that every operation whose cost can grow with user-controlled input is bounded, charged before execution, or rejected safely. Below is a list of all issues addressed. Delayed-inbox validation and liveness The largest class of fixes concerns invalid delayed transactions that were aborting the block that included them. Each of the following is now rejected safely: Reject EVM transactions that cannot cover value plus gas: The prepay check did not count the transferred value, so a transaction whose sender could not cover its maximum gas fee plus its value could abort the block. ( a15a4f1c59 ) Reject oversized EVM contract creations: A contract creation whose initcode exceeds the EIP-3860 limit is now invalid rather than fatal. ( a20625ff2f ) Reject EVM transactions below their intrinsic gas: A transaction whose gas limit does not cover its intrinsic gas is now invalid. ( 29c346234a ) Reject EVM transactions below their EIP-7623 calldata floor: A transaction whose gas limit covers its intrinsic gas but not its calldata floor is now invalid. ( b28c063a65 ) Reject malformed EIP-7702 transactions: EIP-7702 transactions with no destination ( ffbb397c51 ), or with an empty authorization list ( 24e956fcfb ), are now invalid rather than fatal. Reject Michelson operation batches whose gas limits overflow: A Michelson operation batch whose declared gas limits sum past u64 is now invalid. ( c7d18b6fb4 ) Reject Michelson amounts above the mutez domain: A Michelson transfer whose amount ( 17d13ad1c1 ), or origination whose balance ( 1f806a3a41 ) takes more than 64 bits is now invalid, instead of aborting the block or stopping the chain. Michelson runtime gas and memory accounting The kernel also addresses some gas and memory accounting issues for Michelson operations: Charge EDIV for its result allocation: EDIV is now charged at least for the memory its quotient and remainder allocate, closing an out-of-memory vector on divisions of large numbers. ( 62f5d4cf2d ) Charge MAP for key comparisons: Interpreting MAP on a map now consumes gas for the per-key comparisons it performs when updating the accumulator. ( d5214c1f4e ) Charge map rebuilding during big-map traversal: Gas is now consumed for rebuilding maps while extracting their big maps. ( 026da52e32 ) Charge the full budget on alias-creation out-of-gas: When the creation of a sender or source alias runs out of gas - in a Michelson call to the EVM through the runtime gateway (%call, %call_evm) ( ecc7e28202 ), or in an EVM call to Michelson ( 10661a9733 ) - the whole gas budget is now charged, as it should be for any out-of-gas condition. An EVM alias initialization that runs out of gas is now also reported as such ( 2a5e18f7c9 ). Bounded error output Converting large numbers to strings requires changing their representation from binary to decimal, which takes quadratic time in the length of the number. This was a possible attack vector that could lead to very slow block application because not enough gas was consumed for these conversions. In Etherlink 7.3, we stop converting large numbers to decimal by introducing the following size limits: In error messages, numbers taking more than 64 bits are replaced by an indication of their length. ( 96675f86a5 , 4308ecd54d , 28cffe03ba ) For the string syntax of timestamp literals, a string that is not RFC3339 compliant and is longer than 32 bytes is now rejected. ( 99898429ac ) Micheline nodes displayed in type-checking error messages ( 0776fb362c ) or raised by the FAILWITH instruction ( 18886ff727 ) are now displayed with a bounded representation ( e67008edbd ) which limits numbers to 64 bits and strings to 256 bytes, and displays at most 10 Micheline nodes. Runtime gateway hardening A few aspects of cross-runtime calls have also been improved: Charge gateway calldata before decoding: The per-word charge on gateway calldata, and the base cost of callMichelson , callMichelsonView and call , are now charged before the calldata is decoded. A call forwarding too little gas now runs out of gas without decoding its input, whereas it previously decoded the whole payload first. The total charged for a successful call is unchanged. ( c522c2e861 ) Reject user-supplied gateway headers: The gateway’s %call entrypoints no longer accept a non-empty headers array. These headers were never read by either runtime - an empty array behaves exactly as before ( 1b606083be , 0e39b9ec49 ) Internal-operation cap enforcement A series of fixes close ways for a transaction to exceed the cap on internal operations. The counter is now preserved across frame reverts ( ac0f048c8b ), reserves entries for receipts ( 5441cea20e ), stays synchronized across gateway calls ( 3d1b6b41ab ), counts re-entrant receipts in the next batch operation ( 43adffcd24 ), is checked for gateway callbacks ( bd961cac09 ), and counts replayed internal operations ( 944981b76d ). Keeping Etherlink Secure Our thanks go out to the security experts contributing via the Tezos Foundation bug bounty program . If you are a security researcher, we strongly encourage you to look into Etherlink and other Tezos ecosystem projects. Submitting findings through the bug bounty program remains vital for ensuring the ongoing secure evolution of Etherlink alongside Tezos X. Link

talk.nervos.org: How can we change username?<br /> Hi everyone, First post! How can we change username here? Link

forum.polkadot.network: Polkadot Technical Fellowship — OpenDev Call · Proceedings · 17 November 2026<br /> Date: Tuesday, 17 November 2026, 14:00 UTC, OpenDev Call #6 Host: Jesse Chejieh ( @jessechejieh :matrix.org), Rank II Agenda: help-center#23 Previous proceedings: 20 October 2026 Recording: Google Drive Recap: x.com Alistair Singh / Snowfork opened with the JAM port and bootnode discovery update. The team has its first major PR merged upstream into the SDK, the spec-msg primitives for offchain messaging in polkadot-sdk#12676 , which covers version 0.5 of the design. Parity has since released version 0.6, and Snowfork spent the last month updating to it, with the alignment in polkadot-sdk#13759 and further PRs open. The team also now has a usable JAM testnet, which resolves the blocker named at the October call. On bootnode discovery: today every parachain node is also a relay chain node, so it can reach the relay chain DHT, discover another parachain, retrieve its genesis hash and fork ID, connect to that parachain’s own DHT and find its nodes. Today: para B finds para A through the relay chain DHT 1440×780 105 KB JAM has no relay chain DHT, but it does have state: a parachain can write data into JAM storage and another parachain can listen to that storage key. The proposal, designed in polkadot-sdk#12809 , is that parachain A writes its bootnodes, fork ID and genesis hash into JAM storage; parachain B listens to A’s key, dials the bootnode, joins A’s DHT and discovers A’s other nodes. As the chat pointed out, the record carries the genesis hash and fork ID, not only the bootnode multiaddresses. JAM: para B finds para A through A's record in the Parachain Service 1280×588 219 KB Alistair demoed this on a JAM testnet with collators alpha, beta and gamma and the parachain service, run with a pre-built PolkaJam binary from Parity, launched via Zombienet, with hack PRs on top because JAM is still in development. For now parachain B is pointed at parachain A with a command-line flag; later this will be discovered automatically or fed by governance. In the demo, alpha added itself as a bootnode, gamma picked up the record, dialed alpha, joined the DHT and discovered beta. Asked by Oliver Tale-Yazdi what is stored on-chain, Alistair clarified that the records live in JAM storage, set through the parachain service on behalf of parachains, not in the parachain’s own storage. Asked which JAM node the demo uses, he said it is a pre-built PolkaJam version from Parity, not a community node. Snowfork takes further questions on Element. Fresh off milestone 1, the Fellowship welcomes new JAM implementer members: Junha Park has been building FastRoll, a Rust client, for about two years, with a pause of a few months, and is now syncing to the latest Gray Paper and targeting the milestone 2 standards. Arjan Zijderveld is working on PyJAMaz , a Python implementation, and is weighing the full node against the light client path for milestone 2. Prematurata Validator has been working on a TypeScript implementation, also for about two years, with the same full node versus light node considerations. Mihail Kirov joined as a JAM implementer as well. From the floor came the sponsorship question left open in October, and Oliver Tale-Yazdi took it: how rank III members would sponsor lower ranks for retention and promotion. Oliver said there are no concrete ideas yet and the process will have to be figured out informally, by doing it. What sponsorship means is still open, including whether a member failing retention reflects back on their sponsor, in some recursive reputation system, or whether it is simply a list of names; he has so far held off nominating anyone for lack of clarity. Oliver also reported that his aura authorizer merge request, polkadot-sdk#13453 , is still open. It is the first piece upstreamed from the parachain service proof-of-concept repository into the SDK, where the pieces are being cleaned up and made production-ready; it verifies collator signatures, that they are the correct authors of their parachain blocks. The remaining pieces will follow and need changes in the authorship code and in Cumulus. Oliver then walked through the recent dotUSD incident on Asset Hub. The fault was not in USD itself, which stayed fully backed, with never more USD in existence than backing tether, but in XCM: the withdraw_asset instruction allowed the total issuance accounting to be manipulated, and that accounting feeds the DEX code in the asset conversion pallet, which was loaded with Treasury liquidity. Through bridged XCMs the recorded total issuance of USD was pushed much lower, arbitrage bots on Asset Hub exploited the distortion, the USD price spiked to $26, and the Treasury liquidity was drained. The arbitrage bots made about $1.3 million in total while the attacker account made around $1,000; that they are the same party is not proven, and the attack could have been carried out far more efficiently, in a single transaction rather than through bridges. The latest runtime upgrade readjusted the total issuance, which is now correct again, but the liquidity pools are nearly empty at around $90,000, and a proposal to replenish them may come. Alexandre Baldé described his follow-up security work on the exploit. His fuzzing in the months before had not caught the root cause, because he had not considered combining asset conversion pallet actions with PSM actions and XCM, plus a bridge; that combination was the missing ingredient, and it will inform his future campaigns. He has a couple of small findings, with a PR coming this week. Oliver added that he runs a Fellowship fuzzing repository continuously on one machine, dispatching arbitrary XCMs and batches of them and checking post-conditions, across 16 threads at roughly 400 operations per second per thread; its coverage has been extended so it should now find this class of issue. Between Oliver’s XCM fuzzer, Alexandre’s grammar-based approach and Brian’s AI-driven search, three different fuzzing methods are running. Nasihudeen Jimoh presented the kill switch pallet, runtimes#1344 , now wired into Asset Hub. Anyone can post a target, such as PSM swaps or XCM asset transfers, by putting up a 10,000 DOT deposit for swaps as currently set, with the deposit parameters open to reviewer input. The deposit runs for a day, and the Fellowship can end it early, refunding an honest post or slashing a dishonest one. The PR is rebased from the earlier kill switch PR, with safe mode removed. Bastian has given an initial review and the comments are being worked through; more reviews are requested, and Oliver said he would take a look. Next call: Tuesday, 15 December 2026, 14:00 UTC, the third Tuesday as always · agenda thread opens ~1 week out. Link

forum.pyth.network: [Pythian Council Election #6] Smartcoded - SmartCodedBot Studio<br /> Gm Pythians, I am putting myself forward for the 6th Pythian Council. I build and run onchain trading products, and Pyth has been part of that stack. I wired Hermes updates into two live products, along with the staleness guards, confidence checks and fallbacks that come with them. I also lived the August 2026 change that put Hermes behind an API key, and I know what an access change costs an integrator because I paid it in engineering time. That is the view I want to bring to a Council that sets data request fees, publisher terms and upgrade timing. Candidate information Name : Smartcoded Current role : Founder and lead engineer, SmartCodedBot, a Web3 product studio Location : Lagos, Nigeria (WAT, UTC+1) X : @smartcoded Discord : smartcoded GitHub : smartcoded2011 Solana wallet : 6FE294omNqwoL6Bb9KGSdMisaBYGYoKESSY9JjK5L7w6 Ethereum wallet : 0x60Bc5323C0E0e9144Af0B35CE8de119fC743e345 (smartcoded2011.eth) Signing-key custody : Council signing keys will be held on a dedicated hardware wallet for the full term, and no Council key will ever sit on a server that serves user traffic. Relevant experience Integrator on the Pyth side. I wired Hermes SSE and REST updates into two production trading products, with staleness guards, confidence interval checks and fallbacks for quiet feeds. When Hermes moved behind an API key in August 2026, I migrated the stack rather than stall the product, so I know both what Pyth gives an integrator and what it costs a small team to stay. Shipping and operating contracts. Deployed and verified contracts on Base and other EVM chains, plus Solana transaction flows, and automated execution and payment rails that move user funds, with simulation, RPC failover and monitoring around them. Multisig discipline. Every proposal I would sign gets read, simulated and diffed against what its text claims, before a key touches it. I would rather ask a basic question on a Tuesday than find a wrong parameter after execution. What I would prioritize An access tier a small team can actually use. Clearer oracle ergonomics, cross-chain error standards, and upgrade notices that reach integrators before they break a live product. Parameter review with reasons. Data request fees, publisher incentives and runtime upgrades reviewed against a written rationale, not just a yes. Signing responsiveness. Same-day turnaround on routine proposals, with coverage across African and European hours. An independent builder voice. The Council already carries the foundation and core contributor view. I would add the view of someone who has to make the feed work in a product that users actually touch. Link

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