> ## Documentation Index
> Fetch the complete documentation index at: https://cantonfoundation-generated-reference-full-stack-preview.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# POST /v2/interactive-submission/prepare

> Requires `readAs` scope for the submitting party when LAPI User authorization is enabled

<div class="x2mdx-ref-page x2mdx-ref-page--operation x2mdx-ref-page--manual-api" />

<div class="x2mdx-ref-hero">
  <p class="x2mdx-ref-summary">Requires `readAs` scope for the submitting party when LAPI User authorization is enabled</p>

  <div class="x2mdx-ref-badges">
    <span class="x2mdx-ref-badge x2mdx-ref-badge--protocol">OpenAPI</span>

    <a class="x2mdx-ref-badge x2mdx-ref-badge--changed" href="#history-updated-3-5">Updated 3.5</a>
  </div>
</div>

<RequestExample>
  ```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
  curl --request POST \
    --url 'http://localhost:7575/v2/interactive-submission/prepare' \
    --header 'Authorization: Bearer $TOKEN' \
    --header 'Content-Type: application/json' \
    --data '{
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }'
  ```

  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  import json
  import requests

  url = "http://localhost:7575/v2/interactive-submission/prepare"
  headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
  payload = json.loads(r'''{
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }''')
  response = requests.request(
      "POST", url, headers=headers, json=payload
  )

  print(response.text)
  ```

  ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  const response = await fetch('http://localhost:7575/v2/interactive-submission/prepare', {
    method: 'POST',
    headers: {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
  },
    body: JSON.stringify({
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }),
  });

  console.log(await response.text());
  ```

  ```php PHP theme={"theme":{"light":"github-light","dark":"github-dark"}}
  <?php
  $curl = curl_init();

  curl_setopt_array($curl, [
      CURLOPT_URL => 'http://localhost:7575/v2/interactive-submission/prepare',
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_CUSTOMREQUEST => 'POST',
      CURLOPT_POSTFIELDS => <<<'JSON'
  {
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }
  JSON,
      CURLOPT_HTTPHEADER => [
          "Authorization: Bearer <token>",
          "Content-Type: application/json"
      ],
  ]);

  $response = curl_exec($curl);
  echo $response;
  ```

  ```go Go theme={"theme":{"light":"github-light","dark":"github-dark"}}
  package main

  import (
    "bytes"
    "fmt"
    "io"
    "net/http"
  )

  func main() {
    req, _ := http.NewRequest("POST", "http://localhost:7575/v2/interactive-submission/prepare", bytes.NewBufferString(`{
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }`))
    req.Header.Set("Authorization", "Bearer <token>")
    req.Header.Set("Content-Type", "application/json")
    response, _ := http.DefaultClient.Do(req)
    defer response.Body.Close()
    body, _ := io.ReadAll(response.Body)
    fmt.Println(string(body))
  }
  ```

  ```java Java theme={"theme":{"light":"github-light","dark":"github-dark"}}
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;

  var request = HttpRequest.newBuilder()
      .uri(URI.create("http://localhost:7575/v2/interactive-submission/prepare"))
      .header("Authorization", "Bearer <token>")
      .header("Content-Type", "application/json")
      .method("POST", HttpRequest.BodyPublishers.ofString("""
  {
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }
  """))
      .build();
  var response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString());
  System.out.println(response.body());
  ```

  ```ruby Ruby theme={"theme":{"light":"github-light","dark":"github-dark"}}
  require 'net/http'
  require 'uri'

  uri = URI('http://localhost:7575/v2/interactive-submission/prepare')
  request = Net::HTTP::Post.new(uri)
  request['Authorization'] = 'Bearer <token>'
  request['Content-Type'] = 'application/json'
  request.body = <<~JSON
  {
    "userId": "<string>",
    "commandId": "<string>",
    "commands": [
      {
        "CreateAndExerciseCommand": {
          "templateId": "<string>",
          "createArguments": "<string>",
          "choice": "<string>",
          "choiceArgument": "<string>"
        }
      }
    ],
    "minLedgerTime": {
      "time": {
        "Empty": {}
      }
    },
    "actAs": [
      "<string>"
    ],
    "readAs": [
      "<string>"
    ],
    "disclosedContracts": [
      {
        "templateId": "<string>",
        "contractId": "<string>",
        "createdEventBlob": "<string>",
        "synchronizerId": "<string>"
      }
    ],
    "synchronizerId": "<string>",
    "packageIdSelectionPreference": [
      "<string>"
    ],
    "verboseHashing": false,
    "prefetchContractKeys": [
      {
        "templateId": "<string>",
        "contractKey": "<string>",
        "limit": 123
      }
    ],
    "maxRecordTime": "<string>",
    "estimateTrafficCost": {
      "disabled": false,
      "expectedSignatures": [
        "SIGNING_ALGORITHM_SPEC_UNSPECIFIED"
      ]
    },
    "tapsMaxPasses": 123,
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED"
  }
  JSON
  response = Net::HTTP.start(uri.hostname, uri.port) do |http|
    http.request(request)
  end
  puts response.body
  ```
</RequestExample>

<ResponseExample>
  ```json 200 theme={"theme":{"light":"github-light","dark":"github-dark"}}
  {
    "preparedTransaction": "<string>",
    "preparedTransactionHash": "<string>",
    "hashingSchemeVersion": "HASHING_SCHEME_VERSION_UNSPECIFIED",
    "hashingDetails": "<string>",
    "costEstimation": {
      "estimationTimestamp": "<string>",
      "confirmationRequestTrafficCostEstimation": 123,
      "confirmationResponseTrafficCostEstimation": 123,
      "totalTrafficCostEstimation": 123
    }
  }
  ```

  ```text 400 theme={"theme":{"light":"github-light","dark":"github-dark"}}
  <string>
  ```

  ```json default theme={"theme":{"light":"github-light","dark":"github-dark"}}
  {
    "code": "<string>",
    "cause": "<string>",
    "correlationId": "<string>",
    "traceId": "<string>",
    "context": {},
    "resources": [
      [
        "<string>"
      ]
    ],
    "errorCategory": 123,
    "grpcCodeValue": 123,
    "retryInfo": "<string>",
    "definiteAnswer": false
  }
  ```
</ResponseExample>

## Authorizations

### httpAuth

<ParamField header="Authorization" type="string" required>
  HTTP bearer authentication. Send the token as `Authorization: Bearer &lt;token&gt;`. Ledger API standard JWT token
</ParamField>

### apiKeyAuth

<ParamField header="Sec-WebSocket-Protocol" type="string" required>
  API key authentication in the header. Ledger API standard JWT token (websocket)
</ParamField>

## Body

<div class="x2mdx-ref-badges">
  <span class="x2mdx-ref-badge x2mdx-ref-badge--neutral">application/json</span>
</div>

<ParamField body="userId" type="string">
  Uniquely identifies the participant user that prepares the transaction. Must be a valid UserIdString (as described in `value.proto`). Required unless authentication is used with a user token. In that case, the token's user-id will be used for the request's user\_id. Optional
</ParamField>

<ParamField body="commandId" type="string" required>
  Uniquely identifies the command. The triple (user\_id, act\_as, command\_id) constitutes the change ID for the intended ledger change, where act\_as is interpreted as a set of party names. The change ID can be used for matching the intended ledger changes with all their completions. Must be a valid LedgerString (as described in `value.proto`). Required
</ParamField>

<ParamField body="commands" type="object[]" required>
  OpenAPI type: <code>Command\[]</code>.

  Individual elements of this atomic command. Must be non-empty. Limitation: Only single command transaction are currently supported by the API. The field is marked as repeated in preparation for future support of multiple commands. Required: must be non-empty

  <Expandable title="child attributes">
    <ParamField body="Variant 1" type="object">
      <Expandable title="child attributes">
        <ParamField body="CreateAndExerciseCommand" type="object" required>
          OpenAPI type: <code>CreateAndExerciseCommand</code>.

          Create a contract and exercise a choice on it in the same transaction.

          <Expandable title="child attributes">
            <ParamField body="templateId" type="string" required>
              The template of the contract the client wants to create. Both package-name and package-id reference identifier formats for the template-id are supported. Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4. Required
            </ParamField>

            <ParamField body="createArguments" type="object" required>
              The arguments required for creating a contract from this template. Required
            </ParamField>

            <ParamField body="choice" type="string" required>
              The name of the choice the client wants to exercise. Must be a valid NameString (as described in `value.proto`). Required
            </ParamField>

            <ParamField body="choiceArgument" type="object" required>
              The argument for this choice. Required
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="Variant 2" type="object">
      <Expandable title="child attributes">
        <ParamField body="CreateCommand" type="object" required>
          OpenAPI type: <code>CreateCommand</code>.

          Create a new contract instance based on a template.

          <Expandable title="child attributes">
            <ParamField body="templateId" type="string" required>
              The template of contract the client wants to create. Both package-name and package-id reference identifier formats for the template-id are supported. Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4. Required
            </ParamField>

            <ParamField body="createArguments" type="object" required>
              The arguments required for creating a contract from this template. Required
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="Variant 3" type="object">
      <Expandable title="child attributes">
        <ParamField body="ExerciseByKeyCommand" type="object" required>
          OpenAPI type: <code>ExerciseByKeyCommand</code>.

          Exercise a choice on an existing contract specified by its key.

          <Expandable title="child attributes">
            <ParamField body="templateId" type="string" required>
              The template of contract the client wants to exercise. Both package-name and package-id reference identifier formats for the template-id are supported. Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4. Required
            </ParamField>

            <ParamField body="contractKey" type="object" required>
              The key of the contract the client wants to exercise upon. Required
            </ParamField>

            <ParamField body="choice" type="string" required>
              The name of the choice the client wants to exercise. Must be a valid NameString (as described in `value.proto`) Required
            </ParamField>

            <ParamField body="choiceArgument" type="object" required>
              The argument for this choice. Required
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>

    <ParamField body="Variant 4" type="object">
      <Expandable title="child attributes">
        <ParamField body="ExerciseCommand" type="object" required>
          OpenAPI type: <code>ExerciseCommand</code>.

          Exercise a choice on an existing contract.

          <Expandable title="child attributes">
            <ParamField body="templateId" type="string" required>
              The template or interface of the contract the client wants to exercise. Both package-name and package-id reference identifier formats for the template-id are supported. Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4. To exercise a choice on an interface, specify the interface identifier in the template\_id field. Required
            </ParamField>

            <ParamField body="contractId" type="string" required>
              The ID of the contract the client wants to exercise upon. Must be a valid LedgerString (as described in `value.proto`). Required
            </ParamField>

            <ParamField body="choice" type="string" required>
              The name of the choice the client wants to exercise. Must be a valid NameString (as described in `value.proto`) Required
            </ParamField>

            <ParamField body="choiceArgument" type="object" required>
              The argument for this choice. Required
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="minLedgerTime" type="object">
  OpenAPI type: <code>MinLedgerTime</code>.

  Optional

  <Expandable title="child attributes">
    <ParamField body="time" type="object">
      OpenAPI type: <code>Time</code>.

      Required

      <Expandable title="child attributes">
        <ParamField body="Variant 1" type="object">
          <Expandable title="child attributes">
            <ParamField body="Empty" type="object" required>
              OpenAPI type: <code>Empty9</code>.
            </ParamField>
          </Expandable>
        </ParamField>

        <ParamField body="Variant 2" type="object">
          <Expandable title="child attributes">
            <ParamField body="MinLedgerTimeAbs" type="object" required>
              OpenAPI type: <code>MinLedgerTimeAbs</code>.

              <Expandable title="child attributes">
                <ParamField body="value" type="string" required />
              </Expandable>
            </ParamField>
          </Expandable>
        </ParamField>

        <ParamField body="Variant 3" type="object">
          <Expandable title="child attributes">
            <ParamField body="MinLedgerTimeRel" type="object" required>
              OpenAPI type: <code>MinLedgerTimeRel</code>.

              <Expandable title="child attributes">
                <ParamField body="value" type="object" required>
                  OpenAPI type: <code>Duration</code>.

                  <Expandable title="child attributes">
                    <ParamField body="seconds" type="number" required>
                      OpenAPI type: <code>integer (int64)</code>.
                    </ParamField>

                    <ParamField body="nanos" type="number" required>
                      OpenAPI type: <code>integer (int32)</code>.
                    </ParamField>

                    <ParamField body="unknownFields" type="object">
                      OpenAPI type: <code>UnknownFieldSet</code>.

                      This field is automatically added as part of protobuf to json mapping

                      <Expandable title="child attributes">
                        <ParamField body="fields" type="object" required>
                          OpenAPI type: <code>Map\_Int\_Field</code>.
                        </ParamField>
                      </Expandable>
                    </ParamField>
                  </Expandable>
                </ParamField>
              </Expandable>
            </ParamField>
          </Expandable>
        </ParamField>
      </Expandable>
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="actAs" type="string[]" required>
  Set of parties on whose behalf the command should be executed, if submitted. If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request to **read** (not act) on behalf of each of the given parties. This is because this RPC merely prepares a transaction and does not execute it. Therefore read authorization is sufficient even for actAs parties. Note: This may change, and more specific authorization scope may be introduced in the future. Each element must be a valid PartyIdString (as described in `value.proto`). Required: must be non-empty
</ParamField>

<ParamField body="readAs" type="string[]">
  Set of parties on whose behalf (in addition to all parties listed in `act_as`) contracts can be retrieved. This affects Daml operations such as `fetch`, `fetchByKey`, `lookupByKey`, `exercise`, and `exerciseByKey`. Note: A command can only use contracts that are visible to at least one of the parties in `act_as` or `read_as`. This visibility check is independent from the Daml authorization rules for fetch operations. If ledger API authorization is enabled, then the authorization metadata must authorize the sender of the request to read contract data on behalf of each of the given parties. Optional: can be empty
</ParamField>

<ParamField body="disclosedContracts" type="object[]">
  OpenAPI type: <code>DisclosedContract\[]</code>.

  Additional contracts used to resolve contract & contract key lookups. Optional: can be empty

  <Expandable title="child attributes">
    <ParamField body="templateId" type="string">
      The template id of the contract. The identifier uses the package-id reference format. If provided, used to validate the template id of the contract serialized in the created\_event\_blob. Optional
    </ParamField>

    <ParamField body="contractId" type="string">
      The contract id If provided, used to validate the contract id of the contract serialized in the created\_event\_blob. Optional
    </ParamField>

    <ParamField body="createdEventBlob" type="string" required>
      Opaque byte string containing the complete payload required by the Daml engine to reconstruct a contract not known to the receiving participant. Required: must be non-empty
    </ParamField>

    <ParamField body="synchronizerId" type="string">
      The ID of the synchronizer where the contract is currently assigned Optional
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="synchronizerId" type="string">
  Must be a valid synchronizer id If not set, a suitable synchronizer that this node is connected to will be chosen Optional
</ParamField>

<ParamField body="packageIdSelectionPreference" type="string[]">
  The package-id selection preference of the client for resolving package names and interface instances in command submission and interpretation Optional: can be empty
</ParamField>

<ParamField body="verboseHashing" type="boolean">
  When true, the response will contain additional details on how the transaction was encoded and hashed This can be useful for troubleshooting of hash mismatches. Should only be used for debugging. Defaults to false Optional
</ParamField>

<ParamField body="prefetchContractKeys" type="object[]">
  OpenAPI type: <code>PrefetchContractKey\[]</code>.

  Fetches the contract keys into the caches to speed up the command processing. Should only contain contract keys that are expected to be resolved during interpretation of the commands. Keys of disclosed contracts do not need prefetching. Optional: can be empty

  <Expandable title="child attributes">
    <ParamField body="templateId" type="string" required>
      The template of contract the client wants to prefetch. Both package-name and package-id reference identifier formats for the template-id are supported. Note: The package-id reference identifier format is deprecated. We plan to end support for this format in version 3.4. Required
    </ParamField>

    <ParamField body="contractKey" type="object" required>
      The key of the contract the client wants to prefetch. Required
    </ParamField>

    <ParamField body="limit" type="number">
      OpenAPI type: <code>integer (int32)</code>.

      The number of contracts to prefetch for this key, if available. This is in addition to disclosed contracts. - for backward compatibility reason, absence is interpreted as 1 - 0 is forbidden - capped at 2^31 - 1. The system may impose further limits. Optional
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="maxRecordTime" type="string">
  Maximum timestamp at which the transaction can be recorded onto the ledger via the synchronizer specified in the `PrepareSubmissionResponse`. If submitted after it will be rejected even if otherwise valid, in which case it needs to be prepared and signed again with a new valid max\_record\_time. Use this to limit the time-to-life of a prepared transaction, which is useful to know when it can definitely not be accepted anymore and resorting to preparing another transaction for the same intent is safe again. Optional
</ParamField>

<ParamField body="estimateTrafficCost" type="object">
  OpenAPI type: <code>CostEstimationHints</code>.

  Hints to improve cost estimation precision of a prepared transaction

  <Expandable title="child attributes">
    <ParamField body="disabled" type="boolean">
      Disable cost estimation Default (not set) is false Optional
    </ParamField>

    <ParamField body="expectedSignatures" type="string[]">
      Details on the keys that will be used to sign the transaction (how many and of which type). Signature size impacts the cost of the transaction. If empty, the signature sizes will be approximated with threshold-many signatures (where threshold is defined in the PartyToParticipant of the external party), using keys in the order they are registered. Empty list is equivalent to not providing this field Optional: can be empty
    </ParamField>
  </Expandable>
</ParamField>

<ParamField body="tapsMaxPasses" type="number">
  OpenAPI type: <code>integer (int32)</code>.

  The maximum number of passes for the Topology-Aware Package Selection (TAPS). Higher values can increase the chance of successful package selection for routing of interpreted transactions. If unset, this defaults to the value defined in the participant configuration. The provided value must not exceed the limit specified in the participant configuration. Optional
</ParamField>

<ParamField body="hashingSchemeVersion" type="string">
  The hashing scheme version to be used when building the hash. Defaults to HASHING\_SCHEME\_VERSION\_V2. Optional

  Allowed values: <code>HASHING\_SCHEME\_VERSION\_UNSPECIFIED</code>, <code>HASHING\_SCHEME\_VERSION\_V2</code>, <code>HASHING\_SCHEME\_VERSION\_V3</code>.
</ParamField>

## Responses

### 200

<div class="x2mdx-ref-badges">
  <span class="x2mdx-ref-badge x2mdx-ref-badge--neutral">application/json</span>
</div>

<ResponseField name="preparedTransaction" type="string" required>
  The interpreted transaction, it represents the ledger changes necessary to execute the commands specified in the request. Clients MUST display the content of the transaction to the user for them to validate before signing the hash if the preparing participant is not trusted. Required
</ResponseField>

<ResponseField name="preparedTransactionHash" type="string" required>
  Hash of the transaction, this is what needs to be signed by the party to authorize the transaction. Only provided for convenience, clients MUST recompute the hash from the raw transaction if the preparing participant is not trusted. May be removed in future versions Required: must be non-empty
</ResponseField>

<ResponseField name="hashingSchemeVersion" type="string" required>
  The hashing scheme version used when building the hash Required

  Allowed values: <code>HASHING\_SCHEME\_VERSION\_UNSPECIFIED</code>, <code>HASHING\_SCHEME\_VERSION\_V2</code>, <code>HASHING\_SCHEME\_VERSION\_V3</code>.
</ResponseField>

<ResponseField name="hashingDetails" type="string">
  Optional additional details on how the transaction was encoded and hashed. Only set if verbose\_hashing = true in the request Note that there are no guarantees on the stability of the format or content of this field. Its content should NOT be parsed and should only be used for troubleshooting purposes. Optional
</ResponseField>

<ResponseField name="costEstimation" type="CostEstimation">
  Estimation of the cost of submitting the prepared transaction The estimation is done against the synchronizer chosen during preparation of the transaction (or the one explicitly requested). The cost of re-assigning contracts to another synchronizer when necessary is not included in the estimation.

  <Expandable title="child attributes">
    <ResponseField name="estimationTimestamp" type="string" required>
      Timestamp at which the estimation was made Required
    </ResponseField>

    <ResponseField name="confirmationRequestTrafficCostEstimation" type="integer (int64)" required>
      Estimated traffic cost of the confirmation request associated with the transaction Required
    </ResponseField>

    <ResponseField name="confirmationResponseTrafficCostEstimation" type="integer (int64)" required>
      Estimated traffic cost of the confirmation response associated with the transaction This field can also be used as an indication of the cost that other potential confirming nodes of the party will incur to approve or reject the transaction Required
    </ResponseField>

    <ResponseField name="totalTrafficCostEstimation" type="integer (int64)" required>
      Sum of the fields above Required
    </ResponseField>
  </Expandable>
</ResponseField>

### 400

Invalid value, Invalid value for: body

<div class="x2mdx-ref-badges">
  <span class="x2mdx-ref-badge x2mdx-ref-badge--neutral">text/plain</span>
</div>

<ResponseField name="value" type="string" required />

### default

<div class="x2mdx-ref-badges">
  <span class="x2mdx-ref-badge x2mdx-ref-badge--neutral">application/json</span>
</div>

<ResponseField name="code" type="string" required />

<ResponseField name="cause" type="string" required />

<ResponseField name="correlationId" type="string" />

<ResponseField name="traceId" type="string" />

<ResponseField name="context" type="Map_String" required />

<ResponseField name="resources" type="Tuple2_String_String[]" />

<ResponseField name="errorCategory" type="integer (int32)" required />

<ResponseField name="grpcCodeValue" type="integer (int32)" />

<ResponseField name="retryInfo" type="string" />

<ResponseField name="definiteAnswer" type="boolean" />

## History

<div class="x2mdx-ref-history" aria-label="Reference history">
  <div class="x2mdx-ref-history-event x2mdx-ref-history-event--changed" id="history-updated-3-5">
    <div class="x2mdx-ref-history-event-head">
      <span class="x2mdx-ref-history-event-label">Updated</span>
      <code class="x2mdx-ref-history-event-version">3.5</code>
    </div>

    <p class="x2mdx-ref-history-event-detail">The POST /v2/interactive-submission/prepare operation changed in this snapshot.</p>
  </div>
</div>