| 3 | | `Signatories, observers, and controllers` | Signatories, observers, and controllers are parties involved in actions taken on a contract, i.e., actions that are *exercised* on a contract. Signatories, observers, and controllers are therefore represented by the `Party` data type. They control who can read, create and archive a contract.
| 4 | | `Contract` | Contracts are created from blueprints called `templates` - this is the Daml code you write. Templates include:
- contract data (e.g., date, description, parties involved etc.)
- roles (signatory, observer)
- choices and their respective controllers (*who* gets to do *what*)
Every contract is a *template instance* stored as a row on the ledger. Contracts are immutable: once they are created on the ledger, the information in the contract cannot be changed. In order to "change" a contract you need to create a new one with the desired contract data.
| 5 | | `Choice` | A choice is something that a party can exercise (take action) on a contract. Choices give you a way to transform the data in a contract: while the contract itself is immutable, you can write a choice that archives the contract and creates a new version of it with the updated data.
A choice can only be exercised by its controller and contains the `authorization` of all of the contract's signatories as well as of the controller.
| 6 | | `Ledger` | The ledger represents the database where all contracts are recorded. More information on Daml Ledgers can be found here.
| 7 | 8 | If you are interested you can find the detailed glossary here and a free online course here. 9 | -------------------------------------------------------------------------------- /_includes/en/ContractKeys.md: -------------------------------------------------------------------------------- 1 | Contract keys are unique and stable references to a contract that won't change even if the contract 2 | id of that contract changes due to an update. 3 | 4 | Contract keys are optional. 5 | 6 | Contract keys have an associated set of key maintainer parties. These parties guarantee the uniquess 7 | of their maintained keys. 8 | 9 | Contract keys are specified on a contract template with the `key` and `maintainer` keywords. If you 10 | specify a `key` you also have to specify its `maintainers`. 11 | 12 | | -------------------- | ----------------------------------------------------- | 13 | | `key` | Can be any expression of the contract arguments that does _not_ contain a contract id. It _must_ include all maintainer parties specified in the `maintainer` field. | 14 | |`maintainer` | Keys are unique for all specified maintainers. The maintainers need to be a projection of the expression specified with `key`.| 15 | -------------------------------------------------------------------------------- /_includes/en/Data.md: -------------------------------------------------------------------------------- 1 | | | | 2 | | -------------------- | ----------------------------------------------------- | 3 | | Record | `data MyRecord = MyRecord { label1 : Int, label2 : Text}` | 4 | | Product type | `data IntAndText = IntAndText with myInt : Int, myText : Text` | 5 | | Sum type | `data IntOrText = MyInt Int | MyText Text` | 6 | | Record with type parameters | `data MyRecord a b = MyRecord {label1 : a, label2 : b}` | 7 | | Deriving Show/Eq instances | `data MyRecord = MyRecord {label : Int} deriving (Show, Eq)` | 8 | -------------------------------------------------------------------------------- /_includes/en/Functions.md: -------------------------------------------------------------------------------- 1 | | ------------------------ | ------------------------------------------------- | 2 | | Signature | `f : Text -> Text -> Text` 3 | | Definition | `f x y = x <> " " <> y` | 4 | | Lambda definition | `\x y -> x <> y` | 5 | | Polymorphic functions | `f : (Show a, Eq a) => a -> Text -> Text`| 6 | | Function application | `f "hello" "world!"` | 7 | | Partial application of functions | `salute : Text -> Text`
`salute = f "Hello"`| 8 | 9 | Functions are first class members of Daml, in particular, functions can be arguments to functions 10 | ``` 11 | apply : (Text -> Text) -> Text -> Text 12 | apply h x = h x 13 | 14 | apply salute "John" -- "Hello John" 15 | ``` 16 | -------------------------------------------------------------------------------- /_includes/en/JavaScript.md: -------------------------------------------------------------------------------- 1 | Daml ledgers expose a unified API for interaction. 2 | 3 | The following describes how to interact with a ledger using the TypeScript libraries `@daml/ledger`, `@daml/react` in a 5 | frontend build with React . 6 | 7 | Import the libraries via: 8 | 9 | ``` 10 | import Ledger from @daml/ledger 11 | import {useParty, ...} from @daml/react 12 | ``` 13 | 14 | React entry point: 15 | 16 | ```typescript 17 | import DamlLeddger from @daml/react 18 | 19 | const App: React.FC = () => { 20 |
`...`
`
You're logged in as {party}
`| 33 | | Query the ledger | `const {contracts: queryResult, loading: isLoading, } = useQuery(ContractTemplate, () => ({field: value}), [dep1, dep2, ...]) ` | 34 | | Query for contract keys | `const {contracts, loading} = useFetchByKey(ContractTemplate, () => key, [dep1, dep2, ...])` | 35 | | Reload the query results | `reload = useReload();``...`
`onClick={() => reload()}`| 36 | | Query the ledger, returns a refreshing stream | `const {contracts, loading}` = useStreamQuery(ContractTemplate, () => ({field: value}), [dep1, dep2, ...]) ` | 37 | | Query for contract keys, returns a refreshing stream | `const {contracts, loading} = useStreamFetchByKey(ContractTemplate, () => key, [dep1, dep2, ...])` | 38 | | Create a contract on the ledger | `const ledger = useLedger();`
`const newContract = await ledger.create(ContractTemplate, arguments)`| 39 | | Archive a contract on the ledger | `const ledger = useLedger();`
`const archiveEvent = await ledger.archive(ContractTemplate, contractId)`| 40 | | Exercise a contract choice on the ledger | `const ledger = useLedger();`
`const [choiceReturnValue, events] = await ledger.exercise(ContractChoice, contractId, choiceArguments)`| 41 | -------------------------------------------------------------------------------- /_includes/en/Resources.md: -------------------------------------------------------------------------------- 1 | - [Official documentation](https://docs.daml.com) 2 | - [The Daml code repository](https://github.com/digital-asset/daml) 3 | - [A Daml project template](https://github.com/digital-asset/create-daml-app) 4 | - [Read about how people are using Daml on the Daml Blog](https://daml.com/blog) 5 | -------------------------------------------------------------------------------- /_includes/en/Scripts.md: -------------------------------------------------------------------------------- 1 | Daml script is a scripting language to run Daml commands against a ledger. For example: 2 | 3 | ``` 4 | module Test where 5 | 6 | import Daml.Script 7 | 8 | test : Script () 9 | test = do 10 | alice <- allocateParty "Alice" 11 | bob <- allocateParty "Bob" 12 | c <- submit alice $ createCmd NewContract with ... 13 | submit bob $ exerciseCmd c Accept with ... 14 | ``` 15 | 16 | Scripts are compiled like usual Daml code to a `dar` package with the `daml build` command. 17 | 18 | | -------------------- | ----------------------------------------------------- | 19 | | Running a script | `daml script --dar example-0.0.1.dar --script-name ModuleName:scriptFunction --ledger-host localhost --ledger-port 6865` 20 | | Running a script with initial arguments given | `daml script --dar example-0.0.1.dar --input-file arguments_in_damllf_json.json --script-name ModuleName:scriptFunction --ledger-host localhost --ledger-port 6865` | 21 | | Allocating a party on the ledger | `alice <- allocateParty "Alice"` | 22 | | List all known parties on the ledger | `parties <- listKnownParties` | 23 | | Query for a given contract template visible to a given party | `query @ExampleTemplate alice` | 24 | | Create a new contract | `createCmd ExampleTemplate with ...` | 25 | | Exercise a choice on a contract | `exerciseCmd contractId ChoiceName with ... ` | 26 | | Exercise a choice on a contract by contract key | `exerciseByKeyCmd contractKey ChoiceName with ... ` | 27 | | Create and then exercise a choice on the created contract | `createAndExerciseCmd (ExampleTemplate with ... ) (ChoiceName with ...)` | 28 | | Pass time on the ledger (only applicable for a ledger running in **STATIC TIME MODE**, like the in-memory ledger of Daml Studio or `daml test`) | `passTime (hours 10)` | 29 | | Set time on the ledger (only applicable for a ledger running in **STATIC TIME MODE**, like the in-memory ledger of Daml Studio or `daml test`) | `setTime (time (date 2007 Apr 5) 14 30 05)` | 30 | -------------------------------------------------------------------------------- /_includes/en/Templates.md: -------------------------------------------------------------------------------- 1 | Contract templates describe data that will be stored on the ledger. Templates determine who can read 2 | and write data; and by whom and how this data can be altered. 3 | A contract template is defined with the `template` keyword: 4 | 5 | ``` 6 | template MyData 7 | with 8 | i : Int 9 | party1 : Party 10 | party2 : Party 11 | dataKey : (Party, Text) 12 | where 13 | signatory party1 14 | observer party2 15 | key dataKey : (Party, Text) 16 | maintainer key._1 17 | 18 | choice MyChoice : () 19 | ... 20 | ``` 21 | 22 | `with` and `where` are keywords to structure the template. 23 | 24 | | -------------------- | ----------------------------------------------------- | 25 | | `signatory` | Observes the contract and its evolution. Gives the signatory's authority to all the defined contract updates in the contract choices. | 26 | | `observer` | Observes the contract and its evolution. | 27 | | `key` | A field of the contract data used as primary index of contracts defined by this template, see `Contract Keys`. | 28 | | `maintainer` | A set of parties that guarantee uniqueness of contract keys of this template on the ledger, see `Contract Keys`. | 29 | 30 | -------------------------------------------------------------------------------- /_includes/en/Types.md: -------------------------------------------------------------------------------- 1 | | ------------------------ | ------------------------------------------------- | 2 | | Type annotation | `myVar : TypeName`| 3 | | Builtin types | `Int, Decimal, Numeric n, Text, Bool, Party, Date, Time, RelTime` | 4 | | Type synonym | `type MyInt = Int` | 5 | | Lists | `type ListOfInts = [Int]`| 6 | | Tuples | `type MyTuple = (Int, Text)` | 7 | | Polymorphic types | `type MyType a b = [(a, b)]`| 8 | -------------------------------------------------------------------------------- /_includes/en/Updates.md: -------------------------------------------------------------------------------- 1 | Updates specify the transactions that will be committed to the ledger. Updates are described within 2 | a `do` block: 3 | 4 | ``` 5 | do 6 | cid <- create NewContract with field1 = 1 7 | , field2 = "hello world" 8 | let answer = 42 9 | exercise cid SomeChoice with choiceArgument = "123" 10 | return answer 11 | ``` 12 | 13 | 14 | | -------------------- | ----------------------------------------------------- | 15 | | `create` | create an instance of the given template on the ledger
`create NameOfTemplate with exampleParameters` | 16 | | `exercise` | exercise a choice on a given contract by contract id
`exercise IdOfContract NameOfChoiceContract with choiceArgument1 = value1 `| 17 | | `exerciseByKey` | exercise a choice on a given contract by contract key
`exerciseByKey @ContractType contractKey NameOfChoiceOnContract with choiceArgument1 = value1 ` | 18 | | `fetch` | fetch the contract data from the ledger by contract id
`fetchedContract <- fetch IdOfContract `| 19 | | `fetchByKey` | fetch the contract id and data from the ledger by contract key
`fetchedContract <- fetchByKey @ContractType contractKey` | 20 | | `lookupByKey` | check whether a contract with the given key exists and if yes, return the contract id
`fetchedContractId <- lookupByKey @ContractType contractKey` | 21 | | `abort` | abort a transaction with an error message, the transaction will not be committed to the ledger
`abort errorMessage` | 22 | | `assert` | assert that a given predicate holds, otherwise fail the transaction
`assert (condition == True)` | 23 | | `getTime` | get the ledger effective time
`currentTime <- getTime `| 24 | | `return` | return a value from a `do` block
`return 42`| 25 | | `let` | bind a local variable or define a local function within the update `do` block
`let createContract x = create NameOfContract with issuer = x; owner = x`
`let answer = 42 `| 26 | | `this` | refers to the current contract data that contains this update in a choice
`create NewContract with owner = this.owner` | 27 | | `forA` | run a for loop of actions over a list
`forA [alice, bob, charlie] $ \p -> create NewContract with owner = p` | 28 | -------------------------------------------------------------------------------- /_includes/en/What-is.md: -------------------------------------------------------------------------------- 1 | [Daml](https://daml.com) is an open-source smart contract language designed to build composable 2 | applications on an abstract ledger model. 3 | 4 | Daml is a high level language that focuses on data privacy and authorization of distributed 5 | applications. These concepts are represented first class in the language. 6 | 7 | By abstracting data privacy and authorization, Daml takes the burden off the programmer to think 8 | about concrete cryptographic primitives and lets her focus on workflow logic. 9 | 10 | Daml is a statically typed functional language. 11 | 12 | The full documentation of Daml can be found here . 13 | -------------------------------------------------------------------------------- /_includes/header.html: -------------------------------------------------------------------------------- 1 |
2 | 
7 |
8 |
9 |
10 |
11 |
12 |
3 |
6 | {{ site.t[page.lang]["fast-track"] }}
4 |{{ site.t[page.lang]["quick-dirty"] }}
5 |
7 |
8 |
9 |
10 |
13 | {{ site.t[page.lang]["github-1"] }}
14 |
15 | {{ site.t[page.lang]["github-2"] }}
16 | .
17 | {{ site.t[page.lang]["github-3"] }}
18 |
19 |
--------------------------------------------------------------------------------
/_layouts/default.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |