dApp SDK supporting codegen TS

[PHOL-DA]

the dApp SDK should support using interacting and using custom daml models as generated by the Typescript SDK.

The SDK team should be directly engaged as part of this task to ensure a nice User Experience when developing for custom code against the SDK.

[hrischuk-da]

Matt Franczak matt@brale.xyz
Today at 09:32
We've built one for doing stablecoin issuance. We are using openapi-fetch to generate a client for the HTTP JSON API and daml codegen js to generate types for the templates we interact with. The most challenging part we ran into was mapping the data in the request and response types to the contract types; the generated client treats the schemas for contracts and choices as having unknown types. I have some code implementing a client wrapper that handles the type conversions that I'm thinking of open sourcing, but it may be a while before I have the chance to factor it out into it's own package and add coverage for the endpoints we're not using

technically, you need to manually force the conversion for now with as casting?

From Matt --> what we did was use generics to write wrappers that would

/**
   * Exercises a choice on a contract and returns the resulting exercise event
   * @param contractId the ID of the contract to exercise the choice on
   * @param choice the choice to exercise
   * @param choiceArguments the arguments to pass to the choice
   * @param actAsPartyId the party to act as when exercising the choice
   * @returns
   */
  async exerciseChoice<T extends object, C, R, K>(
    contractId: ContractId<T>,
    choice: Choice<T, C, R, K>,
    choiceArguments: K,
    actAsPartyId: string,
  ): Promise<ExercisedEvent<T, C, R>> {
    const commandId = crypto.randomUUID();
    const result = await this.client.POST(
      '/v2/commands/submit-and-wait-for-transaction',
      {
        body: {
          commands: {
            commands: [
              {
                ExerciseCommand: {
                  contractId: contractId,
                  templateId: choice.template().templateId,
                  choice: choice.choiceName,
                  choiceArgument: choiceArguments,
                },
              },
            ],
            actAs: [actAsPartyId],
            commandId: commandId,
          },
          transactionFormat: {
            eventFormat: {
              filtersByParty: {
                [actAsPartyId]: {
                  cumulative: [
                    {
                      identifierFilter: {
                        TemplateFilter: {
                          value: {
                            templateId: choice.template().templateId,
                            includeCreatedEventBlob: false,
                          },
                        },
                      },
                    },
                  ],
                },
              },
              verbose: false,
            },
            transactionShape: 'TRANSACTION_SHAPE_LEDGER_EFFECTS',
          },
        },
      },
    );

    if (result.error) {
      console.log(JSON.stringify(result.error, null, 2));
      throw new Error(
        `Failed to exercise choice ${choice.choiceName} on contract ${contractId} with command ID ${commandId}: ${result.response.status} ${result.response.statusText}`,
        { cause: result.error },
      );
    }

    this.logger.log(
      `Exercised choice ${choice.choiceName} on contract ${contractId} with command ID ${commandId} in update ID ${result.data.transaction.updateId} with completion offset ${result.data.transaction.offset}`,
    );

    // Find the ExercisedEvent for the choice we just exercised
    const exercisedEvent = result.data.transaction.events
      ?.filter(
        (
          event,
        ): event is {
          ExercisedEvent: components['schemas']['ExercisedEvent'];
        } => 'ExercisedEvent' in event,
      )
      .find(
        (event) =>
          event.ExercisedEvent.templateId.split(':')[1] ===
            choice.template().templateId.split(':')[1] &&
          event.ExercisedEvent.choice === choice.choiceName,
      )?.ExercisedEvent;

    if (!exercisedEvent) {
      throw new Error(
        `Failed to find CreatedEvent for template ${
          choice.template().templateId
        } in transaction response`,
      );
    }
    return this.toExercisedEvent<T, C, R>(exercisedEvent);
  }

that allows us to exercise choices with type safety - below code returns a Promise

    const result = await this.cantonLedgerService.exerciseChoice(
      transferInstruction.contractId as ContractId<TransferInstruction>,
      TransferInstruction.TransferInstruction_Accept,
      acceptArgs,
      transferInstruction.interfaceViews[0].viewValue.transfer.sender,
    );
    return result.exerciseResult;