POST /v2/parties/external/generate-topology

cURL
Python
JavaScript
PHP
Go
Java
Ruby
curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/generate-topology' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}'
import json
import requests

url = "http://localhost:7575/v2/parties/external/generate-topology"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)
const response = await fetch('http://localhost:7575/v2/parties/external/generate-topology', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}),
});

console.log(await response.text());
<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/generate-topology',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;
package main

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

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/generate-topology", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}`))
  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))
}
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/parties/external/generate-topology"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/generate-topology')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

200
400
default
{
  "partyId": "<string>",
  "publicKeyFingerprint": "<string>",
  "topologyTransactions": [
    "<string>"
  ],
  "multiHash": "<string>"
}
<string>
{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

POST

parties

external

generate-topology

Try it

cURL
Python
JavaScript
PHP
Go
Java
Ruby
curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/generate-topology' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}'
import json
import requests

url = "http://localhost:7575/v2/parties/external/generate-topology"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)
const response = await fetch('http://localhost:7575/v2/parties/external/generate-topology', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}),
});

console.log(await response.text());
<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/generate-topology',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;
package main

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

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/generate-topology", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}`))
  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))
}
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/parties/external/generate-topology"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/generate-topology')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

200
400
default
{
  "partyId": "<string>",
  "publicKeyFingerprint": "<string>",
  "topologyTransactions": [
    "<string>"
  ],
  "multiHash": "<string>"
}
<string>
{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

You may use this endpoint to generate the common external topology transactions which can be signed externally and uploaded as part of the allocate party process Note that this request will create a normal namespace using the same key for the identity as for signing. More elaborate schemes such as multi-signature or decentralized parties require you to construct the topology transactions yourself.

OpenAPIUpdated 3.5

cURL
Python
JavaScript
PHP
Go
Java
Ruby
curl --request POST \
  --url 'http://localhost:7575/v2/parties/external/generate-topology' \
  --header 'Authorization: Bearer $TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}'
import json
import requests

url = "http://localhost:7575/v2/parties/external/generate-topology"
headers = {'Authorization': 'Bearer <token>', 'Content-Type': 'application/json'}
payload = json.loads(r'''{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}''')
response = requests.request(
    "POST", url, headers=headers, json=payload
)

print(response.text)
const response = await fetch('http://localhost:7575/v2/parties/external/generate-topology', {
  method: 'POST',
  headers: {
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
},
  body: JSON.stringify({
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}),
});

console.log(await response.text());
<?php
$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => 'http://localhost:7575/v2/parties/external/generate-topology',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_POSTFIELDS => <<<'JSON'
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer <token>",
        "Content-Type: application/json"
    ],
]);

$response = curl_exec($curl);
echo $response;
package main

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

func main() {
  req, _ := http.NewRequest("POST", "http://localhost:7575/v2/parties/external/generate-topology", bytes.NewBufferString(`{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}`))
  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))
}
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/parties/external/generate-topology"))
    .header("Authorization", "Bearer <token>")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("""
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
"""))
    .build();
var response = HttpClient.newHttpClient().send(
    request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
require 'net/http'
require 'uri'

uri = URI('http://localhost:7575/v2/parties/external/generate-topology')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer <token>'
request['Content-Type'] = 'application/json'
request.body = <<~JSON
{
  "synchronizer": "<string>",
  "partyHint": "<string>",
  "publicKey": {
    "format": "CRYPTO_KEY_FORMAT_DER_X509_SUBJECT_PUBLIC_KEY_INFO",
    "keyData": "<string>",
    "keySpec": "SIGNING_KEY_SPEC_EC_CURVE25519"
  },
  "localParticipantObservationOnly": false,
  "otherConfirmingParticipantUids": [
    "<string>"
  ],
  "confirmationThreshold": 123,
  "observingParticipantUids": [
    "<string>"
  ]
}
JSON
response = Net::HTTP.start(uri.hostname, uri.port) do |http|
  http.request(request)
end
puts response.body

200
400
default
{
  "partyId": "<string>",
  "publicKeyFingerprint": "<string>",
  "topologyTransactions": [
    "<string>"
  ],
  "multiHash": "<string>"
}
<string>
{
  "code": "<string>",
  "cause": "<string>",
  "correlationId": "<string>",
  "traceId": "<string>",
  "context": {},
  "resources": [
    [
      "<string>"
    ]
  ],
  "errorCategory": 123,
  "grpcCodeValue": 123,
  "retryInfo": "<string>",
  "definiteAnswer": false
}

Authorizations

httpAuth

Authorization

string

required

HTTP bearer authentication. Send the token as Authorization: Bearer <token>. Ledger API standard JWT token

apiKeyAuth

Sec-WebSocket-Protocol

string

required

API key authentication in the header. Ledger API standard JWT token (websocket)

Body

application/json

synchronizer

string

required

Synchronizer-id for which we are building this request. Required

partyHint

string

required

The actual party id will be constructed from this hint and a fingerprint of the public key Required

publicKey

object

required

OpenAPI type: SigningPublicKey.Public key Required

Show child attributes

format

string

required

The serialization format of the public key Required

keyData

string

required

Serialized public key in the format specified above Required: must be non-empty

keySpec

string

required

The key specification Required

localParticipantObservationOnly

boolean

If true, then the local participant will only be observing, not confirming. Default false. Optional

otherConfirmingParticipantUids

string[]

Other participant ids which should be confirming for this party Optional: can be empty

confirmationThreshold

number

OpenAPI type: integer (int32).Confirmation threshold >= 1 for the party. Defaults to all available confirmers (or if set to 0). Optional

observingParticipantUids

string[]

Other observing participant ids for this party Optional: can be empty

Responses

200

application/json

partyId

string

required

The generated party id Required

publicKeyFingerprint

string

required

The fingerprint of the supplied public key Required

topologyTransactions

string[]

required

The serialized topology transactions which need to be signed and submitted as part of the allocate party process Note that the serialization includes the versioning information. Therefore, the transaction here is serialized as an UntypedVersionedMessage which in turn contains the serialized TopologyTransaction in the version supported by the synchronizer. Required: must be non-empty

multiHash

string

required

the multi-hash which may be signed instead of each individual transaction Required: must be non-empty

400

Invalid value, Invalid value for: body

text/plain

value

string

required

default

application/json

code

string

required

cause

string

required

correlationId

string

traceId

string

context

Map_String

required

resources

Tuple2_String_String[]

errorCategory

integer (int32)

required

grpcCodeValue

integer (int32)

retryInfo

string

definiteAnswer

boolean

History

Updated3.5

The POST /v2/parties/external/generate-topology operation changed in this snapshot.

← Back to Documentation

POST /v2/parties/external/generate-topology

​Authorizations

​httpAuth

​apiKeyAuth

​Body

​Responses

​200

​400

​default

​History

Authorizations

httpAuth

apiKeyAuth

Body

Responses

200

400

default

History