WEEKLY DEVELOPMENT REPORT
This week the team worked on preparations for the upcoming Daedalus Byron reboot release, including successfully integrating the new cardano-launcher and new Haskell Cardano node.
This week the team continued working on improvements to the cardano-launcher required for the Daedalus Byron reboot release.
This week the team finished all the UI improvements for the mobile view of the Cardano Explorer, which is now ready for release as part of the Byron reboot.
The team has been busy working on ensuring smooth integration across all the elements of the wallet stack, from the node and the wallet backend to the launcher and Daedalus itself. These integration efforts will ensure robust, reliable performance and positive user experience when delivering the Byron reboot.
This week the networking team has been working on improving the chairman application, a testing program that checks the success of node consensus for any given cluster. The team discovered that in some scenarios the chairman application does not properly register chain progress failures, and this issue has now been fixed. The chairman application will now report an error if one of the nodes has connection problems, or for some other reason will not make progress in reaching consensus.
The team has also been working on per-state protocol timeouts and rate limiting of accepted connections, with two pull requests currently under review. Work was also done to refactor a large portion of the Win32-network library.
This week the team worked on integrating the new cardano-node into the launcher configuration for Daedalus, as well as writing a new faucet for the testnet using cardano-byron-wallet as a backend. The team also improved the monitoring of relay and explorer nodes on the network. Finally, the team added a self-node configuration to cardano-node that can be used for development purposes, allowing users to run a node locally that produces its own blocks without access to a network.
This week the team continued to work on the CDDL tests, and can now check any given deserialization against the CDDL file by using a Ruby tool. The team also worked on adding a ‘safety zone’ to the protocol parameter updates, which ensures that voting is stabilized 2,000 slots before the end of the epoch so that the consensus layer has time to react.
Work was also done this week to adjust which pool parameter snapshots are used to calculate rewards. Previously, snapshots corresponding to the ‘performance epoch’ were used, but now a snapshot from the epoch in which stake distribution happened is used instead.
Finally, the ledger state now stores all the necessary information required for the non-myopic rewards calculation, as well as having an API to access it. There is still some work to do to add the finishing touches based on feedback from the researchers, but the team expects it to be relatively straightforward.
The Plutus team added the signing process as a separate service this week, similar to the node and chain index. They also removed gas costs for type checking and added a scale operation for values.
Meanwhile, the Marlowe team continued their efforts on improvements to Blockly. In particular, the presentation of labels and tutorial images.
WEEKLY DEVELOPMENT REPORT
This week the team successfully released Daedalus 2.3.1-ITN1, which introduces new versions of the cardano-wallet and Jörmungandr node, as well as fixing an issue with stake pools not loading in the interface. The latest release also resolves a problem with the Daedalus installer on MacOS Catalina systems and includes improvements to network performance and reliability.
In the scope of regular maintenance tasks, the team implemented multiple improvements to the automated test suite and updated important third-party dependencies such as Node, Yarn, and Electron packages.
The team is now entirely focused on the preparation of the upcoming Daedalus Byron reboot release which, includes a new cardano-launcher and new Haskell Cardano node.
This week the team implemented several improvements to the cardano-launcher which were required in order to integrate it into Daedalus for the Byron reboot.
This week the team was working on UI improvements for the mobile view of the Cardano Explorer.
This week the team has been fixing some bugs found on Windows and finalizing end-to-end integration with cardano-node. Work is also being done to close the gaps between the new API and the old one currently used by Daedalus on the Cardano mainnet. The team is aiming for a smooth transition for both end-users and cryptocurrency exchanges, while continuing to preserve the functionality of the legacy API to prevent breaking changes. This requires some careful considerations regarding what ought to go in the new API.
The team also added support for cold wallets this week, enabling the wallet backend to work only from an account public key without ever seeing a private key. This, combined with the proxy transaction submission added a while ago, enables clients to build integration with hardware devices such as Ledger or Trezor.
No update from the networking team this week. They’ve been helping out other development teams this week.
This week the DevOps team has been working on creating the installer for the Byron reboot version of Daedalus, as well as performance testing different node relay configurations, the results of which have been very positive. Performance tests indicated that a handful of relays can serve thousands of wallets without any problems whatsoever. The team has also been writing a testnet faucet using the new Byron reboot node, and generating Windows bundles for running Ouroboros network tests on native Windows hosts.
The team has also worked on improving the cardano-db-sync and cardano-rest Docker images so that they have finer granularity and support secrets in the Docker Compose files for PostgreSQL credentials.
This week the team finished renaming some of the packages and modules, and have also been investigating heap exhaustion problems that are affecting the test suite (rather than the code itself). Some of these issues have been solved, but work is ongoing to fix the last of them.
The team also fixed an edge case problem with the optimization of the active slot coefficient this week. Work has also progressed on the CDDL tests, with one half complete (generating from CDDL and deserializing in Haskell). The other half of the tests (serializing from Haskell and checking against the CDDL) will be added soon.
Finally, some minor tweaks were made to the CDDL, such as using the CBOR tag for rationals. Lenses were also removed from the Shelley ledger, and a handful of examples were created illustrating how to construct various transactions, including what the abstract size and minimum fee for them might be.
This week the Plutus team investigated a new approach for how the error term is treated in the metatheory package. They also made updates to the code to reflect the new EUTXO terminology and added a missing rule for the data script hashes.
Meanwhile, the Marlowe team concentrated on improving the usability and layout of Blockly. This included changing colors to make them more distinct, adjusting width layouts so that contracts occupy less space, removing the Case block and merging it into a different action, as well as making a new block for currency/token. Finally, they also worked on the layout of Marlowe contracts in the Marlowe Playground.
WEEKLY DEVELOPMENT REPORT
This week, the team successfully released Daedalus 2.3.0-ITN1. This introduces new versions of the cardano-wallet and Jörmungandr node, which should improve Daedalus connecting and syncing times.
In the scope of regular maintenance tasks, the team implemented test coverage for custom number, date, and time formats, and re-enabled theme selection on the Settings screen. Lastly, the team continued to work on updating the third-party packages in Daedalus.
The team added CORS configuration to Cardano GraphQL to enable greater control over API access, with the ability to provide a single or comma-separated array of origins. The automatically generated TypeScript definitions for the GraphQL schema is also now being published for consumption as a package, decoupling the need for a direct dependency on the running service for client-side type safety.
The QA team completed the frontend design and application logic changes, to conform with QA testing results. A new staging continuous deployment process was established to aid with further development, establishing an improved standard for the team moving forward with other web projects.
The team produced the first E2E integration scenarios of sending a transaction from a Byron wallet to another Byron wallet using a combination of cardano-wallet and cardano-node. This is a major milestone, and the team hopes to release it next week after a few more integration scenarios have been controlled.
The team is also investigating a few issues recently discovered - in particular, some odd behaviors noticed on Windows machine - and are close to being able to run automated nightly tests on a Windows environment, which should improve issue identification and resolution speeds.
This week, the networking team calculated size limits, which protect multiplexer ingress queue, and refactored the code so all required parameters which have an influence on the bytes in-flight (for example, how many messages are pipelined) are set in a central location. The team also implemented timeouts for the handshake mini-protocol, and fixed some bugs which did not allow the cardano-db-sync client to connect to a node.
The team has been working on Windows CI automation for the new Cardano node and packaging Daedalus with the new Haskell node and wallet.
This week, the team performed bug fixing, and put proper block header size and block body size functions in place (which replaced the naive spec functions). More work is yet to be done, however, and the team intends to adopt annotated serializes to avoid re-hashing.
The team also added a much-needed optimization for the VRF checks (storing ln (1-f) instead of computing it every time) and swapped out active stake for total stake in the reward calculation, as recommended by IOHK’s researchers. Relative stake is still represented elsewhere, however, such as in performance, etc.
Additionally, the team added a mechanism to halt outdated nodes. There is now a new global variable for a max major protocol version, after which blocks are deemed valid. They also added optional stake pool metadata and stake pool relays to the stake pool registration parameters, renamed the Shelley-ledger Haskell packages and modules, and worked on testing performance.
This week, the team added a multi-agent effect for signing transactions to the emulator and removed the sign function from the walletAPI. They also added a chain index that keeps track of unspent outputs and the transactions that produced them, so that data values can be retrieved. In conjunction, a stateful chain follower protocol was added to the mock node, so that queries can be made for the most recent blocks only, and the entire blockchain does not need to be transmitted every time.
Last but not least, a runGuardedStep was added to the StateMachine module so that an additional predicate is used, which is checked before actually submitting a transaction.
Meanwhile, the Marlowe team worked on making block explanations more compact in Blockly. They also added a QuickCheck property for Marlowe static analysis and investigated the usage of LiquidHaskell for proving contracts properties.
WEEKLY DEVELOPMENT REPORT
This week, the team completed work on the Shelley features test coverage. All of the features are now covered by automated tests, which was required to start work on the Haskell node integration. The team also continued the work on updating third-party packages in Daedalus.
The team is still working on the implementation of the new Cardano Launcher.
The QA team is finishing working on fixing the issues identified during the QA testing phase, in preparation for the upcoming Cardano Explorer Byron release.
This week, the wallet backend team continued working on the new cardano-launcher as well as a testing setup for cardano-node. The team also took time to upgrade quite a few dependencies, libraries, and standards used across many components of cardano-wallet.
Meanwhile, the wallet command-line now provides tools for manipulating wallet credentials and operations, such as mnemonic-to-root-private-key generation and parent-to-child-key derivation. This is particularly handy for DevOps as well as pool operators who need to actively manage their credentials. A few issues regarding Windows are also under investigation.
The networking team is continuing to work alongside other teams towards the release of Shelley, identifying ways to improve network performance and reliability.
The DevOps team has been working on perf-ops. This allows the testing of multiple copies of any NixOS service in bulk, which subsequently allows the simulation of Daedalus clients. The team has tested thousands of nodes against both the Jörmungandr and cardano-node. Additionally, the team has been packaging docker containers for the cardano-node, cardano-db-sync, and cardano-rest, which are all part of the Byron stack needed to run a custom explorer.
Significant improvements were made to the test data generators this week. These include using real VRF leader values instead of always inserting zero, real transaction fee generation instead of zero, improved UTXO entries in the transactions, multiple delegation certificates in transactions, and the ability to generate more non-zero rewards on the epoch boundary.
Meanwhile, the team now has the wire format it wants for transaction witness sets (which will work well when Plutus scripts are added) and the CDDL tests (though CI integration of those tests is still pending). The tests generate data from the CDDL file and check the deserialization in Haskell. This is then serialized from Haskell and checked against the CDDL.
Numerous smaller improvements were also made, including making the protocol version two numbers instead of three and allowing UTF-8 instead of ASCII.
Lastly, the team began sketching out what it would look like to have the ledger do all the non-myopic reward calculations. Even though these calculations are only needed by the wallet, it seems simpler to have the ledger calculate them directly. A few decisions still need to be made before the team can continue, such as whether it wants a moving average, or just, for example, the last few values.
This week, the team implemented the parser generator for parsing contracts, which increased response times. They also started work on a testing branch for the smart contract backend and updated the extended UTXO document to include information about the partial order of finitely-supported functions.
Meanwhile, the Marlowe team worked on separating out the Marlowe editor errors and warnings.