• Daml Documentation

Home

  • Introduction to Multi-Party Applications
    • Multi-Party Applications
    • Why Do Multi-Party Applications Matter?
    • What Is a Multi-Party Application?
    • Important Concepts in Multi-Party Applications
    • Key Architectural Concepts in Daml
    • Transfer Example Using Daml
    • Next Steps

Set Up Your Developer Environment

  • Installation
    • Install the Dependencies
    • Choose Daml Enterprise or Daml Open Source
    • Install Daml Open Source SDK
      • Windows 10
      • Mac and Linux
    • Install Daml Enterprise
    • Download Manually
    • Next Steps
  • System Requirements
    • Feature/Component System Requirements
  • Set JAVA_HOME and PATH Variables
    • Windows
      • Set the JAVA_HOME Variable
      • Set the PATH Variable
    • Mac OS
    • Linux
      • Set the JAVA_HOME Variable
      • Set the PATH Variable
      • Verify the Changes
  • Manual Installation

Tutorial: Write Your First Daml App

  • Getting Started
    • Prerequisites
    • Run the App
  • App Architecture
    • The Daml Model
    • TypeScript Code Generation
    • The UI
  • Your First Feature
    • Daml Changes
    • Messaging UI
      • MessageList Component
      • MessageEdit Component
      • MainView Component
    • Run the Updated UI
    • Next Steps
  • Test Your App
    • Set Up the Tests
    • Example: Log In and Out
    • Accessing UI Elements
    • Writing CSS Selectors
    • The Full Test Suite

Create Daml Apps

  • Introduction
    • Overall Considerations
    • Developer Considerations
    • Operational Considerations
    • Next Steps
  • Write Smart Contracts With Daml
    • Introduction
    • Basic Contracts
      • Daml Ledger Basics
      • Daml Files and Modules
      • Templates
      • Signatories
      • Next Up
    • Test Templates With Daml Script
      • Script Basics
      • Run the Scripts
      • Test for Failure
      • Archive Contracts
      • Explore the Ledger
      • Exercises
      • Next Up
    • Data Types
      • Native Types
      • Assemble Types
        • Tuples
        • Lists
        • Records
        • Variants and Pattern Matching
      • Manipulate Data
      • Contract Keys
      • Next Up
    • Transform Data Using Choices
      • Choices as Methods
      • Choices as Delegation
      • Choices In the Ledger Model
        • The Archive Choice
      • A Simple Cash Model
      • Next Up
    • Add Constraints to a Contract
      • Template Preconditions
      • Assertions
      • Time on Daml Ledgers
        • Time in Test Scripts
        • Time on Ledgers
      • Actions and do Blocks
        • Pure Expressions Compared to Actions
        • Actions and Impurity
        • Chain Actions With do Blocks
        • Wrap Values in Actions
      • Failing Actions
      • A Sample Action
      • Errors
      • Next Up
    • Parties and Authority
      • Preventing IOU Revocation
      • Use Propose-Accept Workflows for One-Off Authorization
      • Use Role Contracts for Ongoing Authorization
      • Daml’s Authorization Model
        • An Authorization Example
      • Next Up
    • Composing Choices
      • Daml Projects
      • Project Structure
      • Project Overview
      • Composed Choices and Scripts
      • Daml’s Execution Model
      • Observers
      • Privacy
        • Divulgence
      • Next Up
    • Exception Handling
      • Next Up
    • Work With Dependencies
      • DAR, DALF, Daml-LF, and the Engine
      • Hashes and Identifiers
      • Dependencies and Data Dependencies
      • Structuring Projects
      • Next Up
    • Functional Programming 101
      • The Haskell Connection
      • Functions
        • Function Application
        • Infix Functions
        • Type Constraints
        • Pattern Matching in Arguments
        • Functions Everywhere
        • Lambdas
      • Control Flow
        • Branching
        • Looping
      • Next Up
    • The Daml Standard Library
      • The Prelude
      • Important Types From the Prelude
        • Lists
        • Tuples
        • Optional
        • Either
      • Typeclasses
      • Important Typeclasses From the Prelude
        • Eq
        • Ord
        • Show
        • Functor
        • Applicative Functor
        • Actions
        • Semigroups and Monoids
        • Additive and Multiplicative
      • Important Modules in the Standard Library
      • Search the Standard Library
        • Search for Functions by Name
        • Search for Functions by Signature
      • Next Up
    • Testing
      • Daml Test Tooling
      • Debug, Trace, and Stacktraces
      • Diagnose Contention Errors
        • Common Errors
        • Avoid Race Conditions and Stale References
        • Collisions Due to Ignorance
      • Next Up
    • Next Steps
    • Good Design Patterns
      • The Initiate and Accept Pattern
        • Motivation
        • Implementation
        • Trade-offs
      • The Multiple Party Agreement Pattern
        • Motivation
        • Implementation
      • The Delegation Pattern
        • Motivation
        • Implementation
      • The Authorization Pattern
        • Motivation
        • Authorization
      • The Locking Pattern
        • Motivation
        • Implementation
        • Lock by Archiving
        • Lock by State
        • Lock by Safekeeping
      • Diagram Legends
  • Integrate Daml with Off-Ledger Services
    • Introduction
    • Architectural Patterns
      • Backend
      • Frontend
      • Authorization
      • Developer Workflow
        • Command Deduplication
        • Deal With Failures
        • Deal With Time
    • Parties and Users On a Daml Ledger
      • Parties in SDK 2.0 and Subsequent
      • Party ID Hints and Display Names
      • Authorization and User Management
      • Working with Parties
        • Daml Script
        • Daml Triggers
        • Navigator
        • Java Bindings
        • Create-daml-app and UIs
    • Access Active Contracts with the HTTP JSON API Service
      • Overview
        • Run the JSON API
        • HTTP Status Codes
        • Create a New Contract
        • Create a Contract with a Command ID
        • Exercise by Contract ID
        • Exercise by Contract Key
        • Create and Exercise in the Same Transaction
        • Fetch Contract by Contract ID
        • Fetch Contract by Key
        • Get All Active Contracts
        • Get All Active Contracts Matching a Given Query
        • Fetch Parties by Identifiers
        • Fetch All Known Parties
        • Allocate a New Party
        • Create a New User
        • Get Authenticated User Information
        • Get Specific User Information
        • Delete Specific User
        • List Users
        • Grant User Rights
        • Revoke User Rights
        • List Authenticated User Rights
        • List Specific User Rights
        • List All DALF Packages
        • Download a DALF Package
        • Upload a DAR File
        • Metering Report
        • Streaming API
        • Healthcheck Endpoints
      • Daml-LF JSON Encoding
        • Codec Library
        • Type-directed Parsing
        • ContractId
        • Decimal
        • Int64
        • Timestamp
        • Party
        • Unit
        • Date
        • Text
        • Bool
        • Record
        • List
        • TextMap
        • GenMap
        • Optional
        • Variant
        • Enum
      • Query Language
        • Fallback Rule
        • Simple Equality
        • Comparison Query
        • Appendix: Type-aware Queries
        • Appendix: Known Issues
      • Javascript Client Libraries
        • Use the JavaScript Code Generator
        • @daml/react
        • @daml/ledger
        • @daml/types
      • Production Setup
        • Overview
        • Query Store
        • Security and Privacy
        • Architecture
        • Scaling and Redundancy
        • Logging
        • Metrics
    • Build Integration with the Ledger API
      • What’s in the Ledger API
      • How to Access the Ledger API
      • Daml-LF
        • When You Need to Know About Daml-LF
      • The Ledger API Services
        • Overview
        • Submit Commands to the Ledger
        • Read From the Ledger
        • Utility Services
        • Testing Services
      • Java Bindings
        • Overview
        • Reference Documentation
        • Get Started
        • Example Projects
        • Generate Java Code from Daml
        • Ping Pong Example
        • Iou Quickstart Tutorial
      • Python Bindings
      • Use the Ledger API With gRPC
        • Get Started
        • Protobuf Reference Documentation
        • Example Project
        • Daml Types and Protobuf
        • Error Handling
      • Ledger API Reference
        • com/daml/ledger/api/v1/active_contracts_service.proto
        • com/daml/ledger/api/v1/admin/config_management_service.proto
        • com/daml/ledger/api/v1/admin/metering_report_service.proto
        • com/daml/ledger/api/v1/admin/object_meta.proto
        • com/daml/ledger/api/v1/admin/package_management_service.proto
        • com/daml/ledger/api/v1/admin/participant_pruning_service.proto
        • com/daml/ledger/api/v1/admin/party_management_service.proto
        • com/daml/ledger/api/v1/admin/user_management_service.proto
        • com/daml/ledger/api/v1/command_completion_service.proto
        • com/daml/ledger/api/v1/command_service.proto
        • com/daml/ledger/api/v1/command_submission_service.proto
        • com/daml/ledger/api/v1/commands.proto
        • com/daml/ledger/api/v1/completion.proto
        • com/daml/ledger/api/v1/contract_metadata.proto
        • com/daml/ledger/api/v1/event.proto
        • com/daml/ledger/api/v1/experimental_features.proto
        • com/daml/ledger/api/v1/ledger_configuration_service.proto
        • com/daml/ledger/api/v1/ledger_identity_service.proto
        • com/daml/ledger/api/v1/ledger_offset.proto
        • com/daml/ledger/api/v1/package_service.proto
        • com/daml/ledger/api/v1/testing/time_service.proto
        • com/daml/ledger/api/v1/transaction.proto
        • com/daml/ledger/api/v1/transaction_filter.proto
        • com/daml/ledger/api/v1/transaction_service.proto
        • com/daml/ledger/api/v1/value.proto
        • com/daml/ledger/api/v1/version_service.proto
        • Scalar Value Types
      • How Daml Types are Translated to Protobuf
        • Notation
        • Records and Primitive Types
        • Variants
        • Contract Templates
      • How Daml Types are Translated to Daml-LF
        • Primitive Types
        • Tuple Types
        • Data Types
        • Type Synonyms
        • Template Types
        • Names with Special Characters
      • Create Your Own Bindings
        • Build Ledger Commands
        • Summary
        • Links
    • Write Off-Ledger Automation Using Daml
      • Overview
      • React to Off-Ledger Events: Daml Script
        • Usage
        • Use Daml Script for Ledger Initialization
        • Use Daml Script in Canton
        • Run Daml Script Against Ledgers with Authorization
        • Run Daml Script Against the HTTP JSON API
      • React to On-Ledger Events: Daml Triggers
        • How To Think About Triggers
        • Sample Trigger
        • Daml Trigger Basics
        • Run a No-Op Trigger
        • Diversion: Updating Message
        • AutoReply
        • Command Deduplication
        • Authorization
        • When Not to Use Daml Triggers
        • Trigger Service
        • Auth Middleware
    • Handle Errors
      • Error Codes
        • Overview
        • Glossary
        • Anatomy of an Error
        • Work With Error Codes
        • Error Categories Inventory
        • Error Codes Inventory
      • Command Deduplication
        • How Command Deduplication Works
        • How to Use Command Deduplication
    • Authorization
      • Introduction
      • Acquire and Use Access Tokens
      • Access Tokens and Rights
      • Access Token Formats
        • User Access Tokens
        • Custom Daml Claims Access Tokens
    • Upgrading and Extending Daml Applications
      • Extending Daml Applications
      • Upgrading Daml Applications
        • Daml Upgrade Overview
        • Structure Upgrade Contracts
        • Build and Deploy carbon-1.0.0
        • Create carbon-1.0.0 Certificates
        • Build and Deploy carbon-2.0.0
        • Build and Deploy carbon-upgrade
        • Upgrade Existing Certificates from carbon-1.0.0 to carbon-2.0.0
        • Further Steps
      • Automating the Upgrade Process
        • Structure the Upgrade
        • Implementation of the Daml Script
        • Implementation of the Daml Trigger
        • Deploy and Execute the Upgrade
  • Developer Tools
    • Daml Assistant
      • Full Help for Commands
      • Configuration Files
        • Global Config File (daml-config.yaml)
        • Project Config File (daml.yaml)
        • Recommended build-options
      • Build Daml Projects
      • Manage Releases
      • Terminal Command Completion
      • Run Commands Outside of the Project Directory
    • Canton Console
      • Introduction
      • Run the Canton Console Against the Sandbox
      • Built-in Documentation
      • Interact With the Sandbox
    • Deploy to Generic Daml Ledger
      • Connect via TLS
      • Configure Request Timeouts
    • Experiment: Daml REPL
      • Usage
      • What Is in Scope at the Prompt?
      • Using Daml REPL Without a Ledger
      • Connecting via TLS
      • Connection to a Ledger With Authorization
      • Using Daml REPL to Convert to JSON
    • Write: Daml Studio
      • Install
      • Create Your First Daml File
      • Supported Features
        • Symbols and Problem Reporting
        • Hover Tooltips
        • Daml Script Results
        • Daml Snippets
      • Common Script Errors
        • Abort, Assert, and Debug
        • Missing Authorization on Create
        • Missing Authorization on Exercise
        • Contract Not Visible
      • Work with Multiple Packages
    • Test: Daml Sandbox
      • Run With Authorization
        • Generate JSON Web Tokens (JWT)
        • Generate RSA keys
        • Generate EC keys
      • Run With TLS
      • Command-line Reference
      • Metrics
        • Enable and Configure Reporting
        • Types of Metrics
        • List of Metrics
    • Visualize: Daml Navigator
      • Navigator Functionality
      • Starting Navigator
      • Logging In
        • Logging in as a Party
      • Viewing Templates or Contracts
        • Listing templates
        • Listing contracts
        • Viewing contracts based on a template
        • Viewing template and contract details
      • Using Navigator
        • Creating contracts
        • Exercising choices
        • Advancing time
      • Authorizing Navigator
      • Advanced Usage
        • Customizable table views
        • Using Navigator with a Daml Ledger
    • Measure: Daml Profiler
      • Usage
      • Caveats
    • Daml Codegen
      • Introduction
      • Run the Daml Codegen
        • Command Line Configuration
        • Project File Configuration (Java)

Deploy Daml

  • Intro
    • Introducing Canton
    • Canton Overview
      • Canton 101
        • A Basic Example
        • Transaction Processing in Canton
        • Conflict Detection
        • Time in Canton
        • Subtransaction privacy
      • Domain Entities
        • Sequencer
        • Mediator
        • Topology Manager
      • Participant-internal Canton Components
        • Transactions
        • Sequencer Client
        • Identity Client
      • System Model And Trust Assumptions
        • System Model
        • General Trust Assumptions
        • Assumptions Relevant for Privacy
        • Assumptions Relevant for Liveness
    • Canton Demo
    • Getting Started
      • Installation
      • Starting Canton
      • The Example Topology
      • Connecting The Nodes
      • Canton Identities and Provisioning Parties
      • Creating Parties
      • Extracting Identifiers
      • Provisioning Smart Contract Code
      • Executing Smart Contracts
      • Privacy
      • Your Development Choices
      • Automation using bootstrap scripts
      • What Next?
    • Daml SDK and Canton
      • Starting Canton
      • Running the Create Daml App Example
        • Connecting to participant2
      • What Next?
    • Composability
      • Part 1: A multi-domain workflow
        • Setting up the topology
        • Creating the IOU and the paint offer
        • Contracts and Their Domains
        • Transferring a contract
        • Atomic acceptance
        • Completing the workflow
        • Performing transfers automatically
        • Take aways
      • Part 2: Composing existing workflows
        • Existing workflows
        • Required changes
        • Preparation using the existing workflows
        • The paint offer-accept workflow
        • Continuing the existing workflows
        • Take aways
    • Compatibility Matrix and Supported Dependencies
      • Canton release version
      • For application developers and operators
      • For Canton participant and domain operators
        • Canton protocol version
        • Features and protocol versions
        • Configuring the protocol version
        • Minimum protocol version
        • Ethereum contract version
        • Support and bug fixes
  • Download the Components
    • Choosing Open-Source or Enterprise Edition
    • Downloading the Open Source Edition
    • Downloading the Enterprise Edition
  • Install a Daml Ledger
    • Installation
      • Downloading Canton
      • Your Topology
      • Environment Variables
      • Selecting your Storage Layer
        • Persistence using Postgres
      • Setting up a Participant
        • Secure the APIs
        • Configure Applications, Users and Connection
      • Setting up a Domain
        • Secure the APIs
        • Next Steps
      • Multi-Node Setup
    • Work With the Docker Containers
      • Obtaining the Docker Images
      • Starting Canton
      • Configuring Logging
      • Supplying custom configuration and DARs
      • Exposing the ledger-api to the host machine
      • Running Postgres in Docker
    • Set Configuration Options
      • Configuration reference
      • Configuration Compatibility
      • Advanced Configurations
      • Configuration Mixin
      • Multiple Domains
      • Fail Fast Mode
      • Init Configuration
    • Set Up A Daml Domain With Enterprise Drivers
      • Oracle Domain
      • Fabric Domain
        • Tutorial
        • User Manual
        • Fabric Setup
      • Ethereum Domain
        • Introduction
        • The Ethereum Demo
        • Error codes
        • TLS configuration
        • Ethereum accounts and wallets
        • Deployment of the sequencer contract
        • Authorization
        • Requirements for the Ethereum Network
        • Trust Properties of the Ethereum Sequencer Integration
        • High Availability
  • High Availability
    • Overview
    • Domain Manager
    • HA Setup on Oracle
    • Mediator
      • Running a Stand-Alone Mediator Node
      • HA Configuration
    • Sequencer
      • Total Node Count
      • External load balancer
      • Client-side load balancing
    • Participant
      • Domain Connectivity during Fail-over
      • Manual Trigger of a Fail-over
      • Load Balancer Configuration
  • Persistence
    • Postgres
      • SSL
    • Oracle
      • Installation and Setup of Oracle
        • Default Character Set and Collations
        • Database Replication
        • Setup Oracle Schemas
      • Configuring Canton Nodes for Oracle
      • Performance Tuning
        • Operating System Modifications
        • System Container Configuration (CDB)
    • General Settings
      • Max Connection Settings
      • Queue Size
    • Backup and Restore
      • Order of Backups
      • Restore Caveats
        • Incomplete Command Deduplication State
        • Application State Reset
        • Private Keys
      • Postgres Example
    • Database Replication for Disaster Recovery
      • Synchronous Replication

Operate a Daml Ledger

  • Canton Administration Quick Start
    • Use the Canton Command Line
      • Selecting a Configuration
      • Run Modes
        • Interactive Console
        • Remote Console Mode
        • Headless Script Mode
        • Daemon
      • Flush Log Files Immediately
      • Java Virtual Machine Arguments
    • Console Quickstart
      • Remote Administration
      • Node References
      • Help
      • Lifecycle Operations
      • Timeouts
      • Code-Generation in Console
    • Console Commands
      • Top-level Commands
      • Participant Commands
        • Database
        • Health
        • Domain Connectivity
        • Packages
        • DAR Management
        • DAR Sharing
        • Party Management
        • Key Administration
        • Topology Administration
        • Ledger API Access
        • Composability
        • Ledger Pruning
        • Bilateral Commitments
        • Participant Repair
        • Resource Management
        • Replication
      • Multiple Participants
      • Domain Administration Commands
        • Health
        • Database
        • Participants
        • Sequencer
        • Mediator
        • Key Administration
        • Parties
        • Service
        • Topology Administration
      • Domain Manager Administration Commands
        • Setup
        • Health
        • Database
        • Sequencer Connection
        • Key Administration
        • Parties
        • Service
        • Topology Administration
      • Sequencer Administration Commands
        • Sequencer
        • Health
        • Database
      • Mediator Administration Commands
        • Mediator
        • Health
        • Database
        • Sequencer Connection
  • Monitoring Best Practices
    • Logging
      • Viewing Logs
      • Detailed Logging
    • Tracing
      • Sampling
      • Known Limitations
      • Traces
    • Status
    • Health Dumps
      • Remote Health Dumps
    • Health Check
    • Metrics
      • Common gRPC Metrics
      • Participant Metrics
        • canton.<domain>.conflict-detection.sequencer-counter-queue
        • canton.<domain>.conflict-detection.task-queue
        • canton.<domain>.dirty-requests
        • canton.<domain>.protocol-messages.confirmation-request-creation
        • canton.<domain>.protocol-messages.confirmation-request-size
        • canton.<domain>.protocol-messages.transaction-message-receipt
        • canton.<domain>.request-tracker.sequencer-counter-queue
        • canton.<domain>.request-tracker.task-queue
        • canton.<domain>.sequencer-client.application-handle
        • canton.<domain>.sequencer-client.delay
        • canton.<domain>.sequencer-client.event-handle
        • canton.<domain>.sequencer-client.load
        • canton.<domain>.sequencer-client.submissions.dropped
        • canton.<domain>.sequencer-client.submissions.in-flight
        • canton.<domain>.sequencer-client.submissions.overloaded
        • canton.<domain>.sequencer-client.submissions.sends
        • canton.<domain>.sequencer-client.submissions.sequencing
        • canton.commitments.compute
        • canton.db-storage.<service>.executor.queued
        • canton.db-storage.<service>.executor.running
        • canton.db-storage.<service>.executor.waittime
        • canton.db-storage.<storage>
        • canton.db-storage.<storage>.load
        • canton.db-storage.alerts.multi-domain-event-log
        • canton.db-storage.alerts.single-dimension-event-log
        • canton.prune
        • canton.updates-published
        • daml.commands.delayed_submissions
        • daml.commands.failed_command_interpretations
        • daml.commands.input_buffer_capacity
        • daml.commands.input_buffer_delay
        • daml.commands.input_buffer_length
        • daml.commands.max_in_flight_capacity
        • daml.commands.max_in_flight_length
        • daml.commands.submissions
        • daml.commands.submissions_running
        • daml.commands.valid_submissions
        • daml.commands.validation
        • daml.execution.cache.<state_cache>.evicted_weight
        • daml.execution.cache.<state_cache>.evictions
        • daml.execution.cache.<state_cache>.hits
        • daml.execution.cache.<state_cache>.misses
        • daml.execution.cache.contract_state.register_update
        • daml.execution.cache.key_state.register_update
        • daml.execution.cache.read_through_not_found
        • daml.execution.cache.resolve_divulgence_lookup
        • daml.execution.cache.resolve_full_lookup
        • daml.execution.engine
        • daml.execution.engine_running
        • daml.execution.get_lf_package
        • daml.execution.lookup_active_contract
        • daml.execution.lookup_active_contract_count_per_execution
        • daml.execution.lookup_active_contract_per_execution
        • daml.execution.lookup_contract_key
        • daml.execution.lookup_contract_key_count_per_execution
        • daml.execution.lookup_contract_key_per_execution
        • daml.execution.retry
        • daml.execution.total
        • daml.execution.total_running
        • daml.identity_provider_config_store.<operation>.commit
        • daml.identity_provider_config_store.<operation>.compression
        • daml.identity_provider_config_store.<operation>.exec
        • daml.identity_provider_config_store.<operation>.query
        • daml.identity_provider_config_store.<operation>.translation
        • daml.identity_provider_config_store.<operation>.wait
        • daml.identity_provider_config_store.cache.evicted_weight
        • daml.identity_provider_config_store.cache.evictions
        • daml.identity_provider_config_store.cache.hits
        • daml.identity_provider_config_store.cache.misses
        • daml.index.active_contracts_buffer_size
        • daml.index.completions_buffer_size
        • daml.index.db.<operation>.commit
        • daml.index.db.<operation>.compression
        • daml.index.db.<operation>.exec
        • daml.index.db.<operation>.query
        • daml.index.db.<operation>.translation
        • daml.index.db.<operation>.wait
        • daml.index.db.compression.create_argument_compressed
        • daml.index.db.compression.create_argument_uncompressed
        • daml.index.db.compression.create_key_value_compressed
        • daml.index.db.compression.create_key_value_uncompressed
        • daml.index.db.compression.exercise_argument_compressed
        • daml.index.db.compression.exercise_argument_uncompressed
        • daml.index.db.compression.exercise_result_compressed
        • daml.index.db.compression.exercise_result_uncompressed
        • daml.index.db.lookup_active_contract
        • daml.index.db.lookup_key
        • daml.index.db.threadpool.connection.<server_role>.completed
        • daml.index.db.threadpool.connection.<server_role>.duration
        • daml.index.db.threadpool.connection.<server_role>.idle
        • daml.index.db.threadpool.connection.<server_role>.running
        • daml.index.db.threadpool.connection.<server_role>.submitted
        • daml.index.db.translation.get_lf_package
        • daml.index.flat_transactions_buffer_size
        • daml.index.ledger_end_sequential_id
        • daml.index.lf_value.compute_interface_view
        • daml.index.package_metadata.decode_archive
        • daml.index.package_metadata.view_init
        • daml.index.transaction_trees_buffer_size
        • daml.indexer.current_record_time_lag
        • daml.indexer.last_received_offset
        • daml.indexer.last_received_record_time
        • daml.indexer.ledger_end_sequential_id
        • daml.lapi.<service_method>
        • daml.lapi.return_status.<gRPC_status_code>
        • daml.lapi.streams.acs_sent
        • daml.lapi.streams.active
        • daml.lapi.streams.completions_sent
        • daml.lapi.streams.transaction_trees_sent
        • daml.lapi.streams.transactions_sent
        • daml.lapi.threadpool.<threadpool>.completed
        • daml.lapi.threadpool.<threadpool>.duration
        • daml.lapi.threadpool.<threadpool>.idle
        • daml.lapi.threadpool.<threadpool>.running
        • daml.lapi.threadpool.<threadpool>.submitted
        • daml.parallel_indexer.<stage>.commit
        • daml.parallel_indexer.<stage>.compression
        • daml.parallel_indexer.<stage>.exec
        • daml.parallel_indexer.<stage>.executor.completed
        • daml.parallel_indexer.<stage>.executor.duration
        • daml.parallel_indexer.<stage>.executor.idle
        • daml.parallel_indexer.<stage>.executor.running
        • daml.parallel_indexer.<stage>.executor.submitted
        • daml.parallel_indexer.<stage>.query
        • daml.parallel_indexer.<stage>.translation
        • daml.parallel_indexer.<stage>.wait
        • daml.parallel_indexer.input_buffer_length
        • daml.parallel_indexer.inputmapping.batch_size
        • daml.parallel_indexer.output_batched_buffer_length
        • daml.parallel_indexer.seqmapping.duration
        • daml.parallel_indexer.updates
        • daml.party_record_store.<operation>.commit
        • daml.party_record_store.<operation>.compression
        • daml.party_record_store.<operation>.exec
        • daml.party_record_store.<operation>.query
        • daml.party_record_store.<operation>.translation
        • daml.party_record_store.<operation>.wait
        • daml.services.index.<operation>
        • daml.services.index.in_memory_fan_out_buffer.prune
        • daml.services.index.in_memory_fan_out_buffer.push
        • daml.services.index.in_memory_fan_out_buffer.size
        • daml.services.read.<operation>
        • daml.services.write.<operation>
        • daml.services.write.submit_transaction.count
        • daml.user_management.<operation>.commit
        • daml.user_management.<operation>.compression
        • daml.user_management.<operation>.exec
        • daml.user_management.<operation>.query
        • daml.user_management.<operation>.translation
        • daml.user_management.<operation>.wait
        • daml.user_management.cache.evicted_weight
        • daml.user_management.cache.evictions
        • daml.user_management.cache.hits
        • daml.user_management.cache.misses
        • test.db.commit
        • test.db.compression
        • test.db.exec
        • test.db.query
        • test.db.translation
        • test.db.wait
      • Domain Metrics
        • canton.<component>.sequencer-client.application-handle
        • canton.<component>.sequencer-client.delay
        • canton.<component>.sequencer-client.event-handle
        • canton.<component>.sequencer-client.load
        • canton.db-storage.<service>.executor.queued
        • canton.db-storage.<service>.executor.running
        • canton.db-storage.<service>.executor.waittime
        • canton.db-storage.<storage>
        • canton.db-storage.<storage>.load
        • canton.db-storage.alerts.multi-domain-event-log
        • canton.db-storage.alerts.single-dimension-event-log
        • canton.mediator.outstanding-requests
        • canton.mediator.requests
        • canton.mediator.sequencer-client.submissions.dropped
        • canton.mediator.sequencer-client.submissions.in-flight
        • canton.mediator.sequencer-client.submissions.overloaded
        • canton.mediator.sequencer-client.submissions.sends
        • canton.mediator.sequencer-client.submissions.sequencing
        • canton.sequencer.db-storage.<storage>
        • canton.sequencer.db-storage.<storage>.load
        • canton.sequencer.db-storage.alerts.multi-domain-event-log
        • canton.sequencer.db-storage.alerts.single-dimension-event-log
        • canton.sequencer.db-storage.general.executor.queued
        • canton.sequencer.db-storage.general.executor.running
        • canton.sequencer.db-storage.general.executor.waittime
        • canton.sequencer.db-storage.locks.executor.queued
        • canton.sequencer.db-storage.locks.executor.running
        • canton.sequencer.db-storage.locks.executor.waittime
        • canton.sequencer.db-storage.write.executor.queued
        • canton.sequencer.db-storage.write.executor.running
        • canton.sequencer.db-storage.write.executor.waittime
        • canton.sequencer.processed
        • canton.sequencer.processed-bytes
        • canton.sequencer.sequencer-client.submissions.dropped
        • canton.sequencer.sequencer-client.submissions.in-flight
        • canton.sequencer.sequencer-client.submissions.overloaded
        • canton.sequencer.sequencer-client.submissions.sends
        • canton.sequencer.sequencer-client.submissions.sequencing
        • canton.sequencer.subscriptions
        • canton.sequencer.time-requests
        • canton.topology-manager.sequencer-client.submissions.dropped
        • canton.topology-manager.sequencer-client.submissions.in-flight
        • canton.topology-manager.sequencer-client.submissions.overloaded
        • canton.topology-manager.sequencer-client.submissions.sends
        • canton.topology-manager.sequencer-client.submissions.sequencing
    • Common Metrics
      • gRPC Metrics
        • daml_grpc_server_duration_seconds
        • daml_grpc_server_messages_sent_total
        • daml_grpc_server_messages_received_total
        • daml_grpc_server_started_total
        • daml_grpc_server_handled_total
        • daml_grpc_server_messages_sent_bytes
        • daml_grpc_server_messages_received_bytes
      • HTTP Metrics
        • daml_http_requests_duration_seconds
        • daml_http_requests_total
        • daml_http_websocket_messages_received_total
        • daml_http_websocket_messages_sent_total
        • daml_http_requests_payload_bytes
        • daml_http_responses_payload_bytes
        • daml_http_websocket_messages_received_bytes
        • daml_http_websocket_messages_sent_bytes
    • Example Monitoring Setup
      • Canton Setup
        • Network Configuration
        • Postgres Setup
        • Domain Setup
        • Participant Setup
        • Dependencies
        • Docker Images
        • Running Docker Compose
      • Connecting to Nodes
        • Remote configurations
        • Getting Started
      • Monitoring
  • Identity Management
    • Introduction
      • What is a Canton Identity?
      • Unique Identifier
      • Topology Transactions
      • Legal Identities
      • Life of a Party
      • Participant Onboarding
      • Default Initialization
      • Identity Setup Guide
    • User Identity Management
    • Cookbook
      • Manage Users
        • Create
        • Update
        • Inspect
        • Decommission
      • Adding a new Party to a Participant
      • Migrate Party to Another Participant Node
      • Party on Two Nodes
      • Manually Initializing a Node
        • Domain Initialization
        • Participant Initialization
  • Common Tasks
    • Manage DARs and Packages
      • Uploading DARs
      • Inspecting DARs and Packages
      • Understanding Package Vetting
      • Removing Packages and DARs
        • Removing DARs
        • Removing Packages
    • Upgrade To a New Release
      • Upgrade Canton Binary
        • Preparation
        • Back Up Your Database
        • Test your Configuration
        • Migrating the Database
        • Test Your Upgrade
        • Version Specific Notes
      • Change the Canton Protocol Version
        • Upgrade the Domain to a new Protocol Version
        • Hard Domain Connection Upgrade
        • Soft Domain Connection Upgrade
    • Configure Auth0 Middleware (With Example Configuration)
      • Configure Auth0
        • Create an API
        • Create an Application
        • Create a Rule
        • Create a User
      • Start Daml
        • Sandbox
        • OAuth 2.0 Middleware
        • Trigger Service
      • Configure Web Server
      • Test the Setup
    • Security & Key Management
      • Cryptographic Key Usage
        • Supported Cryptographic Schemes in Canton
        • Key Generation and storage
        • Public Key Distribution using Topology Management
        • Common Node Keys
        • Participant Node Keys
        • Domain Topology Manager Keys
        • Sequencer Node Keys
        • Mediator Node Keys
        • Domain Node Keys
        • Canton Console Keys
      • Cryptographic Key Management
        • Rotating Canton Node Keys
        • Namespace Intermediate Key Management
        • Moving the Namespace Secret Key to Offline Storage
        • Identifier Delegation Key Management
        • Key Management Service Setup
      • Ledger-API Authorization
  • Infrastructure Automation (Node and Domain)
    • Administration APIs
      • Participant Admin APIs
        • Package Service
        • Participant Status Service
        • Ping Pong Service
        • Domain Connectivity Service
        • Party Name Management Service
        • Inspection Service
        • Transfer Service
        • Pruning Service
      • Domain Admin APIs
        • Domain Status Service
      • Identity Admin APIs
        • Vault Management Service
        • Initialization Service
        • Topology Aggregation Service
        • Topology Manager Read Service
        • Topology Manager Write Service
      • Mediator Admin APIs
        • Mediator Initialization Service
        • Enterprise Mediator Administration Service
      • Sequencer Admin APIs
        • Sequencer Administration Service
        • Enterprise Sequencer Administration Service
  • Scaling and Performance
    • Network Scaling
    • Node Scaling
    • Performance and Sizing
    • Batching
    • Storage Estimation
    • How to Setup Canton to Get Best Performance?
      • System Design / Architecture
      • Hardware and Database
      • Configuration
  • Advanced Operations
    • Manage Domains
      • Permissioned Domains
      • Domain Rules
      • Dynamic domain parameters
      • Recover From a Small Max Request Size
    • Manage Domain Entities
      • Setting up a Distributed Domain With a Single Console
      • Setting up a Distributed Domain With Separate Consoles
      • Adding new sequencers to distributed domain
    • Ledger Pruning
      • Pruning Ledgers in Test Environments
      • Common Notes
    • Participant Pruning
      • Impacts on Daml Applications
      • How the Daml Ledger API is Affected
      • Other Limitations
      • How Pruning Affects Index DB Administration
      • Determine a Suitable Pruning Offset
    • Participant Metering
      • Generate a Metering Report
      • Example
      • Output
    • Api Configuration
      • Default Ports
      • Administration API
      • TLS Configuration
      • Keep Alive
      • Max Inbound Message Size
      • Participant Configuration
        • Ledger Api
      • Domain Configurations
        • Public Api
      • Limiting concurrent GRPC requests (preview feature)
    • Sequencer Connections
      • Participant Connections
        • Connect Using Macros
        • Inspect Connections
        • Modify Connections
        • Enable and Disable Connections
      • Mediator and Domain Manager
    • Repair the Topology Information
      • Preparation
      • Importing an actual Ledger
        • Repairing Participants
      • Recovering from a Lost Domain
      • Repairing an actual Topology
        • Repair Macros
      • Clone Identity
      • Importing existing Contracts

Daml Finance

  • Introduction
  • Overview
    • Introduction
    • Architecture
    • Building Applications
    • Extending Daml Finance
  • Concepts
    • Asset Model
    • Settlement
    • Lifecycling
    • Contingent Claims
  • Packages
    • Interface Packages
      • Daml.Finance.Interface.Holding
      • Daml.Finance.Interface.Account
      • Daml.Finance.Interface.Settlement
      • Daml.Finance.Interface.Lifecycle
      • Daml.Finance.Interface.Instrument.Base
      • Daml.Finance.Interface.Claims
      • Daml.Finance.Interface.Data
      • Daml.Finance.Interface.Types.Common
      • Daml.Finance.Interface.Types.Date
      • Daml.Finance.Interface.Util
      • ContingentClaims.Core
      • Daml.Finance.Interface.Instrument.Bond
      • Daml.Finance.Interface.Instrument.Equity
      • Daml.Finance.Interface.Instrument.Generic
      • Daml.Finance.Interface.Instrument.Swap
      • Daml.Finance.Interface.Instrument.Token
    • Implementation Packages
      • Daml.Finance.Holding
      • Daml.Finance.Account
      • Daml.Finance.Settlement
      • Daml.Finance.Lifecycle
      • Daml.Finance.Data
      • Daml.Finance.Claims
      • Daml.Finance.Util
      • ContingentClaims.Lifecycle
      • ContingentClaims.Valuation
      • Daml.Finance.Instrument.Bond
      • Daml.Finance.Instrument.Equity
      • Daml.Finance.Instrument.Generic
      • Daml.Finance.Instrument.Swap
      • Daml.Finance.Instrument.Token
  • Tutorials
    • Getting Started
      • Transfer
      • Settlement
      • Lifecycling
    • Instrument Modeling
      • How to Use the Bond Extension Package
      • How To Use the Swap Extension Package
      • How To Model and Lifecycle Equity Instruments
      • How To Model and Lifecycle Generic Instruments
      • Intermediated Lifecycling of a Generic Instrument
      • How to Implement a Contingent Claims-Based Instrument
      • Contingent Claims Tree on Ledger vs On-the-Fly Creation
  • Reference
    • Glossary
    • Daml Finance
      • ContingentClaims.Core.Builders
      • ContingentClaims.Core.Claim
      • ContingentClaims.Core.Internal.Claim
      • ContingentClaims.Core.Observation
      • ContingentClaims.Core.Util.Recursion
      • ContingentClaims.Lifecycle.Lifecycle
      • ContingentClaims.Lifecycle.Util
      • ContingentClaims.Valuation.MathML
      • ContingentClaims.Valuation.Stochastic
      • Daml.Finance.Account.Account
      • Daml.Finance.Claims.Lifecycle.Rule
      • Daml.Finance.Claims.Util
      • Daml.Finance.Claims.Util.Builders
      • Daml.Finance.Claims.Util.Lifecycle
      • Daml.Finance.Data.Numeric.Observation
      • Daml.Finance.Data.Reference.HolidayCalendar
      • Daml.Finance.Data.Time.DateClock
      • Daml.Finance.Data.Time.DateClock.Types
      • Daml.Finance.Data.Time.DateClockUpdate
      • Daml.Finance.Data.Time.LedgerTime
      • Daml.Finance.Holding.Fungible
      • Daml.Finance.Holding.NonFungible
      • Daml.Finance.Holding.NonTransferable
      • Daml.Finance.Holding.Util
      • Daml.Finance.Instrument.Bond.FixedRate.Factory
      • Daml.Finance.Instrument.Bond.FixedRate.Instrument
      • Daml.Finance.Instrument.Bond.FloatingRate.Factory
      • Daml.Finance.Instrument.Bond.FloatingRate.Instrument
      • Daml.Finance.Instrument.Bond.InflationLinked.Factory
      • Daml.Finance.Instrument.Bond.InflationLinked.Instrument
      • Daml.Finance.Instrument.Bond.Util
      • Daml.Finance.Instrument.Bond.ZeroCoupon.Factory
      • Daml.Finance.Instrument.Bond.ZeroCoupon.Instrument
      • Daml.Finance.Instrument.Equity.Factory
      • Daml.Finance.Instrument.Equity.Instrument
      • Daml.Finance.Instrument.Generic.Election
      • Daml.Finance.Instrument.Generic.Factory
      • Daml.Finance.Instrument.Generic.Instrument
      • Daml.Finance.Instrument.Generic.Lifecycle.Rule
      • Daml.Finance.Instrument.Swap.Asset.Factory
      • Daml.Finance.Instrument.Swap.Asset.Instrument
      • Daml.Finance.Instrument.Swap.CreditDefault.Factory
      • Daml.Finance.Instrument.Swap.CreditDefault.Instrument
      • Daml.Finance.Instrument.Swap.Currency.Factory
      • Daml.Finance.Instrument.Swap.Currency.Instrument
      • Daml.Finance.Instrument.Swap.ForeignExchange.Factory
      • Daml.Finance.Instrument.Swap.ForeignExchange.Instrument
      • Daml.Finance.Instrument.Swap.Fpml.Factory
      • Daml.Finance.Instrument.Swap.Fpml.Instrument
      • Daml.Finance.Instrument.Swap.Fpml.Util
      • Daml.Finance.Instrument.Swap.InterestRate.Factory
      • Daml.Finance.Instrument.Swap.InterestRate.Instrument
      • Daml.Finance.Instrument.Swap.Util
      • Daml.Finance.Instrument.Token.Factory
      • Daml.Finance.Instrument.Token.Instrument
      • Daml.Finance.Interface.Account.Account
      • Daml.Finance.Interface.Account.Factory
      • Daml.Finance.Interface.Account.Util
      • Daml.Finance.Interface.Claims.Claim
      • Daml.Finance.Interface.Claims.Dynamic.Instrument
      • Daml.Finance.Interface.Claims.Types
      • Daml.Finance.Interface.Data.Numeric.Observation
      • Daml.Finance.Interface.Data.Numeric.Observation.Factory
      • Daml.Finance.Interface.Data.Reference.HolidayCalendar
      • Daml.Finance.Interface.Data.Reference.HolidayCalendar.Factory
      • Daml.Finance.Interface.Data.Reference.Time
      • Daml.Finance.Interface.Holding.Base
      • Daml.Finance.Interface.Holding.Factory
      • Daml.Finance.Interface.Holding.Fungible
      • Daml.Finance.Interface.Holding.Transferable
      • Daml.Finance.Interface.Holding.Util
      • Daml.Finance.Interface.Instrument.Base.Instrument
      • Daml.Finance.Interface.Instrument.Bond.FixedRate.Factory
      • Daml.Finance.Interface.Instrument.Bond.FixedRate.Instrument
      • Daml.Finance.Interface.Instrument.Bond.FixedRate.Types
      • Daml.Finance.Interface.Instrument.Bond.FloatingRate.Factory
      • Daml.Finance.Interface.Instrument.Bond.FloatingRate.Instrument
      • Daml.Finance.Interface.Instrument.Bond.FloatingRate.Types
      • Daml.Finance.Interface.Instrument.Bond.InflationLinked.Factory
      • Daml.Finance.Interface.Instrument.Bond.InflationLinked.Instrument
      • Daml.Finance.Interface.Instrument.Bond.InflationLinked.Types
      • Daml.Finance.Interface.Instrument.Bond.ZeroCoupon.Factory
      • Daml.Finance.Interface.Instrument.Bond.ZeroCoupon.Instrument
      • Daml.Finance.Interface.Instrument.Bond.ZeroCoupon.Types
      • Daml.Finance.Interface.Instrument.Equity.Factory
      • Daml.Finance.Interface.Instrument.Equity.Instrument
      • Daml.Finance.Interface.Instrument.Generic.Election
      • Daml.Finance.Interface.Instrument.Generic.Election.Factory
      • Daml.Finance.Interface.Instrument.Generic.Factory
      • Daml.Finance.Interface.Instrument.Generic.Instrument
      • Daml.Finance.Interface.Instrument.Swap.Asset.Factory
      • Daml.Finance.Interface.Instrument.Swap.Asset.Instrument
      • Daml.Finance.Interface.Instrument.Swap.Asset.Types
      • Daml.Finance.Interface.Instrument.Swap.CreditDefault.Factory
      • Daml.Finance.Interface.Instrument.Swap.CreditDefault.Instrument
      • Daml.Finance.Interface.Instrument.Swap.CreditDefault.Types
      • Daml.Finance.Interface.Instrument.Swap.Currency.Factory
      • Daml.Finance.Interface.Instrument.Swap.Currency.Instrument
      • Daml.Finance.Interface.Instrument.Swap.Currency.Types
      • Daml.Finance.Interface.Instrument.Swap.ForeignExchange.Factory
      • Daml.Finance.Interface.Instrument.Swap.ForeignExchange.Instrument
      • Daml.Finance.Interface.Instrument.Swap.ForeignExchange.Types
      • Daml.Finance.Interface.Instrument.Swap.Fpml.Factory
      • Daml.Finance.Interface.Instrument.Swap.Fpml.FpmlTypes
      • Daml.Finance.Interface.Instrument.Swap.Fpml.Instrument
      • Daml.Finance.Interface.Instrument.Swap.Fpml.Types
      • Daml.Finance.Interface.Instrument.Swap.InterestRate.Factory
      • Daml.Finance.Interface.Instrument.Swap.InterestRate.Instrument
      • Daml.Finance.Interface.Instrument.Swap.InterestRate.Types
      • Daml.Finance.Interface.Instrument.Token.Factory
      • Daml.Finance.Interface.Instrument.Token.Instrument
      • Daml.Finance.Interface.Instrument.Token.Types
      • Daml.Finance.Interface.Lifecycle.Effect
      • Daml.Finance.Interface.Lifecycle.Event
      • Daml.Finance.Interface.Lifecycle.Event.Distribution
      • Daml.Finance.Interface.Lifecycle.Event.Replacement
      • Daml.Finance.Interface.Lifecycle.Event.Time
      • Daml.Finance.Interface.Lifecycle.Observable.NumericObservable
      • Daml.Finance.Interface.Lifecycle.Observable.TimeObservable
      • Daml.Finance.Interface.Lifecycle.Rule.Claim
      • Daml.Finance.Interface.Lifecycle.Rule.Lifecycle
      • Daml.Finance.Interface.Settlement.Batch
      • Daml.Finance.Interface.Settlement.Factory
      • Daml.Finance.Interface.Settlement.Instruction
      • Daml.Finance.Interface.Settlement.RouteProvider
      • Daml.Finance.Interface.Settlement.Types
      • Daml.Finance.Interface.Types.Common.Types
      • Daml.Finance.Interface.Types.Date.Calendar
      • Daml.Finance.Interface.Types.Date.Classes
      • Daml.Finance.Interface.Types.Date.DayCount
      • Daml.Finance.Interface.Types.Date.RollConvention
      • Daml.Finance.Interface.Types.Date.Schedule
      • Daml.Finance.Interface.Util.Common
      • Daml.Finance.Interface.Util.Disclosure
      • Daml.Finance.Lifecycle.Effect
      • Daml.Finance.Lifecycle.ElectionEffect
      • Daml.Finance.Lifecycle.Event.Distribution
      • Daml.Finance.Lifecycle.Event.Replacement
      • Daml.Finance.Lifecycle.Rule.Claim
      • Daml.Finance.Lifecycle.Rule.Distribution
      • Daml.Finance.Lifecycle.Rule.Replacement
      • Daml.Finance.Lifecycle.Rule.Util
      • Daml.Finance.Settlement.Batch
      • Daml.Finance.Settlement.Factory
      • Daml.Finance.Settlement.Hierarchy
      • Daml.Finance.Settlement.Instruction
      • Daml.Finance.Settlement.RouteProvider.IntermediatedStatic
      • Daml.Finance.Settlement.RouteProvider.SingleCustodian
      • Daml.Finance.Util.Common
      • Daml.Finance.Util.Date.Calendar
      • Daml.Finance.Util.Date.DayCount
      • Daml.Finance.Util.Date.RollConvention
      • Daml.Finance.Util.Date.Schedule
      • Daml.Finance.Util.Disclosure

Help

  • Troubleshooting
    • Error: “<X> is not authorized to commit an update”
    • Error: “Argument is not of serializable type”
    • Modeling Questions
      • How To Model an Agreement With Another Party
      • How To Model Rights
      • How To Void a Contract
      • How To Represent Off-ledger Parties
      • How To Limit a Choice by Time
      • How To Model a Mandatory Action
      • When to Use Optional
    • Testing Questions
      • How To Test That a Contract Is Visible to a Party
      • How To Test That an Update Action Cannot Be Committed
  • Getting Help
    • Support Expectations
  • Portability, Compatibility, and Support Durations
    • Ledger API Compatibility: Application Portability
      • List of Ledger API Versions Supported by Daml
      • Summary of Ledger API Changes
    • Driver and Participant Compatibility: Network Upgradeability
      • Participant database migration
    • SDK, Runtime Component, and Library Compatibility: Daml Upgradeability
    • Ledger API Support Duration
  • Daml Ecosystem Overview
    • Architecture
    • Daml Networks
      • Daml drivers
    • Participant Nodes
    • Ledger API
    • Daml Components
      • Runtime Components
      • Libraries
      • Generated Code
      • Developer Tools / SDK
    • Status Definitions
      • Early Access Features
      • Deprecation
      • Comparison of Statuses
    • Feature and Component Statuses
      • Ledger API
      • Runtime Components
      • Libraries
      • Developer Tools
  • Releases and Versioning
    • Versioning
    • Cadence
    • Support Duration
    • Release Notes
    • Roadmap
    • Process

Reference

  • Cheat Sheet
  • Glossary of concepts
    • Key Concepts
      • Daml
      • Daml Language
      • Daml Ledger
        • Canton Ledger
      • Canton Protocol
      • Synchronization Technology
      • Daml Drivers
    • Daml Language Concepts
      • Contract
        • Active Contract, Archived Contract
      • Template
      • Choice
        • Consuming Choice
        • Nonconsuming Choice
        • Disjunction Choice, Flexible Controllers
      • Party
        • Signatory
        • Observer
        • Controller
        • Choice Observer
        • Stakeholder
        • Maintainer
      • Authorization, Signing
      • Standard Library
      • Agreement
      • Create
      • Exercise
      • Daml Script
      • Contract Key
      • DAR File, DALF File
    • Developer Tools
      • Assistant
      • Studio
      • Sandbox
      • Navigator
        • Navigator GUI
    • Building Applications
      • Application, Ledger Client, Integration
      • Ledger API
        • Command Submission Service
        • Command Completion Service
        • Command Service
        • Transaction Service
        • Active Contract Service
        • Package Service
        • Ledger Identity Service
        • Ledger Configuration Service
      • Ledger API Libraries
        • Java Bindings
        • Python Bindings
      • Reading From the Ledger
      • Submitting Commands, Writing To the Ledger
        • Commands
      • Participant Node
      • Sub-transaction Privacy
      • Daml-LF
      • Composability
      • Trust Domain
    • Canton Concepts
      • Domain
      • Private Contract Store
      • Virtual Global Ledger
      • Mediator
      • Sequencer
      • Domain Identity Manager
      • Consensus
  • Examples
  • Canton Advanced Architecture
    • Contract Keys in Canton
      • Domains with Uniqueness Guarantees
      • Non Unique Contract Keys Mode
        • Examples of Semantic Differences
        • Canton’s Implementation of Keys
        • Workarounds for Recovering Uniqueness
        • Formal Semantics of Keys in Canton
    • Domain Architecture and Integrations
      • Domain-specific Requirements
        • Functional Requirements
        • Non-Functional Requirements
      • Domain-Internal Components
      • Drivers
      • Canton Domain on Ethereum
        • Smart contract Sequencer.sol
      • Canton Domain on Fabric
        • Introduction to Hyperledger Fabric
        • Architecture
        • Analysis and Limitations
    • High Availability
      • Canton High Availability: Overview and Principles
      • Replicated Participant Node Architecture
        • High-Level System Design
        • Participant Node Replica Monitoring and Fail-Over
        • Enforce a Passive Replica
        • Ledger API Client Fail-Over via Load Balancer
      • Domain HA
        • Sequencer HA
        • Mediator and Domain Manager HA
    • Identity Management
      • Identity Providing Service
        • Requirements
      • Identity Management Design
        • Design Principles
        • Formalism for a Global Composeable Topology System
      • Implementation
        • Domain Id
        • Identity Providing Service API
        • Sync Crypto Api
        • High-Level Picture
        • Transaction Flow
    • Canton High-Level Requirements
      • Functional requirements
      • Resource limits
      • Non-functional requirements
      • Known limitations
        • Limitations that apply always
        • Limitations that apply only sometimes
      • Requirement Exceptions: Notes
        • Ledger consistency
        • No unnecessary rejections
        • Privacy
    • Research Publications
    • Security
      • Secure Cryptographic Private Key Storage
        • Background
        • Requirements
        • Protect Private Keys With a Key Management Service
        • Satisfied Requirements
      • Resilience to Malicious Participants
        • Model Conformance
        • Signatory and Controller Authorization
        • Daml Ledger Integrity
        • Detection of Malicious Participants
      • Consensus & Transparency
        • Operating on the Same Transaction
        • Stakeholders Are Notified About Their Views
    • System Architecture FAQ
      • What does the Sequencer do?
      • How does Canton process a transaction?
      • How does Canton ensure privacy?
      • Where does “the golden source” of Daml Ledger data live in Canton?
      • How is Canton able to recover from data loss?
  • Language Reference
    • Overview: Template Structure
      • Template Outline Structure
      • Choice Structure
      • Choice Body Structure
    • Templates
      • Template Name
      • Template Parameters
      • Implicit Record
      • this and self
      • Template-local Definitions
      • Signatory Parties
      • Observers
      • Choices
      • Serializable Types
      • Agreements
      • Preconditions
      • Contract Keys and Maintainers
      • Interface Instances
    • Choices
      • choice First or controller First
      • Choice Name
      • Controllers
        • Contract Consumption
      • Preconsuming Choices
      • Postconsuming Choices
      • Non-consuming Choices
        • Return Type
      • Choice Arguments
      • Choice Body
      • Deprecation of controller first syntax
        • Migrating
        • Disabling the warning
    • Updates
      • Background
      • Binding Variables
      • do
      • create
      • exercise
      • exerciseByKey
      • fetch
      • fetchByKey
      • lookupByKey
      • abort
      • assert
      • getTime
      • return
      • let
      • this
    • Data types
      • Built-in Types
        • Table of built-in primitive types
        • Escaping Characters
        • Time
      • Lists
        • Sum a List
      • Records and Record Types
        • Data Constructors
        • Access Record Fields
        • Update Record Fields
        • Parameterized Data Types
      • Type Synonyms
        • Function Types
      • Algebraic Data Types
        • Product Types
        • Sum Types
        • Pattern Matching
    • Built-in functions
      • Work with Time
      • Work with Numbers
      • Work with Text
      • Work with Lists
        • Fold
    • Expressions
      • Definitions
        • Values
        • Functions
      • Arithmetic Operators
      • Comparison Operators
      • Logical Operators
      • If-then-else
      • Let
    • Functions
      • Defining Functions
      • Partial Application
      • Functions are Values
      • Generic Functions
    • File structure
      • File Structure
      • Imports
      • Libraries
      • Comments
      • Contract Identifiers
    • Packages
      • Building Daml Archives
      • Inspecting DARs
      • Import Daml Packages
        • Import a Daml package via Dependencies
        • Import a Daml Archive via data-dependencies
        • Reference Daml Packages Already On the Ledger
      • Handling Module Name Collisions
    • Contract keys
      • What Can Be a Contract Key
      • Specify Maintainers
      • Contract Lookups
        • fetchByKey
        • visibleByKey
        • lookupByKey
      • exerciseByKey
      • Example
    • Exceptions
      • Builtin Errors
      • User-defined Exceptions
      • Throw Exceptions
      • Catch Exceptions
    • Interfaces
      • Configuration
      • Interface Declaration
        • Interface Name
        • Implicit abstract type
        • Interface Methods
        • Interface View Type
        • Interface Choices
        • Empty Interfaces
      • Interface Instances
        • interface instance clause
        • interface instance clause in the interface
        • Empty interface instance clause
      • Interface Functions
        • interfaceTypeRep
        • toInterface
        • fromInterface
        • toInterfaceContractId
        • fromInterfaceContractId
        • coerceInterfaceContractId
        • fetchFromInterface
      • Required Interfaces
        • Interface Functions
  • The Standard Library
    • Prelude
      • Typeclasses
      • Data Types
      • Functions
    • DA.Action
      • Functions
    • DA.Action.State
      • Data Types
      • Functions
    • DA.Action.State.Class
      • Typeclasses
    • DA.Assert
      • Functions
    • DA.Bifunctor
      • Typeclasses
    • DA.BigNumeric
      • Functions
    • DA.Date
      • Data Types
      • Functions
    • DA.Either
      • Functions
    • DA.Exception
      • Typeclasses
      • Data Types
    • DA.Foldable
      • Typeclasses
      • Functions
    • DA.Functor
      • Functions
    • DA.Internal.Interface.AnyView
      • Typeclasses
      • Functions
    • DA.Internal.Interface.AnyView.Types
      • Data Types
    • DA.List
      • Functions
    • DA.List.BuiltinOrder
      • Functions
    • DA.List.Total
      • Functions
    • DA.Logic
      • Data Types
      • Functions
    • DA.Map
      • Functions
    • DA.Math
      • Functions
    • DA.Monoid
      • Data Types
    • DA.NonEmpty
      • Functions
    • DA.NonEmpty.Types
      • Data Types
    • DA.Numeric
      • Functions
    • DA.Optional
      • Functions
    • DA.Record
      • Typeclasses
    • DA.Semigroup
      • Data Types
    • DA.Set
      • Data Types
      • Functions
    • DA.Stack
      • Data Types
      • Functions
    • DA.Text
      • Functions
    • DA.TextMap
      • Functions
    • DA.Time
      • Data Types
      • Functions
    • DA.Traversable
      • Typeclasses
      • Functions
    • DA.Tuple
      • Functions
    • DA.Validation
      • Data Types
      • Functions
    • GHC.Show.Text
      • Functions
    • GHC.Tuple.Check
      • Functions
  • Daml Script Library
    • Module Daml.Script
      • Data Types
      • Functions
  • Daml Trigger Library
    • Module Daml.Trigger
      • Typeclasses
      • Data Types
      • Functions
    • Module Daml.Trigger.Assert
      • Data Types
      • Functions
    • Module Daml.Trigger.LowLevel
      • Typeclasses
      • Data Types
      • Functions
  • Canton Frequently Asked Questions
    • Log Messages
      • Database task queue full
      • Serialization Exception
    • Console Commands
      • I received an error saying that the DomainAlias I used was too long. Where I can see the limits of String types in Canton?
    • Bootstrap Scripts
      • Why do you have an additional new line between each line in your example scripts?
      • How can I use nested import statements to split my script into multiple files?
      • How do I write data to a file and how do I read it back?
    • Why is Canton complaining about my database version?
      • Postgres
      • Oracle
      • Using non-standard database versions
    • How do I enable unsupported features?
    • How to troubleshoot included configuration files?
  • Error codes
    • Error Categories
    • Machine Readable Information
    • Example
    • List of error codes
      • 1. ParticipantErrorGroup
      • 1.1. Errors
        • ACS_COMMITMENT_INTERNAL_ERROR
      • 1.1.1. MismatchError
        • ACS_COMMITMENT_ALARM
        • ACS_COMMITMENT_MISMATCH
        • ACS_MISMATCH_NO_SHARED_CONTRACTS
      • 1.2. LedgerApiErrors
        • HEAP_MEMORY_OVER_LIMIT
        • LEDGER_API_INTERNAL_ERROR
        • MAXIMUM_NUMBER_OF_STREAMS
        • PARTICIPANT_BACKPRESSURE
        • THREADPOOL_OVERLOADED
      • 1.2.1. CommandExecution
        • FAILED_TO_DETERMINE_LEDGER_TIME
      • 1.2.1.1. Package
        • ALLOWED_LANGUAGE_VERSIONS
        • PACKAGE_VALIDATION_FAILED
      • 1.2.1.2. Preprocessing
        • COMMAND_PREPROCESSING_FAILED
      • 1.2.1.3. Interpreter
        • CONTRACT_NOT_ACTIVE
        • DAML_AUTHORIZATION_ERROR
        • DAML_INTERPRETATION_ERROR
        • DAML_INTERPRETER_INVALID_ARGUMENT
      • 1.2.1.3.1. LookupErrors
        • CONTRACT_KEY_NOT_FOUND
      • 1.2.2. AdminServices
        • CONFIGURATION_ENTRY_REJECTED
        • INTERNALLY_INVALID_KEY
        • PACKAGE_UPLOAD_REJECTED
      • 1.2.2.1. PartyManagementServiceErrorGroup
        • CONCURRENT_PARTY_DETAILS_UPDATE_DETECTED
        • INTERNAL_PARTY_RECORD_ALREADY_EXISTS
        • INTERNAL_PARTY_RECORD_NOT_FOUND
        • INVALID_PARTY_DETAILS_UPDATE_REQUEST
        • MAX_PARTY_DETAILS_ANNOTATIONS_SIZE_EXCEEDED
        • PARTY_NOT_FOUND
      • 1.2.2.2. UserManagementServiceErrorGroup
        • CONCURRENT_USER_UPDATE_DETECTED
        • INVALID_USER_UPDATE_REQUEST
        • MAX_USER_ANNOTATIONS_SIZE_EXCEEDED
        • TOO_MANY_USER_RIGHTS
        • USER_ALREADY_EXISTS
        • USER_NOT_FOUND
      • 1.2.3. ConsistencyErrors
        • CONTRACT_NOT_FOUND
        • DISCLOSED_CONTRACT_INVALID
        • DUPLICATE_COMMAND
        • DUPLICATE_CONTRACT_KEY
        • INCONSISTENT
        • INCONSISTENT_CONTRACTS
        • INCONSISTENT_CONTRACT_KEY
        • INVALID_LEDGER_TIME
        • SUBMISSION_ALREADY_IN_FLIGHT
      • 1.2.4. PackageServiceError
        • DAR_NOT_SELF_CONSISTENT
        • DAR_VALIDATION_ERROR
        • PACKAGE_SERVICE_INTERNAL_ERROR
      • 1.2.4.1. Reading
        • DAR_PARSE_ERROR
        • INVALID_DAR
        • INVALID_DAR_FILE_NAME
        • INVALID_LEGACY_DAR
        • INVALID_ZIP_ENTRY
        • ZIP_BOMB
      • 1.2.5. WriteServiceRejections
        • DISPUTED
        • OUT_OF_QUOTA
        • PARTY_NOT_KNOWN_ON_LEDGER
        • SUBMITTER_CANNOT_ACT_VIA_PARTICIPANT
        • SUBMITTING_PARTY_NOT_KNOWN_ON_LEDGER
      • 1.2.5.1. Internal
        • INTERNALLY_DUPLICATE_KEYS
        • INTERNALLY_INCONSISTENT_KEYS
      • 1.2.6. AuthorizationChecks
        • INTERNAL_AUTHORIZATION_ERROR
        • PERMISSION_DENIED
        • STALE_STREAM_AUTHORIZATION
        • UNAUTHENTICATED
      • 1.2.7. RequestValidation
        • INVALID_ARGUMENT
        • INVALID_DEDUPLICATION_PERIOD
        • INVALID_FIELD
        • LEDGER_ID_MISMATCH
        • MISSING_FIELD
        • NON_HEXADECIMAL_OFFSET
        • OFFSET_AFTER_LEDGER_END
        • OFFSET_OUT_OF_RANGE
        • PARTICIPANT_PRUNED_DATA_ACCESSED
      • 1.2.7.1. NotFound
        • LEDGER_CONFIGURATION_NOT_FOUND
        • PACKAGE_NOT_FOUND
        • TEMPLATES_OR_INTERFACES_NOT_FOUND
        • TRANSACTION_NOT_FOUND
      • 1.3. TransactionErrorGroup
      • 1.3.1. TransactionRoutingError
        • AUTOMATIC_TRANSFER_FOR_TRANSACTION_FAILED
        • ROUTING_INTERNAL_ERROR
        • UNABLE_TO_GET_TOPOLOGY_SNAPSHOT
      • 1.3.1.1. TopologyErrors
        • INFORMEES_NOT_ACTIVE
        • NOT_CONNECTED_TO_ALL_CONTRACT_DOMAINS
        • NO_COMMON_DOMAIN
        • NO_DOMAIN_FOR_SUBMISSION
        • NO_DOMAIN_ON_WHICH_ALL_SUBMITTERS_CAN_SUBMIT
        • SUBMITTER_ALWAYS_STAKEHOLDER
        • UNKNOWN_CONTRACT_DOMAINS
        • UNKNOWN_INFORMEES
      • 1.3.1.2. MalformedInputErrors
        • INVALID_DOMAIN_ALIAS
        • INVALID_DOMAIN_ID
        • INVALID_PARTY_IDENTIFIER
        • INVALID_SUBMITTER
      • 1.3.1.3. ConfigurationErrors
        • INVALID_PRESCRIBED_DOMAIN_ID
        • MULTI_DOMAIN_SUPPORT_NOT_ENABLED
        • SUBMISSION_DOMAIN_NOT_READY
      • 1.3.2. SubmissionErrors
        • CHOSEN_MEDIATOR_IS_INACTIVE
        • CONTRACT_AUTHENTICATION_FAILED
        • DOMAIN_BACKPRESSURE
        • DOMAIN_WITHOUT_MEDIATOR
        • MALFORMED_REQUEST
        • NOT_SEQUENCED_TIMEOUT
        • PACKAGE_NOT_VETTED_BY_RECIPIENTS
        • PARTICIPANT_OVERLOADED
        • SEQUENCER_DELIVER_ERROR
        • SEQUENCER_REQUEST_FAILED
        • SUBMISSION_DURING_SHUTDOWN
      • 1.3.3. SyncServiceInjectionError
        • COMMAND_INJECTION_FAILURE
        • NODE_IS_PASSIVE_REPLICA
        • NOT_CONNECTED_TO_ANY_DOMAIN
      • 1.3.4. LocalReject
      • 1.3.4.1. MalformedRejects
        • LOCAL_VERDICT_BAD_ROOT_HASH_MESSAGES
        • LOCAL_VERDICT_CREATES_EXISTING_CONTRACTS
        • LOCAL_VERDICT_DETECTED_MULTIPLE_CONFIRMATION_POLICIES
        • LOCAL_VERDICT_FAILED_MODEL_CONFORMANCE_CHECK
        • LOCAL_VERDICT_MALFORMED_PAYLOAD
      • 1.3.4.2. ConsistencyRejections
        • LOCAL_VERDICT_DUPLICATE_KEY
        • LOCAL_VERDICT_INACTIVE_CONTRACTS
        • LOCAL_VERDICT_INCONSISTENT_KEY
        • LOCAL_VERDICT_LOCKED_CONTRACTS
        • LOCAL_VERDICT_LOCKED_KEYS
      • 1.3.4.3. TimeRejects
        • LOCAL_VERDICT_LEDGER_TIME_OUT_OF_BOUND
        • LOCAL_VERDICT_SUBMISSION_TIME_OUT_OF_BOUND
        • LOCAL_VERDICT_TIMEOUT
      • 1.3.4.4. TransferInRejects
        • TRANSFER_IN_ALREADY_COMPLETED
        • TRANSFER_IN_CONTRACT_ALREADY_ACTIVE
        • TRANSFER_IN_CONTRACT_ALREADY_ARCHIVED
        • TRANSFER_IN_CONTRACT_IS_LOCKED
      • 1.3.4.5. TransferOutRejects
        • TRANSFER_OUT_ACTIVENESS_CHECK_FAILED
      • 1.3.5. CommandDeduplicationError
        • MALFORMED_DEDUPLICATION_OFFSET
      • 1.4. SyncServiceError
        • PARTY_ALLOCATION_WITHOUT_CONNECTED_DOMAIN
        • SYNC_SERVICE_ALARM
        • SYNC_SERVICE_ALREADY_ADDED
        • SYNC_SERVICE_DOMAIN_BECAME_PASSIVE
        • SYNC_SERVICE_DOMAIN_DISABLED_US
        • SYNC_SERVICE_DOMAIN_DISCONNECTED
        • SYNC_SERVICE_DOMAIN_MUST_BE_OFFLINE
        • SYNC_SERVICE_DOMAIN_STATUS_NOT_ACTIVE
        • SYNC_SERVICE_INTERNAL_ERROR
        • SYNC_SERVICE_UNKNOWN_DOMAIN
      • 1.4.1. SyncDomainMigrationError
        • BROKEN_DOMAIN_MIGRATION
        • INVALID_DOMAIN_MIGRATION_REQUEST
      • 1.4.2. DomainRegistryError
        • DOMAIN_REGISTRY_INTERNAL_ERROR
        • TOPOLOGY_CONVERSION_ERROR
      • 1.4.2.1. ConfigurationErrors
        • CANNOT_ISSUE_DOMAIN_TRUST_CERTIFICATE
        • DOMAIN_PARAMETERS_CHANGED
        • INCOMPATIBLE_UNIQUE_CONTRACT_KEYS_MODE
        • INVALID_DOMAIN_CONNECTION
      • 1.4.2.2. HandshakeErrors
        • DOMAIN_ALIAS_DUPLICATION
        • DOMAIN_CRYPTO_HANDSHAKE_FAILED
        • DOMAIN_HANDSHAKE_FAILED
        • DOMAIN_ID_MISMATCH
        • SERVICE_AGREEMENT_ACCEPTANCE_FAILED
      • 1.4.2.3. ConnectionErrors
        • DOMAIN_IS_NOT_AVAILABLE
        • FAILED_TO_CONNECT_TO_SEQUENCER
        • GRPC_CONNECTION_FAILURE
        • PARTICIPANT_IS_NOT_ACTIVE
      • 1.5. AdminWorkflowServices
        • CAN_NOT_AUTOMATICALLY_VET_ADMIN_WORKFLOW_PACKAGE
      • 1.6. IndexErrors
      • 1.6.1. DatabaseErrors
        • INDEX_DB_INVALID_RESULT_SET
        • INDEX_DB_SQL_NON_TRANSIENT_ERROR
        • INDEX_DB_SQL_TRANSIENT_ERROR
      • 1.7. PruningServiceError
        • INTERNAL_PRUNING_ERROR
        • NON_CANTON_OFFSET
        • PRUNING_NOT_SUPPORTED_IN_COMMUNITY_EDITION
        • UNSAFE_TO_PRUNE
      • 1.8. CantonPackageServiceError
        • PACKAGE_OR_DAR_REMOVAL_ERROR
      • 1.9. ParticipantReplicationServiceError
        • PARTICIPANT_REPLICATION_INTERNAL_ERROR
        • PARTICIPANT_REPLICATION_NOT_SUPPORTED_BY_STORAGE
      • 1.10. CommonErrors
        • REQUEST_TIME_OUT
        • SERVER_IS_SHUTTING_DOWN
        • SERVICE_INTERNAL_ERROR
        • SERVICE_NOT_RUNNING
        • UNSUPPORTED_OPERATION
      • 2. EthereumErrors
      • 2.1. ConfigurationErrors
        • AHEAD_OF_HEAD
        • ATTEMPT_TO_CHANGE_IMMUTABLE_VALUE
        • AUTHORIZATION_ENABLEMENT_MISMATCH
        • ETHEREUM_CANT_QUERY_VERSION
        • MANY_BLOCKS_BEHIND_HEAD
        • NOT_FREE_GAS_NETWORK
        • UNAUTHORIZED
        • WRONG_EVM_BYTECODE
      • 2.2. TransactionErrors
        • ETHEREUM_TRANSACTION_INVALID
        • ETHEREUM_TRANSACTION_RECEIPT_FETCHING_FAILED
        • ETHEREUM_TRANSACTION_SUBMISSION_FAILED
      • 3. TopologyManagementErrorGroup
      • 3.1. TopologyManagerError
        • CERTIFICATE_GENERATION_ERROR
        • DUPLICATE_TOPOLOGY_TRANSACTION
        • INCREASE_OF_LEDGER_TIME_RECORD_TIME_TOLERANCE
        • INVALID_TOPOLOGY_TX_SIGNATURE_ERROR
        • NO_APPROPRIATE_SIGNING_KEY_IN_STORE
        • NO_CORRESPONDING_ACTIVE_TX_TO_REVOKE
        • PUBLIC_KEY_NOT_IN_STORE
        • REMOVING_KEY_DANGLING_TRANSACTIONS_MUST_BE_FORCED
        • REMOVING_LAST_KEY_MUST_BE_FORCED
        • SECRET_KEY_NOT_IN_STORE
        • TOPOLOGY_MANAGER_ALARM
        • TOPOLOGY_MANAGER_INTERNAL_ERROR
        • TOPOLOGY_MAPPING_ALREADY_EXISTS
        • UNAUTHORIZED_TOPOLOGY_TRANSACTION
      • 3.1.1. DomainTopologyManagerError
        • ALIEN_DOMAIN_ENTITIES
        • FAILED_TO_ADD_MEMBER
        • MALICOUS_OR_FAULTY_ONBOARDING_REQUEST
        • PARTICIPANT_NOT_INITIALIZED
        • WRONG_DOMAIN
        • WRONG_PROTOCOL_VERSION
      • 3.1.2. ParticipantTopologyManagerError
        • CANNOT_VET_DUE_TO_MISSING_PACKAGES
        • DANGEROUS_KEY_USE_COMMAND_REQUIRES_FORCE
        • DANGEROUS_VETTING_COMMANDS_REQUIRE_FORCE
        • DEPENDENCIES_NOT_VETTED
        • DISABLE_PARTY_WITH_ACTIVE_CONTRACTS_REQUIRES_FORCE
        • UNINITIALIZED_PARTICIPANT
      • 3.1.3. Domain
      • 3.1.3.1. GrpcSequencerAuthenticationService
        • CLIENT_AUTHENTICATION_FAULTY
        • CLIENT_AUTHENTICATION_REJECTED
      • 3.2. DomainTopologySender
        • TOPOLOGY_DISPATCHING_DEGRADATION
        • TOPOLOGY_DISPATCHING_INTERNAL_ERROR
      • 4. ConfigErrors
        • CANNOT_PARSE_CONFIG_FILES
        • CANNOT_READ_CONFIG_FILES
        • CONFIG_SUBSTITUTION_ERROR
        • CONFIG_VALIDATION_ERROR
        • GENERIC_CONFIG_ERROR
        • NO_CONFIG_FILES
      • 5. CommandErrors
        • CONSOLE_COMMAND_INTERNAL_ERROR
        • CONSOLE_COMMAND_TIMED_OUT
        • NODE_NOT_STARTED
      • 6. DatabaseStorageError
        • DB_CONNECTION_LOST
        • DB_STORAGE_DEGRADATION
      • 7. HandshakeErrors
        • DEPRECATED_PROTOCOL_VERSION
      • 8. FabricErrors
      • 8.1. ConfigurationErrors
        • FABRIC_AHEAD_OF_HEAD
        • FABRIC_MANY_BLOCKS_BEHIND_HEAD
      • 8.2. TransactionErrors
        • FABRIC_TRANSACTION_INVALID
        • FABRIC_TRANSACTION_PROPOSAL_SUBMISSION_FAILED
        • FABRIC_TRANSACTION_SUBMISSION_FAILED
      • 9. SequencerError
        • INVALID_ACKNOWLEDGEMENT_SIGNATURE
        • INVALID_ACKNOWLEDGEMENT_TIMESTAMP
        • INVALID_SEQUENCER_PRUNING_REQUEST_ON_CHAIN
        • INVALID_SUBMISSION_REQUEST_SIGNATURE
        • MAX_REQUEST_SIZE_EXCEEDED
        • MISSING_SUBMISSION_REQUEST_SIGNATURE_TIMESTAMP
      • 10. EnterpriseGrpcVaultServiceError
        • INVALID_WRAPPER_KEY_ID
        • NO_ENCRYPTED_PRIVATE_KEY_STORE_ERROR
        • WRAPPER_KEY_ALREADY_IN_USE_ERROR
        • WRAPPER_KEY_NOT_EXIST_ERROR
        • WRAPPER_KEY_ROTATION_INTERNAL_ERROR
      • 11. MediatorError
        • MEDIATOR_INTERNAL_ERROR
        • MEDIATOR_INVALID_MESSAGE
        • MEDIATOR_RECEIVED_MALFORMED_MESSAGE
        • MEDIATOR_SAYS_TX_TIMED_OUT
      • 12. ProtoDeserializationError
        • PROTO_DESERIALIZATION_FAILURE
      • 13. ResilientSequencerSubscription
        • SEQUENCER_SUBSCRIPTION_LOST
      • 14. Clock
        • SYSTEM_CLOCK_RUNNING_BACKWARDS
      • 15. VmbcErrors
      • 15.1. ConfigurationErrors
        • VMBC_ATTEMPT_TO_CHANGE_IMMUTABLE_VALUE
      • 15.2. Anomalies
        • VMBC_READ_FAILURE
        • VMBC_TRANSACTION_INVALID
        • VMBC_UNEXPECTED_REQUEST
  • Daml Ledger Model
    • Structure
      • Actions and Transactions
      • Ledgers
    • Integrity
      • Valid Ledgers
      • Consistency
        • Contract Consistency
        • Key Consistency
        • Ledger Consistency
        • Internal Consistency
      • Conformance
      • Authorization
        • Signatories, Agreements, and Maintainers
        • Authorization Rules
        • Examples
      • Valid Ledgers, Obligations, Offers and Rights
    • Privacy
      • Contract Observers and Stakeholders
      • Choice Observers
      • Projections
      • Privacy Through Authorization
      • Divulgence: When Non-Stakeholders See Contracts
    • Daml: Define Contract Models Compactly
    • Exceptions
      • Structure
      • Consistency
      • Transaction Normalization
      • Authorization
      • Privacy
      • Relation to Daml Exceptions
  • Identity and Package Management
    • Identity Management
      • Provisioning Identifiers
      • Identifiers and Authorization
      • Identifiers and the Real World
    • Package Management
      • Package Formats and Identifiers
      • Package Management API
      • Package Vetting
      • Package Upgrades
  • Time on Daml Ledgers
    • Ledger Time
    • Record Time
    • Guarantees
    • Ledger Time Model
    • Assign Ledger Time
  • Causality and Local Daml Ledgers
    • Causality Examples
      • Stakeholders of a Contract See Creation and Archival in the Same Order
      • Signatories of a Contract and Stakeholder Actors See Usages After the Creation and Before the Archival
      • Commits Are Atomic
      • Non-Consuming Usages in Different Commits May Appear in Different Orders
      • Out-of-Band Causality Is Not Respected
      • Divulged Actions Do Not Induce Order
      • The Ordering Guarantees Depend on the Party
    • Causality Graphs
      • Consistency
      • From Causality Graphs to Ledgers
    • Local Ledgers
      • Ledger API Ordering Guarantees
      • Explaining the Causality Examples
  • Test Evidence

Early Access

  • Daml Ledger Interoperability
    • Interoperability Examples
      • Topology
      • Aggregation at the Participant
      • Enter and Leave Events
      • Cross-ledger Transactions
    • Multi-ledger Causality Graphs
      • Consistency
      • Minimality and Reduction
      • From Multi-ledger Causality Graphs to Ledgers
    • Ledger-aware Projection
    • Ledger API Ordering Guarantees
  • Ledger Export
    • Introduction
    • Usage
    • Output
      • Daml Script
      • Arguments
    • Execute the Export
    • Ledger Offsets
    • Unknown Contract Ids
    • Transaction Time
    • Caveats
      • Contracts Created and Referenced In the Same Transaction
  • Non-repudiation
    • Architecture
    • Run the Server-side Components
    • Use the Client
    • Non-repudiation Over the HTTP JSON API
    • TLS Support
  • Visualizing Daml Contracts
    • Example: Visualize the Quickstart Project
    • Visualize Daml Contracts - Within IDE
    • Visualize Daml Contracts - Interactive Graphs
  • Custom Views
    • Overview
    • Projector
      • BatchSource
        • Batch
        • Envelope
      • Projection
      • The Project function
        • The JdbcAction
        • Projecting rows in batches
    • Configuration
      • Database migration with Flyway
      • Batcher configuration
      • Dispatcher configuration for blocking operation
Download as PDF

Developers
Products
Company
Version 
Please enter at least 3 letters.
In This Section
  • Implementation Packages

Implementation Packages¶

This section lists the implementation packages contained within Daml Finance:

  • Daml.Finance.Holding
  • Daml.Finance.Account
  • Daml.Finance.Settlement
  • Daml.Finance.Lifecycle
  • Daml.Finance.Data
  • Daml.Finance.Claims
  • Daml.Finance.Util
  • ContingentClaims.Lifecycle
  • ContingentClaims.Valuation
  • Daml.Finance.Instrument.Bond
  • Daml.Finance.Instrument.Equity
  • Daml.Finance.Instrument.Generic
  • Daml.Finance.Instrument.Swap
  • Daml.Finance.Instrument.Token
Previous Next

Copyright (c) 2022 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved. Any unauthorized use, duplication or distribution is strictly prohibited. "Digital Asset" and "Daml" are Registered in the U.S. Patent and Trademark Office.