Iou.cs

// <auto-generated>
// This code was generated by daml-codegen-csharp.
// Do not edit this file manually.
// </auto-generated>

#nullable enable

using Daml.Ledger.Abstractions;
using Daml.Runtime.Commands;
using Daml.Runtime.Contracts;
using Daml.Runtime.Data;
using Daml.Runtime.Outcomes;
using Daml.Runtime.Stdlib;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Quickstart;

/// <summary>
/// Generated from Daml template Iou:Iou
/// </summary>
public sealed partial record Iou(Party Issuer, Party Owner, string Currency, decimal Amount) : ITemplate
{
    /// <summary>Gets the template identifier.</summary>
    public static Identifier TemplateId { get; } = new("c6ae1a03c6a0e5c146dba48c5c577583e4e2bc12ef1dad7fa72429f733367aba", "Iou", "Iou");

    /// <summary>Gets the package ID.</summary>
    public static string PackageId => "c6ae1a03c6a0e5c146dba48c5c577583e4e2bc12ef1dad7fa72429f733367aba";

    /// <summary>Gets the package name.</summary>
    public static string PackageName => "quickstart";

    /// <summary>Gets the package version.</summary>
    public static Version PackageVersion { get; } = new(0, 0, 1);

    /// <summary>Gets the compile-time Daml type descriptor.</summary>
    public static DamlTypeDescriptor DamlTypeId { get; } = new(TemplateId, DamlTypeKind.Template, PackageName);

    /// <summary>Converts this value to a DamlRecord.</summary>
    public DamlRecord ToRecord() => DamlRecord.Create(
        DamlField.Create("issuer", Issuer.ToDamlValue()),
        DamlField.Create("owner", Owner.ToDamlValue()),
        DamlField.Create("currency", new DamlText(Currency)),
        DamlField.Create("amount", new DamlNumeric(Amount))
    );

    /// <summary>Creates an instance from a DamlRecord.</summary>
    public static Iou FromRecord(DamlRecord record) => new Iou(
        Issuer: Party.FromDamlValue(record.GetRequiredField("issuer").As<DamlParty>()),
        Owner: Party.FromDamlValue(record.GetRequiredField("owner").As<DamlParty>()),
        Currency: record.GetRequiredField("currency").As<DamlText>().Value,
        Amount: record.GetRequiredField("amount").As<DamlNumeric>().Value
    );

    /// <summary>
    /// Exercise the Archive choice.
    /// This choice is consuming and will archive the contract.
    /// </summary>
    public static Choice<Iou, DamlUnit, DamlUnit> ChoiceArchive { get; } = new()
    {
        Name = new ChoiceName("Archive"),
        Consuming = true,
        ArgumentEncoder = _ => DamlUnit.Instance,
        ResultDecoder = _ => DamlUnit.Instance
    };

    /// <summary>
    /// Exercise the Transfer choice.
    /// This choice is consuming and will archive the contract.
    /// </summary>
    public static Choice<Iou, Transfer, ContractId<Iou>> ChoiceTransfer { get; } = new()
    {
        Name = new ChoiceName("Transfer"),
        Consuming = true,
        ArgumentEncoder = arg => arg.ToRecord(),
        ResultDecoder = val => new ContractId<Iou>(val.As<DamlContractId>().Value)
    };

    /// <summary>Contract ID for Iou.</summary>
    public sealed record ContractId(string Value) : ContractId<Iou>(Value), IExercises<Iou>
    {
        ContractId<Iou> IExercises<Iou>.ContractId => this;
    }

    /// <summary>Active contract for Iou.</summary>
    public sealed record Contract(ContractId Id, Iou Data) : IContract<ContractId, Iou>
    {
        /// <summary>Creates a Contract from a CreatedEvent.</summary>
        public static Contract FromCreatedEvent(CreatedEvent @event) =>
            new(new ContractId(@event.ContractId), Iou.FromRecord(@event.CreateArguments));
    }
}

/// <summary>
/// Typed projection of the contracts created by the Transfer choice.
/// One field per template the choice creates; cardinality follows the choice's
/// return type (single, optional, list).
/// </summary>
public sealed record TransferResult(ContractId<Iou> Iou)
{
    /// <summary>
    /// Projects an upstream transaction's created contracts to a typed <see cref="TransferResult"/>.
    /// Returns:
    /// <list type="bullet">
    ///   <item><see cref="ExerciseOutcome{T}.One"/> when every expected template's cardinality matches.</item>
    ///   <item><see cref="ExerciseOutcome{T}.None"/> when at least one required slot's template is missing from the transaction.</item>
    ///   <item><see cref="ExerciseOutcome{T}.Many"/> when a single-cardinality slot has more than one created contract of its template, or an optional-cardinality slot has more than one.</item>
    /// </list>
    /// Cardinality is matched by template ID's <c>(module, entity)</c> pair only — package upgrades that share the same logical template name match cleanly.
    /// </summary>
    public static ExerciseOutcome<TransferResult> FromCreatedContracts(IEnumerable<CreatedContract> created)
    {
        ArgumentNullException.ThrowIfNull(created);
        var templateMatches0 = new List<string>();
        foreach (var item in created)
        {
            if (string.Equals(item.TemplateId.ModuleName, global::Quickstart.Iou.TemplateId.ModuleName, StringComparison.Ordinal)
                && string.Equals(item.TemplateId.EntityName, global::Quickstart.Iou.TemplateId.EntityName, StringComparison.Ordinal))
            {
                templateMatches0.Add(item.ContractId);
            }
        }
        var matches0 = new List<string>();
        var templateMatchIndex0 = 0;
        if (templateMatchIndex0 < templateMatches0.Count)
        {
            matches0.Add(templateMatches0[templateMatchIndex0]);
            templateMatchIndex0++;
        }
        if (templateMatchIndex0 < templateMatches0.Count)
        {
            while (templateMatchIndex0 < templateMatches0.Count)
            {
                matches0.Add(templateMatches0[templateMatchIndex0]);
                templateMatchIndex0++;
            }
        }

        if (matches0.Count == 0)
        {
            return new ExerciseOutcome<TransferResult>.None();
        }
        if (matches0.Count > 1)
        {
            return new ExerciseOutcome<TransferResult>.Many(matches0.Count, matches0);
        }

        return new ExerciseOutcome<TransferResult>.One(new TransferResult(
            Iou: new ContractId<global::Quickstart.Iou>(matches0[0])
        ));
    }

}


/// <summary>
/// Static <c>&lt;Choice&gt;Async</c> extension methods for <see cref="Iou"/>.
/// One method per create-bearing choice; each delegates to
/// <see cref="global::Daml.Ledger.Abstractions.ILedgerClient.TrySubmitAndWaitForTransactionAsync"/>
/// and projects success via <c>&lt;Choice&gt;Result.FromCreatedContracts</c>.
/// </summary>
public static class IouExtensions
{
    /// <summary>
    /// Exercises the Transfer choice and projects the resulting transaction's created contracts to a typed <see cref="TransferResult"/>.
    /// The submitter is passed explicitly via <paramref name="submitter"/> — the static
    /// analyzer could not resolve the Daml <c>controller</c> clause to payload-field
    /// references. <see cref="SubmitterInfo"/> implicitly converts from a
    /// single <c>Party</c>, so the single-party call site stays a one-liner.
    /// </summary>
    /// <param name="contractId">The contract on which to exercise the choice.</param>
    /// <param name="client">The ledger client.</param>
    /// <param name="argument">The choice argument.</param>
    /// <param name="submitter">The submitter party set (<c>actAs</c> + optional <c>readAs</c>).</param>
    /// <param name="workflowId">Optional workflow id; passed through to the ledger when supplied. No default — workflow IDs are correlation keys, and a per-choice default would bucket every submission of the same choice under one ID.</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    public static async Task<ExerciseOutcome<TransferResult>> TransferAsync(
        this ContractId<Iou> contractId,
        ILedgerClient client,
        Iou.Transfer argument,
        SubmitterInfo submitter,
        string? workflowId = null,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(contractId);
        ArgumentNullException.ThrowIfNull(client);
        ArgumentNullException.ThrowIfNull(argument);

        var command = new ExerciseCommand(
            Iou.TemplateId,
            contractId,
            new ChoiceName("Transfer"),
            argument.ToRecord());

        var submission = CommandsSubmission.Single(command)
            .WithSubmitter(submitter)
            .WithCommandId(new CommandId(Guid.NewGuid().ToString()));
        if (!string.IsNullOrEmpty(workflowId))
        {
            submission = submission.WithWorkflowId(new WorkflowId(workflowId));
        }

        var outcome = await client.TrySubmitAndWaitForTransactionAsync(submission, cancellationToken).ConfigureAwait(false);

        return outcome switch
        {
            ExerciseOutcome<TransactionResult>.One success => TransferResult.FromCreatedContracts(success.Result.CreatedContracts),
            ExerciseOutcome<TransactionResult>.DamlError damlError => new ExerciseOutcome<TransferResult>.DamlError(damlError.Category, damlError.ErrorId, damlError.Message, damlError.Metadata),
            ExerciseOutcome<TransactionResult>.InfraError infraError => new ExerciseOutcome<TransferResult>.InfraError(infraError.StatusCode, infraError.Message),
            _ => throw new InvalidOperationException($"Unhandled outcome: {outcome.GetType().Name}"),
        };
    }
}

/// <summary>
/// Typed-submitter extensions for <see cref="Iou"/>. The
/// <see cref="CreateAsync"/> overload derives the <c>actAs</c> parties
/// from the template payload (for signatories that are payload-field
/// references) and from the caller's explicit arguments (for signatories
/// the static analyzer could not resolve). When the template's
/// <c>observer</c> clause is statically resolvable, an
/// <c>Observers(payload)</c> documentation helper is also emitted.
/// </summary>
public static class IouSubmissionExtensions
{
    /// <summary>
    /// Creates a new <see cref="Iou"/> contract on the ledger.
    /// The submitter is passed explicitly via <paramref name="submitter"/>. The static
    /// analyzer could not resolve the Daml <c>signatory</c> clause to payload-field
    /// references — typically because the expression involves the template key, a
    /// constant, or a function call. <see cref="SubmitterInfo"/> implicitly converts
    /// from a single <c>Party</c>, so single-party callers still pass one literal.
    /// </summary>
    /// <param name="client">The ledger client.</param>
    /// <param name="payload">The contract payload.</param>
    /// <param name="submitter">The submitter party set (<c>actAs</c> + optional <c>readAs</c>).</param>
    /// <param name="cancellationToken">Cancellation token.</param>
    public static Task<ExerciseOutcome<ContractId<Iou>>> CreateAsync(
        this ILedgerClient client,
        Iou payload,
        SubmitterInfo submitter,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(client);
        ArgumentNullException.ThrowIfNull(payload);

        return client.TryCreateAsync<Iou>(payload, submitter, cancellationToken: cancellationToken);
    }
}