Smart Contracts for… SaaS apps?!

  • We’re open sourcing OpenWork: 3 productivity apps backed by smart contracts. The suite comprises Kanban boards, team chat, and a vacation tracker.
  • Smart contracts are often closely associated with financial transactions due to their history, but they’re more broadly applicable than that. Any app which needs transparent data management and open APIs is suitable.
  • The early generations of distributed ledgers were hard to use, so only high-dollar value use cases were tried. With Daml, the difficulty of writing smart contracts drops so low that new fields open up.
  • As an experiment, we’ve built or ported 3 productivity products to prove that hypothesis, and learn about what works and where improvements can be made to the current tooling.
  • At some point, the overhead of writing smart contracts will be so low that all persistence backends will be described in this way. You can get ahead of the curve by downloading the Daml SDK and taking a look at what we’re working on.

What do you think of when you hear “smart contracts”? Cryptocurrencies? Tokenization of assets? Automating financial agreements? Track and trace? Those are certainly canonical use cases, but are they all smart contracts are good for?

Smart contracts were first described by Nick Szabo in 1994, but really exploded in popularity with the advent of Ethereum in 2015. Given that Ethereum had a native cryptocurrency with a burgeoning market around it, most of the early smart contracts that were built were monetary in nature.

Around the same time, we at Digital Asset were working on streamlining post-trade capital markets. While they certainly have monetary components, the workflows in the capital market space are richer: coordinating information flows and permissions between different parties before finally moving assets, often in a batch settlement.

The smart contract languages of the day, such as Solidity, didn’t cut it for our needs so we developed Daml — a programming language capable of describing the rich processes around persisting and updating critical information. More than just the ability to describe these processes, Daml was designed to be easy to write.

Try OpenWork Board now or download the Daml SDK and fork the code now!

When you think about smart contracts like we do — a high-level language that makes persisting and updating information transparent, safe, and easy — it becomes clear that financial contracts are just one possible use case. In fact, what could be more critical to your business than the tools you use to get your tasks done? Whether it’s a todo list, internal communications, or even tracking time-off, these are key processes at the heart of everyday organizations.

When smart contracts were hard to write, and the languages designed around money movement, it would be crazy to think about writing productivity apps backed by smart contracts. But because Daml’s different, that’s exactly what we tried.

Over the past few weeks we’ve built or ported 3 separate productivity apps to use smart contracts: kanban boards, team chat, and a vacation tracker. We’ve committed to using these tools internally and we’ll be releasing them as open source under the OpenWork brand for you to inspect and deploy yourself.

Our motivation was to prove our hypothesis that smart contracts had value beyond currency transactions and to learn where the pain points were so we could work improvements into our roadmap. In that respect it was a resounding success, and expect to see some useful features coming to the Daml SDK soon!

However, we also think that there are teams who’d be interested in running open-source productivity apps which are “radically transparent”, where smart contracts give users the powers to inspect, remix, and extend the core functionality, and where the data is portable across different persistence layers, including blockchains. Perhaps you work with one of the platforms that Daml supports and would like your productivity tooling to use the same stack? Perhaps you’re an open source community and you’d like to store key collaboration data across multiple providers rather than be locked-in to a single vendor? If that sounds interesting to you, we’d love to hear from you.

As it stands, writing smart contracts is still more overhead than writing traditional, centralized storage definitions. But for increasing classes of applications today the benefits already outweigh the costs, and as we continue to improve the tooling, that costs keep dropping. In the not-too-distant future, we expect that all new apps will be written with a distributed mindset. You can get a jump on that future by exploring Daml today.

This is the first in a short series of posts about OpenWork and Daml. Future posts will explain the interesting features of the apps as they stand today and where they could head.

Read the next post: Inside the “Radically Transparent” OpenWork Suite

Release of Daml SDK 0.13.54


  • Removed the warnings regarding static time and scenarios on
    initialization. We will not deprecate these until we have a stable
  • If no ledger ID is provided when running against an existing ledger,
    use the existing ID. Previously, Sandbox would fail to start.

Daml Standard Library

  • Add subtractDays to the Daml Standard Library.

Skip the Scaffolding with Project:DABL

So you’re an entrepreneur who’s dreamed up the Next Killer Idea?

As thousands of startups before you have discovered, a product vision is just a nice story unless you can find the market for it. Your most important tasks on the way to market should be refining your early ideas into killer features and finding your first customers.

Sadly, the majority of your efforts instead will likely go into building baseline functionality that those customers will never see: infrastructure, APIs, user management, authorization, roles and access controls, not losing your first users’ data … The list goes on. 

Why put up with it? All this effort is just a tax on your idea — something that prevents you from getting to market. You really want to test your product’s fit in the market and win your first users — not prove that you know how to bootstrap a software stack. Even if you can finance it, it’s a resource-intensive grind that overwhelms from the excitement of your idea with the difficulties of getting something shipped.

We are working hard to build Daml and project:DABL to end this scourge of innovation. Daml is open source under Apache 2.0, and DABL is free to use until your product gets enough traction that early adopters are using it regularly. We made these decisions to enable permissionless innovation — like you can find in public blockchain networks — but with all the features you know and expect from modern developer platforms. 

How would it change the startup landscape if architects had a tool that could spin up production apps quickly and inexpensively? 

Enter project:DABL — now free for anyone to try — which lets developers deploy and host their Daml applications end-to-end, from the back-end code to the front-end UI.

“Think of DABL as the next evolution of Heroku,” says Product Architect Dimitri Liakakos. “We are making the experience so you never have to provision infrastructure, write code for APIs and authentication, think about how to scale across services, and much more.”

It’s easy for Digital Asset to say that Daml and project:DABL speed time to production — and another to put it to the test with real-world examples anyone can use. 

Check out a couple of DABL-deployed applications born in Digital Asset’s own offices. 


OpenWork can-do

Daml Product Lead Bernhard Elsner had a problem familiar to many new parents: With a small baby at home, he couldn’t travel from Zurich to his company’s offsite meeting in the US. 

Bernhard decided to use the time he would have spent traveling to spin up a Daml version of the workforce collaboration app Trello.

“If we want to build a completely new experience for developers, it’s important we have that experience ourselves,” Bernhard says. “Building new apps using our technology allows us to iterate and fine-tune the developer experience continuously.”

In just four days, Bernhard wrote the back end in Daml, adapted an open source React-Kanban UI, and pushed his new creation live. Many new languages offer tutorials that show you how to build a personal task tracker, but few (if any) let you push that code into prod for anyone to use with the same amount of effort. 

Bernhard’s creation, dubbed OpenWork Board, is free for anyone to use and open source on GitHub for users who have installed the Daml SDK


Using DABL for a better breed of chat 

Across the Atlantic, at Digital Asset’s New York offices, Product Architect Dimitri Liakakos wanted to showcase how developers could deploy distributed applications with Daml in a matter of minutes. However, Dimitri knew that merely talking about the benefits of Daml wouldn’t get his point across.

“Developers are highly opinionated people who are passionate about the tools they use,” Dimitri says. “They’re not going to respond well to someone who just shows up and tells them there’s a better way of doing things.”

Dimitri decided the best way to explain Daml was to show rather than tell. Starting from a basic UI layout he borrowed from Pusher, he built a Daml version of the popular workforce messaging app Slack that he dubbed DABL Chat in less than two weeks. 

DABL Chat highlights some of the features that differentiate a Daml-based messaging application from the pack. Private and bilateral conversations in DABL Chat are not visible to the application operator. DABL ensures that the Daml privacy model is enforced – even against the developer of the application – on a live system. Soon, users of DABL Chat will be able to log into DABL and see all the data that is held in the application and who has access to each piece of data.

“Our long-term goal is to ensure application users have increased transparency and control over the data being held in SaaS applications. As a first step, we allow all users to audit their data via the DABL workspace in real time,” says Eric Saraniecki, co-founder of Digital Asset. 


Go and try it yourself!

A free instance of DABL Chat is ready for you to deploy by logging into project:DABL, building a new project, and launching from the workspace. Anyone can do it – developers and non-developers alike – just follow these simple instructions.

If you would prefer to build and deploy a version yourself, the source code is available as a free download from GitHub. It requires installation of the Daml SDK.

Release of Daml SDK 0.13.53

Daml Stdlib

  • Restrict the (>>) operator to instances of Action and make it lazy in its second argument. This gives expressions of the form do A; B the desirable semantics of only running B when A is a successful action.
  • Remove the Action and ActionFail instances for Validation in DA.Validation. Please enable the ApplicativeDo language extension if you want to use Validation with do-notation and replace fail with DA.Validation.invalid.

Daml Ledger Integration Kit

  • Enforce that all parties referenced as stakeholders, actors, or maintainers in a transaction have been allocated.
  • Ledger API Test Tool default tests modified. Use --list for the updated list of default tests. Time service test dropped from the suite.


  • Static time mode is being deprecated in the future. A warning has been added to notify users of this fact.
  • Scenarios for ledger initialization are being deprecated in the future, in favor of Daml Script. A warning has been added to notify users of this fact. Scenarios can still be used for testing in Daml studio.
  • Participant index contract lookups simplified. This should speed up command interpretation.
  • If authentication is enabled, requests without a valid authentication are going to be rejected with an UNAUTHENTICATED return code instead of PERMISSION_DENIED.

JSON API – Experimental

  • Add {"live": true} to WebSocket streams to mark the beginning of “live” data. See #4461. This marker is a placeholder feature; issue #4509 bookmarks in query streams will obsolete this marker, after which it will no longer be emitted. When building features on the marker, be aware of this forthcoming replacement.

Daml Standard Library

  • Add a subtract function which is useful as a replacement for sections of (-), e.g., subtract 1 is equivalent to \x -> x - 1.

Easy authentication for your distributed app with Daml and Auth0

This post may contain outdated information. Please visit Secure Daml Infrastructure for more up-to-date content.

Daml ledgers that are connected to the public internet need to be protected against unauthorized access. This is done using the same mechanism that is used to authorize the access to the backend of a regular web application: The ledger operator provides a token issuer service where users can authenticate themselves and acquire access tokens. Applications attach these tokens to each ledger API request, and the ledger uses the tokens for authorization checks.

Daml ledgers can be configured to work with arbitrary access token formats, and it is the responsibility of the ledger operator to provide a matching token issuer service. Managed Daml offerings provide such token issuer services and authorization checks out of the box.

In this blog post, we’ll have a look at how to create a custom authorization setup. We’ll use:

  • For the ledger: The Daml sandbox, which comes with integrated authorization checks based on JWT tokens with custom authorization claims.
  • For the token issuer:, a third-party solution for issuing custom access tokens and authenticating users against social identity providers such as google. We have chosen auth0 because it is a popular service that is easy to configure, but any other token issuer capable of issuing custom JWT tokens would work as well.
  • For the application: A simple single page web application that uses an OAuth based workflow to securely acquire access tokens from, and then uses the tokens in the Daml JSON API.

To simplify user management, we’ll set up a “public” ledger: everyone can sign up to use the ledger, and a new Daml party is automatically allocated for each new user.

Authorization workflowauth blog post

The authentication workflow looks like this: a web application contacts and asks for a ledger API access token (1). The user chooses to log in via google, and then asks google to authenticate the user (2). Google asks the user for consent (“are you ok with sharing your identity with this application?”) (3, 4), and returns a google ID token (signed by google) to (5). This token proves the identity of the user, and contains among others the verified email address of the user. uses this information to automatically look up or allocate a Daml party on the ledger (6), generates a corresponding [ledger API access token (signed by, and sends it to the application (7). The application then attaches this token to each ledger API request (8). Finally, the ledger verifies the cryptographic signature of the token and checks whether the token authorizes the user to perform the given ledger API operation.

The remainder of this blog post will provide a step by step explanation of how to set up auth0, the web app, and the sandbox. If you wish to just explore the example application, the source code is available here. We recommend that you change any auth0 configuration values in the example code.

Configuring auth0

To start, log in to or create a new account.

Then, in the web UI, create a new application of type “single page application”. Select your new application, go to its quick start tab, select React as your frontend technology, and download the sample code. On the same page, follow the instructions in the “Configure Auth0” section. If you now run the application (following the instructions in its readme file), you should already be able to log in to your application using google.

Next, we need to tell auth0 about our ledger API. In the auth0 web UI, create a new API. Call it “Ledger API” and use “#” as the API identifier. If you pick a different API identifier, adjust the “audience” parameter in the web app accordingly, as described in the next section.

Finally, we need to configure auth0 to generate ledger API access tokens. This can be done using auth0 rules – these are small JavaScript programs that can be used to customize auth0 functionality. We’ll use one rule to onboard new users onto the ledger, and another rule to generate the access tokens.

Create a new rule in the auth0 web UI with the following content, and call it “Onboard user to the ledger”. This rule only runs once for each user, and stores the Daml party identifier in the auth0 user metadata.


Then, create another rule with the following content, and call it “Add ledger API claims”. This rule runs every time a user requests an access token, and extends the default token with claims that are specific for the sandbox ledger API. Use the rule configuration object if you do not want to hardcode the ledger and application ID in the script


Requesting access tokens

In order to work with an authenticated ledger, we need to modify our web application to request access tokens. Open auth_config.json and add an “audience” field. 


Then, open index.js and add an “audience” parameter to the Auth0Provider react element.


Now add the following component to your application. The main function callLedgerApi() consists of two important steps:

  1. Calling getTokenSilently(). This function provided by the auth0 client library asynchronously returns the ledger API access token. 
  2. Calling fetch(). This is a regular REST call to the Daml JSON API, but with an additional “Authorization” HTTP header where we place the access token.


Starting the web app

The Daml JSON API does not support CORS. In order to run your application locally, add a proxy field to your package.json file. The create react app script will use this to route all unknown requests to the given address.


You can now start a local development server that hosts the web app using

yarn install & yarn start

Starting the sandbox

We need to tell the Daml sandbox how to verify access tokens. This is done using JWKS, which is a public URL that contains the RSA public key for verifying the cryptographic signature of the access token. The JWKS URL of your auth0 tenant is listed in the auth0 docs after you log in – it should look like https://YOUR_DOMAIN/.well-known/jwks.json and you should be able to open the URL in your browser.

We also need to specify the sandbox ledger ID, as the tokens generated by our “Add ledger API claims” auth0 rule contain a hardcoded ledger ID.

Putting this together, start the sandbox using the following command:

daml sandbox .daml/dist/quickstart-0.0.1.dar --auth-jwt-rs256-jwks https://YOUR_DOMAIN/.well-known/jwks.json --ledgerId daml-auth0-example-ledger

Starting the JSON API

The last piece in our setup is the HTTP JSON API. Before we can start it, we need to get an access token that will allow the JSON API to list all Daml packages on the ledger. In a real setup, we could set up a process to automatically acquire the token through machine-to-machine authorization. For this example, the easiest way is to log in to our web app, use the new component that uses the ledger API, and copy the user access token from the browser log. Add a “Bearer “ prefix to the token string and save the result into a local file access-token.txt. You can now start the JSON API using

daml json-api --ledger-host localhost --ledger-port 6865 --http-port 4000 --access-token-file ./access-token.txt 

Having started the sandbox, the JSON API server, and the dev server hosting the web application, you should now be able to log in to your web app using your social ID, and see responses from the JSON API.

Further Considerations

In the above setup, everyone can sign up to use the ledger, and every confirmed email address is assigned a new Daml party. Depending on the application, a more sophisticated setup will be required to link authenticated users to confirmed natural or legal entities.

How XBourse is building the financial market of the future with Daml and project: DABL

Tony Mackay has a history of disrupting financial markets. Mackay was a key member of the Instinet team that pioneered electronic trading in the ‘90s, and in the ‘00s developed INET (the markets and technology that powers NASDAQ). From 2007 onward, Mackay founded Chi-X, which evolved into the largest pan-European trading center and then expanded globally to Canada, Japan, Australia and Singapore.

Now CEO and co-founder of XBourse Global, Mackay is utilizing distributed ledger technology to again create innovative market solutions that will help businesses of all sizes expand their access to capital.

In the process, XBourse partnered with Digital Asset to develop differentiated market-as-a-service offerings in as little as three months. XBourse’s development team employs Daml, Digital Asset’s open-source smart-contract language, and DABL, a Daml deployment environment. 

Here are three ways XBourse is using Daml and DABL to develop the financial market infrastructure of the future:

1. Accelerate the development of new market-as-a-service offerings.

Raising capital can be an onerous process for businesses. For example, going public can take as long as 18 months and can cost around 10% of the funds raised. It’s no wonder that more than half of private companies abandon their plans for an IPO. 

XBourse is democratizing access to capital by allowing companies to create private corporate security issuance platforms for their company. These platforms support secondary trading markets and collateralized loan modules, so companies can build out their own internal markets and digitally connect with investors via investment and loyalty tokens.

“We are building a different version of financial markets that allows businesses to tokenize assets that aren’t easily served by traditional paper flows,” Mackay said. “With XBourse, businesses are free to focus on defining workflows aligned with their business needs, instead of having to worry about the security, reliability and availability of the underlying infrastructure.”

Allan Erskine leads the technology team at XBourse. Erskine’s first project at the company: to build out a private bond issuance platform for a leading resort company. Only a few weeks into the project, Erskine was impressed by how fast he was able to get to market with Daml.

“Daml is a powerful high-level language,” Erskine said. “I can succinctly define my data states and associated parties with just a few lines of code. What’s more, with Daml I don’t have to worry about factors like authorization checks, user-privacy controls, and double-spends. All of these checks happen automatically during compile-time.”

With Daml, Erskine was able to go to market with a private bond issuance platform in a little over three months.

“Daml is a highly secure smart-contract language,” Erskine says. “Daml has a powerful type system that catches large categories of errors prior to deployment. This helps ensure that every transaction on the system is secure and error-free”

DABL is a managed cloud-based offering that lets developers host their Daml applications end-to-end – from the back-end code to the front-end UI. 

“DABL takes care of many of our hosting concerns,” Erskine said. “Our system makes use of DABL ‘bots’ that take care of tasks like managing interactions with the ledger without having to worry about hosting our own customized services.”

2. Make financial markets more secure and efficient.

Financial assets can be traded many times with many different counterparties over the course of a day. Modern markets consolidate the number of outstanding line items by netting offsetting investors’ trades into a single position at the end of the day.  

However, the net delivery of securities or assets versus the net payments for these normally occurs a few days later.  This introduces the risk of default into the process — as evidenced by the fall of Lehman Brothers in 2008, the delay involved with settlement can pose a significant risk to investors.

Distributed Ledger Technology will allow investors to verify their trades and reconcile positions in near real time. This could enable trades to be settled on the day of trading – thereby removing a huge element of risk and cost (via margins) to the entire financial system.

Developed with Daml, XBourse’s trading platforms offset this risk by allowing different parties to confirm every trade in a centralized ledger. 

“Daml allows us to overcome the limitations associated with traditional blockchain in a very clever way,” Mackay said. “With Daml, we can identify the parties associated with every transaction. We can use Daml to lock in every trade and perform near real time verification and reconciliation at the end of the day ”

Notably, Daml and DABL made it easy for XBourse to build out workflows for different scenarios.

“Daml gives us the flexibility to define workflows where settlements are instantaneous and atomic, and don’t need compression and netting. We can also define separate workflows for bulk transactions.”

3. Drive interoperability between multiple exchanges.

Daml is a blockchain-agnostic and open smart contract language. This makes it easy to integrate with private exchanges as well as multi-project open source collaborative efforts like Hyperledger.

“With Daml, we can choose a database solution if that makes sense, or choose to layer over open-source payment and settlement layers, as is the norm,” Mackay said.

Because Daml is interoperable with most of the leading blockchains and new ones, businesses using XBourse should be able to read and write to any blockchain.

“History might not repeat itself,” Mackay said. “But it does rhyme,” with certain patterns emerging again and again. “As we saw in the 1990s, people that adapt to new technologies are the new winners.”

“I firmly believe that the financial industry is ripe for disruption, and Daml is going to be key in making that happen.”

Learn more and download the Daml SDK here. You can also see a DABL demo and learn more here.

For more information on XBourse, please visit

Release of Daml SDK 0.13.52

Daml Assistant

  • The assistant can now do completions for SDK commands, e.g., daml ledger upl<TAB> will complete to daml ledger upload-dar.
  • The new behavior introduced in 0.13.51 to shut down when stdin is closed is now disabled unless you explicitly enable it by passing --shutdown-stdin-close.

Daml Script

  • Add a HasTime instance for Script which allows you to get the current time (UTC in wallclock mode, UNIX epoch otherwise)

Daml Script – Experimental

  • The time mode must now always be specified explicitly. Use --static-time to recover the previous default time mode.
  • Add a sleep function that pauses the script for the given duration. This is primarily useful in tests where you repeatedly call query until a certain state is reached.

Daml SDK

  • Fix computation of witnesses of top-level fetch nodes in scenario results (“known to”).

Daml Studio

  • You can now open Daml Studio in the root of a multi-package project instead of opening it separately for each package. Take a look at the documentation for details on how to set this up.

Daml Triggers – Experimental

  • The time mode must now always be specified explicitly. Use --static-time to recover the previous default time mode.

JSON API – Experimental

  • wrap Streaming API events in JSON object: { "events": [ E1, E2, ... ] }. See issue #4384.
  • The format of archived responses from WebSocket endpoints has changed to include template IDs, similar to exercise responses. See issue #4383.
  • Rename JSON API endpoints. See issue #4289 and issue #3145.
    /command/create => /v1/create
    /command/exercise => /v1/exercise
    /contracts/lookup => /v1/fetch
    /contracts/search => /v1/query
    /contracts/searchForever => /v1/stream/query
    /contracts/lookupForever => /v1/stream/fetch
    /parties => /v1/parties
  • Exercise response field “contracts” renamed to “events”. See issue #4385.
  • Added streaming version of fetch by key: /stream/fetch. See issue #4705.
  • /contracts/searchForever accepts multiple queries, and includes with each created result the matchedQueries indicating which queries matched. See issue #4363.


  • Fixed a memory leak when using the ResetService; not everything was cleaned up correctly.
  • Preliminary work to rebuild Sandbox on top of the Daml Ledger Integration Kit. Currently not exposed through the CLI.

Smart Legal Contracts

This is a guest post by Arity, a technology company based in New York building next-generation contract software.

What is a “smart legal contract” and how do legal contracts interact, if at all, with distributed ledgers? Some take the view that Ricardian contracts are the correct paradigm to reason about the interplay between software and legal contracts.

A Ricardian contract places the defining elements of a legal agreement in a format that can be expressed and executed in software.

There is an allure to having a contract that is both readable by attorneys and executable by software. But, it is practically very difficult to build software that parses natural legal language and code as part of the same document. At least in the short term, it is far more likely that quasi-Ricardian contracts or another model arises to connect legal contracts to smart contracts.

So, the real question becomes how do we connect natural language prose to a smart contract or series of smart contracts that takes some automated action based on the legal contract? At Arity, we believe changing the document model underlying legal documents can have a significant effect on integrating legal contracts with smart contracts. Arity’s web-native editor for legal contracts uses a data-rich document model that is human-readable and can be parsed and manipulated using any programming language, including smart-contract languages.

An example of the document model underlying Arity’s editor.

By changing the document model and embedding data within the model itself, we can transform our legal contracts into documents that can be processed by software, including smart-contracts, and used in interesting applications that require data typically locked in natural language prose.

With a data-rich document model underpinning legal contracts, there are many interesting applications leveraging distributed-ledger technology that can be built. In fact, many smart-contract use cases currently being explored, at base, rely heavily on legal contracts. Use cases in finance, supply chain, and global trade all currently run on “dumb” legal contracts.

The first step to building a meaningful smart-contract application using legal contracts is getting verified data from a legal contract on the ledger. As anyone who has built a smart-contract application knows, garbage data in equals garbage out. 🗑️

To ensure data fidelity and consistency, Arity’s engineering team has prototyped a peer-to-peer network for signing legal contracts that have a data-rich document model underpinning each contract. We have chosen to build the prototype using Daml, an open-source programming language for writing distributed applications quickly, concisely, and correctly. Using the provable correctness of Daml, we were able to build a prototype that allows any Daml Party – a primitive data type in Daml that uniquely represents a user in a Daml network – to receive a proposed legal contract, go through a defined Daml workflow, and execute the legal contract using that Party’s cryptographic keys. The legal agreement is then persisted as a SignedContract (see lines 181-187) representing the final, signed legal contact. But, in this case, the signedAgreement (line 183) has a JSON-like data structure rich with information and data pertaining to the legal contract.

Any of the Daml Parties involved in the legal contract workflow can then utilize the SignedContract on line 181 – or just certain data within the JSON-like data structure – in other Daml smart contracts to perform interesting and in some cases automated actions. For instance, if the legal contract pertained to an insurance policy, the claims administrator could utilize other Daml contracts to receive and process insurance claims in a more automated manner using data tied directly to the underlying insurance policy, whose execution and information is recorded on the ledger.

Daml program for peer-to-peer execution of legal contracts.

We have presented a prototype that provides a strong primitive for building further applications using any data within the legal contract itself, all of which are made possible by recording a data-rich document model – the JSONValue – within the distributed ledger itself for use in a myriad of smart contracts. A peer-to-peer legal network as envisioned could have businesses and individuals with their own unique cryptographic keys for signing data-rich legal documents that, when executed, would be recorded on a distributed ledger. The ledger would record the authoritative legal document for all parties and allow any of the parties to a contract to compose even further Daml workflows using data from the executed legal document.

Why we used Daml

Arity chose to use Daml for this use case for a number of reasons:

  1. We became productive in Daml using the Daml SDK quickly. Daml is intuitive to use, and abstracts away important but critical elements when building smart-contract applications. For instance, Daml’s strong authorization abstractions are powerful to build off of. Using signatories, observers, and choices, it is effectively impossible for any Party in a Daml network to enter into a smart-contract without that Party’s authorization. As a benefit, this closely tracks the legal world as well.
  2. Daml abstracts the ledger underlying a Daml program so the application developer can focus on business logic without having to pick, up front, the underlying distributed ledger.
  3. Daml is a very readable programming language, meaning even attorneys can understand the syntax and effect of a Daml program.
  4. The privacy features of Daml are critical for an application involving sensitive data, such as legal contracts. Using Daml, you can simply write your smart-contracts using Parties and Observers and data on the ledger is only disclosed to the correct Parties and Observers, by default.

As Arity continues to build out the prototype, we will continue to use Daml and explore some of its more powerful features.

About Arity

Arity is a technology company based in New York, New York building next-generation contract software. Arity’s web-native editor makes composing contract templates, clauses, and workflows simple for legal teams, allowing all stakeholders in the contract process to collaborate, in a data-rich way, like never before. Learn more about Arity on its homepage.

Release of Daml SDK 0.13.51

JSON API – Experimental

  • In websocket endpoints, if a created and archived contract
    in the same result array share a contract key, the archived is
    guaranteed to occur earlier in the array than the created. See
    issue #4354.

Daml Assistant

  • Bash and Zsh completions will now fall back to regular file
    completions after the command argument.
  • The Daml assistant will now shut down long-running processes like
    daml sandbox when stdin is closed. This is mainly useful on
    Windows, where process APIs often kill the process in a way that
    does not allow it to do any cleanup, in particular, we cannot stop
    child processes.


  • Added a test case to the participant state tests to ensure your
    ledger state is resumable upon restart.


  • Fix an error that stops the server from exiting cleanly if API
    server initialization fails.

Daml Stdlib

  • Added partition function to prelude.


  • Updated roadmap to reflect the current state.

Outcompeting Destructive Systems with Smart Contracts

How to Leverage New Technology for Reducing Carbon Emissions and Plastic Waste

The recent conversation at Davos centered around the critical importance of combating climate change by replacing destructive systems with both sustainable and economically viable solutions. In fact, our CEO, Yuval Rooz, recently participated on a panel hosted by Global Blockchain Business Council and the non-profit open innovation group, Odyssey, focused on how emerging technologies, particularly blockchain and smart contracts, can enable collaboration and outcompete destructive systems.

As Yuval expressed at Davos, “A lot of people talk about how blockchain is going to change the world, but I actually think that what we can do by educating people about blockchain is change how humans interact with one another.” This has been on my mind as I head to The Hague for the Odyssey Hackathon Connect event this week with our partners at VMware to determine how blockchain technology and our Daml smart contract language can help individuals, governments and corporations achieve the UN Sustainable Development Goals (SDGs)

The effects of greenhouse gasses (GHGs) due to rising carbon emissions are leading to irreversible damage to the planet at an alarming rate. Many of the effects of GHGs are turning out to exceed the worst case scenarios predicted by climate change scientists, including the rate of glacial melting, sea level rise and increase in ambient and ocean temperatures. As a result of these terrestrial and marine changes, countries and cities around the world are striving to cope with heat waves, wildfires, storms and floods, air quality and public health crises.

The numbers alone make the case for why we need to act with urgency. In 2019, about 43.1 billion tons of CO2 from human activities were emitted into the atmosphere, while 8 million tons of plastic ended up in our oceans. So how can we help empower individuals, governments and corporations to combat this? By fostering more efficient and profitable circular economies designed to continuously and creatively re-use, re-invent, and re-purpose resources. These ecosystems will inevitably generate new business models that operate sustainably, through collaboration, distributed trust, and equitability.

In addition to the social and ecological benefits, industry stakeholders can also gain significant economic and business value from robust solutions in this space. Waste from single-use plastic packaging costs the global economy an estimated $100+ billion a year in lost value, while innovations in low-emission and carbon-neutral energy sources represent a multi-trillion dollar investment opportunity in emerging industries.

Smart contracts and blockchain technology can facilitate these models by enabling wide-spread community partnerships to build a better future. Global leaders in business and government need to collaborate to support mass adoption of compelling solutions that can combat the wastefulness and pollution endemic in existing destructive systems.

As an innovator and first mover in the smart contract and blockchain space, I am excited to represent Digital Asset in supporting teams to employ the unique properties of Daml with VMware blockchain deployment, including immutability, auditability, security, and traceability. Together we can empower consumers and organizations alike to make informed decisions around carbon emissions and the repurposing of ocean plastics, as well as build systems to enable transparency on a grander scale. 

By creating a platform to measure alignment to the UN Sustainable Development Goals, as well as the global call to keep the temperature of the planet from rising above two degrees, corporations can support governments by effectively and efficiently tracking and monitoring carbon emissions. Using Daml and VMware Blockchain, teams will be able to rapidly innovate to build solutions that combat the most pressing issues facing our planet. Collectively, this is what we are setting out to do by supporting the “From Plastic Pollution to Upcycling Economy” and “Consumer and Organization-Driven Decarbonization” challenges at the Odyssey Hackathon. Dozens of teams and industry stakeholders involved in these tracks have the opportunity to create – and adopt – transformative solutions addressing the most challenging ecological and economic problems today, while generating significant investment and business opportunities.

Join us this week in The Hague for the Daml & VMware Blockchain Meetup at Odyssey Connect, February 5th at 6:00pm and participate in the hackathon on April 3 – 5 to turn these goals into our shared reality.

Join our Meetup @ Odyssey Connect!

Apply for Odyssey Hackathon!