List view
- No due date•0/1 issues closed
When you create a contract, you get as part of the response a field called safetyError which currently is an array of unknowns. This should be properly typed. Also, most endpoints, if they fail (via 4XX status code) you get an Axios Error, we should map those out to semantic errors like ContractNotFound, AmigousTimeInterval, etc and add those to the documentation as `@throws ContractNotFound` When the server responds something that we are not expecting, we are currently throwing a DecodingError which is an alias for `string[]` we should make this a proper error. Typescript handles errors as unknowns, so we need to provide the proper guards (not necessarily io-ts guards), and we need to add in the documentation to show users how to handle the different errors that we throw ``` try { //... } catch (err: unknown) { if (isContractNotFound(err)) { // proper handle } else { throw err } ```
No due date•1/2 issues closedIn the refactors between version 0.1.0-alpha to 0.2.0-beta the previous e2e test were disabled. Now that we have an official way of doing Node.js Scope of the Milestone: - To enable all developers to be able to add an integration test on their work (if applicable) - Manual execution of integration tests - Add at least 3 meaningful tests Out of scope for the Milestone: - Add CI with nightly checks
Overdue by 1 year(s)•Due by January 12, 2024•9/9 issues closedThe 0.3.0-beta release will try to capture the work of: - Node.js/deno support - Large contract support - Additions to runtime-rest-client (getting closer to 1-1 feature parity) And some general improvements
Overdue by 1 year(s)•Due by April 1, 2024•8/10 issues closed**Why Merkleizing Contracts ?** In many real world scenarios, the size of a Marlowe contract can pose challenges. For instance, a contract may be too big to fit on a Cardano transaction. To handle this situation, the Marlowe semantics and plutus validator both support a size optimization called merkleization. Merkleization is a process that transforms a contract from a tree structure into a merkle DAG (directed-acyclic graph) consisting of multiple contract fragments that reference each other by hashes. Merkle DAGs translate well to storage in UTxO-based blockchains like Cardano, because these blockchains are themselves merkle DAGs. Transactions reference outputs of previous transactions by their hashes. A merkleized Marlowe contract gives just enough information to validate the next transaction. When applying an input to a merkleized contract, the next contract fragment must be provided alongside the input. As long as the continuation's hash matches the hash contained in the existing fragment, we know the continuation is genuine. The provided continuation can then be used to compute the next contract that will be in effect after the input is applied. This Milestone handles the work for adding basic support for large contracts in the ts-sdk. Future work might be needed in order to improve the DX
Overdue by 1 year(s)•Due by January 12, 2024•5/8 issues closed