Corda Network Map

CordaNetworkMapAPI

acknowledgeUsingPOST

Accept new network parameters

NOTIMPLEMENTED For the node operator to acknowledge network map that new parameters were accepted for future update.

/ack-parameters

Usage and SDK Samples

curl -X POST "http://localhost:8080/network-map/ack-parameters"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CordaNetworkMapAPIApi;

import java.io.File;
import java.util.*;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        try {
            apiInstance.acknowledgeUsingPOST();
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#acknowledgeUsingPOST");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CordaNetworkMapAPIApi;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        try {
            apiInstance.acknowledgeUsingPOST();
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#acknowledgeUsingPOST");
            e.printStackTrace();
        }
    }
}


CordaNetworkMapAPIApi *apiInstance = [[CordaNetworkMapAPIApi alloc] init];

// Accept new network parameters
[apiInstance acknowledgeUsingPOSTWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CordaNetworkMap = require('corda_network_map');

var api = new CordaNetworkMap.CordaNetworkMapAPIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.acknowledgeUsingPOST(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class acknowledgeUsingPOSTExample
    {
        public void main()
        {
            
            var apiInstance = new CordaNetworkMapAPIApi();

            try
            {
                // Accept new network parameters
                apiInstance.acknowledgeUsingPOST();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CordaNetworkMapAPIApi.acknowledgeUsingPOST: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new OpenAPITools\Client\Api\CordaNetworkMapAPIApi();

try {
    $api_instance->acknowledgeUsingPOST();
} catch (Exception $e) {
    echo 'Exception when calling CordaNetworkMapAPIApi->acknowledgeUsingPOST: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CordaNetworkMapAPIApi;

my $api_instance = WWW::OPenAPIClient::CordaNetworkMapAPIApi->new();

eval { 
    $api_instance->acknowledgeUsingPOST();
};
if ($@) {
    warn "Exception when calling CordaNetworkMapAPIApi->acknowledgeUsingPOST: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = openapi_client.CordaNetworkMapAPIApi()

try: 
    # Accept new network parameters
    api_instance.acknowledge_using_post()
except ApiException as e:
    print("Exception when calling CordaNetworkMapAPIApi->acknowledgeUsingPOST: %s\n" % e)

extern crate CordaNetworkMapAPIApi;

pub fn main() {

    let mut context = CordaNetworkMapAPIApi::Context::default();
    let result = client.acknowledgeUsingPOST(&context).wait();
    println!("{:?}", result);

}

Scopes

Parameters

Responses

getUsingGET

Get the network map

Retrieve the current signed network map object. The entire object is signed with the network map certificate which is also attached.

Usage and SDK Samples

curl -X GET "http://localhost:8080/network-map/"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CordaNetworkMapAPIApi;

import java.io.File;
import java.util.*;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        try {
            File result = apiInstance.getUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#getUsingGET");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CordaNetworkMapAPIApi;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        try {
            File result = apiInstance.getUsingGET();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#getUsingGET");
            e.printStackTrace();
        }
    }
}


CordaNetworkMapAPIApi *apiInstance = [[CordaNetworkMapAPIApi alloc] init];

// Get the network map
[apiInstance getUsingGETWithCompletionHandler: 
              ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CordaNetworkMap = require('corda_network_map');

var api = new CordaNetworkMap.CordaNetworkMapAPIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsingGET(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUsingGETExample
    {
        public void main()
        {
            
            var apiInstance = new CordaNetworkMapAPIApi();

            try
            {
                // Get the network map
                File result = apiInstance.getUsingGET();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CordaNetworkMapAPIApi.getUsingGET: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new OpenAPITools\Client\Api\CordaNetworkMapAPIApi();

try {
    $result = $api_instance->getUsingGET();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CordaNetworkMapAPIApi->getUsingGET: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CordaNetworkMapAPIApi;

my $api_instance = WWW::OPenAPIClient::CordaNetworkMapAPIApi->new();

eval { 
    my $result = $api_instance->getUsingGET();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CordaNetworkMapAPIApi->getUsingGET: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = openapi_client.CordaNetworkMapAPIApi()

try: 
    # Get the network map
    api_response = api_instance.get_using_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CordaNetworkMapAPIApi->getUsingGET: %s\n" % e)

extern crate CordaNetworkMapAPIApi;

pub fn main() {

    let mut context = CordaNetworkMapAPIApi::Context::default();
    let result = client.getUsingGET(&context).wait();
    println!("{:?}", result);

}

Scopes

Parameters

Responses

Schema

networkParametersUsingGET

Get a network parameters file

Retrieve the signed network parameters (see below). The entire object is signed with the network map certificate which is also attached.

/network-parameters/{hash}

Usage and SDK Samples

curl -X GET "http://localhost:8080/network-map/network-parameters/{hash}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CordaNetworkMapAPIApi;

import java.io.File;
import java.util.*;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        String hash = hash_example; // String | The hash of the network parameters to get.
        try {
            File result = apiInstance.networkParametersUsingGET(hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#networkParametersUsingGET");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CordaNetworkMapAPIApi;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        String hash = hash_example; // String | The hash of the network parameters to get.
        try {
            File result = apiInstance.networkParametersUsingGET(hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#networkParametersUsingGET");
            e.printStackTrace();
        }
    }
}

String *hash = hash_example; // The hash of the network parameters to get.

CordaNetworkMapAPIApi *apiInstance = [[CordaNetworkMapAPIApi alloc] init];

// Get a network parameters file
[apiInstance networkParametersUsingGETWith:hash
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CordaNetworkMap = require('corda_network_map');

var api = new CordaNetworkMap.CordaNetworkMapAPIApi()
var hash = hash_example; // {String} The hash of the network parameters to get.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.networkParametersUsingGET(hash, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class networkParametersUsingGETExample
    {
        public void main()
        {
            
            var apiInstance = new CordaNetworkMapAPIApi();
            var hash = hash_example;  // String | The hash of the network parameters to get.

            try
            {
                // Get a network parameters file
                File result = apiInstance.networkParametersUsingGET(hash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CordaNetworkMapAPIApi.networkParametersUsingGET: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new OpenAPITools\Client\Api\CordaNetworkMapAPIApi();
$hash = hash_example; // String | The hash of the network parameters to get.

try {
    $result = $api_instance->networkParametersUsingGET($hash);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CordaNetworkMapAPIApi->networkParametersUsingGET: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CordaNetworkMapAPIApi;

my $api_instance = WWW::OPenAPIClient::CordaNetworkMapAPIApi->new();
my $hash = hash_example; # String | The hash of the network parameters to get.

eval { 
    my $result = $api_instance->networkParametersUsingGET(hash => $hash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CordaNetworkMapAPIApi->networkParametersUsingGET: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = openapi_client.CordaNetworkMapAPIApi()
hash = hash_example # String | The hash of the network parameters to get.

try: 
    # Get a network parameters file
    api_response = api_instance.network_parameters_using_get(hash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CordaNetworkMapAPIApi->networkParametersUsingGET: %s\n" % e)

extern crate CordaNetworkMapAPIApi;

pub fn main() {
    let hash = hash_example; // String

    let mut context = CordaNetworkMapAPIApi::Context::default();
    let result = client.networkParametersUsingGET(hash, &context).wait();
    println!("{:?}", result);

}

Scopes

Parameters

Path parameters

Name	Description
hash*	String The hash of the network parameters to get. Required

Responses

Schema

nodeInfoUsingGET

Get a NodeInfo

Retrieve a signed NodeInfo as specified in the network map object.

/node-info/{hash}

Usage and SDK Samples

curl -X GET "http://localhost:8080/network-map/node-info/{hash}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CordaNetworkMapAPIApi;

import java.io.File;
import java.util.*;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        String hash = hash_example; // String | The hash of the legal name of the node to get the nodeInfo for.
        try {
            File result = apiInstance.nodeInfoUsingGET(hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#nodeInfoUsingGET");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CordaNetworkMapAPIApi;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        String hash = hash_example; // String | The hash of the legal name of the node to get the nodeInfo for.
        try {
            File result = apiInstance.nodeInfoUsingGET(hash);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#nodeInfoUsingGET");
            e.printStackTrace();
        }
    }
}

String *hash = hash_example; // The hash of the legal name of the node to get the nodeInfo for.

CordaNetworkMapAPIApi *apiInstance = [[CordaNetworkMapAPIApi alloc] init];

// Get a NodeInfo
[apiInstance nodeInfoUsingGETWith:hash
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CordaNetworkMap = require('corda_network_map');

var api = new CordaNetworkMap.CordaNetworkMapAPIApi()
var hash = hash_example; // {String} The hash of the legal name of the node to get the nodeInfo for.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.nodeInfoUsingGET(hash, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class nodeInfoUsingGETExample
    {
        public void main()
        {
            
            var apiInstance = new CordaNetworkMapAPIApi();
            var hash = hash_example;  // String | The hash of the legal name of the node to get the nodeInfo for.

            try
            {
                // Get a NodeInfo
                File result = apiInstance.nodeInfoUsingGET(hash);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CordaNetworkMapAPIApi.nodeInfoUsingGET: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new OpenAPITools\Client\Api\CordaNetworkMapAPIApi();
$hash = hash_example; // String | The hash of the legal name of the node to get the nodeInfo for.

try {
    $result = $api_instance->nodeInfoUsingGET($hash);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CordaNetworkMapAPIApi->nodeInfoUsingGET: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CordaNetworkMapAPIApi;

my $api_instance = WWW::OPenAPIClient::CordaNetworkMapAPIApi->new();
my $hash = hash_example; # String | The hash of the legal name of the node to get the nodeInfo for.

eval { 
    my $result = $api_instance->nodeInfoUsingGET(hash => $hash);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CordaNetworkMapAPIApi->nodeInfoUsingGET: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = openapi_client.CordaNetworkMapAPIApi()
hash = hash_example # String | The hash of the legal name of the node to get the nodeInfo for.

try: 
    # Get a NodeInfo
    api_response = api_instance.node_info_using_get(hash)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CordaNetworkMapAPIApi->nodeInfoUsingGET: %s\n" % e)

extern crate CordaNetworkMapAPIApi;

pub fn main() {
    let hash = hash_example; // String

    let mut context = CordaNetworkMapAPIApi::Context::default();
    let result = client.nodeInfoUsingGET(hash, &context).wait();
    println!("{:?}", result);

}

Scopes

Parameters

Path parameters

Name	Description
hash*	String The hash of the legal name of the node to get the nodeInfo for. Required

Responses

Schema

publishUsingPOST

Publish a node

For the node to upload its signed NodeInfo object to the network map.

/publish

Usage and SDK Samples

curl -X POST "http://localhost:8080/network-map/publish"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CordaNetworkMapAPIApi;

import java.io.File;
import java.util.*;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        File body = BINARY_DATA_HERE; // File | 
        try {
            apiInstance.publishUsingPOST(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#publishUsingPOST");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.CordaNetworkMapAPIApi;

public class CordaNetworkMapAPIApiExample {

    public static void main(String[] args) {
        CordaNetworkMapAPIApi apiInstance = new CordaNetworkMapAPIApi();
        File body = BINARY_DATA_HERE; // File | 
        try {
            apiInstance.publishUsingPOST(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling CordaNetworkMapAPIApi#publishUsingPOST");
            e.printStackTrace();
        }
    }
}

File *body = BINARY_DATA_HERE; // 

CordaNetworkMapAPIApi *apiInstance = [[CordaNetworkMapAPIApi alloc] init];

// Publish a node
[apiInstance publishUsingPOSTWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var CordaNetworkMap = require('corda_network_map');

var api = new CordaNetworkMap.CordaNetworkMapAPIApi()
var body = BINARY_DATA_HERE; // {File} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.publishUsingPOST(body, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class publishUsingPOSTExample
    {
        public void main()
        {
            
            var apiInstance = new CordaNetworkMapAPIApi();
            var body = BINARY_DATA_HERE;  // File | 

            try
            {
                // Publish a node
                apiInstance.publishUsingPOST(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CordaNetworkMapAPIApi.publishUsingPOST: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new OpenAPITools\Client\Api\CordaNetworkMapAPIApi();
$body = BINARY_DATA_HERE; // File | 

try {
    $api_instance->publishUsingPOST($body);
} catch (Exception $e) {
    echo 'Exception when calling CordaNetworkMapAPIApi->publishUsingPOST: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CordaNetworkMapAPIApi;

my $api_instance = WWW::OPenAPIClient::CordaNetworkMapAPIApi->new();
my $body = WWW::OPenAPIClient::Object::File->new(); # File | 

eval { 
    $api_instance->publishUsingPOST(body => $body);
};
if ($@) {
    warn "Exception when calling CordaNetworkMapAPIApi->publishUsingPOST: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = openapi_client.CordaNetworkMapAPIApi()
body = BINARY_DATA_HERE # File | 

try: 
    # Publish a node
    api_instance.publish_using_post(body)
except ApiException as e:
    print("Exception when calling CordaNetworkMapAPIApi->publishUsingPOST: %s\n" % e)

extern crate CordaNetworkMapAPIApi;

pub fn main() {
    let body = BINARY_DATA_HERE; // File

    let mut context = CordaNetworkMapAPIApi::Context::default();
    let result = client.publishUsingPOST(body, &context).wait();
    println!("{:?}", result);

}

Scopes

Parameters

Body parameters

Name	Description
body *	The Signed NodeInfo from the node

Corda Network Map

API and SDK Documentation

CordaNetworkMapAPI

acknowledgeUsingPOST

Usage and SDK Samples

Scopes

Parameters

Responses

getUsingGET

Usage and SDK Samples

Scopes

Parameters

Responses

networkParametersUsingGET

Usage and SDK Samples

Scopes

Parameters

Responses

nodeInfoUsingGET

Usage and SDK Samples

Scopes

Parameters

Responses

publishUsingPOST

Usage and SDK Samples

Scopes

Parameters

Responses