Typeclasses

class IsSubmitOptions options where

Defines a type that can be transformed into a SubmitOptions

toSubmitOptions

: options -> SubmitOptions

class Applicative script => ScriptSubmit script where

Defines an applicative that can run transaction submissions. Usually this is simply Script.

liftSubmission

: HasCallStack => ConcurrentSubmits a -> script a

Data Types

data InvalidUserId

Thrown if text for a user identifier does not conform to the format restriction.

InvalidUserId

Field	Type	Description
m	Text

data User

User-info record for a user in the user management service.

User

Field	Type	Description
userId	UserId
primaryParty	Optional Party

data UserAlreadyExists

Thrown if a user to be created already exists.

UserAlreadyExists

Field	Type	Description
userId	UserId

data UserId

Identifier for a user in the user management service.

UserId Text

data UserNotFound

Thrown if a user cannot be located for a given user identifier.

UserNotFound

Field	Type	Description
userId	UserId

data UserRight

The rights of a user.

ParticipantAdmin

CanActAs Party

CanReadAs Party

CanReadAsAnyParty

data ConcurrentSubmits a

Applicative that allows for multiple concurrent transaction submissions See concurrently for usage of this type.

ConcurrentSubmits

Field	Type	Description
submits	[Submission]
continue	[Either SubmitError ([CommandResult], TransactionTree)] -> a

data PackageId

Package-id newtype for package preference

PackageId Text

data SubmitOptions

Options to detemine the stakeholders of a transaction, as well as disclosures. Intended to be specified using the actAs, readAs and disclose builders, combined using the Semigroup concat (<>) operator.

actAs alice <> readAs [alice, bob] <> disclose myContract

Note that actAs and readAs follows the same party derivation rules as signatory, see their docs for examples. All submissions must specify at least one actAs party, else a runtime error will be thrown. A minimum submission may look like

actAs alice `submit` createCmd MyContract with party = alice

For backwards compatibility, a single or set of parties can be provided in place of the SubmitOptions to submit, which will represent the actAs field. The above example could be reduced to

alice `submit` createCmd MyContract with party = alice

SubmitOptions

Field	Type	Description
soActAs	[Party]
soReadAs	[Party]
soDisclosures	[Disclosure]
soPackagePreference	Optional [PackageId]
soPrefetchKeys	[AnyContractKey]

data CryptoErrorType

Daml Crypto (Secp256k1) related submission errors

MalformedByteEncoding

Field	Type	Description
value	Text

MalformedKey

Field	Type	Description
keyValue	Text

MalformedSignature

Field	Type	Description
signatureValue	Text

data SubmitError

Errors that can be thrown by a command submission via trySubmit

ContractNotFound

Contract with given contract ID could not be found, and has never existed on this participant When run on Canton, there may be more than one contract ID, and additionalDebuggingInfo is always None On the other hand, when run on IDELedger, there is only ever one contract ID, and additionalDebuggingInfo is always Some

Field	Type	Description
unknownContractIds	NonEmpty Text	Provided as text, as we do not know the template ID of a contract if the lookup fails
additionalDebuggingInfo	Optional ContractNotFoundAdditionalInfo	should always be None in Canton’s case, see https://github.com/digital-asset/daml/issues/17154

ContractKeyNotFound

Contract with given contract key could not be found

Field	Type	Description
contractKey	AnyContractKey

UnresolvedPackageName

No vetted package with given package name could be found

Field	Type	Description
packageName	Text

AuthorizationError

Generic authorization failure, included missing party authority, invalid signatories, etc.

Field	Type	Description
authorizationErrorMessage	Text

ContractHashingError

Failed to hash a contract

Field	Type	Description
contractId	AnyContractId
dstTemplateId	TemplateTypeRep
createArg	AnyTemplate
errorMessage	Text

DisclosedContractKeyHashingError

Given disclosed contract key does not match the contract key of the contract on ledger.

Field	Type	Description
contractId	AnyContractId
expectedKey	AnyContractKey
givenKeyHash	Text

DuplicateContractKey

Attempted to create a contract with a contract key that already exists

Field	Type	Description
duplicateContractKey	Optional AnyContractKey	Canton will often not provide this key, IDELedger will

InconsistentContractKey

Contract key lookup yielded different results

Field	Type	Description
contractKey	AnyContractKey

UnhandledException

Unhandled user thrown exception

Field	Type	Description
exc	Optional AnyException	Errors more complex than simple records cannot currently be encoded over the grpc status. Such errors will be missing here.

UserError

Transaction failure due to abort/assert calls pre-exceptions

Field	Type	Description
userErrorMessage	Text

TemplatePreconditionViolated

Failure due to false result from ensure, strictly pre-exception. According to docs, not throwable with LF >= 1.14. On LF >= 1.14, a failed ensure will result in a PreconditionFailed exception wrapped in UnhandledException.

CreateEmptyContractKeyMaintainers

Attempted to create a contract with empty contract key maintainers

Field	Type	Description
invalidTemplate	AnyTemplate

FetchEmptyContractKeyMaintainers

Attempted to fetch a contract with empty contract key maintainers

Field	Type	Description
failedTemplateKey	AnyContractKey

WronglyTypedContract

Attempted to exercise/fetch a contract with the wrong template type

Field	Type	Description
contractId	AnyContractId	Any contract Id of the actual contract
expectedTemplateId	TemplateTypeRep
actualTemplateId	TemplateTypeRep

ContractDoesNotImplementInterface

Attempted to use a contract as an interface that it does not implement

Field	Type	Description
contractId	AnyContractId
templateId	TemplateTypeRep
interfaceId	TemplateTypeRep

ContractDoesNotImplementRequiringInterface

Attempted to use a contract as a required interface that it does not implement

Field	Type	Description
contractId	AnyContractId
templateId	TemplateTypeRep
requiredInterfaceId	TemplateTypeRep
requiringInterfaceId	TemplateTypeRep

NonComparableValues

Attempted to compare values that are not comparable

ContractIdInContractKey

Illegal Contract ID found in Contract Key

(no fields)

ContractIdComparability

Attempted to compare incomparable contract IDs. You’re doing something very wrong. Two contract IDs with the same prefix are incomparable if one of them is local and the other non-local or if one is relative and the other relative or absolute with a different suffix.

Field	Type	Description
globalExistingContractId	Text	We do not know the template ID at time of comparison.

ValueNesting

A value has been nested beyond a given depth limit

Field	Type	Description
limit	Int	Nesting limit that was exceeded

LocalVerdictLockedContracts

The transaction refers to locked contracts which are in the process of being created, transferred, or archived by another transaction. If the other transaction fails, this transaction could be successfully retried.

Field	Type	Description
localVerdictLockedContracts	[AnyContractId]	Locked contract ids

LocalVerdictLockedKeys

The transaction refers to locked keys which are in the process of being modified by another transaction.

Field	Type	Description
localVerdictLockedKeys	[AnyContractKey]	Locked contract keys

UpgradeError

Upgrade exception

Field	Type	Description
errorType	UpgradeErrorType
errorMessage	Text

FailureStatusError

Exception resulting from call to failWithStatus

Field	Type	Description
failureStatus	FailureStatus

CryptoError

Crypto exceptions

Field	Type	Description
cryptoErrorType	CryptoErrorType
cryptoErrorMessage	Text

EffectfulRollbackError

Rollback exceptions

Field	Type	Description
effectfulRollbackErrorMsg	Text

DevError

Development feature exceptions

Field	Type	Description
devErrorType	DevErrorType
devErrorMessage	Text

UnknownError

Generic catch-all for missing errors.

Field	Type	Description
unknownErrorMessage	Text

TruncatedError

One of the above error types where the full exception body did not fit into the response, and was incomplete.

Field	Type	Description
truncatedErrorType	Text	One of the constructor names of SubmitFailure except DevError, UnknownError, TruncatedError
truncatedErrorMessage	Text

data UpgradeErrorType

SCU related submission errors

ValidationFailed

Field	Type	Description
coid	AnyContractId
srcTemplateId	TemplateTypeRep
dstTemplateId	TemplateTypeRep
srcPackageName	Text
dstPackageName	Text
originalSignatories	[Party]
originalObservers	[Party]
originalKeyOpt	Optional (AnyContractKey, [Party])
recomputedSignatories	[Party]
recomputedObservers	[Party]
recomputedKeyOpt	Optional (AnyContractKey, [Party])

TranslationFailed

Field	Type	Description
mCoid	Optional AnyContractId
srcTemplateId	TemplateTypeRep
dstTemplateId	TemplateTypeRep
createArg	AnyTemplate

AuthenticationFailed

Field	Type	Description
coid	AnyContractId
srcTemplateId	TemplateTypeRep
dstTemplateId	TemplateTypeRep
createArg	AnyTemplate

data Created

Created

Field	Type	Description
contractId	AnyContractId
argument	AnyTemplate

data CreatedIndexPayload t

CreatedIndexPayload

Field	Type	Description
templateId	TemplateTypeRep
offset	Int

data Exercised

Exercised

Field	Type	Description
contractId	AnyContractId
choice	Text
argument	AnyChoice
childEvents	[TreeEvent]

data ExercisedIndexPayload t

ExercisedIndexPayload

Field	Type	Description
templateId	TemplateTypeRep
choice	Text
offset	Int
child	TreeIndex t

data TransactionTree

TransactionTree

Field	Type	Description
rootEvents	[TreeEvent]

data TreeEvent

CreatedEvent Created

ExercisedEvent Exercised

data TreeIndex t

CreatedIndex (CreatedIndexPayload t)

ExercisedIndex (ExercisedIndexPayload t)

data AnyContractId

AnyContractId

Field	Type	Description
templateId	TemplateTypeRep
contractId	ContractId ()

data ParticipantName

Participant name for multi-participant script runs to address a specific participant

ParticipantName

Field	Type	Description
participantName	Text

data PartyDetails

The party details returned by the party management service.

PartyDetails

Field	Type	Description
party	Party	Party id
isLocal	Bool	True if party is hosted by the backing participant.

data PartyIdHint

A hint to the backing participant what party id to allocate. Must be a valid PartyIdString (as described in @value.proto@).

PartyIdHint

Field	Type	Description
partyIdHint	Text

= BytesHex

A DER formatted private key to be used for ECDSA message signing

data Secp256k1KeyPair

Secp256k1 key pair generated by secp256k1generatekeypair for testing.

Secp256k1KeyPair

Field	Type	Description
privateKey	PrivateKeyHex
publicKey	PublicKeyHex

data AnyContractKey

Existential contract key type that can wrap an arbitrary contract key.

data Commands a

This is used to build up the commands sent as part of submit. If you enable the ApplicativeDo extension by adding {-# LANGUAGE ApplicativeDo #-} at the top of your file, you can use do-notation but the individual commands must not depend on each other and the last statement in a do block must be of the form return expr or pure expr.

Commands

Field	Type	Description
commands	[CommandWithMeta]
continue	[CommandResult] -> a

data Disclosure

Contract disclosures which can be acquired via queryDisclosure

Disclosure

Field	Type	Description
templateId	TemplateTypeRep
contractId	ContractId ()
blob	Text

data Script a

This is the type of A Daml script. Script is an instance of Action, so you can use do notation.

Script

Field	Type	Description
runScript	() -> Free ScriptF (a, ())	HIDE We use an inlined StateT () to separate evaluation of something of type Script from execution and to ensure proper sequencing of evaluation. This is mainly so that debug does something slightly more sensible.
dummy	()	HIDE Dummy field to make sure damlc does not consider this an old-style typeclass.

Functions

: UserId -> Text

Extract the name-text from a user identitifer.

: HasCallStack => Text -> Script UserId

Construct a user identifer from text. May throw InvalidUserId.

: HasCallStack => User -> [UserRight] -> Script ()

Create a user with the given rights. May throw UserAlreadyExists.

: HasCallStack => User -> [UserRight] -> ParticipantName -> Script ()

Create a user with the given rights on the given participant. May throw UserAlreadyExists.

: HasCallStack => UserId -> Script User

Fetch a user record by user id. May throw UserNotFound.

: HasCallStack => UserId -> ParticipantName -> Script User

Fetch a user record by user id from the given participant. May throw UserNotFound.

: Script [User]

List all users. This function may make multiple calls to underlying paginated ledger API.

: ParticipantName -> Script [User]

List all users on the given participant. This function may make multiple calls to underlying paginated ledger API.

: HasCallStack => UserId -> [UserRight] -> Script [UserRight]

Grant rights to a user. Returns the rights that have been newly granted. May throw UserNotFound.

: HasCallStack => UserId -> [UserRight] -> ParticipantName -> Script [UserRight]

Grant rights to a user on the given participant. Returns the rights that have been newly granted. May throw UserNotFound.

: HasCallStack => UserId -> [UserRight] -> Script [UserRight]

Revoke rights for a user. Returns the revoked rights. May throw UserNotFound.

: HasCallStack => UserId -> [UserRight] -> ParticipantName -> Script [UserRight]

Revoke rights for a user on the given participant. Returns the revoked rights. May throw UserNotFound.

: HasCallStack => UserId -> Script ()

Delete a user. May throw UserNotFound.

: HasCallStack => UserId -> ParticipantName -> Script ()

Delete a user on the given participant. May throw UserNotFound.

: HasCallStack => UserId -> Script [UserRight]

List the rights of a user. May throw UserNotFound.

: HasCallStack => UserId -> ParticipantName -> Script [UserRight]

List the rights of a user on the given participant. May throw UserNotFound.

: HasCallStack => UserId -> Commands a -> Script a

Submit the commands with the actAs and readAs claims granted to a user. May throw UserNotFound.

: HasCallStack => UserId -> ParticipantName -> Commands a -> Script a

Submit the commands with the actAs and readAs claims granted to the user on the given participant. May throw UserNotFound.

: HasCallStack => Time -> Script ()

Set the time via the time service.

This is only supported in Daml Studio and dpm test as well as when running over the gRPC API against a ledger in static time mode.

Note that the ledger time service does not support going backwards in time. However, you can go back in time in Daml Studio.

: HasCallStack => RelTime -> Script ()

Sleep for the given duration.

This is primarily useful in tests where you repeatedly call query until a certain state is reached.

Note that this will sleep for the same duration in both wall clock and static time mode.

: RelTime -> Script ()

Advance ledger time by the given interval.

This is only supported in Daml Studio and dpm test as well as when running over the gRPC API against a ledger in static time mode. Note that this is not an atomic operation over the gRPC API so no other clients should try to change time while this is running.

Note that the ledger time service does not support going backwards in time. However, you can go back in time in Daml Studio.

: IsParties parties => parties -> SubmitOptions

Builds a SubmitOptions with given actAs parties. Any given submission must include at least one actAs party. Note that the parties type is constrainted by IsParties, allowing for specifying parties as any of the following:

Party
[Party]
NonEmpty Party
Set Party
Optional Party

: IsParties parties => parties -> SubmitOptions

Builds a SubmitOptions with given readAs parties. A given submission may omit any readAs parties and still be valid. Note that the parties type is constrainted by IsParties, allowing for specifying parties as any of the following:

Party
[Party]
NonEmpty Party
Set Party
Optional Party

: [Disclosure] -> SubmitOptions

Provides many Explicit Disclosures to the transaction.

: Disclosure -> SubmitOptions

Provides an Explicit Disclosure to the transaction.

: [PackageId] -> SubmitOptions

Provide a package id selection preference for upgrades for a submission

: [AnyContractKey] -> SubmitOptions

Provide a list of contract keys to prefetch for a submission

: HasCallStack => ConcurrentSubmits a -> Script a

Allows for concurrent submission of transactions, using an applicative, similar to Commands. Concurrently takes a computation in ConcurrentSubmits, which supports all the existing submit functions that Script supports. It however does not implement Action, and thus does not support true binding and computation interdependence NOTE: The submission order of transactions within concurrently is deterministic, this function is not intended to test contention. It is only intended to allow faster submission of many unrelated transactions, by not waiting for completion for each transaction before sending the next. Example:

exerciseResult <- concurrently $ do
  alice `submit` createCmd ...
  res <- alice `submit` exerciseCmd ...
  bob `submit` createCmd ...
  pure res

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script (a, TransactionTree)

Equivalent to submit but returns the result and the full transaction tree.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script (Either SubmitError (a, TransactionTree))

Equivalent to trySubmit but returns the result and the full transaction tree.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script SubmitError

Equivalent to submitMustFail but returns the error thrown.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script a

submit p cmds submits the commands cmds as a single transaction from party p and returns the value returned by cmds. The options field can either be any "Parties" like type (See IsParties) or SubmitOptions which allows for finer control over parameters of the submission.

If the transaction fails, submit also fails.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script a

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script TransactionTree

Equivalent to submit but returns the full transaction tree.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script (Either SubmitError a)

Submit a transaction and recieve back either the result, or a SubmitError. In the majority of failures, this will not crash at runtime.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script (Either SubmitError TransactionTree)

Equivalent to trySubmit but returns the full transaction tree.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script ()

submitMustFail p cmds submits the commands cmds as a single transaction from party p. See submitWithOptions for details on the options field

It only succeeds if the submitting the transaction fails.

: (HasCallStack, ScriptSubmit script, IsSubmitOptions options) => options -> Commands a -> script ()

: (HasCallStack, ScriptSubmit script) => [Party] -> [Party] -> Commands a -> script a

submitMulti actAs readAs cmds submits cmds as a single transaction authorized by actAs. Fetched contracts must be visible to at least one party in the union of actAs and readAs.

Note: This behaviour can be achieved using submit (actAs actors <> readAs readers) cmds and is only provided for backwards compatibility.

: (HasCallStack, ScriptSubmit script) => [Party] -> [Party] -> Commands a -> script ()

submitMultiMustFail actAs readAs cmds behaves like submitMulti actAs readAs cmds but fails when submitMulti succeeds and the other way around.

Note: This behaviour can be achieved using submitMustFail (actAs actors <> readAs readers) cmds and is only provided for backwards compatibility.

: (HasCallStack, ScriptSubmit script) => [Party] -> [Party] -> Commands a -> script TransactionTree

Equivalent to submitMulti but returns the full transaction tree.

Note: This behaviour can be achieved using submitTree (actAs actors <> readAs readers) cmds and is only provided for backwards compatibility.

: (HasCallStack, ScriptSubmit script) => [Party] -> [Party] -> Commands a -> script (Either SubmitError a)

Alternate version of trySubmit that allows specifying the actAs and readAs parties.

Note: This behaviour can be achieved using trySubmit (actAs actors <> readAs readers) cmds and is only provided for backwards compatibility.

: HasCallStack => Party -> [Commands a] -> Script [Either SubmitError a]

: HasCallStack => Party -> [Disclosure] -> Commands a -> Script a

: HasCallStack => Party -> [Disclosure] -> Commands a -> Script ()

: Template t => TransactionTree -> TreeIndex t -> ContractId t

Finds the contract id of an event within a tree given a tree index Tree indices are created using the created(N) and exercised(N) builders which allow building "paths" within a transaction to a create node For example, exercisedN @MyTemplate1 "MyChoice" 2 $ createdN @MyTemplate2 1 would find the ContractId MyTemplate2 of the second (0 index) create event under the 3rd exercise event of MyChoice from MyTemplate1

: HasTemplateTypeRep t => TreeIndex t

Index for the first create event of a given template e.g. created @MyTemplate

: HasTemplateTypeRep t => Int -> TreeIndex t

Index for the Nth create event of a given template e.g. createdN 2 @MyTemplate created = createdN 0

: HasTemplateTypeRep t => Text -> TreeIndex t’ -> TreeIndex t’

Index for the first exercise of a given choice on a given template e.g. exercised @MyTemplate "MyChoice"

: HasTemplateTypeRep t => Text -> Int -> TreeIndex t’ -> TreeIndex t’

Index for the Nth exercise of a given choice on a given template e.g. exercisedN @MyTemplate "MyChoice" 2 exercised c = exercisedN c 0

: Template t => AnyContractId -> Optional (ContractId t)

: (Template t, HasEnsure t, IsParties p) => p -> Script [(ContractId t, t)]

Query the set of active contracts of the template that are visible to the given party.

: (Template c, HasEnsure c, IsParties p) => p -> (c -> Bool) -> Script [(ContractId c, c)]

Query the set of active contracts of the template that are visible to the given party and match the given predicate.

: (Template t, HasEnsure t, IsParties p, HasCallStack) => p -> ContractId t -> Script (Optional t)

Query for the contract with the given contract id.

Returns None if there is no active contract the party is a stakeholder on.

WARNING: Over the gRPC backend this performs a linear search over all contracts of the same type, so only use this if the number of active contracts is small.

This is semantically equivalent to calling query and filtering on the client side.

: (Template t, IsParties p, HasCallStack) => p -> ContractId t -> Script (Optional Disclosure)

Queries a Disclosure for a given ContractId. Same performance caveats apply as to queryContractId.

: (Template i, HasInterfaceView i v, IsParties p) => p -> Script [(ContractId i, Optional v)]

Query the set of active contract views for an interface that are visible to the given party. If the view function fails for a given contract id, The Optional v will be None.

: (Template i, HasInterfaceView i v, IsParties p, HasCallStack) => p -> ContractId i -> Script (Optional v)

Query for the contract view with the given contract id.

Returns None if there is no active contract the party is a stakeholder on.

Returns None if the view function fails for the given contract id.

WARNING: Over the gRPC backend this performs a linear search over all contracts of the same type, so only use this if the number of active contracts is small.

This is semantically equivalent to calling queryInterface and filtering on the client side.

: (HasCallStack, TemplateKey t k, IsParties p) => p -> k -> Script (Optional (ContractId t, t))

Returns None if there is no active contract with the given key that the party is a stakeholder on.

WARNING: Over the gRPC backend this performs a linear search over all contracts of the same type, so only use this if the number of active contracts is small.

This is semantically equivalent to calling query and filtering on the client side.

: (HasCallStack, TemplateKey t k, IsParties p) => p -> Int -> k -> Script [(ContractId t, t)]

Returns N contracts matching a key, returns empty list if the key is inactive Only available in LF 2.3+

WARNING: Over the gRPC backend this performs a linear search over all contracts of the same type, so only use this if the number of active contracts is small.

This is semantically equivalent to calling query and filtering on the client side.

: (HasCallStack, TemplateKey t k, IsParties p) => p -> k -> Script [(ContractId t, t)]

Returns all contracts matching a key, returns empty list if the key is inactive Only available in LF 2.3+

WARNING: Over the gRPC backend this performs a linear search over all contracts of the same type, so only use this if the number of active contracts is small.

This is semantically equivalent to calling query and filtering on the client side.

: HasCallStack => Text -> Script Party

Allocate a party with the given display name using the party management service.

: HasCallStack => Text -> PartyIdHint -> Script Party

: HasCallStack => PartyIdHint -> Script Party

Allocate a party with the given id hint using the party management service.

: Text -> ParticipantName -> Script Party

Allocate a party with the given display name on the specified participant using the party management service.

: Text -> PartyIdHint -> ParticipantName -> Script Party

: PartyIdHint -> ParticipantName -> Script Party

Allocate a party with the given id hint on the specified participant using the party management service.

: HasCallStack => Script [PartyDetails]

List the parties known to the default participant.

: HasCallStack => ParticipantName -> Script [PartyDetails]

List the parties known to the given participant.

: (() -> Script t) -> Script (Either AnyException t)

Named version of the try catch behaviour of Daml-Script. Note that this is no more powerful than try catch in daml-script, and will not catch exceptions in submissions. (Use trySubmit for this) Input computation is deferred to catch pure exceptions

: Script a -> Script (Either FailureStatus a)

Runs a script for a result. If it fails either by Daml Exceptions or failWithStatus, returns the FailureStatus that a Canton Ledger would return.

: HasCallStack => PrivateKeyHex -> BytesHex -> Script BytesHex

Using a DER formatted private key (encoded as a hex string) use Secp256k1 to sign a hex encoded string message.

Note that this implementation uses a random source with a fixed PRNG and seed, ensuring it behaves deterministically during testing.

For example, CCTP attestation services may be mocked in daml-script code.

: HasCallStack => PrivateKeyHex -> BytesHex -> Script BytesHex

Using a DER formatted private key (encoded as a hex string) use Secp256k1 to sign a SHA256 digest of a hex encoded string message.

Note that this implementation uses a random source with a fixed PRNG and seed, ensuring it behaves deterministically during testing.

For example, CCTP attestation services may be mocked in daml-script code.

: HasCallStack => Script Secp256k1KeyPair

Generate DER formatted Secp256k1 public/private key pairs.

: (HasTemplateTypeRep t, TemplateKey t k) => k -> AnyContractKey

Wrap a contract key in AnyContractKey.

You must pass the template type t using an explicit type application. For example toAnyContractKey @Proposal k.

: (HasTemplateTypeRep t, TemplateKey t k) => AnyContractKey -> Optional k

Extract the underlying key from AnyContractKey if the template and choice types match, or return None.

You must pass the template type t using an explicit type application. For example fromAnyContractKey @Proposal k.

: (Template t, HasEnsure t) => t -> Commands (ContractId t)

Create a contract of the given template.

: Choice t c r => ContractId t -> c -> Commands r

Exercise a choice on the given contract.

: (TemplateKey t k, Choice t c r) => k -> c -> Commands r

Exercise a choice on the contract with the given key.

: (Template t, Choice t c r, HasEnsure t) => t -> c -> Commands (ContractId t, r)

Create a contract and exercise a choice on it in the same transaction, returns the created ContractId, and the choice result.

: (Template t, Choice t c r, HasEnsure t) => t -> c -> Commands r

Create a contract and exercise a choice on it in the same transaction, returns only the choice result.

: (Template t, HasEnsure t) => t -> Commands (ContractId t)

Create a contract of the given template, using the exact package ID of the template given - upgrades are disabled.

: Choice t c r => ContractId t -> c -> Commands r

Exercise a choice on the given contract, using the exact package ID of the template given - upgrades are disabled.

: (TemplateKey t k, Choice t c r) => k -> c -> Commands r

Exercise a choice on the contract with the given key, using the exact package ID of the template given - upgrades are disabled.

: (Template t, Choice t c r, HasEnsure t) => t -> c -> Commands (ContractId t, r)

Create a contract and exercise a choice on it in the same transaction, returns the created ContractId, and the choice result. Uses the exact package ID of the template given - upgrades are disabled.

: (Template t, Choice t c r, HasEnsure t) => t -> c -> Commands r

Create a contract and exercise a choice on it in the same transaction, returns only the choice result.

: Choice t Archive () => ContractId t -> Commands ()

Archive the given contract.

archiveCmd cid is equivalent to exerciseCmd cid Archive.

: Script a -> Script a

Convenience helper to declare you are writing a Script.

This is only useful for readability and to improve type inference. Any expression of type Script a is a valid script regardless of whether it is implemented using script or not.