Please describe your proposed solution.

plu-ts is a smart contract programming language for cardano embedded in typescript.

it was initially proposed in found 9 but was never founded (for lack of founds).

It allows typescript developers to create, deploy and interact with a Cardano dApp only using typescript (or javascript) from the ground up.

Typescript is one of the most used programming languages according to stack overflow and it is interoperable with javascript (the most used programming language according to the same source)

as for now plu-ts:

• produces between the most efficient contracts in Cardano
• it has improved the syntax to get as close as possible to plain typescript
• is the first (and the most complete) transaction creation soultion not based on WASM

on top of that most of the code so far produced has been broken into modules so that it can be reused for many other projects and any other cardano-related scope (such as the cardano-node typescript implementation proposal (TODO add link))

some of the packages include:

• cardano-ledger-ts
• an UPLC module
• a plutus virtual machine
• and many more…

(all of wich can run in any javascript runtime).

but, there's always room for improvments.

In order for plu-ts to be production ready we will mainly focus on:

• further compiler optimizations
• additional typescript-like language features
• additional testing and coverage of the source code

optionally (but not necessarely) that also include improved API over the plu-ts IR (intermediate reperesentation) for language extensions.

How does your proposed solution address the challenge and what benefits will this bring to the Cardano ecosystem?

The main purpose of the challange is to make easier for developers to deploy applications on Cardano.

This is the exact goal of plu-ts; with special focus to typescript developers.

How do you intend to measure the success of your project?

plu-ts is already being used by established and emerging project in cardano, on top many other indipendent developers.

Ideally, once the project reaches a production-ready state, the number of projects and independent developers adopting it should be noticeable.

Please describe your plans to share the outputs and results of your project?

So far Twitter has been mainly used to comunicate the progress of the project.

Initially the personal account of MicheleHarmonic was used; later the HarmonicLabs one and currently (finally) the plu-ts profile is being used.

Twitter has proven itself a useful tool to share the progress and it will still be used.

for any unreported progress, the project itself has always been open source, and anyone interested should be able to use github to stay updated; the repository can be found at: <https://github.com/HarmonicLabs/plu-ts>

What is your capability to deliver your project with high levels of trust and accountability?

The main proposer (Michele) is known to have been working on the project from the ground up; the project was ideated when "alternative plutus languages" weren't even a thing, and the idea has raised thanks to projects like this one.

In this process we could say the proposer has acquired the necessary skills and knowledge to successfully complete the project.

What are the main goals for the project and how will you validate if your approach is feasible?

The main goal of the project is to finalize plu-ts so it can be used as a professional tool for dApp development with ease.

we can distinguish all the possible steps for the final product in 3 main categories:

1. developer experience
2. perfomance
3. testing (pre-alpha)

the goals for each of the categories are detailed in the following section.

Please provide a detailed breakdown of your project’s milestones and each of the main tasks or activities to reach the milestone plus the expected timeline for the delivery.

developer experience optimizaitons :

• allow for methods on structs (on the style of builtin lists and pairs)
• add additional "native" methods over maps (list of pairs) such as "lookup"; based on standard equality

performace optimizations :

• optimizations over builtin methods

example: list.at( constantIndex ) compiles to a constant time operation, instead of being based on recursion (already done for some; compile time known recursive functions)

• optimizations over all the recursive functions or methods (also user implemented)
• static IR analysis
• optimized field extractions
• function interface modifications for efficiency (for example cases where entire structs are passed but only some fields are used)

testing process :

• introduction of a native "Blockchain emultaor" for reproducible tests
• incrementally more complex functions and contracts implementation

Please describe the deliverables, outputs and intended outcomes of each milestone.

each of the goals above will result in an incremental version.

the exact version will depend by the compatibility of the cheanges made;

as an example, the introduction of methods on structs will potentially break compatibility with the current v0.4 so a new version will be required (eg v0.5)

same goes for additional methods over builtin types such as lists or maps,

other might still be compatible with existing implementations; namely, the performance optimizations which are hidden to the user; in those cases it will result in a patch increment (eg 0.5.0 -> 0.5.1).

The final product will be marked with version 1.0.0.

Please provide a detailed budget breakdown of the proposed work and resources.

The total amount required for the project is 566,890 ADA.

The amount has been calculated as follows.

The total amount of ADA allocated to the challenge is 6,316,800 ADA.

To operate with a price that is not subject to volatility over time we are assuming that corresponds to an allocation of 1,800,000 $

that would roughly correspond to a price of 1,800,000 / 6,316,800 = 0,284954407 $/ADA

or equivalently 1,800,000 / 6,316,800 = 3,509333333 ADA/$

To better handle the load of goals implementation and testing we feel that two engineers should be working parallelly on the project (qualified engineers will be recruited before the start of the project; therefore this isn't a milestone)

A wage of 45 $/h after taxes should be fair for the experience required;

Since the hiring entity operates in Italy we'll consider a 22% standard tax due to VAT (see source on agenzia delle entrate)

45 · (100 / (100 - 22)) =

45 · 100 / 78 =

4500 / 78 ~= 57.692 $/h

The estimated timeline for the final product is of 8 months.

assuming 8h of work a day; for 5 days a week, for ~35 weeks in an 8 months period, the following should be the yearly cost of a single engineer involved in the project:

57.692 · 8 · 5 · 35 = 80,768.80 $

multiplied by 3, which is the number of expected people actively working on it, we should have the final cost of the project in dollar value:

80,768.80 · 2 = 161,537.60 $

which, at a rate of 3,509333333 ADA per $, results in a final amount of:

161,537.60 $ · 3,509333333 ADA/$ = 566,889.284267 ADA

Who is in the project team and what are their roles?

The main proposer will be actively working on the proposal.

Michele (twitter: MicheleHarmonic) has a deep understanding of the Cardano protocol and most of the implementation details required for many projects; most of them are publicly verifiable through the Harmonic Labs' GitHub (Michele's company, dedicated to Cardano dApps & infrastructure development)

Harmonic Laboratories S.R.L. constantly receives applications from largely qualified engineers to work on the company's project; despite that so far Harmonic Labs hasn't had the capability to hire any of them, hence the reason for the missing profile.

The other figure to be hired would have to satisfy the following (minimum) requirements:

• senior Typescript developer
• solid experience with functional programming

nice to have for the applicants are:

• solid understanding of UTxO-based ledgers

How does the cost of the project represent value for money for the Cardano ecosystem?

plu-ts has already proved to be a valid option among the alternative today we have in order to build a decentralized application; so far that some pioneer projects and independent individuals are actively using it already.

Many more are reluctant to the idea exactly because it is a new technology and not fully tested yet.

a project like plu-ts ready for production means that more developers will have a concrete choice on their favorite stack to use on Cardano.