canton-daml 0.2.2

Runtime types and Value codecs for canton-codegen-generated Daml bindings.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//! Builders that turn typed templates and choices into Ledger API commands.
//!
//! These construct the `Command` values the client crate (`canton-ledger`)
//! submits — they perform no I/O. A [`Template`] payload becomes a
//! `CreateCommand`; a [`Choice`] argument exercised on a [`ContractId`] becomes
//! an `ExerciseCommand`. Both use the template's upgrade-friendly
//! [`Template::template_id`] (the `#<package-name>` form).

use canton_proto::com::daml::ledger::api::v2 as pb;

use crate::choice::Choice;
use crate::primitives::ContractId;
use crate::template::{Contract, Template, WithKey};
use crate::value::ToValue;

/// A `CreateCommand` for a new contract of template `T` from its payload.
#[must_use]
pub fn create_command<T: Template>(payload: &T) -> pb::Command {
    wrap(pb::command::Command::Create(pb::CreateCommand {
        template_id: Some(T::template_id()),
        create_arguments: Some(payload.to_record()),
    }))
}

/// An `ExerciseCommand` exercising choice `C` (with `argument`) on the contract
/// `contract_id` of template or interface `T`.
#[must_use]
pub fn exercise_command<T, C>(contract_id: &ContractId<T>, argument: &C) -> pb::Command
where
    T: Contract,
    C: Choice<T> + ToValue,
{
    wrap(pb::command::Command::Exercise(pb::ExerciseCommand {
        template_id: Some(T::template_id()),
        contract_id: contract_id.as_str().to_string(),
        choice: C::NAME.to_string(),
        choice_argument: Some(argument.to_value()),
    }))
}

/// An `ExerciseByKeyCommand` exercising choice `C` (with `argument`) on the
/// contract of template `T` identified by its contract `key`.
#[must_use]
pub fn exercise_by_key_command<T, C>(key: &T::Key, argument: &C) -> pb::Command
where
    T: WithKey,
    C: Choice<T> + ToValue,
{
    wrap(pb::command::Command::ExerciseByKey(
        pb::ExerciseByKeyCommand {
            template_id: Some(T::template_id()),
            contract_key: Some(key.to_value()),
            choice: C::NAME.to_string(),
            choice_argument: Some(argument.to_value()),
        },
    ))
}

/// Wrap a command variant in the top-level `Command` envelope.
fn wrap(command: pb::command::Command) -> pb::Command {
    pb::Command {
        command: Some(command),
    }
}